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
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct