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
24       val length : 'a array -> int
25
26       Return the length (number of elements) of the given array.
27
28
29
30
31       val get : 'a array -> int -> 'a
32
33
34       Array.get a n returns the element number n of array a .  The first ele‐
35       ment has number 0.  The last element has number Array.length a  -  1  .
36       You can also write a.(n) instead of Array.get a n .
37
38       Raise  Invalid_argument index out of bounds if n is outside the range 0
39       to (Array.length a - 1) .
40
41
42
43
44       val set : 'a array -> int -> 'a -> unit
45
46
47       Array.set a n x modifies array a in place, replacing element  number  n
48       with x .  You can also write a.(n) <- x instead of Array.set a n x .
49
50       Raise  Invalid_argument index out of bounds if n is outside the range 0
51       to Array.length a - 1 .
52
53
54
55
56       val make : int -> 'a -> 'a array
57
58
59       Array.make n x returns a fresh array of length n , initialized with x .
60       All  the elements of this new array are initially physically equal to x
61       (in the sense of the == predicate).  Consequently, if x is mutable,  it
62       is  shared among all elements of the array, and modifying x through one
63       of the array entries will modify all other entries at the same time.
64
65       Raise Invalid_argument if n < 0 or n > Sys.max_array_length .   If  the
66       value  of  x  is a floating-point number, then the maximum size is only
67       Sys.max_array_length / 2 .
68
69
70
71
72       val create : int -> 'a -> 'a array
73
74       Deprecated.
75
76       Array.create is an alias for Array.make .
77
78
79
80
81       val init : int -> (int -> 'a) -> 'a array
82
83
84       Array.init n f returns a fresh array of length n , with element  number
85       i  initialized  to  the result of f i .  In other terms, Array.init n f
86       tabulates the results of f applied to the integers 0 to n-1 .
87
88       Raise Invalid_argument if n < 0 or n > Sys.max_array_length .   If  the
89       return   type   of  f  is  float  ,  then  the  maximum  size  is  only
90       Sys.max_array_length / 2 .
91
92
93
94
95       val make_matrix : int -> int -> 'a -> 'a array array
96
97
98       Array.make_matrix dimx dimy e returns a two-dimensional array (an array
99       of  arrays)  with  first dimension dimx and second dimension dimy . All
100       the elements of this new matrix are initially physically equal to  e  .
101       The  element  (  x,y  )  of  a  matrix  m is accessed with the notation
102       m.(x).(y) .
103
104       Raise 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
111       val create_matrix : int -> int -> 'a -> 'a array array
112
113       Deprecated.
114
115       Array.create_matrix is an alias for Array.make_matrix .
116
117
118
119
120       val append : 'a array -> 'a array -> 'a array
121
122
123       Array.append v1 v2 returns a fresh array containing  the  concatenation
124       of the arrays v1 and v2 .
125
126
127
128
129       val concat : 'a array list -> 'a array
130
131       Same as Array.append , but concatenates a list of arrays.
132
133
134
135
136       val sub : 'a array -> int -> int -> 'a array
137
138
139       Array.sub  a start len returns a fresh array of length len , containing
140       the elements number start to start + len - 1 of array a .
141
142       Raise Invalid_argument Array.sub if start and len do  not  designate  a
143       valid  subarray  of a ; that is, if start < 0 , or len < 0 , or start +
144       len > Array.length a .
145
146
147
148
149       val copy : 'a array -> 'a array
150
151
152       Array.copy a returns a copy of a , that is, a  fresh  array  containing
153       the same elements as a .
154
155
156
157
158       val fill : 'a array -> int -> int -> 'a -> unit
159
160
161       Array.fill a ofs len x modifies the array a in place, storing x in ele‐
162       ments number ofs to ofs + len - 1 .
163
164       Raise Invalid_argument Array.fill if ofs and len  do  not  designate  a
165       valid subarray of a .
166
167
168
169
170       val blit : 'a array -> int -> 'a array -> int -> int -> unit
171
172
173       Array.blit v1 o1 v2 o2 len copies len elements from array v1 , starting
174       at element number o1 , to array v2 , starting at element number o2 . It
175       works  correctly  even  if v1 and v2 are the same array, and the source
176       and destination chunks overlap.
177
178       Raise Invalid_argument Array.blit if o1 and  len  do  not  designate  a
179       valid subarray of v1 , or if o2 and len do not designate a valid subar‐
180       ray of v2 .
181
182
183
184
185       val to_list : 'a array -> 'a list
186
187
188       Array.to_list a returns the list of all the elements of a .
189
190
191
192
193       val of_list : 'a list -> 'a array
194
195
196       Array.of_list l returns a fresh array containing the elements of l .
197
198
199
200
201       val iter : ('a -> unit) -> 'a array -> unit
202
203
204       Array.iter f a applies function f in turn to all the elements  of  a  .
205       It is equivalent to f a.(0); f a.(1); ...; f a.(Array.length a - 1); ()
206       .
207
208
209
210
211       val map : ('a -> 'b) -> 'a array -> 'b array
212
213
214       Array.map f a applies function f to all the elements of a , and  builds
215       an  array  with the results returned by f : [| f a.(0); f a.(1); ...; f
216       a.(Array.length a - 1) |] .
217
218
219
220
221       val iteri : (int -> 'a -> unit) -> 'a array -> unit
222
223       Same as Array.iter , but the function is applied to the  index  of  the
224       element as first argument, and the element itself as second argument.
225
226
227
228
229       val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array
230
231       Same  as  Array.map  ,  but the function is applied to the index of the
232       element as first argument, and the element itself as second argument.
233
234
235
236
237       val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
238
239
240       Array.fold_left f x a computes f  (...  (f  (f  x  a.(0))  a.(1))  ...)
241       a.(n-1) , where n is the length of the array a .
242
243
244
245
246       val fold_right : ('a -> 'b -> 'b) -> 'a array -> 'b -> 'b
247
248
249       Array.fold_right  f  a  x computes f a.(0) (f a.(1) ( ... (f a.(n-1) x)
250       ...))  , where n is the length of the array a .
251
252
253
254
255
256       === Sorting ===
257
258
259       val sort : ('a -> 'a -> int) -> 'a array -> unit
260
261       Sort an array in increasing order according to a  comparison  function.
262       The  comparison  function  must  return  0  if its arguments compare as
263       equal, a positive integer if the first is greater, and a negative inte‐
264       ger  if  the first is smaller (see below for a complete specification).
265       For example, Pervasives.compare is a suitable comparison function, pro‐
266       vided  there are no floating-point NaN values in the data.  After call‐
267       ing Array.sort , the array is sorted  in  place  in  increasing  order.
268       Array.sort  is  guaranteed  to run in constant heap space and (at most)
269       logarithmic stack space.
270
271       The current implementation uses Heap Sort.  It runs in  constant  stack
272       space.
273
274       Specification  of  the  comparison function: Let a be the array and cmp
275       the comparison function.  The following must be true for all x, y, z in
276       a :
277
278       - cmp x y > 0 if and only if cmp y x < 0
279
280       -  if cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0
281
282       When  Array.sort  returns,  a  contains  the  same  elements as before,
283       reordered in such a way that for all i and j valid indices of a :
284
285       - cmp a.(i) a.(j) >= 0 if and only if i >= j
286
287
288
289
290
291       val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
292
293       Same as Array.sort , but the sorting algorithm is  stable  (i.e.   ele‐
294       ments  that  compare  equal  are  kept in their original order) and not
295       guaranteed to run in constant heap space.
296
297       The current implementation uses Merge Sort. It uses n/2 words  of  heap
298       space,  where  n is the length of the array.  It is usually faster than
299       the current implementation of Array.sort .
300
301
302
303
304       val fast_sort : ('a -> 'a -> int) -> 'a array -> unit
305
306       Same as Array.sort or Array.stable_sort , whichever is faster on  typi‐
307       cal input.
308
309
310
311
312
313
314OCamldoc                          2007-05-24                          Array(3)