Trait TensorOpsExt 

pub trait TensorOpsExt {
    // Required methods
    fn convert<B: TensorBackend>(
        &self,
        to: DType,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn cast<B: TensorBackend>(
        &self,
        to: DType,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn add<B: TensorBackend>(
        &self,
        rhs: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn sub<B: TensorBackend>(
        &self,
        rhs: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn mul<B: TensorBackend>(
        &self,
        rhs: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn div<B: TensorBackend>(
        &self,
        rhs: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn rem<B: TensorBackend>(
        &self,
        rhs: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn pow<B: TensorBackend>(
        &self,
        rhs: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn maximum<B: TensorBackend>(
        &self,
        rhs: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn minimum<B: TensorBackend>(
        &self,
        rhs: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn neg<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn abs<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn sign<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn conj<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn exp<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn log<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn sin<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn cos<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn tanh<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn sqrt<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn rsqrt<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn expm1<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn log1p<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>;
    fn compare<B: TensorBackend>(
        &self,
        rhs: &Tensor,
        dir: CompareDir,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn where_select<B: TensorBackend>(
        &self,
        on_true: &Tensor,
        on_false: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn clamp<B: TensorBackend>(
        &self,
        lower: &Tensor,
        upper: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn matmul<B: TensorBackend>(
        &self,
        rhs: &Tensor,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn reshape<B: TensorBackend>(
        &self,
        shape: &[usize],
        backend: &mut B,
    ) -> Result<Tensor>;
    fn transpose<B: TensorBackend>(
        &self,
        perm: &[usize],
        backend: &mut B,
    ) -> Result<Tensor>;
    fn reduce_sum<B: TensorBackend>(
        &self,
        axes: &[usize],
        backend: &mut B,
    ) -> Result<Tensor>;
}

Backend-explicit concrete tensor operations.

Tensor is owned by tenferro-tensor, so tenferro-runtime exposes these operations as a crate-root extension trait rather than as inherent methods.

Public API rationale

This trait is intentionally public: it is the supported non-AD concrete tensor operation surface for downstream users who want to run operations on an explicit backend. The old public module/free-function surface was removed; the private tensor module now contains implementation helpers only and must not be treated as a compatibility API.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorOpsExt};

let mut backend = CpuBackend::new();
let a = Tensor::from_vec_col_major(vec![2, 2], vec![1.0_f64; 4]).unwrap();
let b = Tensor::from_vec_col_major(vec![2, 2], vec![2.0_f64; 4]).unwrap();
let c = a.matmul(&b, &mut backend).unwrap();
assert_eq!(c.shape(), &[2, 2]);

Required Methods

fn convert<B: TensorBackend>( &self, to: DType, backend: &mut B, ) -> Result<Tensor>

Convert to a different dtype using the checked conversion lattice.

fn cast<B: TensorBackend>(&self, to: DType, backend: &mut B) -> Result<Tensor>

Cast to a different dtype using explicit lossy projection.

fn add<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise addition with NumPy-style broadcasting.

fn sub<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise subtraction with NumPy-style broadcasting.

fn mul<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise multiplication with NumPy-style broadcasting.

fn div<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise division with NumPy-style broadcasting.

fn rem<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise remainder with NumPy-style broadcasting.

fn pow<B: TensorBackend>(&self, rhs: &Tensor, backend: &mut B) -> Result<Tensor>

Elementwise power with NumPy-style broadcasting.

fn maximum<B: TensorBackend>( &self, rhs: &Tensor, backend: &mut B, ) -> Result<Tensor>

Elementwise maximum with NumPy-style broadcasting.

fn minimum<B: TensorBackend>( &self, rhs: &Tensor, backend: &mut B, ) -> Result<Tensor>

Elementwise minimum with NumPy-style broadcasting.

fn neg<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise negation.

fn abs<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise absolute value.

fn sign<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise sign.

fn conj<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise complex conjugate.

fn exp<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise exponential.

fn log<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise natural logarithm.

fn sin<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise sine.

fn cos<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise cosine.

fn tanh<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise hyperbolic tangent.

fn sqrt<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise square root.

fn rsqrt<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise reciprocal square root.

fn expm1<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise exp(x) - 1.

fn log1p<B: TensorBackend>(&self, backend: &mut B) -> Result<Tensor>

Elementwise log(1 + x).

fn compare<B: TensorBackend>( &self, rhs: &Tensor, dir: CompareDir, backend: &mut B, ) -> Result<Tensor>

Elementwise comparison with NumPy-style broadcasting.

fn where_select<B: TensorBackend>( &self, on_true: &Tensor, on_false: &Tensor, backend: &mut B, ) -> Result<Tensor>

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

fn clamp<B: TensorBackend>( &self, lower: &Tensor, upper: &Tensor, backend: &mut B, ) -> Result<Tensor>

Clamp values elementwise between lower and upper bounds.

fn matmul<B: TensorBackend>( &self, rhs: &Tensor, backend: &mut B, ) -> Result<Tensor>

Rank-2 matrix multiplication.

fn reshape<B: TensorBackend>( &self, shape: &[usize], backend: &mut B, ) -> Result<Tensor>

Reshape without changing element order.

fn transpose<B: TensorBackend>( &self, perm: &[usize], backend: &mut B, ) -> Result<Tensor>

Permute axes.

fn reduce_sum<B: TensorBackend>( &self, axes: &[usize], backend: &mut B, ) -> Result<Tensor>

Sum over one or more axes.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl TensorOpsExt for Tensor