skainet-lang-core/sk.ainet.java/TensorJavaOps

TensorJavaOps

Java-friendly static utility class wrapping the most common tensor operations.

All methods are static and accept/return Tensor<*, *> to avoid requiring Java developers to deal with Kotlin generic type parameters.

Example usage from Java:

var c = TensorJavaOps.matmul(a, b);
var d = TensorJavaOps.relu(c);
var e = TensorJavaOps.softmax(d, -1);

Functions

abs

@JvmStatic

fun abs(a: Tensor<*, *>): Tensor<*, *>

Element-wise absolute value.

add

@JvmStatic

fun add(a: Tensor<*, *>, b: Tensor<*, *>): Tensor<*, *>

Element-wise addition of two tensors.

addScalar

@JvmStatic

fun addScalar(a: Tensor<*, *>, value: Number): Tensor<*, *>

Add a scalar value to every element.

clamp

@JvmStatic

fun clamp(a: Tensor<*, *>, minVal: Float, maxVal: Float): Tensor<*, *>

Clamp values to minVal, maxVal.

divide

@JvmStatic

fun divide(a: Tensor<*, *>, b: Tensor<*, *>): Tensor<*, *>

Element-wise division: a / b.

divScalar

@JvmStatic

fun divScalar(a: Tensor<*, *>, value: Number): Tensor<*, *>

Divide every element by a scalar value.

elu

@JvmStatic

@JvmOverloads

fun elu(a: Tensor<*, *>, alpha: Float = 1.0f): Tensor<*, *>

ELU activation.

flatten

@JvmStatic

@JvmOverloads

fun flatten(a: Tensor<*, *>, startDim: Int = 0, endDim: Int = -1): Tensor<*, *>

Flatten the tensor between startDim and endDim.

@JvmStatic

fun ge(a: Tensor<*, *>, value: Float): Tensor<*, *>

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

gelu

@JvmStatic

fun gelu(a: Tensor<*, *>): Tensor<*, *>

GELU activation (Gaussian Error Linear Unit).

leakyRelu

@JvmStatic

@JvmOverloads

fun leakyRelu(a: Tensor<*, *>, negativeSlope: Float = 0.01f): Tensor<*, *>

Leaky ReLU activation.

logSoftmax

@JvmStatic

@JvmOverloads

fun logSoftmax(a: Tensor<*, *>, dim: Int = -1): Tensor<*, *>

Log-softmax along the given dimension.

@JvmStatic

fun lt(a: Tensor<*, *>, value: Float): Tensor<*, *>

Element-wise less-than comparison.

matmul

@JvmStatic

fun matmul(a: Tensor<*, *>, b: Tensor<*, *>): Tensor<*, *>

Matrix multiplication of two tensors.

mean

@JvmStatic

fun mean(a: Tensor<*, *>, dim: Int? = null): Tensor<*, *>

Mean of all elements, or mean along a dimension.

mulScalar

@JvmStatic

fun mulScalar(a: Tensor<*, *>, value: Number): Tensor<*, *>

Multiply every element by a scalar value.

multiply

@JvmStatic

fun multiply(a: Tensor<*, *>, b: Tensor<*, *>): Tensor<*, *>

Element-wise multiplication of two tensors.

narrow

@JvmStatic

fun narrow(a: Tensor<*, *>, dim: Int, start: Int, length: Int): Tensor<*, *>

Extract a narrow slice along a dimension.

relu

@JvmStatic

fun relu(a: Tensor<*, *>): Tensor<*, *>

ReLU activation: max(0, x).

reshape

@JvmStatic

fun reshape(a: Tensor<*, *>, newShape: IntArray): Tensor<*, *>

Reshape the tensor to the given dimensions.

sigmoid

@JvmStatic

fun sigmoid(a: Tensor<*, *>): Tensor<*, *>

Sigmoid activation: 1 / (1 + exp(-x)).

sign

@JvmStatic

fun sign(a: Tensor<*, *>): Tensor<*, *>

Element-wise sign (-1, 0, or 1).

silu

@JvmStatic

fun silu(a: Tensor<*, *>): Tensor<*, *>

SiLU (Swish) activation: x * sigmoid(x).

softmax

@JvmStatic

@JvmOverloads

fun softmax(a: Tensor<*, *>, dim: Int = -1): Tensor<*, *>

Softmax along the given dimension.

sqrt

@JvmStatic

fun sqrt(a: Tensor<*, *>): Tensor<*, *>

Element-wise square root.

squeeze

@JvmStatic

fun squeeze(a: Tensor<*, *>, dim: Int? = null): Tensor<*, *>

Remove dimensions of size 1.

subScalar

@JvmStatic

fun subScalar(a: Tensor<*, *>, value: Number): Tensor<*, *>

Subtract a scalar value from every element.

subtract

@JvmStatic

fun subtract(a: Tensor<*, *>, b: Tensor<*, *>): Tensor<*, *>

Element-wise subtraction: a - b.

sum

@JvmStatic

fun sum(a: Tensor<*, *>, dim: Int? = null): Tensor<*, *>

Sum all elements, or sum along a dimension if dim is specified.

transpose

@JvmStatic

fun transpose(a: Tensor<*, *>): Tensor<*, *>

Transpose a 2D tensor.

tril

@JvmStatic

@JvmOverloads

fun tril(a: Tensor<*, *>, k: Int = 0): Tensor<*, *>

Returns the lower triangular part of a matrix.

unsqueeze

@JvmStatic

fun unsqueeze(a: Tensor<*, *>, dim: Int): Tensor<*, *>

Add a dimension of size 1 at the given position.

variance

@JvmStatic

fun variance(a: Tensor<*, *>, dim: Int? = null): Tensor<*, *>

Variance of all elements, or variance along a dimension.