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<T>.div(k: Number): StructureND<T>

abstract operator override fun T.div(arg: StructureND<T>): Tensor<T>

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

abstract operator override fun StructureND<T>.div(arg: T): Tensor<T>

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

abstract operator override fun StructureND<T>.div(arg: StructureND<T>): Tensor<T>

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

divAssign

abstract operator fun Tensor<T>.divAssign(value: T)

Divides by the scalar value each element of this tensor.

abstract operator fun Tensor<T>.divAssign(arg: StructureND<T>)

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

divide

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

dot

abstract infix fun StructureND<T>.dot(other: StructureND<T>): Tensor<T>

Matrix product of two tensors.

exp

abstract override fun exp(arg: StructureND<T>): StructureND<T>

export

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

floor

abstract fun floor(structureND: StructureND<T>): Tensor<T>

getFeature

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

getTensor

abstract fun Tensor<T>.getTensor(i: Int): Tensor<T>

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

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

invoke

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

abstract override fun ln(arg: StructureND<T>): StructureND<T>

map

open fun StructureND<T>.map(transform: A.(T) -> T): StructureND<T>

mapIndexed

open fun StructureND<T>.mapIndexed(transform: A.(index: IntArray, T) -> T): StructureND<T>

max

abstract fun StructureND<T>.max(): T?

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

abstract fun StructureND<T>.max(dim: Int, keepDim: Boolean): Tensor<T>

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

mean

abstract fun mean(structureND: StructureND<T>): T

abstract fun mean(structureND: StructureND<T>, dim: Int, keepDim: Boolean): Tensor<T>

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

min

abstract fun StructureND<T>.min(): T?

abstract fun StructureND<T>.min(dim: Int, keepDim: Boolean): Tensor<T>

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

minus

abstract operator override fun T.minus(arg: StructureND<T>): Tensor<T>

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

abstract operator override fun StructureND<T>.minus(arg: T): Tensor<T>

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

abstract operator override fun StructureND<T>.minus(arg: StructureND<T>): Tensor<T>

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

minusAssign

abstract operator fun Tensor<T>.minusAssign(value: T)

Subtracts the scalar value from each element of this tensor.

abstract operator fun Tensor<T>.minusAssign(arg: StructureND<T>)

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

multiply

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

plus

abstract operator override fun T.plus(arg: StructureND<T>): Tensor<T>

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

abstract operator override fun StructureND<T>.plus(arg: T): Tensor<T>

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

abstract operator override fun StructureND<T>.plus(arg: StructureND<T>): Tensor<T>

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

plusAssign

abstract operator fun Tensor<T>.plusAssign(value: T)

Adds the scalar value to each element of this tensor.

abstract operator fun Tensor<T>.plusAssign(arg: StructureND<T>)

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

pow

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

power

abstract fun power(arg: StructureND<T>, pow: Number): StructureND<T>

scale

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

sin

abstract override fun sin(arg: StructureND<T>): StructureND<T>

sinh

abstract override fun sinh(arg: StructureND<T>): StructureND<T>

sqrt

abstract override fun sqrt(arg: StructureND<T>): Tensor<T>

std

abstract fun std(structureND: StructureND<T>): T

abstract fun std(structureND: StructureND<T>, dim: Int, keepDim: Boolean): Tensor<T>

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

structureND

abstract fun structureND(shape: ShapeND, initializer: A.(IntArray) -> T): StructureND<T>

sum

abstract fun StructureND<T>.sum(): T

abstract fun StructureND<T>.sum(dim: Int, keepDim: Boolean): Tensor<T>

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

tan

abstract override fun tan(arg: StructureND<T>): Tensor<T>

tanh

abstract override fun tanh(arg: StructureND<T>): Tensor<T>

times

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

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

abstract operator override fun T.times(arg: StructureND<T>): Tensor<T>

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

abstract operator override fun StructureND<T>.times(arg: T): Tensor<T>

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

abstract operator override fun StructureND<T>.times(arg: StructureND<T>): Tensor<T>

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

timesAssign

abstract operator fun Tensor<T>.timesAssign(value: T)

Multiplies the scalar value by each element of this tensor.

abstract operator fun Tensor<T>.timesAssign(arg: StructureND<T>)

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

transposed

abstract fun StructureND<T>.transposed(i: Int = shape.size - 2, j: Int = shape.size - 1): Tensor<T>

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

abstract operator override fun StructureND<T>.unaryMinus(): Tensor<T>

Numerical negative, element-wise.

unaryOperation

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

unaryOperationFunction

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

unaryPlus

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

value

open fun StructureND<T>.value(): T

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

valueOrNull

abstract fun StructureND<T>.valueOrNull(): T?

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

variance

abstract fun variance(structureND: StructureND<T>): T

abstract fun variance(structureND: StructureND<T>, dim: Int, keepDim: Boolean): Tensor<T>

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

view

abstract fun Tensor<T>.view(shape: ShapeND): Tensor<T>

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

abstract fun Tensor<T>.viewAs(other: StructureND<T>): Tensor<T>

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

zip

open fun zip(left: StructureND<T>, right: StructureND<T>, transform: A.(T, T) -> T): StructureND<T>

Properties

bufferFactory

open val bufferFactory: MutableBufferFactory<StructureND<T>>

elementAlgebra

abstract val elementAlgebra: A