Show / Hide Table of Contents

    Class Tensor<'T>

    An N-dimensional array with elements of type 'T.

    Inheritance
    System.Object
    Tensor<'T>
    Implements
    ITensorFrontend<'T>
    ITensor
    Namespace: Tensor
    Assembly: Tensor.dll
    Syntax
    type Tensor<'T> (layout:TensorLayout, storage:ITensorStorage<'T>)
        interface ITensor
        interface ITensorFrontend<'T>
    Parameters
    Type Name Description
    TensorLayout layout

    The memory layout to use.

    ITensorStorage<'T> storage

    The storage to use.

    Type Parameters
    Name Description
    'T

    The type of the data stored within the tensor.

    Remarks

    The data of a tensor can be stored on different devices. Currently supported devices are host memory and CUDA GPU memory.

    Different tensors can share the whole or parts of the underlying data.

    The recommended way to create a new tensor is to use static member zeros: ITensorDevice -> int64 list -> Tensor<'T>. The implicit constructor creates a view into the specified storage using the specified memory layout. In most cases, it is not necessary to use the implicit constructor.

    Constructors

    Name Description
    new: int64 list * ITensorDevice * TensorOrder option -> Tensor<'T>

    Creates a new, uninitialized tensor with a new storage.

    new: TensorLayout * ITensorStorage<'T> -> Tensor<'T>

    Implicit constructor.

    Properties

    Name Description
    property DataType: Type

    Type of data stored within this tensor.

    property Dev: ITensorDevice

    Device the data of tensor is stored on.

    property Full: string

    Unabreviated string representation of the tensor.

    property Item: int64 [] -> 'T

    Accesses a single element within the tensor.

    property Item: int64 list -> 'T

    Accesses a single element within the tensor.

    property Item: int64 -> Tensor<'T>

    Accesses a slice (part) of the tensor.

    property Item: Rng list -> Tensor<'T>

    Accesses a slice (part) of the tensor.

    property Layout: TensorLayout

    Memory layout of this tensor.

    property M: Tensor<bool> list -> Tensor<'T>

    Picks elements from a tensor using one or more boolean mask tensors.

    property M: Tensor<bool> -> Tensor<'T>

    Picks elements from a tensor using one or more boolean mask tensors.

    property NDims: int

    Dimensionality of this tensor.

    property NElems: int64

    Total number of elements within this tensor.

    property Pretty: string

    String representation of the tensor limited to 10 elements per dimension.

    property Shape: int64 list

    Shape of this tensor.

    property Storage: ITensorStorage<'T>

    The storage object that holds the data of this tensor.

    property T: Tensor<'T>

    Transpose of a matrix.

    property Value: 'T

    Accesses the value of a zero-dimensional (scalar) tensor.

    Methods

    Name Description
    static member Abs: Tensor<'T> -> Tensor<'T>

    Element-wise absolute value.

    static member Acos: Tensor<'T> -> Tensor<'T>

    Element-wise arccosine (inverse cosine).

    static member all: Tensor<bool> -> bool

    Checks if all elements of the tensor are true.

    static member allAxis: int -> Tensor<bool> -> Tensor<bool>

    Checks if all elements along the specified axis are true.

    static member allElems: Tensor<'T> -> seq<'T>

    Gets a sequence of all all elements within the tensor.

    static member allFinite: Tensor<'T> -> bool

    Checks that all elements of the tensor are finite.

    static member allIdx: Tensor<'T> -> seq<int64 list>

    Gets a sequence of all indices to enumerate all elements within the tensor.

    static member allTensor: Tensor<bool> -> Tensor<bool>

    Checks if all elements of the tensor are true returning the result as a tensor.

    static member almostEqual: Tensor<'T> * Tensor<'T> * 'T option * 'T option -> bool

    Checks if two tensors have the same (within machine precision) values in all elements.

    static member any: Tensor<bool> -> bool

    Checks if any elements of the tensor are true.

    static member anyAxis: int -> Tensor<bool> -> Tensor<bool>

    Checks if any element along the specified axis is true.

    static member anyTensor: Tensor<bool> -> Tensor<bool>

    Checks if any element of the tensor is true returning the result as a tensor.

    static member arange: ITensorDevice -> 'T -> 'T -> 'T -> Tensor<'T>

    Creates a new vector filled with equaly spaced values using a specifed increment.

    static member argMax: Tensor<'T> -> int64 list

    Finds the indicies of the maximum value of the tensor.

    static member argMaxAxis: int -> Tensor<'T> -> Tensor<int64>

    Finds the index of the maximum value along the specified axis.

    static member argMin: Tensor<'T> -> int64 list

    Finds the indicies of the minimum value of the tensor.

    static member argMinAxis: int -> Tensor<'T> -> Tensor<int64>

    Finds the index of the minimum value along the specified axis.

    static member Asin: Tensor<'T> -> Tensor<'T>

    Element-wise arcsine (inverse sine).

    static member Atan: Tensor<'T> -> Tensor<'T>

    Element-wise arctanget (inverse tangent).

    static member atLeast1D: Tensor<'T> -> Tensor<'T>

    Pads the tensor from the left with size-one dimensions until it has at least one dimension.

    static member atLeast2D: Tensor<'T> -> Tensor<'T>

    Pads the tensor from the left with size-one dimensions until it has at least two dimensions.

    static member atLeast3D: Tensor<'T> -> Tensor<'T>

    Pads the tensor from the left with size-one dimensions until it has at least three dimensions.

    static member atLeastND: int -> Tensor<'T> -> Tensor<'T>

    Pads the tensor from the left with size-one dimensions until it has at least the specified number of dimensions.

    static member broadcastDim: int -> int64 -> Tensor<'T> -> Tensor<'T>

    Broadcast a dimension to a specified size.

    static member broadcastTo: int64 list -> Tensor<'T> -> Tensor<'T>

    Broadcasts the specified tensor to the specified shape.

    static member broadcastToSame: Tensor<'T> list -> Tensor<'T> list

    Broadcasts all specified tensors to have the same shape.

    static member broadcastToSame: Tensor<'TA> * Tensor<'TB> * Tensor<'TC> -> Tensor<'TA> * Tensor<'TB> * Tensor<'TC>

    Broadcasts all specified tensors to have the same shape.

    static member broadcastToSame: Tensor<'TA> * Tensor<'TB> -> Tensor<'TA> * Tensor<'TB>

    Broadcasts all specified tensors to have the same shape.

    static member broadcastToSameInDims: seq<int> * Tensor<'T> list -> Tensor<'T> list

    Broadcasts all specified tensors to have the same size in the specified dimensions.

    static member broadcastToSameInDims: seq<int> * Tensor<'TA> * Tensor<'TB> * Tensor<'TC> -> Tensor<'TA> * Tensor<'TB> * Tensor<'TC>

    Broadcasts all specified tensors to have the same size in the specified dimensions.

    static member broadcastToSameInDims: seq<int> * Tensor<'TA> * Tensor<'TB> -> Tensor<'TA> * Tensor<'TB>

    Broadcasts all specified tensors to have the same size in the specified dimensions.

    static member Ceiling: Tensor<'T> -> Tensor<'T>

    Element-wise ceiling (round towards positive infinity).

    member CheckAxis: int -> unit

    Checks the the specified axis is valid for this tensor.

    static member concat: int -> seq<Tensor<'T>> -> Tensor<'T>

    Concatenates tensors along an axis.

    static member convert: Tensor<'C> -> Tensor<'T>

    Convert the elements of a tensor to the specifed type.

    static member copy: Tensor<'T> * TensorOrder option -> Tensor<'T>

    Returns a copy of the tensor.

    member CopyFrom: Tensor<'T> -> unit

    Fills this tensor with a copy of the specified tensor.

    static member Cos: Tensor<'T> -> Tensor<'T>

    Element-wise cosine.

    static member Cosh: Tensor<'T> -> Tensor<'T>

    Element-wise hyperbolic cosine.

    static member counting: ITensorDevice -> int64 -> Tensor<int64>

    Creates a new vector filled with the integers from zero to the specified maximum.

    static member countTrue: Tensor<bool> -> int64

    Counts the elements being true.

    static member countTrueAxis: int -> Tensor<bool> -> Tensor<int64>

    Counts the elements being true along the specified axis.

    static member countTrueTensor: Tensor<bool> -> Tensor<int64>

    Counts the elements being true returning the result as a Tensor.

    static member cutLeft: Tensor<'T> -> Tensor<'T>

    Removes the first dimension.

    static member cutRight: Tensor<'T> -> Tensor<'T>

    Removes the last dimension.

    static member dataType: Tensor<'T> -> Type

    Type of data stored within the tensor.

    static member dev: Tensor<'T> -> ITensorDevice

    Device the data of tensor is stored on.

    static member diag: Tensor<'T> -> Tensor<'T>

    Returns a view of the diagonal of the matrix.

    static member diagAxis: int -> int -> Tensor<'T> -> Tensor<'T>

    Returns a view of the diagonal along the given axes.

    static member diagMat: Tensor<'T> -> Tensor<'T>

    Creates a matrix with the specified diagonal.

    static member diagMatAxis: int -> int -> Tensor<'T> -> Tensor<'T>

    Creates a tensor with the specified diagonal along the given axes.

    static member diff: Tensor<'T> -> Tensor<'T>

    Calculates the difference between adjoining elements of the vector.

    static member diffAxis: int -> Tensor<'T> -> Tensor<'T>

    Calculates the difference between adjoining elements along the specified axes.

    static member dot: Tensor<'T> -> Tensor<'T> -> Tensor<'T>

    Computes the (batched) matrix product, (batched) matrix-vector product or scalar product.

    static member empty: ITensorDevice -> int -> Tensor<'T>

    Creates a new, empty tensor with the given number of dimensions.

    override member Equals: obj -> bool

    Tests for equality to another object.

    static member Exp: Tensor<'T> -> Tensor<'T>

    Element-wise exponential function.

    static member falses: ITensorDevice -> int64 list -> Tensor<bool>

    Creates a new boolean tensor filled with falses.

    member FillAbs: Tensor<'T> -> unit

    Fills this tensor with the element-wise absolute value of the argument.

    member FillAcos: Tensor<'T> -> unit

    Fills this tensor with the element-wise arccosine (inverse cosine) of the argument.

    member FillAdd: Tensor<'T> -> Tensor<'T> -> unit

    Fills this tensor with the element-wise addition of the arguments.

    member FillAllAxis: int -> Tensor<bool> -> unit

    Checks if all elements along the specified axis are true using this tensor as target.

    member FillAnd: Tensor<bool> -> Tensor<bool> -> unit

    Fills this tensor with the element-wise logical and of the arguments.

    member FillAnyAxis: int -> Tensor<bool> -> unit

    Checks if any element along the specified axis is true using this tensor as target.

    member FillArgMaxAxis: int -> Tensor<'R> -> unit

    Finds the index of the maximum value along the specified axis and writes it into this tensor.

    member FillArgMinAxis: int -> Tensor<'R> -> unit

    Finds the index of the minimum value along the specified axis and writes it into this tensor.

    member FillAsin: Tensor<'T> -> unit

    Fills this tensor with the element-wise arcsine (inverse sine) of the argument.

    member FillAtan: Tensor<'T> -> unit

    Fills this tensor with the element-wise arctanget (inverse tangent) of the argument.

    member FillCeiling: Tensor<'T> -> unit

    Fills this tensor with the element-wise ceiling (round towards positive infinity) of the argument.

    member FillConst: 'T -> unit

    Fills this tensor with the specified constant value.

    member FillConvert: Tensor<'C> -> unit

    Copies elements from a tensor of different data type into this tensor and converts their type.

    member FillCos: Tensor<'T> -> unit

    Fills this tensor with the element-wise cosine of the argument.

    member FillCosh: Tensor<'T> -> unit

    Fills this tensor with the element-wise hyperbolic cosine of the argument.

    member FillCountTrueAxis: int -> Tensor<bool> -> unit

    Counts the elements being true along the specified axis and writes the result into this tensor.

    member FillDivide: Tensor<'T> -> Tensor<'T> -> unit

    Fills this tensor with the element-wise division of the arguments.

    member FillDot: Tensor<'T> -> Tensor<'T> -> unit

    Fill this tensor with the (batched) matrix product, matrix-vector product or scalar product of the arguments.

    static member filled: ITensorDevice -> int64 list -> 'T -> Tensor<'T>

    Creates a new tensor filled with the specified value.

    member FillEqual: Tensor<'R> -> Tensor<'R> -> unit

    Fills this tensor with the element-wise equality test of the arguments.

    member FillExp: Tensor<'T> -> unit

    Fills this tensor with the element-wise exponential function of the argument.

    member FillFindAxis: 'R -> int -> Tensor<'R> -> unit

    Finds the first occurence of the specfied value along the specified axis and write its index into this tensor.

    member FillFloor: Tensor<'T> -> unit

    Fills this tensor with the element-wise floor (round towards negative infinity) of the argument.

    member FillFrom: Tensor<'T> -> unit

    Fills this tensor with a copy of the specified tensor.

    member FillGather: Tensor<int64> option list -> Tensor<'T> -> unit

    Selects elements from a tensor according to specified indices.

    member FillGreater: Tensor<'R> -> Tensor<'R> -> unit

    Fills this tensor with the element-wise greater-than test of the arguments.

    member FillGreaterOrEqual: Tensor<'R> -> Tensor<'R> -> unit

    Fills this tensor with the element-wise greater-than-or-equal test of the arguments.

    member FillIfThenElse: Tensor<bool> -> Tensor<'T> -> Tensor<'T> -> unit

    Fills this tensor with an element-wise choice between two sources depending on a condition.

    member FillIncrementing: 'T * 'T -> unit

    Fills this vector with an equispaced sequence of elements.

    member FillInvert: Tensor<'T> -> unit

    Fills this tensor with the (batch) inverse of a matrix.

    member FillIsFinite: Tensor<'R> -> unit

    Fills this tensor with the element-wise finity check (not -Inf, Inf or NaN) of the argument.

    member FillLess: Tensor<'R> -> Tensor<'R> -> unit

    Fills this tensor with the element-wise less-than test of the arguments.

    member FillLessOrEqual: Tensor<'R> -> Tensor<'R> -> unit

    Fills this tensor with the element-wise less-than-or-equal test of the arguments.

    member FillLog: Tensor<'T> -> unit

    Fills this tensor with the element-wise natural logarithm of the argument.

    member FillLog10: Tensor<'T> -> unit

    Fills this tensor with the element-wise common logarithm of the argument.

    member FillMaxAxis: int -> Tensor<'T> -> unit

    Calculates the maximum value of the elements over the specified axis and writes the result into this tensor.

    member FillMaxElemwise: Tensor<'T> -> Tensor<'T> -> unit

    Fills this tensor with the element-wise maximum of the arguments.

    member FillMinAxis: int -> Tensor<'T> -> unit

    Calculates the minimum value of the elements over the specified axis and writes the result into this tensor.

    member FillMinElemwise: Tensor<'T> -> Tensor<'T> -> unit

    Fills this tensor with the element-wise minimum of the arguments.

    member FillModulo: Tensor<'T> -> Tensor<'T> -> unit

    Fills this tensor with the element-wise remainder of the division of the arguments.

    member FillMultiply: Tensor<'T> -> Tensor<'T> -> unit

    Fills this tensor with the element-wise multiplication of the arguments.

    member FillNegate: Tensor<bool> -> unit

    Fills this tensor with the element-wise logical negation of the argument.

    member FillNotEqual: Tensor<'R> -> Tensor<'R> -> unit

    Fills this tensor with the element-wise not-equality test or of the arguments.

    member FillOr: Tensor<bool> -> Tensor<bool> -> unit

    Fills this tensor with the element-wise logical or of the arguments.

    member FillPower: Tensor<'T> -> Tensor<'T> -> unit

    Fills this tensor with the element-wise exponentiation.

    member FillProductAxis: int -> Tensor<'T> -> unit

    Calculates the product of the elements over the specified axis and writes the result into this tensor.

    member FillPseudoInvert: Tensor<'T> * 'T option -> unit

    Fills this tensor with the (batched) Moore-Penrose pseudo-inverse of the specified matrix.

    member FillRound: Tensor<'T> -> unit

    Fills this tensor with the element-wise rounding of the argument.

    member FillScatter: Tensor<int64> option list -> Tensor<'T> -> unit

    Disperses elements from a source tensor to this tensor according to the specified indices.

    member FillSgn: Tensor<'T> -> unit

    Fills this tensor with the element-wise sign of the argument.

    member FillSin: Tensor<'T> -> unit

    Fills this tensor with the element-wise sine of the argument.

    member FillSinh: Tensor<'T> -> unit

    Fills this tensor with the element-wise hyperbolic sine of the argument.

    member FillSqrt: Tensor<'T> -> unit

    Fills this tensor with the element-wise square root of the argument.

    member FillSubtract: Tensor<'T> -> Tensor<'T> -> unit

    Fills this tensor with the element-wise substraction of the arguments.

    member FillSumAxis: int -> Tensor<'T> -> unit

    Sums the elements over the specified axis and writes the result into this tensor.

    member FillSVD: Tensor<'T> * Tensor<'T> * Tensor<'T> option -> unit

    Fills this tensor with the (batched) singular values of the specified matrix.

    static member FillSymmetricEigenDecomposition: MatrixPart -> Tensor<'T> -> Tensor<'T> -> Tensor<'T> -> unit

    Computes the (real) eigendecomposition of a symmetric matrix and writes it into the specified target tensors.

    member FillTan: Tensor<'T> -> unit

    Fills this tensor with the element-wise tangent of the argument.

    member FillTanh: Tensor<'T> -> unit

    Fills this tensor with the element-wise hyperbolic tangent of the argument.

    member FillTruncate: Tensor<'T> -> unit

    Fills this tensor with the element-wise truncation (rounding towards zero) of the argument.

    member FillUnaryMinus: Tensor<'T> -> unit

    Fills this tensor with the element-wise negation of the argument.

    member FillUnaryPlus: Tensor<'T> -> unit

    Fills this tensor with the element-wise prefix plus of the argument.

    member FillXor: Tensor<bool> -> Tensor<bool> -> unit

    Fills this tensor with the element-wise logical xor of the arguments.

    static member find: 'T -> Tensor<'T> -> int64 list

    Finds the first occurence of the specfied value and returns its indices.

    static member findAxis: 'T -> int -> Tensor<'T> -> Tensor<int64>

    Finds the first occurence of the specfied value along the specified axis and returns its index.

    static member flatten: Tensor<'T> -> Tensor<'T>

    Flattens the tensor into a (one-dimensional) vector.

    static member Floor: Tensor<'T> -> Tensor<'T>

    Element-wise floor (round towards negative infinity).

    static member gather: Tensor<int64> option list -> Tensor<'T> -> Tensor<'T>

    Selects elements from a tensor according to specified indices.

    static member get: Tensor<'T> -> int64 list -> 'T

    Gets the value of a single element of the tensor.

    override member GetHashCode: unit -> int

    Calculates the hash code of the tensor.

    static member identity: ITensorDevice -> int64 -> Tensor<'T>

    Creates a new identity matrix.

    static member ifThenElse: Tensor<bool> -> Tensor<'T> -> Tensor<'T> -> Tensor<'T>

    Element-wise choice between two sources depending on a condition.

    static member insertAxis: int -> Tensor<'T> -> Tensor<'T>

    Insert a dimension of size one before the specifed dimension.

    static member invert: Tensor<'T> -> Tensor<'T>

    (Batch) inverts a matrix.

    static member isBroadcasted: Tensor<'T> -> bool

    Checks if the specified tensor is broadcasted in at least one dimension.

    static member isClose: Tensor<'T> * Tensor<'T> * 'T option * 'T option -> Tensor<bool>

    Element-wise check if two tensors have same (within machine precision) values.

    static member isFinite: Tensor<'T> -> Tensor<bool>

    Element-wise finity check (not -Inf, Inf or NaN).

    static member layout: Tensor<'T> -> TensorLayout

    Memory layout of the tensor.

    static member linspace: ITensorDevice -> 'T -> 'T -> int64 -> Tensor<'T>

    Creates a new vector of given size filled with equaly spaced values.

    static member Log: Tensor<'T> -> Tensor<'T>

    Element-wise natural logarithm.

    static member Log10: Tensor<'T> -> Tensor<'T>

    Element-wise common logarithm.

    static member max: Tensor<'T> -> 'T

    Calculates the maximum of all elements.

    static member maxAxis: int -> Tensor<'T> -> Tensor<'T>

    Calculates the maximum value of the elements along the specified axis.

    static member maxElemwise: Tensor<'T> -> Tensor<'T> -> Tensor<'T>

    Element-wise maximum.

    static member maxTensor: Tensor<'T> -> Tensor<'T>

    Calculates the maximum all elements returning a Tensor.

    static member mean: Tensor<'T> -> 'T

    Calculates the mean of the tensor.

    static member meanAxis: int -> Tensor<'T> -> Tensor<'T>

    Calculates the mean of the elements along the specified axis.

    static member min: Tensor<'T> -> 'T

    Calculates the minimum of all elements.

    static member minAxis: int -> Tensor<'T> -> Tensor<'T>

    Calculates the minimum value of the elements along the specified axis.

    static member minElemwise: Tensor<'T> -> Tensor<'T> -> Tensor<'T>

    Element-wise minimum.

    static member minTensor: Tensor<'T> -> Tensor<'T>

    Calculates the minimum all elements returning a Tensor.

    static member nDims: Tensor<'T> -> int

    Dimensionality of the tensor.

    static member nElems: Tensor<'T> -> int64

    Total number of elements within the tensor.

    static member NewOfType: int64 list * Type * ITensorDevice * TensorOrder option -> ITensor

    Type-neutral function for creating a new, uninitialized tensor with a new storage.

    static member norm: Tensor<'T> * 'T option -> 'T

    Calculates the norm of the (flattened) tensor.

    static member normAxis: int * Tensor<'T> * 'T option -> Tensor<'T>

    Calculates the norm along the specified axis.

    static member ofBlocks: BlockTensor<'T> -> Tensor<'T>

    Builds a tensor out of tensor blocks.

    static member ofBlocks: Tensor<'T> list list list -> Tensor<'T>

    Builds a three dimensional tensor out of tensor blocks.

    static member ofBlocks: Tensor<'T> list list -> Tensor<'T>

    Builds a matrix out of matrix blocks.

    static member ofBlocks: Tensor<'T> list -> Tensor<'T>

    Builds a vector out of vectors blocks.

    static member ones: ITensorDevice -> int64 list -> Tensor<'T>

    Creates a new tensor filled with ones (1).

    static member onesLike: Tensor<'T> -> Tensor<'T>

    Creates a new tensor filled with ones using the specified tensor as template.

    static member padLeft: Tensor<'T> -> Tensor<'T>

    Insert a dimension of size one as the first dimension.

    static member padRight: Tensor<'T> -> Tensor<'T>

    Append a dimension of size one after the last dimension.

    static member padToSame: Tensor<'T> list -> Tensor<'T> list

    Pads all specified tensors from the left with dimensions of size one until they have the same dimensionality.

    static member padToSame: Tensor<'TA> * Tensor<'TB> * Tensor<'TC> -> Tensor<'TA> * Tensor<'TB> * Tensor<'TC>

    Pads all specified tensors from the left with dimensions of size one until they have the same dimensionality.

    static member padToSame: Tensor<'TA> * Tensor<'TB> -> Tensor<'TA> * Tensor<'TB>

    Pads all specified tensors from the left with dimensions of size one until they have the same dimensionality.

    static member permuteAxes: int list -> Tensor<'T> -> Tensor<'T>

    Permutes the axes as specified.

    static member Pow: 'T * Tensor<'T> -> Tensor<'T>

    Element-wise exponentiation with scalar.

    static member Pow: Tensor<'T> * 'T -> Tensor<'T>

    Element-wise exponentiation with scalar.

    static member Pow: Tensor<'T> * Tensor<'T> -> Tensor<'T>

    Element-wise exponentiation.

    static member product: Tensor<'T> -> 'T

    Calculates the product of all elements.

    static member productAxis: int -> Tensor<'T> -> Tensor<'T>

    Calculates the product of the elements along the specified axis.

    static member productTensor: Tensor<'T> -> Tensor<'T>

    Calculates the product all elements returning a Tensor.

    static member pseudoInvert: Tensor<'T> * 'T option -> Tensor<'T>

    Computes the (batched) Moore-Penrose pseudo-inverse of the specified matrix.

    static member range: Rng list -> Tensor<'T> -> Tensor<'T>

    Get a slice (part) of the tensor.

    static member relayout: TensorLayout -> Tensor<'T> -> Tensor<'T>

    Creates a tensor with the specified layout sharing its storage with the original tensor.

    static member replicate: int -> int64 -> Tensor<'T> -> Tensor<'T>

    Repeats the tensor along an axis.

    static member reshape: int64 list -> Tensor<'T> -> Tensor<'T>

    Changes the shape of a tensor.

    static member reshapeView: int64 list -> Tensor<'T> -> Tensor<'T>

    Creates a reshaped view of the tensor (without copying).

    static member reverseAxis: int -> Tensor<'T> -> Tensor<'T>

    Reverses the elements in the specified dimension.

    static member Round: Tensor<'T> -> Tensor<'T>

    Element-wise rounding.

    static member scalar: ITensorDevice -> 'T -> Tensor<'T>

    Creates a new zero-dimensional (scalar) tensor with the specified value.

    static member scalarLike: ITensor -> 'T -> Tensor<'T>

    Creates a new zero-dimensional (scalar) tensor using the specified tensor as template and with the specified value.

    static member scatter: Tensor<int64> option list -> int64 list -> Tensor<'T> -> Tensor<'T>

    Disperses elements from a source tensor to a new tensor according to the specified indices.

    static member set: Tensor<'T> -> int64 list -> 'T -> unit

    Sets the value of a single element of the tensor.

    static member Sgn: Tensor<'T> -> Tensor<'T>

    Element-wise sign.

    static member shape: Tensor<'T> -> int64 list

    Shape of the tensor.

    static member Sin: Tensor<'T> -> Tensor<'T>

    Element-wise sine.

    static member Sinh: Tensor<'T> -> Tensor<'T>

    Element-wise hyperbolic sine.

    static member Sqrt: Tensor<'T> -> Tensor<'T>

    Element-wise square root.

    static member std: Tensor<'T> * int64 option -> 'T

    Calculates the standard deviation of the tensor.

    static member stdAxis: int * Tensor<'T> * int64 option -> Tensor<'T>

    Calculates the standard deviation of the elements along the specified axis.

    static member sum: Tensor<'T> -> 'T

    Sums all elements.

    static member sumAxis: int -> Tensor<'T> -> Tensor<'T>

    Sums the elements along the specified axis.

    static member sumTensor: Tensor<'T> -> Tensor<'T>

    Sums all elements returning a Tensor.

    static member SVD: Tensor<'T> -> Tensor<'T> * Tensor<'T> * Tensor<'T>

    Computes the (batched) singular value decomposition (SVD) of the specified matrix.

    static member SVDWithoutUV: Tensor<'T> -> Tensor<'T>

    Computes the (batched) singular values of the specified matrix.

    static member swapDim: int -> int -> Tensor<'T> -> Tensor<'T>

    Swaps the specified dimensions of the tensor.

    static member symmetricEigenDecomposition: MatrixPart -> Tensor<'T> -> Tensor<'T> * Tensor<'T>

    Computes the (real) eigendecomposition of a symmetric matrix.

    static member Tan: Tensor<'T> -> Tensor<'T>

    Element-wise tangent.

    static member Tanh: Tensor<'T> -> Tensor<'T>

    Element-wise hyperbolic tangent.

    static member tensorProduct: Tensor<'T> -> Tensor<'T> -> Tensor<'T>

    Computes the tensor product between two tensors.

    member ToString: int64 -> string

    String representation of the tensor limited to a specific number of elements per dimension.

    override member ToString: unit -> string

    String representation of the tensor limited to 10 elements per dimension.

    static member trace: Tensor<'T> -> Tensor<'T>

    Calculates the trace of the matrix.

    static member traceAxis: int -> int -> Tensor<'T> -> Tensor<'T>

    Calculates the trace along the specified axes.

    static member transfer: ITensorDevice -> Tensor<'T> -> Tensor<'T>

    Transfers a tensor to the specifed device.

    member TransferFrom: Tensor<'T> -> unit

    Transfers the specified tensor located on another device into this tensor.

    static member transpose: Tensor<'T> -> Tensor<'T>

    (Batched) transpose of a matrix.

    static member trueIdx: Tensor<bool> -> Tensor<int64>

    Finds the indices of all element that are true.

    static member trues: ITensorDevice -> int64 list -> Tensor<bool>

    Creates a new boolean tensor filled with trues.

    static member Truncate: Tensor<'T> -> Tensor<'T>

    Element-wise truncation (rounding towards zero).

    static member tryFind: 'T -> Tensor<'T> -> int64 list option

    Finds the first occurence of the specfied value and returns its indices.

    static member tryReshapeView: int64 list -> Tensor<'T> -> Tensor<'T> option

    Tries to create a reshaped view of the tensor (without copying).

    static member value: Tensor<'T> -> 'T

    Gets the value of a zero-dimensional (scalar) tensor.

    static member var: Tensor<'T> * int64 option -> 'T

    Calculates the variance of the tensor.

    static member varAxis: int * Tensor<'T> * int64 option -> Tensor<'T>

    Calculates the variance of the elements along the specified axis.

    static member zeros: ITensorDevice -> int64 list -> Tensor<'T>

    Creates a new tensor filled with zeros (0).

    static member zerosLike: Tensor<'T> -> Tensor<'T>

    Creates a new tensor filled with zeros using the specified tensor as template.

    Operators

    Name Description
    static member ( + ): 'T * Tensor<'T> -> Tensor<'T>

    Element-wise addition with scalar.

    static member ( + ): Tensor<'T> * 'T -> Tensor<'T>

    Element-wise addition with scalar.

    static member ( + ): Tensor<'T> * Tensor<'T> -> Tensor<'T>

    Element-wise addition.

    static member ( &&&& ): bool * Tensor<bool> -> Tensor<bool>

    Element-wise loigcal and with scalar.

    static member ( &&&& ): Tensor<bool> * bool -> Tensor<bool>

    Element-wise loigcal and with scalar.

    static member ( &&&& ): Tensor<bool> * Tensor<bool> -> Tensor<bool>

    Element-wise loigcal and.

    static member ( |||| ): bool * Tensor<bool> -> Tensor<bool>

    Element-wise loigcal or with scalar.

    static member ( |||| ): Tensor<bool> * bool -> Tensor<bool>

    Element-wise loigcal or with scalar.

    static member ( |||| ): Tensor<bool> * Tensor<bool> -> Tensor<bool>

    Element-wise loigcal or.

    static member ( / ): 'T * Tensor<'T> -> Tensor<'T>

    Element-wise division with scalar.

    static member ( / ): Tensor<'T> * 'T -> Tensor<'T>

    Element-wise division with scalar.

    static member ( / ): Tensor<'T> * Tensor<'T> -> Tensor<'T>

    Element-wise division.

    static member ( .* ): Tensor<'T> * Tensor<'T> -> Tensor<'T>

    Computes the (batched) matrix product, (batched) matrix-vector product or scalar product.

    static member ( ==== ): 'T * Tensor<'T> -> Tensor<bool>

    Element-wise equality test with scalar.

    static member ( ==== ): Tensor<'T> * 'T -> Tensor<bool>

    Element-wise equality test with scalar.

    static member ( ==== ): Tensor<'T> * Tensor<'T> -> Tensor<bool>

    Element-wise equality test.

    static member ( >>== ): 'T * Tensor<'T> -> Tensor<bool>

    Element-wise greater-than-or-equal test with scalar.

    static member ( >>== ): Tensor<'T> * 'T -> Tensor<bool>

    Element-wise greater-than-or-equal test with scalar.

    static member ( >>== ): Tensor<'T> * Tensor<'T> -> Tensor<bool>

    Element-wise greater-than-or-equal test.

    static member ( >>>> ): 'T * Tensor<'T> -> Tensor<bool>

    Element-wise greater-than test with scalar.

    static member ( >>>> ): Tensor<'T> * 'T -> Tensor<bool>

    Element-wise greater-than test with scalar.

    static member ( >>>> ): Tensor<'T> * Tensor<'T> -> Tensor<bool>

    Element-wise greater-than test.

    static member ( ^^^^ ): bool * Tensor<bool> -> Tensor<bool>

    Element-wise loigcal xor with scalar.

    static member ( ^^^^ ): Tensor<bool> * bool -> Tensor<bool>

    Element-wise loigcal xor with scalar.

    static member ( ^^^^ ): Tensor<bool> * Tensor<bool> -> Tensor<bool>

    Element-wise loigcal xor.

    static member ( <<== ): 'T * Tensor<'T> -> Tensor<bool>

    Element-wise less-than-or-equal test with scalar.

    static member ( <<== ): Tensor<'T> * 'T -> Tensor<bool>

    Element-wise less-than-or-equal test with scalar.

    static member ( <<== ): Tensor<'T> * Tensor<'T> -> Tensor<bool>

    Element-wise less-than-or-equal test.

    static member ( <<>> ): 'T * Tensor<'T> -> Tensor<bool>

    Element-wise not-equality test with scalar.

    static member ( <<>> ): Tensor<'T> * 'T -> Tensor<bool>

    Element-wise not-equality test with scalar.

    static member ( <<>> ): Tensor<'T> * Tensor<'T> -> Tensor<bool>

    Element-wise not-equality test.

    static member ( <<<< ): 'T * Tensor<'T> -> Tensor<bool>

    Element-wise less-than test with scalar.

    static member ( <<<< ): Tensor<'T> * 'T -> Tensor<bool>

    Element-wise less-than test with scalar.

    static member ( <<<< ): Tensor<'T> * Tensor<'T> -> Tensor<bool>

    Element-wise less-than test.

    static member ( % ): 'T * Tensor<'T> -> Tensor<'T>

    Element-wise division with scalar.

    static member ( % ): Tensor<'T> * 'T -> Tensor<'T>

    Element-wise remainder of division with scalar.

    static member ( % ): Tensor<'T> * Tensor<'T> -> Tensor<'T>

    Element-wise remainder of division.

    static member ( * ): 'T * Tensor<'T> -> Tensor<'T>

    Element-wise multiplication with scalar.

    static member ( * ): Tensor<'T> * 'T -> Tensor<'T>

    Element-wise multiplication with scalar.

    static member ( * ): Tensor<'T> * Tensor<'T> -> Tensor<'T>

    Element-wise multiplication.

    static member ( - ): 'T * Tensor<'T> -> Tensor<'T>

    Element-wise substraction with scalar.

    static member ( - ): Tensor<'T> * 'T -> Tensor<'T>

    Element-wise substraction with scalar.

    static member ( - ): Tensor<'T> * Tensor<'T> -> Tensor<'T>

    Element-wise substraction.

    static member ( ~~~~ ): Tensor<bool> -> Tensor<bool>

    Element-wise logical negation.

    static member ( ~- ): Tensor<'T> -> Tensor<'T>

    Element-wise negation.

    static member ( ~+ ): Tensor<'T> -> Tensor<'T>

    Element-wise prefix plus.

    See Also

    ITensor
    Back to top Generated by DocFX