#### bigarray-compat

The type of three-dimensional Bigarrays whose elements have OCaml type `'a`

, representation kind `'b`

, and memory layout `'c`

.

`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 ) kind ->
'c 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`

.

`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.

`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.

`val size_in_bytes : ( 'a, 'b, 'c ) t -> int`

`size_in_bytes a`

is the number of elements in `a`

multiplied by `a`

's `kind_size_in_bytes`

.

`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.

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, fortran_layout ) t ->
int ->
int ->
( 'a, 'b, 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.

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, fortran_layout ) t ->
int ->
int ->
( 'a, 'b, fortran_layout ) 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.

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, fortran_layout ) t ->
int ->
( 'a, 'b, fortran_layout ) 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.

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.

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.