---
name: "Bigarray.Array1"
section: "3o"
platform: "linux"
package: "ocaml"
version: "5.5.0-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/Bigarray.Array1"
---

# Bigarray.Array1(3o)

One-dimensional arrays.

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