Bigarray.Array2(3) OCaml library Bigarray.Array2(3)

# [NAME](#NAME)

Bigarray.Array2 - Two-dimensional arrays.

# [Module](#Module)

Module Bigarray.Array2

# [Documentation](#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.

2026-10-23 OCamldoc

---

Document: Bigarray.Array2(3o) from ocaml 5.5.2-r0 (Chainguard OS)
Source: https://github.com/ocaml/ocaml