Vector<'Td, 'Tv>
Generic vector of elements with arbitrary stride. All sizes are given as 1-dimensional vectors, with the first parameter specifying the inner dimension. The vector does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on vectors 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 1 stride direction(s) are called DX, DY, aso. The vector 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 vector of view element types.
Constructors
| Constructor | Description |
new(data, info)
Signature: (data:'Td [] * info:VectorInfo) -> unit
|
Construct from data array with specified info without copying. |
new(size)
Signature: size:int64 -> unit
|
Construct vector of specified size. |
new(size)
Signature: size:int -> unit
|
Construct vector of specified size. |
new(info)
Signature: info:VectorInfo -> unit
|
Construct vector with specified info. |
new(data)
Signature: (data:'Td []) -> unit
|
Construct from data array without copying. |
new(data, size)
Signature: (data:'Td [] * size:int64) -> unit
|
Construct from data array with specified size without copying. |
new(data, size)
Signature: (data:'Td [] * size:int) -> unit
|
Construct from data array with specified size without copying. |
new(size, value)
Signature: (size:int64 * value:'Tv) -> unit
|
Construct vector of specified size, with all elements set to the supplied value. |
new(size, value)
Signature: (size:int * 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:int64 * delta:int64) -> unit
|
Construct from data array with specified size and delta without copying. |
new(data, origin, size, delta, first)
Signature: (data:'Td [] * origin:int64 * size:int64 * delta:int64 * first:int64) -> unit
|
Construct from data array with specified size and delta without copying. |
new(origin, size, delta)
Signature: (origin:int64 * size:int64 * delta:int64) -> 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> -> Vector<'Td,'Tv>
|
Apply the supplied function on the elements of the vector. The value of the elements is given to fun. |
Apply(t1, element_element1_elementFun)
Signature: (t1:Vector<'T1> * element_element1_elementFun:Func<'Tv,'T1,'Tv>) -> Vector<'Td,'Tv>
|
Apply the supplied function to each pair of corresponding elements of the original vector and the supplied vector. |
Apply(t1, element_element1_elementFun)
Signature: (t1:Vector<'T1d,'T1> * element_element1_elementFun:Func<'Tv,'T1,'Tv>) -> Vector<'Td,'Tv>
|
Apply the supplied function to each pair of corresponding elements of the original vector and the supplied vector. |
ApplyByCoord(fun)
Signature: fun:Func<'Tv,int64,'Tv> -> Vector<'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. |
Copy()
Signature: unit -> Vector<'Td,'Tv>
|
Elementwise copy. This methods returns a Vector with zero as first coordinates. |
Copy(fun)
Signature: fun:Func<'Tv,'T1> -> Vector<'T1>
|
Elementwise copy with function application. This methods returns a Vector with zero as first coordinates. |
Copy(fun)
Signature: fun:Func<'Tv,'Tv> -> Vector<'Td,'Tv>
|
Elementwise copy with function application. This methods returns a Vector with zero as first coordinates. |
CopyView()
Signature: unit -> Vector<'Tv>
|
|
CopyViewWindow()
Signature: unit -> Vector<'Tv>
|
|
CopyWindow()
Signature: unit -> Vector<'Td,'Tv>
|
Elementwise copy. This method retains the coordinates of the original Vector. |
CopyWindow(fun)
Signature: fun:Func<'Tv,'T1> -> Vector<'T1>
|
Elementwise copy with function application. This method retains the coordinates of the original Vector. |
CopyWindow(fun)
Signature: fun:Func<'Tv,'Tv> -> Vector<'Td,'Tv>
|
Elementwise copy with function application. This method retains the complete layout of the original Vector. |
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: int64
Modifiers: abstract |
Dimension of the generic Vector. |
DS
Signature: int64
|
Cummulative delta for all elements up to this dimension. |
DSX
Signature: int64
|
Cummulative delta for all elements up to this dimension. |
DX()
Signature: unit -> unit
|
Delta in dimension X. |
E
Signature: int64
|
End: one step beyond the last element. |
Elements
Signature: IEnumerable<'Tv>
|
Yields all elemnts ordered by index. |
End
Signature: int64
|
One step beyond the last element. |
EX
Signature: int64
|
End in dimension X (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<int64> -> unit
|
|
ForeachIndex(i_action)
Signature: i_action:Action<int64> -> unit
|
|
ForeachIndex(x_i_action)
Signature: x_i_action:Action<int64,int64> -> unit
|
|
ForeachIndex(t1, i_i1_act)
Signature: (t1:VectorInfo * i_i1_act:Action<int64,int64>) -> unit
|
|
FX()
Signature: unit -> unit
|
First in dimension X. |
GetValue(x)
Signature: x:int64 -> obj
Modifiers: abstract |
|
I
Signature: int64
|
|
InnerProduct(t1, mulFun, bias, sumFun)
Signature: (t1:Vector<'T1> * mulFun:Func<'Tv,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts>) -> 'Ts
Type parameters: 'Ts |
|
InnerProduct(t1, mulFun, bias, sumFun)
Signature: (t1:Vector<'T1d,'T1> * mulFun:Func<'Tv,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts>) -> 'Ts
Type parameters: 'Tm, 'Ts |
|
InnerProduct(...)
Signature: (t1:Vector<'T1> * mulFun:Func<'Tv,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * breakIfTrueFun:Func<'Ts,bool>) -> 'Ts
Type parameters: 'Ts |
|
InnerProduct(...)
Signature: (t1:Vector<'T1d,'T1> * mulFun:Func<'Tv,'T1,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * breakIfTrueFun:Func<'Ts,bool>) -> 'Ts
Type parameters: 'Tm, 'Ts |
|
IsInvalid
Signature: bool
Modifiers: abstract |
Returns true if the vector does not have a data array. |
IsValid
Signature: bool
Modifiers: abstract |
Returns true if the vector has a data array. |
[()]
Signature: unit -> int64
Modifiers: abstract |
Get/Set element at specified coordinates. |
[()]
Signature: unit -> int
|
Get/Set element at specified coordinates. |
JX
Signature: int64
|
Jump this many elements in the underlying data array when stepping in dimension X. |
Map(fun)
Signature: fun:Func<'Tv,'T1> -> Vector<'T1>
|
Elementwise copy with function application. This methods returns a Vector with zero as first coordinates. |
Map(fun)
Signature: fun:Func<'Tv,'Tv> -> Vector<'Td,'Tv>
|
Elementwise copy with function application. This methods returns a Vector with zero as first coordinates. |
MapWindow(fun)
Signature: fun:Func<'Tv,'T1> -> Vector<'T1>
|
Elementwise copy with function application. This method retains the coordinates of the original Vector. |
MapWindow(fun)
Signature: fun:Func<'Tv,'Tv> -> Vector<'Td,'Tv>
|
Elementwise copy with function application. This method retains the complete layout of the original Vector. |
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,'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,'Ti> * bias:'Tr * sumFun:Func<'Tr,'Ti,'Tr> * breakIfTrueFun:Func<'Tr,bool>) -> 'Tr
|
|
O
Signature: int64
|
|
Origin()
Signature: unit -> unit
Modifiers: abstract |
|
OriginIndex()
Signature: unit -> unit
Modifiers: abstract |
|
Rank
Signature: int
Modifiers: abstract |
Return the rank or dimension of the vector (1). |
S()
Signature: unit -> unit
|
Size |
Sample2(...)
Signature: (x:float * ipl:Func<float,'Tv,'Tv,'TRes> * index_min_max_delta_indexFun:Func<int64,int64,int64,int64,Tup2<int64>>) -> 'TRes
|
Sample the vector using 2 samples and the supplied interpolation function. If an integer coordinte is supplied the returned value is the same as the indexer of the vector. |
Sample2Clamped(x, ipl)
Signature: (x:float * ipl:Func<float,'Tv,'Tv,'TRes>) -> 'TRes
|
|
Sample4(...)
Signature: (x:float * ipl:Func<float,Tup4<'T1>> * smp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'TRes> * index_min_max_delta_indexFun:Func<int64,int64,int64,int64,Tup4<int64>>) -> 'TRes
|
|
Sample4Clamped(x, ipl, smp)
Signature: (x:float * ipl:Func<float,Tup4<'T1>> * smp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'TRes>) -> 'TRes
|
|
Sample6(...)
Signature: (x:float * ipl:Func<float,Tup6<'T1>> * smp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'TRes> * index_min_max_delta_indexFun:Func<int64,int64,int64,int64,Tup6<int64>>) -> 'TRes
|
|
Sample6Clamped(x, ipl, smp)
Signature: (x:float * ipl:Func<float,Tup6<'T1>> * smp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'TRes>) -> 'TRes
|
|
SampleRaw2(x, ipl)
Signature: (x:float * ipl:Func<float,'Tv,'Tv,'TRes>) -> 'TRes
|
Sample the vector using 2 samples and the supplied interpolation function. If an integer coordinte is supplied the returned value is the same as the indexer of the vector. No bounds checking is performed. |
SampleRaw4(x, ipl, smp)
Signature: (x:float * ipl:Func<float,Tup4<'T1>> * smp:FuncRef1<'Tv,'Tv,'Tv,'Tv,Tup4<'T1>,'TRes>) -> 'TRes
|
|
SampleRaw6(x, ipl, smp)
Signature: (x:float * ipl:Func<float,Tup6<'T1>> * smp:FuncRef1<'Tv,'Tv,'Tv,'Tv,'Tv,'Tv,Tup6<'T1>,'TRes>) -> 'TRes
|
|
Set(v)
Signature: v:'Tv -> Vector<'Td,'Tv>
|
Sets all elements to the supplied value. |
Set(it1)
Signature: it1:IVector<'Tv> -> Vector<'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:Vector<'Tv> -> Vector<'Td,'Tv>
|
Copy all elements from another vector. |
Set(t1, element1_elementFun)
Signature: (t1:Vector<'T1> * element1_elementFun:Func<'T1,'Tv>) -> Vector<'Td,'Tv>
|
Set the elements of a vector to the result of a function of the elements of the supplied vector. |
Set(t1)
Signature: t1:Vector<'T1,'Tv> -> Vector<'Td,'Tv>
|
Copy all elements from another vector. |
Set(t1, element1_elementFun)
Signature: (t1:Vector<'T1d,'T1> * element1_elementFun:Func<'T1,'Tv>) -> Vector<'Td,'Tv>
|
Set the elements of a vector to the result of a function of the elements of the supplied vector. |
Set(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
|
Set the elements of a vector to the result of a function of corresponding pairs of elements of the two supplied tensors. |
Set(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Set the elements of a vector to the result of a function of corresponding pairs of elements of the two supplied tensors. |
Set(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Set the elements of a vector to the result of a function of corresponding pairs of elements of the two supplied tensors. |
Set(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Set the elements of a vector to the result of a function of corresponding pairs of elements of the two supplied tensors. |
Set(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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_elementFun)
Signature: x_elementFun:Func<int64,'Tv> -> Vector<'Td,'Tv>
|
Set each element to the value of a function of the element coords. |
SetByIndex(index_elementFun)
Signature: index_elementFun:Func<int64,'Tv> -> Vector<'Td,'Tv>
|
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(t1, index1_elementFun)
Signature: (t1:Vector<'T1> * index1_elementFun:Func<int64,'Tv>) -> Vector<'Td,'Tv>
|
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(t1, index1_elementFun)
Signature: (t1:Vector<'T1d,'T1> * index1_elementFun:Func<int64,'Tv>) -> Vector<'Td,'Tv>
|
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * index1_index2_elementFun:Func<int64,int64,'Tv>) -> Vector<'Td,'Tv>
|
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * index1_index2_elementFun:Func<int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * index1_index2_elementFun:Func<int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * index1_index2_elementFun:Func<int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T3 |
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T3d, 'T3 |
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'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 vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Set each element to the value of a function of the index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'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 vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'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 vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetByIndex(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'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 vector. The function may access the elements of the supplied vector to compute the elements of the vector. |
SetConvolution(...)
Signature: (image:Vector<'Ti> * filter:Vector<'Tf> * mulFun:Func<'Ti,'Tf,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * castFun:Func<'Ts,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'Tm, 'Ts |
Set the vector to be the convolution of the supplied image and filter tensors. |
SetMap(t1, element1_elementFun)
Signature: (t1:Vector<'T1> * element1_elementFun:Func<'T1,'Tv>) -> Vector<'Td,'Tv>
|
Set the elements of a vector to the result of a function of the elements of the supplied vector. |
SetMap(t1, element1_elementFun)
Signature: (t1:Vector<'T1d,'T1> * element1_elementFun:Func<'T1,'Tv>) -> Vector<'Td,'Tv>
|
Set the elements of a vector to the result of a function of the elements of the supplied vector. |
SetMap2(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
|
Set the elements of a vector to the result of a function of corresponding pairs of elements of the two supplied tensors. |
SetMap2(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Set the elements of a vector to the result of a function of corresponding pairs of elements of the two supplied tensors. |
SetMap2(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Set the elements of a vector to the result of a function of corresponding pairs of elements of the two supplied tensors. |
SetMap2(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Set the elements of a vector to the result of a function of corresponding pairs of elements of the two supplied tensors. |
SetMap3(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'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. |
SetValue(value, x)
Signature: (value:obj * x:int64) -> 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. |
SubVector(begin, size)
Signature: (begin:int64 * size: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. This methods returns a Vector with zero as first coordinates. |
SubVector(begin, size)
Signature: (begin:int * size:int) -> 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. This methods returns a Vector with zero as first coordinates. |
SubVector(begin, size, delta)
Signature: (begin:int64 * 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. This methods returns a Vector with zero as first coordinates. |
SubVector(begin, size, delta)
Signature: (begin:int * size:int * delta:int) -> 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. This methods returns a Vector with zero as first coordinates. |
SubVector(begin, size)
Signature: (begin:int64 * size: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. This methods returns a Vector with zero as first coordinates. |
SubVector(begin, size)
Signature: (begin:int * size:int) -> 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. This methods returns a Vector with zero as first coordinates. |
SubVector(begin, size, delta)
Signature: (begin:int64 * 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. This methods returns a Vector with zero as first coordinates. |
SubVector(begin, size, delta)
Signature: (begin:int * size:int * delta:int) -> 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. This methods returns a Vector with zero as first coordinates. |
SubVectorWindow(begin, size)
Signature: (begin:int64 * size: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. This method retains the coordinates of the parent Vector. |
SubVectorWindow(begin, size)
Signature: (begin:int * size:int) -> 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. This method retains the coordinates of the parent Vector. |
SubVectorWindow(begin, size, delta)
Signature: (begin:int64 * 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. This method retains the coordinates of the parent Vector. |
SubVectorWindow(begin, size, delta)
Signature: (begin:int * size:int * delta:int) -> 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. This method retains the coordinates of the parent Vector. |
SubVectorWindow(begin, size)
Signature: (begin:int64 * size: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. This method retains the coordinates of the parent Vector. |
SubVectorWindow(begin, size)
Signature: (begin:int * size:int) -> 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. This method retains the coordinates of the parent Vector. |
SubVectorWindow(begin, size, delta)
Signature: (begin:int64 * 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. This method retains the coordinates of the parent Vector. |
SubVectorWindow(begin, size, delta)
Signature: (begin:int * size:int * delta:int) -> 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. This method retains the coordinates of the parent Vector. |
SX()
Signature: unit -> unit
|
Size in dimension X. |
Static members
| Static member | Description |
Create(t1)
Signature: t1:Vector<'Tv> -> Vector<'Td,'Tv>
|
Create a new vector as copy of the supplied vector. |
Create(t1)
Signature: t1:Vector<'T1d,'Tv> -> Vector<'Td,'Tv>
|
Create a new vector as copy of the supplied vector. |
Create(t1, element1_elementFun)
Signature: (t1:Vector<'T1> * element1_elementFun:Func<'T1,'Tv>) -> Vector<'Td,'Tv>
|
Create a new vector by applying a function on each element of the supplied vector. |
Create(t1, element1_elementFun)
Signature: (t1:Vector<'T1d,'T1> * element1_elementFun:Func<'T1,'Tv>) -> Vector<'Td,'Tv>
|
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
|
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T3d, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3d, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Create(size, fun)
Signature: (size:int64 * fun:Func<int64,'Tv>) -> Vector<'Td,'Tv>
|
Create a new vector by applying a function to the coordinates of the elements the newly created vector. |
CreateByIndex(t1, index1_elementFun)
Signature: (t1:Vector<'T1> * index1_elementFun:Func<int64,'Tv>) -> Vector<'Td,'Tv>
|
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(t1, index1_elementFun)
Signature: (t1:Vector<'T1d,'T1> * index1_elementFun:Func<int64,'Tv>) -> Vector<'Td,'Tv>
|
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * index1_index2_fun:Func<int64,int64,'Tv>) -> Vector<'Td,'Tv>
|
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * index1_index2_fun:Func<int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * index1_index2_fun:Func<int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(t1, t2, index1_index2_fun)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * index1_index2_fun:Func<int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T3 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T3d, 'T3 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateByIndex(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * index1_index2_index3_elementFun:Func<int64,int64,int64,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3d, 'T3 |
Create a new vector by applying a function to each index of the elements of the supplied vector. The function may access the elements of the supplied vector to compute the elements of the new vector. |
CreateConvolution(...)
Signature: (image:Vector<'Ti> * filter:Vector<'Tf> * mulFun:Func<'Ti,'Tf,'Tm> * bias:'Ts * sumFun:Func<'Ts,'Tm,'Ts> * castFun:Func<'Ts,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'Tm, 'Ts |
Create a new Vector 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 Vector. |
Map(t1, element1_elementFun)
Signature: (t1:Vector<'T1> * element1_elementFun:Func<'T1,'Tv>) -> Vector<'Td,'Tv>
|
Create a new vector by applying a function on each element of the supplied vector. |
Map(t1, element1_elementFun)
Signature: (t1:Vector<'T1d,'T1> * element1_elementFun:Func<'T1,'Tv>) -> Vector<'Td,'Tv>
|
Create a new vector by applying a function on each element of the supplied vector. |
Map2(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
|
Create a new vector by applying a function on each element of the supplied vector. |
Map2(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Create a new vector by applying a function on each element of the supplied vector. |
Map2(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2 |
Create a new vector by applying a function on each element of the supplied vector. |
Map2(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * element1_element2_elementFun:Func<'T1,'T2,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2 |
Create a new vector by applying a function on each element of the supplied vector. |
Map3(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Map3(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T3d, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Map3(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Map3(...)
Signature: (t1:Vector<'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Map3(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Map3(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2, 'T3d, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Map3(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
Map3(...)
Signature: (t1:Vector<'T1d,'T1> * t2:Vector<'T2d,'T2> * t3:Vector<'T3d,'T3> * element1_element2_element3_elementFun:Func<'T1,'T2,'T3,'Tv>) -> Vector<'Td,'Tv>
Type parameters: 'T2d, 'T2, 'T3d, 'T3 |
Create a new vector by applying a function on each element of the supplied vector. |
