Aardvark.Base


Volume<'Td>

Generic volume of elements with arbitrary stride. All sizes are given as 3-dimensional vectors, with the first parameter specifying the inner dimension. The volume does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on volumes are supported by function arguments which can be easily exploited by using lambda functions. Note: stride is called Delta (or D) within this data structure, the 3 stride direction(s) are called DX, DY, aso.

Constructors

ConstructorDescription
new(data, info)
Signature: (data:'Td [] * info:VolumeInfo) -> unit

Construct from data array with specified info without copying.

new(size)
Signature: size:V3l -> unit

Construct volume of specified size.

new(size)
Signature: size:V3i -> unit

Construct volume of specified size.

new(info)
Signature: info:VolumeInfo -> unit

Construct volume with specified info.

new(sx, sy, sz)
Signature: (sx:int64 * sy:int64 * sz:int64) -> unit

Construct volume of specified size.

new(data, sx, sy, sz)
Signature: (data:'Td [] * sx:int64 * sy:int64 * sz:int64) -> unit

Construct from data array with specified size without copying.

new(sx, sy, sz, value)
Signature: (sx:int64 * sy:int64 * sz:int64 * value:'Td) -> unit

Construct with specified size and sets all elements to the supplied value.

new(data, size)
Signature: (data:'Td [] * size:V3l) -> unit

Construct from data array with specified size without copying.

new(data, size)
Signature: (data:'Td [] * size:V3i) -> unit

Construct from data array with specified size without copying.

new(size, value)
Signature: (size:V3l * value:'Td) -> unit

Construct volume of specified size, with all elements set to the supplied value.

new(size, value)
Signature: (size:V3i * value:'Td) -> unit

Construct matrix of specified size, with all elements set to the supplied value.

new(data, origin, size, delta)
Signature: (data:'Td [] * origin:int64 * size:V3l * delta:V3l) -> unit

Construct from data array with specified size and delta without copying.

new(data, origin, size, delta, first)
Signature: (data:'Td [] * origin:int64 * size:V3l * delta:V3l * first:V3l) -> unit

Construct from data array with specified size and delta without copying.

new(origin, size, delta)
Signature: (origin:int64 * size:V3l * delta:V3l) -> unit

Construct with specified size and delta.

Instance members

Instance memberDescription
Apply(element_elementFun)
Signature: element_elementFun:Func<'Td,'Td> -> Volume<'Td>

Apply the supplied function on the elements of the volume. The value of the elements is given to fun.

Apply(t1, element_element1_elementFun)
Signature: (t1:Volume<'T1> * element_element1_elementFun:Func<'Td,'T1,'Td>) -> Volume<'Td>

Apply the supplied function to each pair of corresponding elements of the original volume and the supplied volume.

Apply(t1, element_element1_elementFun)
Signature: (t1:Volume<'T1d,'T1> * element_element1_elementFun:Func<'Td,'T1,'Td>) -> Volume<'Td>
Type parameters: 'T1

Apply the supplied function to each pair of corresponding elements of the original volume and the supplied volume.

ApplyByCoord(element_crd_elementFun)
Signature: element_crd_elementFun:Func<'Td,V3l,'Td> -> Volume<'Td>

Apply the supplied function on the elements of the volume. The value of the elements is given to fun.

ApplyByCoord(fun)
Signature: fun:Func<'Td,int64,int64,int64,'Td> -> Volume<'Td>

Set each element to the value of a function of the element coords.

Array()
Signature: unit -> unit
Modifiers: abstract

Return the underlying data array as an untyped array.

ArrayType
Signature: Type
Modifiers: abstract

Return the type of the underlying data array.

AsMatrixXxYZ()
Signature: unit -> Matrix<'Td>

If the planes of the volume are stored consecutively without gaps, they can be merged, and the volume can be viewed as a matrix.

AsMatrixXxYZ()
Signature: unit -> Matrix<'Td,'T1>

If the planes of the volume are stored consecutively without gaps, they can be merged, and the volume can be viewed as a matrix.

AsMatrixXYxZ()
Signature: unit -> Matrix<'Td>

If the lines of the volume are stored consecutively without gaps, they can be merged, and the volume can be viewed as a matrix.

AsMatrixXYxZ()
Signature: unit -> Matrix<'Td,'T1>

If the lines of the volume are stored consecutively without gaps, they can be merged, and the volume can be viewed as a matrix.

AsVector()
Signature: unit -> Vector<'Td>

If the lines and planes of the volume are stored consecutively without gaps, the whole volume can be viewed as a single vector.

AsVector()
Signature: unit -> Vector<'Td,'T1>

If the lines and planes of the volume are stored consecutively without gaps, the whole volume can be viewed as a single vector.

Copy()
Signature: unit -> Volume<'Td>

Elementwise copy. This methods returns a Volume with zero as first coordinates.

Copy(fun)
Signature: fun:Func<'Td,'T1> -> Volume<'T1>

Elementwise copy with function application. This methods returns a Volume with zero as first coordinates.

CopyWindow()
Signature: unit -> Volume<'Td>

Elementwise copy. This method retains the coordinates of the original Volume.

CopyWindow(fun)
Signature: fun:Func<'Td,'T1> -> Volume<'T1>

Elementwise copy with function application. This method retains the coordinates of the original Volume.

Count
Signature: int64

Total number of element in the matrix.

CreateOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Ty, 'Tz

Create a new volume as the outer product of the three supplied vectors.

CreateOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Ty, 'Tzd, 'Tz

Create a new volume as the outer product of the three supplied vectors.

CreateOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tyd, 'Ty, 'Tz

Create a new volume as the outer product of the three supplied vectors.

CreateOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tyd, 'Ty, 'Tzd, 'Tz

Create a new volume as the outer product of the three supplied vectors.

CreateOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tx, 'Ty, 'Tz

Create a new volume as the outer product of the three supplied vectors.

CreateOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tx, 'Ty, 'Tzd, 'Tz

Create a new volume as the outer product of the three supplied vectors.

CreateOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tx, 'Tyd, 'Ty, 'Tz

Create a new volume as the outer product of the three supplied vectors.

CreateOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tx, 'Tyd, 'Ty, 'Tzd, 'Tz

Create a new volume as the outer product of the three supplied vectors.

D()
Signature: unit -> unit

Delta

Delta()
Signature: unit -> unit
Modifiers: abstract
DeltaArray()
Signature: unit -> unit
Modifiers: abstract

Get or set the deltas of the tensor in each dimension as an array of longs.

Dim
Signature: V3l
Modifiers: abstract

Dimension of the generic Volume.

DSX
Signature: int64

Cummulative delta for all elements up to this dimension.

DSY
Signature: int64

Cummulative delta for all elements up to this dimension.

DSZ
Signature: int64

Cummulative delta for all elements up to this dimension.

DX()
Signature: unit -> unit

Delta in dimension X.

DY()
Signature: unit -> unit

Delta in dimension Y.

DZ()
Signature: unit -> unit

Delta in dimension Z.

E
Signature: V3l

End: one step beyond the last element.

Elements
Signature: IEnumerable<'Td>

Yields all elemnts ordered by index.

End
Signature: V3l

One step beyond the last element.

EX
Signature: int64

End in dimension X (one step beyond the last element).

EY
Signature: int64

End in dimension Y (one step beyond the last element).

EZ
Signature: int64

End in dimension Z (one step beyond the last element).

F()
Signature: unit -> unit

First

First()
Signature: unit -> unit
Modifiers: abstract
FirstArray()
Signature: unit -> unit
Modifiers: abstract

Get or set the first coords of the tensor in each dimension as an array of longs.

FirstIndex
Signature: int64

Return the index of the first element in the underlying data array.

ForeachCoord(v_action)
Signature: v_action:Action<V3l> -> unit
ForeachIndex(i_action)
Signature: i_action:Action<int64> -> unit
ForeachIndex(x_y_z_i_action)
Signature: x_y_z_i_action:Action<int64,int64,int64,int64> -> unit
ForeachIndex(t1, i_i1_act)
Signature: (t1:VolumeInfo * i_i1_act:Action<int64,int64>) -> unit
ForeachX(x_elementAct)
Signature: x_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.

ForeachXIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.

ForeachXIndex(x_i_elementAct)
Signature: x_i_elementAct:Action<int64,int64> -> unit

Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.

ForeachXY(x_y_elementAct)
Signature: x_y_elementAct:Action<int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXY(x_y_elementAct, x_postLineAct)
Signature: (x_y_elementAct:Action<int64,int64> * x_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXY(x_preLineAct, x_y_elementAct)
Signature: (x_preLineAct:Action<int64> * x_y_elementAct:Action<int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXY(...)
Signature: (x_preLineAct:Action<int64> * x_y_elementAct:Action<int64,int64> * x_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXYIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXYIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXYIndex(preLineAct, i_elementAct)
Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXYIndex(...)
Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXYIndex(x_y_i_elementAct)
Signature: x_y_i_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXYIndex(...)
Signature: (x_y_i_elementAct:Action<int64,int64,int64> * x_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXYIndex(...)
Signature: (x_preLineAct:Action<int64> * x_y_i_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXYIndex(...)
Signature: (x_preLineAct:Action<int64> * x_y_i_elementAct:Action<int64,int64,int64> * x_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXYZ(x_y_z_elementAct)
Signature: x_y_z_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZ(...)
Signature: (x_y_z_elementAct:Action<int64,int64,int64> * x_y_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZ(...)
Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZ(...)
Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_elementAct:Action<int64,int64,int64> * x_y_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZIndex(x_y_z_i_elementAct)
Signature: x_y_z_i_elementAct:Action<int64,int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZIndex(...)
Signature: (x_y_z_i_elementAct:Action<int64,int64,int64,int64> * x_y_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZIndex(...)
Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_i_elementAct:Action<int64,int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXYZIndex(...)
Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_i_elementAct:Action<int64,int64,int64,int64> * x_y_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZ(x_z_elementAct)
Signature: x_z_elementAct:Action<int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZ(x_z_elementAct, x_postLineAct)
Signature: (x_z_elementAct:Action<int64,int64> * x_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZ(x_preLineAct, x_z_elementAct)
Signature: (x_preLineAct:Action<int64> * x_z_elementAct:Action<int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZ(...)
Signature: (x_preLineAct:Action<int64> * x_z_elementAct:Action<int64,int64> * x_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZIndex(preLineAct, i_elementAct)
Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZIndex(...)
Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZIndex(x_z_i_elementAct)
Signature: x_z_i_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZIndex(...)
Signature: (x_z_i_elementAct:Action<int64,int64,int64> * x_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZIndex(...)
Signature: (x_preLineAct:Action<int64> * x_z_i_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZIndex(...)
Signature: (x_preLineAct:Action<int64> * x_z_i_elementAct:Action<int64,int64,int64> * x_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachXZY(x_z_y_elementAct)
Signature: x_z_y_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZY(...)
Signature: (x_z_y_elementAct:Action<int64,int64,int64> * x_z_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZY(...)
Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZY(...)
Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_elementAct:Action<int64,int64,int64> * x_z_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZYIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZYIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZYIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZYIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZYIndex(x_z_y_i_elementAct)
Signature: x_z_y_i_elementAct:Action<int64,int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZYIndex(...)
Signature: (x_z_y_i_elementAct:Action<int64,int64,int64,int64> * x_z_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZYIndex(...)
Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_i_elementAct:Action<int64,int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachXZYIndex(...)
Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_i_elementAct:Action<int64,int64,int64,int64> * x_z_postLineAct:Action<int64,int64> * x_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachY(y_elementAct)
Signature: y_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.

ForeachYIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.

ForeachYIndex(y_i_elementAct)
Signature: y_i_elementAct:Action<int64,int64> -> unit

Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.

ForeachYX(y_x_elementAct)
Signature: y_x_elementAct:Action<int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYX(y_x_elementAct, y_postLineAct)
Signature: (y_x_elementAct:Action<int64,int64> * y_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYX(y_preLineAct, y_x_elementAct)
Signature: (y_preLineAct:Action<int64> * y_x_elementAct:Action<int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYX(...)
Signature: (y_preLineAct:Action<int64> * y_x_elementAct:Action<int64,int64> * y_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYXIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYXIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYXIndex(preLineAct, i_elementAct)
Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYXIndex(...)
Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYXIndex(y_x_i_elementAct)
Signature: y_x_i_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYXIndex(...)
Signature: (y_x_i_elementAct:Action<int64,int64,int64> * y_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYXIndex(...)
Signature: (y_preLineAct:Action<int64> * y_x_i_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYXIndex(...)
Signature: (y_preLineAct:Action<int64> * y_x_i_elementAct:Action<int64,int64,int64> * y_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYXZ(y_x_z_elementAct)
Signature: y_x_z_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZ(...)
Signature: (y_x_z_elementAct:Action<int64,int64,int64> * y_x_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZ(...)
Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZ(...)
Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_elementAct:Action<int64,int64,int64> * y_x_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZIndex(y_x_z_i_elementAct)
Signature: y_x_z_i_elementAct:Action<int64,int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZIndex(...)
Signature: (y_x_z_i_elementAct:Action<int64,int64,int64,int64> * y_x_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZIndex(...)
Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_i_elementAct:Action<int64,int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYXZIndex(...)
Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_i_elementAct:Action<int64,int64,int64,int64> * y_x_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZ(y_z_elementAct)
Signature: y_z_elementAct:Action<int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZ(y_z_elementAct, y_postLineAct)
Signature: (y_z_elementAct:Action<int64,int64> * y_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZ(y_preLineAct, y_z_elementAct)
Signature: (y_preLineAct:Action<int64> * y_z_elementAct:Action<int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZ(...)
Signature: (y_preLineAct:Action<int64> * y_z_elementAct:Action<int64,int64> * y_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZIndex(preLineAct, i_elementAct)
Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZIndex(...)
Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZIndex(y_z_i_elementAct)
Signature: y_z_i_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZIndex(...)
Signature: (y_z_i_elementAct:Action<int64,int64,int64> * y_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZIndex(...)
Signature: (y_preLineAct:Action<int64> * y_z_i_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZIndex(...)
Signature: (y_preLineAct:Action<int64> * y_z_i_elementAct:Action<int64,int64,int64> * y_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachYZX(y_z_x_elementAct)
Signature: y_z_x_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZX(...)
Signature: (y_z_x_elementAct:Action<int64,int64,int64> * y_z_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZX(...)
Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZX(...)
Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_elementAct:Action<int64,int64,int64> * y_z_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZXIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZXIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZXIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZXIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZXIndex(y_z_x_i_elementAct)
Signature: y_z_x_i_elementAct:Action<int64,int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZXIndex(...)
Signature: (y_z_x_i_elementAct:Action<int64,int64,int64,int64> * y_z_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZXIndex(...)
Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_i_elementAct:Action<int64,int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachYZXIndex(...)
Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_i_elementAct:Action<int64,int64,int64,int64> * y_z_postLineAct:Action<int64,int64> * y_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZ(z_elementAct)
Signature: z_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.

ForeachZIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.

ForeachZIndex(z_i_elementAct)
Signature: z_i_elementAct:Action<int64,int64> -> unit

Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action.

ForeachZX(z_x_elementAct)
Signature: z_x_elementAct:Action<int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZX(z_x_elementAct, z_postLineAct)
Signature: (z_x_elementAct:Action<int64,int64> * z_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZX(z_preLineAct, z_x_elementAct)
Signature: (z_preLineAct:Action<int64> * z_x_elementAct:Action<int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZX(...)
Signature: (z_preLineAct:Action<int64> * z_x_elementAct:Action<int64,int64> * z_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZXIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZXIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZXIndex(preLineAct, i_elementAct)
Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZXIndex(...)
Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZXIndex(z_x_i_elementAct)
Signature: z_x_i_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZXIndex(...)
Signature: (z_x_i_elementAct:Action<int64,int64,int64> * z_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZXIndex(...)
Signature: (z_preLineAct:Action<int64> * z_x_i_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZXIndex(...)
Signature: (z_preLineAct:Action<int64> * z_x_i_elementAct:Action<int64,int64,int64> * z_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZXY(z_x_y_elementAct)
Signature: z_x_y_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXY(...)
Signature: (z_x_y_elementAct:Action<int64,int64,int64> * z_x_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXY(...)
Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXY(...)
Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_elementAct:Action<int64,int64,int64> * z_x_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXYIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXYIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXYIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXYIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXYIndex(z_x_y_i_elementAct)
Signature: z_x_y_i_elementAct:Action<int64,int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXYIndex(...)
Signature: (z_x_y_i_elementAct:Action<int64,int64,int64,int64> * z_x_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXYIndex(...)
Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_i_elementAct:Action<int64,int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZXYIndex(...)
Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_i_elementAct:Action<int64,int64,int64,int64> * z_x_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZY(z_y_elementAct)
Signature: z_y_elementAct:Action<int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZY(z_y_elementAct, z_postLineAct)
Signature: (z_y_elementAct:Action<int64,int64> * z_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZY(z_preLineAct, z_y_elementAct)
Signature: (z_preLineAct:Action<int64> * z_y_elementAct:Action<int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZY(...)
Signature: (z_preLineAct:Action<int64> * z_y_elementAct:Action<int64,int64> * z_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZYIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZYIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZYIndex(preLineAct, i_elementAct)
Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZYIndex(...)
Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZYIndex(z_y_i_elementAct)
Signature: z_y_i_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZYIndex(...)
Signature: (z_y_i_elementAct:Action<int64,int64,int64> * z_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZYIndex(...)
Signature: (z_preLineAct:Action<int64> * z_y_i_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZYIndex(...)
Signature: (z_preLineAct:Action<int64> * z_y_i_elementAct:Action<int64,int64,int64> * z_postLineAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified.

ForeachZYX(z_y_x_elementAct)
Signature: z_y_x_elementAct:Action<int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYX(...)
Signature: (z_y_x_elementAct:Action<int64,int64,int64> * z_y_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYX(...)
Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_elementAct:Action<int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYX(...)
Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_elementAct:Action<int64,int64,int64> * z_y_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYXIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYXIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYXIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYXIndex(...)
Signature: (prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYXIndex(z_y_x_i_elementAct)
Signature: z_y_x_i_elementAct:Action<int64,int64,int64,int64> -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYXIndex(...)
Signature: (z_y_x_i_elementAct:Action<int64,int64,int64,int64> * z_y_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYXIndex(...)
Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_i_elementAct:Action<int64,int64,int64,int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

ForeachZYXIndex(...)
Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_i_elementAct:Action<int64,int64,int64,int64> * z_y_postLineAct:Action<int64,int64> * z_postPlaneAct:Action<int64>) -> unit

Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line, post-line, pre-plane, and post-plane actions can be specified.

FX()
Signature: unit -> unit

First in dimension X.

FY()
Signature: unit -> unit

First in dimension Y.

FZ()
Signature: unit -> unit

First in dimension Z.

GetValue(x, y, z)
Signature: (x:int64 * y:int64 * z:int64) -> obj
Modifiers: abstract
GetValue(v)
Signature: v:V3l -> obj
Modifiers: abstract
III
Signature: V3l
IIO
Signature: V3l
InnerProduct(t1, mulFun, bias, sumFun)
Signature: (t1:Volume<'T1> * mulFun:Func<'Td,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts>) -> 'Ts
Type parameters: 'Tm, 'Ts
InnerProduct(t1, mulFun, bias, sumFun)
Signature: (t1:Volume<'T1d,'T1> * mulFun:Func<'Td,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts>) -> 'Ts
Type parameters: 'T1, 'Tm, 'Ts
InnerProduct(...)
Signature: (t1:Volume<'T1> * mulFun:Func<'Td,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * breakIfTrueFun:Func<'Ts,bool>) -> 'Ts
Type parameters: 'Tm, 'Ts
InnerProduct(...)
Signature: (t1:Volume<'T1d,'T1> * mulFun:Func<'Td,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * breakIfTrueFun:Func<'Ts,bool>) -> 'Ts
Type parameters: 'T1, 'Tm, 'Ts
IOI
Signature: V3l
IOO
Signature: V3l
IsInvalid
Signature: bool
Modifiers: abstract

Returns true if the volume does not have a data array.

IsValid
Signature: bool
Modifiers: abstract

Returns true if the volume has a data array.

[()]
Signature: unit -> V3l
Modifiers: abstract

Get/Set element at specified coordinate.

[()]
Signature: unit -> V3i

Get/Set element at specified coordinate.

[()]
Signature: unit -> int64

Get/Set element at the specified index in the underlying data array.

[arg1, arg2]
Signature: int64 * int64 -> int64
Modifiers: abstract

Get/Set element at specified coordinates.

[arg1, arg2]
Signature: int * int -> int

Get/Set element at specified coordinates.

JX
Signature: int64

Jump this many elements in the underlying data array when stepping in dimension X.

JY
Signature: int64

Jump this many elements in the underlying data array when stepping in dimension Y.

JZ
Signature: int64

Jump this many elements in the underlying data array when stepping in dimension Z.

Map(fun)
Signature: fun:Func<'Td,'T1> -> Volume<'T1>

Elementwise copy with function application. This methods returns a Volume with zero as first coordinates.

MapWindow(fun)
Signature: fun:Func<'Td,'T1> -> Volume<'T1>

Elementwise copy with function application. This method retains the coordinates of the original Volume.

Norm(elementFun, bias, sumFun)
Signature: (elementFun:Func<'Td,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr>) -> 'Tr
Type parameters: 'Ti
Norm(elementFun, bias, sumFun)
Signature: (elementFun:Func<'Td,int64,int64,int64,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr>) -> 'Tr
Type parameters: 'Ti
Norm(elementFun, bias, sumFun)
Signature: (elementFun:Func<'Td,V3l,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr>) -> 'Tr
Type parameters: 'Ti
Norm(...)
Signature: (elementFun:Func<'Td,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr> * breakIfTrueFun:Func<'Tr,bool>) -> 'Tr
Type parameters: 'Ti
Norm(...)
Signature: (elementFun:Func<'Td,int64,int64,int64,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr> * breakIfTrueFun:Func<'Tr,bool>) -> 'Tr
Type parameters: 'Ti
Norm(...)
Signature: (elementFun:Func<'Td,V3l,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr> * breakIfTrueFun:Func<'Tr,bool>) -> 'Tr
Type parameters: 'Ti
OII
Signature: V3l
OIO
Signature: V3l
OOI
Signature: V3l
OOO
Signature: V3l
Origin()
Signature: unit -> unit
Modifiers: abstract
OriginIndex()
Signature: unit -> unit
Modifiers: abstract
Rank
Signature: int
Modifiers: abstract

Return the rank or dimension of the volume (3).

Repeated(count)
Signature: count:V3l -> Volume<'Td>

Returns a tensor repeated in each dimension by the specified count.

S()
Signature: unit -> unit

Size

Sample64(...)
Signature: (v:V3d * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * zipl:Func<float,Tup4<'T3>> * xsmp:FuncRef1<'Td,'Td,'Td,'Td,Tup4<'T1>,'T4> * ysmp:FuncRef1<'T4,'T4,'T4,'T4,Tup4<'T2>,'T5> * zsmp:FuncRef1<'T5,'T5,'T5,'T5,Tup4<'T3>,'TRes> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup4<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup4<int64>> * index_min_max_delta_zIndexFun:Func<int64,int64,int64,int64,Tup4<int64>>) -> 'TRes
Type parameters: 'T2, 'T3, 'T4, 'T5, 'TRes
Sample64(...)
Signature: (x:float * y:float * z:float * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * zipl:Func<float,Tup4<'T3>> * xsmp:FuncRef1<'Td,'Td,'Td,'Td,Tup4<'T1>,'T4> * ysmp:FuncRef1<'T4,'T4,'T4,'T4,Tup4<'T2>,'T5> * zsmp:FuncRef1<'T5,'T5,'T5,'T5,Tup4<'T3>,'TRes> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup4<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup4<int64>> * index_min_max_delta_zIndexFun:Func<int64,int64,int64,int64,Tup4<int64>>) -> 'TRes
Type parameters: 'T2, 'T3, 'T4, 'T5, 'TRes
Sample64Clamped(...)
Signature: (v:V3d * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * zipl:Func<float,Tup4<'T3>> * xsmp:FuncRef1<'Td,'Td,'Td,'Td,Tup4<'T1>,'T4> * ysmp:FuncRef1<'T4,'T4,'T4,'T4,Tup4<'T2>,'T5> * zsmp:FuncRef1<'T5,'T5,'T5,'T5,Tup4<'T3>,'TRes>) -> 'TRes
Type parameters: 'T2, 'T3, 'T4, 'T5, 'TRes
Sample64Clamped(...)
Signature: (x:float * y:float * z:float * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * zipl:Func<float,Tup4<'T3>> * xsmp:FuncRef1<'Td,'Td,'Td,'Td,Tup4<'T1>,'T4> * ysmp:FuncRef1<'T4,'T4,'T4,'T4,Tup4<'T2>,'T5> * zsmp:FuncRef1<'T5,'T5,'T5,'T5,Tup4<'T3>,'TRes>) -> 'TRes
Type parameters: 'T2, 'T3, 'T4, 'T5, 'TRes
Sample8(...)
Signature: (v:V3d * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'TRes> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup2<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup2<int64>> * index_min_max_delta_zIndexFun:Func<int64,int64,int64,int64,Tup2<int64>>) -> 'TRes
Type parameters: 'T2, 'TRes
Sample8(...)
Signature: (x:float * y:float * z:float * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'TRes> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup2<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup2<int64>> * index_min_max_delta_zIndexFun:Func<int64,int64,int64,int64,Tup2<int64>>) -> 'TRes
Type parameters: 'T2, 'TRes

Sample the volume using 8 samples and the supplied interpolation functions. If only integer coordintes are supplied the returned value is the same as the indexer of the volume, i.e. voxel centers are assumed to be on integer coordinates.

Sample8Clamped(v, xipl, yipl, zipl)
Signature: (v:V3d * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'TRes>) -> 'TRes
Type parameters: 'T2, 'TRes
Sample8Clamped(...)
Signature: (x:float * y:float * z:float * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'TRes>) -> 'TRes
Type parameters: 'T2, 'TRes
SampleRaw64(...)
Signature: (v:V3d * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * zipl:Func<float,Tup4<'T3>> * xsmp:FuncRef1<'Td,'Td,'Td,'Td,Tup4<'T1>,'T4> * ysmp:FuncRef1<'T4,'T4,'T4,'T4,Tup4<'T2>,'T5> * zsmp:FuncRef1<'T5,'T5,'T5,'T5,Tup4<'T3>,'TRes>) -> 'TRes
Type parameters: 'T2, 'T3, 'T4, 'T5, 'TRes
SampleRaw64(...)
Signature: (x:float * y:float * z:float * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * zipl:Func<float,Tup4<'T3>> * xsmp:FuncRef1<'Td,'Td,'Td,'Td,Tup4<'T1>,'T4> * ysmp:FuncRef1<'T4,'T4,'T4,'T4,Tup4<'T2>,'T5> * zsmp:FuncRef1<'T5,'T5,'T5,'T5,Tup4<'T3>,'TRes>) -> 'TRes
Type parameters: 'T2, 'T3, 'T4, 'T5, 'TRes
SampleRaw8(v, xipl, yipl, zipl)
Signature: (v:V3d * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'TRes>) -> 'TRes
Type parameters: 'T2, 'TRes
SampleRaw8(x, y, z, xipl, yipl, zipl)
Signature: (x:float * y:float * z:float * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'TRes>) -> 'TRes
Type parameters: 'T2, 'TRes

Sample the volume using 8 samples and the supplied interpolation functions. If only integer coordintes are supplied the returned value is the same as the indexer of the volume, i.e. voxel centers are assumed to be on integer coordinates. No bounds checking is performed.

Set(v)
Signature: v:'Td -> Volume<'Td>

Sets all elements to the supplied value.

Set(it1)
Signature: it1:IVolume<'Td> -> Volume<'Td>

Set from a tensor that conforms to the corresponding tensor interface. Note, that this function checks if faster set operations are available and uses them if appropriate.

Set(t1)
Signature: t1:Volume<'Td> -> Volume<'Td>

Copy all elements from another volume.

Set(t1, element1_elementFun)
Signature: (t1:Volume<'T1> * element1_elementFun:Func<'T1,'Td>) -> Volume<'Td>

Set the elements of a volume to the result of a function of the elements of the supplied volume.

Set(t1)
Signature: t1:Volume<'T1,'Td> -> Volume<'Td>

Copy all elements from another volume.

Set(t1, element1_elementFun)
Signature: (t1:Volume<'T1d,'T1> * element1_elementFun:Func<'T1,'Td>) -> Volume<'Td>
Type parameters: 'T1

Set the elements of a volume to the result of a function of the elements of the supplied volume.

Set(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T2

Set the elements of a volume to the result of a function of corresponding pairs of elements of the two supplied tensors.

Set(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2

Set the elements of a volume to the result of a function of corresponding pairs of elements of the two supplied tensors.

Set(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2

Set the elements of a volume to the result of a function of corresponding pairs of elements of the two supplied tensors.

Set(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2

Set the elements of a volume to the result of a function of corresponding pairs of elements of the two supplied tensors.

Set(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

Set(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3d, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

Set(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

Set(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3d, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

Set(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

Set(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3d, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

Set(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

Set(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3d, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

SetByCoord(x_y_z_elementFun)
Signature: x_y_z_elementFun:Func<int64,int64,int64,'Td> -> Volume<'Td>

Set each element to the value of a function of the element coords.

SetByCoord(crd_elementFun)
Signature: crd_elementFun:Func<V3l,'Td> -> Volume<'Td>

Set each element to the value of a function of the element coords.

SetByCoord(zFun, yFun, fun)
Signature: (zFun:Func<int64,'Tz> * yFun:Func<int64,int64,'Tz,'Ty> * fun:Func<int64,int64,int64,'Tz,'Ty,'Td>) -> Volume<'Td>
Type parameters: 'Ty

Set each element to the value of a function of the element coords.

SetByIndex(index_elementFun)
Signature: index_elementFun:Func<int64,'Td> -> Volume<'Td>

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(t1, index1_elementFun)
Signature: (t1:Volume<'T1> * index1_elementFun:Func<int64,'Td>) -> Volume<'Td>

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(t1, index1_elementFun)
Signature: (t1:Volume<'T1d,'T1> * index1_elementFun:Func<int64,'Td>) -> Volume<'Td>
Type parameters: 'T1

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * index1_index2_elementFun:Func<int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * index1_index2_elementFun:Func<int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * index1_index2_elementFun:Func<int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * index1_index2_elementFun:Func<int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3d, 'T3

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3d, 'T3

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3d, 'T3

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetByIndex(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3d, 'T3

Set each element to the value of a function of the index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the volume.

SetConvolution(...)
Signature: (image:Volume<'Ti> * filter:Volume<'Tf> * mulFun:Func<'Ti,'Tf,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * castFun:Func<'Ts,'Td>) -> Volume<'Td>
Type parameters: 'Tf, 'Tm, 'Ts

Set the volume to be the convolution of the supplied image and filter tensors.

SetMap(t1, element1_elementFun)
Signature: (t1:Volume<'T1> * element1_elementFun:Func<'T1,'Td>) -> Volume<'Td>

Set the elements of a volume to the result of a function of the elements of the supplied volume.

SetMap(t1, element1_elementFun)
Signature: (t1:Volume<'T1d,'T1> * element1_elementFun:Func<'T1,'Td>) -> Volume<'Td>
Type parameters: 'T1

Set the elements of a volume to the result of a function of the elements of the supplied volume.

SetMap2(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T2

Set the elements of a volume to the result of a function of corresponding pairs of elements of the two supplied tensors.

SetMap2(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2

Set the elements of a volume to the result of a function of corresponding pairs of elements of the two supplied tensors.

SetMap2(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2

Set the elements of a volume to the result of a function of corresponding pairs of elements of the two supplied tensors.

SetMap2(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2

Set the elements of a volume to the result of a function of corresponding pairs of elements of the two supplied tensors.

SetMap3(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

SetMap3(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3d, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

SetMap3(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

SetMap3(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3d, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

SetMap3(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

SetMap3(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3d, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

SetMap3(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

SetMap3(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3d, 'T3

Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors.

SetOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Ty, 'Tz

Set the volume to be the outer product of the three supplied vectors.

SetOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Ty, 'Tzd, 'Tz

Set the volume to be the outer product of the three supplied vectors.

SetOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tyd, 'Ty, 'Tz

Set the volume to be the outer product of the three supplied vectors.

SetOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tyd, 'Ty, 'Tzd, 'Tz

Set the volume to be the outer product of the three supplied vectors.

SetOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tx, 'Ty, 'Tz

Set the volume to be the outer product of the three supplied vectors.

SetOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tx, 'Ty, 'Tzd, 'Tz

Set the volume to be the outer product of the three supplied vectors.

SetOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tx, 'Tyd, 'Ty, 'Tz

Set the volume to be the outer product of the three supplied vectors.

SetOuterProduct(tx, ty, tz, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * fun:Func<'Tx,'Ty,'Tz,'Td>) -> Volume<'Td>
Type parameters: 'Tx, 'Tyd, 'Ty, 'Tzd, 'Tz

Set the volume to be the outer product of the three supplied vectors.

SetValue(value, x, y, z)
Signature: (value:obj * x:int64 * y:int64 * z:int64) -> unit
Modifiers: abstract
SetValue(value, v)
Signature: (value:obj * v:V3l) -> unit
Modifiers: abstract
Size()
Signature: unit -> unit
Modifiers: abstract
SizeArray()
Signature: unit -> unit
Modifiers: abstract

Get or set the size of the tensor in each dimension as an array of longs.

SubMatrix(origin, size, delta)
Signature: (origin:V3l * size:V2l * delta:V2l) -> Matrix<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubMatrix(origin, size, delta)
Signature: (origin:V3i * size:V2i * delta:V2l) -> Matrix<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubMatrix(...)
Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * deltaX:int64 * deltaY:int64) -> Matrix<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubMatrix(origin, size, delta)
Signature: (origin:V3l * size:V2l * delta:V2l) -> Matrix<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubMatrix(origin, size, delta)
Signature: (origin:V3i * size:V2i * delta:V2l) -> Matrix<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubMatrix(...)
Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * deltaX:int64 * deltaY:int64) -> Matrix<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubVector(origin, size, delta)
Signature: (origin:V3l * size:int64 * delta:int64) -> Vector<'Td>

A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubVector(origin, size, delta)
Signature: (origin:V3i * size:int64 * delta:int64) -> Vector<'Td>

A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubVector(origin, size, delta)
Signature: (origin:V3l * size:int64 * delta:int64) -> Vector<'Td,'T1>

A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubVector(origin, size, delta)
Signature: (origin:V3i * size:int64 * delta:int64) -> Vector<'Td,'T1>

A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubVolume(begin, size)
Signature: (begin:V3l * size:V3l) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(begin, size)
Signature: (begin:V3i * size:V3i) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(begin, size, delta)
Signature: (begin:V3l * size:V3l * delta:V3l) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(begin, size, delta)
Signature: (begin:V3i * size:V3i * delta:V3i) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(...)
Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(...)
Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * deltaX:int64 * deltaY:int64 * deltaZ:int64) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(begin, size)
Signature: (begin:V3l * size:V3l) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(begin, size)
Signature: (begin:V3i * size:V3i) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(begin, size, delta)
Signature: (begin:V3l * size:V3l * delta:V3l) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(begin, size, delta)
Signature: (begin:V3i * size:V3i * delta:V3i) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(...)
Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolume(...)
Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * deltaX:int64 * deltaY:int64 * deltaZ:int64) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Volume with zero as first coordinates.

SubVolumeWindow(begin, size)
Signature: (begin:V3l * size:V3l) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(begin, size)
Signature: (begin:V3i * size:V3i) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(begin, size, delta)
Signature: (begin:V3l * size:V3l * delta:V3l) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(begin, size, delta)
Signature: (begin:V3i * size:V3i * delta:V3i) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(...)
Signature: (begin:V3l * size:V3l * delta:V3l * first:V3l) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubVolumeWindow(...)
Signature: (begin:V3i * size:V3i * delta:V3i * first:V3i) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubVolumeWindow(...)
Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(...)
Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * deltaX:int64 * deltaY:int64 * deltaZ:int64) -> Volume<'Td>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(begin, size)
Signature: (begin:V3l * size:V3l) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(begin, size)
Signature: (begin:V3i * size:V3i) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(begin, size, delta)
Signature: (begin:V3l * size:V3l * delta:V3l) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(begin, size, delta)
Signature: (begin:V3i * size:V3i * delta:V3i) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(...)
Signature: (begin:V3l * size:V3l * delta:V3l * first:V3l) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubVolumeWindow(...)
Signature: (begin:V3i * size:V3i * delta:V3i * first:V3i) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.

SubVolumeWindow(...)
Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubVolumeWindow(...)
Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * deltaX:int64 * deltaY:int64 * deltaZ:int64) -> Volume<'Td,'T1>

A SubVolume does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This method retains the coordinates of the parent Volume.

SubXVectorAsReadOnlyVolume(...)
Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> Volume<'Td>

Return a full X vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.

SubXVectorAsReadOnlyVolume(...)
Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> Volume<'Td,'T1>

Return a full X vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.

SubXVectorAsReadOnlyVolumeWindow(...)
Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> Volume<'Td>

Return a full X vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubXVectorAsReadOnlyVolumeWindow(...)
Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> Volume<'Td,'T1>

Return a full X vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubXYMatrix(z)
Signature: z:int64 -> Matrix<'Td>

Return a full XY matrix slice of the volume. This methods returns a matrix with zero as first coordinates.

SubXYMatrix(z)
Signature: z:int64 -> Matrix<'Td,'T1>

Return a full XY matrix slice of the volume. This methods returns a matrix with zero as first coordinates.

SubXYMatrixAsReadOnlyVolume(z, sizez)
Signature: (z:int64 * sizez:int64) -> Volume<'Td>

Return a full XY matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a matrix with zero as first coordinates.

SubXYMatrixAsReadOnlyVolume(z, sizez)
Signature: (z:int64 * sizez:int64) -> Volume<'Td,'T1>

Return a full XY matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a matrix with zero as first coordinates.

SubXYMatrixAsReadOnlyVolumeWindow(...)
Signature: (z:int64 * sizez:int64) -> Volume<'Td>

Return a full XY matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubXYMatrixAsReadOnlyVolumeWindow(...)
Signature: (z:int64 * sizez:int64) -> Volume<'Td,'T1>

Return a full XY matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubXYMatrixWindow(z)
Signature: z:int64 -> Matrix<'Td>

Return a full XY matrix slice of the volume. This method retains the coordinates of the parent volume.

SubXYMatrixWindow(z)
Signature: z:int64 -> Matrix<'Td,'T1>

Return a full XY matrix slice of the volume. This method retains the coordinates of the parent volume.

SubXZMatrix(y)
Signature: y:int64 -> Matrix<'Td>

Return a full XZ matrix slice of the volume. This methods returns a matrix with zero as first coordinates.

SubXZMatrix(y)
Signature: y:int64 -> Matrix<'Td,'T1>

Return a full XZ matrix slice of the volume. This methods returns a matrix with zero as first coordinates.

SubXZMatrixAsReadOnlyVolume(y, sizey)
Signature: (y:int64 * sizey:int64) -> Volume<'Td>

Return a full XZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a matrix with zero as first coordinates.

SubXZMatrixAsReadOnlyVolume(y, sizey)
Signature: (y:int64 * sizey:int64) -> Volume<'Td,'T1>

Return a full XZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a matrix with zero as first coordinates.

SubXZMatrixAsReadOnlyVolumeWindow(...)
Signature: (y:int64 * sizey:int64) -> Volume<'Td>

Return a full XZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubXZMatrixAsReadOnlyVolumeWindow(...)
Signature: (y:int64 * sizey:int64) -> Volume<'Td,'T1>

Return a full XZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubXZMatrixWindow(y)
Signature: y:int64 -> Matrix<'Td>

Return a full XZ matrix slice of the volume. This method retains the coordinates of the parent volume.

SubXZMatrixWindow(y)
Signature: y:int64 -> Matrix<'Td,'T1>

Return a full XZ matrix slice of the volume. This method retains the coordinates of the parent volume.

SubYVectorAsReadOnlyVolume(...)
Signature: (x:int64 * z:int64 * sizex:int64 * sizez:int64) -> Volume<'Td>

Return a full Y vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.

SubYVectorAsReadOnlyVolume(...)
Signature: (x:int64 * z:int64 * sizex:int64 * sizez:int64) -> Volume<'Td,'T1>

Return a full Y vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.

SubYVectorAsReadOnlyVolumeWindow(...)
Signature: (x:int64 * z:int64 * sizex:int64 * sizez:int64) -> Volume<'Td>

Return a full Y vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubYVectorAsReadOnlyVolumeWindow(...)
Signature: (x:int64 * z:int64 * sizex:int64 * sizez:int64) -> Volume<'Td,'T1>

Return a full Y vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubYZMatrix(x)
Signature: x:int64 -> Matrix<'Td>

Return a full YZ matrix slice of the volume. This methods returns a matrix with zero as first coordinates.

SubYZMatrix(x)
Signature: x:int64 -> Matrix<'Td,'T1>

Return a full YZ matrix slice of the volume. This methods returns a matrix with zero as first coordinates.

SubYZMatrixAsReadOnlyVolume(x, sizex)
Signature: (x:int64 * sizex:int64) -> Volume<'Td>

Return a full YZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a matrix with zero as first coordinates.

SubYZMatrixAsReadOnlyVolume(x, sizex)
Signature: (x:int64 * sizex:int64) -> Volume<'Td,'T1>

Return a full YZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a matrix with zero as first coordinates.

SubYZMatrixAsReadOnlyVolumeWindow(...)
Signature: (x:int64 * sizex:int64) -> Volume<'Td>

Return a full YZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubYZMatrixAsReadOnlyVolumeWindow(...)
Signature: (x:int64 * sizex:int64) -> Volume<'Td,'T1>

Return a full YZ matrix slice of the volume as a special volume that replicates the matrix the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubYZMatrixWindow(x)
Signature: x:int64 -> Matrix<'Td>

Return a full YZ matrix slice of the volume. This method retains the coordinates of the parent volume.

SubYZMatrixWindow(x)
Signature: x:int64 -> Matrix<'Td,'T1>

Return a full YZ matrix slice of the volume. This method retains the coordinates of the parent volume.

SubZVectorAsReadOnlyVolume(...)
Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Volume<'Td>

Return a full Z vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.

SubZVectorAsReadOnlyVolume(...)
Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Volume<'Td,'T1>

Return a full Z vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.

SubZVectorAsReadOnlyVolumeWindow(...)
Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Volume<'Td>

Return a full Z vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SubZVectorAsReadOnlyVolumeWindow(...)
Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Volume<'Td,'T1>

Return a full Z vector slice of the volume as a special volume that replicates the vector the supplied number of times. The special volume can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent volume.

SX()
Signature: unit -> unit

Size in dimension X.

SY()
Signature: unit -> unit

Size in dimension Y.

SZ()
Signature: unit -> unit

Size in dimension Z.

Static members

Static memberDescription
Create(t1)
Signature: t1:Volume<'Td> -> Volume<'Td>

Create a new volume as copy of the supplied volume.

Create(t1)
Signature: t1:Volume<'T1d,'Td> -> Volume<'Td>

Create a new volume as copy of the supplied volume.

Create(t1, element1_elementFun)
Signature: (t1:Volume<'T1> * element1_elementFun:Func<'T1,'Td>) -> Volume<'Td>

Create a new volume by applying a function on each element of the supplied volume.

Create(t1, element1_elementFun)
Signature: (t1:Volume<'T1d,'T1> * element1_elementFun:Func<'T1,'Td>) -> Volume<'Td>
Type parameters: 'T1

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T2

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3d, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3d, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3d, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Create(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3d, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Create(size, fun)
Signature: (size:V3l * fun:Func<V3l,'Td>) -> Volume<'Td>

Create a new volume by applying a function to the coordinates of the elements the newly created volume.

CreateByIndex(t1, index1_elementFun)
Signature: (t1:Volume<'T1> * index1_elementFun:Func<int64,'Td>) -> Volume<'Td>

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(t1, index1_elementFun)
Signature: (t1:Volume<'T1d,'T1> * index1_elementFun:Func<int64,'Td>) -> Volume<'Td>
Type parameters: 'T1

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * index1_index2_fun:Func<int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * index1_index2_fun:Func<int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * index1_index2_fun:Func<int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * index1_index2_fun:Func<int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3d, 'T3

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3d, 'T3

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3d, 'T3

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateByIndex(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3d, 'T3

Create a new volume by applying a function to each index of the elements of the supplied volume. The function may access the elements of the supplied volume to compute the elements of the new volume.

CreateConvolution(...)
Signature: (image:Volume<'Ti> * filter:Volume<'Tf> * mulFun:Func<'Ti,'Tf,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * castFun:Func<'Ts,'Td>) -> Volume<'Td>
Type parameters: 'Tf, 'Tm, 'Ts

Create a new Volume by convolving the image with the filter. The mulFun is used to combine single elements of the image with the filter. The result is summed up using the sumFun starting with bias. The complete sum is put through the castFun and put into the resulting Volume.

Map(t1, element1_elementFun)
Signature: (t1:Volume<'T1> * element1_elementFun:Func<'T1,'Td>) -> Volume<'Td>

Create a new volume by applying a function on each element of the supplied volume.

Map(t1, element1_elementFun)
Signature: (t1:Volume<'T1d,'T1> * element1_elementFun:Func<'T1,'Td>) -> Volume<'Td>
Type parameters: 'T1

Create a new volume by applying a function on each element of the supplied volume.

Map2(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T2

Create a new volume by applying a function on each element of the supplied volume.

Map2(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2

Create a new volume by applying a function on each element of the supplied volume.

Map2(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2

Create a new volume by applying a function on each element of the supplied volume.

Map2(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2

Create a new volume by applying a function on each element of the supplied volume.

Map3(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Map3(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2, 'T3d, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Map3(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Map3(...)
Signature: (t1:Volume<'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T2d, 'T2, 'T3d, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Map3(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Map3(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2, 'T3d, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Map3(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Map3(...)
Signature: (t1:Volume<'T1d,'T1> * t2:Volume<'T2d,'T2> * t3:Volume<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Volume<'Td>
Type parameters: 'T1, 'T2d, 'T2, 'T3d, 'T3

Create a new volume by applying a function on each element of the supplied volume.

Fork me on GitHub