Bigarray.Genarray - no description
Module Bigarray.Genarray
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 .