1Array(3)                         OCaml library                        Array(3)
2
3
4

NAME

6       Array - Array operations.
7

Module

9       Module   Array
10

Documentation

12       Module Array
13        : sig end
14
15
16       Array operations.
17
18
19
20
21
22
23       val length : 'a array -> int
24
25       Return the length (number of elements) of the given array.
26
27
28
29       val get : 'a array -> int -> 'a
30
31
32       Array.get a n returns the element number n of array a .  The first ele‐
33       ment has number 0.  The last element has number Array.length a  -  1  .
34       You can also write a.(n) instead of Array.get a n .
35
36       Raise  Invalid_argument index out of bounds if n is outside the range 0
37       to (Array.length a - 1) .
38
39
40
41       val set : 'a array -> int -> 'a -> unit
42
43
44       Array.set a n x modifies array a in place, replacing element  number  n
45       with x .  You can also write a.(n) <- x instead of Array.set a n x .
46
47       Raise  Invalid_argument index out of bounds if n is outside the range 0
48       to Array.length a - 1 .
49
50
51
52       val make : int -> 'a -> 'a array
53
54
55       Array.make n x returns a fresh array of length n , initialized with x .
56       All  the elements of this new array are initially physically equal to x
57       (in the sense of the == predicate).  Consequently, if x is mutable,  it
58       is  shared among all elements of the array, and modifying x through one
59       of the array entries will modify all other entries at the same time.
60
61       Raise Invalid_argument if n < 0 or n > Sys.max_array_length .   If  the
62       value  of  x  is a floating-point number, then the maximum size is only
63       Sys.max_array_length / 2 .
64
65
66
67       val create : int -> 'a -> 'a array
68
69       Deprecated.
70
71       Array.create is an alias for Array.make .
72
73
74
75       val create_float : int -> float array
76
77
78       Array.create_float n returns a fresh float array of  length  n  ,  with
79       uninitialized data.
80
81
82       Since 4.03
83
84
85
86       val make_float : int -> float array
87
88       Deprecated.
89
90       Array.make_float is an alias for Array.create_float .
91
92
93
94       val init : int -> (int -> 'a) -> 'a array
95
96
97       Array.init  n f returns a fresh array of length n , with element number
98       i initialized to the result of f i .  In other terms,  Array.init  n  f
99       tabulates the results of f applied to the integers 0 to n-1 .
100
101       Raise  Invalid_argument  if n < 0 or n > Sys.max_array_length .  If the
102       return  type  of  f  is  float  ,  then  the  maximum  size   is   only
103       Sys.max_array_length / 2 .
104
105
106
107       val make_matrix : int -> int -> 'a -> 'a array array
108
109
110       Array.make_matrix dimx dimy e returns a two-dimensional array (an array
111       of arrays) with first dimension dimx and second dimension  dimy  .  All
112       the  elements  of this new matrix are initially physically equal to e .
113       The element ( x,y ) of  a  matrix  m  is  accessed  with  the  notation
114       m.(x).(y) .
115
116       Raise  Invalid_argument  if  dimx  or  dimy is negative or greater than
117       Sys.max_array_length .  If the value of e is a  floating-point  number,
118       then the maximum size is only Sys.max_array_length / 2 .
119
120
121
122       val create_matrix : int -> int -> 'a -> 'a array array
123
124       Deprecated.
125
126       Array.create_matrix is an alias for Array.make_matrix .
127
128
129
130       val append : 'a array -> 'a array -> 'a array
131
132
133       Array.append  v1  v2 returns a fresh array containing the concatenation
134       of the arrays v1 and v2 .
135
136
137
138       val concat : 'a array list -> 'a array
139
140       Same as Array.append , but concatenates a list of arrays.
141
142
143
144       val sub : 'a array -> int -> int -> 'a array
145
146
147       Array.sub a start len returns a fresh array of length len ,  containing
148       the elements number start to start + len - 1 of array a .
149
150       Raise  Invalid_argument  Array.sub  if start and len do not designate a
151       valid subarray of a ; that is, if start < 0 , or len < 0 , or  start  +
152       len > Array.length a .
153
154
155
156       val copy : 'a array -> 'a array
157
158
159       Array.copy  a  returns  a copy of a , that is, a fresh array containing
160       the same elements as a .
161
162
163
164       val fill : 'a array -> int -> int -> 'a -> unit
165
166
167       Array.fill a ofs len x modifies the array a in place, storing x in ele‐
168       ments number ofs to ofs + len - 1 .
169
170       Raise  Invalid_argument  Array.fill  if  ofs and len do not designate a
171       valid subarray of a .
172
173
174
175       val blit : 'a array -> int -> 'a array -> int -> int -> unit
176
177
178       Array.blit v1 o1 v2 o2 len copies len elements from array v1 , starting
179       at element number o1 , to array v2 , starting at element number o2 . It
180       works correctly even if v1 and v2 are the same array,  and  the  source
181       and destination chunks overlap.
182
183       Raise  Invalid_argument  Array.blit  if  o1  and len do not designate a
184       valid subarray of v1 , or if o2 and len do not designate a valid subar‐
185       ray of v2 .
186
187
188
189       val to_list : 'a array -> 'a list
190
191
192       Array.to_list a returns the list of all the elements of a .
193
194
195
196       val of_list : 'a list -> 'a array
197
198
199       Array.of_list l returns a fresh array containing the elements of l .
200
201
202
203
204       === Iterators ===
205
206
207       val iter : ('a -> unit) -> 'a array -> unit
208
209
210       Array.iter  f  a  applies function f in turn to all the elements of a .
211       It is equivalent to f a.(0); f a.(1); ...; f a.(Array.length a - 1); ()
212       .
213
214
215
216       val iteri : (int -> 'a -> unit) -> 'a array -> unit
217
218       Same  as Array.iter , but the function is applied with the index of the
219       element as first argument, and the element itself as second argument.
220
221
222
223       val map : ('a -> 'b) -> 'a array -> 'b array
224
225
226       Array.map f a applies function f to all the elements of a , and  builds
227       an  array  with the results returned by f : [| f a.(0); f a.(1); ...; f
228       a.(Array.length a - 1) |] .
229
230
231
232       val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array
233
234       Same as Array.map , but the function is applied to  the  index  of  the
235       element as first argument, and the element itself as second argument.
236
237
238
239       val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
240
241
242       Array.fold_left  f  x  a  computes  f  (...  (f (f x a.(0)) a.(1)) ...)
243       a.(n-1) , where n is the length of the array a .
244
245
246
247       val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
248
249
250       Array.fold_right f a x computes f a.(0) (f a.(1) ( ...  (f  a.(n-1)  x)
251       ...))  , where n is the length of the array a .
252
253
254
255
256       === Iterators on two arrays ===
257
258
259       val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit
260
261
262       Array.iter2  f  a b applies function f to all the elements of a and b .
263       Raise Invalid_argument if the arrays are not the same size.
264
265
266       Since 4.03.0
267
268
269
270       val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
271
272
273       Array.map2 f a b applies function f to all the elements of a  and  b  ,
274       and  builds an array with the results returned by f : [| f a.(0) b.(0);
275       ...; f a.(Array.length a  -  1)  b.(Array.length  b  -  1)|]  .   Raise
276       Invalid_argument if the arrays are not the same size.
277
278
279       Since 4.03.0
280
281
282
283
284       === Array scanning ===
285
286
287       val for_all : ('a -> bool) -> 'a array -> bool
288
289
290       Array.for_all  p  [|a1;  ...;  an|] checks if all elements of the array
291       satisfy the predicate p . That is, it returns (p a1) && (p a2)  &&  ...
292       && (p an) .
293
294
295       Since 4.03.0
296
297
298
299       val exists : ('a -> bool) -> 'a array -> bool
300
301
302       Array.exists  p  [|a1;  ...; an|] checks if at least one element of the
303       array satisfies the predicate p . That is, it returns (p a1) || (p  a2)
304       || ... || (p an) .
305
306
307       Since 4.03.0
308
309
310
311       val mem : 'a -> 'a array -> bool
312
313
314       mem a l is true if and only if a is equal to an element of l .
315
316
317       Since 4.03.0
318
319
320
321       val memq : 'a -> 'a array -> bool
322
323       Same  as  Array.mem  , but uses physical equality instead of structural
324       equality to compare array elements.
325
326
327       Since 4.03.0
328
329
330
331
332       === Sorting ===
333
334
335       val sort : ('a -> 'a -> int) -> 'a array -> unit
336
337       Sort an array in increasing order according to a  comparison  function.
338       The  comparison  function  must  return  0  if its arguments compare as
339       equal, a positive integer if the first is greater, and a negative inte‐
340       ger  if  the first is smaller (see below for a complete specification).
341       For example, Pervasives.compare is a suitable comparison function, pro‐
342       vided  there are no floating-point NaN values in the data.  After call‐
343       ing Array.sort , the array is sorted  in  place  in  increasing  order.
344       Array.sort  is  guaranteed  to run in constant heap space and (at most)
345       logarithmic stack space.
346
347       The current implementation uses Heap Sort.  It runs in  constant  stack
348       space.
349
350       Specification  of  the  comparison function: Let a be the array and cmp
351       the comparison function.  The following must be true for all x, y, z in
352       a :
353
354       - cmp x y > 0 if and only if cmp y x < 0
355
356       -  if cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0
357
358       When  Array.sort  returns,  a  contains  the  same  elements as before,
359       reordered in such a way that for all i and j valid indices of a :
360
361       - cmp a.(i) a.(j) >= 0 if and only if i >= j
362
363
364
365
366       val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
367
368       Same as Array.sort , but the sorting algorithm is  stable  (i.e.   ele‐
369       ments  that  compare  equal  are  kept in their original order) and not
370       guaranteed to run in constant heap space.
371
372       The current implementation uses Merge Sort. It uses n/2 words  of  heap
373       space,  where  n is the length of the array.  It is usually faster than
374       the current implementation of Array.sort .
375
376
377
378       val fast_sort : ('a -> 'a -> int) -> 'a array -> unit
379
380       Same as Array.sort or Array.stable_sort , whichever is faster on  typi‐
381       cal input.
382
383
384
385
386       === Iterators ===
387
388
389       val to_seq : 'a array -> 'a Seq.t
390
391       Iterate  on  the array, in increasing order. Modifications of the array
392       during iteration will be reflected in the iterator.
393
394
395       Since 4.07
396
397
398
399       val to_seqi : 'a array -> (int * 'a) Seq.t
400
401       Iterate on the array, in increasing order, yielding indices along  ele‐
402       ments.   Modifications  of the array during iteration will be reflected
403       in the iterator.
404
405
406       Since 4.07
407
408
409
410       val of_seq : 'a Seq.t -> 'a array
411
412       Create an array from the generator
413
414
415       Since 4.07
416
417
418
419
420
421OCamldoc                          2019-02-02                          Array(3)