# Bigarray.Array1.3o man page

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.