<!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">
<link rel="Start" href="index.html">
<link rel="next" href="BatAvlTree.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 class methods" rel=Appendix href="index_methods.html">
<link title="Index of classes" rel=Appendix href="index_classes.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="BatArray" rel="Chapter" href="BatArray.html">
<link title="BatAvlTree" rel="Chapter" href="BatAvlTree.html">
<link title="BatBase64" rel="Chapter" href="BatBase64.html">
<link title="BatBig_int" rel="Chapter" href="BatBig_int.html">
<link title="BatBigarray" rel="Chapter" href="BatBigarray.html">
<link title="BatBitSet" rel="Chapter" href="BatBitSet.html">
<link title="BatBool" rel="Chapter" href="BatBool.html">
<link title="BatBounded" rel="Chapter" href="BatBounded.html">
<link title="BatBuffer" rel="Chapter" href="BatBuffer.html">
<link title="BatCache" rel="Chapter" href="BatCache.html">
<link title="BatChar" rel="Chapter" href="BatChar.html">
<link title="BatCharParser" rel="Chapter" href="BatCharParser.html">
<link title="BatComplex" rel="Chapter" href="BatComplex.html">
<link title="BatConcurrent" rel="Chapter" href="BatConcurrent.html">
<link title="BatDeque" rel="Chapter" href="BatDeque.html">
<link title="BatDigest" rel="Chapter" href="BatDigest.html">
<link title="BatDllist" rel="Chapter" href="BatDllist.html">
<link title="BatDynArray" rel="Chapter" href="BatDynArray.html">
<link title="BatEnum" rel="Chapter" href="BatEnum.html">
<link title="BatFile" rel="Chapter" href="BatFile.html">
<link title="BatFingerTree" rel="Chapter" href="BatFingerTree.html">
<link title="BatFloat" rel="Chapter" href="BatFloat.html">
<link title="BatFormat" rel="Chapter" href="BatFormat.html">
<link title="BatGc" rel="Chapter" href="BatGc.html">
<link title="BatGenlex" rel="Chapter" href="BatGenlex.html">
<link title="BatGlobal" rel="Chapter" href="BatGlobal.html">
<link title="BatHashcons" rel="Chapter" href="BatHashcons.html">
<link title="BatHashtbl" rel="Chapter" href="BatHashtbl.html">
<link title="BatHeap" rel="Chapter" href="BatHeap.html">
<link title="BatIMap" rel="Chapter" href="BatIMap.html">
<link title="BatIO" rel="Chapter" href="BatIO.html">
<link title="BatISet" rel="Chapter" href="BatISet.html">
<link title="BatInnerIO" rel="Chapter" href="BatInnerIO.html">
<link title="BatInnerPervasives" rel="Chapter" href="BatInnerPervasives.html">
<link title="BatInnerWeaktbl" rel="Chapter" href="BatInnerWeaktbl.html">
<link title="BatInt" rel="Chapter" href="BatInt.html">
<link title="BatInt32" rel="Chapter" href="BatInt32.html">
<link title="BatInt64" rel="Chapter" href="BatInt64.html">
<link title="BatInterfaces" rel="Chapter" href="BatInterfaces.html">
<link title="BatLazyList" rel="Chapter" href="BatLazyList.html">
<link title="BatLexing" rel="Chapter" href="BatLexing.html">
<link title="BatList" rel="Chapter" href="BatList.html">
<link title="BatLog" rel="Chapter" href="BatLog.html">
<link title="BatLogger" rel="Chapter" href="BatLogger.html">
<link title="BatMap" rel="Chapter" href="BatMap.html">
<link title="BatMarshal" rel="Chapter" href="BatMarshal.html">
<link title="BatMultiMap" rel="Chapter" href="BatMultiMap.html">
<link title="BatMultiPMap" rel="Chapter" href="BatMultiPMap.html">
<link title="BatMutex" rel="Chapter" href="BatMutex.html">
<link title="BatNativeint" rel="Chapter" href="BatNativeint.html">
<link title="BatNum" rel="Chapter" href="BatNum.html">
<link title="BatNumber" rel="Chapter" href="BatNumber.html">
<link title="BatOo" rel="Chapter" href="BatOo.html">
<link title="BatOptParse" rel="Chapter" href="BatOptParse.html">
<link title="BatOption" rel="Chapter" href="BatOption.html">
<link title="BatOrd" rel="Chapter" href="BatOrd.html">
<link title="BatParserCo" rel="Chapter" href="BatParserCo.html">
<link title="BatPathGen" rel="Chapter" href="BatPathGen.html">
<link title="BatPervasives" rel="Chapter" href="BatPervasives.html">
<link title="BatPrintexc" rel="Chapter" href="BatPrintexc.html">
<link title="BatPrintf" rel="Chapter" href="BatPrintf.html">
<link title="BatQueue" rel="Chapter" href="BatQueue.html">
<link title="BatRMutex" rel="Chapter" href="BatRMutex.html">
<link title="BatRandom" rel="Chapter" href="BatRandom.html">
<link title="BatRef" rel="Chapter" href="BatRef.html">
<link title="BatRefList" rel="Chapter" href="BatRefList.html">
<link title="BatResult" rel="Chapter" href="BatResult.html">
<link title="BatReturn" rel="Chapter" href="BatReturn.html">
<link title="BatScanf" rel="Chapter" href="BatScanf.html">
<link title="BatSeq" rel="Chapter" href="BatSeq.html">
<link title="BatSet" rel="Chapter" href="BatSet.html">
<link title="BatSplay" rel="Chapter" href="BatSplay.html">
<link title="BatStack" rel="Chapter" href="BatStack.html">
<link title="BatStream" rel="Chapter" href="BatStream.html">
<link title="BatString" rel="Chapter" href="BatString.html">
<link title="BatSubstring" rel="Chapter" href="BatSubstring.html">
<link title="BatSys" rel="Chapter" href="BatSys.html">
<link title="BatText" rel="Chapter" href="BatText.html">
<link title="BatTuple" rel="Chapter" href="BatTuple.html">
<link title="BatUChar" rel="Chapter" href="BatUChar.html">
<link title="BatUTF8" rel="Chapter" href="BatUTF8.html">
<link title="BatUnit" rel="Chapter" href="BatUnit.html">
<link title="BatUnix" rel="Chapter" href="BatUnix.html">
<link title="BatUref" rel="Chapter" href="BatUref.html">
<link title="BatVect" rel="Chapter" href="BatVect.html">
<link title="Batteries" rel="Chapter" href="Batteries.html">
<link title="BatteriesConfig" rel="Chapter" href="BatteriesConfig.html">
<link title="BatteriesPrint" rel="Chapter" href="BatteriesPrint.html">
<link title="BatteriesThread" rel="Chapter" href="BatteriesThread.html">
<link title="Extlib" rel="Chapter" href="Extlib.html"><link title="Sorting" rel="Section" href="#6_Sorting">
<link title="Operations on two arrays" rel="Section" href="#6_Operationsontwoarrays">
<link title="Predicates" rel="Section" href="#6_Predicates">
<link title="Array transformations" rel="Section" href="#6_Arraytransformations">
<link title="Conversions" rel="Section" href="#6_Conversions">
<link title="Utilities" rel="Section" href="#6_Utilities">
<link title="Boilerplate code" rel="Section" href="#6_Boilerplatecode">
<link title="Override modules" rel="Section" href="#6_Overridemodules">
<title>Batteries user guide : BatArray</title>
</head>
<body>
<div class="navbar"> <a class="up" href="index.html" title="Index">Up</a>
<a class="post" href="BatAvlTree.html" title="BatAvlTree">Next</a>
</div>
<h1>Module <a href="type_BatArray.html">BatArray</a></h1>
<pre><span class="keyword">module</span> BatArray: <code class="code"><span class="keyword">sig</span></code> <a href="BatArray.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info module top">
<h6 id="6_Arrayoperations">Array operations</h6>
<p>
Arrays are mutable data structures with a fixed size, which
support fast access and modification, and are used pervasively in
imperative computing. While arrays are completely supported in
OCaml, it is often a good idea to investigate persistent
alternatives, such as lists or hash maps.
<p>
This module replaces Stdlib's
<a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/Array.html">Array</a>
module.
<p>
A variant of arrays, arrays with capabilities, is provided in
module <a href="BatArray.Cap.html"><code class="code"><span class="constructor">BatArray</span>.<span class="constructor">Cap</span></code></a>. This notion of capabilities permit the
transformation of a mutable array into a read-only or a write-only
arrays, without loss of speed and with the possibility of
distributing different capabilities to different expressions.<br>
<b>Author(s):</b> Xavier Leroy, Richard W.M. Jones, David Teller<br>
</div>
<hr width="100%">
<pre><span id="TYPEt"><span class="keyword">type</span> <code class="type">'a</code> t</span> = <code class="type">'a array</code> </pre>
<div class="info ">
The type of arrays.<br>
</div>
<pre><span class="keyword">include</span> <a href="BatEnum.Enumerable.html">BatEnum.Enumerable</a></pre>
<pre><span class="keyword">include</span> <a href="BatInterfaces.Mappable.html">BatInterfaces.Mappable</a></pre>
<pre><span id="VALlength"><span class="keyword">val</span> length</span> : <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 id="VALget"><span class="keyword">val</span> get</span> : <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>.
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>
<b>Raises</b> <code>Invalid_argument</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>.<br>
</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 ">
<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>.<br>
<b>Raises</b> <code>Invalid_argument</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>.<br>
</div>
<pre><span id="VALmake"><span class="keyword">val</span> make</span> : <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.<br>
<b>Raises</b> <code>Invalid_argument</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 id="VALcreate"><span class="keyword">val</span> create</span> : <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 <code class="code"><span class="constructor">Array</span>.make</code>.<br>
</div>
<pre><span id="VALinit"><span class="keyword">val</span> init</span> : <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>.<br>
<b>Raises</b> <code>Invalid_argument</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 id="VALmake_matrix"><span class="keyword">val</span> make_matrix</span> : <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>.<br>
<b>Raises</b> <code>Invalid_argument</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 id="VALcreate_matrix"><span class="keyword">val</span> create_matrix</span> : <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 <code class="code"><span class="constructor">Array</span>.make_matrix</code>.<br>
</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 ">
<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 id="VALconcat"><span class="keyword">val</span> concat</span> : <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 id="VALsub"><span class="keyword">val</span> sub</span> : <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>.<br>
<b>Raises</b> <code>Invalid_argument</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 id="VALcopy"><span class="keyword">val</span> copy</span> : <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 id="VALfill"><span class="keyword">val</span> fill</span> : <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>.<br>
<b>Raises</b> <code>Invalid_argument</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 id="VALblit"><span class="keyword">val</span> blit</span> : <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.<br>
<b>Raises</b> <code>Invalid_argument</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 id="VALto_list"><span class="keyword">val</span> to_list</span> : <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 id="VALof_list"><span class="keyword">val</span> of_list</span> : <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 id="VALmax"><span class="keyword">val</span> max</span> : <code class="type">'a array -> 'a</code></pre><div class="info ">
<code class="code">max a</code> returns the largest value in <code class="code">a</code> as judged by
<code class="code"><span class="constructor">Pervasives</span>.compare</code><br>
<b>Raises</b> <code>Invalid_argument</code> on empty input<br>
</div>
<pre><span id="VALmin"><span class="keyword">val</span> min</span> : <code class="type">'a array -> 'a</code></pre><div class="info ">
<code class="code">min a</code> returns the smallest value in <code class="code">a</code> as judged by
<code class="code"><span class="constructor">Pervasives</span>.compare</code><br>
<b>Raises</b> <code>Invalid_argument</code> on empty input<br>
</div>
<pre><span id="VALsum"><span class="keyword">val</span> sum</span> : <code class="type">int array -> int</code></pre><div class="info ">
<code class="code">sum l</code> returns the sum of the integers of <code class="code">l</code><br>
</div>
<pre><span id="VALfsum"><span class="keyword">val</span> fsum</span> : <code class="type">float array -> float</code></pre><div class="info ">
<code class="code">fsum l</code> returns the sum of the floats of <code class="code">l</code><br>
</div>
<pre><span id="VALavg"><span class="keyword">val</span> avg</span> : <code class="type">int array -> float</code></pre><div class="info ">
<code class="code">avg l</code> returns the average of <code class="code">l</code><br>
<b>Since</b> 2.1<br>
</div>
<pre><span id="VALfavg"><span class="keyword">val</span> favg</span> : <code class="type">float array -> float</code></pre><div class="info ">
<code class="code">favg l</code> returns the average of <code class="code">l</code><br>
<b>Since</b> 2.1<br>
</div>
<pre><span id="VALleft"><span class="keyword">val</span> left</span> : <code class="type">'a array -> int -> 'a array</code></pre><div class="info ">
<code class="code">left r len</code> returns the array containing the <code class="code">len</code> first
characters of <code class="code">r</code>. If <code class="code">r</code> contains less than <code class="code">len</code> characters, it
returns <code class="code">r</code>.
<p>
Examples:
<code class="code"><span class="constructor">Array</span>.left [|0;1;2;3;4;5;6|] 4 = [|0;1;2;3|]</code>
<code class="code"><span class="constructor">Array</span>.left [|1;2;3|] 0 = [||]</code>
<code class="code"><span class="constructor">Array</span>.left [|1;2;3|] 10 = [|1;2;3|]</code><br>
</div>
<pre><span id="VALright"><span class="keyword">val</span> right</span> : <code class="type">'a array -> int -> 'a array</code></pre><div class="info ">
<code class="code">left r len</code> returns the array containing the <code class="code">len</code> last characters of <code class="code">r</code>.
If <code class="code">r</code> contains less than <code class="code">len</code> characters, it returns <code class="code">r</code>.
<p>
Example: <code class="code"><span class="constructor">Array</span>.right [|1;2;3;4;5;6|] 4 = [|3;4;5;6|]</code><br>
</div>
<pre><span id="VALhead"><span class="keyword">val</span> head</span> : <code class="type">'a array -> int -> 'a array</code></pre><div class="info ">
as <a href="BatArray.html#VALleft"><code class="code"><span class="constructor">BatArray</span>.left</code></a><br>
</div>
<pre><span id="VALtail"><span class="keyword">val</span> tail</span> : <code class="type">'a array -> int -> 'a array</code></pre><div class="info ">
<code class="code">tail r pos</code> returns the array containing all but the <code class="code">pos</code> first characters of <code class="code">r</code>
<p>
Example: <code class="code"><span class="constructor">Array</span>.tail [|1;2;3;4;5;6|] 4 = [|5;6|]</code><br>
</div>
<pre><span id="VALiter"><span class="keyword">val</span> iter</span> : <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 id="VALmap"><span class="keyword">val</span> map</span> : <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 id="VALiteri"><span class="keyword">val</span> iteri</span> : <code class="type">(int -> 'a -> unit) -> 'a array -> unit</code></pre><div class="info ">
Same as <code class="code"><span class="constructor">Array</span>.iter</code>, 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 id="VALmapi"><span class="keyword">val</span> mapi</span> : <code class="type">(int -> 'a -> 'b) -> 'a array -> 'b array</code></pre><div class="info ">
Same as <code class="code"><span class="constructor">Array</span>.map</code>, 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 id="VALfold_left"><span class="keyword">val</span> fold_left</span> : <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 id="VALfold_right"><span class="keyword">val</span> fold_right</span> : <code class="type">('b -> 'a -> 'a) -> 'b array -> 'a -> 'a</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>
<pre><span id="VALmodify"><span class="keyword">val</span> modify</span> : <code class="type">('a -> 'a) -> 'a array -> unit</code></pre><div class="info ">
<code class="code">modify f a</code> replaces every element <code class="code">x</code> of <code class="code">a</code> with <code class="code">f x</code>.<br>
</div>
<pre><span id="VALmodifyi"><span class="keyword">val</span> modifyi</span> : <code class="type">(int -> 'a -> 'a) -> 'a array -> unit</code></pre><div class="info ">
Same as <a href="BatArray.html#VALmodify"><code class="code"><span class="constructor">BatArray</span>.modify</code></a>, but the function is applied to the index of
the element as the first argument, and the element itself as
the second argument.<br>
</div>
<pre><span id="VALfold_lefti"><span class="keyword">val</span> fold_lefti</span> : <code class="type">('a -> int -> 'b -> 'a) -> 'a -> 'b array -> 'a</code></pre><div class="info ">
As <code class="code">fold_left</code>, but with the index of the element as additional argument<br>
</div>
<pre><span id="VALfold_righti"><span class="keyword">val</span> fold_righti</span> : <code class="type">(int -> 'b -> 'a -> 'a) -> 'b array -> 'a -> 'a</code></pre><div class="info ">
As <code class="code">fold_right</code>, but with the index of the element as additional argument<br>
</div>
<pre><span id="VALreduce"><span class="keyword">val</span> reduce</span> : <code class="type">('a -> 'a -> 'a) -> 'a array -> 'a</code></pre><div class="info ">
<code class="code"><span class="constructor">Array</span>.reduce f a</code> is <code class="code">fold_left f a.(0) [|a.(1); ..; a.(n-1)|]</code>. This
is useful for merging a group of things that have no
reasonable default value to return if the group is empty.<br>
<b>Raises</b> <code>Invalid_argument</code> on empty arrays.<br>
</div>
<pre><span id="VALsingleton"><span class="keyword">val</span> singleton</span> : <code class="type">'a -> 'a array</code></pre><div class="info ">
Create an array consisting of exactly one element.<br>
<b>Since</b> 2.1<br>
</div>
<br>
<h6 id="6_Sorting">Sorting</h6><br>
<pre><span id="VALsort"><span class="keyword">val</span> sort</span> : <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, <code class="code"><span class="constructor">Pervasives</span>.compare</code> 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 id="VALstable_sort"><span class="keyword">val</span> stable_sort</span> : <code class="type">('a -> 'a -> int) -> 'a array -> unit</code></pre><div class="info ">
Same as <code class="code"><span class="constructor">Array</span>.sort</code>, 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 <code class="code"><span class="constructor">Array</span>.sort</code>.<br>
</div>
<pre><span id="VALfast_sort"><span class="keyword">val</span> fast_sort</span> : <code class="type">('a -> 'a -> int) -> 'a array -> unit</code></pre><div class="info ">
Same as <code class="code"><span class="constructor">Array</span>.sort</code> or <code class="code"><span class="constructor">Array</span>.stable_sort</code>, whichever is faster
on typical input.<br>
</div>
<pre><span id="VALdecorate_stable_sort"><span class="keyword">val</span> decorate_stable_sort</span> : <code class="type">('a -> 'b) -> 'a array -> 'a array</code></pre><div class="info ">
<code class="code">decorate_stable_sort f a</code> returns a sorted copy of <code class="code">a</code> such that if <code class="code">f
x < f y</code> then <code class="code">x</code> is earlier in the result than <code class="code">y</code>. This
function is useful when <code class="code">f</code> is expensive, as it only computes <code class="code">f
x</code> once for each element in the array. See
<code class="code">:[http://en.wikipedia.org/wiki/<span class="constructor">Schwartzian_transform</span>]<span class="constructor">Schwartzian</span>
<span class="constructor">Transform</span></code>.
<p>
It is unnecessary to have an additional comparison function as
argument, as the builtin <code class="code"><span class="constructor">Pervasives</span>.compare</code> is used to compare
the <code class="code"><span class="keywordsign">'</span>b</code> values. This is deemed sufficient.<br>
</div>
<pre><span id="VALdecorate_fast_sort"><span class="keyword">val</span> decorate_fast_sort</span> : <code class="type">('a -> 'b) -> 'a array -> 'a array</code></pre><div class="info ">
As <code class="code"><span class="constructor">Array</span>.decorate_stable_sort</code>, but uses fast_sort internally.<br>
</div>
<br>
<h6 id="6_Operationsontwoarrays">Operations on two arrays</h6><br>
<pre><span id="VALiter2"><span class="keyword">val</span> iter2</span> : <code class="type">('a -> 'b -> unit) -> 'a array -> 'b array -> unit</code></pre><div class="info ">
<code class="code"><span class="constructor">Array</span>.iter2 f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]</code>
performs calls <code class="code">f a0 b0; f a1 b1; ...; f an bn</code> in that order.<br>
<b>Raises</b> <code>Invalid_argument</code> if the two arrays have different lengths.<br>
</div>
<pre><span id="VALiter2i"><span class="keyword">val</span> iter2i</span> : <code class="type">(int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unit</code></pre><div class="info ">
<code class="code"><span class="constructor">Array</span>.iter2i f [|a0; a1; ...; an|] [|b0; b1; ...; bn|]</code>
performs calls <code class="code">f 0 a0 b0; f 1 a1 b1; ...; f n an bn</code> in that
order.<br>
<b>Raises</b> <code>Invalid_argument</code> if the two arrays have different
lengths.<br>
</div>
<pre><span id="VALfor_all2"><span class="keyword">val</span> for_all2</span> : <code class="type">('a -> 'b -> bool) -> 'a array -> 'b array -> bool</code></pre><div class="info ">
As <code class="code"><span class="constructor">Array</span>.for_all</code> but on two arrays.<br>
<b>Raises</b> <code>Invalid_argument</code> if the two arrays have different lengths.<br>
</div>
<pre><span id="VALexists2"><span class="keyword">val</span> exists2</span> : <code class="type">('a -> 'b -> bool) -> 'a array -> 'b array -> bool</code></pre><div class="info ">
As <code class="code"><span class="constructor">Array</span>.exists</code> but on two arrays.<br>
<b>Raises</b> <code>Invalid_argument</code> if the two arrays have different lengths.<br>
</div>
<pre><span id="VALmap2"><span class="keyword">val</span> map2</span> : <code class="type">('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array</code></pre><div class="info ">
As <code class="code"><span class="constructor">Array</span>.map</code> but on two arrays.<br>
<b>Raises</b> <code>Invalid_argument</code> if the two arrays have different lengths.<br>
</div>
<br>
<h6 id="6_Predicates">Predicates</h6><br>
<pre><span id="VALfor_all"><span class="keyword">val</span> for_all</span> : <code class="type">('a -> bool) -> 'a array -> bool</code></pre><div class="info ">
<code class="code">for_all p [|a0; 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 a0)
<span class="keywordsign">&&</span> (p a1) <span class="keywordsign">&&</span> ... <span class="keywordsign">&&</span> (p an)</code>.<br>
</div>
<pre><span id="VALexists"><span class="keyword">val</span> exists</span> : <code class="type">('a -> bool) -> 'a array -> bool</code></pre><div class="info ">
<code class="code">exists p [|a0; 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
a0) <span class="keywordsign">||</span> (p a1) <span class="keywordsign">||</span> ... <span class="keywordsign">||</span> (p an)</code>.<br>
</div>
<pre><span id="VALfind"><span class="keyword">val</span> find</span> : <code class="type">('a -> bool) -> 'a array -> 'a</code></pre><div class="info ">
<code class="code">find p a</code> returns the first element of array <code class="code">a</code> that
satisfies the predicate <code class="code">p</code>.<br>
<b>Raises</b> <code>Not_found</code> if there is no value that satisfies <code class="code">p</code> in
the array <code class="code">a</code>.<br>
</div>
<pre><span id="VALmem"><span class="keyword">val</span> mem</span> : <code class="type">'a -> 'a array -> bool</code></pre><div class="info ">
<code class="code">mem m a</code> is true if and only if <code class="code">m</code> is equal to an element of <code class="code">a</code>.<br>
</div>
<pre><span id="VALmemq"><span class="keyword">val</span> memq</span> : <code class="type">'a -> 'a array -> bool</code></pre><div class="info ">
Same as <code class="code"><span class="constructor">Array</span>.mem</code> but uses physical equality instead of
structural equality to compare array elements.<br>
</div>
<pre><span id="VALfindi"><span class="keyword">val</span> findi</span> : <code class="type">('a -> bool) -> 'a array -> int</code></pre><div class="info ">
<code class="code">findi p a</code> returns the index of the first element of array <code class="code">a</code>
that satisfies the predicate <code class="code">p</code>.<br>
<b>Raises</b> <code>Not_found</code> if there is no value that satisfies <code class="code">p</code> in the
array <code class="code">a</code>.<br>
</div>
<pre><span id="VALfilter"><span class="keyword">val</span> filter</span> : <code class="type">('a -> bool) -> 'a array -> 'a array</code></pre><div class="info ">
<code class="code">filter p a</code> returns all the elements of the array <code class="code">a</code>
that satisfy the predicate <code class="code">p</code>. The order of the elements
in the input array is preserved.<br>
</div>
<pre><span id="VALfilteri"><span class="keyword">val</span> filteri</span> : <code class="type">(int -> 'a -> bool) -> 'a array -> 'a array</code></pre><div class="info ">
As <code class="code">filter</code> but with the index passed to the predicate.<br>
</div>
<pre><span id="VALfilter_map"><span class="keyword">val</span> filter_map</span> : <code class="type">('a -> 'b option) -> 'a array -> 'b array</code></pre><div class="info ">
<code class="code">filter_map f e</code> returns an array consisting of all elements
<code class="code">x</code> such that <code class="code">f y</code> returns <code class="code"><span class="constructor">Some</span> x</code> , where <code class="code">y</code> is an element
of <code class="code">e</code>.<br>
</div>
<pre><span id="VALfind_all"><span class="keyword">val</span> find_all</span> : <code class="type">('a -> bool) -> 'a array -> 'a array</code></pre><div class="info ">
<code class="code">find_all</code> is another name for <code class="code"><span class="constructor">Array</span>.filter</code>.<br>
</div>
<pre><span id="VALpartition"><span class="keyword">val</span> partition</span> : <code class="type">('a -> bool) -> 'a array -> 'a array * 'a array</code></pre><div class="info ">
<code class="code">partition p a</code> returns a pair of arrays <code class="code">(a1, a2)</code>, where
<code class="code">a1</code> is the array of all the elements of <code class="code">a</code> that
satisfy the predicate <code class="code">p</code>, and <code class="code">a2</code> is the array of all the
elements of <code class="code">a</code> that do not satisfy <code class="code">p</code>.
The order of the elements in the input array is preserved.<br>
</div>
<br>
<h6 id="6_Arraytransformations">Array transformations</h6><br>
<pre><span id="VALrev"><span class="keyword">val</span> rev</span> : <code class="type">'a array -> 'a array</code></pre><div class="info ">
Array reversal.<br>
</div>
<pre><span id="VALrev_in_place"><span class="keyword">val</span> rev_in_place</span> : <code class="type">'a array -> unit</code></pre><div class="info ">
In-place array reversal. The array argument is updated.<br>
</div>
<br>
<h6 id="6_Conversions">Conversions</h6><br>
<pre><span id="VALenum"><span class="keyword">val</span> enum</span> : <code class="type">'a array -> 'a <a href="BatEnum.html#TYPEt">BatEnum.t</a></code></pre><div class="info ">
Returns an enumeration of the elements of an array.
Behavior of the enumeration is undefined if the contents of the array changes afterwards.<br>
</div>
<pre><span id="VALof_enum"><span class="keyword">val</span> of_enum</span> : <code class="type">'a <a href="BatEnum.html#TYPEt">BatEnum.t</a> -> 'a array</code></pre><div class="info ">
Build an array from an enumeration.<br>
</div>
<pre><span id="VALbackwards"><span class="keyword">val</span> backwards</span> : <code class="type">'a array -> 'a <a href="BatEnum.html#TYPEt">BatEnum.t</a></code></pre><div class="info ">
Returns an enumeration of the elements of an array, from last to first.<br>
</div>
<pre><span id="VALof_backwards"><span class="keyword">val</span> of_backwards</span> : <code class="type">'a <a href="BatEnum.html#TYPEt">BatEnum.t</a> -> 'a array</code></pre><div class="info ">
Build an array from an enumeration, with the first element of
the enumeration as the last element of the array and vice
versa.<br>
</div>
<br>
<h6 id="6_Utilities">Utilities</h6><br>
<pre><span id="VALrange"><span class="keyword">val</span> range</span> : <code class="type">'a array -> int <a href="BatEnum.html#TYPEt">BatEnum.t</a></code></pre><div class="info ">
<code class="code">range a</code> returns an enumeration of all valid indexes into the given
array. For example, <code class="code">range [|2;4;6;8|] = 0--3</code>.<br>
</div>
<pre><span id="VALinsert"><span class="keyword">val</span> insert</span> : <code class="type">'a array -> 'a -> int -> 'a array</code></pre><div class="info ">
<code class="code">insert xs x i</code> returns a copy of <code class="code">xs</code> except the value <code class="code">x</code> is
inserted in position <code class="code">i</code> (and all later indices are shifted to the
right).<br>
</div>
<br>
<h6 id="6_Boilerplatecode">Boilerplate code</h6><br>
<pre><span id="VALprint"><span class="keyword">val</span> print</span> : <code class="type">?first:string -><br> ?last:string -><br> ?sep:string -> ('a, 'b) <a href="BatIO.html#TYPEprinter">BatIO.printer</a> -> ('a <a href="BatArray.html#TYPEt">t</a>, 'b) <a href="BatIO.html#TYPEprinter">BatIO.printer</a></code></pre><div class="info ">
Print the contents of an array, with <code class="code">~first</code> preceeding the first
item (default: "<code class="code"><span class="keywordsign">|</span><span class="string">"), [~last] following the last item (default:
"</span><span class="keywordsign">|</span></code>") and <code class="code">~sep</code> separating items (default: "; "). A printing
function must be provided to print the items in the array.
<p>
Example: IO.to_string (Array.print Int.print) <code class="code"><span class="keywordsign">|</span>2;4;66<span class="keywordsign">|</span></code> = "<code class="code"><span class="keywordsign">|</span>2; 4; 66<span class="keywordsign">|</span></code>"<br>
</div>
<pre><span id="VALcompare"><span class="keyword">val</span> compare</span> : <code class="type">'a <a href="BatOrd.html#TYPEcomp">BatOrd.comp</a> -> 'a array <a href="BatOrd.html#TYPEcomp">BatOrd.comp</a></code></pre><div class="info ">
<code class="code">compare c</code> generates the lexicographical order on arrays induced
by <code class="code">c</code>. That is, given a comparison function for the elements of
an array, this will return a comparison function for arrays of
that type.<br>
</div>
<pre><span id="VALord"><span class="keyword">val</span> ord</span> : <code class="type">'a <a href="BatOrd.html#TYPEord">BatOrd.ord</a> -> 'a array <a href="BatOrd.html#TYPEord">BatOrd.ord</a></code></pre><div class="info ">
Hoist an element comparison function to compare arrays of those
elements, with shorter arrays less than longer ones, and
lexicographically for arrays of the same size. This is a
different ordering than <code class="code">compare</code>, but is often faster.<br>
</div>
<pre><span id="VALequal"><span class="keyword">val</span> equal</span> : <code class="type">'a <a href="BatOrd.html#TYPEeq">BatOrd.eq</a> -> 'a array <a href="BatOrd.html#TYPEeq">BatOrd.eq</a></code></pre><div class="info ">
Hoist a equality test for elements to arrays. Arrays are only
equal if their lengths are the same and corresponding elements
test equal.<br>
</div>
<br>
<h6 id="6_Overridemodules">Override modules</h6><br>
<br>
The following modules replace functions defined in <code class="code"><span class="constructor">Array</span></code> with
functions behaving slightly differently but having the same
name. This is by design: the functions are meant to override the
corresponding functions of <code class="code"><span class="constructor">Array</span></code>.<br>
<pre><span class="keyword">module</span> <a href="BatArray.Exceptionless.html">Exceptionless</a>: <code class="code"><span class="keyword">sig</span></code> <a href="BatArray.Exceptionless.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info">
Operations on <code class="code"><span class="constructor">Array</span></code> without exceptions.
</div>
<pre><span class="keyword">module</span> <a href="BatArray.Labels.html">Labels</a>: <code class="code"><span class="keyword">sig</span></code> <a href="BatArray.Labels.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info">
Operations on <code class="code"><span class="constructor">Array</span></code> with labels.
</div>
<pre><span class="keyword">module</span> <a href="BatArray.Cap.html">Cap</a>: <code class="code"><span class="keyword">sig</span></code> <a href="BatArray.Cap.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><div class="info">
Capabilities for arrays.
</div>
<pre><span class="keyword">module</span> <a href="BatArray.Incubator.html">Incubator</a>: <code class="code"><span class="keyword">sig</span></code> <a href="BatArray.Incubator.html">..</a> <code class="code"><span class="keyword">end</span></code></pre></body></html>
