Aardvark.Base


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

ConstructorDescription
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 memberDescription
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 memberDescription
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.

Fork me on GitHub