### Bigarray.Array1 (3)

#### NAME

Bigarray.Array1 - One-dimensional arrays.#### Module

Module Bigarray.Array1#### Documentation

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