package containers

  1. Overview
  2. Docs
package containers
Legend:
Library
Module
Module type
Parameter
Class
Class type

Bigarrays of dimension 1

  • deprecated

    do not use, this was always experimental NOTE this module will be removed soon and should not be depended upon

    status: deprecated

  • since 0.12

used types

type 'a printer = Format.formatter -> 'a -> unit
type 'a sequence = ('a -> unit) -> unit
type 'a or_error = [
  1. | `Ok of 'a
  2. | `Error of string
]
type random = Random.State.t
type json = [
  1. | `Assoc of (string * json) list
  2. | `Bool of bool
  3. | `Float of float
  4. | `Int of int
  5. | `List of json list
  6. | `Null
  7. | `String of string
]
type 'a to_json = 'a -> json
type 'a of_json = json -> 'a or_error

Type Declarations

type ('a, 'b, 'perm) t constraint 'perm = [< `R | `W ]

Array of OCaml values of type 'a with C representation of type b' with permissions 'perm

type ('a, 'b, 'perm) array_ = ('a, 'b, 'perm) t
exception WrongDimension

Raised when arrays do not have expected length

Basic Operations

val make : ?x:'a -> kind:('a, 'b) Bigarray.kind -> int -> ('a, 'b, 'perm) t

New array with undefined elements

  • parameter kind

    the kind of bigarray

  • parameter x

    optional element to fill every slot

  • parameter n

    the number of elements

val make_int : int -> (int, Bigarray.int_elt, 'perm) t
val make_char : int -> (char, Bigarray.int8_unsigned_elt, 'perm) t
val make_int8s : int -> (int, Bigarray.int8_signed_elt, 'perm) t
val make_int8u : int -> (int, Bigarray.int8_unsigned_elt, 'perm) t
val make_int16s : int -> (int, Bigarray.int16_signed_elt, 'perm) t
val make_int16u : int -> (int, Bigarray.int16_unsigned_elt, 'perm) t
val make_int32 : int -> (int32, Bigarray.int32_elt, 'perm) t
val make_int64 : int -> (int64, Bigarray.int64_elt, 'perm) t
val make_native : int -> (nativeint, Bigarray.nativeint_elt, 'perm) t
val make_float32 : int -> (float, Bigarray.float32_elt, 'perm) t
val make_float64 : int -> (float, Bigarray.float64_elt, 'perm) t
val make_complex32 : int -> (Complex.t, Bigarray.complex32_elt, 'perm) t
val make_complex64 : int -> (Complex.t, Bigarray.complex64_elt, 'perm) t
val init : kind:('a, 'b) Bigarray.kind -> f:(int -> 'a) -> int -> ('a, 'b, 'perm) t

Initialize with given size and initialization function

val of_bigarray : ('a, 'b, Bigarray.c_layout) Bigarray.Array1.t -> ('a, 'b, 'perm) t

Convert from a big array

val to_bigarray : ('a, 'b, [ `R | `W ]) t -> ('a, 'b, Bigarray.c_layout) Bigarray.Array1.t

Obtain the underlying array

val ro : ('a, 'b, [> `R ]) t -> ('a, 'b, [ `R ]) t

Change permission (old reference to array might still be mutable!)

val wo : ('a, 'b, [> `W ]) t -> ('a, 'b, [ `W ]) t

Change permission

val length : (_, _, [> `R ]) t -> int

Number of elements

val set : ('a, _, [> `W ]) t -> int -> 'a -> unit

set n-th element

val get : ('a, _, [> `R ]) t -> int -> 'a

Get n-th element

val fill : ('a, _, [> `W ]) t -> 'a -> unit

fill a x fills a with x

val sub : ('a, 'b, 'perm) t -> int -> int -> ('a, 'b, 'perm) t

sub a i len takes the slice of length len starting at offset i

val blit : ('a, 'b, [> `R ]) t -> ('a, 'b, [> `W ]) t -> unit

blit the first array to the second

val copy : ('a, 'b, [> `R ]) t -> ('a, 'b, 'perm) t

Fresh copy

val iter : f:('a -> unit) -> ('a, _, [> `R ]) t -> unit

iter a ~f calls f v where get a i = v for each i < length a. It iterates on all bits in increasing order

val iteri : f:(int -> 'a -> unit) -> ('a, _, [> `R ]) t -> unit

iteri a ~f calls f i v where get a i = v for each i < length a. It iterates on all elements in increasing order

val foldi : ('b -> int -> 'a -> 'b) -> 'b -> ('a, _, [> `R ]) t -> 'b
val for_all : f:('a -> bool) -> ('a, _, [> `R ]) t -> bool
val exists : f:('a -> bool) -> ('a, _, [> `R ]) t -> bool
val pp : 'a printer -> ('a, _, [> `R ]) t printer

Print the SDR nicely

Boolean Vectors

module Bool : sig ... end

Operations

val map : ?res:('a, 'b, [> `W ] as 'perm) t -> f:('a -> 'a) -> ('a, 'b, [> `R ]) t -> ('a, 'b, 'perm) t
val map2 : ?res:('a, 'b, [> `W ] as 'perm) t -> f:('a -> 'a2 -> 'a) -> ('a, 'b, [> `R ]) t -> ('a2, _, [> `R ]) t -> ('a, 'b, 'perm) t
val append : ?res:('a, 'b, [> `W ] as 'perm) t -> ('a, 'b, [> `R ]) t -> ('a, 'b, [> `R ]) t -> ('a, 'b, 'perm) t

append a b ~into assumes length a + length b = length into and copies a and b side by side in into

val filter : ?res:(Bigarray.int8_unsigned_elt, [> `W ] as 'perm) Bool.t -> f:('a -> bool) -> ('a, 'b, [> `R ]) t -> (Bigarray.int8_unsigned_elt, 'perm) Bool.t
module type S = sig ... end
module Int : S with type elt = int
module Float : S with type elt = float

Conversions

val to_list : ('a, _, [> `R ]) t -> 'a list
val to_array : ('a, _, [> `R ]) t -> 'a array
val to_seq : ('a, _, [> `R ]) t -> 'a sequence
val of_array : kind:('a, 'b) Bigarray.kind -> 'a array -> ('a, 'b, 'perm) t

Serialization

val to_yojson : 'a to_json -> ('a, _, [> `R ]) t to_json
val of_yojson : kind:('a, 'b) Bigarray.kind -> 'a of_json -> ('a, 'b, 'perm) t of_json
val int_to_yojson : int to_json
val int_of_yojson : int of_json
val float_to_yojson : float to_json
val float_of_yojson : float of_json

Views

module View : sig ... end