Array(3o) OCaml library Array(3o)
NAME
Array - Array operations.
Module
Module Array
Documentation
Module Array
: sig end
Array operations.
The labeled version of this module can be used as described in the Std-
Labels module.
type 'a t = 'a array
An alias for the type of arrays.
val length : 'a array -> int
Return the length (number of elements) of the given array.
val get : 'a array -> 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 .
Raises Invalid_argument if n is outside the range 0 to (length a - 1) .
val set : 'a array -> 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 .
Raises Invalid_argument if n is outside the range 0 to length a - 1 .
val make : int -> 'a -> 'a 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.
Raises 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 .
val create : int -> 'a -> 'a array
Deprecated.
create is an alias for Array.make .
val create_float : int -> float array
create_float n returns a fresh float array of length n , with unini-
tialized data.
Since 4.03
val make_float : int -> float array
Deprecated.
make_float is an alias for Array.create_float .
val init : int -> (int -> 'a) -> 'a array
init n f returns a fresh array of length n , with element number i ini-
tialized to the result of f i . In other terms, init n f tabulates the
results of f applied to the integers 0 to n-1 .
Raises Invalid_argument if n < 0 or n > Sys.max_array_length . If the
return type of f is float , then the maximum size is only Sys.max_ar-
ray_length / 2 .
val make_matrix : int -> int -> 'a -> 'a 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) .
Raises Invalid_argument if dimx or dimy is negative 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 .
val create_matrix : int -> int -> 'a -> 'a array array
Deprecated.
create_matrix is an alias for Array.make_matrix .
val append : 'a array -> 'a array -> 'a array
append v1 v2 returns a fresh array containing the concatenation of the
arrays v1 and v2 .
Raises Invalid_argument if length v1 + length v2 > Sys.max_array_length
.
val concat : 'a array list -> 'a array
Same as Array.append , but concatenates a list of arrays.
val sub : 'a array -> int -> int -> 'a array
sub a pos len returns a fresh array of length len , containing the ele-
ments number pos to pos + len - 1 of array a .
Raises Invalid_argument if pos and len do not designate a valid subar-
ray of a ; that is, if pos < 0 , or len < 0 , or pos + len > length a .
val copy : 'a array -> 'a array
copy a returns a copy of a , that is, a fresh array containing the same
elements as a .
val fill : 'a array -> int -> int -> 'a -> unit
fill a pos len x modifies the array a in place, storing x in elements
number pos to pos + len - 1 .
Raises Invalid_argument if pos and len do not designate a valid subar-
ray of a .
val blit : 'a array -> int -> 'a array -> int -> int -> unit
blit src src_pos dst dst_pos len copies len elements from array src ,
starting at element number src_pos , to array dst , starting at element
number dst_pos . It works correctly even if src and dst are the same
array, and the source and destination chunks overlap.
Raises Invalid_argument if src_pos and len do not designate a valid
subarray of src , or if dst_pos and len do not designate a valid subar-
ray of dst .
val to_list : 'a array -> 'a list
to_list a returns the list of all the elements of a .
val of_list : 'a list -> 'a array
of_list l returns a fresh array containing the elements of l .
Raises Invalid_argument if the length of l is greater than Sys.max_ar-
ray_length .
Iterators
val iter : ('a -> unit) -> 'a array -> unit
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.(length a - 1); () .
val iteri : (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 map : ('a -> 'b) -> 'a array -> 'b array
map f a applies function f to all the elements of a , and builds an ar-
ray with the results returned by f : [| f a.(0); f a.(1); ...; f
a.(length a - 1) |] .
val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array
Same as Array.map , but the function is applied to the index of the el-
ement as first argument, and the element itself as second argument.
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
fold_left 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 fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b array -> 'a * 'c
array
fold_left_map is a combination of Array.fold_left and Array.map that
threads an accumulator through calls to f .
Since 4.13.0
val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
fold_right f a init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init)
...)) , where n is the length of the array a .
Iterators on two arrays
val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit
iter2 f a b applies function f to all the elements of a and b .
Since 4.03.0 (4.05.0 in ArrayLabels)
Raises Invalid_argument if the arrays are not the same size.
val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
map2 f a b applies function f to all the 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)|] .
Since 4.03.0 (4.05.0 in ArrayLabels)
Raises Invalid_argument if the arrays are not the same size.
Array scanning
val for_all : ('a -> bool) -> 'a array -> bool
for_all f [|a1; ...; an|] checks if all elements of the array satisfy
the predicate f . That is, it returns (f a1) && (f a2) && ... && (f an)
.
Since 4.03.0
val exists : ('a -> bool) -> 'a array -> bool
exists f [|a1; ...; an|] checks if at least one element of the array
satisfies the predicate f . That is, it returns (f a1) || (f a2) || ...
|| (f an) .
Since 4.03.0
val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
Same as Array.for_all , but for a two-argument predicate.
Since 4.11.0
Raises Invalid_argument if the two arrays have different lengths.
val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
Same as Array.exists , but for a two-argument predicate.
Since 4.11.0
Raises Invalid_argument if the two arrays have different lengths.
val mem : 'a -> 'a array -> bool
mem a set is true if and only if a is structurally equal to an element
of l (i.e. there is an x in l such that compare a x = 0 ).
Since 4.03.0
val memq : 'a -> 'a array -> bool
Same as Array.mem , but uses physical equality instead of structural
equality to compare list elements.
Since 4.03.0
val find_opt : ('a -> bool) -> 'a array -> 'a option
find_opt f a returns the first element of the array a that satisfies
the predicate f , or None if there is no value that satisfies f in the
array a .
Since 4.13.0
val find_map : ('a -> 'b option) -> 'a array -> 'b option
find_map f a applies f to the elements of a in order, and returns the
first result of the form Some v , or None if none exist.
Since 4.13.0
Arrays of pairs
val split : ('a * 'b) array -> 'a array * 'b array
split [|(a1,b1); ...; (an,bn)|] is ([|a1; ...; an|], [|b1; ...; bn|]) .
Since 4.13.0
val combine : 'a array -> 'b array -> ('a * 'b) array
combine [|a1; ...; an|] [|b1; ...; bn|] is [|(a1,b1); ...; (an,bn)|] .
Raise Invalid_argument if the two arrays have different lengths.
Since 4.13.0
Sorting
val sort : ('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 inte-
ger if the first is smaller (see below for a complete specification).
For example, compare is a suitable comparison function. After calling
sort , the array is sorted in place in increasing order. sort is guar-
anteed 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 and cmp
the comparison function. The following must be true for all x , y , z
in a :
- cmp x y > 0 if and only if cmp y x < 0
- if cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0
When sort returns, a contains the same elements as before, reordered in
such a way that for all i and j valid indices of a :
- cmp a.(i) a.(j) >= 0 if and only if i >= j
val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
Same as Array.sort , but the sorting algorithm is stable (i.e. ele-
ments 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 a temporary array
of length n/2 , where n is the length of the array. It is usually
faster than the current implementation of Array.sort .
val fast_sort : ('a -> 'a -> int) -> 'a array -> unit
Same as Array.sort or Array.stable_sort , whichever is faster on typi-
cal input.
Arrays and Sequences
val to_seq : 'a array -> 'a Seq.t
Iterate on the array, in increasing order. Modifications of the array
during iteration will be reflected in the sequence.
Since 4.07
val to_seqi : 'a array -> (int * 'a) Seq.t
Iterate on the array, in increasing order, yielding indices along ele-
ments. Modifications of the array during iteration will be reflected
in the sequence.
Since 4.07
val of_seq : 'a Seq.t -> 'a array
Create an array from the generator
Since 4.07
OCamldoc 2023-02-12 Array(3o)
Generated by dwww version 1.15 on Sun Jun 23 04:21:33 CEST 2024.