Trait TensorLinalgExt 

pub trait TensorLinalgExt {
    // Required methods
    fn svd(
        &self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor, Tensor)>;
    fn svdvals(&self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn svd_with_options(
        &self,
        options: SvdOptions,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor, Tensor)>;
    fn qr(&self, session: &mut dyn BackendSession) -> Result<(Tensor, Tensor)>;
    fn qr_with_options(
        &self,
        options: QrOptions,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor)>;
    fn lu(
        &self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor, Tensor, Tensor)>;
    fn full_piv_lu(
        &self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor)>;
    fn full_piv_lu_solve(
        &self,
        b: &Tensor,
        session: &mut dyn BackendSession,
    ) -> Result<Tensor>;
    fn solve(
        &self,
        b: &Tensor,
        session: &mut dyn BackendSession,
    ) -> Result<Tensor>;
    fn cholesky(&self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn eigh(&self, session: &mut dyn BackendSession) -> Result<(Tensor, Tensor)>;
    fn eigh_with_options(
        &self,
        options: EighOptions,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor)>;
    fn eig(&self, session: &mut dyn BackendSession) -> Result<(Tensor, Tensor)>;
    fn triangular_solve(
        &self,
        b: &Tensor,
        left_side: bool,
        lower: bool,
        transpose_a: bool,
        unit_diagonal: bool,
        session: &mut dyn BackendSession,
    ) -> Result<Tensor>;
    fn slogdet(
        &self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor)>;
    fn det(&self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn inv(&self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn eigvalsh(&self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn eigvals(&self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn pinv(&self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn pinv_with_rtol(
        &self,
        rtol: f64,
        session: &mut dyn BackendSession,
    ) -> Result<Tensor>;
    fn norm(
        &self,
        ord: Option<f64>,
        dim: Option<&[usize]>,
        keepdim: bool,
        session: &mut dyn BackendSession,
    ) -> Result<Tensor>;
}

Linear algebra methods for dtype-erased owned tensors.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_linalg::TensorLinalgExt;
use tenferro_tensor::{BackendSessionHost, Tensor};

let a = Tensor::from_vec_col_major(vec![2, 2], vec![2.0_f64, 0.0, 0.0, 4.0])?;
let mut host = CpuBackend::new();
let (_u, singular_values, _vt) = host.with_backend_session(|session| a.svd(session))?;
assert_eq!(singular_values.as_slice::<f64>()?, &[4.0, 2.0]);

Required Methods

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, unsupported-backend, numerical, or output-contract errors.

Examples

let (_u, s, _vt) = host.with_backend_session(|session| a.svd(session))?;
assert_eq!(s.shape(), &[2]);

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

Compute singular values without allocating singular-vector outputs.

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend has no values-only capability, rather than silently computing a full decomposition and discarding its vectors.

Examples

let values = host.with_backend_session(|session| a.svdvals(session))?;
assert_eq!(values.as_slice::<f64>()?, &[4.0, 2.0]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation errors for matrix metadata or options, plus SVD backend errors.

Examples

let (_u, s, _vt) = host.with_backend_session(|session| { a.svd_with_options(SvdOptions::default(), session) })?;
assert_eq!(s.shape(), &[2]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, unsupported-backend, numerical, or output-contract errors.

Examples

let (q, r) = host.with_backend_session(|session| a.qr(session))?;
assert_eq!(q.shape(), &[2, 2]);
assert_eq!(r.shape(), &[2, 2]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation errors for matrix metadata or options, plus QR backend errors.

Examples

let (q, r) = host.with_backend_session(|session| { a.qr_with_options(QrOptions::default(), session) })?;
assert_eq!(q.shape(), &[2, 2]);
assert_eq!(r.shape(), &[2, 2]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, unsupported-backend, numerical, or output-contract errors.

Examples

let (_p, l, u, parity) = host.with_backend_session(|session| a.lu(session))?;
assert_eq!(l.shape(), &[2, 2]);
assert_eq!(u.shape(), &[2, 2]);
assert_eq!(parity.shape(), &[]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, unsupported-backend, numerical, or output-contract errors.

Examples

let (p, _l, _u, q, parity) = host.with_backend_session(|session| a.full_piv_lu(session))?;
assert_eq!(p.shape(), &[2, 2]);
assert_eq!(q.shape(), &[2, 2]);
assert_eq!(parity.shape(), &[]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation errors for incompatible inputs or a backend/singular-system error.

Examples

let x = host.with_backend_session(|session| a.full_piv_lu_solve(&b, session))?;
assert_eq!(x.shape(), &[2, 1]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation errors for incompatible inputs or a backend/singular-system error.

Examples

let x = host.with_backend_session(|session| a.solve(&b, session))?;
assert_eq!(x.as_slice::<f64>()?, &[2.0, 2.0]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation errors for a non-square input or backend/numerical errors.

Examples

let l = host.with_backend_session(|session| a.cholesky(session))?;
assert_eq!(l.shape(), &[2, 2]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, unsupported-backend, convergence, or output-contract errors.

Examples

let (values, vectors) = host.with_backend_session(|session| a.eigh(session))?;
assert_eq!(values.as_slice::<f64>()?, &[1.0, 3.0]);
assert_eq!(vectors.shape(), &[2, 2]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation errors for matrix metadata or options, plus Eigh backend errors.

Examples

let (values, vectors) = host.with_backend_session(|session| { a.eigh_with_options(EighOptions::default(), session) })?;
assert_eq!(values.shape(), &[2]);
assert_eq!(vectors.shape(), &[2, 2]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, unsupported-backend, convergence, or output-contract errors.

Examples

let (values, vectors) = host.with_backend_session(|session| a.eig(session))?;
assert_eq!(values.shape(), &[2]);
assert_eq!(vectors.shape(), &[2, 2]);

fn triangular_solve( &self, b: &Tensor, left_side: bool, lower: bool, transpose_a: bool, unit_diagonal: bool, session: &mut dyn BackendSession, ) -> Result<Tensor>

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation errors for incompatible inputs/flags or backend/numerical errors.

Examples

let x = host.with_backend_session(|session| { a.triangular_solve(&b, true, false, false, false, session) })?;
assert_eq!(x.shape(), &[2, 1]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, unsupported-backend, numerical, or LU output-contract errors.

Examples

let (sign, logabsdet) = host.with_backend_session(|session| a.slogdet(session))?;
assert_eq!(sign.as_slice::<f64>()?, &[1.0]);
assert_eq!(logabsdet.shape(), &[]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns the validation, backend, numerical, or contract errors from Self::slogdet.

Examples

let determinant = host.with_backend_session(|session| a.det(session))?;
assert!((determinant.as_slice::<f64>()?[0] - 8.0).abs() < 1.0e-12);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, unsupported-backend, or singular-solve numerical errors.

Examples

let inverse = host.with_backend_session(|session| a.inv(session))?;
assert_eq!(inverse.as_slice::<f64>()?, &[0.5, 0.0, 0.0, 0.25]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns the validation, backend, convergence, or contract errors from Self::eigh.

Examples

let values = host.with_backend_session(|session| a.eigvalsh(session))?;
assert_eq!(values.as_slice::<f64>()?, &[1.0, 3.0]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns the validation, backend, convergence, or contract errors from Self::eig.

Examples

let values = host.with_backend_session(|session| a.eigvals(session))?;
assert_eq!(values.shape(), &[2]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, unsupported-backend, numerical, or SVD contract errors.

Examples

let pseudoinverse = host.with_backend_session(|session| a.pinv(session))?;
assert_eq!(pseudoinverse.shape(), &[2, 2]);

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns a validation error for invalid rtol, plus errors from Self::pinv.

Examples

let pseudoinverse = host.with_backend_session(|session| a.pinv_with_rtol(1.0e-12, session))?;
assert_eq!(pseudoinverse.shape(), &[2, 2]);

fn norm( &self, ord: Option<f64>, dim: Option<&[usize]>, keepdim: bool, session: &mut dyn BackendSession, ) -> Result<Tensor>

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation errors for axes/order combinations or required backend operations.

Examples

let frobenius = host.with_backend_session(|session| a.norm(None, None, false, session))?;
assert_eq!(frobenius.shape(), &[]);

Dyn Compatibility

This trait is dyn compatible.

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

Implementors

impl TensorLinalgExt for Tensor