---
name: "Bigarray.Array3"
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.Array3"
---

# Bigarray.Array3(3o)

Three-dimensional arrays.

## NAME

Bigarray.Array3 - Three-dimensional arrays.

## Module

Module   Bigarray.Array3

## Documentation

Module **Array3**\
  :  **sig end**

Three-dimensional arrays. The  **Array3** structure provides operations similar to those of  **Bigarray.Genarray** , but specialized to the case of three-dimensional arrays.

*type* **(!'a, !'b, !'c)** *t*

The type of three-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 -\> int -\> int -\> ('a, 'b, 'c) t**

**Array3.create kind layout dim1 dim2 dim3** returns a new Bigarray of three dimensions, whose size is  **dim1** in the first dimension, **dim2** in the second dimension, and  **dim3** in the third. **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 -\> int -\> (int -\> int -\> int -\> 'a) -\> ('a, 'b, 'c) t**

**Array3.init kind layout dim1 dim2 dim3 f** returns a new Bigarray  **b** of three dimensions, whose size is  **dim1** in the first dimension, **dim2** in the second dimension, and  **dim3** in the third. **kind** and  **layout** determine the array element kind and the array layout as described for  **Bigarray.Genarray.create** .

Each element  **Array3.get b i j k** of the array is initialized to the result of  **f i j k** .

In other words,  **Array3.init kind layout dim1 dim2 dim3 f** tabulates the results of  **f** applied to the indices of a new Bigarray whose layout is described by  **kind** ,  **layout** ,  **dim1** ,  **dim2** and  **dim3** .

**Since** 4.12

*val dim1* :  **('a, 'b, 'c) t -\> int**

Return the first dimension of the given three-dimensional Bigarray.

*val dim2* :  **('a, 'b, 'c) t -\> int**

Return the second dimension of the given three-dimensional Bigarray.

*val dim3* :  **('a, 'b, 'c) t -\> int**

Return the third dimension of the given three-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**

**Array3.change\_layout a layout** returns a Bigarray with the specified  **layout** , sharing the data with  **a** (and hence having the same dimensions as  **a** ). No copying of elements is involved: the new array and the original array share the same storage space. The dimensions are reversed, such that  **get v \[\| a; b; c \|\]** in C layout becomes  **get v \[\| c+1; b+1; a+1 \|\]** in Fortran layout.

**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 -\> int -\> int -\> 'a**

**Array3.get a x y z** , also written  **a.{x,y,z}** , returns the element of  **a** at coordinates ( **x** ,  **y** ,  **z** ). **x** ,  **y** and  **z** must be within the bounds of  **a** , as described for  **Bigarray.Genarray.get** ; otherwise,  **Invalid\_argument** is raised.

*val set* :  **('a, 'b, 'c) t -\> int -\> int -\> int -\> 'a -\> unit**

**Array3.set a x y v** , or alternatively  **a.{x,y,z} \<- v** , stores the value  **v** at coordinates ( **x** ,  **y** ,  **z** ) in  **a** . **x** ,  **y** and  **z** must be within the bounds of  **a** , as described for  **Bigarray.Genarray.set** ; otherwise,  **Invalid\_argument** is raised.

*val sub\_left* :  **('a, 'b, Bigarray.c\_layout) t -\>** **int -\> int -\> ('a, 'b, Bigarray.c\_layout) t**

Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the first dimension. See  **Bigarray.Genarray.sub\_left** for more details.   **Array3.sub\_left** applies only to arrays with C layout.

*val sub\_right* :  **('a, 'b, Bigarray.fortran\_layout) t -\>** **int -\> int -\> ('a, 'b, Bigarray.fortran\_layout) t**

Extract a three-dimensional sub-array of the given three-dimensional Bigarray by restricting the second dimension. See  **Bigarray.Genarray.sub\_right** for more details.   **Array3.sub\_right** applies only to arrays with Fortran layout.

*val slice\_left\_1* :  **('a, 'b, Bigarray.c\_layout) t -\>** **int -\> int -\> ('a, 'b, Bigarray.c\_layout) Bigarray.Array1.t**

Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the first two coordinates. The integer parameters are the coordinates of the slice to extract.  See  **Bigarray.Genarray.slice\_left** for more details. **Array3.slice\_left\_1** applies only to arrays with C layout.

*val slice\_right\_1* :  **('a, 'b, Bigarray.fortran\_layout) t -\>** **int -\> int -\> ('a, 'b, Bigarray.fortran\_layout) Bigarray.Array1.t**

Extract a one-dimensional slice of the given three-dimensional Bigarray by fixing the last two coordinates. The integer parameters are the coordinates of the slice to extract.  See  **Bigarray.Genarray.slice\_right** for more details. **Array3.slice\_right\_1** applies only to arrays with Fortran layout.

*val slice\_left\_2* :  **('a, 'b, Bigarray.c\_layout) t -\>** **int -\> ('a, 'b, Bigarray.c\_layout) Bigarray.Array2.t**

Extract a  two-dimensional slice of the given three-dimensional Bigarray by fixing the first coordinate. The integer parameter is the first coordinate of the slice to extract.  See  **Bigarray.Genarray.slice\_left** for more details. **Array3.slice\_left\_2** applies only to arrays with C layout.

*val slice\_right\_2* :  **('a, 'b, Bigarray.fortran\_layout) t -\>** **int -\> ('a, 'b, Bigarray.fortran\_layout) Bigarray.Array2.t**

Extract a two-dimensional slice of the given three-dimensional Bigarray by fixing the last coordinate. The integer parameter is the coordinate of the slice to extract.  See  **Bigarray.Genarray.slice\_right** for more details. **Array3.slice\_right\_2** applies only to arrays with Fortran layout.

*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 array array -\> ('a, 'b, 'c) t**

Build a three-dimensional Bigarray initialized from the given array of arrays of arrays.

*val unsafe\_get* :  **('a, 'b, 'c) t -\> int -\> int -\> int -\> 'a**

Like  **Bigarray.Array3.get** , but bounds checking is not always performed.

*val unsafe\_set* :  **('a, 'b, 'c) t -\> int -\> int -\> int -\> 'a -\> unit**

Like  **Bigarray.Array3.set** , but bounds checking is not always performed.