Tensor<'T>
Namespace: Tensor
An N-dimensional array with elements of type 'T.
Constructors
| Constructor | Description |
new(shape, dev, order)
Signature: (shape:int64 list * dev:ITensorDevice * order:TensorOrder option) -> Tensor<'T>
|
Creates a new tensor of specifed shape with newly allocated storage using the specified storage device. CompiledName: |
new(layout, storage)
Signature: (layout:TensorLayout * storage:ITensorStorage<'T>) -> Tensor<'T>
|
CompiledName: |
Instance members
| Instance member | Description |
CheckAxis(ax)
Signature: ax:int -> unit
|
checks that the given axis is valid |
Copy(order)
Signature: (order:TensorOrder option) -> Tensor<'T>
|
returns a copy of the tensor |
CopyFrom(src)
Signature: src:Tensor<'T> -> unit
|
Copies the specifed tensor into this tensor. Both tensors must have same shape and storage. |
DataType
Signature: Type
|
type of data stored in this tensor CompiledName: |
Dev
Signature: ITensorDevice
|
device this tensor is stored on CompiledName: |
Fill(fn)
Signature: (fn:(unit -> 'T)) -> unit
|
Fills the tensor with the values returned by the function. |
FillAbs(a)
Signature: a:Tensor<'T> -> unit
|
element-wise absolute value using this tensor as target |
FillAcos(a)
Signature: a:Tensor<'T> -> unit
|
element-wise arcus cosinus function using this tensor as target |
FillAdd(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> unit
|
element-wise addition of two tensors using this tensor as target |
FillAllAxis(ax src)
Signature: ax:int -> src:Tensor<bool> -> unit
|
false if there is at least one false element in given axis, using this tensor as target |
FillAnd(a b)
Signature: a:Tensor<bool> -> b:Tensor<bool> -> unit
|
element-wise logical "and" of two tensors using this tensor as target |
FillAnyAxis(ax src)
Signature: ax:int -> src:Tensor<bool> -> unit
|
true if there is at least one true element in given axis, using this tensor as target |
FillArgMaxAxis(ax src)
Signature: ax:int -> src:Tensor<'R> -> unit
|
positions of maximum values along given axis using this tensor as target |
FillArgMinAxis(ax src)
Signature: ax:int -> src:Tensor<'R> -> unit
|
positions of minimum values along given axis using this tensor as target |
FillAsin(a)
Signature: a:Tensor<'T> -> unit
|
element-wise arcus sinus function using this tensor as target |
FillAtan(a)
Signature: a:Tensor<'T> -> unit
|
element-wise arcus tangens function using this tensor as target |
FillCeiling(a)
Signature: a:Tensor<'T> -> unit
|
element-wise ceiling using this tensor as target |
FillConst(value)
Signature: value:'T -> unit
|
Fills the tensor with the specified constant. |
FillConvert(a)
Signature: a:Tensor<'TA> -> unit
|
copies all elements into this tensor and converts their data type appropriately |
FillCos(a)
Signature: a:Tensor<'T> -> unit
|
element-wise cosinus function using this tensor as target |
FillCosh(a)
Signature: a:Tensor<'T> -> unit
|
element-wise cosinus hyperbolicus function using this tensor as target |
FillDivide(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> unit
|
element-wise division of two tensors using this tensor as target |
FillDot(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> unit
|
Dot product of two tensors using this tensor as target: vecvec=>scalar, matvec=>vec, matmat=>mat, (batched mat)(batched mat)=>(batched mat). |
FillEqual(a b)
Signature: a:Tensor<'R> -> b:Tensor<'R> -> unit
|
element-wise equal of two tensors using this tensor as target |
FillExp(a)
Signature: a:Tensor<'T> -> unit
|
element-wise exponential function using this tensor as target |
FillFloor(a)
Signature: a:Tensor<'T> -> unit
|
element-wise floor using this tensor as target |
FillFoldAxis(fn initial axis a)
Signature: (fn:('T -> 'TA -> 'T)) -> initial:'T -> axis:int -> a:Tensor<'TA> -> unit
|
folds the function over the given axis, using this tensor as target |
FillFrom(src)
Signature: src:Tensor<'T> -> unit
|
Copy source tensor into this tensor. The source tensor is broadcasted to the size of this tensor, if possible. |
FillGather(indices src)
Signature: (indices:Tensor<int64> option list) -> src:Tensor<'T> -> unit
|
Selects elements from src according to the specified indices.
Indices must be a list of Tensor |
FillGreater(a b)
Signature: a:Tensor<'R> -> b:Tensor<'R> -> unit
|
element-wise greater than of two tensors using this tensor as target |
FillGreaterOrEqual(a b)
Signature: a:Tensor<'R> -> b:Tensor<'R> -> unit
|
element-wise greater than or equal to of two tensors using this tensor as target |
FillIfThenElse(cond ifTrue ifFalse)
Signature: cond:Tensor<bool> -> ifTrue:Tensor<'T> -> ifFalse:Tensor<'T> -> unit
|
Elementwise writes elements from ifTrue if cond is true in this tensor, otherwise elements from ifFalse. |
FillIndexed(fn)
Signature: (fn:(int64 [] -> 'T)) -> unit
|
Fills the tensor with the values returned by the function. |
FillInvert(a)
Signature: a:Tensor<'T> -> unit
|
Matrix inversion using this tensor as target. If the specified tensor has more than two dimensions, the matrices consisting of the last two dimensions are inverted. |
FillIsFinite(a)
Signature: a:Tensor<'R> -> unit
|
element-wise check if elements are finite (not -Inf, Inf or NaN) using this tensor as target |
FillLess(a b)
Signature: a:Tensor<'R> -> b:Tensor<'R> -> unit
|
element-wise less than of two tensors using this tensor as target |
FillLessOrEqual(a b)
Signature: a:Tensor<'R> -> b:Tensor<'R> -> unit
|
element-wise less than of two tensors using this tensor as target |
FillLog(a)
Signature: a:Tensor<'T> -> unit
|
element-wise logarithm to base e using this tensor as target |
FillLog10(a)
Signature: a:Tensor<'T> -> unit
|
element-wise logarithm to base 10 using this tensor as target |
FillMap(fn a)
Signature: (fn:('TA -> 'T)) -> a:Tensor<'TA> -> unit
|
maps all elements using the specified function into this tensor |
FillMap2(fn a b)
Signature: (fn:('TA -> 'TB -> 'T)) -> a:Tensor<'TA> -> b:Tensor<'TB> -> unit
Type parameters: 'TB |
maps all elements using the specified function into this tensor |
FillMapIndexed(fn a)
Signature: (fn:(int64 [] -> 'TA -> 'T)) -> a:Tensor<'TA> -> unit
|
maps all elements using the specified indexed function into this tensor |
FillMapIndexed2(fn a b)
Signature: (fn:(int64 [] -> 'TA -> 'TB -> 'T)) -> a:Tensor<'TA> -> b:Tensor<'TB> -> unit
Type parameters: 'TB |
maps all elements using the specified indexed function into this tensor |
FillMaxAxis(ax src)
Signature: ax:int -> src:Tensor<'T> -> unit
|
maximum value over given axis using this tensor as target |
FillMaxElemwise(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> unit
|
element-wise picks the maximum of a or b using this tensor as target |
FillMinAxis(ax src)
Signature: ax:int -> src:Tensor<'T> -> unit
|
minimum value over given axis using this tensor as target |
FillMinElemwise(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> unit
|
element-wise picks the minimum of a or b using this tensor as target |
FillModulo(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> unit
|
element-wise modulo of two tensors using this tensor as target |
FillMultiply(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> unit
|
element-wise multiplication of two tensors using this tensor as target |
FillNegate(a)
Signature: a:Tensor<bool> -> unit
|
element-wise logical negation using this tensor as target |
FillNotEqual(a b)
Signature: a:Tensor<'R> -> b:Tensor<'R> -> unit
|
element-wise not equal of two tensors using this tensor as target |
FillOr(a b)
Signature: a:Tensor<bool> -> b:Tensor<bool> -> unit
|
element-wise logical "or" of two tensors using this tensor as target |
FillParallel(fn)
Signature: (fn:(unit -> 'T)) -> unit
|
Fills the tensor with the values returned by the function using multiple threads. |
FillParallelFoldAxis(fn initial axis a)
Signature: (fn:('T -> 'TA -> 'T)) -> initial:'T -> axis:int -> a:Tensor<'TA> -> unit
|
folds the function over the given axis, using this tensor as target and multiple threads |
FillParallelIndexed(fn)
Signature: (fn:(int64 [] -> 'T)) -> unit
|
Fills the tensor with the values returned by the function using multiple threads. |
FillParallelMap(fn a)
Signature: (fn:('TA -> 'T)) -> a:Tensor<'TA> -> unit
|
maps all elements using the specified function into this tensor using multiple threads |
FillParallelMap2(fn a b)
Signature: (fn:('TA -> 'TB -> 'T)) -> a:Tensor<'TA> -> b:Tensor<'TB> -> unit
Type parameters: 'TB |
maps all elements using the specified function into this tensor using multiple threads |
FillParallelMapIndexed(fn a)
Signature: (fn:(int64 [] -> 'TA -> 'T)) -> a:Tensor<'TA> -> unit
|
maps all elements using the specified indexed function into this tensor using multiple threads |
FillParallelMapIndexed2(fn a b)
Signature: (fn:(int64 [] -> 'TA -> 'TB -> 'T)) -> a:Tensor<'TA> -> b:Tensor<'TB> -> unit
Type parameters: 'TB |
maps all elements using the specified indexed function into this tensor using multiple threads |
FillPower(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> unit
|
element-wise power of two tensors using this tensor as target |
FillProductAxis(ax src)
Signature: ax:int -> src:Tensor<'T> -> unit
|
product over given axis using this tensor as target |
FillRound(a)
Signature: a:Tensor<'T> -> unit
|
element-wise rounding using this tensor as target |
FillScatter(indices src)
Signature: (indices:Tensor<int64> option list) -> src:Tensor<'T> -> unit
|
Sets the values of this tensor by summing elements from the source tensor into the elements of this tensor specified by the indices. If an index tensor is set to None then the target index is used as the source index. |
FillSeq(data)
Signature: data:seq<'T> -> unit
|
Fills the tensor with the values returned by the given sequence. |
FillSgn(a)
Signature: a:Tensor<'T> -> unit
|
element-wise sign (keeping type) using this tensor as target |
FillSin(a)
Signature: a:Tensor<'T> -> unit
|
element-wise sinus function using this tensor as target |
FillSinh(a)
Signature: a:Tensor<'T> -> unit
|
element-wise sinus hyperbolicus function using this tensor as target |
FillSqrt(a)
Signature: a:Tensor<'T> -> unit
|
element-wise square root using this tensor as target |
FillSubtract(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> unit
|
element-wise subtraction of two tensors using this tensor as target |
FillSumAxis(ax src)
Signature: ax:int -> src:Tensor<'T> -> unit
|
sum over given axis using this tensor as target |
FillTan(a)
Signature: a:Tensor<'T> -> unit
|
element-wise tangens function using this tensor as target |
FillTanh(a)
Signature: a:Tensor<'T> -> unit
|
element-wise tangens hyperbolicus function using this tensor as target |
FillTruncate(a)
Signature: a:Tensor<'T> -> unit
|
element-wise truncation using this tensor as target |
FillUnaryMinus(a)
Signature: a:Tensor<'T> -> unit
|
element-wise unary (prefix) minus using this tensor as target |
FillUnaryPlus(a)
Signature: a:Tensor<'T> -> unit
|
element-wise unary (prefix) plus using this tensor as target |
FillXor(a b)
Signature: a:Tensor<bool> -> b:Tensor<bool> -> unit
|
element-wise logical "xor" of two tensors using this tensor as target |
Full
Signature: string
|
full contents string CompiledName: |
GetSlice(...)
Signature: (i0s:int64 option * i0f:int64 option * i1s:int64 option * i1f:int64 option * i2s:int64 option * i2f:int64 option * o3:obj * r:obj []) -> Tensor<'T>
|
|
GetSlice(i0s, i0f, i1s, i1f, i2, o3, r)
Signature: (i0s:int64 option * i0f:int64 option * i1s:int64 option * i1f:int64 option * i2:int64 * o3:obj * r:obj []) -> Tensor<'T>
|
|
GetSlice(i0s, i0f, i1, i2s, i2f, o3, r)
Signature: (i0s:int64 option * i0f:int64 option * i1:int64 * i2s:int64 option * i2f:int64 option * o3:obj * r:obj []) -> Tensor<'T>
|
|
GetSlice(i0, i1s, i1f, i2s, i2f, o3, r)
Signature: (i0:int64 * i1s:int64 option * i1f:int64 option * i2s:int64 option * i2f:int64 option * o3:obj * r:obj []) -> Tensor<'T>
|
|
GetSlice(i0s, i0f, i1, i2, o3, r)
Signature: (i0s:int64 option * i0f:int64 option * i1:int64 * i2:int64 * o3:obj * r:obj []) -> Tensor<'T>
|
|
GetSlice(i0, i1s, i1f, i2, o3, r)
Signature: (i0:int64 * i1s:int64 option * i1f:int64 option * i2:int64 * o3:obj * r:obj []) -> Tensor<'T>
|
|
GetSlice(i0, i1, i2s, i2f, o3, r)
Signature: (i0:int64 * i1:int64 * i2s:int64 option * i2f:int64 option * o3:obj * r:obj []) -> Tensor<'T>
|
|
GetSlice(i0, i1, i2, o3, r)
Signature: (i0:int64 * i1:int64 * i2:int64 * o3:obj * r:obj []) -> Tensor<'T>
|
|
GetSlice(i0s, i0f, i1s, i1f, i2s, i2f)
Signature: (i0s:int64 option * i0f:int64 option * i1s:int64 option * i1f:int64 option * i2s:int64 option * i2f:int64 option) -> Tensor<'T>
|
|
GetSlice(i0s, i0f, i1s, i1f, i2)
Signature: (i0s:int64 option * i0f:int64 option * i1s:int64 option * i1f:int64 option * i2:int64) -> Tensor<'T>
|
|
GetSlice(i0s, i0f, i1, i2s, i2f)
Signature: (i0s:int64 option * i0f:int64 option * i1:int64 * i2s:int64 option * i2f:int64 option) -> Tensor<'T>
|
|
GetSlice(i0, i1s, i1f, i2s, i2f)
Signature: (i0:int64 * i1s:int64 option * i1f:int64 option * i2s:int64 option * i2f:int64 option) -> Tensor<'T>
|
|
GetSlice(i0s, i0f, i1, i2)
Signature: (i0s:int64 option * i0f:int64 option * i1:int64 * i2:int64) -> Tensor<'T>
|
|
GetSlice(i0, i1s, i1f, i2)
Signature: (i0:int64 * i1s:int64 option * i1f:int64 option * i2:int64) -> Tensor<'T>
|
|
GetSlice(i0, i1, i2s, i2f)
Signature: (i0:int64 * i1:int64 * i2s:int64 option * i2f:int64 option) -> Tensor<'T>
|
|
GetSlice(i0, i1, i2)
Signature: (i0:int64 * i1:int64 * i2:int64) -> Tensor<'T>
|
|
GetSlice(i0s, i0f, i1s, i1f)
Signature: (i0s:int64 option * i0f:int64 option * i1s:int64 option * i1f:int64 option) -> Tensor<'T>
|
|
GetSlice(i0s, i0f, i1)
Signature: (i0s:int64 option * i0f:int64 option * i1:int64) -> Tensor<'T>
|
|
GetSlice(i0, i1s, i1f)
Signature: (i0:int64 * i1s:int64 option * i1f:int64 option) -> Tensor<'T>
|
|
GetSlice(i0s, i0f)
Signature: (i0s:int64 option * i0f:int64 option) -> Tensor<'T>
|
|
[o0, o1, o2, o3, o4, o5, o6, o7, o8, o9]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj * o5:obj * o6:obj * o7:obj * o8:obj * o9:obj -> Tensor<'T>
|
CompiledName: |
[o0, o1, o2, o3, o4, o5, o6, o7, o8]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj * o5:obj * o6:obj * o7:obj * o8:obj -> Tensor<'T>
|
CompiledName: |
[o0, o1, o2, o3, o4, o5, o6, o7]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj * o5:obj * o6:obj * o7:obj -> Tensor<'T>
|
CompiledName: |
[o0, o1, o2, o3, o4, o5, o6]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj * o5:obj * o6:obj -> Tensor<'T>
|
CompiledName: |
[o0, o1, o2, o3, o4, o5]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj * o5:obj -> Tensor<'T>
|
CompiledName: |
[o0, o1, o2, o3, o4]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj -> Tensor<'T>
|
CompiledName: |
[o0, o1, o2, o3]
Signature: o0:obj * o1:obj * o2:obj * o3:obj -> Tensor<'T>
|
four- and more-dimensional slicing using indices and special axes CompiledName: |
[i0, i1, i2]
Signature: i0:int64 * i1:int64 * i2:int64 -> Tensor<'T>
|
three-dimensional slicing using indices and special axes CompiledName: |
[i0, i1]
Signature: i0:int64 * i1:int64 -> Tensor<'T>
|
two-dimensional slicing using indices and special axes CompiledName: |
[i0]
Signature: i0:int64 -> Tensor<'T>
|
one-dimensional slicing using indices and special axes CompiledName: |
[rng]
Signature: rng:TensorRng list -> Tensor<'T>
|
n-dimensional slicing using a list of TensorRngs CompiledName: |
[idx]
Signature: idx:int64 list -> 'T
|
access to a single item using a list of indices (use array of indices for faster access) CompiledName: |
[idx]
Signature: idx:int64 [] -> 'T
|
access to a single item using an array of indices CompiledName: |
[()]
Signature: unit -> int64 []
|
access to a single item using an array of indices CompiledName: |
[()]
Signature: unit -> int64 list
|
access to a single item using a list of indices (use array of indices for faster access) CompiledName: |
[()]
Signature: unit -> TensorRng list
|
n-dimensional slicing using a list of TensorRngs CompiledName: |
[()]
Signature: unit -> int64
|
one-dimensional slicing using indices and special axes CompiledName: |
[i0]
Signature: i0:int64 -> int64
|
two-dimensional slicing using indices and special axes CompiledName: |
[i0, i1]
Signature: i0:int64 * i1:int64 -> int64
|
three-dimensional slicing using indices and special axes CompiledName: |
[o0, o1, o2]
Signature: o0:obj * o1:obj * o2:obj -> obj
|
four- and more-dimensional slicing using indices and special axes CompiledName: |
[o0, o1, o2, o3]
Signature: o0:obj * o1:obj * o2:obj * o3:obj -> obj
|
CompiledName: |
[o0, o1, o2, o3, o4]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj -> obj
|
CompiledName: |
[o0, o1, o2, o3, o4, o5]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj * o5:obj -> obj
|
CompiledName: |
[o0, o1, o2, o3, o4, o5, o6]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj * o5:obj * o6:obj -> obj
|
CompiledName: |
[o0, o1, o2, o3, o4, o5, o6, o7]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj * o5:obj * o6:obj * o7:obj -> obj
|
CompiledName: |
[o0, o1, o2, o3, o4, o5, o6, o7, o8]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * o4:obj * o5:obj * o6:obj * o7:obj * o8:obj -> obj
|
CompiledName: |
[o0, o1, o2, o3, r]
Signature: o0:obj * o1:obj * o2:obj * o3:obj * r:obj [] -> Tensor<'T>
|
four- and more-dimensional slicing using indices and special axes CompiledName: |
Layout
Signature: TensorLayout
|
layout of this tensor (shape, offset and strides) CompiledName: |
NDims
Signature: int
|
number of dimensions CompiledName: |
NElems
Signature: int64
|
number of elements CompiledName: |
Offset
Signature: int64
|
offset CompiledName: |
Pretty
Signature: string
|
pretty contents string CompiledName: |
SetSlice(...)
Signature: (i0s:int64 option * i0f:int64 option * i1s:int64 option * i1f:int64 option * i2s:int64 option * i2f:int64 option * o3:obj * o4:obj * r:obj []) -> unit
|
|
SetSlice(...)
Signature: (i0s:int64 option * i0f:int64 option * i1s:int64 option * i1f:int64 option * i2:int64 * o3:obj * o4:obj * r:obj []) -> unit
|
|
SetSlice(...)
Signature: (i0s:int64 option * i0f:int64 option * i1:int64 * i2s:int64 option * i2f:int64 option * o3:obj * o4:obj * r:obj []) -> unit
|
|
SetSlice(...)
Signature: (i0:int64 * i1s:int64 option * i1f:int64 option * i2s:int64 option * i2f:int64 option * o3:obj * o4:obj * r:obj []) -> unit
|
|
SetSlice(i0s, i0f, i1, i2, o3, o4, r)
Signature: (i0s:int64 option * i0f:int64 option * i1:int64 * i2:int64 * o3:obj * o4:obj * r:obj []) -> unit
|
|
SetSlice(i0, i1s, i1f, i2, o3, o4, r)
Signature: (i0:int64 * i1s:int64 option * i1f:int64 option * i2:int64 * o3:obj * o4:obj * r:obj []) -> unit
|
|
SetSlice(i0, i1, i2s, i2f, o3, o4, r)
Signature: (i0:int64 * i1:int64 * i2s:int64 option * i2f:int64 option * o3:obj * o4:obj * r:obj []) -> unit
|
|
SetSlice(i0, i1, i2, o3, o4, r)
Signature: (i0:int64 * i1:int64 * i2:int64 * o3:obj * o4:obj * r:obj []) -> unit
|
|
SetSlice(...)
Signature: (i0s:int64 option * i0f:int64 option * i1s:int64 option * i1f:int64 option * i2s:int64 option * i2f:int64 option * value:Tensor<'T>) -> unit
|
|
SetSlice(i0s, i0f, i1s, i1f, i2, value)
Signature: (i0s:int64 option * i0f:int64 option * i1s:int64 option * i1f:int64 option * i2:int64 * value:Tensor<'T>) -> unit
|
|
SetSlice(i0s, i0f, i1, i2s, i2f, value)
Signature: (i0s:int64 option * i0f:int64 option * i1:int64 * i2s:int64 option * i2f:int64 option * value:Tensor<'T>) -> unit
|
|
SetSlice(i0, i1s, i1f, i2s, i2f, value)
Signature: (i0:int64 * i1s:int64 option * i1f:int64 option * i2s:int64 option * i2f:int64 option * value:Tensor<'T>) -> unit
|
|
SetSlice(i0s, i0f, i1, i2, value)
Signature: (i0s:int64 option * i0f:int64 option * i1:int64 * i2:int64 * value:Tensor<'T>) -> unit
|
|
SetSlice(i0, i1s, i1f, i2, value)
Signature: (i0:int64 * i1s:int64 option * i1f:int64 option * i2:int64 * value:Tensor<'T>) -> unit
|
|
SetSlice(i0, i1, i2s, i2f, value)
Signature: (i0:int64 * i1:int64 * i2s:int64 option * i2f:int64 option * value:Tensor<'T>) -> unit
|
|
SetSlice(i0, i1, i2, value)
Signature: (i0:int64 * i1:int64 * i2:int64 * value:Tensor<'T>) -> unit
|
|
SetSlice(i0s, i0f, i1s, i1f, value)
Signature: (i0s:int64 option * i0f:int64 option * i1s:int64 option * i1f:int64 option * value:Tensor<'T>) -> unit
|
|
SetSlice(i0s, i0f, i1, value)
Signature: (i0s:int64 option * i0f:int64 option * i1:int64 * value:Tensor<'T>) -> unit
|
|
SetSlice(i0, i1s, i1f, value)
Signature: (i0:int64 * i1s:int64 option * i1f:int64 option * value:Tensor<'T>) -> unit
|
|
SetSlice(i0s, i0f, value)
Signature: (i0s:int64 option * i0f:int64 option * value:Tensor<'T>) -> unit
|
|
Shape
Signature: int64 list
|
shape CompiledName: |
Storage
Signature: ITensorStorage<'T>
|
storage of this tensor CompiledName: |
Stride
Signature: int64 list
|
strides CompiledName: |
T
Signature: Tensor<'T>
|
Transposes the given matrix. If the given tensor has more then two dimensions, the last two axes are swapped. CompiledName: |
ToString(maxElems)
Signature: maxElems:int64 -> string
|
Pretty string containing maxElems elements per dimension. |
Transfer(dev)
Signature: dev:ITensorDevice -> Tensor<'T>
|
Transfers this tensor to the specifed device. |
TransferFrom(src)
Signature: src:Tensor<'T> -> unit
|
Transfers the specified tensor located on another device into this tensor. Both tensors must have the same shape. |
Value()
Signature: unit -> 'T
|
value of scalar (0-dimensional) tensor CompiledName: |
Value()
Signature: unit -> unit
|
value of scalar (0-dimensional) tensor CompiledName: |
Static members
| Static member | Description |
( - )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<'T>
|
CompiledName: |
( - )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<'T>
|
CompiledName: |
( - )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<'T>
|
element-wise subtraction of two tensors CompiledName: |
( % )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<'T>
|
CompiledName: |
( % )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<'T>
|
CompiledName: |
( % )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<'T>
|
element-wise modulo of two tensors CompiledName: |
( &&&& )(a, b)
Signature: (a:bool * b:Tensor<bool>) -> Tensor<bool>
|
CompiledName: |
( &&&& )(a, b)
Signature: (a:Tensor<bool> * b:bool) -> Tensor<bool>
|
CompiledName: |
( &&&& )(a, b)
Signature: (a:Tensor<bool> * b:Tensor<bool>) -> Tensor<bool>
|
element-wise logical "and" CompiledName: |
( * )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<'T>
|
CompiledName: |
( * )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<'T>
|
CompiledName: |
( * )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<'T>
|
element-wise multiplication of two tensor CompiledName: |
( .* )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<'T>
|
Dot product of two tensors: vecvec=>scalar, matvec=>vec, matmat=>mat, (batched mat)(batched mat)=>(batched mat), (batched mat)*(batched vec)=>(batched vec). Broadcasting is applied over batch dimensions. CompiledName: |
( / )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<'T>
|
CompiledName: |
( / )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<'T>
|
CompiledName: |
( / )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<'T>
|
element-wise division of two tensors CompiledName: |
( ^^^^ )(a, b)
Signature: (a:bool * b:Tensor<bool>) -> Tensor<bool>
|
CompiledName: |
( ^^^^ )(a, b)
Signature: (a:Tensor<bool> * b:bool) -> Tensor<bool>
|
CompiledName: |
( ^^^^ )(a, b)
Signature: (a:Tensor<bool> * b:Tensor<bool>) -> Tensor<bool>
|
element-wise logical "xor" CompiledName: |
( |||| )(a, b)
Signature: (a:bool * b:Tensor<bool>) -> Tensor<bool>
|
CompiledName: |
( |||| )(a, b)
Signature: (a:Tensor<bool> * b:bool) -> Tensor<bool>
|
CompiledName: |
( |||| )(a, b)
Signature: (a:Tensor<bool> * b:Tensor<bool>) -> Tensor<bool>
|
element-wise logical "or" CompiledName: |
( ~- )(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise unary (prefix) minus CompiledName: |
( ~~~~ )(a)
Signature: a:Tensor<bool> -> Tensor<bool>
|
element-wise logical negation CompiledName: |
( ~+ )(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise unary (prefix) plus CompiledName: |
( + )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<'T>
|
CompiledName: |
( + )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<'T>
|
CompiledName: |
( + )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<'T>
|
element-wise addition of two tensors CompiledName: |
( <<<< )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<bool>
|
CompiledName: |
( <<<< )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<bool>
|
CompiledName: |
( <<<< )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<bool>
|
element-wise less than CompiledName: |
( <<== )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<bool>
|
CompiledName: |
( <<== )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<bool>
|
CompiledName: |
( <<== )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<bool>
|
element-wise less than or equal to CompiledName: |
( <<>> )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<bool>
|
CompiledName: |
( <<>> )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<bool>
|
CompiledName: |
( <<>> )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<bool>
|
element-wise not equal CompiledName: |
( ==== )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<bool>
|
CompiledName: |
( ==== )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<bool>
|
CompiledName: |
( ==== )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<bool>
|
element-wise equal CompiledName: |
( >>== )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<bool>
|
CompiledName: |
( >>== )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<bool>
|
CompiledName: |
( >>== )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<bool>
|
element-wise greater than or equal to CompiledName: |
( >>>> )(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<bool>
|
CompiledName: |
( >>>> )(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<bool>
|
CompiledName: |
( >>>> )(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<bool>
|
element-wise greater than CompiledName: |
Abs(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise absolute value |
Acos(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise arcus cosinus function |
all(src)
Signature: src:Tensor<bool> -> bool
|
false if there is at least one false element in the tensor, otherwise true |
allAxis(ax src)
Signature: ax:int -> src:Tensor<bool> -> Tensor<bool>
|
false if there is at least one false element in given axis, otherwise true |
allElems(a)
Signature: a:Tensor<'T> -> seq<'T>
|
sequence of all elements stored in the tensor |
allIdx(a)
Signature: a:'?181213 -> seq<int64 list>
|
sequence of all indices |
allIdxOfDim(dim a)
Signature: dim:int -> a:'?181216 -> seq<int64>
|
all indices of the given dimension |
any(src)
Signature: src:Tensor<bool> -> bool
|
true if there is at least one true element in the tensor, otherwise false |
anyAxis(ax src)
Signature: ax:int -> src:Tensor<bool> -> Tensor<bool>
|
true if there is at least one true element in given axis, otherwise false |
argMax(a)
Signature: a:Tensor<'T> -> int64 list
|
position of maximum value |
argMaxAxis(ax src)
Signature: ax:int -> src:Tensor<'T> -> Tensor<int64>
|
positions of maximum values along given axis |
argMin(a)
Signature: a:Tensor<'T> -> int64 list
|
position of minimum value |
argMinAxis(ax src)
Signature: ax:int -> src:Tensor<'T> -> Tensor<int64>
|
positions of minimum values along given axis |
Asin(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise arcus sinus function |
Atan(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise arcus tangens function |
atLeast1D(a)
Signature: a:'A -> 'A
|
Ensures that the tensor has at least one dimension. |
atLeast2D(a)
Signature: a:'A -> 'A
|
Ensures that the tensor has at least two dimensions. If not, it is padded with size one dimensions from the left. |
atLeast3D(a)
Signature: a:'A -> 'A
|
Ensures that the tensor has at least three dimensions. If not, it is padded with size one dimensions from the left. |
atLeastND(minDims a)
Signature: minDims:int -> a:'A -> 'A
|
Ensures that the tensor has at least minDims dimensions. If not, it is padded with size one dimensions from the left. |
broadcastDim(dim size a)
Signature: dim:int -> size:int64 -> a:'?181236 -> '?181236
|
broadcast the given dimension to the given size |
broadcastTo(shp a)
Signature: (shp:int64 list) -> a:'?181289 -> '?181289
|
broadcasts the tensor to the given shape |
broadcastToSame(xs)
Signature: (xs:'?181274 list) -> '?181274 list
|
broadcasts all tensors to the same shape if possible |
broadcastToSame(a, b, c)
Signature: (a:'?181269 * b:'?181270 * c:'?181271) -> '?181269 * '?181270 * '?181271
Type parameters: '?181270, '?181271 |
broadcasts all tensors to the same shape if possible |
broadcastToSame(a, b)
Signature: (a:'?181265 * b:'?181266) -> '?181265 * '?181266
Type parameters: '?181266 |
broadcasts all tensors to the same shape |
broadcastToSameInDims(dims, xs)
Signature: (dims:seq<int> * xs:'?181286 list) -> '?181286 list
|
broadcasts all tensors to the same sizes in the given dimensions |
broadcastToSameInDims(dims, a, b, c)
Signature: (dims:seq<int> * a:'?181281 * b:'?181282 * c:'?181283) -> '?181281 * '?181282 * '?181283
Type parameters: '?181282, '?181283 |
broadcasts all tensors to the same sizes in the given dimensions |
broadcastToSameInDims(dims, a, b)
Signature: (dims:seq<int> * a:'?181277 * b:'?181278) -> '?181277 * '?181278
Type parameters: '?181278 |
broadcasts all tensors to the same sizes in the given dimensions |
canReshapeView(shp a)
Signature: (shp:int64 list) -> a:ITensor -> bool
|
Returns true if the tensor can be reshaped without copying. |
Ceiling(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise ceiling |
convert(a)
Signature: a:Tensor<'T> -> Tensor<'C>
|
converts all elements to the specified type |
copy(a, order)
Signature: (a:'A * order:TensorOrder option) -> 'A
|
returns a copy of the tensor |
Cos(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise cosinus function |
Cosh(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise cosinus hyperbolicus function |
cutLeft(a)
Signature: a:'?181230 -> '?181230
|
removes the first dimension from the tensor |
cutRight(a)
Signature: a:'?181233 -> '?181233
|
removes the last dimension from the tensor |
dataType(a)
Signature: a:'?181198 -> Type
|
type of data stored in the specified tensor |
dev(a)
Signature: a:'?181166 -> ITensorDevice
|
device where the specified tensor is stored |
dot(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> Tensor<'T>
|
Dot product of two tensors: vecvec=>scalar, matvec=>vec, matmat=>mat, (batched mat)(batched mat)=>(batched mat), (batched mat)*(batched vec)=>(batched vec). Broadcasting is applied over batch dimensions. |
Exp(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise exponential function |
FillSymmetricEigenDecomposition(...)
Signature: part:MatrixPart -> trgtEigVals:Tensor<'T> -> trgtEigVecs:Tensor<'T> -> a:Tensor<'T> -> unit
|
Computes the (real) eigenvalues and eigenvectors of the symmetric matrix. Returns (vals, vecs) where each column of 'vecs' is the eigenvector for the corresponding eigenvalue in 'vals'. |
flatten(a)
Signature: a:'A -> 'A
|
Flattens the tensor into a (one-dimensional) vector. |
Floor(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise floor |
foldAxis(fn initial axis a)
Signature: (fn:('T -> 'TA -> 'T)) -> initial:'T -> axis:int -> a:Tensor<'TA> -> Tensor<'T>
|
folds the function over the given axis |
gather(indices src)
Signature: (indices:Tensor<int64> option list) -> src:Tensor<'T> -> Tensor<'T>
|
Creates a new tensor by selecting elements from src according to the specified indices.
Indices must be a list of Tensor |
get(a pos)
Signature: a:Tensor<'?181868> -> (pos:int64 list) -> '?181868
|
get element value |
ifThenElse(cond ifTrue ifFalse)
Signature: cond:Tensor<bool> -> ifTrue:Tensor<'T> -> ifFalse:Tensor<'T> -> Tensor<'T>
|
Elementwise takes elements from ifTrue if cond is true, otherwise elements from ifFalse. |
insertAxis(ax a)
Signature: ax:int -> a:'?181227 -> '?181227
|
Inserts an axis of size 1 before the specified position. |
invert(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
Matrix inversion. If the specified tensor has more than two dimensions, the matrices consisting of the last two dimensions are inverted. |
isBroadcasted(a)
Signature: a:ITensor -> bool
|
returns true if at least one dimension is broadcasted |
isColumnMajor(a)
Signature: a:ITensor -> bool
|
returns true if tensor is stored in column-major order |
isFinite(a)
Signature: a:Tensor<'T> -> Tensor<bool>
|
element-wise check if elements are finite (not -Inf, Inf or NaN) |
isRowMajor(a)
Signature: a:ITensor -> bool
|
returns true if tensor is stored in row-major order |
layout(a)
Signature: a:'?181159 -> TensorLayout
|
layout |
Log(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise logarithm to base e |
Log10(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise logarithm to base 10 |
map(fn a)
Signature: (fn:('T -> 'R)) -> a:Tensor<'T> -> Tensor<'R>
|
maps all elements using the specified function into a new tensor |
map2(fn a b)
Signature: (fn:('TA -> 'TB -> 'R)) -> a:Tensor<'TA> -> b:Tensor<'TB> -> Tensor<'R>
Type parameters: 'TB, 'R |
maps all elements using the specified function into a new tensor |
mapi(fn a)
Signature: (fn:(int64 [] -> 'T -> 'R)) -> a:Tensor<'T> -> Tensor<'R>
|
maps all elements using the specified indexed function into a new tensor |
mapi2(fn a b)
Signature: (fn:(int64 [] -> 'TA -> 'TB -> 'R)) -> a:Tensor<'TA> -> b:Tensor<'TB> -> Tensor<'R>
Type parameters: 'TB, 'R |
maps all elements using the specified indexed function into a new tensor |
max(src)
Signature: src:Tensor<'T> -> Tensor<'T>
|
maximum of all elements |
maxAxis(ax src)
Signature: ax:int -> src:Tensor<'T> -> Tensor<'T>
|
maximum value over given axis |
maxElemwise(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> Tensor<'T>
|
element-wise picks the maximum of a or b |
min(src)
Signature: src:Tensor<'T> -> Tensor<'T>
|
minimum of all elements |
minAxis(ax src)
Signature: ax:int -> src:Tensor<'T> -> Tensor<'T>
|
minimum value over given axis |
minElemwise(a b)
Signature: a:Tensor<'T> -> b:Tensor<'T> -> Tensor<'T>
|
element-wise picks the minimum of a or b |
nDims(a)
Signature: a:'b -> int
|
number of dimensions |
nElems(a)
Signature: a:'?181183 -> int64
|
number of elements |
offset(a)
Signature: a:'?181193 -> int64
|
offset |
One
Signature: 'T
|
value one of type 'T CompiledName: |
padLeft(a)
Signature: a:'?181221 -> '?181221
|
inserts a broadcastable dimension of size one as first dimension |
padRight(a)
Signature: a:'?181224 -> '?181224
|
appends a broadcastable dimension of size one as last dimension |
padToSame(xs)
Signature: (xs:'?181262 list) -> '?181262 list
|
pads the shapes of all tensors from the left until they have same rank |
padToSame(a, b, c)
Signature: (a:'?181257 * b:'?181258 * c:'?181259) -> '?181257 * '?181258 * '?181259
Type parameters: '?181258, '?181259 |
pads the shapes of all tensors from the left until they have same rank |
padToSame(a, b)
Signature: (a:'?181253 * b:'?181254) -> '?181253 * '?181254
Type parameters: '?181254 |
pads the shapes of all tensors from the left until they have same rank |
permuteAxes(permut a)
Signature: (permut:int list) -> a:'?181318 -> '?181318
|
Permutes the axes as specified. Each entry in the specified permutation specifies the new position of the corresponding axis, i.e. to which position the axis should move. |
Pow(a, b)
Signature: (a:'T * b:Tensor<'T>) -> Tensor<'T>
|
|
Pow(a, b)
Signature: (a:Tensor<'T> * b:'T) -> Tensor<'T>
|
|
Pow(a, b)
Signature: (a:Tensor<'T> * b:Tensor<'T>) -> Tensor<'T>
|
element-wise power of two tensors |
product(src)
Signature: src:Tensor<'T> -> Tensor<'T>
|
product of all elements |
productAxis(ax src)
Signature: ax:int -> src:Tensor<'T> -> Tensor<'T>
|
product over given axis |
range(rng a)
Signature: (rng:TensorRng list) -> a:'A -> 'A
|
a view of the specified tensor over the given range |
relayout(newLayout a)
Signature: newLayout:TensorLayout -> a:'A -> 'A
|
a tensor with the same storage but new layout |
reshape(shp a)
Signature: (shp:int64 list) -> a:'A -> 'A
|
Reshape array assuming a row-major order. If the array is currently not in row-major order, a reshaped copy is returned. Otherwise, a reshaped view of the same tensor is returned. The number of elements must not change. One element can be -1, in which case the size of that element is inferred automatically. |
reshapeView(shp a)
Signature: (shp:int64 list) -> a:'?181301 -> '?181301
|
Tries to reshape the tensor without copying. For this to succeed, the tensor must have row-major layout. If this a reshape without copying is impossible, an error is raised. |
reverseAxis(ax a)
Signature: ax:int -> a:'?181321 -> '?181321
|
Reverses the elements in the specified dimension. |
Round(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise rounding |
scatter(indices trgtShp src)
Signature: (indices:Tensor<int64> option list) -> (trgtShp:int64 list) -> src:Tensor<'T> -> Tensor<'T>
|
Creates a new tensor of shape trgtShp by dispersing elements from src according to
the specified target indices.
If an index occurs multiple times the corresponding values are summed.
Target elements that do not occur, are set to zero.
Indices must be a list of Tensor |
set(a pos value)
Signature: a:Tensor<'?181871> -> (pos:int64 list) -> value:'?181871 -> unit
|
set element value |
Sgn(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise sign (keeping type) |
shape(a)
Signature: a:'b -> int64 list
|
shape |
Sin(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise sinus function |
Sinh(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise sinus hyperbolicus function |
Sqrt(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise square root |
stride(a)
Signature: a:'?181188 -> int64 list
|
strides |
sum(src)
Signature: src:Tensor<'T> -> Tensor<'T>
|
sum of all elements |
sumAxis(ax src)
Signature: ax:int -> src:Tensor<'T> -> Tensor<'T>
|
sum over given axis |
swapDim(ax1 ax2 a)
Signature: ax1:int -> ax2:int -> a:'?181312 -> '?181312
|
swaps the given dimensions |
symmetricEigenDecomposition(part a)
Signature: part:MatrixPart -> a:Tensor<'T> -> Tensor<'T> * Tensor<'T>
|
Computes the (real) eigenvalues and eigenvectors of the symmetric matrix. Returns (vals, vecs) where each column of 'vecs' is the eigenvector for the corresponding eigenvalue in 'vals'. |
Tan(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise tangens function |
Tanh(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise tangens hyperbolicus function |
transfer(dev src)
Signature: dev:ITensorDevice -> src:'A -> 'A
|
Transfers the specified tensor to the specifed device. |
transpose(a)
Signature: a:'b -> 'b
|
Transposes the given matrix. If the given tensor has more then two dimensions, the last two axes are swapped. |
Truncate(a)
Signature: a:Tensor<'T> -> Tensor<'T>
|
element-wise truncation |
tryReshapeView(shp a)
Signature: (shp:int64 list) -> a:'?181298 -> '?181298 option
|
Tries to reshape the tensor without copying. For this to succeed, the tensor must have row-major layout. If this a reshape without copying is impossible, None is returned. |
value(a)
Signature: a:Tensor<'T> -> 'T
|
value of scalar (0-dimensional) tensor |
Zero
Signature: 'T
|
value zero of type 'T CompiledName: |
