`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 t('a, 'b, 'c);
```

The type of two-dimensional big arrays whose elements have
OCaml type

`'a`

, representation kind `'b`

, and memory layout `'c`

.```
let create:
(Bigarray.kind('a, 'b), Bigarray.layout('c), int, int) => t('a, 'b, 'c);
```

`Array2.create kind layout dim1 dim2`

returns a new bigarray of
two dimension, 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`

.```
let dim1: t('a, 'b, 'c) => int;
```

Return the first dimension of the given two-dimensional big array.

```
let dim2: t('a, 'b, 'c) => int;
```

Return the second dimension of the given two-dimensional big array.

```
let kind: t('a, 'b, 'c) => Bigarray.kind('a, 'b);
```

Return the kind of the given big array.

```
let layout: t('a, 'b, 'c) => Bigarray.layout('c);
```

Return the layout of the given big array.

```
let get: (t('a, 'b, 'c), 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.```
let set: (t('a, 'b, 'c), 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.```
let sub_left:
(t('a, 'b, Bigarray.c_layout), int, int) => t('a, 'b, Bigarray.c_layout);
```

Extract a two-dimensional sub-array of the given two-dimensional
big array by restricting the first dimension.
See

`Bigarray.Genarray.sub_left`

for more details.
`Array2.sub_left`

applies only to arrays with C layout.```
let sub_right:
(t('a, 'b, Bigarray.fortran_layout), int, int) =>
t('a, 'b, Bigarray.fortran_layout);
```

Extract a two-dimensional sub-array of the given two-dimensional
big array by restricting the second dimension.
See

`Bigarray.Genarray.sub_right`

for more details.
`Array2.sub_right`

applies only to arrays with Fortran layout.```
let slice_left:
(t('a, 'b, Bigarray.c_layout), int) =>
Bigarray.Array1.t('a, 'b, Bigarray.c_layout);
```

Extract a row (one-dimensional slice) of the given two-dimensional
big array. 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.```
let slice_right:
(t('a, 'b, Bigarray.fortran_layout), int) =>
Bigarray.Array1.t('a, 'b, Bigarray.fortran_layout);
```

Extract a column (one-dimensional slice) of the given
two-dimensional big array. 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.```
let blit: (t('a, 'b, 'c), t('a, 'b, 'c)) => unit;
```

Copy the first big array to the second big array.
See

`Bigarray.Genarray.blit`

for more details.```
let fill: (t('a, 'b, 'c), 'a) => unit;
```

Fill the given big array with the given value.
See

`Bigarray.Genarray.fill`

for more details.```
let of_array:
(Bigarray.kind('a, 'b), Bigarray.layout('c), array(array('a))) =>
t('a, 'b, 'c);
```

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

```
let map_file:
(
Unix.file_descr,
~pos: int64=?,
Bigarray.kind('a, 'b),
Bigarray.layout('c),
bool,
int,
int
) =>
t('a, 'b, 'c);
```

Memory mapping of a file as a two-dimensional big array.
See

`Bigarray.Genarray.map_file`

for more details.```
let unsafe_get: (t('a, 'b, 'c), int, int) => 'a;
```

Like

`Bigarray.Array2.get`

, but bounds checking is not always
performed.```
let unsafe_set: (t('a, 'b, 'c), int, int, 'a) => unit;
```

Like

`Bigarray.Array2.set`

, but bounds checking is not always
performed.