kmath-tensors/space.kscience.kmath.tensors.core/BroadcastDoubleTensorAlgebra

BroadcastDoubleTensorAlgebra

object BroadcastDoubleTensorAlgebra : DoubleTensorAlgebra(source)

Basic linear algebra operations implemented with broadcasting. For more information: https://pytorch.org/docs/stable/notes/broadcasting.html

Functions

acos

open override fun acos(arg: StructureND<Double>): DoubleTensor

acosh

open override fun acosh(arg: StructureND<Double>): DoubleTensor

add

open override fun add(left: StructureND<Double>, right: StructureND<Double>): Tensor<Double>

argMax

open override fun StructureND<Double>.argMax(dim: Int, keepDim: Boolean): IntTensor

Returns the index of maximum value of each row of the input tensor in the given dimension dim.

argMin

open override fun StructureND<Double>.argMin(dim: Int, keepDim: Boolean): Tensor<Int>

Returns the index of minimum value of each row of the input tensor in the given dimension dim.

asin

open override fun asin(arg: StructureND<Double>): DoubleTensor

asinh

open override fun asinh(arg: StructureND<Double>): DoubleTensor

atan

open override fun atan(arg: StructureND<Double>): DoubleTensor

atanh

open override fun atanh(arg: StructureND<Double>): DoubleTensor

binaryOperation

open fun binaryOperation(operation: String, left: StructureND<Double>, right: StructureND<Double>): StructureND<Double>

binaryOperationFunction

open override fun binaryOperationFunction(operation: String): (left: StructureND<Double>, right: StructureND<Double>) -> StructureND<Double>

bindSymbol

open fun bindSymbol(value: String): StructureND<Double>

bindSymbolOrNull

open fun bindSymbolOrNull(value: String): StructureND<Double>?

ceil

open override fun ceil(arg: StructureND<Double>): DoubleTensor

cholesky

open override fun cholesky(structureND: StructureND<Double>): DoubleTensor

Cholesky decomposition.

cholesky

fun DoubleTensorAlgebra.cholesky(structureND: StructureND<Double>, epsilon: Double = 1.0E-6): DoubleTensor

QR decomposition.

cos

open override fun cos(arg: StructureND<Double>): DoubleTensor

cosh

open override fun cosh(arg: StructureND<Double>): DoubleTensor

covariance

fun DoubleTensorAlgebra.covariance(vectors: List<Buffer<Double>>): DoubleTensor

Returns the covariance matrix M of given vectors.

det

open override fun StructureND<Double>.det(): DoubleTensor

Computes the determinant of a square matrix input, or of each square matrix in a batched input. For more information: https://pytorch.org/docs/stable/linalg.html#torch.linalg.det

detLU

fun DoubleTensorAlgebra.detLU(structureND: StructureND<Double>, epsilon: Double = 1.0E-9): DoubleTensor

Computes the determinant of a square matrix input, or of each square matrix in a batched input using LU factorization algorithm.

diagonalEmbedding

open override fun diagonalEmbedding(diagonalEntries: StructureND<Double>, offset: Int, dim1: Int, dim2: Int): DoubleTensor

Creates a tensor whose diagonals of certain 2D planes (specified by dim1 and dim2) are filled by diagonalEntries. To facilitate creating batched diagonal matrices, the 2D planes formed by the last two dimensions of the returned tensor are chosen by default.

div

open operator fun StructureND<Double>.div(k: Number): StructureND<Double>

open operator override fun StructureND<Double>.div(arg: StructureND<Double>): DoubleTensor

Each element of the tensor arg is divided by each element of this tensor. The resulting tensor is returned.

open operator override fun Double.div(arg: StructureND<Double>): DoubleTensor

Each element of the tensor arg is divided by this value. The resulting tensor is returned.

open operator override fun StructureND<Double>.div(arg: Double): DoubleTensor

Divide by the scalar arg each element of this tensor returns a new resulting tensor.

divAssign

open operator override fun Tensor<Double>.divAssign(arg: StructureND<Double>)

Each element of this tensor is divided by each element of the arg tensor.

open operator override fun Tensor<Double>.divAssign(value: Double)

Divides by the scalar value each element of this tensor.

divide

open override fun divide(left: StructureND<Double>, right: StructureND<Double>): StructureND<Double>

dot

open infix override fun StructureND<Double>.dot(other: StructureND<Double>): DoubleTensor

Matrix product of two tensors.

infix fun Tensor<Double>.eq(other: Tensor<Double>): Boolean

Compares element-wise two tensors. Comparison of two Double values occurs with 1e-5 precision.

fun Tensor<Double>.eq(other: Tensor<Double>, epsilon: Double): Boolean

Compares element-wise two tensors with a specified precision.

exp

open override fun exp(arg: StructureND<Double>): DoubleTensor

export

open fun export(arg: StructureND<Double>): StructureND<Double>

eye

fun eye(n: Int): DoubleTensor

Returns a 2D tensor with shape (n, n), with ones on the diagonal and zeros elsewhere.

floor

open override fun floor(structureND: StructureND<Double>): DoubleTensor

fromArray

fun fromArray(shape: ShapeND, array: DoubleArray): DoubleTensor

Constructs a tensor with the specified shape and data.

fromBuffer

fun fromBuffer(shape: ShapeND, buffer: Buffer<Double>): DoubleTensor

full

fun full(value: Double, shape: ShapeND): DoubleTensor

Creates a tensor of a given shape and fills all elements with a given value.

fullLike

fun fullLike(structureND: StructureND<*>, value: Double): DoubleTensor

Returns a tensor with the same shape as input filled with value.

getFeature

open fun <F : StructureFeature> getFeature(structure: StructureND<Double>, type: KClass<out F>): F?

getTensor

open fun Tensor<Double>.getTensor(first: Int, second: Int): Tensor<Double>

open override fun Tensor<Double>.getTensor(i: Int): DoubleTensor

Returns the tensor at index i For more information: https://pytorch.org/cppdocs/notes/tensor_indexing.html

inv

open override fun StructureND<Double>.inv(): DoubleTensor

Computes the multiplicative inverse matrix of a square matrix input, or of each square matrix in a batched input. Given a square matrix A, return the matrix AInv satisfying A dot AInv == AInv dot A == eye(a.shape[0]). For more information: https://pytorch.org/docs/stable/linalg.html#torch.linalg.inv

invLU

fun DoubleTensorAlgebra.invLU(structureND: StructureND<Double>, epsilon: Double = 1.0E-9): DoubleTensor

Computes the multiplicative inverse matrix of a square matrix input, or of each square matrix in a batched input using LU factorization algorithm. Given a square matrix a, return the matrix aInv satisfying a dot aInv == aInv dot a == eye(a.shape[0]).

invoke

open operator fun (Double) -> Double.invoke(structure: StructureND<Double>): StructureND<Double>

open override fun ln(arg: StructureND<Double>): DoubleTensor

open override fun lu(structureND: StructureND<Double>): Triple<DoubleTensor, DoubleTensor, DoubleTensor>

LUP decomposition

fun DoubleTensorAlgebra.lu(structureND: StructureND<Double>, epsilon: Double = 1.0E-9): Triple<DoubleTensor, DoubleTensor, DoubleTensor>

LUP decomposition.

luFactor

fun DoubleTensorAlgebra.luFactor(structureND: StructureND<Double>, epsilon: Double = 1.0E-9): Pair<DoubleTensor, IntTensor>

Computes the LU factorization of a matrix or batches of matrices input. Returns a tuple containing the LU factorization and pivots of input.

luPivot

fun DoubleTensorAlgebra.luPivot(luTensor: StructureND<Double>, pivotsTensor: Tensor<Int>): Triple<DoubleTensor, DoubleTensor, DoubleTensor>

Unpacks the data and pivots from a LU factorization of a tensor. Given a tensor luTensor, return tensors Triple(P, L, U) satisfying P dot luTensor = L dot U, with P being a permutation matrix or batch of matrices, L being a lower triangular matrix or batch of matrices, U being an upper triangular matrix or batch of matrices.

map

inline override fun StructureND<Double>.map(transform: DoubleField.(Double) -> Double): DoubleTensor

Applies the transform function to each element of the tensor and returns the resulting modified tensor.

mapIndexed

inline override fun StructureND<Double>.mapIndexed(transform: DoubleField.(index: IntArray, Double) -> Double): DoubleTensor

mapIndexedInPlace

inline fun Tensor<Double>.mapIndexedInPlace(operation: DoubleField.(IntArray, Double) -> Double)

mapInPlace

inline fun Tensor<Double>.mapInPlace(operation: (Double) -> Double)

matmul

infix fun StructureND<Double>.matmul(other: StructureND<Double>): DoubleTensor

Broadcasting Matrix product of two tensors.

max

open override fun StructureND<Double>.max(): Double

Returns the maximum value of all elements in the input tensor or null if there are no values

open override fun StructureND<Double>.max(dim: Int, keepDim: Boolean): DoubleTensor

Returns the maximum value of each row of the input tensor in the given dimension dim.

mean

open override fun mean(structureND: StructureND<Double>): Double

open override fun mean(structureND: StructureND<Double>, dim: Int, keepDim: Boolean): Tensor<Double>

Returns the mean of each row of the input tensor in the given dimension dim.

min

open override fun StructureND<Double>.min(): Double

open override fun StructureND<Double>.min(dim: Int, keepDim: Boolean): DoubleTensor

Returns the minimum value of each row of the input tensor in the given dimension dim.

minus

open operator override fun StructureND<Double>.minus(arg: StructureND<Double>): DoubleTensor

Each element of the tensor arg is subtracted from each element of this tensor. The resulting tensor is returned.

open operator override fun Double.minus(arg: StructureND<Double>): DoubleTensor

Each element of the tensor arg is subtracted from this value. The resulting tensor is returned.

open operator override fun StructureND<Double>.minus(arg: Double): DoubleTensor

Subtracts the scalar arg from each element of this tensor and returns a new resulting tensor.

minusAssign

open operator override fun Tensor<Double>.minusAssign(arg: StructureND<Double>)

Each element of the tensor arg is subtracted from each element of this tensor.

open operator override fun Tensor<Double>.minusAssign(value: Double)

Subtracts the scalar value from each element of this tensor.

multiply

open override fun multiply(left: StructureND<Double>, right: StructureND<Double>): Tensor<Double>

one

@JvmName(name = "varArgOne")

fun DoubleTensorAlgebra.one(vararg shape: Int): DoubleTensor

fun DoubleTensorAlgebra.one(shape: ShapeND): DoubleTensor

ones

fun ones(shape: ShapeND): DoubleTensor

Returns a tensor filled with the scalar value 1.0, with the shape defined by the variable argument shape.

onesLike

fun onesLike(structureND: StructureND<*>): DoubleTensor

Returns a tensor filled with the scalar value 1.0, with the same shape as a given array.

plus

open operator override fun StructureND<Double>.plus(arg: StructureND<Double>): DoubleTensor

Each element of the tensor arg is added to each element of this tensor. The resulting tensor is returned.

open operator override fun Double.plus(arg: StructureND<Double>): DoubleTensor

Each element of the tensor arg is added to this value. The resulting tensor is returned.

open operator override fun StructureND<Double>.plus(arg: Double): DoubleTensor

Adds the scalar arg to each element of this tensor and returns a new resulting tensor.

plusAssign

open operator override fun Tensor<Double>.plusAssign(arg: StructureND<Double>)

Each element of the tensor arg is added to each element of this tensor.

open operator override fun Tensor<Double>.plusAssign(value: Double)

Adds the scalar value to each element of this tensor.

pow

open infix fun StructureND<Double>.pow(pow: Number): StructureND<Double>

power

open override fun power(arg: StructureND<Double>, pow: Number): StructureND<Double>

open override fun qr(structureND: StructureND<Double>): Pair<DoubleTensor, DoubleTensor>

QR decomposition.

randomNormal

fun DoubleTensorAlgebra.randomNormal(shape: ShapeND, seed: Long = 0): DoubleTensor

Returns a tensor of random numbers drawn from normal distributions with 0.0 mean and 1.0 standard deviation.

randomNormalLike

fun DoubleTensorAlgebra.randomNormalLike(structure: WithShape, seed: Long = 0): DoubleTensor

Returns a tensor with the same shape as input of random numbers drawn from normal distributions with 0.0 mean and 1.0 standard deviation.

reduceElements

inline fun StructureND<Double>.reduceElements(transform: (DoubleBuffer) -> Double): Double

rowsByIndices

fun Tensor<Double>.rowsByIndices(indices: IntArray): DoubleTensor

Builds tensor from rows of the input tensor.

scale

open override fun scale(a: StructureND<Double>, value: Double): StructureND<Double>

sin

open override fun sin(arg: StructureND<Double>): DoubleTensor

sinh

open override fun sinh(arg: StructureND<Double>): DoubleTensor

sqrt

open override fun sqrt(arg: StructureND<Double>): DoubleTensor

std

open override fun std(structureND: StructureND<Double>): Double

open override fun std(structureND: StructureND<Double>, dim: Int, keepDim: Boolean): Tensor<Double>

Returns the standard deviation of each row of the input tensor in the given dimension dim.

structureND

open override fun structureND(shape: ShapeND, initializer: DoubleField.(IntArray) -> Double): DoubleTensor

Constructs a tensor with the specified shape and initializer.

sum

open override fun StructureND<Double>.sum(): Double

open override fun StructureND<Double>.sum(dim: Int, keepDim: Boolean): DoubleTensor

Returns the sum of each row of the input tensor in the given dimension dim.

svd

open override fun svd(structureND: StructureND<Double>): Triple<StructureND<Double>, StructureND<Double>, StructureND<Double>>

Singular Value Decomposition.

svd

fun DoubleTensorAlgebra.svd(structureND: StructureND<Double>, epsilon: Double): Triple<StructureND<Double>, StructureND<Double>, StructureND<Double>>

Singular Value Decomposition.

symEig

open override fun symEig(structureND: StructureND<Double>): Pair<DoubleTensor, DoubleTensor>

Returns eigenvalues and eigenvectors of a real symmetric matrix input or a batch of real symmetric matrices, represented by a pair eigenvalues to eigenvectors. For more information: https://pytorch.org/docs/stable/generated/torch.symeig.html

symEigJacobi

fun DoubleTensorAlgebra.symEigJacobi(structureND: StructureND<Double>, maxIteration: Int, epsilon: Double): Pair<DoubleTensor, DoubleTensor>

symEigSvd

fun DoubleTensorAlgebra.symEigSvd(structureND: StructureND<Double>, epsilon: Double): Pair<DoubleTensor, StructureND<Double>>

Returns eigenvalues and eigenvectors of a real symmetric matrix input or a batch of real symmetric matrices, represented by a pair eigenvalues to eigenvectors.

tan

open override fun tan(arg: StructureND<Double>): DoubleTensor

tanh

open override fun tanh(arg: StructureND<Double>): DoubleTensor

times

open operator fun Number.times(arg: StructureND<Double>): StructureND<Double>

open operator fun StructureND<Double>.times(k: Number): StructureND<Double>

open operator override fun StructureND<Double>.times(arg: StructureND<Double>): DoubleTensor

Each element of the tensor arg is multiplied by each element of this tensor. The resulting tensor is returned.

open operator override fun Double.times(arg: StructureND<Double>): DoubleTensor

Each element of the tensor arg is multiplied by this value. The resulting tensor is returned.

open operator override fun StructureND<Double>.times(arg: Double): DoubleTensor

Multiplies the scalar arg by each element of this tensor and returns a new resulting tensor.

timesAssign

open operator override fun Tensor<Double>.timesAssign(arg: StructureND<Double>)

Each element of the tensor arg is multiplied by each element of this tensor.

open operator override fun Tensor<Double>.timesAssign(value: Double)

Multiplies the scalar value by each element of this tensor.

transposed

open override fun StructureND<Double>.transposed(i: Int, j: Int): Tensor<Double>

Returns a tensor that is a transposed version of this tensor. The given dimensions i and j are swapped. For more information: https://pytorch.org/docs/stable/generated/torch.transpose.html

unaryMinus

open operator override fun StructureND<Double>.unaryMinus(): DoubleTensor

Numerical negative, element-wise.

unaryOperation

open fun unaryOperation(operation: String, arg: StructureND<Double>): StructureND<Double>

unaryOperationFunction

open override fun unaryOperationFunction(operation: String): (arg: StructureND<Double>) -> StructureND<Double>

unaryPlus

open operator fun StructureND<Double>.unaryPlus(): StructureND<Double>

value

open override fun StructureND<Double>.value(): Double

Returns a single tensor value of unit dimension. The tensor shape must be equal to 1.

valueOrNull

open override fun StructureND<Double>.valueOrNull(): Double?

Returns a single tensor value of unit dimension if tensor shape equals to 1.

variance

open override fun variance(structureND: StructureND<Double>): Double

open override fun variance(structureND: StructureND<Double>, dim: Int, keepDim: Boolean): Tensor<Double>

Returns the variance of each row of the input tensor in the given dimension dim.

view

open override fun Tensor<Double>.view(shape: ShapeND): DoubleTensor

Returns a new tensor with the same data as the self tensor but of a different shape. The returned tensor shares the same data and must have the same number of elements, but may have a different size For more information: https://pytorch.org/docs/stable/tensor_view.html

viewAs

open override fun Tensor<Double>.viewAs(other: StructureND<Double>): DoubleTensor

View this tensor as the same size as other. this.viewAs(other) is equivalent to this.view(other.shape). For more information: https://pytorch.org/cppdocs/notes/tensor_indexing.html

withBroadcast

@UnstableKMathAPI