1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
|
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="Start" href="index.html">
<link rel="next" href="Bigarray.Array1.html">
<link rel="Up" href="Bigarray.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="CamlinternalMod" rel="Chapter" href="CamlinternalMod.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="Unix" rel="Chapter" href="Unix.html">
<link title="UnixLabels" rel="Chapter" href="UnixLabels.html">
<link title="Weak" rel="Chapter" href="Weak.html"><title>Bigarray.Genarray</title>
</head>
<body>
<div class="navbar"> <a href="Bigarray.html">Up</a>
<a href="Bigarray.Array1.html">Next</a>
</div>
<center><h1>Module <a href="type_Bigarray.Genarray.html">Bigarray.Genarray</a></h1></center>
<br>
<pre><span class="keyword">module</span> Genarray: <code class="code"><span class="keyword">sig</span></code> <a href="Bigarray.Genarray.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><hr width="100%">
<pre><span class="keyword">type</span> <a name="TYPEt"></a><code class="type">('a, 'b, 'c)</code> t </pre>
<div class="info">
The type <code class="code"><span class="constructor">Genarray</span>.t</code> is the type of big arrays with variable
numbers of dimensions. Any number of dimensions between 1 and 16
is supported.
<p>
The three type parameters to <code class="code"><span class="constructor">Genarray</span>.t</code> identify the array element
kind and layout, as follows:<ul>
<li>the first parameter, <code class="code"><span class="keywordsign">'</span>a</code>, is the Caml type for accessing array
elements (<code class="code">float</code>, <code class="code">int</code>, <code class="code">int32</code>, <code class="code">int64</code>, <code class="code">nativeint</code>);</li>
<li>the second parameter, <code class="code"><span class="keywordsign">'</span>b</code>, is the actual kind of array elements
(<code class="code">float32_elt</code>, <code class="code">float64_elt</code>, <code class="code">int8_signed_elt</code>, <code class="code">int8_unsigned_elt</code>,
etc);</li>
<li>the third parameter, <code class="code"><span class="keywordsign">'</span>c</code>, identifies the array layout
(<code class="code">c_layout</code> or <code class="code">fortran_layout</code>).</li>
</ul>
For instance, <code class="code">(float, float32_elt, fortran_layout) <span class="constructor">Genarray</span>.t</code>
is the type of generic big arrays containing 32-bit floats
in Fortran layout; reads and writes in this array use the
Caml type <code class="code">float</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALcreate"></a>create : <code class="type">('a, 'b) <a href="Bigarray.html#TYPEkind">Bigarray.kind</a> -><br> 'c <a href="Bigarray.html#TYPElayout">Bigarray.layout</a> -> int array -> ('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info">
<code class="code"><span class="constructor">Genarray</span>.create kind layout dimensions</code> returns a new big array
whose element kind is determined by the parameter <code class="code">kind</code> (one of
<code class="code">float32</code>, <code class="code">float64</code>, <code class="code">int8_signed</code>, etc) and whose layout is
determined by the parameter <code class="code">layout</code> (one of <code class="code">c_layout</code> or
<code class="code">fortran_layout</code>). The <code class="code">dimensions</code> parameter is an array of
integers that indicate the size of the big array in each dimension.
The length of <code class="code">dimensions</code> determines the number of dimensions
of the bigarray.
<p>
For instance, <code class="code"><span class="constructor">Genarray</span>.create int32 c_layout [|4;6;8|]</code>
returns a fresh big array of 32-bit integers, in C layout,
having three dimensions, the three dimensions being 4, 6 and 8
respectively.
<p>
Big arrays returned by <code class="code"><span class="constructor">Genarray</span>.create</code> are not initialized:
the initial values of array elements is unspecified.
<p>
<code class="code"><span class="constructor">Genarray</span>.create</code> raises <code class="code"><span class="constructor">Invalid_arg</span></code> if the number of dimensions
is not in the range 1 to 16 inclusive, or if one of the dimensions
is negative.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALnum_dims"></a>num_dims : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int</code></pre><div class="info">
Return the number of dimensions of the given big array.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALdims"></a>dims : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int array</code></pre><div class="info">
<code class="code"><span class="constructor">Genarray</span>.dims a</code> returns all dimensions of the big array <code class="code">a</code>,
as an array of integers of length <code class="code"><span class="constructor">Genarray</span>.num_dims a</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALnth_dim"></a>nth_dim : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int -> int</code></pre><div class="info">
<code class="code"><span class="constructor">Genarray</span>.nth_dim a n</code> returns the <code class="code">n</code>-th dimension of the
big array <code class="code">a</code>. The first dimension corresponds to <code class="code">n = 0</code>;
the second dimension corresponds to <code class="code">n = 1</code>; the last dimension,
to <code class="code">n = <span class="constructor">Genarray</span>.num_dims a - 1</code>.
Raise <code class="code"><span class="constructor">Invalid_arg</span></code> if <code class="code">n</code> is less than 0 or greater or equal than
<code class="code"><span class="constructor">Genarray</span>.num_dims a</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALkind"></a>kind : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> ('a, 'b) <a href="Bigarray.html#TYPEkind">Bigarray.kind</a></code></pre><div class="info">
Return the kind of the given big array.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALlayout"></a>layout : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> 'c <a href="Bigarray.html#TYPElayout">Bigarray.layout</a></code></pre><div class="info">
Return the layout of the given big array.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALget"></a>get : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int array -> 'a</code></pre><div class="info">
Read an element of a generic big array.
<code class="code"><span class="constructor">Genarray</span>.get a [|i1; ...; iN|]</code> returns the element of <code class="code">a</code>
whose coordinates are <code class="code">i1</code> in the first dimension, <code class="code">i2</code> in
the second dimension, ..., <code class="code">iN</code> in the <code class="code"><span class="constructor">N</span></code>-th dimension.
<p>
If <code class="code">a</code> has C layout, the coordinates must be greater or equal than 0
and strictly less than the corresponding dimensions of <code class="code">a</code>.
If <code class="code">a</code> has Fortran layout, the coordinates must be greater or equal
than 1 and less or equal than the corresponding dimensions of <code class="code">a</code>.
Raise <code class="code"><span class="constructor">Invalid_arg</span></code> if the array <code class="code">a</code> does not have exactly <code class="code"><span class="constructor">N</span></code>
dimensions, or if the coordinates are outside the array bounds.
<p>
If <code class="code"><span class="constructor">N</span> > 3</code>, alternate syntax is provided: you can write
<code class="code">a.{i1, i2, ..., iN}</code> instead of <code class="code"><span class="constructor">Genarray</span>.get a [|i1; ...; iN|]</code>.
(The syntax <code class="code">a.{...}</code> with one, two or three coordinates is
reserved for accessing one-, two- and three-dimensional arrays
as described below.)<br>
</div>
<pre><span class="keyword">val</span> <a name="VALset"></a>set : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int array -> 'a -> unit</code></pre><div class="info">
Assign an element of a generic big array.
<code class="code"><span class="constructor">Genarray</span>.set a [|i1; ...; iN|] v</code> stores the value <code class="code">v</code> in the
element of <code class="code">a</code> whose coordinates are <code class="code">i1</code> in the first dimension,
<code class="code">i2</code> in the second dimension, ..., <code class="code">iN</code> in the <code class="code"><span class="constructor">N</span></code>-th dimension.
<p>
The array <code class="code">a</code> must have exactly <code class="code"><span class="constructor">N</span></code> dimensions, and all coordinates
must lie inside the array bounds, as described for <code class="code"><span class="constructor">Genarray</span>.get</code>;
otherwise, <code class="code"><span class="constructor">Invalid_arg</span></code> is raised.
<p>
If <code class="code"><span class="constructor">N</span> > 3</code>, alternate syntax is provided: you can write
<code class="code">a.{i1, i2, ..., iN} <- v</code> instead of
<code class="code"><span class="constructor">Genarray</span>.set a [|i1; ...; iN|] v</code>.
(The syntax <code class="code">a.{...} <- v</code> with one, two or three coordinates is
reserved for updating one-, two- and three-dimensional arrays
as described below.)<br>
</div>
<pre><span class="keyword">val</span> <a name="VALsub_left"></a>sub_left : <code class="type">('a, 'b, <a href="Bigarray.html#TYPEc_layout">Bigarray.c_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a> -><br> int -> int -> ('a, 'b, <a href="Bigarray.html#TYPEc_layout">Bigarray.c_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info">
Extract a sub-array of the given big array by restricting the
first (left-most) dimension. <code class="code"><span class="constructor">Genarray</span>.sub_left a ofs len</code>
returns a big array with the same number of dimensions as <code class="code">a</code>,
and the same dimensions as <code class="code">a</code>, except the first dimension,
which corresponds to the interval <code class="code">[ofs ... ofs + len - 1]</code>
of the first dimension of <code class="code">a</code>. No copying of elements is
involved: the sub-array and the original array share the same
storage space. In other terms, the element at coordinates
<code class="code">[|i1; ...; iN|]</code> of the sub-array is identical to the
element at coordinates <code class="code">[|i1+ofs; ...; iN|]</code> of the original
array <code class="code">a</code>.
<p>
<code class="code"><span class="constructor">Genarray</span>.sub_left</code> applies only to big arrays in C layout.
Raise <code class="code"><span class="constructor">Invalid_arg</span></code> if <code class="code">ofs</code> and <code class="code">len</code> do not designate
a valid sub-array of <code class="code">a</code>, that is, if <code class="code">ofs < 0</code>, or <code class="code">len < 0</code>,
or <code class="code">ofs + len > <span class="constructor">Genarray</span>.nth_dim a 0</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALsub_right"></a>sub_right : <code class="type">('a, 'b, <a href="Bigarray.html#TYPEfortran_layout">Bigarray.fortran_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a> -><br> int -> int -> ('a, 'b, <a href="Bigarray.html#TYPEfortran_layout">Bigarray.fortran_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info">
Extract a sub-array of the given big array by restricting the
last (right-most) dimension. <code class="code"><span class="constructor">Genarray</span>.sub_right a ofs len</code>
returns a big array with the same number of dimensions as <code class="code">a</code>,
and the same dimensions as <code class="code">a</code>, except the last dimension,
which corresponds to the interval <code class="code">[ofs ... ofs + len - 1]</code>
of the last dimension of <code class="code">a</code>. No copying of elements is
involved: the sub-array and the original array share the same
storage space. In other terms, the element at coordinates
<code class="code">[|i1; ...; iN|]</code> of the sub-array is identical to the
element at coordinates <code class="code">[|i1; ...; iN+ofs|]</code> of the original
array <code class="code">a</code>.
<p>
<code class="code"><span class="constructor">Genarray</span>.sub_right</code> applies only to big arrays in Fortran layout.
Raise <code class="code"><span class="constructor">Invalid_arg</span></code> if <code class="code">ofs</code> and <code class="code">len</code> do not designate
a valid sub-array of <code class="code">a</code>, that is, if <code class="code">ofs < 1</code>, or <code class="code">len < 0</code>,
or <code class="code">ofs + len > <span class="constructor">Genarray</span>.nth_dim a (<span class="constructor">Genarray</span>.num_dims a - 1)</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALslice_left"></a>slice_left : <code class="type">('a, 'b, <a href="Bigarray.html#TYPEc_layout">Bigarray.c_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a> -><br> int array -> ('a, 'b, <a href="Bigarray.html#TYPEc_layout">Bigarray.c_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info">
Extract a sub-array of lower dimension from the given big array
by fixing one or several of the first (left-most) coordinates.
<code class="code"><span class="constructor">Genarray</span>.slice_left a [|i1; ... ; iM|]</code> returns the ``slice''
of <code class="code">a</code> obtained by setting the first <code class="code"><span class="constructor">M</span></code> coordinates to
<code class="code">i1</code>, ..., <code class="code">iM</code>. If <code class="code">a</code> has <code class="code"><span class="constructor">N</span></code> dimensions, the slice has
dimension <code class="code"><span class="constructor">N</span> - <span class="constructor">M</span></code>, and the element at coordinates
<code class="code">[|j1; ...; j(<span class="constructor">N</span>-<span class="constructor">M</span>)|]</code> in the slice is identical to the element
at coordinates <code class="code">[|i1; ...; iM; j1; ...; j(<span class="constructor">N</span>-<span class="constructor">M</span>)|]</code> in the original
array <code class="code">a</code>. No copying of elements is involved: the slice and
the original array share the same storage space.
<p>
<code class="code"><span class="constructor">Genarray</span>.slice_left</code> applies only to big arrays in C layout.
Raise <code class="code"><span class="constructor">Invalid_arg</span></code> if <code class="code"><span class="constructor">M</span> >= <span class="constructor">N</span></code>, or if <code class="code">[|i1; ... ; iM|]</code>
is outside the bounds of <code class="code">a</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALslice_right"></a>slice_right : <code class="type">('a, 'b, <a href="Bigarray.html#TYPEfortran_layout">Bigarray.fortran_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a> -><br> int array -> ('a, 'b, <a href="Bigarray.html#TYPEfortran_layout">Bigarray.fortran_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info">
Extract a sub-array of lower dimension from the given big array
by fixing one or several of the last (right-most) coordinates.
<code class="code"><span class="constructor">Genarray</span>.slice_right a [|i1; ... ; iM|]</code> returns the ``slice''
of <code class="code">a</code> obtained by setting the last <code class="code"><span class="constructor">M</span></code> coordinates to
<code class="code">i1</code>, ..., <code class="code">iM</code>. If <code class="code">a</code> has <code class="code"><span class="constructor">N</span></code> dimensions, the slice has
dimension <code class="code"><span class="constructor">N</span> - <span class="constructor">M</span></code>, and the element at coordinates
<code class="code">[|j1; ...; j(<span class="constructor">N</span>-<span class="constructor">M</span>)|]</code> in the slice is identical to the element
at coordinates <code class="code">[|j1; ...; j(<span class="constructor">N</span>-<span class="constructor">M</span>); i1; ...; iM|]</code> in the original
array <code class="code">a</code>. No copying of elements is involved: the slice and
the original array share the same storage space.
<p>
<code class="code"><span class="constructor">Genarray</span>.slice_right</code> applies only to big arrays in Fortran layout.
Raise <code class="code"><span class="constructor">Invalid_arg</span></code> if <code class="code"><span class="constructor">M</span> >= <span class="constructor">N</span></code>, or if <code class="code">[|i1; ... ; iM|]</code>
is outside the bounds of <code class="code">a</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALblit"></a>blit : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> ('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> unit</code></pre><div class="info">
Copy all elements of a big array in another big array.
<code class="code"><span class="constructor">Genarray</span>.blit src dst</code> copies all elements of <code class="code">src</code> into
<code class="code">dst</code>. Both arrays <code class="code">src</code> and <code class="code">dst</code> must have the same number of
dimensions and equal dimensions. Copying a sub-array of <code class="code">src</code>
to a sub-array of <code class="code">dst</code> can be achieved by applying <code class="code"><span class="constructor">Genarray</span>.blit</code>
to sub-array or slices of <code class="code">src</code> and <code class="code">dst</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALfill"></a>fill : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> 'a -> unit</code></pre><div class="info">
Set all elements of a big array to a given value.
<code class="code"><span class="constructor">Genarray</span>.fill a v</code> stores the value <code class="code">v</code> in all elements of
the big array <code class="code">a</code>. Setting only some elements of <code class="code">a</code> to <code class="code">v</code>
can be achieved by applying <code class="code"><span class="constructor">Genarray</span>.fill</code> to a sub-array
or a slice of <code class="code">a</code>.<br>
</div>
<pre><span class="keyword">val</span> <a name="VALmap_file"></a>map_file : <code class="type"><a href="Unix.html#TYPEfile_descr">Unix.file_descr</a> -><br> ('a, 'b) <a href="Bigarray.html#TYPEkind">Bigarray.kind</a> -><br> 'c <a href="Bigarray.html#TYPElayout">Bigarray.layout</a> -> bool -> int array -> ('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info">
Memory mapping of a file as a big array.
<code class="code"><span class="constructor">Genarray</span>.map_file fd kind layout shared dims</code>
returns a big array of kind <code class="code">kind</code>, layout <code class="code">layout</code>,
and dimensions as specified in <code class="code">dims</code>. The data contained in
this big array are the contents of the file referred to by
the file descriptor <code class="code">fd</code> (as opened previously with
<code class="code"><span class="constructor">Unix</span>.openfile</code>, for example). If <code class="code">shared</code> is <code class="code"><span class="keyword">true</span></code>,
all modifications performed on the array are reflected in
the file. This requires that <code class="code">fd</code> be opened with write permissions.
If <code class="code">shared</code> is <code class="code"><span class="keyword">false</span></code>, modifications performed on the array
are done in memory only, using copy-on-write of the modified
pages; the underlying file is not affected.
<p>
<code class="code"><span class="constructor">Genarray</span>.map_file</code> is much more efficient than reading
the whole file in a big array, modifying that big array,
and writing it afterwards.
<p>
To adjust automatically the dimensions of the big array to
the actual size of the file, the major dimension (that is,
the first dimension for an array with C layout, and the last
dimension for an array with Fortran layout) can be given as
<code class="code">-1</code>. <code class="code"><span class="constructor">Genarray</span>.map_file</code> then determines the major dimension
from the size of the file. The file must contain an integral
number of sub-arrays as determined by the non-major dimensions,
otherwise <code class="code"><span class="constructor">Failure</span></code> is raised.
<p>
If all dimensions of the big array are given, the file size is
matched against the size of the big array. If the file is larger
than the big array, only the initial portion of the file is
mapped to the big array. If the file is smaller than the big
array, the file is automatically grown to the size of the big array.
This requires write permissions on <code class="code">fd</code>.<br>
</div>
</body></html>
|
