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

# Bigarray.Array2(3o)

Two-dimensional arrays.

## NAME

Bigarray.Array2 - Two-dimensional arrays.

## Module

Module   Bigarray.Array2

## Documentation

Module **Array2**\
  :  **sig end**

Two-dimensional arrays. The  **Array2** structure provides operations similar to those of  **Bigarray.Genarray** , but specialized to the case of two-dimensional arrays.

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

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

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

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

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

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

**Since** 4.12

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

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

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

Return the second dimension of the given two-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**

**Array2.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 \|\]** in C layout becomes  **get v \[\| 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 -\> 'a**

**Array2.get a x y** , also written  **a.{x,y}** , returns the element of  **a** at coordinates ( **x** ,  **y** ). **x** and  **y** 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 -\> 'a -\> unit**

**Array2.set a x y v** , or alternatively  **a.{x,y} \<- v** , stores the value  **v** at coordinates ( **x** ,  **y** ) in  **a** . **x** and  **y** 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 two-dimensional sub-array of the given two-dimensional Bigarray by restricting the first dimension. See  **Bigarray.Genarray.sub\_left** for more details. **Array2.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 two-dimensional sub-array of the given two-dimensional Bigarray by restricting the second dimension. See  **Bigarray.Genarray.sub\_right** for more details. **Array2.sub\_right** applies only to arrays with Fortran layout.

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

Extract a row (one-dimensional slice) of the given two-dimensional Bigarray.  The integer parameter is the index of the row to extract.  See  **Bigarray.Genarray.slice\_left** for more details. **Array2.slice\_left** applies only to arrays with C layout.

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

Extract a column (one-dimensional slice) of the given two-dimensional Bigarray.  The integer parameter is the index of the column to extract.  See  **Bigarray.Genarray.slice\_right** for more details.   **Array2.slice\_right** 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 -\> ('a, 'b, 'c) t**

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

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

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

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

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