<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="Start" href="index.html">
<link rel="previous" href="Arith_status.html">
<link rel="next" href="ArrayLabels.html">
<link rel="Up" href="index.html">
<link title="Index of types" rel=Appendix href="index_types.html">
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
<link title="Index of values" rel=Appendix href="index_values.html">
<link title="Index of modules" rel=Appendix href="index_modules.html">
<link title="Index of module types" rel=Appendix href="index_module_types.html">
<link title="Arg" rel="Chapter" href="Arg.html">
<link title="Arith_status" rel="Chapter" href="Arith_status.html">
<link title="Array" rel="Chapter" href="Array.html">
<link title="ArrayLabels" rel="Chapter" href="ArrayLabels.html">
<link title="Big_int" rel="Chapter" href="Big_int.html">
<link title="Bigarray" rel="Chapter" href="Bigarray.html">
<link title="Buffer" rel="Chapter" href="Buffer.html">
<link title="Callback" rel="Chapter" href="Callback.html">
<link title="CamlinternalOO" rel="Chapter" href="CamlinternalOO.html">
<link title="Char" rel="Chapter" href="Char.html">
<link title="Complex" rel="Chapter" href="Complex.html">
<link title="Condition" rel="Chapter" href="Condition.html">
<link title="Dbm" rel="Chapter" href="Dbm.html">
<link title="Digest" rel="Chapter" href="Digest.html">
<link title="Dynlink" rel="Chapter" href="Dynlink.html">
<link title="Event" rel="Chapter" href="Event.html">
<link title="Filename" rel="Chapter" href="Filename.html">
<link title="Format" rel="Chapter" href="Format.html">
<link title="Gc" rel="Chapter" href="Gc.html">
<link title="Genlex" rel="Chapter" href="Genlex.html">
<link title="Graphics" rel="Chapter" href="Graphics.html">
<link title="GraphicsX11" rel="Chapter" href="GraphicsX11.html">
<link title="Hashtbl" rel="Chapter" href="Hashtbl.html">
<link title="Int32" rel="Chapter" href="Int32.html">
<link title="Int64" rel="Chapter" href="Int64.html">
<link title="Lazy" rel="Chapter" href="Lazy.html">
<link title="Lexing" rel="Chapter" href="Lexing.html">
<link title="List" rel="Chapter" href="List.html">
<link title="ListLabels" rel="Chapter" href="ListLabels.html">
<link title="Map" rel="Chapter" href="Map.html">
<link title="Marshal" rel="Chapter" href="Marshal.html">
<link title="MoreLabels" rel="Chapter" href="MoreLabels.html">
<link title="Mutex" rel="Chapter" href="Mutex.html">
<link title="Nativeint" rel="Chapter" href="Nativeint.html">
<link title="Num" rel="Chapter" href="Num.html">
<link title="Obj" rel="Chapter" href="Obj.html">
<link title="Oo" rel="Chapter" href="Oo.html">
<link title="Parsing" rel="Chapter" href="Parsing.html">
<link title="Pervasives" rel="Chapter" href="Pervasives.html">
<link title="Printexc" rel="Chapter" href="Printexc.html">
<link title="Printf" rel="Chapter" href="Printf.html">
<link title="Queue" rel="Chapter" href="Queue.html">
<link title="Random" rel="Chapter" href="Random.html">
<link title="Scanf" rel="Chapter" href="Scanf.html">
<link title="Set" rel="Chapter" href="Set.html">
<link title="Sort" rel="Chapter" href="Sort.html">
<link title="Stack" rel="Chapter" href="Stack.html">
<link title="StdLabels" rel="Chapter" href="StdLabels.html">
<link title="Str" rel="Chapter" href="Str.html">
<link title="Stream" rel="Chapter" href="Stream.html">
<link title="String" rel="Chapter" href="String.html">
<link title="StringLabels" rel="Chapter" href="StringLabels.html">
<link title="Sys" rel="Chapter" href="Sys.html">
<link title="Thread" rel="Chapter" href="Thread.html">
<link title="ThreadUnix" rel="Chapter" href="ThreadUnix.html">
<link title="Tk" rel="Chapter" href="Tk.html">
<link title="Unix" rel="Chapter" href="Unix.html">
<link title="UnixLabels" rel="Chapter" href="UnixLabels.html">
<link title="Weak" rel="Chapter" href="Weak.html"><link title="Sorting" rel="Section" href="#6_Sorting">
<title>Array</title>
</head>
<body>
<div class="navbar"><a href="Arith_status.html">Previous</a>
<a href="index.html">Up</a>
<a href="ArrayLabels.html">Next</a>
</div>
<center><h1>Module <a href="type_Array.html">Array</a></h1></center>
<br>
<pre><span class="keyword">module</span> Array: <code class="type">sig end</code></pre><div class="info">
Array operations.<br>
</div>
<hr width="100%">
<pre><span class="keyword">val</span> <a name="VALlength"></a>length : <code class="type">'a array -> int</code></pre><div class="info">
Return the length (number of elements) of the given array.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALget"></a>get : <code class="type">'a array -> int -> 'a</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.get a n</code> returns the element number <code class="code">n</code> of array <code class="code">a</code>.
The first element has number 0.
The last element has number <code class="code"><span class="constructor">Array</span>.length a - 1</code>.
<p>
Raise <code class="code"><span class="constructor">Invalid_argument</span> <span class="string">"Array.get"</span></code> if <code class="code">n</code> is outside the range
0 to <code class="code">(<span class="constructor">Array</span>.length a - 1)</code>.
You can also write <code class="code">a.(n)</code> instead of <code class="code"><span class="constructor">Array</span>.get a n</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALset"></a>set : <code class="type">'a array -> int -> 'a -> unit</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.set a n x</code> modifies array <code class="code">a</code> in place, replacing
element number <code class="code">n</code> with <code class="code">x</code>.
<p>
Raise <code class="code"><span class="constructor">Invalid_argument</span> <span class="string">"Array.set"</span></code> if <code class="code">n</code> is outside the range
0 to <code class="code"><span class="constructor">Array</span>.length a - 1</code>.
You can also write <code class="code">a.(n) <- x</code> instead of <code class="code"><span class="constructor">Array</span>.set a n x</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALmake"></a>make : <code class="type">int -> 'a -> 'a array</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.make n x</code> returns a fresh array of length <code class="code">n</code>,
initialized with <code class="code">x</code>.
All the elements of this new array are initially
physically equal to <code class="code">x</code> (in the sense of the <code class="code">==</code> predicate).
Consequently, if <code class="code">x</code> is mutable, it is shared among all elements
of the array, and modifying <code class="code">x</code> through one of the array entries
will modify all other entries at the same time.
<p>
Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">n < 0</code> or <code class="code">n > <span class="constructor">Sys</span>.max_array_length</code>.
If the value of <code class="code">x</code> is a floating-point number, then the maximum
size is only <code class="code"><span class="constructor">Sys</span>.max_array_length / 2</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALcreate"></a>create : <code class="type">int -> 'a -> 'a array</code></pre><div class="info">
<span class="warning">Deprecated.</span> <code class="code"><span class="constructor">Array</span>.create</code> is an alias for <a href="Array.html#VALmake"><code class="code"><span class="constructor">Array</span>.make</code></a>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALinit"></a>init : <code class="type">int -> (int -> 'a) -> 'a array</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.init n f</code> returns a fresh array of length <code class="code">n</code>,
with element number <code class="code">i</code> initialized to the result of <code class="code">f i</code>.
In other terms, <code class="code"><span class="constructor">Array</span>.init n f</code> tabulates the results of <code class="code">f</code>
applied to the integers <code class="code">0</code> to <code class="code">n-1</code>.
<p>
Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">n < 0</code> or <code class="code">n > <span class="constructor">Sys</span>.max_array_length</code>.
If the return type of <code class="code">f</code> is <code class="code">float</code>, then the maximum
size is only <code class="code"><span class="constructor">Sys</span>.max_array_length / 2</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALmake_matrix"></a>make_matrix : <code class="type">int -> int -> 'a -> 'a array array</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.make_matrix dimx dimy e</code> returns a two-dimensional array
(an array of arrays) with first dimension <code class="code">dimx</code> and
second dimension <code class="code">dimy</code>. All the elements of this new matrix
are initially physically equal to <code class="code">e</code>.
The element (<code class="code">x,y</code>) of a matrix <code class="code">m</code> is accessed
with the notation <code class="code">m.(x).(y)</code>.
<p>
Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">dimx</code> or <code class="code">dimy</code> is negative or
greater than <code class="code"><span class="constructor">Sys</span>.max_array_length</code>.
If the value of <code class="code">e</code> is a floating-point number, then the maximum
size is only <code class="code"><span class="constructor">Sys</span>.max_array_length / 2</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALcreate_matrix"></a>create_matrix : <code class="type">int -> int -> 'a -> 'a array array</code></pre><div class="info">
<span class="warning">Deprecated.</span> <code class="code"><span class="constructor">Array</span>.create_matrix</code> is an alias for <a href="Array.html#VALmake_matrix"><code class="code"><span class="constructor">Array</span>.make_matrix</code></a>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALappend"></a>append : <code class="type">'a array -> 'a array -> 'a array</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.append v1 v2</code> returns a fresh array containing the
concatenation of the arrays <code class="code">v1</code> and <code class="code">v2</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALconcat"></a>concat : <code class="type">'a array list -> 'a array</code></pre><div class="info">
Same as <code class="code"><span class="constructor">Array</span>.append</code>, but concatenates a list of arrays.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALsub"></a>sub : <code class="type">'a array -> int -> int -> 'a array</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.sub a start len</code> returns a fresh array of length <code class="code">len</code>,
containing the elements number <code class="code">start</code> to <code class="code">start + len - 1</code>
of array <code class="code">a</code>.
<p>
Raise <code class="code"><span class="constructor">Invalid_argument</span> <span class="string">"Array.sub"</span></code> if <code class="code">start</code> and <code class="code">len</code> do not
designate a valid subarray of <code class="code">a</code>; that is, if
<code class="code">start < 0</code>, or <code class="code">len < 0</code>, or <code class="code">start + len > <span class="constructor">Array</span>.length a</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALcopy"></a>copy : <code class="type">'a array -> 'a array</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.copy a</code> returns a copy of <code class="code">a</code>, that is, a fresh array
containing the same elements as <code class="code">a</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALfill"></a>fill : <code class="type">'a array -> int -> int -> 'a -> unit</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.fill a ofs len x</code> modifies the array <code class="code">a</code> in place,
storing <code class="code">x</code> in elements number <code class="code">ofs</code> to <code class="code">ofs + len - 1</code>.
<p>
Raise <code class="code"><span class="constructor">Invalid_argument</span> <span class="string">"Array.fill"</span></code> if <code class="code">ofs</code> and <code class="code">len</code> do not
designate a valid subarray of <code class="code">a</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALblit"></a>blit : <code class="type">'a array -> int -> 'a array -> int -> int -> unit</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.blit v1 o1 v2 o2 len</code> copies <code class="code">len</code> elements
from array <code class="code">v1</code>, starting at element number <code class="code">o1</code>, to array <code class="code">v2</code>,
starting at element number <code class="code">o2</code>. It works correctly even if
<code class="code">v1</code> and <code class="code">v2</code> are the same array, and the source and
destination chunks overlap.
<p>
Raise <code class="code"><span class="constructor">Invalid_argument</span> <span class="string">"Array.blit"</span></code> if <code class="code">o1</code> and <code class="code">len</code> do not
designate a valid subarray of <code class="code">v1</code>, or if <code class="code">o2</code> and <code class="code">len</code> do not
designate a valid subarray of <code class="code">v2</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALto_list"></a>to_list : <code class="type">'a array -> 'a list</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.to_list a</code> returns the list of all the elements of <code class="code">a</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALof_list"></a>of_list : <code class="type">'a list -> 'a array</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.of_list l</code> returns a fresh array containing the elements
of <code class="code">l</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALiter"></a>iter : <code class="type">('a -> unit) -> 'a array -> unit</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.iter f a</code> applies function <code class="code">f</code> in turn to all
the elements of <code class="code">a</code>. It is equivalent to
<code class="code">f a.(0); f a.(1); ...; f a.(<span class="constructor">Array</span>.length a - 1); ()</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALmap"></a>map : <code class="type">('a -> 'b) -> 'a array -> 'b array</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.map f a</code> applies function <code class="code">f</code> to all the elements of <code class="code">a</code>,
and builds an array with the results returned by <code class="code">f</code>:
<code class="code">[| f a.(0); f a.(1); ...; f a.(<span class="constructor">Array</span>.length a - 1) |]</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALiteri"></a>iteri : <code class="type">(int -> 'a -> unit) -> 'a array -> unit</code></pre><div class="info">
Same as <a href="Array.html#VALiter"><code class="code"><span class="constructor">Array</span>.iter</code></a>, but the
function is applied to the index of the element as first argument,
and the element itself as second argument.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALmapi"></a>mapi : <code class="type">(int -> 'a -> 'b) -> 'a array -> 'b array</code></pre><div class="info">
Same as <a href="Array.html#VALmap"><code class="code"><span class="constructor">Array</span>.map</code></a>, but the
function is applied to the index of the element as first argument,
and the element itself as second argument.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALfold_left"></a>fold_left : <code class="type">('a -> 'b -> 'a) -> 'a -> 'b array -> 'a</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.fold_left f x a</code> computes
<code class="code">f (... (f (f x a.(0)) a.(1)) ...) a.(n-1)</code>,
where <code class="code">n</code> is the length of the array <code class="code">a</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALfold_right"></a>fold_right : <code class="type">('a -> 'b -> 'b) -> 'a array -> 'b -> 'b</code></pre><div class="info">
<code class="code"><span class="constructor">Array</span>.fold_right f a x</code> computes
<code class="code">f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...))</code>,
where <code class="code">n</code> is the length of the array <code class="code">a</code>.<br>
</div>
<br>
<br>
<a name="6_Sorting"></a>
<table cellpadding=5 cellspacing=5 width="100%">
<tr class="title6"><td><div align=center>
<span class="title6">Sorting</span>
</div>
</td>
</tr>
</table>
<br><br>
<pre><span class="keyword">val</span> <a name="VALsort"></a>sort : <code class="type">('a -> 'a -> int) -> 'a array -> unit</code></pre><div class="info">
Sort an array in increasing order according to a comparison
function. The comparison function must return 0 if its arguments
compare as equal, a positive integer if the first is greater,
and a negative integer if the first is smaller (see below for a
complete specification). For example, <a href="Pervasives.html#VALcompare"><code class="code"><span class="constructor">Pervasives</span>.compare</code></a> is
a suitable comparison function, provided there are no floating-point
NaN values in the data. After calling <code class="code"><span class="constructor">Array</span>.sort</code>, the
array is sorted in place in increasing order.
<code class="code"><span class="constructor">Array</span>.sort</code> is guaranteed to run in constant heap space
and (at most) logarithmic stack space.
<p>
The current implementation uses Heap Sort. It runs in constant
stack space.
<p>
Specification of the comparison function:
Let <code class="code">a</code> be the array and <code class="code">cmp</code> the comparison function. The following
must be true for all x, y, z in a :<ul>
<li> <code class="code">cmp x y</code> > 0 if and only if <code class="code">cmp y x</code> < 0</li>
<li> if <code class="code">cmp x y</code> >= 0 and <code class="code">cmp y z</code> >= 0 then <code class="code">cmp x z</code> >= 0</li>
</ul>
When <code class="code"><span class="constructor">Array</span>.sort</code> returns, <code class="code">a</code> contains the same elements as before,
reordered in such a way that for all i and j valid indices of <code class="code">a</code> :<ul>
<li> <code class="code">cmp a.(i) a.(j)</code> >= 0 if and only if i >= j</li>
</ul>
<br>
</div>
<pre><span class="keyword">val</span> <a name="VALstable_sort"></a>stable_sort : <code class="type">('a -> 'a -> int) -> 'a array -> unit</code></pre><div class="info">
Same as <a href="Array.html#VALsort"><code class="code"><span class="constructor">Array</span>.sort</code></a>, but the sorting algorithm is stable (i.e.
elements that compare equal are kept in their original order) and
not guaranteed to run in constant heap space.
<p>
The current implementation uses Merge Sort. It uses <code class="code">n/2</code>
words of heap space, where <code class="code">n</code> is the length of the array.
It is usually faster than the current implementation of <a href="Array.html#VALsort"><code class="code"><span class="constructor">Array</span>.sort</code></a>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALfast_sort"></a>fast_sort : <code class="type">('a -> 'a -> int) -> 'a array -> unit</code></pre><div class="info">
Same as <a href="Array.html#VALsort"><code class="code"><span class="constructor">Array</span>.sort</code></a> or <a href="Array.html#VALstable_sort"><code class="code"><span class="constructor">Array</span>.stable_sort</code></a>, whichever is faster
on typical input.<br>
</div>
</body></html>
