Tensor4<'Td>

Generic tensor4 of elements with arbitrary stride. All sizes are given as 4-dimensional vectors, with the first parameter specifying the inner dimension. The tensor4 does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on tensor4s 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 4 stride direction(s) are called DX, DY, aso.

Constructors

Constructor	Description
`new(data, info)` Signature: (data:'Td [] * info:Tensor4Info) -> unit	Construct from data array with specified info without copying.
`new(size)` Signature: size:V4l -> unit	Construct tensor4 of specified size.
`new(size)` Signature: size:V4i -> unit	Construct tensor4 of specified size.
`new(info)` Signature: info:Tensor4Info -> unit	Construct tensor4 with specified info.
`new(sx, sy, sz, sw)` Signature: (sx:int64 * sy:int64 * sz:int64 * sw:int64) -> unit	Construct tensor4 of specified size.
`new(data, sx, sy, sz, sw)` Signature: (data:'Td [] * sx:int64 * sy:int64 * sz:int64 * sw:int64) -> unit	Construct from data array with specified size without copying.
`new(sx, sy, sz, sw, value)` Signature: (sx:int64 * sy:int64 * sz:int64 * sw:int64 * value:'Td) -> unit	Construct with specified size and sets all elements to the supplied value.
`new(data, size)` Signature: (data:'Td [] * size:V4l) -> unit	Construct from data array with specified size without copying.
`new(data, size)` Signature: (data:'Td [] * size:V4i) -> unit	Construct from data array with specified size without copying.
`new(size, value)` Signature: (size:V4l * value:'Td) -> unit	Construct tensor4 of specified size, with all elements set to the supplied value.
`new(size, value)` Signature: (size:V4i * 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:V4l * delta:V4l) -> unit	Construct from data array with specified size and delta without copying.
`new(data, origin, size, delta, first)` Signature: (data:'Td [] * origin:int64 * size:V4l * delta:V4l * first:V4l) -> unit	Construct from data array with specified size and delta without copying.
`new(origin, size, delta)` Signature: (origin:int64 * size:V4l * delta:V4l) -> unit	Construct with specified size and delta.

Instance members

Instance member	Description
`Apply(element_elementFun)` Signature: element_elementFun:Func<'Td,'Td> -> Tensor4<'Td>	Apply the supplied function on the elements of the tensor4. The value of the elements is given to fun.
`Apply(t1, element_element1_elementFun)` Signature: (t1:Tensor4<'T1> * element_element1_elementFun:Func<'Td,'T1,'Td>) -> Tensor4<'Td>	Apply the supplied function to each pair of corresponding elements of the original tensor4 and the supplied tensor4.
`Apply(t1, element_element1_elementFun)` Signature: (t1:Tensor4<'T1d,'T1> * element_element1_elementFun:Func<'Td,'T1,'Td>) -> Tensor4<'Td> Type parameters: 'T1	Apply the supplied function to each pair of corresponding elements of the original tensor4 and the supplied tensor4.
`ApplyByCoord(element_crd_elementFun)` Signature: element_crd_elementFun:Func<'Td,V4l,'Td> -> Tensor4<'Td>	Apply the supplied function on the elements of the tensor4. The value of the elements is given to fun.
`ApplyByCoord(fun)` Signature: fun:Func<'Td,int64,int64,int64,int64,'Td> -> Tensor4<'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.
`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 -> Tensor4<'Td>	Elementwise copy. This methods returns a Tensor4 with zero as first coordinates.
`Copy(fun)` Signature: fun:Func<'Td,'T1> -> Tensor4<'T1>	Elementwise copy with function application. This methods returns a Tensor4 with zero as first coordinates.
`CopyWindow()` Signature: unit -> Tensor4<'Td>	Elementwise copy. This method retains the coordinates of the original Tensor4.
`CopyWindow(fun)` Signature: fun:Func<'Td,'T1> -> Tensor4<'T1>	Elementwise copy with function application. This method retains the coordinates of the original Tensor4.
`Count` Signature: int64	Total number of element in the matrix.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Ty, 'Tz, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Ty, 'Tz, 'Twd, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Ty, 'Tzd, 'Tz, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Ty, 'Tzd, 'Tz, 'Twd, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tyd, 'Ty, 'Tz, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tyd, 'Ty, 'Tz, 'Twd, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tyd, 'Ty, 'Tzd, 'Tz, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tyd, 'Ty, 'Tzd, 'Tz, 'Twd, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Ty, 'Tz, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Ty, 'Tz, 'Twd, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Ty, 'Tzd, 'Tz, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Ty, 'Tzd, 'Tz, 'Twd, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Tyd, 'Ty, 'Tz, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Tyd, 'Ty, 'Tz, 'Twd, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Tyd, 'Ty, 'Tzd, 'Tz, 'Tw	Create a new four-dimensional tensor as the outer product of the four supplied vectors.
`CreateOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Tyd, 'Ty, 'Tzd, 'Tz, 'Twd, 'Tw	Create a new four-dimensional tensor as the outer product of the four 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: V4l Modifiers: abstract	Dimension of the generic Tensor4.
`DSW` Signature: int64	Cummulative delta for all elements up to this dimension.
`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.
`DW()` Signature: unit -> unit	Delta in dimension W.
`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: V4l	End: one step beyond the last element.
`Elements` Signature: IEnumerable<'Td>	Yields all elemnts ordered by index.
`End` Signature: V4l	One step beyond the last element.
`EW` Signature: int64	End in dimension W (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<V4l> -> unit
`ForeachIndex(i_action)` Signature: i_action:Action<int64> -> unit
`ForeachIndex(x_y_z_w_i_action)` Signature: x_y_z_w_i_action:Action<int64,int64,int64,int64,int64> -> unit
`ForeachIndex(t1, i_i1_act)` Signature: (t1:Tensor4Info * i_i1_act:Action<int64,int64>) -> unit
`ForeachW(w_elementAct)` Signature: w_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.
`ForeachWIndex(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.
`ForeachWIndex(w_i_elementAct)` Signature: w_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.
`ForeachWX(w_x_elementAct)` Signature: w_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.
`ForeachWX(w_x_elementAct, w_postLineAct)` Signature: (w_x_elementAct:Action<int64,int64> * w_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.
`ForeachWX(w_preLineAct, w_x_elementAct)` Signature: (w_preLineAct:Action<int64> * w_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.
`ForeachWX(...)` Signature: (w_preLineAct:Action<int64> * w_x_elementAct:Action<int64,int64> * w_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.
`ForeachWXIndex(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.
`ForeachWXIndex(...)` 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.
`ForeachWXIndex(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.
`ForeachWXIndex(...)` 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.
`ForeachWXIndex(w_x_i_elementAct)` Signature: w_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.
`ForeachWXIndex(...)` Signature: (w_x_i_elementAct:Action<int64,int64,int64> * w_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.
`ForeachWXIndex(...)` Signature: (w_preLineAct:Action<int64> * w_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.
`ForeachWXIndex(...)` Signature: (w_preLineAct:Action<int64> * w_x_i_elementAct:Action<int64,int64,int64> * w_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.
`ForeachWXY(w_x_y_elementAct)` Signature: w_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.
`ForeachWXY(...)` Signature: (w_x_y_elementAct:Action<int64,int64,int64> * w_x_postLineAct:Action<int64,int64> * w_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.
`ForeachWXY(...)` Signature: (w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_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.
`ForeachWXY(...)` Signature: (w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_x_y_elementAct:Action<int64,int64,int64> * w_x_postLineAct:Action<int64,int64> * w_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.
`ForeachWXYIndex(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.
`ForeachWXYIndex(...)` 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.
`ForeachWXYIndex(...)` 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.
`ForeachWXYIndex(...)` 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.
`ForeachWXYIndex(w_x_y_i_elementAct)` Signature: w_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.
`ForeachWXYIndex(...)` Signature: (w_x_y_i_elementAct:Action<int64,int64,int64,int64> * w_x_postLineAct:Action<int64,int64> * w_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.
`ForeachWXYIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_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.
`ForeachWXYIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_x_y_i_elementAct:Action<int64,int64,int64,int64> * w_x_postLineAct:Action<int64,int64> * w_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.
`ForeachWXYZ(w_x_y_z_elementAct)` Signature: w_x_y_z_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.
`ForeachWXYZ(...)` Signature: (w_x_y_z_elementAct:Action<int64,int64,int64,int64> * w_x_y_postLineAct:Action<int64,int64,int64> * w_x_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWXYZ(...)` Signature: (w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_y_preLineAct:Action<int64,int64,int64> * w_x_y_z_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.
`ForeachWXYZ(...)` Signature: (w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_y_preLineAct:Action<int64,int64,int64> * w_x_y_z_elementAct:Action<int64,int64,int64,int64> * w_x_y_postLineAct:Action<int64,int64,int64> * w_x_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWXYZIndex(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.
`ForeachWXYZIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWXYZIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachWXYZIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWXYZIndex(w_x_y_z_i_elementAct)` Signature: w_x_y_z_i_elementAct:Action<int64,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.
`ForeachWXYZIndex(...)` Signature: (w_x_y_z_i_elementAct:Action<int64,int64,int64,int64,int64> * w_x_y_postLineAct:Action<int64,int64,int64> * w_x_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWXYZIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_y_preLineAct:Action<int64,int64,int64> * w_x_y_z_i_elementAct:Action<int64,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.
`ForeachWXYZIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_y_preLineAct:Action<int64,int64,int64> * w_x_y_z_i_elementAct:Action<int64,int64,int64,int64,int64> * w_x_y_postLineAct:Action<int64,int64,int64> * w_x_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWXZ(w_x_z_elementAct)` Signature: w_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.
`ForeachWXZ(...)` Signature: (w_x_z_elementAct:Action<int64,int64,int64> * w_x_postLineAct:Action<int64,int64> * w_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.
`ForeachWXZ(...)` Signature: (w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_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.
`ForeachWXZ(...)` Signature: (w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_x_z_elementAct:Action<int64,int64,int64> * w_x_postLineAct:Action<int64,int64> * w_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.
`ForeachWXZIndex(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.
`ForeachWXZIndex(...)` 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.
`ForeachWXZIndex(...)` 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.
`ForeachWXZIndex(...)` 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.
`ForeachWXZIndex(w_x_z_i_elementAct)` Signature: w_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.
`ForeachWXZIndex(...)` Signature: (w_x_z_i_elementAct:Action<int64,int64,int64,int64> * w_x_postLineAct:Action<int64,int64> * w_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.
`ForeachWXZIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_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.
`ForeachWXZIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_x_z_i_elementAct:Action<int64,int64,int64,int64> * w_x_postLineAct:Action<int64,int64> * w_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.
`ForeachWXZY(w_x_z_y_elementAct)` Signature: w_x_z_y_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.
`ForeachWXZY(...)` Signature: (w_x_z_y_elementAct:Action<int64,int64,int64,int64> * w_x_z_postLineAct:Action<int64,int64,int64> * w_x_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWXZY(...)` Signature: (w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_z_preLineAct:Action<int64,int64,int64> * w_x_z_y_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.
`ForeachWXZY(...)` Signature: (w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_z_preLineAct:Action<int64,int64,int64> * w_x_z_y_elementAct:Action<int64,int64,int64,int64> * w_x_z_postLineAct:Action<int64,int64,int64> * w_x_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWXZYIndex(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.
`ForeachWXZYIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWXZYIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachWXZYIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWXZYIndex(w_x_z_y_i_elementAct)` Signature: w_x_z_y_i_elementAct:Action<int64,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.
`ForeachWXZYIndex(...)` Signature: (w_x_z_y_i_elementAct:Action<int64,int64,int64,int64,int64> * w_x_z_postLineAct:Action<int64,int64,int64> * w_x_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWXZYIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_z_preLineAct:Action<int64,int64,int64> * w_x_z_y_i_elementAct:Action<int64,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.
`ForeachWXZYIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_z_preLineAct:Action<int64,int64,int64> * w_x_z_y_i_elementAct:Action<int64,int64,int64,int64,int64> * w_x_z_postLineAct:Action<int64,int64,int64> * w_x_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWY(w_y_elementAct)` Signature: w_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.
`ForeachWY(w_y_elementAct, w_postLineAct)` Signature: (w_y_elementAct:Action<int64,int64> * w_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.
`ForeachWY(w_preLineAct, w_y_elementAct)` Signature: (w_preLineAct:Action<int64> * w_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.
`ForeachWY(...)` Signature: (w_preLineAct:Action<int64> * w_y_elementAct:Action<int64,int64> * w_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.
`ForeachWYIndex(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.
`ForeachWYIndex(...)` 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.
`ForeachWYIndex(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.
`ForeachWYIndex(...)` 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.
`ForeachWYIndex(w_y_i_elementAct)` Signature: w_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.
`ForeachWYIndex(...)` Signature: (w_y_i_elementAct:Action<int64,int64,int64> * w_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.
`ForeachWYIndex(...)` Signature: (w_preLineAct:Action<int64> * w_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.
`ForeachWYIndex(...)` Signature: (w_preLineAct:Action<int64> * w_y_i_elementAct:Action<int64,int64,int64> * w_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.
`ForeachWYX(w_y_x_elementAct)` Signature: w_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.
`ForeachWYX(...)` Signature: (w_y_x_elementAct:Action<int64,int64,int64> * w_y_postLineAct:Action<int64,int64> * w_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.
`ForeachWYX(...)` Signature: (w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_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.
`ForeachWYX(...)` Signature: (w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_y_x_elementAct:Action<int64,int64,int64> * w_y_postLineAct:Action<int64,int64> * w_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.
`ForeachWYXIndex(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.
`ForeachWYXIndex(...)` 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.
`ForeachWYXIndex(...)` 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.
`ForeachWYXIndex(...)` 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.
`ForeachWYXIndex(w_y_x_i_elementAct)` Signature: w_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.
`ForeachWYXIndex(...)` Signature: (w_y_x_i_elementAct:Action<int64,int64,int64,int64> * w_y_postLineAct:Action<int64,int64> * w_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.
`ForeachWYXIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_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.
`ForeachWYXIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_y_x_i_elementAct:Action<int64,int64,int64,int64> * w_y_postLineAct:Action<int64,int64> * w_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.
`ForeachWYXZ(w_y_x_z_elementAct)` Signature: w_y_x_z_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.
`ForeachWYXZ(...)` Signature: (w_y_x_z_elementAct:Action<int64,int64,int64,int64> * w_y_x_postLineAct:Action<int64,int64,int64> * w_y_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWYXZ(...)` Signature: (w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_x_preLineAct:Action<int64,int64,int64> * w_y_x_z_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.
`ForeachWYXZ(...)` Signature: (w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_x_preLineAct:Action<int64,int64,int64> * w_y_x_z_elementAct:Action<int64,int64,int64,int64> * w_y_x_postLineAct:Action<int64,int64,int64> * w_y_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWYXZIndex(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.
`ForeachWYXZIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWYXZIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachWYXZIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWYXZIndex(w_y_x_z_i_elementAct)` Signature: w_y_x_z_i_elementAct:Action<int64,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.
`ForeachWYXZIndex(...)` Signature: (w_y_x_z_i_elementAct:Action<int64,int64,int64,int64,int64> * w_y_x_postLineAct:Action<int64,int64,int64> * w_y_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWYXZIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_x_preLineAct:Action<int64,int64,int64> * w_y_x_z_i_elementAct:Action<int64,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.
`ForeachWYXZIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_x_preLineAct:Action<int64,int64,int64> * w_y_x_z_i_elementAct:Action<int64,int64,int64,int64,int64> * w_y_x_postLineAct:Action<int64,int64,int64> * w_y_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWYZ(w_y_z_elementAct)` Signature: w_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.
`ForeachWYZ(...)` Signature: (w_y_z_elementAct:Action<int64,int64,int64> * w_y_postLineAct:Action<int64,int64> * w_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.
`ForeachWYZ(...)` Signature: (w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_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.
`ForeachWYZ(...)` Signature: (w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_y_z_elementAct:Action<int64,int64,int64> * w_y_postLineAct:Action<int64,int64> * w_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.
`ForeachWYZIndex(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.
`ForeachWYZIndex(...)` 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.
`ForeachWYZIndex(...)` 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.
`ForeachWYZIndex(...)` 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.
`ForeachWYZIndex(w_y_z_i_elementAct)` Signature: w_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.
`ForeachWYZIndex(...)` Signature: (w_y_z_i_elementAct:Action<int64,int64,int64,int64> * w_y_postLineAct:Action<int64,int64> * w_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.
`ForeachWYZIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_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.
`ForeachWYZIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_y_z_i_elementAct:Action<int64,int64,int64,int64> * w_y_postLineAct:Action<int64,int64> * w_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.
`ForeachWYZX(w_y_z_x_elementAct)` Signature: w_y_z_x_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.
`ForeachWYZX(...)` Signature: (w_y_z_x_elementAct:Action<int64,int64,int64,int64> * w_y_z_postLineAct:Action<int64,int64,int64> * w_y_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWYZX(...)` Signature: (w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_z_preLineAct:Action<int64,int64,int64> * w_y_z_x_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.
`ForeachWYZX(...)` Signature: (w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_z_preLineAct:Action<int64,int64,int64> * w_y_z_x_elementAct:Action<int64,int64,int64,int64> * w_y_z_postLineAct:Action<int64,int64,int64> * w_y_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWYZXIndex(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.
`ForeachWYZXIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWYZXIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachWYZXIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWYZXIndex(w_y_z_x_i_elementAct)` Signature: w_y_z_x_i_elementAct:Action<int64,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.
`ForeachWYZXIndex(...)` Signature: (w_y_z_x_i_elementAct:Action<int64,int64,int64,int64,int64> * w_y_z_postLineAct:Action<int64,int64,int64> * w_y_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWYZXIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_z_preLineAct:Action<int64,int64,int64> * w_y_z_x_i_elementAct:Action<int64,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.
`ForeachWYZXIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_z_preLineAct:Action<int64,int64,int64> * w_y_z_x_i_elementAct:Action<int64,int64,int64,int64,int64> * w_y_z_postLineAct:Action<int64,int64,int64> * w_y_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWZ(w_z_elementAct)` Signature: w_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.
`ForeachWZ(w_z_elementAct, w_postLineAct)` Signature: (w_z_elementAct:Action<int64,int64> * w_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.
`ForeachWZ(w_preLineAct, w_z_elementAct)` Signature: (w_preLineAct:Action<int64> * w_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.
`ForeachWZ(...)` Signature: (w_preLineAct:Action<int64> * w_z_elementAct:Action<int64,int64> * w_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.
`ForeachWZIndex(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.
`ForeachWZIndex(...)` 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.
`ForeachWZIndex(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.
`ForeachWZIndex(...)` 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.
`ForeachWZIndex(w_z_i_elementAct)` Signature: w_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.
`ForeachWZIndex(...)` Signature: (w_z_i_elementAct:Action<int64,int64,int64> * w_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.
`ForeachWZIndex(...)` Signature: (w_preLineAct:Action<int64> * w_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.
`ForeachWZIndex(...)` Signature: (w_preLineAct:Action<int64> * w_z_i_elementAct:Action<int64,int64,int64> * w_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.
`ForeachWZX(w_z_x_elementAct)` Signature: w_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.
`ForeachWZX(...)` Signature: (w_z_x_elementAct:Action<int64,int64,int64> * w_z_postLineAct:Action<int64,int64> * w_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.
`ForeachWZX(...)` Signature: (w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_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.
`ForeachWZX(...)` Signature: (w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_z_x_elementAct:Action<int64,int64,int64> * w_z_postLineAct:Action<int64,int64> * w_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.
`ForeachWZXIndex(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.
`ForeachWZXIndex(...)` 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.
`ForeachWZXIndex(...)` 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.
`ForeachWZXIndex(...)` 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.
`ForeachWZXIndex(w_z_x_i_elementAct)` Signature: w_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.
`ForeachWZXIndex(...)` Signature: (w_z_x_i_elementAct:Action<int64,int64,int64,int64> * w_z_postLineAct:Action<int64,int64> * w_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.
`ForeachWZXIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_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.
`ForeachWZXIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_z_x_i_elementAct:Action<int64,int64,int64,int64> * w_z_postLineAct:Action<int64,int64> * w_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.
`ForeachWZXY(w_z_x_y_elementAct)` Signature: w_z_x_y_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.
`ForeachWZXY(...)` Signature: (w_z_x_y_elementAct:Action<int64,int64,int64,int64> * w_z_x_postLineAct:Action<int64,int64,int64> * w_z_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWZXY(...)` Signature: (w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_x_preLineAct:Action<int64,int64,int64> * w_z_x_y_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.
`ForeachWZXY(...)` Signature: (w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_x_preLineAct:Action<int64,int64,int64> * w_z_x_y_elementAct:Action<int64,int64,int64,int64> * w_z_x_postLineAct:Action<int64,int64,int64> * w_z_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWZXYIndex(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.
`ForeachWZXYIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWZXYIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachWZXYIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWZXYIndex(w_z_x_y_i_elementAct)` Signature: w_z_x_y_i_elementAct:Action<int64,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.
`ForeachWZXYIndex(...)` Signature: (w_z_x_y_i_elementAct:Action<int64,int64,int64,int64,int64> * w_z_x_postLineAct:Action<int64,int64,int64> * w_z_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWZXYIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_x_preLineAct:Action<int64,int64,int64> * w_z_x_y_i_elementAct:Action<int64,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.
`ForeachWZXYIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_x_preLineAct:Action<int64,int64,int64> * w_z_x_y_i_elementAct:Action<int64,int64,int64,int64,int64> * w_z_x_postLineAct:Action<int64,int64,int64> * w_z_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWZY(w_z_y_elementAct)` Signature: w_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.
`ForeachWZY(...)` Signature: (w_z_y_elementAct:Action<int64,int64,int64> * w_z_postLineAct:Action<int64,int64> * w_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.
`ForeachWZY(...)` Signature: (w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_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.
`ForeachWZY(...)` Signature: (w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_z_y_elementAct:Action<int64,int64,int64> * w_z_postLineAct:Action<int64,int64> * w_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.
`ForeachWZYIndex(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.
`ForeachWZYIndex(...)` 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.
`ForeachWZYIndex(...)` 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.
`ForeachWZYIndex(...)` 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.
`ForeachWZYIndex(w_z_y_i_elementAct)` Signature: w_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.
`ForeachWZYIndex(...)` Signature: (w_z_y_i_elementAct:Action<int64,int64,int64,int64> * w_z_postLineAct:Action<int64,int64> * w_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.
`ForeachWZYIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_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.
`ForeachWZYIndex(...)` Signature: (w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_z_y_i_elementAct:Action<int64,int64,int64,int64> * w_z_postLineAct:Action<int64,int64> * w_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.
`ForeachWZYX(w_z_y_x_elementAct)` Signature: w_z_y_x_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.
`ForeachWZYX(...)` Signature: (w_z_y_x_elementAct:Action<int64,int64,int64,int64> * w_z_y_postLineAct:Action<int64,int64,int64> * w_z_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWZYX(...)` Signature: (w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_y_preLineAct:Action<int64,int64,int64> * w_z_y_x_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.
`ForeachWZYX(...)` Signature: (w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_y_preLineAct:Action<int64,int64,int64> * w_z_y_x_elementAct:Action<int64,int64,int64,int64> * w_z_y_postLineAct:Action<int64,int64,int64> * w_z_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWZYXIndex(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.
`ForeachWZYXIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWZYXIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachWZYXIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachWZYXIndex(w_z_y_x_i_elementAct)` Signature: w_z_y_x_i_elementAct:Action<int64,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.
`ForeachWZYXIndex(...)` Signature: (w_z_y_x_i_elementAct:Action<int64,int64,int64,int64,int64> * w_z_y_postLineAct:Action<int64,int64,int64> * w_z_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`ForeachWZYXIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_y_preLineAct:Action<int64,int64,int64> * w_z_y_x_i_elementAct:Action<int64,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.
`ForeachWZYXIndex(...)` Signature: (w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_y_preLineAct:Action<int64,int64,int64> * w_z_y_x_i_elementAct:Action<int64,int64,int64,int64,int64> * w_z_y_postLineAct:Action<int64,int64,int64> * w_z_postPlaneAct:Action<int64,int64> * w_postVolumeAct: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.
`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.
`ForeachXW(x_w_elementAct)` Signature: x_w_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.
`ForeachXW(x_w_elementAct, x_postLineAct)` Signature: (x_w_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.
`ForeachXW(x_preLineAct, x_w_elementAct)` Signature: (x_preLineAct:Action<int64> * x_w_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.
`ForeachXW(...)` Signature: (x_preLineAct:Action<int64> * x_w_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.
`ForeachXWIndex(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.
`ForeachXWIndex(...)` 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.
`ForeachXWIndex(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.
`ForeachXWIndex(...)` 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.
`ForeachXWIndex(x_w_i_elementAct)` Signature: x_w_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.
`ForeachXWIndex(...)` Signature: (x_w_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.
`ForeachXWIndex(...)` Signature: (x_preLineAct:Action<int64> * x_w_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.
`ForeachXWIndex(...)` Signature: (x_preLineAct:Action<int64> * x_w_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.
`ForeachXWY(x_w_y_elementAct)` Signature: x_w_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.
`ForeachXWY(...)` Signature: (x_w_y_elementAct:Action<int64,int64,int64> * x_w_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.
`ForeachXWY(...)` Signature: (x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_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.
`ForeachXWY(...)` Signature: (x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_y_elementAct:Action<int64,int64,int64> * x_w_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.
`ForeachXWYIndex(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.
`ForeachXWYIndex(...)` 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.
`ForeachXWYIndex(...)` 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.
`ForeachXWYIndex(...)` 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.
`ForeachXWYIndex(x_w_y_i_elementAct)` Signature: x_w_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.
`ForeachXWYIndex(...)` Signature: (x_w_y_i_elementAct:Action<int64,int64,int64,int64> * x_w_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.
`ForeachXWYIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_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.
`ForeachXWYIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_y_i_elementAct:Action<int64,int64,int64,int64> * x_w_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.
`ForeachXWYZ(x_w_y_z_elementAct)` Signature: x_w_y_z_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.
`ForeachXWYZ(...)` Signature: (x_w_y_z_elementAct:Action<int64,int64,int64,int64> * x_w_y_postLineAct:Action<int64,int64,int64> * x_w_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXWYZ(...)` Signature: (x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_y_preLineAct:Action<int64,int64,int64> * x_w_y_z_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.
`ForeachXWYZ(...)` Signature: (x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_y_preLineAct:Action<int64,int64,int64> * x_w_y_z_elementAct:Action<int64,int64,int64,int64> * x_w_y_postLineAct:Action<int64,int64,int64> * x_w_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXWYZIndex(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.
`ForeachXWYZIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXWYZIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachXWYZIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXWYZIndex(x_w_y_z_i_elementAct)` Signature: x_w_y_z_i_elementAct:Action<int64,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.
`ForeachXWYZIndex(...)` Signature: (x_w_y_z_i_elementAct:Action<int64,int64,int64,int64,int64> * x_w_y_postLineAct:Action<int64,int64,int64> * x_w_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXWYZIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_y_preLineAct:Action<int64,int64,int64> * x_w_y_z_i_elementAct:Action<int64,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.
`ForeachXWYZIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_y_preLineAct:Action<int64,int64,int64> * x_w_y_z_i_elementAct:Action<int64,int64,int64,int64,int64> * x_w_y_postLineAct:Action<int64,int64,int64> * x_w_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXWZ(x_w_z_elementAct)` Signature: x_w_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.
`ForeachXWZ(...)` Signature: (x_w_z_elementAct:Action<int64,int64,int64> * x_w_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.
`ForeachXWZ(...)` Signature: (x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_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.
`ForeachXWZ(...)` Signature: (x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_z_elementAct:Action<int64,int64,int64> * x_w_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.
`ForeachXWZIndex(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.
`ForeachXWZIndex(...)` 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.
`ForeachXWZIndex(...)` 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.
`ForeachXWZIndex(...)` 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.
`ForeachXWZIndex(x_w_z_i_elementAct)` Signature: x_w_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.
`ForeachXWZIndex(...)` Signature: (x_w_z_i_elementAct:Action<int64,int64,int64,int64> * x_w_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.
`ForeachXWZIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_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.
`ForeachXWZIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_z_i_elementAct:Action<int64,int64,int64,int64> * x_w_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.
`ForeachXWZY(x_w_z_y_elementAct)` Signature: x_w_z_y_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.
`ForeachXWZY(...)` Signature: (x_w_z_y_elementAct:Action<int64,int64,int64,int64> * x_w_z_postLineAct:Action<int64,int64,int64> * x_w_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXWZY(...)` Signature: (x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_z_preLineAct:Action<int64,int64,int64> * x_w_z_y_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.
`ForeachXWZY(...)` Signature: (x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_z_preLineAct:Action<int64,int64,int64> * x_w_z_y_elementAct:Action<int64,int64,int64,int64> * x_w_z_postLineAct:Action<int64,int64,int64> * x_w_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXWZYIndex(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.
`ForeachXWZYIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXWZYIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachXWZYIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXWZYIndex(x_w_z_y_i_elementAct)` Signature: x_w_z_y_i_elementAct:Action<int64,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.
`ForeachXWZYIndex(...)` Signature: (x_w_z_y_i_elementAct:Action<int64,int64,int64,int64,int64> * x_w_z_postLineAct:Action<int64,int64,int64> * x_w_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXWZYIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_z_preLineAct:Action<int64,int64,int64> * x_w_z_y_i_elementAct:Action<int64,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.
`ForeachXWZYIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_z_preLineAct:Action<int64,int64,int64> * x_w_z_y_i_elementAct:Action<int64,int64,int64,int64,int64> * x_w_z_postLineAct:Action<int64,int64,int64> * x_w_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`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.
`ForeachXYW(x_y_w_elementAct)` Signature: x_y_w_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.
`ForeachXYW(...)` Signature: (x_y_w_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.
`ForeachXYW(...)` Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_w_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.
`ForeachXYW(...)` Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_w_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.
`ForeachXYWIndex(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.
`ForeachXYWIndex(...)` 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.
`ForeachXYWIndex(...)` 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.
`ForeachXYWIndex(...)` 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.
`ForeachXYWIndex(x_y_w_i_elementAct)` Signature: x_y_w_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.
`ForeachXYWIndex(...)` Signature: (x_y_w_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.
`ForeachXYWIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_w_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.
`ForeachXYWIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_w_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.
`ForeachXYWZ(x_y_w_z_elementAct)` Signature: x_y_w_z_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.
`ForeachXYWZ(...)` Signature: (x_y_w_z_elementAct:Action<int64,int64,int64,int64> * x_y_w_postLineAct:Action<int64,int64,int64> * x_y_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXYWZ(...)` Signature: (x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_w_preLineAct:Action<int64,int64,int64> * x_y_w_z_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.
`ForeachXYWZ(...)` Signature: (x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_w_preLineAct:Action<int64,int64,int64> * x_y_w_z_elementAct:Action<int64,int64,int64,int64> * x_y_w_postLineAct:Action<int64,int64,int64> * x_y_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXYWZIndex(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.
`ForeachXYWZIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXYWZIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachXYWZIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXYWZIndex(x_y_w_z_i_elementAct)` Signature: x_y_w_z_i_elementAct:Action<int64,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.
`ForeachXYWZIndex(...)` Signature: (x_y_w_z_i_elementAct:Action<int64,int64,int64,int64,int64> * x_y_w_postLineAct:Action<int64,int64,int64> * x_y_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXYWZIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_w_preLineAct:Action<int64,int64,int64> * x_y_w_z_i_elementAct:Action<int64,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.
`ForeachXYWZIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_w_preLineAct:Action<int64,int64,int64> * x_y_w_z_i_elementAct:Action<int64,int64,int64,int64,int64> * x_y_w_postLineAct:Action<int64,int64,int64> * x_y_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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(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.
`ForeachXYZW(x_y_z_w_elementAct)` Signature: x_y_z_w_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.
`ForeachXYZW(...)` Signature: (x_y_z_w_elementAct:Action<int64,int64,int64,int64> * x_y_z_postLineAct:Action<int64,int64,int64> * x_y_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXYZW(...)` Signature: (x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_z_preLineAct:Action<int64,int64,int64> * x_y_z_w_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.
`ForeachXYZW(...)` Signature: (x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_z_preLineAct:Action<int64,int64,int64> * x_y_z_w_elementAct:Action<int64,int64,int64,int64> * x_y_z_postLineAct:Action<int64,int64,int64> * x_y_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXYZWIndex(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.
`ForeachXYZWIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXYZWIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachXYZWIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXYZWIndex(x_y_z_w_i_elementAct)` Signature: x_y_z_w_i_elementAct:Action<int64,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.
`ForeachXYZWIndex(...)` Signature: (x_y_z_w_i_elementAct:Action<int64,int64,int64,int64,int64> * x_y_z_postLineAct:Action<int64,int64,int64> * x_y_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXYZWIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_z_preLineAct:Action<int64,int64,int64> * x_y_z_w_i_elementAct:Action<int64,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.
`ForeachXYZWIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_z_preLineAct:Action<int64,int64,int64> * x_y_z_w_i_elementAct:Action<int64,int64,int64,int64,int64> * x_y_z_postLineAct:Action<int64,int64,int64> * x_y_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXZW(x_z_w_elementAct)` Signature: x_z_w_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.
`ForeachXZW(...)` Signature: (x_z_w_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.
`ForeachXZW(...)` Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_w_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.
`ForeachXZW(...)` Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_w_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.
`ForeachXZWIndex(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.
`ForeachXZWIndex(...)` 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.
`ForeachXZWIndex(...)` 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.
`ForeachXZWIndex(...)` 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.
`ForeachXZWIndex(x_z_w_i_elementAct)` Signature: x_z_w_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.
`ForeachXZWIndex(...)` Signature: (x_z_w_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.
`ForeachXZWIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_w_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.
`ForeachXZWIndex(...)` Signature: (x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_w_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.
`ForeachXZWY(x_z_w_y_elementAct)` Signature: x_z_w_y_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.
`ForeachXZWY(...)` Signature: (x_z_w_y_elementAct:Action<int64,int64,int64,int64> * x_z_w_postLineAct:Action<int64,int64,int64> * x_z_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXZWY(...)` Signature: (x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_w_preLineAct:Action<int64,int64,int64> * x_z_w_y_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.
`ForeachXZWY(...)` Signature: (x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_w_preLineAct:Action<int64,int64,int64> * x_z_w_y_elementAct:Action<int64,int64,int64,int64> * x_z_w_postLineAct:Action<int64,int64,int64> * x_z_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXZWYIndex(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.
`ForeachXZWYIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXZWYIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachXZWYIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXZWYIndex(x_z_w_y_i_elementAct)` Signature: x_z_w_y_i_elementAct:Action<int64,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.
`ForeachXZWYIndex(...)` Signature: (x_z_w_y_i_elementAct:Action<int64,int64,int64,int64,int64> * x_z_w_postLineAct:Action<int64,int64,int64> * x_z_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXZWYIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_w_preLineAct:Action<int64,int64,int64> * x_z_w_y_i_elementAct:Action<int64,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.
`ForeachXZWYIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_w_preLineAct:Action<int64,int64,int64> * x_z_w_y_i_elementAct:Action<int64,int64,int64,int64,int64> * x_z_w_postLineAct:Action<int64,int64,int64> * x_z_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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(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.
`ForeachXZYW(x_z_y_w_elementAct)` Signature: x_z_y_w_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.
`ForeachXZYW(...)` Signature: (x_z_y_w_elementAct:Action<int64,int64,int64,int64> * x_z_y_postLineAct:Action<int64,int64,int64> * x_z_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXZYW(...)` Signature: (x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_y_preLineAct:Action<int64,int64,int64> * x_z_y_w_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.
`ForeachXZYW(...)` Signature: (x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_y_preLineAct:Action<int64,int64,int64> * x_z_y_w_elementAct:Action<int64,int64,int64,int64> * x_z_y_postLineAct:Action<int64,int64,int64> * x_z_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXZYWIndex(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.
`ForeachXZYWIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXZYWIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachXZYWIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachXZYWIndex(x_z_y_w_i_elementAct)` Signature: x_z_y_w_i_elementAct:Action<int64,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.
`ForeachXZYWIndex(...)` Signature: (x_z_y_w_i_elementAct:Action<int64,int64,int64,int64,int64> * x_z_y_postLineAct:Action<int64,int64,int64> * x_z_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachXZYWIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_y_preLineAct:Action<int64,int64,int64> * x_z_y_w_i_elementAct:Action<int64,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.
`ForeachXZYWIndex(...)` Signature: (x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_y_preLineAct:Action<int64,int64,int64> * x_z_y_w_i_elementAct:Action<int64,int64,int64,int64,int64> * x_z_y_postLineAct:Action<int64,int64,int64> * x_z_postPlaneAct:Action<int64,int64> * x_postVolumeAct: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.
`ForeachYW(y_w_elementAct)` Signature: y_w_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.
`ForeachYW(y_w_elementAct, y_postLineAct)` Signature: (y_w_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.
`ForeachYW(y_preLineAct, y_w_elementAct)` Signature: (y_preLineAct:Action<int64> * y_w_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.
`ForeachYW(...)` Signature: (y_preLineAct:Action<int64> * y_w_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.
`ForeachYWIndex(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.
`ForeachYWIndex(...)` 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.
`ForeachYWIndex(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.
`ForeachYWIndex(...)` 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.
`ForeachYWIndex(y_w_i_elementAct)` Signature: y_w_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.
`ForeachYWIndex(...)` Signature: (y_w_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.
`ForeachYWIndex(...)` Signature: (y_preLineAct:Action<int64> * y_w_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.
`ForeachYWIndex(...)` Signature: (y_preLineAct:Action<int64> * y_w_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.
`ForeachYWX(y_w_x_elementAct)` Signature: y_w_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.
`ForeachYWX(...)` Signature: (y_w_x_elementAct:Action<int64,int64,int64> * y_w_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.
`ForeachYWX(...)` Signature: (y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_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.
`ForeachYWX(...)` Signature: (y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_x_elementAct:Action<int64,int64,int64> * y_w_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.
`ForeachYWXIndex(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.
`ForeachYWXIndex(...)` 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.
`ForeachYWXIndex(...)` 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.
`ForeachYWXIndex(...)` 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.
`ForeachYWXIndex(y_w_x_i_elementAct)` Signature: y_w_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.
`ForeachYWXIndex(...)` Signature: (y_w_x_i_elementAct:Action<int64,int64,int64,int64> * y_w_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.
`ForeachYWXIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_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.
`ForeachYWXIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_x_i_elementAct:Action<int64,int64,int64,int64> * y_w_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.
`ForeachYWXZ(y_w_x_z_elementAct)` Signature: y_w_x_z_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.
`ForeachYWXZ(...)` Signature: (y_w_x_z_elementAct:Action<int64,int64,int64,int64> * y_w_x_postLineAct:Action<int64,int64,int64> * y_w_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYWXZ(...)` Signature: (y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_x_preLineAct:Action<int64,int64,int64> * y_w_x_z_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.
`ForeachYWXZ(...)` Signature: (y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_x_preLineAct:Action<int64,int64,int64> * y_w_x_z_elementAct:Action<int64,int64,int64,int64> * y_w_x_postLineAct:Action<int64,int64,int64> * y_w_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYWXZIndex(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.
`ForeachYWXZIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYWXZIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachYWXZIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYWXZIndex(y_w_x_z_i_elementAct)` Signature: y_w_x_z_i_elementAct:Action<int64,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.
`ForeachYWXZIndex(...)` Signature: (y_w_x_z_i_elementAct:Action<int64,int64,int64,int64,int64> * y_w_x_postLineAct:Action<int64,int64,int64> * y_w_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYWXZIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_x_preLineAct:Action<int64,int64,int64> * y_w_x_z_i_elementAct:Action<int64,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.
`ForeachYWXZIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_x_preLineAct:Action<int64,int64,int64> * y_w_x_z_i_elementAct:Action<int64,int64,int64,int64,int64> * y_w_x_postLineAct:Action<int64,int64,int64> * y_w_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYWZ(y_w_z_elementAct)` Signature: y_w_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.
`ForeachYWZ(...)` Signature: (y_w_z_elementAct:Action<int64,int64,int64> * y_w_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.
`ForeachYWZ(...)` Signature: (y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_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.
`ForeachYWZ(...)` Signature: (y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_z_elementAct:Action<int64,int64,int64> * y_w_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.
`ForeachYWZIndex(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.
`ForeachYWZIndex(...)` 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.
`ForeachYWZIndex(...)` 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.
`ForeachYWZIndex(...)` 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.
`ForeachYWZIndex(y_w_z_i_elementAct)` Signature: y_w_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.
`ForeachYWZIndex(...)` Signature: (y_w_z_i_elementAct:Action<int64,int64,int64,int64> * y_w_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.
`ForeachYWZIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_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.
`ForeachYWZIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_z_i_elementAct:Action<int64,int64,int64,int64> * y_w_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.
`ForeachYWZX(y_w_z_x_elementAct)` Signature: y_w_z_x_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.
`ForeachYWZX(...)` Signature: (y_w_z_x_elementAct:Action<int64,int64,int64,int64> * y_w_z_postLineAct:Action<int64,int64,int64> * y_w_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYWZX(...)` Signature: (y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_z_preLineAct:Action<int64,int64,int64> * y_w_z_x_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.
`ForeachYWZX(...)` Signature: (y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_z_preLineAct:Action<int64,int64,int64> * y_w_z_x_elementAct:Action<int64,int64,int64,int64> * y_w_z_postLineAct:Action<int64,int64,int64> * y_w_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYWZXIndex(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.
`ForeachYWZXIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYWZXIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachYWZXIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYWZXIndex(y_w_z_x_i_elementAct)` Signature: y_w_z_x_i_elementAct:Action<int64,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.
`ForeachYWZXIndex(...)` Signature: (y_w_z_x_i_elementAct:Action<int64,int64,int64,int64,int64> * y_w_z_postLineAct:Action<int64,int64,int64> * y_w_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYWZXIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_z_preLineAct:Action<int64,int64,int64> * y_w_z_x_i_elementAct:Action<int64,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.
`ForeachYWZXIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_z_preLineAct:Action<int64,int64,int64> * y_w_z_x_i_elementAct:Action<int64,int64,int64,int64,int64> * y_w_z_postLineAct:Action<int64,int64,int64> * y_w_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`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.
`ForeachYXW(y_x_w_elementAct)` Signature: y_x_w_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.
`ForeachYXW(...)` Signature: (y_x_w_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.
`ForeachYXW(...)` Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_w_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.
`ForeachYXW(...)` Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_w_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.
`ForeachYXWIndex(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.
`ForeachYXWIndex(...)` 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.
`ForeachYXWIndex(...)` 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.
`ForeachYXWIndex(...)` 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.
`ForeachYXWIndex(y_x_w_i_elementAct)` Signature: y_x_w_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.
`ForeachYXWIndex(...)` Signature: (y_x_w_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.
`ForeachYXWIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_w_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.
`ForeachYXWIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_w_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.
`ForeachYXWZ(y_x_w_z_elementAct)` Signature: y_x_w_z_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.
`ForeachYXWZ(...)` Signature: (y_x_w_z_elementAct:Action<int64,int64,int64,int64> * y_x_w_postLineAct:Action<int64,int64,int64> * y_x_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYXWZ(...)` Signature: (y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_w_preLineAct:Action<int64,int64,int64> * y_x_w_z_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.
`ForeachYXWZ(...)` Signature: (y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_w_preLineAct:Action<int64,int64,int64> * y_x_w_z_elementAct:Action<int64,int64,int64,int64> * y_x_w_postLineAct:Action<int64,int64,int64> * y_x_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYXWZIndex(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.
`ForeachYXWZIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYXWZIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachYXWZIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYXWZIndex(y_x_w_z_i_elementAct)` Signature: y_x_w_z_i_elementAct:Action<int64,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.
`ForeachYXWZIndex(...)` Signature: (y_x_w_z_i_elementAct:Action<int64,int64,int64,int64,int64> * y_x_w_postLineAct:Action<int64,int64,int64> * y_x_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYXWZIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_w_preLineAct:Action<int64,int64,int64> * y_x_w_z_i_elementAct:Action<int64,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.
`ForeachYXWZIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_w_preLineAct:Action<int64,int64,int64> * y_x_w_z_i_elementAct:Action<int64,int64,int64,int64,int64> * y_x_w_postLineAct:Action<int64,int64,int64> * y_x_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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(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.
`ForeachYXZW(y_x_z_w_elementAct)` Signature: y_x_z_w_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.
`ForeachYXZW(...)` Signature: (y_x_z_w_elementAct:Action<int64,int64,int64,int64> * y_x_z_postLineAct:Action<int64,int64,int64> * y_x_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYXZW(...)` Signature: (y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_z_preLineAct:Action<int64,int64,int64> * y_x_z_w_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.
`ForeachYXZW(...)` Signature: (y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_z_preLineAct:Action<int64,int64,int64> * y_x_z_w_elementAct:Action<int64,int64,int64,int64> * y_x_z_postLineAct:Action<int64,int64,int64> * y_x_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYXZWIndex(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.
`ForeachYXZWIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYXZWIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachYXZWIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYXZWIndex(y_x_z_w_i_elementAct)` Signature: y_x_z_w_i_elementAct:Action<int64,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.
`ForeachYXZWIndex(...)` Signature: (y_x_z_w_i_elementAct:Action<int64,int64,int64,int64,int64> * y_x_z_postLineAct:Action<int64,int64,int64> * y_x_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYXZWIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_z_preLineAct:Action<int64,int64,int64> * y_x_z_w_i_elementAct:Action<int64,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.
`ForeachYXZWIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_z_preLineAct:Action<int64,int64,int64> * y_x_z_w_i_elementAct:Action<int64,int64,int64,int64,int64> * y_x_z_postLineAct:Action<int64,int64,int64> * y_x_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYZW(y_z_w_elementAct)` Signature: y_z_w_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.
`ForeachYZW(...)` Signature: (y_z_w_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.
`ForeachYZW(...)` Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_w_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.
`ForeachYZW(...)` Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_w_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.
`ForeachYZWIndex(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.
`ForeachYZWIndex(...)` 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.
`ForeachYZWIndex(...)` 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.
`ForeachYZWIndex(...)` 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.
`ForeachYZWIndex(y_z_w_i_elementAct)` Signature: y_z_w_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.
`ForeachYZWIndex(...)` Signature: (y_z_w_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.
`ForeachYZWIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_w_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.
`ForeachYZWIndex(...)` Signature: (y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_w_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.
`ForeachYZWX(y_z_w_x_elementAct)` Signature: y_z_w_x_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.
`ForeachYZWX(...)` Signature: (y_z_w_x_elementAct:Action<int64,int64,int64,int64> * y_z_w_postLineAct:Action<int64,int64,int64> * y_z_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYZWX(...)` Signature: (y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_w_preLineAct:Action<int64,int64,int64> * y_z_w_x_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.
`ForeachYZWX(...)` Signature: (y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_w_preLineAct:Action<int64,int64,int64> * y_z_w_x_elementAct:Action<int64,int64,int64,int64> * y_z_w_postLineAct:Action<int64,int64,int64> * y_z_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYZWXIndex(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.
`ForeachYZWXIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYZWXIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachYZWXIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYZWXIndex(y_z_w_x_i_elementAct)` Signature: y_z_w_x_i_elementAct:Action<int64,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.
`ForeachYZWXIndex(...)` Signature: (y_z_w_x_i_elementAct:Action<int64,int64,int64,int64,int64> * y_z_w_postLineAct:Action<int64,int64,int64> * y_z_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYZWXIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_w_preLineAct:Action<int64,int64,int64> * y_z_w_x_i_elementAct:Action<int64,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.
`ForeachYZWXIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_w_preLineAct:Action<int64,int64,int64> * y_z_w_x_i_elementAct:Action<int64,int64,int64,int64,int64> * y_z_w_postLineAct:Action<int64,int64,int64> * y_z_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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(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.
`ForeachYZXW(y_z_x_w_elementAct)` Signature: y_z_x_w_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.
`ForeachYZXW(...)` Signature: (y_z_x_w_elementAct:Action<int64,int64,int64,int64> * y_z_x_postLineAct:Action<int64,int64,int64> * y_z_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYZXW(...)` Signature: (y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_x_preLineAct:Action<int64,int64,int64> * y_z_x_w_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.
`ForeachYZXW(...)` Signature: (y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_x_preLineAct:Action<int64,int64,int64> * y_z_x_w_elementAct:Action<int64,int64,int64,int64> * y_z_x_postLineAct:Action<int64,int64,int64> * y_z_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYZXWIndex(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.
`ForeachYZXWIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYZXWIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachYZXWIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachYZXWIndex(y_z_x_w_i_elementAct)` Signature: y_z_x_w_i_elementAct:Action<int64,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.
`ForeachYZXWIndex(...)` Signature: (y_z_x_w_i_elementAct:Action<int64,int64,int64,int64,int64> * y_z_x_postLineAct:Action<int64,int64,int64> * y_z_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachYZXWIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_x_preLineAct:Action<int64,int64,int64> * y_z_x_w_i_elementAct:Action<int64,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.
`ForeachYZXWIndex(...)` Signature: (y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_x_preLineAct:Action<int64,int64,int64> * y_z_x_w_i_elementAct:Action<int64,int64,int64,int64,int64> * y_z_x_postLineAct:Action<int64,int64,int64> * y_z_postPlaneAct:Action<int64,int64> * y_postVolumeAct: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.
`ForeachZW(z_w_elementAct)` Signature: z_w_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.
`ForeachZW(z_w_elementAct, z_postLineAct)` Signature: (z_w_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.
`ForeachZW(z_preLineAct, z_w_elementAct)` Signature: (z_preLineAct:Action<int64> * z_w_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.
`ForeachZW(...)` Signature: (z_preLineAct:Action<int64> * z_w_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.
`ForeachZWIndex(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.
`ForeachZWIndex(...)` 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.
`ForeachZWIndex(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.
`ForeachZWIndex(...)` 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.
`ForeachZWIndex(z_w_i_elementAct)` Signature: z_w_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.
`ForeachZWIndex(...)` Signature: (z_w_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.
`ForeachZWIndex(...)` Signature: (z_preLineAct:Action<int64> * z_w_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.
`ForeachZWIndex(...)` Signature: (z_preLineAct:Action<int64> * z_w_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.
`ForeachZWX(z_w_x_elementAct)` Signature: z_w_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.
`ForeachZWX(...)` Signature: (z_w_x_elementAct:Action<int64,int64,int64> * z_w_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.
`ForeachZWX(...)` Signature: (z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_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.
`ForeachZWX(...)` Signature: (z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_x_elementAct:Action<int64,int64,int64> * z_w_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.
`ForeachZWXIndex(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.
`ForeachZWXIndex(...)` 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.
`ForeachZWXIndex(...)` 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.
`ForeachZWXIndex(...)` 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.
`ForeachZWXIndex(z_w_x_i_elementAct)` Signature: z_w_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.
`ForeachZWXIndex(...)` Signature: (z_w_x_i_elementAct:Action<int64,int64,int64,int64> * z_w_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.
`ForeachZWXIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_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.
`ForeachZWXIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_x_i_elementAct:Action<int64,int64,int64,int64> * z_w_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.
`ForeachZWXY(z_w_x_y_elementAct)` Signature: z_w_x_y_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.
`ForeachZWXY(...)` Signature: (z_w_x_y_elementAct:Action<int64,int64,int64,int64> * z_w_x_postLineAct:Action<int64,int64,int64> * z_w_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZWXY(...)` Signature: (z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_x_preLineAct:Action<int64,int64,int64> * z_w_x_y_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.
`ForeachZWXY(...)` Signature: (z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_x_preLineAct:Action<int64,int64,int64> * z_w_x_y_elementAct:Action<int64,int64,int64,int64> * z_w_x_postLineAct:Action<int64,int64,int64> * z_w_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZWXYIndex(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.
`ForeachZWXYIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZWXYIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachZWXYIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZWXYIndex(z_w_x_y_i_elementAct)` Signature: z_w_x_y_i_elementAct:Action<int64,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.
`ForeachZWXYIndex(...)` Signature: (z_w_x_y_i_elementAct:Action<int64,int64,int64,int64,int64> * z_w_x_postLineAct:Action<int64,int64,int64> * z_w_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZWXYIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_x_preLineAct:Action<int64,int64,int64> * z_w_x_y_i_elementAct:Action<int64,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.
`ForeachZWXYIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_x_preLineAct:Action<int64,int64,int64> * z_w_x_y_i_elementAct:Action<int64,int64,int64,int64,int64> * z_w_x_postLineAct:Action<int64,int64,int64> * z_w_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZWY(z_w_y_elementAct)` Signature: z_w_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.
`ForeachZWY(...)` Signature: (z_w_y_elementAct:Action<int64,int64,int64> * z_w_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.
`ForeachZWY(...)` Signature: (z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_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.
`ForeachZWY(...)` Signature: (z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_y_elementAct:Action<int64,int64,int64> * z_w_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.
`ForeachZWYIndex(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.
`ForeachZWYIndex(...)` 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.
`ForeachZWYIndex(...)` 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.
`ForeachZWYIndex(...)` 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.
`ForeachZWYIndex(z_w_y_i_elementAct)` Signature: z_w_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.
`ForeachZWYIndex(...)` Signature: (z_w_y_i_elementAct:Action<int64,int64,int64,int64> * z_w_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.
`ForeachZWYIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_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.
`ForeachZWYIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_y_i_elementAct:Action<int64,int64,int64,int64> * z_w_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.
`ForeachZWYX(z_w_y_x_elementAct)` Signature: z_w_y_x_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.
`ForeachZWYX(...)` Signature: (z_w_y_x_elementAct:Action<int64,int64,int64,int64> * z_w_y_postLineAct:Action<int64,int64,int64> * z_w_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZWYX(...)` Signature: (z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_y_preLineAct:Action<int64,int64,int64> * z_w_y_x_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.
`ForeachZWYX(...)` Signature: (z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_y_preLineAct:Action<int64,int64,int64> * z_w_y_x_elementAct:Action<int64,int64,int64,int64> * z_w_y_postLineAct:Action<int64,int64,int64> * z_w_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZWYXIndex(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.
`ForeachZWYXIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZWYXIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachZWYXIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZWYXIndex(z_w_y_x_i_elementAct)` Signature: z_w_y_x_i_elementAct:Action<int64,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.
`ForeachZWYXIndex(...)` Signature: (z_w_y_x_i_elementAct:Action<int64,int64,int64,int64,int64> * z_w_y_postLineAct:Action<int64,int64,int64> * z_w_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZWYXIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_y_preLineAct:Action<int64,int64,int64> * z_w_y_x_i_elementAct:Action<int64,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.
`ForeachZWYXIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_y_preLineAct:Action<int64,int64,int64> * z_w_y_x_i_elementAct:Action<int64,int64,int64,int64,int64> * z_w_y_postLineAct:Action<int64,int64,int64> * z_w_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`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.
`ForeachZXW(z_x_w_elementAct)` Signature: z_x_w_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.
`ForeachZXW(...)` Signature: (z_x_w_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.
`ForeachZXW(...)` Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_w_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.
`ForeachZXW(...)` Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_w_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.
`ForeachZXWIndex(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.
`ForeachZXWIndex(...)` 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.
`ForeachZXWIndex(...)` 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.
`ForeachZXWIndex(...)` 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.
`ForeachZXWIndex(z_x_w_i_elementAct)` Signature: z_x_w_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.
`ForeachZXWIndex(...)` Signature: (z_x_w_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.
`ForeachZXWIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_w_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.
`ForeachZXWIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_w_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.
`ForeachZXWY(z_x_w_y_elementAct)` Signature: z_x_w_y_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.
`ForeachZXWY(...)` Signature: (z_x_w_y_elementAct:Action<int64,int64,int64,int64> * z_x_w_postLineAct:Action<int64,int64,int64> * z_x_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZXWY(...)` Signature: (z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_w_preLineAct:Action<int64,int64,int64> * z_x_w_y_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.
`ForeachZXWY(...)` Signature: (z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_w_preLineAct:Action<int64,int64,int64> * z_x_w_y_elementAct:Action<int64,int64,int64,int64> * z_x_w_postLineAct:Action<int64,int64,int64> * z_x_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZXWYIndex(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.
`ForeachZXWYIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZXWYIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachZXWYIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZXWYIndex(z_x_w_y_i_elementAct)` Signature: z_x_w_y_i_elementAct:Action<int64,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.
`ForeachZXWYIndex(...)` Signature: (z_x_w_y_i_elementAct:Action<int64,int64,int64,int64,int64> * z_x_w_postLineAct:Action<int64,int64,int64> * z_x_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZXWYIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_w_preLineAct:Action<int64,int64,int64> * z_x_w_y_i_elementAct:Action<int64,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.
`ForeachZXWYIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_w_preLineAct:Action<int64,int64,int64> * z_x_w_y_i_elementAct:Action<int64,int64,int64,int64,int64> * z_x_w_postLineAct:Action<int64,int64,int64> * z_x_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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(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.
`ForeachZXYW(z_x_y_w_elementAct)` Signature: z_x_y_w_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.
`ForeachZXYW(...)` Signature: (z_x_y_w_elementAct:Action<int64,int64,int64,int64> * z_x_y_postLineAct:Action<int64,int64,int64> * z_x_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZXYW(...)` Signature: (z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_y_preLineAct:Action<int64,int64,int64> * z_x_y_w_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.
`ForeachZXYW(...)` Signature: (z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_y_preLineAct:Action<int64,int64,int64> * z_x_y_w_elementAct:Action<int64,int64,int64,int64> * z_x_y_postLineAct:Action<int64,int64,int64> * z_x_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZXYWIndex(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.
`ForeachZXYWIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZXYWIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachZXYWIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZXYWIndex(z_x_y_w_i_elementAct)` Signature: z_x_y_w_i_elementAct:Action<int64,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.
`ForeachZXYWIndex(...)` Signature: (z_x_y_w_i_elementAct:Action<int64,int64,int64,int64,int64> * z_x_y_postLineAct:Action<int64,int64,int64> * z_x_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZXYWIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_y_preLineAct:Action<int64,int64,int64> * z_x_y_w_i_elementAct:Action<int64,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.
`ForeachZXYWIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_y_preLineAct:Action<int64,int64,int64> * z_x_y_w_i_elementAct:Action<int64,int64,int64,int64,int64> * z_x_y_postLineAct:Action<int64,int64,int64> * z_x_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZYW(z_y_w_elementAct)` Signature: z_y_w_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.
`ForeachZYW(...)` Signature: (z_y_w_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.
`ForeachZYW(...)` Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_w_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.
`ForeachZYW(...)` Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_w_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.
`ForeachZYWIndex(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.
`ForeachZYWIndex(...)` 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.
`ForeachZYWIndex(...)` 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.
`ForeachZYWIndex(...)` 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.
`ForeachZYWIndex(z_y_w_i_elementAct)` Signature: z_y_w_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.
`ForeachZYWIndex(...)` Signature: (z_y_w_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.
`ForeachZYWIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_w_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.
`ForeachZYWIndex(...)` Signature: (z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_w_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.
`ForeachZYWX(z_y_w_x_elementAct)` Signature: z_y_w_x_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.
`ForeachZYWX(...)` Signature: (z_y_w_x_elementAct:Action<int64,int64,int64,int64> * z_y_w_postLineAct:Action<int64,int64,int64> * z_y_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZYWX(...)` Signature: (z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_w_preLineAct:Action<int64,int64,int64> * z_y_w_x_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.
`ForeachZYWX(...)` Signature: (z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_w_preLineAct:Action<int64,int64,int64> * z_y_w_x_elementAct:Action<int64,int64,int64,int64> * z_y_w_postLineAct:Action<int64,int64,int64> * z_y_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZYWXIndex(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.
`ForeachZYWXIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZYWXIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachZYWXIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZYWXIndex(z_y_w_x_i_elementAct)` Signature: z_y_w_x_i_elementAct:Action<int64,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.
`ForeachZYWXIndex(...)` Signature: (z_y_w_x_i_elementAct:Action<int64,int64,int64,int64,int64> * z_y_w_postLineAct:Action<int64,int64,int64> * z_y_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZYWXIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_w_preLineAct:Action<int64,int64,int64> * z_y_w_x_i_elementAct:Action<int64,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.
`ForeachZYWXIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_w_preLineAct:Action<int64,int64,int64> * z_y_w_x_i_elementAct:Action<int64,int64,int64,int64,int64> * z_y_w_postLineAct:Action<int64,int64,int64> * z_y_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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(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.
`ForeachZYXW(z_y_x_w_elementAct)` Signature: z_y_x_w_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.
`ForeachZYXW(...)` Signature: (z_y_x_w_elementAct:Action<int64,int64,int64,int64> * z_y_x_postLineAct:Action<int64,int64,int64> * z_y_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZYXW(...)` Signature: (z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_x_preLineAct:Action<int64,int64,int64> * z_y_x_w_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.
`ForeachZYXW(...)` Signature: (z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_x_preLineAct:Action<int64,int64,int64> * z_y_x_w_elementAct:Action<int64,int64,int64,int64> * z_y_x_postLineAct:Action<int64,int64,int64> * z_y_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZYXWIndex(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.
`ForeachZYXWIndex(...)` Signature: (i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZYXWIndex(...)` Signature: (preVolumeAct:Action * 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.
`ForeachZYXWIndex(...)` Signature: (preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action * postPlaneAct:Action * postVolumeAct: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.
`ForeachZYXWIndex(z_y_x_w_i_elementAct)` Signature: z_y_x_w_i_elementAct:Action<int64,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.
`ForeachZYXWIndex(...)` Signature: (z_y_x_w_i_elementAct:Action<int64,int64,int64,int64,int64> * z_y_x_postLineAct:Action<int64,int64,int64> * z_y_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`ForeachZYXWIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_x_preLineAct:Action<int64,int64,int64> * z_y_x_w_i_elementAct:Action<int64,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.
`ForeachZYXWIndex(...)` Signature: (z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_x_preLineAct:Action<int64,int64,int64> * z_y_x_w_i_elementAct:Action<int64,int64,int64,int64,int64> * z_y_x_postLineAct:Action<int64,int64,int64> * z_y_postPlaneAct:Action<int64,int64> * z_postVolumeAct: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.
`FW()` Signature: unit -> unit	First in dimension W.
`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, w)` Signature: (x:int64 * y:int64 * z:int64 * w:int64) -> obj Modifiers: abstract
`GetValue(v)` Signature: v:V4l -> obj Modifiers: abstract
`IIII` Signature: V4l
`IIIO` Signature: V4l
`IIOI` Signature: V4l
`IIOO` Signature: V4l
`InnerProduct(t1, mulFun, bias, sumFun)` Signature: (t1:Tensor4<'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:Tensor4<'T1d,'T1> * mulFun:Func<'Td,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts>) -> 'Ts Type parameters: 'T1, 'Tm, 'Ts
`InnerProduct(...)` Signature: (t1:Tensor4<'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:Tensor4<'T1d,'T1> * mulFun:Func<'Td,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * breakIfTrueFun:Func<'Ts,bool>) -> 'Ts Type parameters: 'T1, 'Tm, 'Ts
`IOII` Signature: V4l
`IOIO` Signature: V4l
`IOOI` Signature: V4l
`IOOO` Signature: V4l
`IsInvalid` Signature: bool Modifiers: abstract	Returns true if the tensor4 does not have a data array.
`IsValid` Signature: bool Modifiers: abstract	Returns true if the tensor4 has a data array.
`[()]` Signature: unit -> V4l Modifiers: abstract	Get/Set element at specified coordinate.
`[()]` Signature: unit -> V4i	Get/Set element at specified coordinate.
`[()]` Signature: unit -> int64	Get/Set element at the specified index in the underlying data array.
`[arg1, arg2, arg3]` Signature: int64 * int64 * int64 -> int64 Modifiers: abstract	Get/Set element at specified coordinates.
`[arg1, arg2, arg3]` Signature: int * int * int -> int	Get/Set element at specified coordinates.
`JW` Signature: int64	Jump this many elements in the underlying data array when stepping in dimension W.
`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> -> Tensor4<'T1>	Elementwise copy with function application. This methods returns a Tensor4 with zero as first coordinates.
`MapWindow(fun)` Signature: fun:Func<'Td,'T1> -> Tensor4<'T1>	Elementwise copy with function application. This method retains the coordinates of the original Tensor4.
`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,int64,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr>) -> 'Tr Type parameters: 'Ti
`Norm(elementFun, bias, sumFun)` Signature: (elementFun:Func<'Td,V4l,'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,int64,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr> * breakIfTrueFun:Func<'Tr,bool>) -> 'Tr Type parameters: 'Ti
`Norm(...)` Signature: (elementFun:Func<'Td,V4l,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr> * breakIfTrueFun:Func<'Tr,bool>) -> 'Tr Type parameters: 'Ti
`OIII` Signature: V4l
`OIIO` Signature: V4l
`OIOI` Signature: V4l
`OIOO` Signature: V4l
`OOII` Signature: V4l
`OOIO` Signature: V4l
`OOOI` Signature: V4l
`OOOO` Signature: V4l
`Origin()` Signature: unit -> unit Modifiers: abstract
`OriginIndex()` Signature: unit -> unit Modifiers: abstract
`Rank` Signature: int Modifiers: abstract	Return the rank or dimension of the tensor4 (4).
`Repeated(count)` Signature: count:V4l -> Tensor4<'Td>	Returns a tensor repeated in each dimension by the specified count.
`S()` Signature: unit -> unit	Size
`Sample16(...)` Signature: (v:V4d * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'T3> * wipl:Func<float,'T3,'T3,'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>> * index_min_max_delta_wIndexFun:Func<int64,int64,int64,int64,Tup2<int64>>) -> 'TRes Type parameters: 'T2, 'T3, 'TRes
`Sample16(...)` Signature: (x:float * y:float * z:float * w:float * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'T3> * wipl:Func<float,'T3,'T3,'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>> * index_min_max_delta_wIndexFun:Func<int64,int64,int64,int64,Tup2<int64>>) -> 'TRes Type parameters: 'T2, 'T3, 'TRes	Sample the tensor4 using 16 neighbouring samples and the supplied interpolation functions and border handling functions. If only integer coordinates are supplied the returned value is the same as the indexer of the tensor4, i.e. voxel centers are assumed to be on integer coordinates.
`Sample16Clamped(...)` Signature: (v:V4d * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'T3> * wipl:Func<float,'T3,'T3,'TRes>) -> 'TRes Type parameters: 'T2, 'T3, 'TRes
`Sample16Clamped(...)` Signature: (x:float * y:float * z:float * w:float * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'T3> * wipl:Func<float,'T3,'T3,'TRes>) -> 'TRes Type parameters: 'T2, 'T3, 'TRes
`SampleRaw16(v, xipl, yipl, zipl, wipl)` Signature: (v:V4d * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'T3> * wipl:Func<float,'T3,'T3,'TRes>) -> 'TRes Type parameters: 'T2, 'T3, 'TRes
`SampleRaw16(...)` Signature: (x:float * y:float * z:float * w:float * xipl:Func<float,'Td,'Td,'T1> * yipl:Func<float,'T1,'T1,'T2> * zipl:Func<float,'T2,'T2,'T3> * wipl:Func<float,'T3,'T3,'TRes>) -> 'TRes Type parameters: 'T2, 'T3, 'TRes	Sample the tensor4 using 16 samples and the supplied interpolation functions. If only integer coordinates are supplied the returned value is the same as the indexer of the tensor4, i.e. voxel centers are assumed to be on integer coordinates. No bounds checking is performed.
`Set(v)` Signature: v:'Td -> Tensor4<'Td>	Sets all elements to the supplied value.
`Set(it1)` Signature: it1:ITensor4<'Td> -> Tensor4<'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:Tensor4<'Td> -> Tensor4<'Td>	Copy all elements from another tensor4.
`Set(t1, element1_elementFun)` Signature: (t1:Tensor4<'T1> * element1_elementFun:Func<'T1,'Td>) -> Tensor4<'Td>	Set the elements of a tensor4 to the result of a function of the elements of the supplied tensor4.
`Set(t1)` Signature: t1:Tensor4<'T1,'Td> -> Tensor4<'Td>	Copy all elements from another tensor4.
`Set(t1, element1_elementFun)` Signature: (t1:Tensor4<'T1d,'T1> * element1_elementFun:Func<'T1,'Td>) -> Tensor4<'Td> Type parameters: 'T1	Set the elements of a tensor4 to the result of a function of the elements of the supplied tensor4.
`Set(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T2	Set the elements of a tensor4 to the result of a function of corresponding pairs of elements of the two supplied tensors.
`Set(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2	Set the elements of a tensor4 to the result of a function of corresponding pairs of elements of the two supplied tensors.
`Set(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2	Set the elements of a tensor4 to the result of a function of corresponding pairs of elements of the two supplied tensors.
`Set(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2	Set the elements of a tensor4 to the result of a function of corresponding pairs of elements of the two supplied tensors.
`Set(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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_w_elementFun)` Signature: x_y_z_w_elementFun:Func<int64,int64,int64,int64,'Td> -> Tensor4<'Td>	Set each element to the value of a function of the element coords.
`SetByCoord(crd_elementFun)` Signature: crd_elementFun:Func<V4l,'Td> -> Tensor4<'Td>	Set each element to the value of a function of the element coords.
`SetByCoord(wFun, zFun, yFun, fun)` Signature: (wFun:Func<int64,'Tw> * zFun:Func<int64,int64,'Tw,'Tz> * yFun:Func<int64,int64,int64,'Tw,'Tz,'Ty> * fun:Func<int64,int64,int64,int64,'Tw,'Tz,'Ty,'Td>) -> Tensor4<'Td> Type parameters: 'Tz, 'Ty	Set each element to the value of a function of the element coords.
`SetByIndex(index_elementFun)` Signature: index_elementFun:Func<int64,'Td> -> Tensor4<'Td>	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(t1, index1_elementFun)` Signature: (t1:Tensor4<'T1> * index1_elementFun:Func<int64,'Td>) -> Tensor4<'Td>	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(t1, index1_elementFun)` Signature: (t1:Tensor4<'T1d,'T1> * index1_elementFun:Func<int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * index1_index2_elementFun:Func<int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * index1_index2_elementFun:Func<int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * index1_index2_elementFun:Func<int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * index1_index2_elementFun:Func<int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2, 'T3	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2, 'T3d, 'T3	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2, 'T3	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'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 tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2, 'T3	Set each element to the value of a function of the index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'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 tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'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 tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetByIndex(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'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 tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the tensor4.
`SetConvolution(...)` Signature: (image:Tensor4<'Ti> * filter:Tensor4<'Tf> * mulFun:Func<'Ti,'Tf,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * castFun:Func<'Ts,'Td>) -> Tensor4<'Td> Type parameters: 'Tf, 'Tm, 'Ts	Set the tensor4 to be the convolution of the supplied image and filter tensors.
`SetMap(t1, element1_elementFun)` Signature: (t1:Tensor4<'T1> * element1_elementFun:Func<'T1,'Td>) -> Tensor4<'Td>	Set the elements of a tensor4 to the result of a function of the elements of the supplied tensor4.
`SetMap(t1, element1_elementFun)` Signature: (t1:Tensor4<'T1d,'T1> * element1_elementFun:Func<'T1,'Td>) -> Tensor4<'Td> Type parameters: 'T1	Set the elements of a tensor4 to the result of a function of the elements of the supplied tensor4.
`SetMap2(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T2	Set the elements of a tensor4 to the result of a function of corresponding pairs of elements of the two supplied tensors.
`SetMap2(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2	Set the elements of a tensor4 to the result of a function of corresponding pairs of elements of the two supplied tensors.
`SetMap2(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2	Set the elements of a tensor4 to the result of a function of corresponding pairs of elements of the two supplied tensors.
`SetMap2(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2	Set the elements of a tensor4 to the result of a function of corresponding pairs of elements of the two supplied tensors.
`SetMap3(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'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, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Ty, 'Tz, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Ty, 'Tz, 'Twd, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Ty, 'Tzd, 'Tz, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Ty, 'Tzd, 'Tz, 'Twd, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tyd, 'Ty, 'Tz, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tyd, 'Ty, 'Tz, 'Twd, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tyd, 'Ty, 'Tzd, 'Tz, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tyd, 'Ty, 'Tzd, 'Tz, 'Twd, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Ty, 'Tz, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Ty, 'Tz, 'Twd, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Ty, 'Tzd, 'Tz, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Ty, 'Tzd, 'Tz, 'Twd, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Tyd, 'Ty, 'Tz, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Tyd, 'Ty, 'Tz, 'Twd, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Tyd, 'Ty, 'Tzd, 'Tz, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetOuterProduct(tx, ty, tz, tw, fun)` Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * tz:Vector<'Tzd,'Tz> * tw:Vector<'Twd,'Tw> * fun:Func<'Tx,'Ty,'Tz,'Tw,'Td>) -> Tensor4<'Td> Type parameters: 'Tx, 'Tyd, 'Ty, 'Tzd, 'Tz, 'Twd, 'Tw	Set the four-dimensional tensor to be the outer product of the four supplied vectors.
`SetValue(value, x, y, z, w)` Signature: (value:obj * x:int64 * y:int64 * z:int64 * w:int64) -> unit Modifiers: abstract
`SetValue(value, v)` Signature: (value:obj * v:V4l) -> 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.
`SubTensor4(begin, size)` Signature: (begin:V4l * size:V4l) -> Tensor4<'Td>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(begin, size)` Signature: (begin:V4i * size:V4i) -> Tensor4<'Td>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(begin, size, delta)` Signature: (begin:V4l * size:V4l * delta:V4l) -> Tensor4<'Td>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(begin, size, delta)` Signature: (begin:V4i * size:V4i * delta:V4i) -> Tensor4<'Td>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * beginW:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * sizeW:int64) -> Tensor4<'Td>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * beginW:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * sizeW:int64 * deltaX:int64 * deltaY:int64 * deltaZ:int64 * deltaW:int64) -> Tensor4<'Td>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(begin, size)` Signature: (begin:V4l * size:V4l) -> Tensor4<'Td,'T1>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(begin, size)` Signature: (begin:V4i * size:V4i) -> Tensor4<'Td,'T1>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(begin, size, delta)` Signature: (begin:V4l * size:V4l * delta:V4l) -> Tensor4<'Td,'T1>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(begin, size, delta)` Signature: (begin:V4i * size:V4i * delta:V4i) -> Tensor4<'Td,'T1>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * beginW:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * sizeW:int64) -> Tensor4<'Td,'T1>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * beginW:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * sizeW:int64 * deltaX:int64 * deltaY:int64 * deltaZ:int64 * deltaW:int64) -> Tensor4<'Td,'T1>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Tensor4 with zero as first coordinates.
`SubTensor4Window(begin, size)` Signature: (begin:V4l * size:V4l) -> Tensor4<'Td>	A SubTensor4 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 Tensor4.
`SubTensor4Window(begin, size)` Signature: (begin:V4i * size:V4i) -> Tensor4<'Td>	A SubTensor4 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 Tensor4.
`SubTensor4Window(begin, size, delta)` Signature: (begin:V4l * size:V4l * delta:V4l) -> Tensor4<'Td>	A SubTensor4 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 Tensor4.
`SubTensor4Window(begin, size, delta)` Signature: (begin:V4i * size:V4i * delta:V4i) -> Tensor4<'Td>	A SubTensor4 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 Tensor4.
`SubTensor4Window(...)` Signature: (begin:V4l * size:V4l * delta:V4l * first:V4l) -> Tensor4<'Td>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.
`SubTensor4Window(...)` Signature: (begin:V4i * size:V4i * delta:V4i * first:V4i) -> Tensor4<'Td>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.
`SubTensor4Window(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * beginW:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * sizeW:int64) -> Tensor4<'Td>	A SubTensor4 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 Tensor4.
`SubTensor4Window(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * beginW:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * sizeW:int64 * deltaX:int64 * deltaY:int64 * deltaZ:int64 * deltaW:int64) -> Tensor4<'Td>	A SubTensor4 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 Tensor4.
`SubTensor4Window(begin, size)` Signature: (begin:V4l * size:V4l) -> Tensor4<'Td,'T1>	A SubTensor4 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 Tensor4.
`SubTensor4Window(begin, size)` Signature: (begin:V4i * size:V4i) -> Tensor4<'Td,'T1>	A SubTensor4 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 Tensor4.
`SubTensor4Window(begin, size, delta)` Signature: (begin:V4l * size:V4l * delta:V4l) -> Tensor4<'Td,'T1>	A SubTensor4 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 Tensor4.
`SubTensor4Window(begin, size, delta)` Signature: (begin:V4i * size:V4i * delta:V4i) -> Tensor4<'Td,'T1>	A SubTensor4 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 Tensor4.
`SubTensor4Window(...)` Signature: (begin:V4l * size:V4l * delta:V4l * first:V4l) -> Tensor4<'Td,'T1>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.
`SubTensor4Window(...)` Signature: (begin:V4i * size:V4i * delta:V4i * first:V4i) -> Tensor4<'Td,'T1>	A SubTensor4 does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent.
`SubTensor4Window(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * beginW:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * sizeW:int64) -> Tensor4<'Td,'T1>	A SubTensor4 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 Tensor4.
`SubTensor4Window(...)` Signature: (beginX:int64 * beginY:int64 * beginZ:int64 * beginW:int64 * sizeX:int64 * sizeY:int64 * sizeZ:int64 * sizeW:int64 * deltaX:int64 * deltaY:int64 * deltaZ:int64 * deltaW:int64) -> Tensor4<'Td,'T1>	A SubTensor4 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 Tensor4.
`SubVector(origin, size, delta)` Signature: (origin:V4l * 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:V4i * 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:V4l * 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:V4i * 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.
`SubXWMatrixAsReadOnlyTensor4(...)` Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> Tensor4<'Td>	Return a full XW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubXWMatrixAsReadOnlyTensor4(...)` Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> Tensor4<'Td,'T1>	Return a full XW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubXWMatrixAsReadOnlyTensor4Window(...)` Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> Tensor4<'Td>	Return a full XW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXWMatrixAsReadOnlyTensor4Window(...)` Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> Tensor4<'Td,'T1>	Return a full XW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXYMatrixAsReadOnlyTensor4(...)` Signature: (z:int64 * w:int64 * sizez:int64 * sizew:int64) -> Tensor4<'Td>	Return a full XY matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubXYMatrixAsReadOnlyTensor4(...)` Signature: (z:int64 * w:int64 * sizez:int64 * sizew:int64) -> Tensor4<'Td,'T1>	Return a full XY matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubXYMatrixAsReadOnlyTensor4Window(...)` Signature: (z:int64 * w:int64 * sizez:int64 * sizew:int64) -> Tensor4<'Td>	Return a full XY matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXYMatrixAsReadOnlyTensor4Window(...)` Signature: (z:int64 * w:int64 * sizez:int64 * sizew:int64) -> Tensor4<'Td,'T1>	Return a full XY matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXYWVolume(z)` Signature: z:int64 -> Volume<'Td>	Return a full XYW volume slice of the tensor4. This methods returns a volume with zero as first coordinates.
`SubXYWVolume(z)` Signature: z:int64 -> Volume<'Td,'T1>	Return a full XYW volume slice of the tensor4. This methods returns a volume with zero as first coordinates.
`SubXYWVolumeAsReadOnlyTensor4(z, sizez)` Signature: (z:int64 * sizez:int64) -> Tensor4<'Td>	Return a full XYW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubXYWVolumeAsReadOnlyTensor4(z, sizez)` Signature: (z:int64 * sizez:int64) -> Tensor4<'Td,'T1>	Return a full XYW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubXYWVolumeAsReadOnlyTensor4Window(...)` Signature: (z:int64 * sizez:int64) -> Tensor4<'Td>	Return a full XYW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXYWVolumeAsReadOnlyTensor4Window(...)` Signature: (z:int64 * sizez:int64) -> Tensor4<'Td,'T1>	Return a full XYW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXYWVolumeWindow(z)` Signature: z:int64 -> Volume<'Td>	Return a full XYW volume slice of the tensor4. This method retains the coordinates of the parent tensor4.
`SubXYWVolumeWindow(z)` Signature: z:int64 -> Volume<'Td,'T1>	Return a full XYW volume slice of the tensor4. This method retains the coordinates of the parent tensor4.
`SubXYZVolume(w)` Signature: w:int64 -> Volume<'Td>	Return a full XYZ volume slice of the tensor4. This methods returns a volume with zero as first coordinates.
`SubXYZVolume(w)` Signature: w:int64 -> Volume<'Td,'T1>	Return a full XYZ volume slice of the tensor4. This methods returns a volume with zero as first coordinates.
`SubXYZVolumeAsReadOnlyTensor4(w, sizew)` Signature: (w:int64 * sizew:int64) -> Tensor4<'Td>	Return a full XYZ volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubXYZVolumeAsReadOnlyTensor4(w, sizew)` Signature: (w:int64 * sizew:int64) -> Tensor4<'Td,'T1>	Return a full XYZ volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubXYZVolumeAsReadOnlyTensor4Window(...)` Signature: (w:int64 * sizew:int64) -> Tensor4<'Td>	Return a full XYZ volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXYZVolumeAsReadOnlyTensor4Window(...)` Signature: (w:int64 * sizew:int64) -> Tensor4<'Td,'T1>	Return a full XYZ volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXYZVolumeWindow(w)` Signature: w:int64 -> Volume<'Td>	Return a full XYZ volume slice of the tensor4. This method retains the coordinates of the parent tensor4.
`SubXYZVolumeWindow(w)` Signature: w:int64 -> Volume<'Td,'T1>	Return a full XYZ volume slice of the tensor4. This method retains the coordinates of the parent tensor4.
`SubXZMatrixAsReadOnlyTensor4(...)` Signature: (y:int64 * w:int64 * sizey:int64 * sizew:int64) -> Tensor4<'Td>	Return a full XZ matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubXZMatrixAsReadOnlyTensor4(...)` Signature: (y:int64 * w:int64 * sizey:int64 * sizew:int64) -> Tensor4<'Td,'T1>	Return a full XZ matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubXZMatrixAsReadOnlyTensor4Window(...)` Signature: (y:int64 * w:int64 * sizey:int64 * sizew:int64) -> Tensor4<'Td>	Return a full XZ matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXZMatrixAsReadOnlyTensor4Window(...)` Signature: (y:int64 * w:int64 * sizey:int64 * sizew:int64) -> Tensor4<'Td,'T1>	Return a full XZ matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXZWVolume(y)` Signature: y:int64 -> Volume<'Td>	Return a full XZW volume slice of the tensor4. This methods returns a volume with zero as first coordinates.
`SubXZWVolume(y)` Signature: y:int64 -> Volume<'Td,'T1>	Return a full XZW volume slice of the tensor4. This methods returns a volume with zero as first coordinates.
`SubXZWVolumeAsReadOnlyTensor4(y, sizey)` Signature: (y:int64 * sizey:int64) -> Tensor4<'Td>	Return a full XZW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubXZWVolumeAsReadOnlyTensor4(y, sizey)` Signature: (y:int64 * sizey:int64) -> Tensor4<'Td,'T1>	Return a full XZW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubXZWVolumeAsReadOnlyTensor4Window(...)` Signature: (y:int64 * sizey:int64) -> Tensor4<'Td>	Return a full XZW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXZWVolumeAsReadOnlyTensor4Window(...)` Signature: (y:int64 * sizey:int64) -> Tensor4<'Td,'T1>	Return a full XZW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubXZWVolumeWindow(y)` Signature: y:int64 -> Volume<'Td>	Return a full XZW volume slice of the tensor4. This method retains the coordinates of the parent tensor4.
`SubXZWVolumeWindow(y)` Signature: y:int64 -> Volume<'Td,'T1>	Return a full XZW volume slice of the tensor4. This method retains the coordinates of the parent tensor4.
`SubYWMatrixAsReadOnlyTensor4(...)` Signature: (x:int64 * z:int64 * sizex:int64 * sizez:int64) -> Tensor4<'Td>	Return a full YW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubYWMatrixAsReadOnlyTensor4(...)` Signature: (x:int64 * z:int64 * sizex:int64 * sizez:int64) -> Tensor4<'Td,'T1>	Return a full YW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubYWMatrixAsReadOnlyTensor4Window(...)` Signature: (x:int64 * z:int64 * sizex:int64 * sizez:int64) -> Tensor4<'Td>	Return a full YW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubYWMatrixAsReadOnlyTensor4Window(...)` Signature: (x:int64 * z:int64 * sizex:int64 * sizez:int64) -> Tensor4<'Td,'T1>	Return a full YW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubYZMatrixAsReadOnlyTensor4(...)` Signature: (x:int64 * w:int64 * sizex:int64 * sizew:int64) -> Tensor4<'Td>	Return a full YZ matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubYZMatrixAsReadOnlyTensor4(...)` Signature: (x:int64 * w:int64 * sizex:int64 * sizew:int64) -> Tensor4<'Td,'T1>	Return a full YZ matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubYZMatrixAsReadOnlyTensor4Window(...)` Signature: (x:int64 * w:int64 * sizex:int64 * sizew:int64) -> Tensor4<'Td>	Return a full YZ matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubYZMatrixAsReadOnlyTensor4Window(...)` Signature: (x:int64 * w:int64 * sizex:int64 * sizew:int64) -> Tensor4<'Td,'T1>	Return a full YZ matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubYZWVolume(x)` Signature: x:int64 -> Volume<'Td>	Return a full YZW volume slice of the tensor4. This methods returns a volume with zero as first coordinates.
`SubYZWVolume(x)` Signature: x:int64 -> Volume<'Td,'T1>	Return a full YZW volume slice of the tensor4. This methods returns a volume with zero as first coordinates.
`SubYZWVolumeAsReadOnlyTensor4(x, sizex)` Signature: (x:int64 * sizex:int64) -> Tensor4<'Td>	Return a full YZW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubYZWVolumeAsReadOnlyTensor4(x, sizex)` Signature: (x:int64 * sizex:int64) -> Tensor4<'Td,'T1>	Return a full YZW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a volume with zero as first coordinates.
`SubYZWVolumeAsReadOnlyTensor4Window(...)` Signature: (x:int64 * sizex:int64) -> Tensor4<'Td>	Return a full YZW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubYZWVolumeAsReadOnlyTensor4Window(...)` Signature: (x:int64 * sizex:int64) -> Tensor4<'Td,'T1>	Return a full YZW volume slice of the tensor4 as a special tensor4 that replicates the volume the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubYZWVolumeWindow(x)` Signature: x:int64 -> Volume<'Td>	Return a full YZW volume slice of the tensor4. This method retains the coordinates of the parent tensor4.
`SubYZWVolumeWindow(x)` Signature: x:int64 -> Volume<'Td,'T1>	Return a full YZW volume slice of the tensor4. This method retains the coordinates of the parent tensor4.
`SubZWMatrixAsReadOnlyTensor4(...)` Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Tensor4<'Td>	Return a full ZW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubZWMatrixAsReadOnlyTensor4(...)` Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Tensor4<'Td,'T1>	Return a full ZW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This methods returns a tensor4 with zero as first coordinates.
`SubZWMatrixAsReadOnlyTensor4Window(...)` Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Tensor4<'Td>	Return a full ZW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SubZWMatrixAsReadOnlyTensor4Window(...)` Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Tensor4<'Td,'T1>	Return a full ZW matrix slice of the tensor4 as a special tensor4 that replicates the matrix the supplied number of times. The special tensor4 can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent tensor4.
`SW()` Signature: unit -> unit	Size in dimension W.
`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:Tensor4<'Td> -> Tensor4<'Td>	Create a new tensor4 as copy of the supplied tensor4.
`Create(t1)` Signature: t1:Tensor4<'T1d,'Td> -> Tensor4<'Td>	Create a new tensor4 as copy of the supplied tensor4.
`Create(t1, element1_elementFun)` Signature: (t1:Tensor4<'T1> * element1_elementFun:Func<'T1,'Td>) -> Tensor4<'Td>	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(t1, element1_elementFun)` Signature: (t1:Tensor4<'T1d,'T1> * element1_elementFun:Func<'T1,'Td>) -> Tensor4<'Td> Type parameters: 'T1	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T2	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T2, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Create(size, fun)` Signature: (size:V4l * fun:Func<V4l,'Td>) -> Tensor4<'Td>	Create a new tensor4 by applying a function to the coordinates of the elements the newly created tensor4.
`CreateByIndex(t1, index1_elementFun)` Signature: (t1:Tensor4<'T1> * index1_elementFun:Func<int64,'Td>) -> Tensor4<'Td>	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(t1, index1_elementFun)` Signature: (t1:Tensor4<'T1d,'T1> * index1_elementFun:Func<int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(t1, t2, index1_index2_fun)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * index1_index2_fun:Func<int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(t1, t2, index1_index2_fun)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * index1_index2_fun:Func<int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(t1, t2, index1_index2_fun)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * index1_index2_fun:Func<int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(t1, t2, index1_index2_fun)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * index1_index2_fun:Func<int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2, 'T3	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2, 'T3	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2, 'T3	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2, 'T3	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateByIndex(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function to each index of the elements of the supplied tensor4. The function may access the elements of the supplied tensor4 to compute the elements of the new tensor4.
`CreateConvolution(...)` Signature: (image:Tensor4<'Ti> * filter:Tensor4<'Tf> * mulFun:Func<'Ti,'Tf,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * castFun:Func<'Ts,'Td>) -> Tensor4<'Td> Type parameters: 'Tf, 'Tm, 'Ts	Create a new Tensor4 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 Tensor4.
`Map(t1, element1_elementFun)` Signature: (t1:Tensor4<'T1> * element1_elementFun:Func<'T1,'Td>) -> Tensor4<'Td>	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map(t1, element1_elementFun)` Signature: (t1:Tensor4<'T1d,'T1> * element1_elementFun:Func<'T1,'Td>) -> Tensor4<'Td> Type parameters: 'T1	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map2(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T2	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map2(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map2(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map2(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map3(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T2, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map3(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map3(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map3(...)` Signature: (t1:Tensor4<'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T2d, 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map3(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map3(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map3(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.
`Map3(...)` Signature: (t1:Tensor4<'T1d,'T1> * t2:Tensor4<'T2d,'T2> * t3:Tensor4<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Td>) -> Tensor4<'Td> Type parameters: 'T1, 'T2d, 'T2, 'T3d, 'T3	Create a new tensor4 by applying a function on each element of the supplied tensor4.

Aardvark.Base

Tensor4<'Td>

Constructors

Instance members

Static members