Enum Tensor 

pub enum Tensor {
    F32(TypedTensor<f32>),
    F64(TypedTensor<f64>),
    I32(TypedTensor<i32>),
    I64(TypedTensor<i64>),
    Bool(TypedTensor<bool>),
    C32(TypedTensor<Complex<f32>>),
    C64(TypedTensor<Complex<f64>>),
}

Dynamic tensor enum over the supported scalar types.

The enum keeps dtype dynamic and rank dynamic. Use TypedTensor<T, R> directly when the scalar type or rank should be represented in Rust’s type system.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let t = Tensor::F64(TypedTensor::from_vec_col_major(vec![2], vec![1.0, 2.0]).unwrap());
assert_eq!(t.shape(), &[2]);

let erased = Tensor::from_vec_col_major(vec![1, 2], vec![1.0_f64, 2.0]).unwrap();
assert_eq!(erased.shape().len(), 2);

Variants

F32(TypedTensor<f32>)

F64(TypedTensor<f64>)

I32(TypedTensor<i32>)

I64(TypedTensor<i64>)

Bool(TypedTensor<bool>)

C32(TypedTensor<Complex<f32>>)

C64(TypedTensor<Complex<f64>>)

Implementations

impl Tensor

pub fn linear_offset(&self, indices: &[usize]) -> Result<usize, Error>

Compute the linear physical-buffer offset for a logical index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 3], vec![0.0_f64; 6]).unwrap();
assert_eq!(t.linear_offset(&[1, 2])?, 5);

Errors

Returns [crate::Error::Validation] containing [tenferro_tensor_core::ValidationError::RankMismatch] when indices has a rank different from the tensor, [tenferro_tensor_core::ValidationError::InvalidArgument] when an index is outside its axis extent, or [tenferro_tensor_core::ValidationError::IntegerOverflow] when checked offset arithmetic overflows.

pub fn linear_offset2(&self, i: usize, j: usize) -> Result<usize, Error>

Compute the linear physical-buffer offset for a rank-2 logical index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 3], vec![0.0_f64; 6]).unwrap();
assert_eq!(t.linear_offset2(1, 2)?, 5);

Errors

Returns [crate::Error::Validation] containing [tenferro_tensor_core::ValidationError::RankMismatch] when the tensor rank is not two, [tenferro_tensor_core::ValidationError::InvalidArgument] when i or j is outside its axis extent, or [tenferro_tensor_core::ValidationError::IntegerOverflow] when checked offset arithmetic overflows.

pub fn linear_offset3( &self, i: usize, j: usize, k: usize, ) -> Result<usize, Error>

Compute the linear physical-buffer offset for a rank-3 logical index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 3, 2], vec![0.0_f64; 12]).unwrap();
assert_eq!(t.linear_offset3(1, 2, 1)?, 11);

Errors

Returns [crate::Error::Validation] containing [tenferro_tensor_core::ValidationError::RankMismatch] when the tensor rank is not three, [tenferro_tensor_core::ValidationError::InvalidArgument] when i, j, or k is outside its axis extent, or [tenferro_tensor_core::ValidationError::IntegerOverflow] when checked offset arithmetic overflows.

pub fn get<T>(&self, indices: &[usize]) -> Result<&T, Error>

where T: TensorScalar,

Borrow a single typed element by multi-index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
assert_eq!(t.get::<f64>(&[1])?, &2.0);
assert!(t.get::<f32>(&[1]).is_err());

Errors

Returns [crate::Error::Validation] containing [tenferro_tensor_core::ValidationError::RankMismatch] or [tenferro_tensor_core::ValidationError::InvalidArgument] for an invalid index, [tenferro_tensor_core::ValidationError::DTypeMismatch] when T does not match the tensor dtype, or [crate::Error::RuntimeState] for a device-backed tensor.

pub fn get_mut<T>(&mut self, indices: &[usize]) -> Result<&mut T, Error>

where T: TensorScalar,

Mutably borrow a single typed element by multi-index.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
*t.get_mut::<f64>(&[0])? = 2.0;
assert_eq!(t.as_slice::<f64>()?, &[2.0]);

Errors

Returns [crate::Error::Validation] containing [tenferro_tensor_core::ValidationError::RankMismatch] or [tenferro_tensor_core::ValidationError::InvalidArgument] for an invalid index, [tenferro_tensor_core::ValidationError::DTypeMismatch] when T does not match the tensor dtype, or [crate::Error::RuntimeState] for a device-backed tensor.

pub unsafe fn get_unchecked<T>(&self, indices: &[usize]) -> Result<&T, Error>

where T: TensorScalar,

Try to borrow a single typed element by multi-index without release-mode bounds checks.

Debug builds still validate the rank and bounds. Dtype and backend host-access failures are still reported as errors.

Safety

indices must have the same rank as this tensor and every index must be in bounds.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
assert_eq!(unsafe { *t.get_unchecked::<f64>(&[1])? }, 2.0);

Errors

Returns [crate::Error::RuntimeState] for a device-backed tensor and [tenferro_tensor_core::ValidationError::DTypeMismatch] when T does not match the tensor dtype.

Panics

May panic if the unsafe rank/bounds precondition is violated and the checked linear-offset calculation overflows.

pub unsafe fn get_unchecked_mut<T>( &mut self, indices: &[usize], ) -> Result<&mut T, Error>

where T: TensorScalar,

Try to mutably borrow a single typed element by multi-index without release-mode bounds checks.

Debug builds still validate the rank and bounds. Dtype and backend host-access failures are still reported as errors.

Safety

indices must have the same rank as this tensor and every index must be in bounds.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
unsafe {
    *t.get_unchecked_mut::<f64>(&[0])? = 2.0;
}
assert_eq!(t.as_slice::<f64>()?, &[2.0]);

Errors

Returns [crate::Error::RuntimeState] for a device-backed tensor and [tenferro_tensor_core::ValidationError::DTypeMismatch] when T does not match the tensor dtype.

Panics

May panic if the unsafe rank/bounds precondition is violated and the checked linear-offset calculation overflows.

pub fn as_slice_mut<T>(&mut self) -> Result<&mut [T], Error>

where T: TensorScalar,

Mutably borrow the host data as a typed slice.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
t.as_slice_mut::<f64>()?[0] = 3.0;
assert_eq!(t.as_slice::<f64>()?, &[3.0, 2.0]);
assert!(t.as_slice_mut::<f32>().is_err());

Errors

Returns [tenferro_tensor_core::ValidationError::DTypeMismatch] when T does not match the tensor dtype, or [crate::Error::RuntimeState] when the tensor is backed by a device buffer.

pub fn iter<T>(&self) -> Result<Iter<'_, T>, Error>

where T: TensorScalar,

Iterate over the contiguous host buffer in physical memory order.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let sum: f64 = t.iter::<f64>()?.copied().sum();
assert_eq!(sum, 3.0);
assert!(t.iter::<f32>().is_err());

Errors

Returns [tenferro_tensor_core::ValidationError::DTypeMismatch] when T does not match the tensor dtype, or [crate::Error::RuntimeState] when the tensor is backed by a device buffer.

pub fn iter_mut<T>(&mut self) -> Result<IterMut<'_, T>, Error>

where T: TensorScalar,

Mutably iterate over the contiguous host buffer in physical memory order.

Examples

use tenferro_tensor::Tensor;

let mut t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
for value in t.iter_mut::<f64>()? {
    *value += 1.0;
}
assert_eq!(t.as_slice::<f64>()?, &[2.0, 3.0]);
assert!(t.iter_mut::<f32>().is_err());

Errors

Returns [tenferro_tensor_core::ValidationError::DTypeMismatch] when T does not match the tensor dtype, or [crate::Error::RuntimeState] when the tensor is backed by a device buffer.

impl Tensor

pub fn index_select( &self, axis: isize, positions: &[usize], session: &mut dyn BackendSession, ) -> Result<Tensor, Error>

Select entries from one axis using host-known positions.

Examples

use tenferro_tensor::{BackendSession, Tensor};

fn select_last_axis(
    session: &mut dyn BackendSession,
    x: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    x.index_select(-1, &[2, 0], session)
}

Errors

Returns [crate::Error::Validation] with a typed shape, axis, or argument source when the inputs cannot be packed without violating their metadata.

pub fn stack( tensors: &[&Tensor], dim: isize, session: &mut dyn BackendSession, ) -> Result<Tensor, Error>

Stack tensors along a newly inserted axis.

Examples

use tenferro_tensor::{BackendSession, Tensor};

fn stack_scalars(
    session: &mut dyn BackendSession,
    a: &Tensor,
    b: &Tensor,
) -> tenferro_tensor::Result<Tensor> {
    Tensor::stack(&[a, b], -1, session)
}

Errors

Returns [crate::Error::Validation] with a typed shape, axis, or argument source when the inputs cannot be packed without violating their metadata.

impl Tensor

pub fn as_real_view(&self) -> Result<TensorView<'_>, Error>

Borrow a complex tensor as its sealed interleaved real representation.

Errors

Returns [crate::Error::Unsupported] for a non-complex dtype and [ValidationError::ViewOutOfBounds] or [ValidationError::InvalidArgument] for invalid layout metadata.

pub fn as_real_view_mut(&mut self) -> Result<TensorViewMut<'_>, Error>

Borrow a complex tensor mutably as its sealed interleaved real representation.

Errors

Returns [crate::Error::Unsupported] for a non-complex dtype and [ValidationError::ViewOutOfBounds] or [ValidationError::InvalidArgument] for invalid layout metadata.

pub fn into_real(self) -> Result<Tensor, ReinterpretError<Tensor>>

Consume a complex tensor and reinterpret its owner as real without copying.

Errors

Returns [ReinterpretError::error] containing [ValidationError::InvalidArgument] or [ValidationError::ViewOutOfBounds] while retaining the unchanged owner.

pub fn as_complex_view(&self) -> Result<TensorView<'_>, Error>

Borrow an interleaved real tensor as its sealed complex representation.

Errors

Returns [crate::Error::Unsupported] for a non-real dtype and [ValidationError::ViewOutOfBounds] or [ValidationError::InvalidArgument] for invalid layout metadata.

pub fn as_complex_view_mut(&mut self) -> Result<TensorViewMut<'_>, Error>

Borrow an interleaved real tensor mutably as its sealed complex representation.

Errors

Returns [crate::Error::Unsupported] for a non-real dtype and [ValidationError::ViewOutOfBounds] or [ValidationError::InvalidArgument] for invalid layout metadata.

pub fn into_complex(self) -> Result<Tensor, ReinterpretError<Tensor>>

Consume a real tensor and reinterpret its owner as complex without copying.

Errors

Returns [ReinterpretError::error] containing [ValidationError::InvalidArgument] or [ValidationError::ViewOutOfBounds] while retaining the unchanged owner.

pub fn duplicate(&self) -> Result<Tensor, Error>

Make an explicit owning copy of this dtype-erased tensor.

Errors

Returns [crate::Error::RuntimeState] or [crate::Error::Unsupported] when the selected backend/storage owner cannot be duplicated.

pub fn from_vec_col_major<T>( shape: impl IntoShapeVec, data: Vec<T>, ) -> Result<Tensor, Error>

where T: TensorScalar,

Create a tensor from a shape and column-major flat data.

This is the Tensor-level equivalent of TypedTensor::<T>::from_vec_col_major.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2, 2], vec![1.0_f64, 3.0, 2.0, 4.0]).unwrap();
assert_eq!(t.shape(), &[2, 2]);
assert_eq!(t.as_slice::<f64>().unwrap(), &[1.0, 3.0, 2.0, 4.0]);

Errors

Returns [crate::Error::Validation] with [tenferro_tensor_core::ValidationError::ShapeDataLengthMismatch] when the shape product differs from data.len(), or [tenferro_tensor_core::ValidationError::IntegerOverflow] when shape arithmetic overflows.

pub fn shape(&self) -> &[usize]

Tensor shape.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let t = Tensor::F64(TypedTensor::from_vec_col_major(vec![2], vec![1.0, 2.0]).unwrap());
assert_eq!(t.shape(), &[2]);

pub fn dtype(&self) -> DType

Tensor dtype tag.

Examples

use tenferro_tensor::{DType, Tensor, TypedTensor};

let t = Tensor::F64(TypedTensor::from_vec_col_major(vec![], vec![1.0]).unwrap());
assert_eq!(t.dtype(), DType::F64);

pub fn placement(&self) -> &Placement

Return placement metadata for this dtype-erased tensor.

Examples

use tenferro_tensor::{MemoryKind, Tensor};

let t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
assert_eq!(t.placement().memory_kind, MemoryKind::UnpinnedHost);

pub fn is_backend_buffer(&self) -> bool

Return whether this tensor is backed by backend-native storage.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![1], vec![1.0_f64]).unwrap();
assert!(!t.is_backend_buffer());

pub fn layout_linear_offset(&self, indices: &[usize]) -> Result<usize, Error>

Compute the physical element offset for a logical index.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert_eq!(t.layout_linear_offset(&[1])?, 1);

Errors

Returns [crate::Error::Validation] with [tenferro_tensor_core::ValidationError::RankMismatch] when indices has the wrong rank, [tenferro_tensor_core::ValidationError::InvalidArgument] when an index is outside its axis extent, or [tenferro_tensor_core::ValidationError::IntegerOverflow] when offset arithmetic overflows.

pub fn is_col_major_contiguous(&self) -> Result<bool, Error>

Return whether this tensor is compact column-major.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert!(t.is_col_major_contiguous()?);

Errors

Returns [crate::Error::Validation] with [tenferro_tensor_core::ValidationError::IntegerOverflow] when compactness arithmetic overflows.

pub fn layout_summary(&self) -> String

Return a compact string summary of this tensor’s layout metadata.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
assert!(t.layout_summary().contains("shape=[2]"));

pub fn assert_col_major_contiguous(&self) -> Result<(), Error>

Assert this tensor is compact column-major.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0])?;
t.assert_col_major_contiguous()?;

Errors

Returns [crate::Error::Validation] with [tenferro_tensor_core::ValidationError::IntegerOverflow] when compactness arithmetic overflows, or [tenferro_tensor_core::ValidationError::InvalidArgument] when the tensor is not compact column-major.

pub fn as_slice<T>(&self) -> Result<&[T], Error>

where T: TensorScalar,

Try to borrow the host data as a typed slice.

Returns an error if the tensor dtype does not match T.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let t = Tensor::F64(TypedTensor::from_vec_col_major(vec![3], vec![1.0, 2.0, 3.0]).unwrap());
assert_eq!(t.as_slice::<f64>().unwrap(), [1.0, 2.0, 3.0].as_slice());
assert!(t.as_slice::<f32>().is_err());

Errors

Returns [crate::Error::Validation] with [tenferro_tensor_core::ValidationError::DTypeMismatch] when T does not match the tensor dtype, or [crate::Error::RuntimeState] when the matching tensor uses backend storage that has not been downloaded.

pub fn into_vec_col_major<T>(self) -> Result<(Vec<usize>, Vec<T>), Error>

where T: TensorScalar,

Consume this tensor and return its owned column-major buffer when the dtype matches.

Examples

use tenferro_tensor::Tensor;

let t = Tensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
assert_eq!(t.into_vec_col_major::<f64>().unwrap().1, vec![2.0]);

Errors

Returns [crate::Error::Validation] with [tenferro_tensor_core::ValidationError::DTypeMismatch] when T does not match the tensor dtype, or [crate::Error::RuntimeState] when the matching tensor uses backend storage that has not been downloaded.

Trait Implementations

impl Debug for Tensor

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<TypedTensor<Complex<f32>>> for Tensor

Wrap a Complex32 TypedTensor into the corresponding Tensor variant.

Examples

use num_complex::Complex32;
use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(
    vec![1],
    vec![Complex32::new(1.0, 2.0)],
).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[1]);

fn from(t: TypedTensor<Complex<f32>>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<Complex<f64>>> for Tensor

Wrap a Complex64 TypedTensor into the corresponding Tensor variant.

Examples

use num_complex::Complex64;
use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(
    vec![1],
    vec![Complex64::new(1.0, 2.0)],
).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[1]);

fn from(t: TypedTensor<Complex<f64>>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<bool>> for Tensor

Wrap a bool TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{DType, Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![true, false]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.dtype(), DType::Bool);
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<bool>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<f32>> for Tensor

Wrap an f32 TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1.0_f32, 2.0]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<f32>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<f64>> for Tensor

Wrap an f64 TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<f64>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<i32>> for Tensor

Wrap an i32 TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{DType, Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1_i32, 2]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.dtype(), DType::I32);
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<i32>) -> Tensor

Converts to this type from the input type.

impl From<TypedTensor<i64>> for Tensor

Wrap an i64 TypedTensor into the corresponding Tensor variant.

Examples

use tenferro_tensor::{DType, Tensor, TypedTensor};

let typed = TypedTensor::from_vec_col_major(vec![2], vec![1_i64, 2]).unwrap();
let tensor: Tensor = typed.into();
assert_eq!(tensor.dtype(), DType::I64);
assert_eq!(tensor.shape(), &[2]);

fn from(t: TypedTensor<i64>) -> Tensor

Converts to this type from the input type.

impl TensorSessionOpsExt for Tensor

fn add(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise addition with NumPy-style broadcasting inside a session.

fn mul(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise multiplication with NumPy-style broadcasting inside a session.

fn exp(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise exponential inside a session.

fn reduce_sum( &self, axes: &[usize], session: &mut dyn BackendSession, ) -> Result<Tensor>

Sum over one or more axes inside a session.

fn convert(&self, to: DType, session: &mut dyn BackendSession) -> Result<Tensor>

Convert to a different dtype using the checked conversion lattice inside a session.

fn cast(&self, to: DType, session: &mut dyn BackendSession) -> Result<Tensor>

Cast to a different dtype using explicit lossy projection inside a session.

fn sub(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise subtraction with NumPy-style broadcasting inside a session.

fn div(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise division with NumPy-style broadcasting inside a session.

fn rem(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise remainder with NumPy-style broadcasting inside a session.

fn pow(&self, rhs: &Tensor, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise power with NumPy-style broadcasting inside a session.

fn maximum( &self, rhs: &Tensor, session: &mut dyn BackendSession, ) -> Result<Tensor>

Elementwise maximum with NumPy-style broadcasting inside a session.

fn minimum( &self, rhs: &Tensor, session: &mut dyn BackendSession, ) -> Result<Tensor>

Elementwise minimum with NumPy-style broadcasting inside a session.

fn neg(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise negation inside a session.

fn abs(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise absolute value inside a session.

fn sign(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise sign inside a session.

fn conj(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise complex conjugate inside a session.

fn log(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise natural logarithm inside a session.

fn expm1(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise exp(x) - 1 inside a session.

fn log1p(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise log(1 + x) inside a session.

fn sin(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise sine inside a session.

fn cos(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise cosine inside a session.

fn tanh(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise hyperbolic tangent inside a session.

fn sqrt(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise square root inside a session.

fn rsqrt(&self, session: &mut dyn BackendSession) -> Result<Tensor>

Elementwise reciprocal square root inside a session.

fn compare( &self, rhs: &Tensor, dir: CompareDir, session: &mut dyn BackendSession, ) -> Result<Tensor>

Elementwise comparison with NumPy-style broadcasting inside a session.

fn where_select( &self, on_true: &Tensor, on_false: &Tensor, session: &mut dyn BackendSession, ) -> Result<Tensor>

Select values from on_true or on_false using this tensor as condition inside a session.

fn clamp( &self, lower: &Tensor, upper: &Tensor, session: &mut dyn BackendSession, ) -> Result<Tensor>

Clamp values elementwise between lower and upper bounds inside a session.

fn matmul( &self, rhs: &Tensor, session: &mut dyn BackendSession, ) -> Result<Tensor>

Rank-2 matrix multiplication inside a session.

fn reshape( &self, shape: &[usize], session: &mut dyn BackendSession, ) -> Result<Tensor>

Reshape without changing element order inside a session.

fn transpose( &self, perm: &[usize], session: &mut dyn BackendSession, ) -> Result<Tensor>

Permute axes inside a session.