include module type of ArrayLabels
val create_matrix : dimx:int ‑> dimy:int ‑> 'a ‑> 'a array array
module Floatarray : 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 : f:('a ‑> 'b ‑> 'a) ‑> init:'a ‑> 'b t ‑> 'a
fold ~f ~init a
computes ~f (... (~f (~f ~init a.(0)) a.(1)) ...) a.(n-1)
,
where n
is the length of the array a
.
val foldi : f:('a ‑> int ‑> 'b ‑> 'a) ‑> init:'a ‑> 'b t ‑> 'a
foldi ~f ~init 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 : f:('a ‑> 'b ‑> 'a * [ `Stop | `Continue ]) ‑> init:'a ‑> 'b t ‑> 'a
fold_while ~f ~init a
folds left on array a
until a stop condition via ('a, `Stop)
is indicated by the accumulator.
fold_map ~f ~init a
is a fold_left
-like function, but it also maps the
array to another array.
scan_left ~f ~init a
returns the array
[|~init; ~f ~init x0; ~f (~f ~init a.(0)) a.(1); …|]
.
val iter : f:('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 : f:(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 : f:('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a array
sorted ~f a
makes a copy of a
and sorts it with ~f
.
val sort_indices : f:('a ‑> 'a ‑> int) ‑> 'a t ‑> int array
sort_indices ~f 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 ~f a
appears in a
. a
is not modified.
In other words, map (fun i -> a.(i)) (sort_indices ~f a) = sorted ~f a
.
sort_indices
yields the inverse permutation of sort_ranking.
val sort_ranking : f:('a ‑> 'a ‑> int) ‑> 'a t ‑> int array
sort_ranking ~f 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 ~f a
. a
is not modified.
In other words, map (fun i -> (sorted ~f a).(i)) (sort_ranking ~f 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 : f:('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 : f:('a ‑> 'b option) ‑> 'a t ‑> 'b option
val find_map_i : f:(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 : f:(int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b option
findi ~f a
is an alias to find_map_i.
val find_idx : f:('a ‑> bool) ‑> 'a t ‑> (int * 'a) option
find_idx ~f a
returns Some (i,x)
where x
is the i
-th element of a
,
and ~f x
holds. Otherwise returns None
.
lookup ~cmp ~key a
lookups the index of some key ~key
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 ~key
is not present, or
Some i
(i
the index of the key) otherwise.lookup_exn ~cmp ~key a
is like lookup, but
~key
is not present.val bsearch : cmp:('a ‑> 'a ‑> int) ‑> key:'a ‑> 'a t ‑> [ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ]
bsearch ~cmp ~key a
finds the index of the object ~key
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) key = 0
(for some i).`All_lower
if all elements of a
are lower than key
.`All_bigger
if all elements of a
are bigger than key
.`Just_after i
if a.(i) < key < a.(i+1)
.`Empty
if the array a
is empty.cmp
.val for_all : f:('a ‑> bool) ‑> 'a t ‑> bool
for_all ~f [|a1; ...; an|]
is true
if all elements of the array
satisfy the predicate ~f
. That is, it returns
(~f a1) && (~f a2) && ... && (~f an)
.
for_all2 ~f [|a1; ...; an|] [|b1; ...; bn|]
is true
if each pair of elements ai bi
satisfies the predicate ~f
.
That is, it returns (~f a1 b1) && (~f a2 b2) && ... && (~f an bn)
.
val exists : f:('a ‑> bool) ‑> 'a t ‑> bool
exists ~f [|a1; ...; an|]
is true
if at least one element of
the array satisfies the predicate ~f
. That is, it returns
(~f a1) || (~f a2) || ... || (~f an)
.
exists2 ~f [|a1; ...; an|] [|b1; ...; bn|]
is true
if any pair of elements ai bi
satisfies the predicate ~f
.
That is, it returns (~f a1 b1) || (~f a2 b2) || ... || (~f an bn)
.
fold2 ~f ~init a b
fold on two arrays a
and b
stepwise.
It computes ~f (... (~f ~init a1 b1)...) an bn
.
a
and b
have distinct lengths.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); ()
.
a
and b
have distinct lengths.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 ~f a
filters elements out of the array a
. Only the elements satisfying
the given predicate ~f
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.