Module Array

`module Array = `struct ... end ``
 Functions

 ``` length``` : `'a array -> int`
Return the length (number of elements) of the given array.

 ``` get``` : `'b array -> int -> 'b`
`Array.get a n` returns the element number `n` of array `a`. The first element has number 0. The last element has number `Array.length a - 1`. Raise `Invalid_argument "Array.get"` if `n` is outside the range 0 to `(Array.length a - 1)`. You can also write `a.(n)` instead of `Array.get a n`.

 ``` set``` : `'c array -> int -> 'c -> unit`
`Array.set a n x` modifies array `a` in place, replacing element number `n` with `x`. Raise `Invalid_argument "Array.set"` if `n` is outside the range 0 to `Array.length a - 1`. You can also write `a.(n) <- x` instead of `Array.set a n x`.

 ``` make``` : `int -> 'd -> 'd array`

 ``` create``` : `int -> 'e -> 'e array`
`Array.make n x` returns a fresh array of length `n`, initialized with `x`. All the elements of this new array are initially physically equal to `x` (in the sense of the `==` predicate). Consequently, if `x` is mutable, it is shared among all elements of the array, and modifying `x` through one of the array entries will modify all other entries at the same time. Raise `Invalid_argument` if `n < 0` or `n > Sys.max_array_length`. If the value of `x` is a floating-point number, then the maximum size is only `Sys.max_array_length / 2`. `Array.create` is a deprecated alias for `Array.make`.

 ``` init``` : `int -> f:(int -> 'f) -> 'f array`
`Array.init n f` returns a fresh array of length `n`, with element number `i` initialized to the result of `f i`. In other terms, `Array.init n f` tabulates the results of `f` applied to the integers `0` to `n-1`.

 ``` make_matrix``` : `dimx:int -> dimy:int -> 'g -> 'g array array`

 ``` create_matrix``` : `dimx:int -> dimy:int -> 'h -> 'h array array`
`Array.make_matrix dimx dimy e` returns a two-dimensional array (an array of arrays) with first dimension `dimx` and second dimension `dimy`. All the elements of this new matrix are initially physically equal to `e`. The element (`x,y`) of a matrix `m` is accessed with the notation `m.(x).(y)`. Raise `Invalid_argument` if `dimx` or `dimy` is less than 1 or greater than `Sys.max_array_length`. If the value of `e` is a floating-point number, then the maximum size is only `Sys.max_array_length / 2`. `Array.create_matrix` is a deprecated alias for `Array.make_matrix`.

 ``` append``` : `'i array -> 'i array -> 'i array`
`Array.append v1 v2` returns a fresh array containing the concatenation of the arrays `v1` and `v2`.

 ``` concat``` : `'j array list -> 'j array`
Same as `Array.append`, but catenates a list of arrays.

 ``` sub``` : `'k array -> pos:int -> len:int -> 'k array`
`Array.sub a start len` returns a fresh array of length `len`, containing the elements number `start` to `start + len - 1` of array `a`. Raise `Invalid_argument "Array.sub"` if `start` and `len` do not designate a valid subarray of `a`; that is, if `start < 0`, or `len < 0`, or `start + len > Array.length a`.

 ``` copy``` : `'l array -> 'l array`
`Array.copy a` returns a copy of `a`, that is, a fresh array containing the same elements as `a`.

 ``` fill``` : `'m array -> pos:int -> len:int -> 'm -> unit`
`Array.fill a ofs len x` modifies the array `a` in place, storing `x` in elements number `ofs` to `ofs + len - 1`. Raise `Invalid_argument "Array.fill"` if `ofs` and `len` do not designate a valid subarray of `a`.

 ``` blit``` : `src:'n array -> src_pos:int -> dst:'n array -> dst_pos:int -> len:int -> unit`
`Array.blit v1 o1 v2 o2 len` copies `len` elements from array `v1`, starting at element number `o1`, to array `v2`, starting at element number `o2`. It works correctly even if `v1` and `v2` are the same array, and the source and destination chunks overlap. Raise `Invalid_argument "Array.blit"` if `o1` and `len` do not designate a valid subarray of `v1`, or if `o2` and `len` do not designate a valid subarray of `v2`.

 ``` to_list``` : `'o array -> 'o list`
`Array.to_list a` returns the list of all the elements of `a`.

 ``` of_list``` : `'p list -> 'p array`
`Array.of_list l` returns a fresh array containing the elements of `l`.

 ``` iter``` : `f:('q -> unit) -> 'q array -> unit`
`Array.iter f a` applies function `f` in turn to all the elements of `a`. It is equivalent to `f a.(0); f a.(1); ...; f a.(Array.length a - 1); ()`.

 ``` map``` : `f:('r -> 's) -> 'r array -> 's array`
`Array.map f a` applies function `f` to all the elements of `a`, and builds an array with the results returned by `f`: `[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |]`.

 ``` iteri``` : `f:(int -> 't -> unit) -> 't array -> unit`

 ``` mapi``` : `f:(int -> 'u -> 'v) -> 'u array -> 'v array`
Same as `Array.iter` and `Array.map` respectively, but the function is applied to the index of the element as first argument, and the element itself as second argument.

 ``` fold_left``` : `f:('w -> 'x -> 'w) -> init:'w -> 'x array -> 'w`
`Array.fold_left f x a` computes `f (... (f (f x a.(0)) a.(1)) ...) a.(n-1)`, where `n` is the length of the array `a`.

 ``` fold_right``` : `f:('y -> 'z -> 'z) -> 'y array -> init:'z -> 'z`
`Array.fold_right f a x` computes `f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...))`, where `n` is the length of the array `a`.

 ``` sort``` : `cmp:('a1 -> 'a1 -> int) -> 'a1 array -> unit`
Sort an array in increasing order according to a comparison function. The comparison function must return 0 if its arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller. For example, the `compare` function is a suitable comparison function. After calling `Array.sort`, the array is sorted in place in increasing order. `Array.sort` is guaranteed to run in constant heap space and logarithmic stack space.
The current implementation uses Heap Sort. It runs in constant stack space.

 ``` stable_sort``` : `cmp:('b1 -> 'b1 -> int) -> 'b1 array -> unit`
Same as `Array.sort`, but the sorting algorithm is stable and not guaranteed to use a fixed amount of heap memory. The current implementation is Merge Sort. It uses `n/2` words of heap space, where `n` is the length of the array. It is faster than the current implementation of `Array.sort`.

 ``` unsafe_get``` : `'c1 array -> int -> 'c1`

 ``` unsafe_set``` : `'d1 array -> int -> 'd1 -> unit`