Trait TensorSessionOpsExt 

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

Required Methods

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

Elementwise addition with NumPy-style broadcasting inside a session.

The broadcast (reshape + broadcast_in_dim, or a copy when shapes already match) and the add itself all run in the caller’s session; this op never enters a session of its own.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let a = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let b = Tensor::from_vec_col_major(vec![2], vec![3.0_f64, 4.0]).unwrap();
let sum = backend.with_backend_session(|session| a.add(&b, session)).unwrap();
assert_eq!(sum.as_slice::<f64>().unwrap(), &[4.0, 6.0]);

Errors

Returns [tenferro_tensor::Error::Validation] with a ShapeMismatch or DTypeMismatch payload when operands are incompatible, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise multiplication with NumPy-style broadcasting inside a session.

Like Self::add, broadcast and multiply run in the one session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let a = Tensor::from_vec_col_major(vec![1], vec![2.0_f64]).unwrap();
let b = Tensor::from_vec_col_major(vec![4], vec![3.0_f64; 4]).unwrap();
let product = backend.with_backend_session(|session| a.mul(&b, session)).unwrap();
assert_eq!(product.as_slice::<f64>().unwrap(), &[6.0; 4]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch or DTypeMismatch for incompatible operands, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise exponential inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![0.0_f64, 1.0]).unwrap();
let y = backend.with_backend_session(|session| x.exp(session)).unwrap();
let y = y.as_slice::<f64>().unwrap();
assert!((y[0] - 1.0).abs() < 1.0e-12);
assert!((y[1] - std::f64::consts::E).abs() < 1.0e-12);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Sum over one or more axes inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2, 3], vec![1.0_f64; 6]).unwrap();
let sums = backend.with_backend_session(|session| x.reduce_sum(&[1], session)).unwrap();
assert_eq!(sums.as_slice::<f64>().unwrap(), &[3.0, 3.0]);

Errors

Returns [tenferro_tensor::Error::Validation] with AxisOutOfBounds or DuplicateAxis for invalid reductions, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

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

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{DType, Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let y = backend.with_backend_session(|session| x.convert(DType::C64, session)).unwrap();
assert_eq!(y.dtype(), DType::C64);

Errors

Returns [tenferro_tensor::Error::UnsupportedDTypeConversion] when the conversion is outside the checked lattice, [tenferro_tensor::Error::Validation] with DTypeMismatch or InvalidArgument for invalid tensor metadata, or [tenferro_tensor::Error::BackendSource] when the backend reports a typed failure.

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

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

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{DType, Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![1.2_f64, -2.8]).unwrap();
let y = backend.with_backend_session(|session| x.cast(DType::I32, session)).unwrap();
assert_eq!(y.as_slice::<i32>().unwrap(), &[1, -2]);

Errors

Returns [tenferro_tensor::Error::UnsupportedDTypeConversion] when the requested cast is unsupported, [tenferro_tensor::Error::Validation] with DTypeMismatch or InvalidArgument for invalid tensor metadata, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise subtraction with NumPy-style broadcasting inside a session.

Like Self::add, the broadcast and the subtraction run in the one session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let a = Tensor::from_vec_col_major(vec![2], vec![2.0_f64, 4.0]).unwrap();
let b = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 8.0]).unwrap();
let y = backend.with_backend_session(|session| a.sub(&b, session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[1.0, -4.0]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch or DTypeMismatch for incompatible operands, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise division with NumPy-style broadcasting inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let a = Tensor::from_vec_col_major(vec![2], vec![4.0_f64, 8.0]).unwrap();
let b = Tensor::from_vec_col_major(vec![2], vec![2.0_f64, 4.0]).unwrap();
let y = backend.with_backend_session(|session| a.div(&b, session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[2.0, 2.0]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch or DTypeMismatch for shape/dtype incompatibility, [tenferro_tensor::Error::Extension] with a numerical classification for a detected zero divisor, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise remainder with NumPy-style broadcasting inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let a = Tensor::from_vec_col_major(vec![2], vec![5.0_f64, 7.0]).unwrap();
let b = Tensor::from_vec_col_major(vec![2], vec![2.0_f64, 4.0]).unwrap();
let y = backend.with_backend_session(|session| a.rem(&b, session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[1.0, 3.0]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch or DTypeMismatch for shape/dtype incompatibility, a numerical [tenferro_tensor::Error::Extension] for a detected zero divisor, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise power with NumPy-style broadcasting inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let a = Tensor::from_vec_col_major(vec![2], vec![2.0_f64, 3.0]).unwrap();
let b = Tensor::from_vec_col_major(vec![2], vec![3.0_f64, 2.0]).unwrap();
let y = backend.with_backend_session(|session| a.pow(&b, session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[8.0, 9.0]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch or DTypeMismatch for incompatible metadata, a numerical [tenferro_tensor::Error::Extension] for a detected negative integer exponent, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise maximum with NumPy-style broadcasting inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let a = Tensor::from_vec_col_major(vec![2], vec![2.0_f64, 4.0]).unwrap();
let b = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 8.0]).unwrap();
let y = backend.with_backend_session(|session| a.maximum(&b, session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[2.0, 8.0]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch or DTypeMismatch for incompatible operands, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise minimum with NumPy-style broadcasting inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let a = Tensor::from_vec_col_major(vec![2], vec![2.0_f64, 4.0]).unwrap();
let b = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 8.0]).unwrap();
let y = backend.with_backend_session(|session| a.minimum(&b, session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[1.0, 4.0]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch or DTypeMismatch for incompatible operands, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise negation inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, -2.0]).unwrap();
let y = backend.with_backend_session(|session| x.neg(session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[-1.0, 2.0]);

Errors

Returns [tenferro_tensor::Error::Unsupported] when the dtype is not supported by the operation, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise absolute value inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![-1.0_f64, 2.0]).unwrap();
let y = backend.with_backend_session(|session| x.abs(session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[1.0, 2.0]);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise sign inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, -2.0]).unwrap();
let y = backend.with_backend_session(|session| x.sign(session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[1.0, -1.0]);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise complex conjugate inside a session.

For real dtypes the conjugate is the identity.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, -2.0]).unwrap();
let y = backend.with_backend_session(|session| x.conj(session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[1.0, -2.0]);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise natural logarithm inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, std::f64::consts::E]).unwrap();
let y = backend.with_backend_session(|session| x.log(session)).unwrap();
let y = y.as_slice::<f64>().unwrap();
assert!(y[0].abs() < 1.0e-12);
assert!((y[1] - 1.0).abs() < 1.0e-12);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise exp(x) - 1 inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![0.0_f64, 1.0]).unwrap();
let y = backend.with_backend_session(|session| x.expm1(session)).unwrap();
let y = y.as_slice::<f64>().unwrap();
assert!(y[0].abs() < 1.0e-12);
assert!((y[1] - (std::f64::consts::E - 1.0)).abs() < 1.0e-12);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise log(1 + x) inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![0.0_f64, std::f64::consts::E - 1.0]).unwrap();
let y = backend.with_backend_session(|session| x.log1p(session)).unwrap();
let y = y.as_slice::<f64>().unwrap();
assert!(y[0].abs() < 1.0e-12);
assert!((y[1] - 1.0).abs() < 1.0e-12);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise sine inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![0.0_f64, std::f64::consts::FRAC_PI_2]).unwrap();
let y = backend.with_backend_session(|session| x.sin(session)).unwrap();
let y = y.as_slice::<f64>().unwrap();
assert!(y[0].abs() < 1.0e-12);
assert!((y[1] - 1.0).abs() < 1.0e-12);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise cosine inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![0.0_f64, std::f64::consts::PI]).unwrap();
let y = backend.with_backend_session(|session| x.cos(session)).unwrap();
let y = y.as_slice::<f64>().unwrap();
assert!((y[0] - 1.0).abs() < 1.0e-12);
assert!((y[1] + 1.0).abs() < 1.0e-12);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise hyperbolic tangent inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![0.0_f64, 1.0]).unwrap();
let y = backend.with_backend_session(|session| x.tanh(session)).unwrap();
let y = y.as_slice::<f64>().unwrap();
assert!(y[0].abs() < 1.0e-12);
assert!((y[1] - 0.7615941559557649).abs() < 1.0e-12);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise square root inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![4.0_f64, 9.0]).unwrap();
let y = backend.with_backend_session(|session| x.sqrt(session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[2.0, 3.0]);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise reciprocal square root inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![4.0_f64, 1.0]).unwrap();
let y = backend.with_backend_session(|session| x.rsqrt(session)).unwrap();
let y = y.as_slice::<f64>().unwrap();
assert!((y[0] - 0.5).abs() < 1.0e-12);
assert!((y[1] - 1.0).abs() < 1.0e-12);

Errors

Returns [tenferro_tensor::Error::Unsupported] for an unsupported dtype or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Elementwise comparison with NumPy-style broadcasting inside a session.

The result is a bool tensor.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{CompareDir, Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let a = Tensor::from_vec_col_major(vec![2], vec![2.0_f64, 4.0]).unwrap();
let b = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 8.0]).unwrap();
let y = backend.with_backend_session(|session| a.compare(&b, CompareDir::Gt, session)).unwrap();
assert_eq!(y.as_slice::<bool>().unwrap(), &[true, false]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch or DTypeMismatch for incompatible shape/dtype metadata, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let condition = Tensor::from_vec_col_major(vec![2], vec![true, false]).unwrap();
let on_true = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let on_false = Tensor::from_vec_col_major(vec![2], vec![3.0_f64, 4.0]).unwrap();
let y = backend.with_backend_session(|session| condition.where_select(&on_true, &on_false, session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[1.0, 4.0]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch or DTypeMismatch when the condition and branches are incompatible, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

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

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2], vec![-2.0_f64, 4.0]).unwrap();
let lower = Tensor::from_vec_col_major(vec![], vec![0.0_f64]).unwrap();
let upper = Tensor::from_vec_col_major(vec![], vec![3.0_f64]).unwrap();
let y = backend.with_backend_session(|session| x.clamp(&lower, &upper, session)).unwrap();
assert_eq!(y.as_slice::<f64>().unwrap(), &[0.0, 3.0]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch or DTypeMismatch when bounds are incompatible with the input, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Rank-2 matrix multiplication inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

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

Errors

Returns [tenferro_tensor::Error::Validation] with RankMismatch, ShapeMismatch, or DTypeMismatch for incompatible matrices, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Reshape without changing element order inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2, 2], vec![1.0_f64, 2.0, 3.0, 4.0]).unwrap();
let y = backend.with_backend_session(|session| x.reshape(&[4], session)).unwrap();
assert_eq!(y.shape(), &[4]);

Errors

Returns [tenferro_tensor::Error::Validation] with ShapeMismatch, RankMismatch, or InvalidArgument when element counts or ranks are invalid, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

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

Permute axes inside a session.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_runtime::{Tensor, TensorSessionOpsExt};
use tenferro_tensor::BackendSessionHost;

let mut backend = CpuBackend::new();
let x = Tensor::from_vec_col_major(vec![2, 3], vec![1.0_f64; 6]).unwrap();
let y = backend.with_backend_session(|session| x.transpose(&[1, 0], session)).unwrap();
assert_eq!(y.shape(), &[3, 2]);

Errors

Returns [tenferro_tensor::Error::Validation] with InvalidPermutationLength, AxisOutOfBounds, or DuplicateAxis for an invalid permutation, or [tenferro_tensor::Error::BackendSource] for a typed backend failure.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl TensorSessionOpsExt for Tensor