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
Constructor | Description |
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 member | Description |
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 member | Description |
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. |