module Array1:One-dimensional arrays. The`sig`

..`end`

`Array1`

structure provides operations
similar to those of
`Bigarray.Genarray`

, but specialized to the case of one-dimensional arrays.
(The `Array2`

and `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 big arrays whose elements have
Caml 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 `Genarray.create`

.`val dim : ``('a, 'b, 'c) t -> int`

Return the size (dimension) of the given one-dimensional
big array.

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

Return the kind of the given big array.

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

Return the layout of the given big array.

`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 big array.
See

`Genarray.sub_left`

for more details.`val blit : ``('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit`

Copy the first big array to the second big array.
See

`Genarray.blit`

for more details.`val fill : ``('a, 'b, 'c) t -> 'a -> unit`

Fill the given big array with the given value.
See

`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 big array initialized from the
given array.

`val map_file : ``Unix.file_descr ->`

?pos:int64 ->

('a, 'b) Bigarray.kind ->

'c Bigarray.layout -> bool -> int -> ('a, 'b, 'c) t

Memory mapping of a file as a one-dimensional big array.
See

`Bigarray.Genarray.map_file`

for more details.`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.