Bigarray.Array1 - One-dimensional arrays.
Module Bigarray.Array1
Module
Array1
:
sig end
One-dimensional arrays. The Array1 structure provides operations similar to
those of Bigarray.Genarray , but specialized to the case of one-dimensional
arrays. (The Bigarray.Array2 and Bigarray.Array3 structures below provide
operations specialized for two- and three-dimensional arrays.) Statically
knowing the number of dimensions of the array allows faster operations, and
more precise static type-checking.
type ('a, 'b, 'c) t
The type of one-dimensional Bigarrays whose elements have OCaml type 'a ,
representation kind 'b , and memory layout 'c .
val create :
('a, 'b) Bigarray.kind -> 'c Bigarray.layout
-> int -> ('a, 'b, 'c) t
Array1.create kind layout dim returns a new Bigarray of one dimension, whose
size is dim . kind and layout determine the array element kind and the array
layout as described for Bigarray.Genarray.create .
val init :
('a, 'b) Bigarray.kind -> 'c Bigarray.layout
-> int -> (int -> 'a) -> ('a, 'b, 'c) t
Array1.init kind layout dim f returns a new Bigarray b of one dimension, whose
size is dim . kind and layout determine the array element kind and the array
layout as described for Bigarray.Genarray.create .
Each element Array1.get b i of the array is initialized to the result of f i .
In other words, Array1.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 dim .
Since 4.12.0
val dim :
('a, 'b, 'c) t -> int
Return the size (dimension) of the given one-dimensional Bigarray.
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
Array1.change_layout a layout returns a Bigarray with the specified layout ,
sharing the data with a (and hence having the same dimension as a ). No
copying of elements is involved: the new array and the original array share
the same storage space.
Since 4.06.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 -> 'a
Array1.get a x , or alternatively a.{x} , returns the element of a at index x .
x must be greater or equal than 0 and strictly less than Array1.dim a if a has
C layout. If a has Fortran layout, x must be greater or equal than 1 and less
or equal than Array1.dim a . Otherwise, Invalid_argument is raised.
val set :
('a, 'b, 'c) t -> int -> 'a -> unit
Array1.set a x v , also written a.{x} <- v , stores the value v at index x in
a . x must be inside the bounds of a as described in Bigarray.Array1.get ;
otherwise, Invalid_argument is raised.
val sub :
('a, 'b, 'c) t -> int -> int -> ('a, 'b, 'c)
t
Extract a sub-array of the given one-dimensional Bigarray. See
Bigarray.Genarray.sub_left for more details.
val slice :
('a, 'b, 'c) t -> int -> ('a, 'b, 'c)
Bigarray.Array0.t
Extract a scalar (zero-dimensional slice) of the given one-dimensional Bigarray.
The integer parameter is the index of the scalar to extract. See
Bigarray.Genarray.slice_left and Bigarray.Genarray.slice_right for more
details.
Since 4.05.0
val blit :
('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit
Copy the first Bigarray to the second Bigarray. See Bigarray.Genarray.blit for
more details.
val fill :
('a, 'b, 'c) t -> 'a -> unit
Fill the given Bigarray with the given value. See Bigarray.Genarray.fill for
more details.
val of_array :
('a, 'b) Bigarray.kind -> 'c Bigarray.layout
-> 'a array -> ('a, 'b, 'c) t
Build a one-dimensional Bigarray initialized from the given array.
val unsafe_get :
('a, 'b, 'c) t -> int -> 'a
Like Bigarray.Array1.get , but bounds checking is not always performed. Use with
caution and only when the program logic guarantees that the access is within
bounds.
val unsafe_set :
('a, 'b, 'c) t -> int -> 'a -> unit
Like Bigarray.Array1.set , but bounds checking is not always performed. Use with
caution and only when the program logic guarantees that the access is within
bounds.