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

NAME

6       Array - no description
7

Module

9       Module   Array
10

Documentation

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