Module Import0.ArrayLabels
val get : 'a array -> int -> 'a
Array.get a n
returns the element numbern
of arraya
. The first element has number 0. The last element has numberArray.length a - 1
. You can also writea.(n)
instead ofArray.get a n
.Raise
Invalid_argument "index out of bounds"
ifn
is outside the range 0 to(Array.length a - 1)
.
val set : 'a array -> int -> 'a -> unit
Array.set a n x
modifies arraya
in place, replacing element numbern
withx
. You can also writea.(n) <- x
instead ofArray.set a n x
.Raise
Invalid_argument "index out of bounds"
ifn
is outside the range 0 toArray.length a - 1
.
val make : int -> 'a -> 'a array
Array.make n x
returns a fresh array of lengthn
, initialized withx
. All the elements of this new array are initially physically equal tox
(in the sense of the==
predicate). Consequently, ifx
is mutable, it is shared among all elements of the array, and modifyingx
through one of the array entries will modify all other entries at the same time.Raise
Invalid_argument
ifn < 0
orn > Sys.max_array_length
. If the value ofx
is a floating-point number, then the maximum size is onlySys.max_array_length / 2
.
val init : int -> f:(int -> 'a) -> 'a array
Array.init n f
returns a fresh array of lengthn
, with element numberi
initialized to the result off i
. In other terms,Array.init n f
tabulates the results off
applied to the integers0
ton-1
.Raise
Invalid_argument
ifn < 0
orn > Sys.max_array_length
. If the return type off
isfloat
, then the maximum size is onlySys.max_array_length / 2
.
val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
Array.make_matrix dimx dimy e
returns a two-dimensional array (an array of arrays) with first dimensiondimx
and second dimensiondimy
. All the elements of this new matrix are initially physically equal toe
. The element (x,y
) of a matrixm
is accessed with the notationm.(x).(y)
.Raise
Invalid_argument
ifdimx
ordimy
is negative or greater thanSys.max_array_length
. If the value ofe
is a floating-point number, then the maximum size is onlySys.max_array_length / 2
.
val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
- deprecated
Array.create_matrix
is an alias forArray
.make_matrix.
val append : 'a array -> 'a array -> 'a array
Array.append v1 v2
returns a fresh array containing the concatenation of the arraysv1
andv2
.
val concat : 'a array list -> 'a array
Same as
Array.append
, but concatenates a list of arrays.
val sub : 'a array -> pos:int -> len:int -> 'a array
Array.sub a start len
returns a fresh array of lengthlen
, containing the elements numberstart
tostart + len - 1
of arraya
.Raise
Invalid_argument "Array.sub"
ifstart
andlen
do not designate a valid subarray ofa
; that is, ifstart < 0
, orlen < 0
, orstart + len > Array.length a
.
val copy : 'a array -> 'a array
Array.copy a
returns a copy ofa
, that is, a fresh array containing the same elements asa
.
val fill : 'a array -> pos:int -> len:int -> 'a -> unit
Array.fill a ofs len x
modifies the arraya
in place, storingx
in elements numberofs
toofs + len - 1
.Raise
Invalid_argument "Array.fill"
ifofs
andlen
do not designate a valid subarray ofa
.
val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit
Array.blit v1 o1 v2 o2 len
copieslen
elements from arrayv1
, starting at element numbero1
, to arrayv2
, starting at element numbero2
. It works correctly even ifv1
andv2
are the same array, and the source and destination chunks overlap.Raise
Invalid_argument "Array.blit"
ifo1
andlen
do not designate a valid subarray ofv1
, or ifo2
andlen
do not designate a valid subarray ofv2
.
val of_list : 'a list -> 'a array
Array.of_list l
returns a fresh array containing the elements ofl
.
val iter : f:('a -> unit) -> 'a array -> unit
Array.iter f a
applies functionf
in turn to all the elements ofa
. It is equivalent tof a.(0); f a.(1); ...; f a.(Array.length a - 1); ()
.
val map : f:('a -> 'b) -> 'a array -> 'b array
Array.map f a
applies functionf
to all the elements ofa
, and builds an array with the results returned byf
:[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |]
.
val iteri : f:(int -> 'a -> unit) -> 'a array -> unit
Same as
Array.iter
, but the function is applied to the index of the element as first argument, and the element itself as second argument.
val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array
Same as
Array.map
, but the function is applied to the index of the element as first argument, and the element itself as second argument.
val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a
Array.fold_left f x a
computesf (... (f (f x a.(0)) a.(1)) ...) a.(n-1)
, wheren
is the length of the arraya
.
val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a
Array.fold_right f a x
computesf a.(0) (f a.(1) ( ... (f a.(n-1) x) ...))
, wheren
is the length of the arraya
.
Iterators on two arrays
val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit
Array.iter2 f a b
applies functionf
to all the elements ofa
andb
. RaiseInvalid_argument
if the arrays are not the same size.- since
- 4.05.0
val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
Array.map2 f a b
applies functionf
to all the elements ofa
andb
, and builds an array with the results returned byf
:[| f a.(0) b.(0); ...; f a.(Array.length a - 1) b.(Array.length b - 1)|]
. RaiseInvalid_argument
if the arrays are not the same size.- since
- 4.05.0
Array scanning
val exists : f:('a -> bool) -> 'a array -> bool
Array.exists p [|a1; ...; an|]
checks if at least one element of the array satisfies the predicatep
. That is, it returns(p a1) || (p a2) || ... || (p an)
.- since
- 4.03.0
val for_all : f:('a -> bool) -> 'a array -> bool
Array.for_all p [|a1; ...; an|]
checks if all elements of the array satisfy the predicatep
. That is, it returns(p a1) && (p a2) && ... && (p an)
.- since
- 4.03.0
val mem : 'a -> set:'a array -> bool
mem x a
is true if and only ifx
is equal to an element ofa
.- since
- 4.03.0
val memq : 'a -> set:'a array -> bool
Same as
Array.mem
, but uses physical equality instead of structural equality to compare list elements.- since
- 4.03.0
Sorting
val sort : cmp:('a -> 'a -> int) -> 'a 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 (see below for a complete specification). For example,
Stdlib.compare
is a suitable comparison function, provided there are no floating-point NaN values in the data. After callingArray.sort
, the array is sorted in place in increasing order.Array.sort
is guaranteed to run in constant heap space and (at most) logarithmic stack space.The current implementation uses Heap Sort. It runs in constant stack space.
Specification of the comparison function: Let
a
be the array andcmp
the comparison function. The following must be true for all x, y, z in a :cmp x y
> 0 if and only ifcmp y x
< 0- if
cmp x y
>= 0 andcmp y z
>= 0 thencmp x z
>= 0
When
Array.sort
returns,a
contains the same elements as before, reordered in such a way that for all i and j valid indices ofa
:cmp a.(i) a.(j)
>= 0 if and only if i >= j
val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
Same as
Array.sort
, but the sorting algorithm is stable (i.e. elements that compare equal are kept in their original order) and not guaranteed to run in constant heap space.The current implementation uses Merge Sort. It uses
n/2
words of heap space, wheren
is the length of the array. It is usually faster than the current implementation ofArray.sort
.
val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
Same as
Array.sort
orArray.stable_sort
, whichever is faster on typical input.
Iterators
val to_seq : 'a array -> 'a Seq.t
Iterate on the array, in increasing order
- since
- 4.07
val to_seqi : 'a array -> (int * 'a) Seq.t
Iterate on the array, in increasing order, yielding indices along elements
- since
- 4.07
val of_seq : 'a Seq.t -> 'a array
Create an array from the generator
- since
- 4.07