NAME

       Bigarray.Genarray - no description

Module

       Module   Bigarray.Genarray

Documentation

       Module Genarray
        : sig end

       type ('a, 'b, 'c) t

       The  type  Genarray.t  is  the type of Bigarrays with variable numbers of dimensions.  Any
       number of dimensions between 0 and 16 is supported.

       The three type parameters to Genarray.t identify the array element  kind  and  layout,  as
       follows:

       -the  first parameter, 'a , is the OCaml type for accessing array elements ( float , int ,
       int32 , int64 , nativeint );

       -the second parameter, 'b ,  is  the  actual  kind  of  array  elements  (  float32_elt  ,
       float64_elt , int8_signed_elt , int8_unsigned_elt , etc);

       -the third parameter, 'c , identifies the array layout ( c_layout or fortran_layout ).

       For  instance,  (float,  float32_elt,  fortran_layout)  Genarray.t  is the type of generic
       Bigarrays containing 32-bit floats in Fortran layout; reads and writes in this  array  use
       the OCaml type float .

       val create : ('a, 'b) Bigarray.kind -> 'c Bigarray.layout -> int array -> ('a, 'b, 'c) t

       Genarray.create  kind  layout  dimensions  returns  a  new  Bigarray whose element kind is
       determined by the parameter kind (one of float32 , float64 , int8_signed , etc) and  whose
       layout  is  determined  by the parameter layout (one of c_layout or fortran_layout ).  The
       dimensions parameter is an array of integers that indicate the size  of  the  Bigarray  in
       each  dimension.   The  length  of  dimensions  determines the number of dimensions of the
       Bigarray.

       For instance, Genarray.create int32 c_layout [|4;6;8|] returns a fresh Bigarray of  32-bit
       integers,  in  C  layout,  having  three dimensions, the three dimensions being 4, 6 and 8
       respectively.

       Bigarrays returned by Genarray.create are not initialized: the  initial  values  of  array
       elements is unspecified.

       Genarray.create  raises Invalid_argument if the number of dimensions is not in the range 0
       to 16 inclusive, or if one of the dimensions is negative.

       val num_dims : ('a, 'b, 'c) t -> int

       Return the number of dimensions of the given Bigarray.

       val dims : ('a, 'b, 'c) t -> int array

       Genarray.dims a returns all dimensions of the Bigarray a , as  an  array  of  integers  of
       length Genarray.num_dims a .

       val nth_dim : ('a, 'b, 'c) t -> int -> int

       Genarray.nth_dim  a n returns the n -th dimension of the Bigarray a .  The first dimension
       corresponds to n = 0 ; the second dimension corresponds to n = 1 ; the last dimension,  to
       n  =  Genarray.num_dims  a - 1 .  Raise Invalid_argument if n is less than 0 or greater or
       equal than Genarray.num_dims a .

       val kind : ('a, 'b, 'c) t -> ('a, 'b) Bigarray.kind

       Return the kind of the given Bigarray.

       val layout : ('a, 'b, 'c) t -> 'c Bigarray.layout

       Return the layout of the given Bigarray.

       val change_layout : ('a, 'b, 'c) t -> 'd Bigarray.layout -> ('a, 'b, 'd) t

       Genarray.change_layout a layout returns a Bigarray with the specified layout , sharing the
       data  with  a  (and  hence  having  the  same dimensions as a ). No copying of elements is
       involved: the new array and  the  original  array  share  the  same  storage  space.   The
       dimensions  are reversed, such that get v [| a; b |] in C layout becomes get v [| b+1; a+1
       |] in Fortran layout.

       Since 4.04.0

       val size_in_bytes : ('a, 'b, 'c) t -> int

       size_in_bytes   a   is   the   number   of   elements   in   a   multiplied   by   a    's
       Bigarray.kind_size_in_bytes .

       Since 4.03.0

       val get : ('a, 'b, 'c) t -> int array -> 'a

       Read an element of a generic Bigarray.  Genarray.get a [|i1; ...; iN|] returns the element
       of a whose coordinates are i1 in the first dimension, i2 in the second dimension, ...,  iN
       in the N -th dimension.

       If  a has C layout, the coordinates must be greater or equal than 0 and strictly less than
       the corresponding dimensions of a .  If a has Fortran  layout,  the  coordinates  must  be
       greater  or equal than 1 and less or equal than the corresponding dimensions of a .  Raise
       Invalid_argument if the array a does not have exactly N dimensions, or if the  coordinates
       are outside the array bounds.

       If  N  >  3  ,  alternate syntax is provided: you can write a.{i1, i2, ..., iN} instead of
       Genarray.get a [|i1; ...; iN|] .  (The syntax a.{...} with one, two or  three  coordinates
       is reserved for accessing one-, two- and three-dimensional arrays as described below.)

       val set : ('a, 'b, 'c) t -> int array -> 'a -> unit

       Assign  an  element  of  a  generic Bigarray.  Genarray.set a [|i1; ...; iN|] v stores the
       value v in the element of a whose coordinates are i1 in the first  dimension,  i2  in  the
       second dimension, ..., iN in the N -th dimension.

       The  array a must have exactly N dimensions, and all coordinates must lie inside the array
       bounds, as described for Genarray.get ; otherwise, Invalid_argument is raised.

       If N > 3 , alternate syntax is provided: you can write a.{i1, i2, ..., iN} <- v instead of
       Genarray.set  a  [|i1;  ...;  iN|]  v  .   (The syntax a.{...} <- v with one, two or three
       coordinates is reserved for updating one-, two- and three-dimensional arrays as  described
       below.)

       val  sub_left : ('a, 'b, Bigarray.c_layout) t -> int -> int -> ('a, 'b, Bigarray.c_layout)
       t

       Extract a sub-array of the given Bigarray by restricting the first (left-most)  dimension.
       Genarray.sub_left  a  ofs len returns a Bigarray with the same number of dimensions as a ,
       and the same dimensions as a , except  the  first  dimension,  which  corresponds  to  the
       interval  [ofs ... ofs + len - 1] of the first dimension of a .  No copying of elements is
       involved: the sub-array and the original array share the same  storage  space.   In  other
       terms,  the  element  at  coordinates [|i1; ...; iN|] of the sub-array is identical to the
       element at coordinates [|i1+ofs; ...; iN|] of the original array a .

       Genarray.sub_left applies only to Bigarrays in C layout.  Raise  Invalid_argument  if  ofs
       and  len  do  not designate a valid sub-array of a , that is, if ofs < 0 , or len < 0 , or
       ofs + len > Genarray.nth_dim a 0 .

       val  sub_right  :  ('a,  'b,  Bigarray.fortran_layout)  t  ->  int  ->  int  ->  ('a,  'b,
       Bigarray.fortran_layout) t

       Extract  a sub-array of the given Bigarray by restricting the last (right-most) dimension.
       Genarray.sub_right a ofs len returns a Bigarray with the same number of dimensions as a  ,
       and  the  same  dimensions  as  a  ,  except  the last dimension, which corresponds to the
       interval [ofs ... ofs + len - 1] of the last dimension of a .  No copying of  elements  is
       involved:  the  sub-array  and  the original array share the same storage space.  In other
       terms, the element at coordinates [|i1; ...; iN|] of the sub-array  is  identical  to  the
       element at coordinates [|i1; ...; iN+ofs|] of the original array a .

       Genarray.sub_right applies only to Bigarrays in Fortran layout.  Raise Invalid_argument if
       ofs and len do not designate a valid sub-array of a , that is, if ofs < 1 , or len <  0  ,
       or ofs + len > Genarray.nth_dim a (Genarray.num_dims a - 1) .

       val slice_left : ('a, 'b, Bigarray.c_layout) t -> int array -> ('a, 'b, Bigarray.c_layout)
       t

       Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of
       the  first  (left-most)  coordinates.   Genarray.slice_left a [|i1; ... ; iM|] returns the
       'slice' of a obtained by setting the first M coordinates to i1 , ..., iM .   If  a  has  N
       dimensions,  the  slice  has  dimension  N - M , and the element at coordinates [|j1; ...;
       j(N-M)|] in the slice is identical to the element at coordinates [|i1; ...; iM;  j1;  ...;
       j(N-M)|]  in the original array a .  No copying of elements is involved: the slice and the
       original array share the same storage space.

       Genarray.slice_left applies only to Bigarrays in C layout.  Raise Invalid_argument if M >=
       N , or if [|i1; ... ; iM|] is outside the bounds of a .

       val  slice_right  :  ('a,  'b,  Bigarray.fortran_layout)  t  ->  int  array  ->  ('a,  'b,
       Bigarray.fortran_layout) t

       Extract a sub-array of lower dimension from the given Bigarray by fixing one or several of
       the  last  (right-most)  coordinates.  Genarray.slice_right a [|i1; ... ; iM|] returns the
       'slice' of a obtained by setting the last M coordinates to i1 , ..., iM  .   If  a  has  N
       dimensions,  the  slice  has  dimension  N - M , and the element at coordinates [|j1; ...;
       j(N-M)|] in the slice is identical to the element at coordinates [|j1;  ...;  j(N-M);  i1;
       ...; iM|] in the original array a .  No copying of elements is involved: the slice and the
       original array share the same storage space.

       Genarray.slice_right applies only to Bigarrays in Fortran layout.  Raise  Invalid_argument
       if M >= N , or if [|i1; ... ; iM|] is outside the bounds of a .

       val blit : ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit

       Copy  all  elements  of  a Bigarray in another Bigarray.  Genarray.blit src dst copies all
       elements of src into dst .  Both  arrays  src  and  dst  must  have  the  same  number  of
       dimensions  and equal dimensions.  Copying a sub-array of src to a sub-array of dst can be
       achieved by applying Genarray.blit to sub-array or slices of src and dst .

       val fill : ('a, 'b, 'c) t -> 'a -> unit

       Set all elements of a Bigarray to a given value.  Genarray.fill a v stores the value v  in
       all  elements of the Bigarray a .  Setting only some elements of a to v can be achieved by
       applying Genarray.fill to a sub-array or a slice of a .