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

NAME

6       ArrayLabels - Array operations
7

Module

9       Module   ArrayLabels
10

Documentation

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