arrayjit 0.3.3 · OCaml Package

N-dimensional arrays: a precision-handling wrapper for Bigarray.Genarray and its utilities.

module A = Bigarray.Genarray

* Handling of precisions *

type ('ocaml, 'elt_t) bigarray = ('ocaml, 'elt_t, Bigarray.c_layout) A.t

val sexp_of_bigarray : ('a, 'b) bigarray -> Base.Sexp.t

type byte_nd = (Base.char, Ops.uint8_elt) bigarray

type half_nd = (Base.float, Ops.float16_elt) bigarray

type single_nd = (Base.float, Ops.float32_elt) bigarray

type double_nd = (Base.float, Ops.float64_elt) bigarray

val sexp_of_address_of : 'a -> Base.Sexp.t

val sexp_of_byte_nd : byte_nd -> Base.Sexp.t

val sexp_of_half_nd : half_nd -> Base.Sexp.t

val sexp_of_single_nd : single_nd -> Base.Sexp.t

val sexp_of_double_nd : double_nd -> Base.Sexp.t

type t =

| Byte_nd of byte_nd
| Half_nd of half_nd
| Single_nd of single_nd
| Double_nd of double_nd

val sexp_of_t : t -> Sexplib0.Sexp.t

val as_array : ('ocaml, 'elt_t) Ops.precision -> ('ocaml, 'elt_t) bigarray -> t

val precision_to_bigarray_kind : 
  ('ocaml, 'elt_t) Ops.precision ->
  ('ocaml, 'elt_t) Bigarray.kind

val precision_string : t -> string

val default_kind : (Base.float, Ops.float32_elt) Ops.precision

val is_double_prec_t : t -> bool

val get_prec : t -> Ops.prec

type 'r map_with_prec = {

f : 'ocaml 'elt_t. ('ocaml, 'elt_t) Ops.precision -> ('ocaml, 'elt_t) bigarray -> 'r;

}

val map_with_prec : 'a map_with_prec -> t -> 'a

val create_bigarray_of_prec : 
  ('ocaml, 'elt_t) Ops.precision ->
  int array ->
  ('ocaml, 'elt_t) bigarray

val init_bigarray_of_prec : 
  ('ocaml, 'elt_t) Ops.precision ->
  int array ->
  f:(Base.int Base.array -> 'ocaml) ->
  ('ocaml, 'elt_t) bigarray

val indices_to_offset : dims:int Base.Array.t -> idcs:int Base.Array.t -> int

val create_bigarray : 
  ('ocaml, 'elt_t) Ops.precision ->
  dims:int Base.Array.t ->
  Ops.init_op ->
  ('ocaml, 'elt_t) bigarray

val create_array : Ops.prec -> dims:int Base.Array.t -> Ops.init_op -> t

val empty_array : Ops.prec -> t

* Accessing *

type 'r map_as_bigarray = {

f : 'ocaml 'elt_t. ('ocaml, 'elt_t) bigarray -> 'r;

}

val map : 'a map_as_bigarray -> t -> 'a

type 'r map2_as_bigarray = {

f2 : 'ocaml 'elt_t. ('ocaml, 'elt_t) bigarray -> ('ocaml, 'elt_t) bigarray -> 'r;

}

val map2 : 'a map2_as_bigarray -> t -> t -> 'a

val dims : t -> int array

val get_voidptr : t -> unit Ctypes_static.ptr

val get_as_float : t -> int array -> Base.Float.t

val set_from_float : t -> int array -> Base.float -> unit

val fill_from_float : t -> Base.float -> unit

val set_bigarray : ('a, 'b, 'c) A.t -> f:(int Base.Array.t -> 'a) -> unit

val reset_bigarray : 
  Ops.init_op ->
  ('o, 'b) Ops.precision ->
  ('o, 'b) bigarray ->
  unit

val reset : Ops.init_op -> t -> unit

val fold_bigarray : 
  ('a, 'b, 'c) A.t ->
  init:'d ->
  f:('d -> int Base.Array.t -> 'a -> 'd) ->
  'd

val fold_as_float : 
  init:'a ->
  f:('a -> int Base.Array.t -> Base.float -> 'a) ->
  t ->
  'a

val size_in_bytes : t -> int

val retrieve_2d_points : 
  ?from_axis:int ->
  xdim:int ->
  ydim:int ->
  t ->
  (Base.Float.t * Base.Float.t) Base.Array.t

val retrieve_1d_points : 
  ?from_axis:int ->
  xdim:int ->
  t ->
  Base.Float.t Base.Array.t

val retrieve_flat_values : t -> Base.Float.t Base.Array.t

* Printing *

val int_dims_to_string : 
  ?with_axis_numbers:bool ->
  Base.Int.t Base.Array.t ->
  Base.String.t

Dimensions to string, "x"-separated, e.g. 1x2x3 for batch dims 1, input dims 3, output dims 2. Outputs "-" for empty dimensions.

val concise_float : prec:int -> float -> Base.String.t

val render_array : 
  ?brief:Base.bool ->
  ?prefix:Base.String.t ->
  ?entries_per_axis:int ->
  ?labels:Base.String.t Base.Array.t ->
  indices:int Base.Array.t ->
  t ->
  PrintBox.t

Prints 0-based indices entries out of arr, where a number between -5 and -1 in an axis means to print out the axis, and a non-negative number means to print out only the indexed dimension of the axis. Prints up to entries_per_axis or entries_per_axis+1 entries per axis, possibly with ellipsis in the middle. labels provides the axis labels for all axes (use "" or "_" for no label). The last label corresponds to axis -1 etc. The printed out axes are arranged as:

-1: a horizontal segment in an inner rectangle (i.e. column numbers of the inner rectangle),
-2: a sequence of segments in a line of text (i.e. column numbers of an outer rectangle),
-3: a vertical segment in an inner rectangle (i.e. row numbers of the inner rectangle),
-4: a vertical sequence of segments (i.e. column numbers of an outer rectangle),
-5: a sequence of screens of text (i.e. stack numbers of outer rectangles).

val pp_array : 
  Format.formatter ->
  ?prefix:Base.String.t ->
  ?entries_per_axis:int ->
  ?labels:Base.String.t Base.Array.t ->
  indices:int Base.Array.t ->
  t ->
  unit

val pp_array_inline : 
  Format.formatter ->
  num_batch_axes:int ->
  num_output_axes:int ->
  num_input_axes:int ->
  ?axes_spec:string ->
  t ->
  unit

Prints the whole array in an inline syntax.

val save : file_name:string -> t -> unit

val restore : file_name:string -> t -> unit

package arrayjit

*** Handling of precisions ***

*** Accessing ***

*** Printing ***

* Handling of precisions *

* Accessing *

* Printing *