module Array = struct ... end
Functions |
length
: 'a array -> int |
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 |
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 |
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 |
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.
stable_sort
: cmp:('b1 -> 'b1 -> int) -> 'b1 array -> unit |
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 |