Module CCArray_slice

The empty array slice.

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).

get_safe a i returns Some a.(i) if i is a valid index.

• Since: 0.18

Create a slice from given offset and length.

• Raises Invalid_argument: if the slice isn't valid.

Make a sub-array from a triple (arr, i, len) where arr is the array, i the offset in arr, and len the number of elements of the slice.

• Raises Invalid_argument: if the slice isn't valid (See make).

Convert into a triple (arr, i, len) where len is the length of the sub-array of arr starting at offset i.

Convert directly to a list.

• Since: 1.0

Slice that covers the full array.

Underlying array (shared). Modifying this array will modify the slice.

Copy into a new array.

Sub-slice.

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.

Return the length (number of elements) of the given array.

fold f x a computes f (... (f (f x a.(0)) a.(1)) ...) a.(n-1), where n is the length of the array a.

Fold left on array, with index.

Fold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator.

• Since: 0.8

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); ().

Like Array.iter, but the function is applied with the index of the element as first argument, and the element itself as second argument.

blit v1 o1 v2 o2 len copies len elements from array v1, starting at element number o1, to array v2, starting at element number o2. It works correctly even if v1 and v2 are the same array, and the source and destination chunks overlap.

Raise Invalid_argument "Array.blit" if o1 and len do not designate a valid subarray of v1, or if o2 and len do not designate a valid subarray of v2.

Reverse the array in place.

sorted cmp a makes a copy of a and sorts it with cmp.

• Since: 1.0

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.

• Since: 1.0

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-the 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).

• Since: 1.0

find f a returns Some y if there is an element x such that f x = Some y, else it returns None.

Like find, but also pass the index to the predicate function.

• Since: 0.3.4

find_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds. Otherwise returns None.

• Since: 0.3.4

Lookup the index of some value in a sorted array.

• Returns None if the key is not present, or Some i (i the index of the key) otherwise.

Like lookup, but

• Raises Not_found: if the key is not present.

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).

• Returns

  • `At i if cmp arr.(i) x = 0 (for some i).
  • `All_lower if all elements of arr are lower than x.
  • `All_bigger if all elements of arr are bigger than x.
  • `Just_after i if arr.(i) < x < arr.(i+1).
  • `Empty if the array is empty.
• Raises Invalid_argument: if the array is found to be unsorted w.r.t cmp.
• Since: 0.13

for_all p [|a1; ...; an|] checks if all elements of the array satisfy the predicate p. That is, it returns (p a1) && (p a2) && ... && (p an).

Forall on pairs of arrays.

• Raises Invalid_argument: if they have distinct lengths. Allow different types.
• Since: 0.20

exists p [|a1; ...; an|] checks if at least one element of the array satisfies the predicate p. That is, it returns (p a1) || (p a2) || ... || (p an).

Exists on pairs of arrays.

• Raises Invalid_argument: if they have distinct lengths. Allow different types.
• Since: 0.20

Fold on two arrays stepwise.

• Raises Invalid_argument: if they have distinct lengths.
• Since: 0.20

Iterate on two arrays stepwise.

• Raises Invalid_argument: if they have distinct lengths.
• Since: 0.20

Shuffle randomly the array, in place.

Like shuffle but using a specialized random state.

Choose an element randomly.

• Raises Not_found: if the array/slice is empty.

Return a sequence of the elements of a slice.

Return a gen of the elements of a slice.

Return a klist of the elements of a slice.

Print an array of items with printing function.

Print an array, giving the printing function both index and item.