Previous  Up  Next

Module CCArray1

module CCArray1: sig .. end
Deprecated.do not use, this was always experimental NOTE this module will be removed soon and should not be depended upon

status: deprecated

Bigarrays of dimension 1


Since 0.12

used types


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

Type Declarations


type ('a, 'b, [< `R | `W ]) t
Array of OCaml values of type 'a with C representation of type b' with permissions 'perm
type ('a, 'b, [< `R | `W ]) array_ = ('a, 'b, [< `R | `W ] as 'c) 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, [< `R | `W ]) t
New array with undefined elements
x : optional element to fill every slot
kind : the kind of bigarray
val make_int : int -> (int, Bigarray.int_elt, [< `R | `W ]) t
val make_char : int -> (char, Bigarray.int8_unsigned_elt, [< `R | `W ]) t
val make_int8s : int -> (int, Bigarray.int8_signed_elt, [< `R | `W ]) t
val make_int8u : int -> (int, Bigarray.int8_unsigned_elt, [< `R | `W ]) t
val make_int16s : int -> (int, Bigarray.int16_signed_elt, [< `R | `W ]) t
val make_int16u : int -> (int, Bigarray.int16_unsigned_elt, [< `R | `W ]) t
val make_int32 : int -> (int32, Bigarray.int32_elt, [< `R | `W ]) t
val make_int64 : int -> (int64, Bigarray.int64_elt, [< `R | `W ]) t
val make_native : int -> (nativeint, Bigarray.nativeint_elt, [< `R | `W ]) t
val make_float32 : int -> (float, Bigarray.float32_elt, [< `R | `W ]) t
val make_float64 : int -> (float, Bigarray.float64_elt, [< `R | `W ]) t
val make_complex32 : int -> (Complex.t, Bigarray.complex32_elt, [< `R | `W ]) t
val make_complex64 : int -> (Complex.t, Bigarray.complex64_elt, [< `R | `W ]) t
val init : kind:('a, 'b) Bigarray.kind ->
       f:(int -> 'a) -> int -> ('a, 'b, [< `R | `W ]) t
Initialize with given size and initialization function
val of_bigarray : ('a, 'b, Bigarray.c_layout) Bigarray.Array1.t ->
       ('a, 'b, [< `R | `W ]) 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 | `W > `R ]) t -> ('a, 'b, [ `R ]) t
Change permission (old reference to array might still be mutable!)
val wo : ('a, 'b, [< `R | `W > `W ]) t -> ('a, 'b, [ `W ]) t
Change permission
val length : ('a, 'b, [< `R | `W > `R ]) t -> int
Number of elements
val set : ('a, 'b, [< `R | `W > `W ]) t -> int -> 'a -> unit
set n-th element
val get : ('a, 'b, [< `R | `W > `R ]) t -> int -> 'a
Get n-th element
val fill : ('a, 'b, [< `R | `W > `W ]) t -> 'a -> unit
fill a x fills a with x
val sub : ('a, 'b, [< `R | `W ] as 'c) t ->
       int -> int -> ('a, 'b, 'c) t
sub a i len takes the slice of length len starting at offset i
val blit : ('a, 'b, [< `R | `W > `R ]) t ->
       ('a, 'b, [< `R | `W > `W ]) t -> unit
blit the first array to the second
val copy : ('a, 'b, [< `R | `W > `R ]) t -> ('a, 'b, [< `R | `W ]) t
Fresh copy
val iter : f:('a -> unit) -> ('a, 'b, [< `R | `W > `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, 'b, [< `R | `W > `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, 'c, [< `R | `W > `R ]) t -> 'b
val for_all : f:('a -> bool) -> ('a, 'b, [< `R | `W > `R ]) t -> bool
val exists : f:('a -> bool) -> ('a, 'b, [< `R | `W > `R ]) t -> bool
val pp : 'a printer ->
       ('a, 'b, [< `R | `W > `R ]) t printer
Print the SDR nicely

Boolean Vectors


module Bool: sig .. end

Operations


val map : ?res:('a, 'b, [< `R | `W > `W ] as 'c) t ->
       f:('a -> 'a) ->
       ('a, 'b, [< `R | `W > `R ]) t -> ('a, 'b, 'c) t
val map2 : ?res:('a, 'b, [< `R | `W > `W ] as 'c) t ->
       f:('a -> 'a2 -> 'a) ->
       ('a, 'b, [< `R | `W > `R ]) t ->
       ('a2, 'd, [< `R | `W > `R ]) t -> ('a, 'b, 'c) t
val append : ?res:('a, 'b, [< `R | `W > `W ] as 'c) t ->
       ('a, 'b, [< `R | `W > `R ]) t ->
       ('a, 'b, [< `R | `W > `R ]) t -> ('a, 'b, 'c) t
append a b ~into assumes length a + length b = length into and copies a and b side by side in into
Raises WrongDimension if dimensions do not match
val filter : ?res:(Bigarray.int8_unsigned_elt, [< `R | `W > `W ] as 'c) Bool.t ->
       f:('a -> bool) ->
       ('a, 'b, [< `R | `W > `R ]) t ->
       (Bigarray.int8_unsigned_elt, 'c) 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, 'b, [< `R | `W > `R ]) t -> 'a list
val to_array : ('a, 'b, [< `R | `W > `R ]) t -> 'a array
val to_seq : ('a, 'b, [< `R | `W > `R ]) t -> 'a sequence
val of_array : kind:('a, 'b) Bigarray.kind -> 'a array -> ('a, 'b, [< `R | `W ]) t

Serialization


val to_yojson : 'a to_json ->
       ('a, 'b, [< `R | `W > `R ]) t to_json
val of_yojson : kind:('a, 'b) Bigarray.kind ->
       'a of_json -> ('a, 'b, [< `R | `W ]) 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