# Bigarray.Array1.3o - Man Page

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

*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

*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

*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

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