Previous  Up  Next

Module Hash_queue.Array

module Array: Core_array
type 'a t = 'a array 
include Container.S1
val max_length : int
Maximum length of a normal array. The maximum length of a float array is max_length/2 on 32-bit machines and max_length on 64-bit machines.
val get : 'a t -> int -> 'a
Array.get a n returns the element number n of array a. The first element has number 0. The last element has number Array.length a - 1. You can also write a.(n) instead of Array.get a n.

Raise Invalid_argument "index out of bounds" if n is outside the range 0 to (Array.length a - 1).

val set : 'a t -> int -> 'a -> unit
Array.set a n x modifies array a in place, replacing element number n with x. You can also write a.(n) <- x instead of Array.set a n x.

Raise Invalid_argument "index out of bounds" if n is outside the range 0 to Array.length a - 1.

val unsafe_get : 'a t -> int -> 'a
Unsafe version of get. Can cause arbitrary behavior when used to for an out-of-bounds array access
val unsafe_set : 'a t -> int -> 'a -> unit
Unsafe version of set. Can cause arbitrary behavior when used to for an out-of-bounds array access
val create : len:int -> 'a -> 'a t
create ~len x creates an array of length len with the value x populated in each element
val init : int -> f:(int -> 'a) -> 'a t
init n ~f creates an array of length n where the ith element is initialized with f i (starting at zero)
val make_matrix : dimx:int -> dimy:int -> 'a -> 'a t t
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.

val append : 'a t -> 'a t -> 'a t
Array.append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.
val concat : 'a t list -> 'a t
Same as Array.append, but concatenates a list of arrays.
type 'a sub = 'a t -> pos:int -> len:int -> 'a t
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.

int_sub and float_sub provide fast bound-checked blit copying for immediate data types.

val sub : 'a sub
val int_sub : int sub
val float_sub : float sub
val copy : 'a t -> 'a t
Array.copy a returns a copy of a, that is, a fresh array containing the same elements as a.
val fill : 'a t -> pos:int -> len:int -> 'a -> unit
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.

val blit : src:'a t ->
       src_pos:int -> dst:'a t -> dst_pos:int -> len:int -> unit
Array.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.

int_blit and float_blit provide fast bound-checked blits for immediate data types. The unsafe versions do not bound-check the arguments.

val int_blit : src:int t ->
       src_pos:int -> dst:int t -> dst_pos:int -> len:int -> unit
val float_blit : src:float t ->
       src_pos:int -> dst:float t -> dst_pos:int -> len:int -> unit
val unsafe_int_blit : src:int t ->
       src_pos:int -> dst:int t -> dst_pos:int -> len:int -> unit
val unsafe_float_blit : src:float t ->
       src_pos:int -> dst:float t -> dst_pos:int -> len:int -> unit
val of_list : 'a list -> 'a t
Array.of_list l returns a fresh array containing the elements of l.
val map : f:('a -> 'b) -> 'a t -> 'b t
Array.map ~f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |].
val iteri : f:(int -> 'a -> unit) -> 'a t -> 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 mapi : f:(int -> 'a -> 'b) -> 'a t -> 'b t
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.
val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b
val fold_right : 'a t -> f:('a -> 'b -> 'b) -> init:'b -> 'b
Array.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.
val sort : ?pos:int -> ?len:int -> 'a t -> cmp:('a -> 'a -> int) -> unit
val stable_sort : 'a t -> cmp:('a -> 'a -> int) -> unit
val is_sorted : 'a t -> cmp:('a -> 'a -> int) -> bool
val concat_map : 'a t -> f:('a -> 'b array) -> 'b array
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val partitioni_tf : 'a t -> f:(int -> 'a -> bool) -> 'a t * 'a t
val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
val normalize : 'a t -> int -> int
normalize array index returns a new index into the array such that if index is less than zero, the returned index will "wrap around" -- i.e. array.(normalize array (-1)) returns the last element of the array.
val slice : 'a t -> int -> int -> 'a t
slice array start stop returns a fresh array including elements array.(start) through array.(stop-1) with the small tweak that the start and stop positions are normalized and a stop index of 0 means the same thing a stop index of Array.length array. In summary, it's mostly like the slicing in Python or Matlab. One difference is that a stop value of 0 here is like not specifying a stop value in Python.
val nget : 'a t -> int -> 'a
Array access with normalized index.
val nset : 'a t -> int -> 'a -> unit
Array modification with normalized index.
val filter_opt : 'a option t -> 'a t
filter_opt array returns a new array where None entries are omitted and Some x entries are replaced with x. Note that this changes the index at which elements will appear.
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
filter_map ~f array maps f over array and filters None out of the results.
val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t
Same as filter_map but uses Array.mapi.
val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
val map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
val fold2_exn : 'a t ->
       'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
val for_all2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool
for_all2 t1 t2 ~f fails if length t1 <> length t2.
val filter : f:('a -> bool) -> 'a t -> 'a t
filter ~f array removes the elements for which f returns false.
val filteri : f:(int -> 'a -> bool) -> 'a t -> 'a t
Like filter except f also receives the index.
val swap : 'a t -> int -> int -> unit
swap arr i j swaps the value at index i with that at index j.
val rev_inplace : 'a t -> unit
rev_inplace t reverses t in place
val of_list_rev : 'a list -> 'a t
of_list_rev l converts from list then reverses in place
val of_list_map : 'a list -> f:('a -> 'b) -> 'b t
of_list_map l ~f is the same as of_list (List.map l ~f)
val of_list_rev_map : 'a list -> f:('a -> 'b) -> 'b t
of_list_rev_map l ~f is the same as rev_inplace (of_list_map l ~f)
val replace : 'a t -> int -> f:('a -> 'a) -> unit
replace t i ~f = t.(i) <- f (t.(i)).
val replace_all : 'a t -> f:('a -> 'a) -> unit
modifies an array in place -- ar.(i) will be set to f(ar.(i))
val find_exn : 'a t -> f:('a -> bool) -> 'a
find_exn f t returns the first a in t for which f t.(i) is true. It raises Not_found if there is no such a.
val findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option
findi t f returns the first index i of t for which f i t.(i) is true
val findi_exn : 'a t -> f:(int -> 'a -> bool) -> int * 'a
findi_exn t f returns the first index i of t for which f i t.(i) is true. It raises Not_found if there is no such element.
val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option
reduce f [a1; ...; an] is Some (f (... (f (f a1 a2) a3) ...) an). Returns None on the empty array.
val reduce_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a
val permute : ?random_state:Core_random.State.t -> 'a t -> unit
permute ?random_state t randomly permutes t in place.

permute side affects random_state by repeated calls to Random.State.int. If random_state is not supplied, permute uses Random.State.default.

val combine : 'a t -> 'b t -> ('a * 'b) t
combine ar combines two arrays to an array of pairs.
val split : ('a * 'b) t -> 'a t * 'b t
split ar splits an array of pairs into two arrays of single elements.
val sorted_copy : 'a t -> cmp:('a -> 'a -> int) -> 'a t
sorted_copy ar cmp returns a shallow copy of ar that is sorted. Similar to List.sort
val last : 'a t -> 'a
val empty : unit -> 'a t
empty () creates an empty array
val equal : 'a t -> 'a t -> equal:('a -> 'a -> bool) -> bool
module Infix: sig .. end
val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t : 'a Bin_prot.Unsafe_read_c.reader -> 'a t Bin_prot.Read_ml.reader
val bin_read_t_ : 'a Bin_prot.Unsafe_read_c.reader ->
       'a t Bin_prot.Unsafe_read_c.reader
val bin_read_t__ : 'a Bin_prot.Unsafe_read_c.reader ->
       (int -> 'a t) Bin_prot.Unsafe_read_c.reader
val bin_reader_t : 'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader
val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t : 'a Bin_prot.Unsafe_write_c.writer -> 'a t Bin_prot.Write_ml.writer
val bin_write_t_ : 'a Bin_prot.Unsafe_write_c.writer ->
       'a t Bin_prot.Unsafe_write_c.writer
val bin_writer_t : 'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer

Maximum length of a normal array. The maximum length of a float array is max_length/2 on 32-bit machines and max_length on 64-bit machines.

Array.get a n returns the element number n of array a. The first element has number 0. The last element has number Array.length a - 1. You can also write a.(n) instead of Array.get a n.

Raise Invalid_argument "index out of bounds" if n is outside the range 0 to (Array.length a - 1).

Array.set a n x modifies array a in place, replacing element number n with x. You can also write a.(n) <- x instead of Array.set a n x.

Raise Invalid_argument "index out of bounds" if n is outside the range 0 to Array.length a - 1.

Unsafe version of get. Can cause arbitrary behavior when used to for an out-of-bounds array access

Unsafe version of set. Can cause arbitrary behavior when used to for an out-of-bounds array access

create ~len x creates an array of length len with the value x populated in each element

init n ~f creates an array of length n where the ith element is initialized with f i (starting at zero)

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.

int_sub and float_sub provide fast bound-checked blit copying for immediate data types.

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

int_blit and float_blit provide fast bound-checked blits for immediate data types. The unsafe versions do not bound-check the arguments.

Array.of_list l returns a fresh array containing the elements of l.

Array.map ~f a applies function f to all the elements of a, and builds an array with the results returned by f: [| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |].

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.

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

normalize array index returns a new index into the array such that if index is less than zero, the returned index will "wrap around" -- i.e. array.(normalize array (-1)) returns the last element of the array.

slice array start stop returns a fresh array including elements array.(start) through array.(stop-1) with the small tweak that the start and stop positions are normalized and a stop index of 0 means the same thing a stop index of Array.length array. In summary, it's mostly like the slicing in Python or Matlab. One difference is that a stop value of 0 here is like not specifying a stop value in Python.

Array access with normalized index.

Array modification with normalized index.

filter_opt array returns a new array where None entries are omitted and Some x entries are replaced with x. Note that this changes the index at which elements will appear.

filter_map ~f array maps f over array and filters None out of the results.

Same as filter_map but uses Array.mapi.

for_all2 t1 t2 ~f fails if length t1 <> length t2.

filter ~f array removes the elements for which f returns false.

Like filter except f also receives the index.

swap arr i j swaps the value at index i with that at index j.

rev_inplace t reverses t in place

of_list_rev l converts from list then reverses in place

of_list_map l ~f is the same as of_list (List.map l ~f)

of_list_rev_map l ~f is the same as rev_inplace (of_list_map l ~f)

replace t i ~f = t.(i) <- f (t.(i)).

modifies an array in place -- ar.(i) will be set to f(ar.(i))

find_exn f t returns the first a in t for which f t.(i) is true. It raises Not_found if there is no such a.

findi t f returns the first index i of t for which f i t.(i) is true

findi_exn t f returns the first index i of t for which f i t.(i) is true. It raises Not_found if there is no such element.

reduce f [a1; ...; an] is Some (f (... (f (f a1 a2) a3) ...) an). Returns None on the empty array.

permute ?random_state t randomly permutes t in place.

permute side affects random_state by repeated calls to Random.State.int. If random_state is not supplied, permute uses Random.State.default.

combine ar combines two arrays to an array of pairs.

split ar splits an array of pairs into two arrays of single elements.

sorted_copy ar cmp returns a shallow copy of ar that is sorted. Similar to List.sort

empty () creates an empty array