include module type of sig ... end
equal eq a1 a2
is true
if the lengths of a1
and a2
are the same
and if their corresponding elements test equal, using eq
.
val get : 'a t ‑> int ‑> 'a
get a n
returns the element number n
of array a
.
The first element has number 0.
The last element has number length a - 1
.
You can also write a.(n)
instead of get a n
.
Raise Invalid_argument "index out of bounds"
if n
is outside the range 0 to (length a - 1)
.
val get_safe : 'a t ‑> int ‑> 'a option
get_safe a i
returns Some a.(i)
if i
is a valid index.
val set : 'a t ‑> int ‑> 'a ‑> unit
set a n x
modifies array a
in place, replacing
element number n
with x
.
You can also write a.(n) <- x
instead of set a n x
.
Raise Invalid_argument "index out of bounds"
if n
is outside the range 0 to length a - 1
.
val fold : ('a ‑> 'b ‑> 'a) ‑> 'a ‑> 'b t ‑> 'a
fold f acc a
computes f (... (f (f acc a.(0)) a.(1)) ...) a.(n-1)
,
where n
is the length of the array a
.
val foldi : ('a ‑> int ‑> 'b ‑> 'a) ‑> 'a ‑> 'b t ‑> 'a
foldi f acc a
is just like fold, but it also passes in the index
of each element as the second argument to the folded function f
.
val fold_while : ('a ‑> 'b ‑> 'a * [ `Stop | `Continue ]) ‑> 'a ‑> 'b t ‑> 'a
fold_while f acc a
folds left on array a
until a stop condition via ('a, `Stop)
is indicated by the accumulator.
fold_map f acc a
is a fold_left
-like function, but it also maps the
array to another array.
val iter : ('a ‑> unit) ‑> 'a t ‑> unit
iter f a
applies function f
in turn to all elements of a
.
It is equivalent to f a.(0); f a.(1); ...; f a.(length a - 1); ()
.
val iteri : (int ‑> 'a ‑> unit) ‑> 'a t ‑> unit
iteri f a
is like iter, but the function f
is applied with the index of the
element as first argument, and the element itself as second argument.
blit a1 o1 a2 o2 len
copies len
elements
from array a1
, starting at element number o1
, to array a2
,
starting at element number o2
. It works correctly even if
a1
and a2
are the same array, and the source and
destination chunks overlap.
Raise Invalid_argument "CCArray.blit"
if o1
and len
do not
designate a valid subarray of a1
, or if o2
and len
do not
designate a valid subarray of a2
.
val sorted : ('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a array
sorted cmp a
makes a copy of a
and sorts it with cmp
.
val sort_indices : ('a ‑> 'a ‑> int) ‑> 'a t ‑> int array
sort_indices cmp a
returns a new array b
, with the same length as a
,
such that b.(i)
is the index at which the i
-th element of sorted cmp a
appears in a
. a
is not modified.
In other words, map (fun i -> a.(i)) (sort_indices cmp a) = sorted cmp a
.
sort_indices
yields the inverse permutation of sort_ranking.
val sort_ranking : ('a ‑> 'a ‑> int) ‑> 'a t ‑> int array
sort_ranking cmp a
returns a new array b
, with the same length as a
,
such that b.(i)
is the index at which the i
-th element of a
appears
in sorted cmp a
. a
is not modified.
In other words, map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a
.
sort_ranking
yields the inverse permutation of sort_indices.
In the absence of duplicate elements in a
, we also have
lookup_exn a.(i) (sorted a) = (sorted_ranking a).(i)
.
val find_map : ('a ‑> 'b option) ‑> 'a t ‑> 'b option
find_map f a
returns Some y
if there is an element x
such
that f x = Some y
. Otherwise returns None
.
val find : ('a ‑> 'b option) ‑> 'a t ‑> 'b option
val find_map_i : (int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b option
find_map_i f a
is like find_map, but the index of the element is also passed
to the predicate function f
.
val findi : (int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b option
findi f a
is an alias to find_map_i.
val find_idx : ('a ‑> bool) ‑> 'a t ‑> (int * 'a) option
find_idx p a
returns Some (i,x)
where x
is the i
-th element of a
,
and p x
holds. Otherwise returns None
.
lookup cmp x a
lookups the index of some key x
in a sorted array a
.
Undefined behavior if the array a
is not sorted wrt cmp
.
Complexity: O(log (n))
(dichotomic search).
None
if the key x
is not present, or
Some i
(i
the index of the key) otherwise.lookup_exn cmp x a
is like lookup, but
x
is not present.val bsearch : cmp:('a ‑> 'a ‑> int) ‑> 'a ‑> 'a t ‑> [ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ]
bsearch ~cmp x a
finds the index of the object x
in the array a
,
provided a
is sorted using cmp
. If the array is not sorted,
the result is not specified (may raise Invalid_argument).
Complexity: O(log n)
where n is the length of the array a
(dichotomic search).
Returns
`At i
if cmp a.(i) x = 0
(for some i).`All_lower
if all elements of a
are lower than x
.`All_bigger
if all elements of a
are bigger than x
.`Just_after i
if a.(i) < x < a.(i+1)
.`Empty
if the array a
is empty.cmp
.val for_all : ('a ‑> bool) ‑> 'a t ‑> bool
for_all p [|a1; ...; an|]
is true
if all elements of the array
satisfy the predicate p
. That is, it returns
(p a1) && (p a2) && ... && (p an)
.
for_all2 p [|a1; ...; an|] [|b1; ...; bn|]
is true
if each pair of elements ai bi
satisfies the predicate p
.
That is, it returns (p a1 b1) && (p a2 b2) && ... && (p an bn)
.
val exists : ('a ‑> bool) ‑> 'a t ‑> bool
exists p [|a1; ...; an|]
is true
if at least one element of
the array satisfies the predicate p
. That is, it returns
(p a1) || (p a2) || ... || (p an)
.
exists2 p [|a1; ...; an|] [|b1; ...; bn|]
is true
if any pair of elements ai bi
satisfies the predicate p
.
That is, it returns (p a1 b1) || (p a2 b2) || ... || (p an bn)
.
fold2 f acc a b
fold on two arrays a
and b
stepwise.
It computes f (... (f acc a1 b1)...) an bn
.
iter2 f a b
iterates on the two arrays a
and b
stepwise.
It is equivalent to f a0 b0; ...; f a.(length a - 1) b.(length b - 1); ()
.
val shuffle_with : Random.State.t ‑> 'a t ‑> unit
shuffle_with rs a
randomly shuffles the array a
(like shuffle) but a specialized random
state rs
is used to control the random numbers being produced during shuffling (for reproducibility).
val random_choose : 'a t ‑> 'a random_gen
random_choose a rs
randomly chooses an element of a
.
to_seq a
returns a sequence
of the elements of an array a
.
The input array a
is shared with the sequence and modification of it will result
in modification of the sequence.
pp ~sep pp_item ppf a
formats the array a
on ppf
.
Each element is formatted with pp_item
and elements are separated
by sep
(defaults to ", ").
pp_i ~sep pp_item ppf a
prints the array a
on ppf
.
The printing function pp_item
is giving both index and element.
Elements are separated by sep
(defaults to ", ").
map f a
applies function f
to all elements of a
,
and builds an array with the results returned by f
:
[| f a.(0); f a.(1); ...; f a.(length a - 1) |]
.
map2 f a b
applies function f
to all elements of a
and b
,
and builds an array with the results returned by f
:
[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|]
.
a
and b
have distinct lengths.filter p a
filters elements out of the array a
. Only the elements satisfying
the given predicate p
will be kept.
filter_map f [|a1; ...; an|]
calls (f a1) ... (f an)
and returns an array b
consisting
of all elements bi
such as f ai = Some bi
. When f
returns None
, the corresponding
element of a
is discarded.
val except_idx : 'a t ‑> int ‑> 'a list
except_idx a i
removes the element of a
at given index i
, and returns
the list of the other elements.
val (--) : int ‑> int ‑> int t
x -- y
creates an array containing integers in the range x .. y
. Bounds included.
val (--^) : int ‑> int ‑> int t
x --^ y
creates an array containing integers in the range x .. y
. Right bound excluded.
val random : 'a random_gen ‑> 'a t random_gen
val random_non_empty : 'a random_gen ‑> 'a t random_gen
val random_len : int ‑> 'a random_gen ‑> 'a t random_gen
module type MONO_ARRAY : sig ... end
val sort_generic : (module MONO_ARRAY with type elt = 'elt and type t = 'arr) ‑> cmp:('elt ‑> 'elt ‑> int) ‑> 'arr ‑> unit
sort_generic (module M) cmp a
sorts the array a
, without allocating (eats stack space though).
Performance might be lower than Array.sort.