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

NAME

6       Stdlib.ArrayLabels - no description
7

Module

9       Module   Stdlib.ArrayLabels
10

Documentation

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