include module type of struct include Array endArray.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_float n returns a fresh float array of length n, with uninitialized data.
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.
Raise 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_array_length / 2.
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 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.
Array.append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.
Same as Array.append, but concatenates a list of arrays.
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.
Array.copy a returns a copy of a, that is, a fresh array containing the same elements as a.
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.
Array.of_list l returns a fresh array containing the elements of l.
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.
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.
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.
Same as Array.mem, but uses physical equality instead of structural equality to compare array elements.
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, Pervasives.compare is a suitable comparison function, provided there are no floating-point NaN values in the data. After calling Array.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 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 < 0cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0When Array.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 >= jSame 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, where n is the length of the array. It is usually faster than the current implementation of Array.sort.
Same as Array.sort or Array.stable_sort, whichever is faster on typical input.
include module type of struct include CCArray endtype 'a klist = unit -> [ `Nil | `Cons of 'a * 'a klist ]type 'a random_gen = Random.State.t -> 'amodule type S = CCArray.Sinclude S with type 'a t := 'a tval empty : 'a tval equal : 'a CCArray.equal -> 'a t CCArray.equalval compare : 'a CCArray.ord -> 'a t CCArray.ordval get : 'a t -> int -> 'aval get_safe : 'a t -> int -> 'a optionget_safe a i returns Some a.(i) if i is a valid index
val set : 'a t -> int -> 'a -> unitval length : _ t -> intval fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'aval foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b t -> 'aFold left on array, with index
val fold_while : ('a -> 'b -> 'a * [ `Stop | `Continue ]) -> 'a -> 'b t -> 'aFold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator
val iter : ('a -> unit) -> 'a t -> unitval iteri : (int -> 'a -> unit) -> 'a t -> unitblit from i into j len copies len elements from the first array to the second. See Array.blit.
val reverse_in_place : 'a t -> unitReverse the array in place
val sorted : ('a -> 'a -> int) -> 'a t -> 'a arraysorted cmp a makes a copy of a and sorts it with cmp.
val sort_indices : ('a -> 'a -> int) -> 'a t -> int arraysort_indices cmp a returns a new array b, with the same length as a, such that b.(i) is the index of the i-th element of a in sort cmp a. In other words, map (fun i -> a.(i)) (sort_indices a) = sorted cmp a. a is not modified.
val sort_ranking : ('a -> 'a -> int) -> 'a t -> int arraysort_ranking cmp a returns a new array b, with the same length as a, such that b.(i) is the position in sorted cmp a of the i-th element of a. a is not modified.
In other words, map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a.
Without duplicates, we also have lookup_exn a.(i) (sorted a) = (sorted_ranking a).(i)
val find : ('a -> 'b option) -> 'a t -> 'b optionfind f a returns Some y if there is an element x such that f x = Some y, else it returns None
val findi : (int -> 'a -> 'b option) -> 'a t -> 'b optionLike find, but also pass the index to the predicate function.
val find_idx : ('a -> bool) -> 'a t -> (int * 'a) optionfind_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds. Otherwise returns None
val lookup : ?cmp:'a CCArray.ord -> 'a -> 'a t -> int optionLookup the index of some value in a sorted array.
val lookup_exn : ?cmp:'a CCArray.ord -> 'a -> 'a t -> intSame as lookup_exn, but
val bsearch :
?cmp:('a -> 'a -> int) ->
'a ->
'a t ->
[ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ]bsearch ?cmp x arr finds the index of the object x in the array arr, provided arr 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 (dichotomic search).
val for_all : ('a -> bool) -> 'a t -> boolval exists : ('a -> bool) -> 'a t -> boolval shuffle : 'a t -> unitShuffle randomly the array, in place
val shuffle_with : Random.State.t -> 'a t -> unitLike shuffle but using a specialized random state
val random_choose : 'a t -> 'a CCArray.random_genChoose an element randomly.
val to_seq : 'a t -> 'a CCArray.sequenceval to_gen : 'a t -> 'a CCArray.genval to_klist : 'a t -> 'a CCArray.klistPrint an array of items with printing function
Print an array, giving the printing function both index and item
val print :
?sep:string ->
(Format.formatter -> 'a -> unit) ->
Format.formatter ->
'a t ->
unitPrint an array of items with printing function
Filter elements out of the array. Only the elements satisfying the given predicate will be kept.
Map each element into another value, or discard it
val except_idx : 'a t -> int -> 'a listRemove given index, obtaining the list of the other elements
val (--) : int -> int -> int tRange array
val (--^) : int -> int -> int tRange array, excluding right bound
val random : 'a random_gen -> 'a t random_genval random_non_empty : 'a random_gen -> 'a t random_genval random_len : int -> 'a random_gen -> 'a t random_genA slice is a part of an array, that requires no copying and shares its storage with the original array.
All indexing in a slice is relative to the beginning of a slice, not to the underlying array (meaning a slice is effectively like a regular array)
module Sub = CCArray.Submodule type MONO_ARRAY = CCArray.MONO_ARRAYval sort_generic :
(module MONO_ARRAY with type elt = 'elt and type t = 'arr) ->
?cmp:('elt -> 'elt -> int) ->
'arr ->
unitSort the array, without allocating (eats stack space though). Performance might be lower than Array.sort.