Provided by: ocaml-man_4.14.1-1ubuntu1_all bug

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 init : ('a, 'b) Bigarray.kind -> 'c Bigarray.layout -> int array -> (int array ->  'a)
       -> ('a, 'b, 'c) t

       Genarray.init  kind  layout  dimensions  f  returns a new Bigarray b 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.

       Each element Genarray.get b i is initialized to the result of  f  i  .   In  other  words,
       Genarray.init  kind  layout dimensions f tabulates the results of f applied to the indices
       of a new Bigarray whose layout is described by kind , layout and dimensions .   The  index
       array i may be shared and mutated between calls to f.

       For instance, Genarray.init int c_layout [|2; 1; 3|]
              (Array.fold_left  (+)  0) returns a fresh Bigarray of integers, in C layout, having
       three dimensions (2, 1, 3, respectively), with the element values 0, 1, 2, 1, 2, 3.

       Genarray.init 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.

       Since 4.12.0

       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 .

       Raises 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 .

       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.)

       Raises  Invalid_argument  if  the  array  a  does not have exactly N dimensions, or if the
       coordinates are outside the array bounds.

       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.

       Raises  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.

       Raises  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.

       Raises 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.

       Raises 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 .