Matrix<'Td, 'Tv>
Generic matrix of elements with arbitrary stride. All sizes are given as 2-dimensional vectors, with the first parameter specifying the inner dimension. The matrix does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on matrixs are supported by function arguments which can be easily exploited by using lambda functions. Note: stride is called Delta (or D) within this data structure, the 2 stride direction(s) are called DX, DY, aso. The matrix has different view and data element types, i.e. although all data is stored using the data element type, in its interfaces it acts as a matrix of view element types.
Constructors
Constructor | Description |
new(data, info)
Signature: (data:'Td [] * info:MatrixInfo) -> unit
|
Construct from data array with specified info without copying. |
new(size)
Signature: size:V2l -> unit
|
Construct matrix of specified size. |
new(size)
Signature: size:V2i -> unit
|
Construct matrix of specified size. |
new(info)
Signature: info:MatrixInfo -> unit
|
Construct matrix with specified info. |
new(sx, sy)
Signature: (sx:int64 * sy:int64) -> unit
|
Construct matrix of specified size. |
new(data, sx, sy)
Signature: (data:'Td [] * sx:int64 * sy:int64) -> unit
|
Construct from data array with specified size without copying. |
new(sx, sy, value)
Signature: (sx:int64 * sy:int64 * value:'Tv) -> unit
|
Construct with specified size and sets all elements to the supplied value. |
new(data, size)
Signature: (data:'Td [] * size:V2l) -> unit
|
Construct from data array with specified size without copying. |
new(data, size)
Signature: (data:'Td [] * size:V2i) -> unit
|
Construct from data array with specified size without copying. |
new(size, value)
Signature: (size:V2l * value:'Tv) -> unit
|
Construct matrix of specified size, with all elements set to the supplied value. |
new(size, value)
Signature: (size:V2i * value:'Tv) -> unit
|
Construct matrix of specified size, with all elements set to the supplied value. |
new(data, origin, size, delta)
Signature: (data:'Td [] * origin:int64 * size:V2l * delta:V2l) -> unit
|
Construct from data array with specified size and delta without copying. |
new(data, origin, size, delta, first)
Signature: (data:'Td [] * origin:int64 * size:V2l * delta:V2l * first:V2l) -> unit
|
Construct from data array with specified size and delta without copying. |
new(origin, size, delta)
Signature: (origin:int64 * size:V2l * delta:V2l) -> unit
|
Construct with specified size and delta. |
Instance members
Instance member | Description |
Accessors()
Signature: unit -> unit
|
|
Apply(element_elementFun)
Signature: element_elementFun:Func<'Tv,'Tv> -> Matrix<'Td,'Tv>
|
Apply the supplied function on the elements of the matrix. The value of the elements is given to fun. |
Apply(t1, element_element1_elementFun)
Signature: (t1:Matrix<'T1> * element_element1_elementFun:Func<'Tv,'T1,'Tv>) -> Matrix<'Td,'Tv>
|
Apply the supplied function to each pair of corresponding elements of the original matrix and the supplied matrix. |
Apply(t1, element_element1_elementFun)
Signature: (t1:Matrix<'T1d,'T1> * element_element1_elementFun:Func<'Tv,'T1,'Tv>) -> Matrix<'Td,'Tv>
|
Apply the supplied function to each pair of corresponding elements of the original matrix and the supplied matrix. |
ApplyByCoord(element_crd_elementFun)
Signature: element_crd_elementFun:Func<'Tv,V2l,'Tv> -> Matrix<'Td,'Tv>
|
Apply the supplied function on the elements of the matrix. The value of the elements is given to fun. |
ApplyByCoord(fun)
Signature: fun:Func<'Tv,int64,int64,'Tv> -> Matrix<'Td,'Tv>
|
Set each element to the value of a function of the element coords. |
Array()
Signature: unit -> unit
Modifiers: abstract |
Return the underlying data array as an untyped array. |
ArrayType
Signature: Type
Modifiers: abstract |
Return the type of the underlying data array. |
AsVector()
Signature: unit -> Vector<'Td,'Tv>
|
If the lines of the matrix are stored consecutively without gaps, the whole matrix can be viewed as a single vector. |
AsVector()
Signature: unit -> Vector<'Td,'T1>
|
If the lines of the matrix are stored consecutively without gaps, the whole matrix can be viewed as a single vector. |
Col(x)
Signature: x:int64 -> Vector<'Td,'Tv>
|
Return a full Y vector slice of the matrix. This methods returns a vector with zero as first coordinates. |
Col(x)
Signature: x:int64 -> Vector<'Td,'T1>
|
Return a full Y vector slice of the matrix. This methods returns a vector with zero as first coordinates. |
ColWindow(x)
Signature: x:int64 -> Vector<'Td,'Tv>
|
Return a full Y vector slice of the matrix. This method retains the coordinates of the parent matrix. |
ColWindow(x)
Signature: x:int64 -> Vector<'Td,'T1>
|
Return a full Y vector slice of the matrix. This method retains the coordinates of the parent matrix. |
Copy()
Signature: unit -> Matrix<'Td,'Tv>
|
Elementwise copy. This methods returns a Matrix with zero as first coordinates. |
Copy(fun)
Signature: fun:Func<'Tv,'T1> -> Matrix<'T1>
|
Elementwise copy with function application. This methods returns a Matrix with zero as first coordinates. |
Copy(fun)
Signature: fun:Func<'Tv,'Tv> -> Matrix<'Td,'Tv>
|
Elementwise copy with function application. This methods returns a Matrix with zero as first coordinates. |
CopyView()
Signature: unit -> Matrix<'Tv>
|
|
CopyViewWindow()
Signature: unit -> Matrix<'Tv>
|
|
CopyWindow()
Signature: unit -> Matrix<'Td,'Tv>
|
Elementwise copy. This method retains the coordinates of the original Matrix. |
CopyWindow(fun)
Signature: fun:Func<'Tv,'T1> -> Matrix<'T1>
|
Elementwise copy with function application. This method retains the coordinates of the original Matrix. |
CopyWindow(fun)
Signature: fun:Func<'Tv,'Tv> -> Matrix<'Td,'Tv>
|
Elementwise copy with function application. This method retains the complete layout of the original Matrix. |
Count
Signature: int64
|
Total number of element in the matrix. |
D()
Signature: unit -> unit
|
Delta |
Delta()
Signature: unit -> unit
Modifiers: abstract |
|
DeltaArray()
Signature: unit -> unit
Modifiers: abstract |
Get or set the deltas of the tensor in each dimension as an array of longs. |
Dim
Signature: V2l
Modifiers: abstract |
Dimension of the generic Matrix. |
DSX
Signature: int64
|
Cummulative delta for all elements up to this dimension. |
DSY
Signature: int64
|
Cummulative delta for all elements up to this dimension. |
DX()
Signature: unit -> unit
|
Delta in dimension X. |
DY()
Signature: unit -> unit
|
Delta in dimension Y. |
E
Signature: V2l
|
End: one step beyond the last element. |
Elements
Signature: IEnumerable<'Tv>
|
Yields all elemnts ordered by index. |
End
Signature: V2l
|
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). |
F()
Signature: unit -> unit
|
First |
First()
Signature: unit -> unit
Modifiers: abstract |
|
FirstArray()
Signature: unit -> unit
Modifiers: abstract |
Get or set the first coords of the tensor in each dimension as an array of longs. |
FirstIndex
Signature: int64
|
Return the index of the first element in the underlying data array. |
ForeachCoord(v_action)
Signature: v_action:Action<V2l> -> unit
|
|
ForeachIndex(i_action)
Signature: i_action:Action<int64> -> unit
|
|
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. |
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. |
ForeachY(y_elementAct)
Signature: y_elementAct:Action<int64> -> unit
|
Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action. |
ForeachYIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit
|
Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action. |
ForeachYIndex(y_i_elementAct)
Signature: y_i_elementAct:Action<int64,int64> -> unit
|
Loops over the underlying data array in the specified order, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action. |
ForeachYX(y_x_elementAct)
Signature: y_x_elementAct:Action<int64,int64> -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYX(y_x_elementAct, y_postLineAct)
Signature: (y_x_elementAct:Action<int64,int64> * y_postLineAct:Action<int64>) -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYX(y_preLineAct, y_x_elementAct)
Signature: (y_preLineAct:Action<int64> * y_x_elementAct:Action<int64,int64>) -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYX(...)
Signature: (y_preLineAct:Action<int64> * y_x_elementAct:Action<int64,int64> * y_postLineAct:Action<int64>) -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYXIndex(i_elementAct)
Signature: i_elementAct:Action<int64> -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYXIndex(...)
Signature: (i_elementAct:Action<int64> * postLineAct:Action) -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYXIndex(preLineAct, i_elementAct)
Signature: (preLineAct:Action * i_elementAct:Action<int64>) -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYXIndex(...)
Signature: (preLineAct:Action * i_elementAct:Action<int64> * postLineAct:Action) -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYXIndex(y_x_i_elementAct)
Signature: y_x_i_elementAct:Action<int64,int64,int64> -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYXIndex(...)
Signature: (y_x_i_elementAct:Action<int64,int64,int64> * y_postLineAct:Action<int64>) -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYXIndex(...)
Signature: (y_preLineAct:Action<int64> * y_x_i_elementAct:Action<int64,int64,int64>) -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
ForeachYXIndex(...)
Signature: (y_preLineAct:Action<int64> * y_x_i_elementAct:Action<int64,int64,int64> * y_postLineAct:Action<int64>) -> unit
|
Loops over the underlying data array in the specified order, with the first coordinate being the outer loop, and the last coordinate being the inner loop, and calls the supplied action with the index into the data array as parameter. Optionally, the coordinates of each element are also fed into the supplied action (in the order specified in the name of the function), and also optionally pre-line and post-line actions can be specified. |
FX()
Signature: unit -> unit
|
First in dimension X. |
FY()
Signature: unit -> unit
|
First in dimension Y. |
GetValue(x, y)
Signature: (x:int64 * y:int64) -> obj
Modifiers: abstract |
|
GetValue(v)
Signature: v:V2l -> obj
Modifiers: abstract |
|
II
Signature: V2l
|
|
InnerProduct(t1, mulFun, bias, sumFun)
Signature: (t1:Matrix<'T1> * mulFun:Func<'Tv,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts>) -> 'Ts
Type parameters: 'Ts |
|
InnerProduct(t1, mulFun, bias, sumFun)
Signature: (t1:Matrix<'T1d,'T1> * mulFun:Func<'Tv,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts>) -> 'Ts
Type parameters: 'Tm, 'Ts |
|
InnerProduct(...)
Signature: (t1:Matrix<'T1> * mulFun:Func<'Tv,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * breakIfTrueFun:Func<'Ts,bool>) -> 'Ts
Type parameters: 'Ts |
|
InnerProduct(...)
Signature: (t1:Matrix<'T1d,'T1> * mulFun:Func<'Tv,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * breakIfTrueFun:Func<'Ts,bool>) -> 'Ts
Type parameters: 'Tm, 'Ts |
|
IO
Signature: V2l
|
|
IsInvalid
Signature: bool
Modifiers: abstract |
Returns true if the matrix does not have a data array. |
IsValid
Signature: bool
Modifiers: abstract |
Returns true if the matrix has a data array. |
[()]
Signature: unit -> V2l
Modifiers: abstract |
Get/Set element at specified coordinate. |
[()]
Signature: unit -> V2i
|
Get/Set element at specified coordinate. |
[()]
Signature: unit -> int64
|
Get/Set element at the specified index in the underlying data array. |
[arg1]
Signature: int64 -> int64
Modifiers: abstract |
Get/Set element at specified coordinates. |
[arg1]
Signature: int -> int
|
Get/Set element at specified coordinates. |
JX
Signature: int64
|
Jump this many elements in the underlying data array when stepping in dimension X. |
JY
Signature: int64
|
Jump this many elements in the underlying data array when stepping in dimension Y. |
Map(fun)
Signature: fun:Func<'Tv,'T1> -> Matrix<'T1>
|
Elementwise copy with function application. This methods returns a Matrix with zero as first coordinates. |
Map(fun)
Signature: fun:Func<'Tv,'Tv> -> Matrix<'Td,'Tv>
|
Elementwise copy with function application. This methods returns a Matrix with zero as first coordinates. |
MapWindow(fun)
Signature: fun:Func<'Tv,'T1> -> Matrix<'T1>
|
Elementwise copy with function application. This method retains the coordinates of the original Matrix. |
MapWindow(fun)
Signature: fun:Func<'Tv,'Tv> -> Matrix<'Td,'Tv>
|
Elementwise copy with function application. This method retains the complete layout of the original Matrix. |
Norm(elementFun, bias, sumFun)
Signature: (elementFun:Func<'Tv,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr>) -> 'Tr
|
|
Norm(elementFun, bias, sumFun)
Signature: (elementFun:Func<'Tv,int64,int64,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr>) -> 'Tr
|
|
Norm(elementFun, bias, sumFun)
Signature: (elementFun:Func<'Tv,V2l,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr>) -> 'Tr
|
|
Norm(...)
Signature: (elementFun:Func<'Tv,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr> * breakIfTrueFun:Func<'Tr,bool>) -> 'Tr
|
|
Norm(...)
Signature: (elementFun:Func<'Tv,int64,int64,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr> * breakIfTrueFun:Func<'Tr,bool>) -> 'Tr
|
|
Norm(...)
Signature: (elementFun:Func<'Tv,V2l,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr> * breakIfTrueFun:Func<'Tr,bool>) -> 'Tr
|
|
OI
Signature: V2l
|
|
OO
Signature: V2l
|
|
Origin()
Signature: unit -> unit
Modifiers: abstract |
|
OriginIndex()
Signature: unit -> unit
Modifiers: abstract |
|
Rank
Signature: int
Modifiers: abstract |
Return the rank or dimension of the matrix (2). |
Row(y)
Signature: y:int64 -> Vector<'Td,'Tv>
|
Return a full X vector slice of the matrix. This methods returns a vector with zero as first coordinates. |
Row(y)
Signature: y:int64 -> Vector<'Td,'T1>
|
Return a full X vector slice of the matrix. This methods returns a vector with zero as first coordinates. |
RowWindow(y)
Signature: y:int64 -> Vector<'Td,'Tv>
|
Return a full X vector slice of the matrix. This method retains the coordinates of the parent matrix. |
RowWindow(y)
Signature: y:int64 -> Vector<'Td,'T1>
|
Return a full X vector slice of the matrix. This method retains the coordinates of the parent matrix. |
S()
Signature: unit -> unit
|
Size |
Sample16(...)
Signature: (v:V2d * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,Tup4<'T2>,'TRes> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup4<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup4<int64>>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
Sample16(...)
Signature: (x:float * y:float * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,Tup4<'T2>,'TRes> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup4<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup4<int64>>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
Sample16(dx, dy, wx, wy, xsmp, ysmp)
Signature: (dx:Tup4<int64> * dy:Tup4<int64> * wx:Tup4<'T1> * wy:Tup4<'T2> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,Tup4<'T2>,'TRes>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
Sample16Clamped(...)
Signature: (v:V2d * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,Tup4<'T2>,'TRes>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
Sample16Clamped(...)
Signature: (x:float * y:float * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,Tup4<'T2>,'TRes>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
Sample36(...)
Signature: (v:V2d * xipl:Func<float,Tup6<'T1>> * yipl:Func<float,Tup6<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,'T3,'T3,Tup6<'T2>,'TRes> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup6<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup6<int64>>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
Sample36(...)
Signature: (x:float * y:float * xipl:Func<float,Tup6<'T1>> * yipl:Func<float,Tup6<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,'T3,'T3,Tup6<'T2>,'TRes> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup6<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup6<int64>>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
Sample36(dx, dy, wx, wy, xsmp, ysmp)
Signature: (dx:Tup6<int64> * dy:Tup6<int64> * wx:Tup6<'T1> * wy:Tup6<'T2> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,'T3,'T3,Tup6<'T2>,'TRes>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
Sample36Clamped(...)
Signature: (v:V2d * xipl:Func<float,Tup6<'T1>> * yipl:Func<float,Tup6<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,'T3,'T3,Tup6<'T2>,'TRes>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
Sample36Clamped(...)
Signature: (x:float * y:float * xipl:Func<float,Tup6<'T1>> * yipl:Func<float,Tup6<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,'T3,'T3,Tup6<'T2>,'TRes>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
Sample4(d0, d1, w, smp)
Signature: (d0:int64 * d1:Tup4<int64> * w:Tup4<'T1> * smp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'TRes>) -> 'TRes
|
|
Sample4(...)
Signature: (v:V2d * xipl:Func<float,'Tv,'Tv,'T1> * yipl:Func<float,'T1,'T1,'TRes> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup2<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup2<int64>>) -> 'TRes
|
|
Sample4(...)
Signature: (x:float * y:float * xipl:Func<float,'Tv,'Tv,'T1> * yipl:Func<float,'T1,'T1,'TRes> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup2<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup2<int64>>) -> 'TRes
|
Sample the matrix using 4 samples and the supplied interpolation functions., If only integer coordintes are supplied the returned value is the same as the indexer of the matrix, i.e. pixel centers are assumed to be on integer coordinates. |
Sample4(dx, dy, xf, yf, xipl, yipl)
Signature: (dx:Tup2<int64> * dy:Tup2<int64> * xf:float * yf:float * xipl:Func<float,'Tv,'Tv,'T1> * yipl:Func<float,'T1,'T1,'TRes>) -> 'TRes
|
|
Sample4Clamped(v, xipl, yipl)
Signature: (v:V2d * xipl:Func<float,'Tv,'Tv,'T1> * yipl:Func<float,'T1,'T1,'TRes>) -> 'TRes
|
|
Sample4Clamped(x, y, xipl, yipl)
Signature: (x:float * y:float * xipl:Func<float,'Tv,'Tv,'T1> * yipl:Func<float,'T1,'T1,'TRes>) -> 'TRes
|
|
SampleRaw16(v, xipl, yipl, xsmp, ysmp)
Signature: (v:V2d * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,Tup4<'T2>,'TRes>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
SampleRaw16(...)
Signature: (x:float * y:float * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,Tup4<'T2>,'TRes>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
SampleRaw36(v, xipl, yipl, xsmp, ysmp)
Signature: (v:V2d * xipl:Func<float,Tup6<'T1>> * yipl:Func<float,Tup6<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,'T3,'T3,Tup6<'T2>,'TRes>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
SampleRaw36(...)
Signature: (x:float * y:float * xipl:Func<float,Tup6<'T1>> * yipl:Func<float,Tup6<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,'T3,'T3,Tup6<'T2>,'TRes>) -> 'TRes
Type parameters: 'T3, 'TRes |
|
SampleRaw4(v, xipl, yipl)
Signature: (v:V2d * xipl:Func<float,'Tv,'Tv,'T1> * yipl:Func<float,'T1,'T1,'TRes>) -> 'TRes
|
|
SampleRaw4(x, y, xipl, yipl)
Signature: (x:float * y:float * xipl:Func<float,'Tv,'Tv,'T1> * yipl:Func<float,'T1,'T1,'TRes>) -> 'TRes
|
Sample the matrix using 4 samples and the supplied interpolation function. If only integer coordintes are supplied the returned value is the same as the indexer of the matrix, i.e. pixel centers are assumed to be on integer coordinates. No bounds checking is performed. |
Set(v)
Signature: v:'Tv -> Matrix<'Td,'Tv>
|
Sets all elements to the supplied value. |
Set(it1)
Signature: it1:IMatrix<'Tv> -> Matrix<'Td,'Tv>
|
Set from a tensor that conforms to the corresponding tensor interface. Note, that this function checks if faster set operations are available and uses them if appropriate. |
Set(t1)
Signature: t1:Matrix<'Tv> -> Matrix<'Td,'Tv>
|
Copy all elements from another matrix. |
Set(t1, element1_elementFun)
Signature: (t1:Matrix<'T1> * element1_elementFun:Func<'T1,'Tv>) -> Matrix<'Td,'Tv>
|
Set the elements of a matrix to the result of a function of the elements of the supplied matrix. |
Set(t1)
Signature: t1:Matrix<'T1,'Tv> -> Matrix<'Td,'Tv>
|
Copy all elements from another matrix. |
Set(t1, element1_elementFun)
Signature: (t1:Matrix<'T1d,'T1> * element1_elementFun:Func<'T1,'Tv>) -> Matrix<'Td,'Tv>
|
Set the elements of a matrix to the result of a function of the elements of the supplied matrix. |
Set(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
|
Set the elements of a matrix to the result of a function of corresponding pairs of elements of the two supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Set the elements of a matrix to the result of a function of corresponding pairs of elements of the two supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Set the elements of a matrix to the result of a function of corresponding pairs of elements of the two supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Set the elements of a matrix to the result of a function of corresponding pairs of elements of the two supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3d, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
Set(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3d, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
SetByCoord(x_y_elementFun)
Signature: x_y_elementFun:Func<int64,int64,'Tv> -> Matrix<'Td,'Tv>
|
Set each element to the value of a function of the element coords. |
SetByCoord(crd_elementFun)
Signature: crd_elementFun:Func<V2l,'Tv> -> Matrix<'Td,'Tv>
|
Set each element to the value of a function of the element coords. |
SetByCoord(yFun, fun)
Signature: (yFun:Func<int64,'Ty> * fun:Func<int64,int64,'Ty,'Tv>) -> Matrix<'Td,'Tv>
|
Set each element to the value of a function of the element coords. |
SetByIndex(index_elementFun)
Signature: index_elementFun:Func<int64,'Tv> -> Matrix<'Td,'Tv>
|
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(t1, index1_elementFun)
Signature: (t1:Matrix<'T1> * index1_elementFun:Func<int64,'Tv>) -> Matrix<'Td,'Tv>
|
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(t1, index1_elementFun)
Signature: (t1:Matrix<'T1d,'T1> * index1_elementFun:Func<int64,'Tv>) -> Matrix<'Td,'Tv>
|
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * index1_index2_elementFun:Func<int64,int64,'Tv>) -> Matrix<'Td,'Tv>
|
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * index1_index2_elementFun:Func<int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * index1_index2_elementFun:Func<int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * index1_index2_elementFun:Func<int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3d, 'T3 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetByIndex(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3d, 'T3 |
Set each element to the value of a function of the index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the matrix. |
SetCircle(p, radius, value)
Signature: (p:V2d * radius:float * value:'Tv) -> unit
|
|
SetCircle(x, y, radius, value)
Signature: (x:float * y:float * radius:float * value:'Tv) -> unit
|
|
SetCircle(p, radius, value)
Signature: (p:V2i * radius:int * value:'Tv) -> unit
|
|
SetCircle(p, radius, value)
Signature: (p:V2l * radius:int64 * value:'Tv) -> unit
|
|
SetCircle(x, y, radius, value)
Signature: (x:int64 * y:int64 * radius:int64 * value:'Tv) -> unit
|
|
SetCircleFilled(p, radius, value)
Signature: (p:V2d * radius:float * value:'Tv) -> unit
|
|
SetCircleFilled(x, y, radius, value)
Signature: (x:float * y:float * radius:float * value:'Tv) -> unit
|
|
SetCircleFilled(p, radius, value)
Signature: (p:V2i * radius:int * value:'Tv) -> unit
|
|
SetCircleFilled(p, radius, value)
Signature: (p:V2l * radius:int64 * value:'Tv) -> unit
|
|
SetCircleFilled(x0, y0, radius, value)
Signature: (x0:int64 * y0:int64 * radius:int64 * value:'Tv) -> unit
|
|
SetConvolution(...)
Signature: (image:Matrix<'Ti> * filter:Matrix<'Tf> * mulFun:Func<'Ti,'Tf,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * castFun:Func<'Ts,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'Tm, 'Ts |
Set the matrix to be the convolution of the supplied image and filter tensors. |
SetCross(p, radius, value)
Signature: (p:V2d * radius:float * value:'Tv) -> unit
|
Draws a vertical/horizontal cross around p. |
SetCross(x, y, radius, value)
Signature: (x:float * y:float * radius:float * value:'Tv) -> unit
|
Draws a vertical/horizontal cross around [x,y]. |
SetCross(p, radius, value)
Signature: (p:V2i * radius:int * value:'Tv) -> unit
|
Draws a vertical/horizontal cross around p. |
SetCross(p, radius, value)
Signature: (p:V2l * radius:int64 * value:'Tv) -> unit
|
Draws a vertical/horizontal cross around p. |
SetCross(x, y, radius, value)
Signature: (x:int64 * y:int64 * radius:int64 * value:'Tv) -> unit
|
Draws a vertical/horizontal cross around [x, y]. |
SetCrossX(p, radius, value)
Signature: (p:V2d * radius:float * value:'Tv) -> unit
|
Draws a X-style cross around [x, y]. Note that radius is the horizontal/vertical distance of the corner. |
SetCrossX(x, y, radius, value)
Signature: (x:float * y:float * radius:float * value:'Tv) -> unit
|
Draws a X-style cross around [x, y]. Note that radius is the horizontal/vertical distance of the corner. |
SetCrossX(p, radius, value)
Signature: (p:V2i * radius:int * value:'Tv) -> unit
|
Draws a X-style cross around [x, y]. Note that radius is the horizontal/vertical distance of the corner. |
SetCrossX(p, radius, value)
Signature: (p:V2l * radius:int64 * value:'Tv) -> unit
|
Draws a X-style cross around [x, y]. Note that radius is the horizontal/vertical distance of the corner. |
SetCrossX(x, y, radius, value)
Signature: (x:int64 * y:int64 * radius:int64 * value:'Tv) -> unit
|
Draws a X-style cross around [x, y]. Note that radius is the horizontal/vertical distance of the corner. |
SetLine(p0, p1, value)
Signature: (p0:V2d * p1:V2d * value:'Tv) -> unit
|
|
SetLine(x0, y0, x1, y1, value)
Signature: (x0:float * y0:float * x1:float * y1:float * value:'Tv) -> unit
|
|
SetLine(p0, p1, value)
Signature: (p0:V2i * p1:V2i * value:'Tv) -> unit
|
|
SetLine(p0, p1, value)
Signature: (p0:V2l * p1:V2l * value:'Tv) -> unit
|
|
SetLine(x0, y0, x1, y1, value)
Signature: (x0:int64 * y0:int64 * x1:int64 * y1:int64 * value:'Tv) -> unit
|
Bresenham Line Algorithm |
SetLineAllTouchedRaw(p0, p1, value)
Signature: (p0:V2d * p1:V2d * value:'Tv) -> unit
|
Set all pixels whose square region is intersected by the line from p0 to p1 to the supplied value. Does not perform any bounds checks. |
SetLineAllTouchedRaw(...)
Signature: (x0:float * y0:float * x1:float * y1:float * value:'Tv) -> unit
|
Set all pixels whose square region is intersected by the line from (x0,y0) to (x1,y1) to the supplied value. Does not perform any bounds checks. |
SetLineX(x0, x1, y, value)
Signature: (x0:float * x1:float * y:float * value:'Tv) -> unit
|
Draws a horizontal line. The parameters x0, x1, and y are rounded to the nearest integer coordinates. |
SetLineX(x0, x1, y, value)
Signature: (x0:int64 * x1:int64 * y:int64 * value:'Tv) -> unit
|
Draws a horizontal line. |
SetLineY(x, y0, y1, value)
Signature: (x:float * y0:float * y1:float * value:'Tv) -> unit
|
Draws a vertical line. The parameters x, y0, and y1 are rounded to the nearest integer coordinates. |
SetLineY(x, y0, y1, value)
Signature: (x:int64 * y0:int64 * y1:int64 * value:'Tv) -> unit
|
Draws a vertical line. |
SetMap(t1, element1_elementFun)
Signature: (t1:Matrix<'T1> * element1_elementFun:Func<'T1,'Tv>) -> Matrix<'Td,'Tv>
|
Set the elements of a matrix to the result of a function of the elements of the supplied matrix. |
SetMap(t1, element1_elementFun)
Signature: (t1:Matrix<'T1d,'T1> * element1_elementFun:Func<'T1,'Tv>) -> Matrix<'Td,'Tv>
|
Set the elements of a matrix to the result of a function of the elements of the supplied matrix. |
SetMap2(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
|
Set the elements of a matrix to the result of a function of corresponding pairs of elements of the two supplied tensors. |
SetMap2(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Set the elements of a matrix to the result of a function of corresponding pairs of elements of the two supplied tensors. |
SetMap2(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Set the elements of a matrix to the result of a function of corresponding pairs of elements of the two supplied tensors. |
SetMap2(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Set the elements of a matrix to the result of a function of corresponding pairs of elements of the two supplied tensors. |
SetMap3(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
SetMap3(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3d, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
SetMap3(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
SetMap3(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
SetMap3(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
SetMap3(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
SetMap3(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
SetMap3(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3d, 'T3 |
Set the elements of a tensor to the result of a function of corresponding triples of elements of the three supplied tensors. |
SetMonotonePolygonFilledRaw(...)
Signature: (polygon:V2d [] * value:'Tv * winding:Winding * eps:float) -> unit
|
Set all matrix pixels inside the specified polygon to the supplied value. This is a raw routine that does no clipping and assumes that all pixels that need to be set are within the matrix. The polygon is assumed to consist of two y-monotone point sequences between the points with minimum and maximum y-coordinate. Note that convex and non-concave polygons automatically fullfill this condition. Rasterization is performed according to DirextX11 rules. |
SetMonotonePolygonFilledRaw(...)
Signature: (polygon:int [] * vertexArray:V2d [] * value:'Tv * winding:Winding * eps:float) -> unit
|
Set all matrix pixels inside the specified polygon to the supplied value. This is a raw routine that does no clipping and assumes that all pixels that need to be set are within the matrix. The polygon is assumed to consist of two y-monotone point sequences between the points with minimum and maximum y-coordinate. Note that convex and non-concave polygons automatically fullfill this condition. Rasterization is performed according to DirextX11 rules. |
SetOuterProduct(tx, ty, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * fun:Func<'Tx,'Ty,'Tv>) -> Matrix<'Td,'Tv>
|
Set the matrix to be the outer product of the two supplied vectors. |
SetOuterProduct(tx, ty, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * fun:Func<'Tx,'Ty,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'Ty |
Set the matrix to be the outer product of the two supplied vectors. |
SetOuterProduct(tx, ty, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * fun:Func<'Tx,'Ty,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'Ty |
Set the matrix to be the outer product of the two supplied vectors. |
SetOuterProduct(tx, ty, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * fun:Func<'Tx,'Ty,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'Tyd, 'Ty |
Set the matrix to be the outer product of the two supplied vectors. |
SetRectangle(p0, p1, value)
Signature: (p0:V2d * p1:V2d * value:'Tv) -> unit
|
Draws a rectangular frame. The corner positions are rounded to the nearest integer coordinates. |
SetRectangle(x0, y0, x1, y1, value)
Signature: (x0:float * y0:float * x1:float * y1:float * value:'Tv) -> unit
|
Draws a rectangular frame. The parameters x0, x1, y0, and y1 are rounded to the nearest integer coordinates. |
SetRectangle(p0, p1, value)
Signature: (p0:V2i * p1:V2i * value:'Tv) -> unit
|
Draws a rectangular frame given the coordinates of two opposing corners. |
SetRectangle(v0, v1, value)
Signature: (v0:V2l * v1:V2l * value:'Tv) -> unit
|
Draws a rectangular frame given the coordinates of two opposing corners. |
SetRectangle(x0, y0, x1, y1, value)
Signature: (x0:int64 * y0:int64 * x1:int64 * y1:int64 * value:'Tv) -> unit
|
Draws a rectangular frame given the coordinates of two opposing corners. |
SetRectangleFilled(p0, p1, value)
Signature: (p0:V2d * p1:V2d * value:'Tv) -> unit
|
Sets the supplied rectangle and its interior to the supplied value. Note that the coordinates are rounded to the nearest integer coordinate. |
SetRectangleFilled(...)
Signature: (x0:float * y0:float * x1:float * y1:float * value:'Tv) -> unit
|
Sets the supplied rectangle and its interior to the supplied value. Note that the coordinates are rounded to the nearest integer coordinate. |
SetRectangleFilled(p0, p1, value)
Signature: (p0:V2i * p1:V2i * value:'Tv) -> unit
|
Sets the supplied rectangle given by its minimal and maximal pixel position vectors and its interior to the supplied value. |
SetRectangleFilled(p0, p1, value)
Signature: (p0:V2l * p1:V2l * value:'Tv) -> unit
|
Sets the supplied rectangle given by its minimal and maximal pixel position vectors and its interior to the supplied value. |
SetRectangleFilled(...)
Signature: (x0:int64 * y0:int64 * x1:int64 * y1:int64 * value:'Tv) -> unit
|
Sets the supplied rectangle given by its minimal and maximal pixel coordinates and its interior to the supplied value. |
SetScaled16(...)
Signature: (sourceMat:Matrix<'Td,'Tv> * xScale:float * yScale:float * xShift:float * yShift:float * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,Tup4<'T2>,'Tv> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup4<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup4<int64>>) -> unit
Type parameters: 'T3 |
|
SetScaled16(...)
Signature: (sourceMat:Matrix<'Td,'Tv> * xScale:float * yScale:float * xShift:float * yShift:float * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,Tup4<'T2>,'T4> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup4<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup4<int64>> * clampFun:Func<'T4,'Tv>) -> unit
Type parameters: 'T3, 'T4 |
|
SetScaled16InDevelopment(...)
Signature: (sourceMat:Matrix<'Td,'Tv> * xScale:float * yScale:float * xShift:float * yShift:float * xipl:Func<float,Tup4<'T1>> * yipl:Func<float,Tup4<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,Tup4<'T2>,'Tv> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup4<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup4<int64>>) -> unit
Type parameters: 'T3 |
|
SetScaled36(...)
Signature: (sourceMat:Matrix<'Td,'Tv> * xScale:float * yScale:float * xShift:float * yShift:float * xipl:Func<float,Tup6<'T1>> * yipl:Func<float,Tup6<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,'T3,'T3,Tup6<'T2>,'Tv> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup6<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup6<int64>>) -> unit
Type parameters: 'T3 |
|
SetScaled36(...)
Signature: (sourceMat:Matrix<'Td,'Tv> * xScale:float * yScale:float * xShift:float * yShift:float * xipl:Func<float,Tup6<'T1>> * yipl:Func<float,Tup6<'T2>> * xsmp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'T3> * ysmp:FuncRef1<'T3,'T3,'T3,'T3,'T3,'T3,Tup6<'T2>,'T4> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup6<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup6<int64>> * clampFun:Func<'T4,'Tv>) -> unit
Type parameters: 'T3, 'T4 |
|
SetScaled4(...)
Signature: (sourceMat:Matrix<'Td,'Tv> * xScale:float * yScale:float * xShift:float * yShift:float * xipl:Func<float,'Tv,'Tv,'T1> * yipl:Func<float,'T1,'T1,'Tv> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup2<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup2<int64>>) -> unit
|
|
SetScaled4(...)
Signature: (sourceMat:Matrix<'Td,'Tv> * xScale:float * yScale:float * xShift:float * yShift:float * xipl:Func<float,'Tv,'Tv,'T1> * yipl:Func<float,'T1,'T1,'T2> * index_min_max_delta_xIndexFun:Func<int64,int64,int64,int64,Tup2<int64>> * index_min_max_delta_yIndexFun:Func<int64,int64,int64,int64,Tup2<int64>> * clampFun:Func<'T2,'Tv>) -> unit
|
|
SetSquare(p, radius, value)
Signature: (p:V2d * radius:float * value:'Tv) -> unit
|
|
SetSquare(x, y, radius, value)
Signature: (x:float * y:float * radius:float * value:'Tv) -> unit
|
|
SetSquare(p, radius, value)
Signature: (p:V2i * radius:int * value:'Tv) -> unit
|
|
SetSquare(p, radius, value)
Signature: (p:V2l * radius:int64 * value:'Tv) -> unit
|
|
SetSquare(x, y, radius, value)
Signature: (x:int64 * y:int64 * radius:int64 * value:'Tv) -> unit
|
|
SetSquareFilled(p, radius, value)
Signature: (p:V2d * radius:float * value:'Tv) -> unit
|
|
SetSquareFilled(x, y, radius, value)
Signature: (x:float * y:float * radius:float * value:'Tv) -> unit
|
|
SetSquareFilled(p, radius, value)
Signature: (p:V2i * radius:int * value:'Tv) -> unit
|
|
SetSquareFilled(p, radius, value)
Signature: (p:V2l * radius:int64 * value:'Tv) -> unit
|
|
SetSquareFilled(x, y, radius, value)
Signature: (x:int64 * y:int64 * radius:int64 * value:'Tv) -> unit
|
|
SetValue(value, x, y)
Signature: (value:obj * x:int64 * y:int64) -> unit
Modifiers: abstract |
|
SetValue(value, v)
Signature: (value:obj * v:V2l) -> unit
Modifiers: abstract |
|
Size()
Signature: unit -> unit
Modifiers: abstract |
|
SizeArray()
Signature: unit -> unit
Modifiers: abstract |
Get or set the size of the tensor in each dimension as an array of longs. |
SubItemAsReadOnlyMatrix(...)
Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Matrix<'Td,'Tv>
|
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. |
SubItemAsReadOnlyMatrix(...)
Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'Tv>
|
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. |
SubItemAsReadOnlyMatrixWindow(...)
Signature: (x:int64 * y:int64 * sizex:int64 * sizey:int64) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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:V2l * size:V2l) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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) -> Matrix<'Td,'Tv>
|
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:V2l * size:V2l) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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) -> Matrix<'Td,'T1>
|
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(origin, size, delta)
Signature: (origin:V2l * size:int64 * delta:int64) -> Vector<'Td,'Tv>
|
A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. |
SubVector(origin, size, delta)
Signature: (origin:V2i * size:int64 * delta:int64) -> Vector<'Td,'Tv>
|
A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. |
SubVector(origin, size, delta)
Signature: (origin:V2l * size:int64 * delta:int64) -> Vector<'Td,'T1>
|
A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. |
SubVector(origin, size, delta)
Signature: (origin:V2i * size:int64 * delta:int64) -> Vector<'Td,'T1>
|
A SubVector does not copy any data, and thus any operations on it are reflected in the corresponding part of the parent. |
SubXVector(y)
Signature: y:int64 -> Vector<'Td,'Tv>
|
Return a full X vector slice of the matrix. This methods returns a vector with zero as first coordinates. |
SubXVector(y)
Signature: y:int64 -> Vector<'Td,'T1>
|
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) -> Matrix<'Td,'Tv>
|
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 vector with zero as first coordinates. |
SubXVectorAsReadOnlyMatrix(y, sizey)
Signature: (y:int64 * sizey:int64) -> Matrix<'Td,'T1>
|
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 vector with zero as first coordinates. |
SubXVectorAsReadOnlyMatrixWindow(...)
Signature: (y:int64 * sizey:int64) -> Matrix<'Td,'Tv>
|
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. |
SubXVectorAsReadOnlyMatrixWindow(...)
Signature: (y:int64 * sizey:int64) -> Matrix<'Td,'T1>
|
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 -> Vector<'Td,'Tv>
|
Return a full X vector slice of the matrix. This method retains the coordinates of the parent matrix. |
SubXVectorWindow(y)
Signature: y:int64 -> Vector<'Td,'T1>
|
Return a full X vector slice of the matrix. This method retains the coordinates of the parent matrix. |
SubYVector(x)
Signature: x:int64 -> Vector<'Td,'Tv>
|
Return a full Y vector slice of the matrix. This methods returns a vector with zero as first coordinates. |
SubYVector(x)
Signature: x:int64 -> Vector<'Td,'T1>
|
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) -> Matrix<'Td,'Tv>
|
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 vector with zero as first coordinates. |
SubYVectorAsReadOnlyMatrix(x, sizex)
Signature: (x:int64 * sizex:int64) -> Matrix<'Td,'T1>
|
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 vector with zero as first coordinates. |
SubYVectorAsReadOnlyMatrixWindow(...)
Signature: (x:int64 * sizex:int64) -> Matrix<'Td,'Tv>
|
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. |
SubYVectorAsReadOnlyMatrixWindow(...)
Signature: (x:int64 * sizex:int64) -> Matrix<'Td,'T1>
|
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 -> Vector<'Td,'Tv>
|
Return a full Y vector slice of the matrix. This method retains the coordinates of the parent matrix. |
SubYVectorWindow(x)
Signature: x:int64 -> Vector<'Td,'T1>
|
Return a full Y vector slice of the matrix. This method retains the coordinates of the parent matrix. |
SX()
Signature: unit -> unit
|
Size in dimension X. |
SY()
Signature: unit -> unit
|
Size in dimension Y. |
Transposed
Signature: Matrix<'Td,'Tv>
|
Returns a matrix that represents a view on the same data with flipped coordinates. |
Static members
Static member | Description |
Create(t1)
Signature: t1:Matrix<'Tv> -> Matrix<'Td,'Tv>
|
Create a new matrix as copy of the supplied matrix. |
Create(t1)
Signature: t1:Matrix<'T1d,'Tv> -> Matrix<'Td,'Tv>
|
Create a new matrix as copy of the supplied matrix. |
Create(t1, element1_elementFun)
Signature: (t1:Matrix<'T1> * element1_elementFun:Func<'T1,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(t1, element1_elementFun)
Signature: (t1:Matrix<'T1d,'T1> * element1_elementFun:Func<'T1,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3d, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3d, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Create(size, fun)
Signature: (size:V2l * fun:Func<V2l,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix by applying a function to the coordinates of the elements the newly created matrix. |
CreateByIndex(t1, index1_elementFun)
Signature: (t1:Matrix<'T1> * index1_elementFun:Func<int64,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(t1, index1_elementFun)
Signature: (t1:Matrix<'T1d,'T1> * index1_elementFun:Func<int64,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * index1_index2_fun:Func<int64,int64,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * index1_index2_fun:Func<int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * index1_index2_fun:Func<int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * index1_index2_fun:Func<int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3d, 'T3 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateByIndex(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3d, 'T3 |
Create a new matrix by applying a function to each index of the elements of the supplied matrix. The function may access the elements of the supplied matrix to compute the elements of the new matrix. |
CreateConvolution(...)
Signature: (image:Matrix<'Ti> * filter:Matrix<'Tf> * mulFun:Func<'Ti,'Tf,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * castFun:Func<'Ts,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'Tm, 'Ts |
Create a new Matrix by convolving the image with the filter. The mulFun is used to combine single elements of the image with the filter. The result is summed up using the sumFun starting with bias. The complete sum is put through the castFun and put into the resulting Matrix. |
CreateOuterProduct(tx, ty, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Ty> * fun:Func<'Tx,'Ty,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix as the outer product of the two supplied vectors. |
CreateOuterProduct(tx, ty, fun)
Signature: (tx:Vector<'Tx> * ty:Vector<'Tyd,'Ty> * fun:Func<'Tx,'Ty,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'Ty |
Create a new matrix as the outer product of the two supplied vectors. |
CreateOuterProduct(tx, ty, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Ty> * fun:Func<'Tx,'Ty,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'Ty |
Create a new matrix as the outer product of the two supplied vectors. |
CreateOuterProduct(tx, ty, fun)
Signature: (tx:Vector<'Txd,'Tx> * ty:Vector<'Tyd,'Ty> * fun:Func<'Tx,'Ty,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'Tyd, 'Ty |
Create a new matrix as the outer product of the two supplied vectors. |
Map(t1, element1_elementFun)
Signature: (t1:Matrix<'T1> * element1_elementFun:Func<'T1,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix by applying a function on each element of the supplied matrix. |
Map(t1, element1_elementFun)
Signature: (t1:Matrix<'T1d,'T1> * element1_elementFun:Func<'T1,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix by applying a function on each element of the supplied matrix. |
Map2(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
|
Create a new matrix by applying a function on each element of the supplied matrix. |
Map2(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Map2(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Map2(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Map3(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Map3(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T3d, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Map3(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Map3(...)
Signature: (t1:Matrix<'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Map3(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Map3(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Map3(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |
Map3(...)
Signature: (t1:Matrix<'T1d,'T1> * t2:Matrix<'T2d,'T2> * t3:Matrix<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Matrix<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3d, 'T3 |
Create a new matrix by applying a function on each element of the supplied matrix. |