MatrixInfo
A matrix info contains the complete indexing information for a matrix, but no data array.
Constructors
| Constructor | Description |
new(origin, size, delta, first)
Signature: (origin:int64 * size:V2l * delta:V2l * first:V2l) -> unit
|
Construct a MatrixInfo given a complete specification. |
new(origin, size, delta)
Signature: (origin:int64 * size:V2l * delta:V2l) -> unit
|
Construct a MatrixInfo given a complete specification. |
new(size)
Signature: size:V2l -> unit
|
|
new(size, delta)
Signature: (size:V2l * delta:V2l) -> unit
|
|
new(info)
Signature: info:MatrixInfo -> unit
|
|
new(size)
Signature: size:V2i -> unit
|
Construct matrix info of specified size. |
new(sizeX, sizeY)
Signature: (sizeX:int64 * sizeY:int64) -> unit
|
Construct matrix info of specified size. |
new(sizeX, sizeY)
Signature: (sizeX:int * sizeY:int) -> unit
|
Construct matrix info of specified size. |
Instance members
| Instance member | Description |
AsVector()
Signature: unit -> VectorInfo
|
If the lines of the matrix are stored consecutively without gaps, the whole matrix can be viewed as a single vector. This methods returns a Vector with zero as first coordinates. |
CheckMatchingSize(t1)
Signature: t1:MatrixInfo -> unit
|
|
CheckMatchingSize(t1, t2)
Signature: (t1:MatrixInfo * t2:MatrixInfo) -> unit
|
|
CheckMatchingSize(t1, t2, t3)
Signature: (t1:MatrixInfo * t2:MatrixInfo * t3:MatrixInfo) -> unit
|
|
Col(x)
Signature: x:int64 -> VectorInfo
|
Return a full Y vector slice of the matrix. This methods returns a vector with zero as first coordinates. |
ColWindow(x)
Signature: x:int64 -> VectorInfo
|
Return a full Y vector slice of the matrix. This method retains the coordinates of the parent matrix. |
Count
Signature: int64
|
Total number of element in the matrix. |
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. |
DSX
Signature: int64
|
Cummulative delta for all elements up to this dimension. |
DSY
Signature: int64
|
Cummulative delta for all elements up to this dimension. |
Dv(dx, dy)
Signature: (dx:int64 * dy:int64) -> int64
|
|
DX()
Signature: unit -> unit
|
Delta.X |
DY()
Signature: unit -> unit
|
Delta.Y |
E
Signature: V2l
|
End (one step beyond the last element in all dimensions). |
End
Signature: V2l
|
End (one step beyond the last element in all dimensions). |
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). |
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<V2l> -> unit
|
|
ForeachIndex(i_action)
Signature: i_action:Action<int64> -> unit
Modifiers: abstract |
|
ForeachIndex(x_y_i_action)
Signature: x_y_i_action:Action<int64,int64,int64> -> unit
|
|
ForeachIndex(t1, i_i1_act)
Signature: (t1:MatrixInfo * i_i1_act:Action<int64,int64>) -> unit
|
|
ForeachX(x_elementAct)
Signature: x_elementAct:Action<int64> -> unit
|
Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action. |
ForeachXIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit
|
Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action. |
ForeachXIndex(x_i_elementAct)
Signature: x_i_elementAct:Action<int64,int64> -> unit
|
Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action. |
ForeachXIndex(t1, i_i1_elementAct)
Signature: (t1:MatrixInfo * 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:MatrixInfo * 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. |
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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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. |
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:MatrixInfo * 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:MatrixInfo * 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. |
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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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:MatrixInfo * 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. |
FX()
Signature: unit -> unit
|
First.X |
FY()
Signature: unit -> unit
|
First.Y |
GetJX(size)
Signature: size:V2l -> int64
|
|
GetJX0(size)
Signature: size:V2l -> int64
|
|
GetJXY(size)
Signature: size:V2l -> int64
|
|
GetJY(size)
Signature: size:V2l -> int64
|
|
GetJY0(size)
Signature: size:V2l -> int64
|
|
GetJYX(size)
Signature: size:V2l -> int64
|
|
HasMatchingLayout(t1)
Signature: t1:MatrixInfo -> bool
|
|
HasMatchingLayout(t1, t2)
Signature: (t1:MatrixInfo * t2:MatrixInfo) -> bool
|
|
HasMatchingLayout(t1, t2, t3)
Signature: (t1:MatrixInfo * t2:MatrixInfo * t3:MatrixInfo) -> bool
|
|
II
Signature: V2l
|
|
Index(x, y)
Signature: (x:int64 * y:int64) -> int64
|
Calculate element index for underlying data array. |
Index(v)
Signature: v:V2l -> int64
|
Calculate element index for underlying data array. |
Index(v)
Signature: v:V2i -> int64
|
Calculate element index for underlying data array. |
IndicesX
Signature: IEnumerable<int64>
|
Return the indices into the underlying data array in the specified order. |
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. |
IndicesY
Signature: IEnumerable<int64>
|
Return the indices into the underlying data array in the specified order. |
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. |
IO
Signature: V2l
|
|
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. |
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. |
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. |
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. |
OI
Signature: V2l
|
|
OO
Signature: V2l
|
|
OriginIndex()
Signature: unit -> unit
Modifiers: abstract |
|
Rank
Signature: int
Modifiers: abstract |
Return the rank or dimension of the the matrix (2). |
Row(y)
Signature: y:int64 -> VectorInfo
|
Return a full X vector slice of the matrix. This methods returns a vector with zero as first coordinates. |
RowWindow(y)
Signature: y:int64 -> VectorInfo
|
Return a full X vector slice of the matrix. This method retains the coordinates of the parent matrix. |
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. |
SubItemAsReadOnlyMatrix(...)
Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> MatrixInfo
|
Return a full item slice of the matrix as a special matrix that replicates the item the supplied number of times. The special matrix can only be correctly used to read from. Other operations are not guaranteed. This methods returns a matrix with zero as first coordinates. |
SubItemAsReadOnlyMatrixWindow(...)
Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> MatrixInfo
|
Return a full item slice of the matrix as a special matrix that replicates the item the supplied number of times. The special matrix can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent matrix. |
SubMatrix(begin, size)
Signature: (begin:V2l * size:V2l) -> MatrixInfo
|
A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Matrix with zero as first coordinates. |
SubMatrix(begin, size)
Signature: (begin:V2i * size:V2i) -> MatrixInfo
|
A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Matrix with zero as first coordinates. |
SubMatrix(begin, size, delta)
Signature: (begin:V2l * size:V2l * delta:V2l) -> MatrixInfo
|
A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Matrix with zero as first coordinates. |
SubMatrix(begin, size, delta)
Signature: (begin:V2i * size:V2i * delta:V2i) -> MatrixInfo
|
A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Matrix with zero as first coordinates. |
SubMatrix(beginX, beginY, sizeX, sizeY)
Signature: (beginX:int64 * beginY:int64 * sizeX:int64 * sizeY:int64) -> MatrixInfo
|
A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Matrix with zero as first coordinates. |
SubMatrix(...)
Signature: (beginX:int64 * beginY:int64 * sizeX:int64 * sizeY:int64 * deltaX:int64 * deltaY:int64) -> MatrixInfo
|
A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. This methods returns a Matrix with zero as first coordinates. |
SubMatrixWindow(begin, size)
Signature: (begin:V2l * size:V2l) -> MatrixInfo
|
A SubMatrix 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 Matrix. |
SubMatrixWindow(begin, size)
Signature: (begin:V2i * size:V2i) -> MatrixInfo
|
A SubMatrix 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 Matrix. |
SubMatrixWindow(begin, size, delta)
Signature: (begin:V2l * size:V2l * delta:V2l) -> MatrixInfo
|
A SubMatrix 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 Matrix. |
SubMatrixWindow(begin, size, delta)
Signature: (begin:V2i * size:V2i * delta:V2i) -> MatrixInfo
|
A SubMatrix 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 Matrix. |
SubMatrixWindow(...)
Signature: (begin:V2l * size:V2l * delta:V2l * first:V2l) -> MatrixInfo
|
A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. |
SubMatrixWindow(...)
Signature: (begin:V2i * size:V2i * delta:V2i * first:V2i) -> MatrixInfo
|
A SubMatrix does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. |
SubMatrixWindow(...)
Signature: (beginX:int64 * beginY:int64 * sizeX:int64 * sizeY:int64) -> MatrixInfo
|
A SubMatrix 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 Matrix. |
SubMatrixWindow(...)
Signature: (beginX:int64 * beginY:int64 * sizeX:int64 * sizeY:int64 * deltaX:int64 * deltaY:int64) -> MatrixInfo
|
A SubMatrix 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 Matrix. |
SubVector(begin, size, delta)
Signature: (begin:V2l * 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:V2i * 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. |
SubXVector(y)
Signature: y:int64 -> VectorInfo
|
Return a full X vector slice of the matrix. This methods returns a vector with zero as first coordinates. |
SubXVectorAsReadOnlyMatrix(y, sizey)
Signature: (y:int64 * sizey:int64) -> MatrixInfo
|
Return a full X vector slice of the matrix as a special matrix that replicates the vector the supplied number of times. The special matrix can only be correctly used to read from. Other operations are not guaranteed. This methods returns a matrix with zero as first coordinates. |
SubXVectorAsReadOnlyMatrixWindow(...)
Signature: (y:int64 * sizey:int64) -> MatrixInfo
|
Return a full X vector slice of the matrix as a special matrix that replicates the vector the supplied number of times. The special matrix can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent matrix. |
SubXVectorWindow(y)
Signature: y:int64 -> VectorInfo
|
Return a full X vector slice of the matrix. This method retains the coordinates of the parent matrix. |
SubYVector(x)
Signature: x:int64 -> VectorInfo
|
Return a full Y vector slice of the matrix. This methods returns a vector with zero as first coordinates. |
SubYVectorAsReadOnlyMatrix(x, sizex)
Signature: (x:int64 * sizex:int64) -> MatrixInfo
|
Return a full Y vector slice of the matrix as a special matrix that replicates the vector the supplied number of times. The special matrix can only be correctly used to read from. Other operations are not guaranteed. This methods returns a matrix with zero as first coordinates. |
SubYVectorAsReadOnlyMatrixWindow(...)
Signature: (x:int64 * sizex:int64) -> MatrixInfo
|
Return a full Y vector slice of the matrix as a special matrix that replicates the vector the supplied number of times. The special matrix can only be correctly used to read from. Other operations are not guaranteed. This method retains the coordinates of the parent matrix. |
SubYVectorWindow(x)
Signature: x:int64 -> VectorInfo
|
Return a full Y vector slice of the matrix. This method retains the coordinates of the parent matrix. |
SX()
Signature: unit -> unit
|
Size.X |
SY()
Signature: unit -> unit
|
Size.Y |
Transposed
Signature: MatrixInfo
|
