Tensor4Info

A tensor4 info contains the complete indexing information for a tensor4, but no data array.

Constructors

Constructor	Description
`new(origin, size, delta, first)` Signature: (origin:int64 * size:V4l * delta:V4l * first:V4l) -> unit	Construct a Tensor4Info given a complete specification.
`new(origin, size, delta)` Signature: (origin:int64 * size:V4l * delta:V4l) -> unit	Construct a Tensor4Info given a complete specification.
`new(size)` Signature: size:V4l -> unit
`new(size, delta)` Signature: (size:V4l * delta:V4l) -> unit
`new(info)` Signature: info:Tensor4Info -> unit
`new(size)` Signature: size:V4i -> unit	Construct matrix info of specified size.
`new(sizeX, sizeY, sizeZ, sizeW)` Signature: (sizeX:int64 * sizeY:int64 * sizeZ:int64 * sizeW:int64) -> unit	Construct matrix info of specified size.
`new(sizeX, sizeY, sizeZ, sizeW)` Signature: (sizeX:int * sizeY:int * sizeZ:int * sizeW:int) -> unit	Construct matrix info of specified size.

Instance members

Instance member	Description
`AsVector()` Signature: unit -> VectorInfo	If the lines and planes of the volume are stored consecutively without gaps, the whole volume can be viewed as a single vector. This methods returns a Vector with zero as first coordinates.
`CheckMatchingSize(t1)` Signature: t1:Tensor4Info -> unit
`CheckMatchingSize(t1, t2)` Signature: (t1:Tensor4Info * t2:Tensor4Info) -> unit
`CheckMatchingSize(t1, t2, t3)` Signature: (t1:Tensor4Info * t2:Tensor4Info * t3:Tensor4Info) -> unit
`Count` Signature: int64	Total number of element in the tensor4.
`D()` Signature: unit -> unit	Delta
`DeltaArray()` Signature: unit -> unit Modifiers: abstract	Get or set the deltas of the tensor in each dimension as an array of longs.
`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.
`Dv(dx, dy, dz, dw)` Signature: (dx:int64 * dy:int64 * dz:int64 * dw:int64) -> int64
`DW()` Signature: unit -> unit	Delta.W
`DX()` Signature: unit -> unit	Delta.X
`DY()` Signature: unit -> unit	Delta.Y
`DZ()` Signature: unit -> unit	Delta.Z
`E` Signature: V4l	End (one step beyond the last element in all dimensions).
`End` Signature: V4l	End (one step beyond the last element in all dimensions).
`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
`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 Modifiers: abstract
`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.
`ForeachWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachWIndex(t1, w_i_i1_elementAct)` Signature: (t1:Tensor4Info * w_i_i1_elementAct:Action<int64,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.
`ForeachWXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachWXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachWXIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, w_x_i_i1_elementAct)` Signature: (t1:Tensor4Info * w_x_i_i1_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 and post-line actions can be specified.
`ForeachWXIndex(...)` Signature: (t1:Tensor4Info * w_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preLineAct:Action<int64> * w_x_i_i1_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 and post-line actions can be specified.
`ForeachWXIndex(...)` Signature: (t1:Tensor4Info * w_preLineAct:Action<int64> * w_x_i_i1_elementAct:Action<int64,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.
`ForeachWXYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWXYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWXYIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_x_y_i_i1_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.
`ForeachWXYIndex(...)` Signature: (t1:Tensor4Info * w_x_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_x_y_i_i1_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.
`ForeachWXYIndex(...)` Signature: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_x_y_i_i1_elementAct:Action<int64,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.
`ForeachWXYZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWXYZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWXYZIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_x_y_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_x_y_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_y_preLineAct:Action<int64,int64,int64> * w_x_y_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_y_preLineAct:Action<int64,int64,int64> * w_x_y_z_i_i1_elementAct:Action<int64,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.
`ForeachWXZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWXZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWXZIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_x_z_i_i1_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.
`ForeachWXZIndex(...)` Signature: (t1:Tensor4Info * w_x_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_x_z_i_i1_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.
`ForeachWXZIndex(...)` Signature: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_x_preLineAct:Action<int64,int64> * w_x_z_i_i1_elementAct:Action<int64,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.
`ForeachWXZYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWXZYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWXZYIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_x_z_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_x_z_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_z_preLineAct:Action<int64,int64,int64> * w_x_z_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_x_prePlaneAct:Action<int64,int64> * w_x_z_preLineAct:Action<int64,int64,int64> * w_x_z_y_i_i1_elementAct:Action<int64,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.
`ForeachWYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachWYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachWYIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, w_y_i_i1_elementAct)` Signature: (t1:Tensor4Info * w_y_i_i1_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 and post-line actions can be specified.
`ForeachWYIndex(...)` Signature: (t1:Tensor4Info * w_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preLineAct:Action<int64> * w_y_i_i1_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 and post-line actions can be specified.
`ForeachWYIndex(...)` Signature: (t1:Tensor4Info * w_preLineAct:Action<int64> * w_y_i_i1_elementAct:Action<int64,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.
`ForeachWYXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWYXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWYXIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_y_x_i_i1_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.
`ForeachWYXIndex(...)` Signature: (t1:Tensor4Info * w_y_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_y_x_i_i1_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.
`ForeachWYXIndex(...)` Signature: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_y_x_i_i1_elementAct:Action<int64,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.
`ForeachWYXZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWYXZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWYXZIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_y_x_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_y_x_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_x_preLineAct:Action<int64,int64,int64> * w_y_x_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_x_preLineAct:Action<int64,int64,int64> * w_y_x_z_i_i1_elementAct:Action<int64,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.
`ForeachWYZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWYZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWYZIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_y_z_i_i1_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.
`ForeachWYZIndex(...)` Signature: (t1:Tensor4Info * w_y_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_y_z_i_i1_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.
`ForeachWYZIndex(...)` Signature: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_y_preLineAct:Action<int64,int64> * w_y_z_i_i1_elementAct:Action<int64,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.
`ForeachWYZXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWYZXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWYZXIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_y_z_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_y_z_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_z_preLineAct:Action<int64,int64,int64> * w_y_z_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_y_prePlaneAct:Action<int64,int64> * w_y_z_preLineAct:Action<int64,int64,int64> * w_y_z_x_i_i1_elementAct:Action<int64,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.
`ForeachWZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachWZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachWZIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, w_z_i_i1_elementAct)` Signature: (t1:Tensor4Info * w_z_i_i1_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 and post-line actions can be specified.
`ForeachWZIndex(...)` Signature: (t1:Tensor4Info * w_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preLineAct:Action<int64> * w_z_i_i1_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 and post-line actions can be specified.
`ForeachWZIndex(...)` Signature: (t1:Tensor4Info * w_preLineAct:Action<int64> * w_z_i_i1_elementAct:Action<int64,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.
`ForeachWZXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWZXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWZXIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_z_x_i_i1_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.
`ForeachWZXIndex(...)` Signature: (t1:Tensor4Info * w_z_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_z_x_i_i1_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.
`ForeachWZXIndex(...)` Signature: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_z_x_i_i1_elementAct:Action<int64,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.
`ForeachWZXYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWZXYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWZXYIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_z_x_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_z_x_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_x_preLineAct:Action<int64,int64,int64> * w_z_x_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_x_preLineAct:Action<int64,int64,int64> * w_z_x_y_i_i1_elementAct:Action<int64,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.
`ForeachWZYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWZYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWZYIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_z_y_i_i1_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.
`ForeachWZYIndex(...)` Signature: (t1:Tensor4Info * w_z_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_z_y_i_i1_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.
`ForeachWZYIndex(...)` Signature: (t1:Tensor4Info * w_prePlaneAct:Action<int64> * w_z_preLineAct:Action<int64,int64> * w_z_y_i_i1_elementAct:Action<int64,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.
`ForeachWZYXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWZYXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachWZYXIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_z_y_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_z_y_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_y_preLineAct:Action<int64,int64,int64> * w_z_y_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * w_preVolumeAct:Action<int64> * w_z_prePlaneAct:Action<int64,int64> * w_z_y_preLineAct:Action<int64,int64,int64> * w_z_y_x_i_i1_elementAct:Action<int64,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.
`ForeachXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachXIndex(t1, x_i_i1_elementAct)` Signature: (t1:Tensor4Info * x_i_i1_elementAct:Action<int64,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.
`ForeachXWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachXWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachXWIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, x_w_i_i1_elementAct)` Signature: (t1:Tensor4Info * x_w_i_i1_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 and post-line actions can be specified.
`ForeachXWIndex(...)` Signature: (t1:Tensor4Info * x_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preLineAct:Action<int64> * x_w_i_i1_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 and post-line actions can be specified.
`ForeachXWIndex(...)` Signature: (t1:Tensor4Info * x_preLineAct:Action<int64> * x_w_i_i1_elementAct:Action<int64,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.
`ForeachXWYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXWYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXWYIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_w_y_i_i1_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.
`ForeachXWYIndex(...)` Signature: (t1:Tensor4Info * x_w_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_y_i_i1_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.
`ForeachXWYIndex(...)` Signature: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_y_i_i1_elementAct:Action<int64,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.
`ForeachXWYZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXWYZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXWYZIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_w_y_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_w_y_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_y_preLineAct:Action<int64,int64,int64> * x_w_y_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_y_preLineAct:Action<int64,int64,int64> * x_w_y_z_i_i1_elementAct:Action<int64,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.
`ForeachXWZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXWZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXWZIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_w_z_i_i1_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.
`ForeachXWZIndex(...)` Signature: (t1:Tensor4Info * x_w_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_z_i_i1_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.
`ForeachXWZIndex(...)` Signature: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_w_preLineAct:Action<int64,int64> * x_w_z_i_i1_elementAct:Action<int64,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.
`ForeachXWZYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXWZYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXWZYIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_w_z_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_w_z_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_z_preLineAct:Action<int64,int64,int64> * x_w_z_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_w_prePlaneAct:Action<int64,int64> * x_w_z_preLineAct:Action<int64,int64,int64> * x_w_z_y_i_i1_elementAct:Action<int64,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.
`ForeachXYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachXYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachXYIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, x_y_i_i1_elementAct)` Signature: (t1:Tensor4Info * x_y_i_i1_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 and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (t1:Tensor4Info * x_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preLineAct:Action<int64> * x_y_i_i1_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 and post-line actions can be specified.
`ForeachXYIndex(...)` Signature: (t1:Tensor4Info * x_preLineAct:Action<int64> * x_y_i_i1_elementAct:Action<int64,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.
`ForeachXYWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYWIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_y_w_i_i1_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.
`ForeachXYWIndex(...)` Signature: (t1:Tensor4Info * x_y_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_w_i_i1_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.
`ForeachXYWIndex(...)` Signature: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_w_i_i1_elementAct:Action<int64,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.
`ForeachXYWZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYWZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYWZIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_y_w_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_y_w_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_w_preLineAct:Action<int64,int64,int64> * x_y_w_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_w_preLineAct:Action<int64,int64,int64> * x_y_w_z_i_i1_elementAct:Action<int64,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.
`ForeachXYZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_y_z_i_i1_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.
`ForeachXYZIndex(...)` Signature: (t1:Tensor4Info * x_y_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_i_i1_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.
`ForeachXYZIndex(...)` Signature: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_y_preLineAct:Action<int64,int64> * x_y_z_i_i1_elementAct:Action<int64,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.
`ForeachXYZWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXYZWIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_y_z_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_y_z_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_z_preLineAct:Action<int64,int64,int64> * x_y_z_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_y_prePlaneAct:Action<int64,int64> * x_y_z_preLineAct:Action<int64,int64,int64> * x_y_z_w_i_i1_elementAct:Action<int64,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.
`ForeachXZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachXZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachXZIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, x_z_i_i1_elementAct)` Signature: (t1:Tensor4Info * x_z_i_i1_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 and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (t1:Tensor4Info * x_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preLineAct:Action<int64> * x_z_i_i1_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 and post-line actions can be specified.
`ForeachXZIndex(...)` Signature: (t1:Tensor4Info * x_preLineAct:Action<int64> * x_z_i_i1_elementAct:Action<int64,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.
`ForeachXZWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZWIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_z_w_i_i1_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.
`ForeachXZWIndex(...)` Signature: (t1:Tensor4Info * x_z_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_w_i_i1_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.
`ForeachXZWIndex(...)` Signature: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_w_i_i1_elementAct:Action<int64,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.
`ForeachXZWYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZWYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZWYIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_z_w_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_z_w_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_w_preLineAct:Action<int64,int64,int64> * x_z_w_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_w_preLineAct:Action<int64,int64,int64> * x_z_w_y_i_i1_elementAct:Action<int64,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.
`ForeachXZYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_z_y_i_i1_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.
`ForeachXZYIndex(...)` Signature: (t1:Tensor4Info * x_z_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_i_i1_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.
`ForeachXZYIndex(...)` Signature: (t1:Tensor4Info * x_prePlaneAct:Action<int64> * x_z_preLineAct:Action<int64,int64> * x_z_y_i_i1_elementAct:Action<int64,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.
`ForeachXZYWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachXZYWIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_z_y_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_z_y_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_y_preLineAct:Action<int64,int64,int64> * x_z_y_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * x_preVolumeAct:Action<int64> * x_z_prePlaneAct:Action<int64,int64> * x_z_y_preLineAct:Action<int64,int64,int64> * x_z_y_w_i_i1_elementAct:Action<int64,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.
`ForeachYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachYIndex(t1, y_i_i1_elementAct)` Signature: (t1:Tensor4Info * y_i_i1_elementAct:Action<int64,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.
`ForeachYWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachYWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachYWIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, y_w_i_i1_elementAct)` Signature: (t1:Tensor4Info * y_w_i_i1_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 and post-line actions can be specified.
`ForeachYWIndex(...)` Signature: (t1:Tensor4Info * y_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preLineAct:Action<int64> * y_w_i_i1_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 and post-line actions can be specified.
`ForeachYWIndex(...)` Signature: (t1:Tensor4Info * y_preLineAct:Action<int64> * y_w_i_i1_elementAct:Action<int64,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.
`ForeachYWXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYWXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYWXIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_w_x_i_i1_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.
`ForeachYWXIndex(...)` Signature: (t1:Tensor4Info * y_w_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_x_i_i1_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.
`ForeachYWXIndex(...)` Signature: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_x_i_i1_elementAct:Action<int64,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.
`ForeachYWXZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYWXZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYWXZIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_w_x_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_w_x_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_x_preLineAct:Action<int64,int64,int64> * y_w_x_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_x_preLineAct:Action<int64,int64,int64> * y_w_x_z_i_i1_elementAct:Action<int64,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.
`ForeachYWZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYWZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYWZIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_w_z_i_i1_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.
`ForeachYWZIndex(...)` Signature: (t1:Tensor4Info * y_w_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_z_i_i1_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.
`ForeachYWZIndex(...)` Signature: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_w_preLineAct:Action<int64,int64> * y_w_z_i_i1_elementAct:Action<int64,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.
`ForeachYWZXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYWZXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYWZXIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_w_z_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_w_z_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_z_preLineAct:Action<int64,int64,int64> * y_w_z_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_w_prePlaneAct:Action<int64,int64> * y_w_z_preLineAct:Action<int64,int64,int64> * y_w_z_x_i_i1_elementAct:Action<int64,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.
`ForeachYXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachYXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachYXIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, y_x_i_i1_elementAct)` Signature: (t1:Tensor4Info * y_x_i_i1_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 and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (t1:Tensor4Info * y_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preLineAct:Action<int64> * y_x_i_i1_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 and post-line actions can be specified.
`ForeachYXIndex(...)` Signature: (t1:Tensor4Info * y_preLineAct:Action<int64> * y_x_i_i1_elementAct:Action<int64,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.
`ForeachYXWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXWIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_x_w_i_i1_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.
`ForeachYXWIndex(...)` Signature: (t1:Tensor4Info * y_x_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_w_i_i1_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.
`ForeachYXWIndex(...)` Signature: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_w_i_i1_elementAct:Action<int64,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.
`ForeachYXWZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXWZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXWZIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_x_w_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_x_w_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_w_preLineAct:Action<int64,int64,int64> * y_x_w_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_w_preLineAct:Action<int64,int64,int64> * y_x_w_z_i_i1_elementAct:Action<int64,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.
`ForeachYXZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_x_z_i_i1_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.
`ForeachYXZIndex(...)` Signature: (t1:Tensor4Info * y_x_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_i_i1_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.
`ForeachYXZIndex(...)` Signature: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_x_preLineAct:Action<int64,int64> * y_x_z_i_i1_elementAct:Action<int64,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.
`ForeachYXZWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYXZWIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_x_z_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_x_z_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_z_preLineAct:Action<int64,int64,int64> * y_x_z_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_x_prePlaneAct:Action<int64,int64> * y_x_z_preLineAct:Action<int64,int64,int64> * y_x_z_w_i_i1_elementAct:Action<int64,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.
`ForeachYZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachYZIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachYZIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, y_z_i_i1_elementAct)` Signature: (t1:Tensor4Info * y_z_i_i1_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 and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (t1:Tensor4Info * y_z_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preLineAct:Action<int64> * y_z_i_i1_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 and post-line actions can be specified.
`ForeachYZIndex(...)` Signature: (t1:Tensor4Info * y_preLineAct:Action<int64> * y_z_i_i1_elementAct:Action<int64,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.
`ForeachYZWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZWIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_z_w_i_i1_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.
`ForeachYZWIndex(...)` Signature: (t1:Tensor4Info * y_z_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_w_i_i1_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.
`ForeachYZWIndex(...)` Signature: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_w_i_i1_elementAct:Action<int64,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.
`ForeachYZWXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZWXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZWXIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_z_w_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_z_w_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_w_preLineAct:Action<int64,int64,int64> * y_z_w_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_w_preLineAct:Action<int64,int64,int64> * y_z_w_x_i_i1_elementAct:Action<int64,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.
`ForeachYZXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_z_x_i_i1_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.
`ForeachYZXIndex(...)` Signature: (t1:Tensor4Info * y_z_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_i_i1_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.
`ForeachYZXIndex(...)` Signature: (t1:Tensor4Info * y_prePlaneAct:Action<int64> * y_z_preLineAct:Action<int64,int64> * y_z_x_i_i1_elementAct:Action<int64,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.
`ForeachYZXWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachYZXWIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_z_x_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_z_x_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_x_preLineAct:Action<int64,int64,int64> * y_z_x_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * y_preVolumeAct:Action<int64> * y_z_prePlaneAct:Action<int64,int64> * y_z_x_preLineAct:Action<int64,int64,int64> * y_z_x_w_i_i1_elementAct:Action<int64,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.
`ForeachZIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachZIndex(t1, z_i_i1_elementAct)` Signature: (t1:Tensor4Info * z_i_i1_elementAct:Action<int64,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.
`ForeachZWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachZWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachZWIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, z_w_i_i1_elementAct)` Signature: (t1:Tensor4Info * z_w_i_i1_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 and post-line actions can be specified.
`ForeachZWIndex(...)` Signature: (t1:Tensor4Info * z_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preLineAct:Action<int64> * z_w_i_i1_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 and post-line actions can be specified.
`ForeachZWIndex(...)` Signature: (t1:Tensor4Info * z_preLineAct:Action<int64> * z_w_i_i1_elementAct:Action<int64,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.
`ForeachZWXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZWXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZWXIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_w_x_i_i1_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.
`ForeachZWXIndex(...)` Signature: (t1:Tensor4Info * z_w_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_x_i_i1_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.
`ForeachZWXIndex(...)` Signature: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_x_i_i1_elementAct:Action<int64,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.
`ForeachZWXYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZWXYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZWXYIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_w_x_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_w_x_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_x_preLineAct:Action<int64,int64,int64> * z_w_x_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_x_preLineAct:Action<int64,int64,int64> * z_w_x_y_i_i1_elementAct:Action<int64,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.
`ForeachZWYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZWYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZWYIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_w_y_i_i1_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.
`ForeachZWYIndex(...)` Signature: (t1:Tensor4Info * z_w_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_y_i_i1_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.
`ForeachZWYIndex(...)` Signature: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_w_preLineAct:Action<int64,int64> * z_w_y_i_i1_elementAct:Action<int64,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.
`ForeachZWYXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZWYXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZWYXIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_w_y_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_w_y_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_y_preLineAct:Action<int64,int64,int64> * z_w_y_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_w_prePlaneAct:Action<int64,int64> * z_w_y_preLineAct:Action<int64,int64,int64> * z_w_y_x_i_i1_elementAct:Action<int64,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.
`ForeachZXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachZXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachZXIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, z_x_i_i1_elementAct)` Signature: (t1:Tensor4Info * z_x_i_i1_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 and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (t1:Tensor4Info * z_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preLineAct:Action<int64> * z_x_i_i1_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 and post-line actions can be specified.
`ForeachZXIndex(...)` Signature: (t1:Tensor4Info * z_preLineAct:Action<int64> * z_x_i_i1_elementAct:Action<int64,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.
`ForeachZXWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXWIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_x_w_i_i1_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.
`ForeachZXWIndex(...)` Signature: (t1:Tensor4Info * z_x_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_w_i_i1_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.
`ForeachZXWIndex(...)` Signature: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_w_i_i1_elementAct:Action<int64,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.
`ForeachZXWYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXWYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXWYIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_x_w_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_x_w_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_w_preLineAct:Action<int64,int64,int64> * z_x_w_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_w_preLineAct:Action<int64,int64,int64> * z_x_w_y_i_i1_elementAct:Action<int64,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.
`ForeachZXYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_x_y_i_i1_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.
`ForeachZXYIndex(...)` Signature: (t1:Tensor4Info * z_x_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_i_i1_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.
`ForeachZXYIndex(...)` Signature: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_x_preLineAct:Action<int64,int64> * z_x_y_i_i1_elementAct:Action<int64,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.
`ForeachZXYWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZXYWIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_x_y_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_x_y_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_y_preLineAct:Action<int64,int64,int64> * z_x_y_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_x_prePlaneAct:Action<int64,int64> * z_x_y_preLineAct:Action<int64,int64,int64> * z_x_y_w_i_i1_elementAct:Action<int64,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.
`ForeachZYIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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.
`ForeachZYIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_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.
`ForeachZYIndex(...)` Signature: (t1:Tensor4Info * preLineAct:Action * i_i1_elementAct:Action<int64,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(t1, z_y_i_i1_elementAct)` Signature: (t1:Tensor4Info * z_y_i_i1_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 and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (t1:Tensor4Info * z_y_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preLineAct:Action<int64> * z_y_i_i1_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 and post-line actions can be specified.
`ForeachZYIndex(...)` Signature: (t1:Tensor4Info * z_preLineAct:Action<int64> * z_y_i_i1_elementAct:Action<int64,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.
`ForeachZYWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYWIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_y_w_i_i1_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.
`ForeachZYWIndex(...)` Signature: (t1:Tensor4Info * z_y_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_w_i_i1_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.
`ForeachZYWIndex(...)` Signature: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_w_i_i1_elementAct:Action<int64,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.
`ForeachZYWXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYWXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYWXIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_y_w_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_y_w_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_w_preLineAct:Action<int64,int64,int64> * z_y_w_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_w_preLineAct:Action<int64,int64,int64> * z_y_w_x_i_i1_elementAct:Action<int64,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.
`ForeachZYXIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXIndex(...)` Signature: (t1:Tensor4Info * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_y_x_i_i1_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.
`ForeachZYXIndex(...)` Signature: (t1:Tensor4Info * z_y_x_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_i_i1_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.
`ForeachZYXIndex(...)` Signature: (t1:Tensor4Info * z_prePlaneAct:Action<int64> * z_y_preLineAct:Action<int64,int64> * z_y_x_i_i1_elementAct:Action<int64,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.
`ForeachZYXWIndex(t1, i_i1_elementAct)` Signature: (t1:Tensor4Info * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXWIndex(...)` Signature: (t1:Tensor4Info * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_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, post-line, pre-plane, and post-plane actions can be specified.
`ForeachZYXWIndex(...)` Signature: (t1:Tensor4Info * preVolumeAct:Action * prePlaneAct:Action * preLineAct:Action * i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_y_x_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_y_x_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_x_preLineAct:Action<int64,int64,int64> * z_y_x_w_i_i1_elementAct:Action<int64,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: (t1:Tensor4Info * z_preVolumeAct:Action<int64> * z_y_prePlaneAct:Action<int64,int64> * z_y_x_preLineAct:Action<int64,int64,int64> * z_y_x_w_i_i1_elementAct:Action<int64,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.W
`FX()` Signature: unit -> unit	First.X
`FY()` Signature: unit -> unit	First.Y
`FZ()` Signature: unit -> unit	First.Z
`GetJW(size)` Signature: size:V4l -> int64
`GetJW0(size)` Signature: size:V4l -> int64
`GetJWX(size)` Signature: size:V4l -> int64
`GetJWY(size)` Signature: size:V4l -> int64
`GetJWZ(size)` Signature: size:V4l -> int64
`GetJX(size)` Signature: size:V4l -> int64
`GetJX0(size)` Signature: size:V4l -> int64
`GetJXW(size)` Signature: size:V4l -> int64
`GetJXY(size)` Signature: size:V4l -> int64
`GetJXZ(size)` Signature: size:V4l -> int64
`GetJY(size)` Signature: size:V4l -> int64
`GetJY0(size)` Signature: size:V4l -> int64
`GetJYW(size)` Signature: size:V4l -> int64
`GetJYX(size)` Signature: size:V4l -> int64
`GetJYZ(size)` Signature: size:V4l -> int64
`GetJZ(size)` Signature: size:V4l -> int64
`GetJZ0(size)` Signature: size:V4l -> int64
`GetJZW(size)` Signature: size:V4l -> int64
`GetJZX(size)` Signature: size:V4l -> int64
`GetJZY(size)` Signature: size:V4l -> int64
`HasMatchingLayout(t1)` Signature: t1:Tensor4Info -> bool
`HasMatchingLayout(t1, t2)` Signature: (t1:Tensor4Info * t2:Tensor4Info) -> bool
`HasMatchingLayout(t1, t2, t3)` Signature: (t1:Tensor4Info * t2:Tensor4Info * t3:Tensor4Info) -> bool
`IIII` Signature: V4l
`IIIO` Signature: V4l
`IIOI` Signature: V4l
`IIOO` Signature: V4l
`Index(x, y, z, w)` Signature: (x:int64 * y:int64 * z:int64 * w:int64) -> int64	Calculate element index for underlying data array.
`Index(v)` Signature: v:V4l -> int64	Calculate element index for underlying data array.
`Index(v)` Signature: v:V4i -> int64	Calculate element index for underlying data array.
`IndicesW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order.
`IndicesWX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesWXY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWXYZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWXZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWXZY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesWYX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWYXZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWYZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWYZX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesWZX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWZXY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWZY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesWZYX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order.
`IndicesXW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesXWY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXWYZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXWZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXWZY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesXYW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXYWZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXYZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXYZW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesXZW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXZWY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXZY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesXZYW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order.
`IndicesYW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesYWX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYWXZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYWZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYWZX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesYXW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYXWZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYXZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYXZW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesYZW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYZWX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYZX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesYZXW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZ` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order.
`IndicesZW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesZWX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZWXY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZWY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZWYX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesZXW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZXWY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZXY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZXYW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZY` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the second coordinate being the inner loop.
`IndicesZYW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZYWX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZYX` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IndicesZYXW` Signature: IEnumerable<int64>	Return the indices into the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop.
`IOII` Signature: V4l
`IOIO` Signature: V4l
`IOOI` Signature: V4l
`IOOO` Signature: V4l
`JW` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension W.
`JW0` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension W in a loop around another loop in dimension 0.
`JWX` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension W in a loop around another loop in dimension X.
`JWY` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension W in a loop around another loop in dimension Y.
`JWZ` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension W in a loop around another loop in dimension Z.
`JX` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension X.
`JX0` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension X in a loop around another loop in dimension 0.
`JXW` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension X in a loop around another loop in dimension W.
`JXY` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension X in a loop around another loop in dimension Y.
`JXZ` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension X in a loop around another loop in dimension Z.
`JY` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Y.
`JY0` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Y in a loop around another loop in dimension 0.
`JYW` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Y in a loop around another loop in dimension W.
`JYX` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Y in a loop around another loop in dimension X.
`JYZ` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Y in a loop around another loop in dimension Z.
`JZ` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Z.
`JZ0` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Z in a loop around another loop in dimension 0.
`JZW` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Z in a loop around another loop in dimension W.
`JZX` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Z in a loop around another loop in dimension X.
`JZY` Signature: int64	Jump this many elements in the underlying data array when stepping between elements in dimension Z in a loop around another loop in dimension Y.
`OIII` Signature: V4l
`OIIO` Signature: V4l
`OIOI` Signature: V4l
`OIOO` Signature: V4l
`OOII` Signature: V4l
`OOIO` Signature: V4l
`OOOI` Signature: V4l
`OOOO` Signature: V4l
`OriginIndex()` Signature: unit -> unit Modifiers: abstract
`Rank` Signature: int Modifiers: abstract	Return the rank or dimension of the the tensor4 (4).
`S()` Signature: unit -> unit	Size
`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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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(begin, size, delta)` Signature: (begin:V4l * size:int64 * delta:int64) -> VectorInfo	A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Vector with zero as first coordinates.
`SubVector(begin, size, delta)` Signature: (begin:V4i * size:int64 * delta:int64) -> VectorInfo	A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Vector with zero as first coordinates.
`SubXWMatrixAsReadOnlyTensor4(...)` Signature: (y:int64 * z:int64 * sizey:int64 * sizez:int64) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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 -> VolumeInfo	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) -> Tensor4Info	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 tensor4 with zero as first coordinates.
`SubXYWVolumeAsReadOnlyTensor4Window(...)` Signature: (z:int64 * sizez:int64) -> Tensor4Info	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 -> VolumeInfo	Return a full XYW volume slice of the tensor4. This method retains the coordinates of the parent tensor4.
`SubXYZVolume(w)` Signature: w:int64 -> VolumeInfo	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) -> Tensor4Info	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 tensor4 with zero as first coordinates.
`SubXYZVolumeAsReadOnlyTensor4Window(...)` Signature: (w:int64 * sizew:int64) -> Tensor4Info	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 -> VolumeInfo	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) -> Tensor4Info	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) -> Tensor4Info	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 -> VolumeInfo	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) -> Tensor4Info	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 tensor4 with zero as first coordinates.
`SubXZWVolumeAsReadOnlyTensor4Window(...)` Signature: (y:int64 * sizey:int64) -> Tensor4Info	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 -> VolumeInfo	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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) -> Tensor4Info	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 -> VolumeInfo	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) -> Tensor4Info	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 tensor4 with zero as first coordinates.
`SubYZWVolumeAsReadOnlyTensor4Window(...)` Signature: (x:int64 * sizex:int64) -> Tensor4Info	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 -> VolumeInfo	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) -> Tensor4Info	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) -> Tensor4Info	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.W
`SX()` Signature: unit -> unit	Size.X
`SY()` Signature: unit -> unit	Size.Y
`SZ()` Signature: unit -> unit	Size.Z

Aardvark.Base

Tensor4Info

Constructors

Instance members