<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="Start" href="index.html">
<link rel="previous" href="Array.html">
<link rel="next" href="Ast_helper.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="Arg_helper" rel="Chapter" href="Arg_helper.html">
<link title="Array" rel="Chapter" href="Array.html">
<link title="ArrayLabels" rel="Chapter" href="ArrayLabels.html">
<link title="Ast_helper" rel="Chapter" href="Ast_helper.html">
<link title="Ast_invariants" rel="Chapter" href="Ast_invariants.html">
<link title="Ast_iterator" rel="Chapter" href="Ast_iterator.html">
<link title="Ast_mapper" rel="Chapter" href="Ast_mapper.html">
<link title="Asttypes" rel="Chapter" href="Asttypes.html">
<link title="Attr_helper" rel="Chapter" href="Attr_helper.html">
<link title="Bigarray" rel="Chapter" href="Bigarray.html">
<link title="Buffer" rel="Chapter" href="Buffer.html">
<link title="Build_path_prefix_map" rel="Chapter" href="Build_path_prefix_map.html">
<link title="Builtin_attributes" rel="Chapter" href="Builtin_attributes.html">
<link title="Bytes" rel="Chapter" href="Bytes.html">
<link title="BytesLabels" rel="Chapter" href="BytesLabels.html">
<link title="Callback" rel="Chapter" href="Callback.html">
<link title="CamlinternalFormat" rel="Chapter" href="CamlinternalFormat.html">
<link title="CamlinternalFormatBasics" rel="Chapter" href="CamlinternalFormatBasics.html">
<link title="CamlinternalLazy" rel="Chapter" href="CamlinternalLazy.html">
<link title="CamlinternalMod" rel="Chapter" href="CamlinternalMod.html">
<link title="CamlinternalOO" rel="Chapter" href="CamlinternalOO.html">
<link title="Ccomp" rel="Chapter" href="Ccomp.html">
<link title="Char" rel="Chapter" href="Char.html">
<link title="Clflags" rel="Chapter" href="Clflags.html">
<link title="Complex" rel="Chapter" href="Complex.html">
<link title="Condition" rel="Chapter" href="Condition.html">
<link title="Config" rel="Chapter" href="Config.html">
<link title="Consistbl" rel="Chapter" href="Consistbl.html">
<link title="Depend" rel="Chapter" href="Depend.html">
<link title="Digest" rel="Chapter" href="Digest.html">
<link title="Docstrings" rel="Chapter" href="Docstrings.html">
<link title="Dynlink" rel="Chapter" href="Dynlink.html">
<link title="Ephemeron" rel="Chapter" href="Ephemeron.html">
<link title="Event" rel="Chapter" href="Event.html">
<link title="Filename" rel="Chapter" href="Filename.html">
<link title="Float" rel="Chapter" href="Float.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="Identifiable" rel="Chapter" href="Identifiable.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="Lexer" rel="Chapter" href="Lexer.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="Location" rel="Chapter" href="Location.html">
<link title="Longident" rel="Chapter" href="Longident.html">
<link title="Map" rel="Chapter" href="Map.html">
<link title="Marshal" rel="Chapter" href="Marshal.html">
<link title="Misc" rel="Chapter" href="Misc.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="Numbers" rel="Chapter" href="Numbers.html">
<link title="Obj" rel="Chapter" href="Obj.html">
<link title="Oo" rel="Chapter" href="Oo.html">
<link title="Parse" rel="Chapter" href="Parse.html">
<link title="Parser" rel="Chapter" href="Parser.html">
<link title="Parsetree" rel="Chapter" href="Parsetree.html">
<link title="Parsing" rel="Chapter" href="Parsing.html">
<link title="Pervasives" rel="Chapter" href="Pervasives.html">
<link title="Pparse" rel="Chapter" href="Pparse.html">
<link title="Pprintast" rel="Chapter" href="Pprintast.html">
<link title="Printast" rel="Chapter" href="Printast.html">
<link title="Printexc" rel="Chapter" href="Printexc.html">
<link title="Printf" rel="Chapter" href="Printf.html">
<link title="Profile" rel="Chapter" href="Profile.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="Seq" rel="Chapter" href="Seq.html">
<link title="Set" rel="Chapter" href="Set.html">
<link title="Simplif" rel="Chapter" href="Simplif.html">
<link title="Sort" rel="Chapter" href="Sort.html">
<link title="Spacetime" rel="Chapter" href="Spacetime.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="Strongly_connected_components" rel="Chapter" href="Strongly_connected_components.html">
<link title="Syntaxerr" rel="Chapter" href="Syntaxerr.html">
<link title="Sys" rel="Chapter" href="Sys.html">
<link title="Targetint" rel="Chapter" href="Targetint.html">
<link title="Tbl" rel="Chapter" href="Tbl.html">
<link title="Terminfo" rel="Chapter" href="Terminfo.html">
<link title="Thread" rel="Chapter" href="Thread.html">
<link title="ThreadUnix" rel="Chapter" href="ThreadUnix.html">
<link title="Typemod" rel="Chapter" href="Typemod.html">
<link title="Uchar" rel="Chapter" href="Uchar.html">
<link title="Unix" rel="Chapter" href="Unix.html">
<link title="UnixLabels" rel="Chapter" href="UnixLabels.html">
<link title="Warnings" rel="Chapter" href="Warnings.html">
<link title="Weak" rel="Chapter" href="Weak.html"><link title="Sorting" rel="Section" href="#1_Sorting">
<link title="Iterators on two arrays" rel="Subsection" href="#6_Iteratorsontwoarrays">
<link title="Array scanning" rel="Subsection" href="#6_Arrayscanning">
<link title="Iterators" rel="Subsection" href="#6_Iterators">
<title>ArrayLabels</title>
</head>
<body>
<div class="navbar"><a class="pre" href="Array.html" title="Array">Previous</a>
<a class="up" href="index.html" title="Index">Up</a>
<a class="post" href="Ast_helper.html" title="Ast_helper">Next</a>
</div>
<h1>Module <a href="type_ArrayLabels.html">ArrayLabels</a></h1>
<pre><span id="MODULEArrayLabels"><span class="keyword">module</span> ArrayLabels</span>: <code class="code"><span class="keyword">sig</span></code> <a href="ArrayLabels.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info module top">
<div class="info-desc">
<p>Array operations.</p>
</div>
</div>
<hr width="100%">
<pre><span id="VALlength"><span class="keyword">val</span> length</span> : <code class="type">'a array -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Return the length (number of elements) of the given array.</p>
</div>
</div>
<pre><span id="VALget"><span class="keyword">val</span> get</span> : <code class="type">'a array -> int -> 'a</code></pre><div class="info ">
<div class="info-desc">
<p><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>.
You can also write <code class="code">a.(n)</code> instead of <code class="code"><span class="constructor">Array</span>.get a n</code>.</p>
<p>Raise <code class="code"><span class="constructor">Invalid_argument</span> <span class="string">"index out of bounds"</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>.</p>
</div>
</div>
<pre><span id="VALset"><span class="keyword">val</span> set</span> : <code class="type">'a array -> int -> 'a -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><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>.
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>.</p>
<p>Raise <code class="code"><span class="constructor">Invalid_argument</span> <span class="string">"index out of bounds"</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>.</p>
</div>
</div>
<pre><span id="VALmake"><span class="keyword">val</span> make</span> : <code class="type">int -> 'a -> 'a array</code></pre><div class="info ">
<div class="info-desc">
<p><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>
<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>.</p>
</div>
</div>
<pre><span id="VALcreate"><span class="keyword">val</span> create</span> : <code class="type">int -> 'a -> 'a array</code></pre><div class="info ">
<div class="info-deprecated">
<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>.</div>
</div>
<pre><span id="VALinit"><span class="keyword">val</span> init</span> : <code class="type">int -> f:(int -> 'a) -> 'a array</code></pre><div class="info ">
<div class="info-desc">
<p><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>
<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>.</p>
</div>
</div>
<pre><span id="VALmake_matrix"><span class="keyword">val</span> make_matrix</span> : <code class="type">dimx:int -> dimy:int -> 'a -> 'a array array</code></pre><div class="info ">
<div class="info-desc">
<p><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>
<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 <a href="Sys.html#VALmax_array_length"><code class="code"><span class="constructor">Sys</span>.max_array_length</code></a>.
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>.</p>
</div>
</div>
<pre><span id="VALcreate_matrix"><span class="keyword">val</span> create_matrix</span> : <code class="type">dimx:int -> dimy:int -> 'a -> 'a array array</code></pre><div class="info ">
<div class="info-deprecated">
<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>.</div>
</div>
<pre><span id="VALappend"><span class="keyword">val</span> append</span> : <code class="type">'a array -> 'a array -> 'a array</code></pre><div class="info ">
<div class="info-desc">
<p><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>.</p>
</div>
</div>
<pre><span id="VALconcat"><span class="keyword">val</span> concat</span> : <code class="type">'a array list -> 'a array</code></pre><div class="info ">
<div class="info-desc">
<p>Same as <a href="Array.html#VALappend"><code class="code"><span class="constructor">Array</span>.append</code></a>, but concatenates a list of arrays.</p>
</div>
</div>
<pre><span id="VALsub"><span class="keyword">val</span> sub</span> : <code class="type">'a array -> pos:int -> len:int -> 'a array</code></pre><div class="info ">
<div class="info-desc">
<p><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>
<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>.</p>
</div>
</div>
<pre><span id="VALcopy"><span class="keyword">val</span> copy</span> : <code class="type">'a array -> 'a array</code></pre><div class="info ">
<div class="info-desc">
<p><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>.</p>
</div>
</div>
<pre><span id="VALfill"><span class="keyword">val</span> fill</span> : <code class="type">'a array -> pos:int -> len:int -> 'a -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><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>
<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>.</p>
</div>
</div>
<pre><span id="VALblit"><span class="keyword">val</span> blit</span> : <code class="type">src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><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>
<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>.</p>
</div>
</div>
<pre><span id="VALto_list"><span class="keyword">val</span> to_list</span> : <code class="type">'a array -> 'a list</code></pre><div class="info ">
<div class="info-desc">
<p><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>.</p>
</div>
</div>
<pre><span id="VALof_list"><span class="keyword">val</span> of_list</span> : <code class="type">'a list -> 'a array</code></pre><div class="info ">
<div class="info-desc">
<p><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>.</p>
</div>
</div>
<pre><span id="VALiter"><span class="keyword">val</span> iter</span> : <code class="type">f:('a -> unit) -> 'a array -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><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>.</p>
</div>
</div>
<pre><span id="VALmap"><span class="keyword">val</span> map</span> : <code class="type">f:('a -> 'b) -> 'a array -> 'b array</code></pre><div class="info ">
<div class="info-desc">
<p><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>.</p>
</div>
</div>
<pre><span id="VALiteri"><span class="keyword">val</span> iteri</span> : <code class="type">f:(int -> 'a -> unit) -> 'a array -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>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.</p>
</div>
</div>
<pre><span id="VALmapi"><span class="keyword">val</span> mapi</span> : <code class="type">f:(int -> 'a -> 'b) -> 'a array -> 'b array</code></pre><div class="info ">
<div class="info-desc">
<p>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.</p>
</div>
</div>
<pre><span id="VALfold_left"><span class="keyword">val</span> fold_left</span> : <code class="type">f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a</code></pre><div class="info ">
<div class="info-desc">
<p><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>.</p>
</div>
</div>
<pre><span id="VALfold_right"><span class="keyword">val</span> fold_right</span> : <code class="type">f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a</code></pre><div class="info ">
<div class="info-desc">
<p><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>.</p>
</div>
</div>
<h7 id="6_Iteratorsontwoarrays">Iterators on two arrays</h7>
<pre><span id="VALiter2"><span class="keyword">val</span> iter2</span> : <code class="type">f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Array</span>.iter2 f a b</code> applies function <code class="code">f</code> to all the elements of <code class="code">a</code>
and <code class="code">b</code>.
Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if the arrays are not the same size.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.05.0</li>
</ul>
</div>
<pre><span id="VALmap2"><span class="keyword">val</span> map2</span> : <code class="type">f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Array</span>.map2 f a b</code> applies function <code class="code">f</code> to all the elements of <code class="code">a</code>
and <code class="code">b</code>, and builds an array with the results returned by <code class="code">f</code>:
<code class="code">[| f a.(0) b.(0); ...; f a.(<span class="constructor">Array</span>.length a - 1) b.(<span class="constructor">Array</span>.length b - 1)|]</code>.
Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if the arrays are not the same size.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.05.0</li>
</ul>
</div>
<h7 id="6_Arrayscanning">Array scanning</h7>
<pre><span id="VALexists"><span class="keyword">val</span> exists</span> : <code class="type">f:('a -> bool) -> 'a array -> bool</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Array</span>.exists p [|a1; ...; an|]</code> checks if at least one element of
the array satisfies the predicate <code class="code">p</code>. That is, it returns
<code class="code">(p a1) <span class="keywordsign">||</span> (p a2) <span class="keywordsign">||</span> ... <span class="keywordsign">||</span> (p an)</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>
<pre><span id="VALfor_all"><span class="keyword">val</span> for_all</span> : <code class="type">f:('a -> bool) -> 'a array -> bool</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Array</span>.for_all p [|a1; ...; an|]</code> checks if all elements of the array
satisfy the predicate <code class="code">p</code>. That is, it returns
<code class="code">(p a1) <span class="keywordsign">&&</span> (p a2) <span class="keywordsign">&&</span> ... <span class="keywordsign">&&</span> (p an)</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>
<pre><span id="VALmem"><span class="keyword">val</span> mem</span> : <code class="type">'a -> set:'a array -> bool</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">mem x a</code> is true if and only if <code class="code">x</code> is equal
to an element of <code class="code">a</code>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>
<pre><span id="VALmemq"><span class="keyword">val</span> memq</span> : <code class="type">'a -> set:'a array -> bool</code></pre><div class="info ">
<div class="info-desc">
<p>Same as <a href="Array.html#VALmem"><code class="code"><span class="constructor">Array</span>.mem</code></a>, but uses physical equality instead of structural
equality to compare list elements.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>
<pre><span id="VALcreate_float"><span class="keyword">val</span> create_float</span> : <code class="type">int -> float array</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Array</span>.create_float n</code> returns a fresh float array of length <code class="code">n</code>,
with uninitialized data.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03</li>
</ul>
</div>
<pre><span id="VALmake_float"><span class="keyword">val</span> make_float</span> : <code class="type">int -> float array</code></pre><div class="info ">
<div class="info-deprecated">
<span class="warning">Deprecated.</span><code class="code"><span class="constructor">Array</span>.make_float</code> is an alias for
<a href="Array.html#VALcreate_float"><code class="code"><span class="constructor">Array</span>.create_float</code></a>.</div>
</div>
<h2 id="1_Sorting">Sorting</h2>
<pre><span id="VALsort"><span class="keyword">val</span> sort</span> : <code class="type">cmp:('a -> 'a -> int) -> 'a array -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>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">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>
<p>The current implementation uses Heap Sort. It runs in constant
stack space.</p>
<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 :</p>
<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>
<p>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> :</p>
<ul>
<li> <code class="code">cmp a.(i) a.(j)</code> >= 0 if and only if i >= j</li>
</ul>
</div>
</div>
<pre><span id="VALstable_sort"><span class="keyword">val</span> stable_sort</span> : <code class="type">cmp:('a -> 'a -> int) -> 'a array -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>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>
<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>.</p>
</div>
</div>
<pre><span id="VALfast_sort"><span class="keyword">val</span> fast_sort</span> : <code class="type">cmp:('a -> 'a -> int) -> 'a array -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>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.</p>
</div>
</div>
<h7 id="6_Iterators">Iterators</h7>
<pre><span id="VALto_seq"><span class="keyword">val</span> to_seq</span> : <code class="type">'a array -> 'a <a href="Seq.html#TYPEt">Seq.t</a></code></pre><div class="info ">
<div class="info-desc">
<p>Iterate on the array, in increasing order</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.07</li>
</ul>
</div>
<pre><span id="VALto_seqi"><span class="keyword">val</span> to_seqi</span> : <code class="type">'a array -> (int * 'a) <a href="Seq.html#TYPEt">Seq.t</a></code></pre><div class="info ">
<div class="info-desc">
<p>Iterate on the array, in increasing order, yielding indices along elements</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.07</li>
</ul>
</div>
<pre><span id="VALof_seq"><span class="keyword">val</span> of_seq</span> : <code class="type">'a <a href="Seq.html#TYPEt">Seq.t</a> -> 'a array</code></pre><div class="info ">
<div class="info-desc">
<p>Create an array from the generator</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.07</li>
</ul>
</div>
</body></html>
distrib
>
Mageia
>
7
>
armv7hl
>
media
>
core-release
>
by-pkgid
>
fb18813323b88f9a6e869238ab603257
>
files
>
35
