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
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
|
<!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="next" href="Bigarray.Array0.html">
<link rel="Up" href="Bigarray.html">
<link title="Index of types" rel=Appendix href="index_types.html">
<link title="Index of extensions" rel=Appendix href="index_extensions.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="Array" rel="Chapter" href="Array.html">
<link title="ArrayLabels" rel="Chapter" href="ArrayLabels.html">
<link title="Bigarray" rel="Chapter" href="Bigarray.html">
<link title="Bool" rel="Chapter" href="Bool.html">
<link title="Buffer" rel="Chapter" href="Buffer.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="Char" rel="Chapter" href="Char.html">
<link title="Complex" rel="Chapter" href="Complex.html">
<link title="Condition" rel="Chapter" href="Condition.html">
<link title="Digest" rel="Chapter" href="Digest.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="Fun" rel="Chapter" href="Fun.html">
<link title="Gc" rel="Chapter" href="Gc.html">
<link title="Genlex" rel="Chapter" href="Genlex.html">
<link title="Hashtbl" rel="Chapter" href="Hashtbl.html">
<link title="Int" rel="Chapter" href="Int.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="Obj" rel="Chapter" href="Obj.html">
<link title="Ocaml_operators" rel="Chapter" href="Ocaml_operators.html">
<link title="Oo" rel="Chapter" href="Oo.html">
<link title="Option" rel="Chapter" href="Option.html">
<link title="Parsing" rel="Chapter" href="Parsing.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="Result" rel="Chapter" href="Result.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="Spacetime" rel="Chapter" href="Spacetime.html">
<link title="Stack" rel="Chapter" href="Stack.html">
<link title="StdLabels" rel="Chapter" href="StdLabels.html">
<link title="Stdlib" rel="Chapter" href="Stdlib.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="Uchar" rel="Chapter" href="Uchar.html">
<link title="Unit" rel="Chapter" href="Unit.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 class="up" href="Bigarray.html" title="Bigarray">Up</a>
<a class="post" href="Bigarray.Array0.html" title="Bigarray.Array0">Next</a>
</div>
<h1>Module <a href="type_Bigarray.Genarray.html">Bigarray.Genarray</a></h1>
<pre><span id="MODULEGenarray"><span class="keyword">module</span> Genarray</span>: <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 id="TYPEt"><span class="keyword">type</span> <code class="type">('a, 'b, 'c)</code> t</span> </pre>
<div class="info ">
<div class="info-desc">
<p>The type <code class="code"><span class="constructor">Genarray</span>.t</code> is the type of Bigarrays with variable
numbers of dimensions. Any number of dimensions between 0 and 16
is supported.</p>
<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:</p>
<ul>
<li>the first parameter, <code class="code"><span class="keywordsign">'</span>a</code>, is the OCaml 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>
<p>For instance, <code class="code">(float, float32_elt, fortran_layout) <span class="constructor">Genarray</span>.t</code>
is the type of generic Bigarrays containing 32-bit floats
in Fortran layout; reads and writes in this array use the
OCaml type <code class="code">float</code>.</p>
</div>
</div>
<pre><span id="VALcreate"><span class="keyword">val</span> create</span> : <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 ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Genarray</span>.create kind layout dimensions</code> returns a new Bigarray
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 Bigarray in each dimension.
The length of <code class="code">dimensions</code> determines the number of dimensions
of the Bigarray.</p>
<p>For instance, <code class="code"><span class="constructor">Genarray</span>.create int32 c_layout [|4;6;8|]</code>
returns a fresh Bigarray of 32-bit integers, in C layout,
having three dimensions, the three dimensions being 4, 6 and 8
respectively.</p>
<p>Bigarrays returned by <code class="code"><span class="constructor">Genarray</span>.create</code> are not initialized:
the initial values of array elements is unspecified.</p>
<p><code class="code"><span class="constructor">Genarray</span>.create</code> raises <code class="code"><span class="constructor">Invalid_argument</span></code> if the number of dimensions
is not in the range 0 to 16 inclusive, or if one of the dimensions
is negative.</p>
</div>
</div>
<pre><span id="VALnum_dims"><span class="keyword">val</span> num_dims</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Return the number of dimensions of the given Bigarray.</p>
</div>
</div>
<pre><span id="VALdims"><span class="keyword">val</span> dims</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int array</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Genarray</span>.dims a</code> returns all dimensions of the Bigarray <code class="code">a</code>,
as an array of integers of length <code class="code"><span class="constructor">Genarray</span>.num_dims a</code>.</p>
</div>
</div>
<pre><span id="VALnth_dim"><span class="keyword">val</span> nth_dim</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Genarray</span>.nth_dim a n</code> returns the <code class="code">n</code>-th dimension of the
Bigarray <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>.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</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>.</li>
</ul>
</div>
<pre><span id="VALkind"><span class="keyword">val</span> kind</span> : <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 ">
<div class="info-desc">
<p>Return the kind of the given Bigarray.</p>
</div>
</div>
<pre><span id="VALlayout"><span class="keyword">val</span> layout</span> : <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 ">
<div class="info-desc">
<p>Return the layout of the given Bigarray.</p>
</div>
</div>
<pre><span id="VALchange_layout"><span class="keyword">val</span> change_layout</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -><br> 'd <a href="Bigarray.html#TYPElayout">Bigarray.layout</a> -> ('a, 'b, 'd) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Genarray</span>.change_layout a layout</code> returns a Bigarray with the
specified <code class="code">layout</code>, sharing the data with <code class="code">a</code> (and hence having
the same dimensions as <code class="code">a</code>). No copying of elements is involved: the
new array and the original array share the same storage space.
The dimensions are reversed, such that <code class="code">get v [| a; b |]</code> in
C layout becomes <code class="code">get v [| b+1; a+1 |]</code> in Fortran layout.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.04.0</li>
</ul>
</div>
<pre><span id="VALsize_in_bytes"><span class="keyword">val</span> size_in_bytes</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">size_in_bytes a</code> is the number of elements in <code class="code">a</code> multiplied
by <code class="code">a</code>'s <a href="Bigarray.html#VALkind_size_in_bytes"><code class="code"><span class="constructor">Bigarray</span>.kind_size_in_bytes</code></a>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>
<pre><span id="VALget"><span class="keyword">val</span> get</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int array -> 'a</code></pre><div class="info ">
<div class="info-desc">
<p>Read an element of a generic Bigarray.
<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>
<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>.</p>
<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.)</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</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.</li>
</ul>
</div>
<pre><span id="VALset"><span class="keyword">val</span> set</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int array -> 'a -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Assign an element of a generic Bigarray.
<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>
<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_argument</span></code> is raised.</p>
<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.)</p>
</div>
</div>
<pre><span id="VALsub_left"><span class="keyword">val</span> sub_left</span> : <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 ">
<div class="info-desc">
<p>Extract a sub-array of the given Bigarray by restricting the
first (left-most) dimension. <code class="code"><span class="constructor">Genarray</span>.sub_left a ofs len</code>
returns a Bigarray 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>
<p><code class="code"><span class="constructor">Genarray</span>.sub_left</code> applies only to Bigarrays in C layout.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</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>.</li>
</ul>
</div>
<pre><span id="VALsub_right"><span class="keyword">val</span> sub_right</span> : <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 ">
<div class="info-desc">
<p>Extract a sub-array of the given Bigarray by restricting the
last (right-most) dimension. <code class="code"><span class="constructor">Genarray</span>.sub_right a ofs len</code>
returns a Bigarray 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>
<p><code class="code"><span class="constructor">Genarray</span>.sub_right</code> applies only to Bigarrays in Fortran layout.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</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>.</li>
</ul>
</div>
<pre><span id="VALslice_left"><span class="keyword">val</span> slice_left</span> : <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 ">
<div class="info-desc">
<p>Extract a sub-array of lower dimension from the given Bigarray
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>
<p><code class="code"><span class="constructor">Genarray</span>.slice_left</code> applies only to Bigarrays in C layout.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</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>.</li>
</ul>
</div>
<pre><span id="VALslice_right"><span class="keyword">val</span> slice_right</span> : <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 ">
<div class="info-desc">
<p>Extract a sub-array of lower dimension from the given Bigarray
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>
<p><code class="code"><span class="constructor">Genarray</span>.slice_right</code> applies only to Bigarrays in Fortran layout.</p>
</div>
<ul class="info-attributes">
<li><b>Raises</b> <code>Invalid_argument</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>.</li>
</ul>
</div>
<pre><span id="VALblit"><span class="keyword">val</span> blit</span> : <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 ">
<div class="info-desc">
<p>Copy all elements of a Bigarray in another Bigarray.
<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>.</p>
</div>
</div>
<pre><span id="VALfill"><span class="keyword">val</span> fill</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> 'a -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Set all elements of a Bigarray 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 Bigarray <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>.</p>
</div>
</div>
</body></html>
|
