Trait TensorReadLinalgExt 

pub trait TensorReadLinalgExt {
    // Required methods
    fn svd_read(
        self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor, Tensor)>;
    fn svdvals_read(self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn svd_with_options_read(
        self,
        options: SvdOptions,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor, Tensor)>;
    fn qr_read(
        self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor)>;
    fn qr_with_options_read(
        self,
        options: QrOptions,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor)>;
    fn lu_read(
        self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor, Tensor, Tensor)>;
    fn full_piv_lu_read(
        self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor)>;
    fn full_piv_lu_solve_read(
        self,
        b: TensorRead<'_>,
        session: &mut dyn BackendSession,
    ) -> Result<Tensor>;
    fn solve_read(
        self,
        b: TensorRead<'_>,
        session: &mut dyn BackendSession,
    ) -> Result<Tensor>;
    fn cholesky_read(self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn eigh_read(
        self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor)>;
    fn eigh_with_options_read(
        self,
        options: EighOptions,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor)>;
    fn eig_read(
        self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor)>;
    fn triangular_solve_read(
        self,
        b: TensorRead<'_>,
        left_side: bool,
        lower: bool,
        transpose_a: bool,
        unit_diagonal: bool,
        session: &mut dyn BackendSession,
    ) -> Result<Tensor>;
    fn slogdet_read(
        self,
        session: &mut dyn BackendSession,
    ) -> Result<(Tensor, Tensor)>;
    fn det_read(self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn inv_read(self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn eigvalsh_read(self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn eigvals_read(self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn pinv_read(self, session: &mut dyn BackendSession) -> Result<Tensor>;
    fn pinv_with_rtol_read(
        self,
        rtol: f64,
        session: &mut dyn BackendSession,
    ) -> Result<Tensor>;
    fn norm_read(
        self,
        ord: Option<f64>,
        dim: Option<&[usize]>,
        keepdim: bool,
        session: &mut dyn BackendSession,
    ) -> Result<Tensor>;

    // Provided method
    fn solve_read_into(
        self,
        b: TensorRead<'_>,
        out: TensorWrite<'_>,
        session: &mut dyn BackendSession,
    ) -> Result<()>
       where Self: Sized { ... }
}

Linear algebra methods for borrowed tensor reads.

Examples

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

let input = Tensor::from_vec_col_major(vec![2, 2], vec![2.0_f64, 0.0, 0.0, 4.0])?;
let mut host = CpuBackend::new();
let (_q, r) = host.with_backend_session(|session| {
    TensorRead::from_tensor(&input).qr_read(session)
})?;
assert_eq!(r.shape(), &[2, 2]);

Required Methods

fn svd_read( 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, same-placement materialization, backend, numerical, or contract errors.

Examples

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

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

Compute singular values from a borrowed tensor read target.

Eligible faer host views are consumed without a full input copy. A provider that requires owned compact storage may materialize explicitly; unsupported providers return a typed error.

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend has no borrowed values-only capability.

Examples

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

fn svd_with_options_read( 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 metadata/options, plus read/materialization or SVD errors.

Examples

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

fn qr_read(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, same-placement materialization, backend, numerical, or contract errors.

Examples

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

fn qr_with_options_read( 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 metadata/options, plus read/materialization or QR errors.

Examples

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

fn lu_read( 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, same-placement materialization, backend, numerical, or contract errors.

Examples

let (_p, l, u, _parity) = host.with_backend_session(|session| { TensorRead::from_tensor(&a).lu_read(session) })?;
assert_eq!(l.shape(), &[2, 2]);
assert_eq!(u.shape(), &[2, 2]);

fn full_piv_lu_read( 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, same-placement materialization, backend, numerical, or contract errors.

Examples

let (p, _l, _u, q, _parity) = host.with_backend_session(|session| { TensorRead::from_tensor(&a).full_piv_lu_read(session) })?;
assert_eq!(p.shape(), &[2, 2]);
assert_eq!(q.shape(), &[2, 2]);

fn full_piv_lu_solve_read( self, b: TensorRead<'_>, session: &mut dyn BackendSession, ) -> Result<Tensor>

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns incompatible-input validation, read/materialization, backend, or singular errors.

Examples

let x = host.with_backend_session(|session| {
    TensorRead::from_tensor(&a).full_piv_lu_solve_read(TensorRead::from_tensor(&b), session)
})?;
assert_eq!(x.shape(), &[2, 1]);

fn solve_read( self, b: TensorRead<'_>, session: &mut dyn BackendSession, ) -> Result<Tensor>

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns incompatible-input validation, read/materialization, backend, or singular errors.

Examples

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

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns matrix validation, read/materialization, backend, or positive-definiteness errors.

Examples

let l = host.with_backend_session(|session| { TensorRead::from_tensor(&a).cholesky_read(session) })?;
assert_eq!(l.shape(), &[2, 2]);

fn eigh_read(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, read/materialization, backend, convergence, or contract errors.

Examples

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

fn eigh_with_options_read( 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 metadata/options, plus read or Eigh backend errors.

Examples

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

fn eig_read(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, read/materialization, backend, convergence, or contract errors.

Examples

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

fn triangular_solve_read( self, b: TensorRead<'_>, 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 incompatible-input/flag validation, read, backend, or singular errors.

Examples

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

fn slogdet_read( 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, read/materialization, backend, numerical, or LU contract errors.

Examples

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

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, read/materialization, backend, numerical, or contract errors.

Examples

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

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

Errors

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

Examples

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

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, read/materialization, backend, convergence, or contract errors.

Examples

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

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

Errors

Returns tenferro_tensor::Error::Unsupported when the selected backend does not support the operation. Returns validation, read/materialization, backend, convergence, or contract errors.

Examples

let values = host.with_backend_session(|session| { TensorRead::from_tensor(&a).eigvals_read(session) })?;
assert_eq!(values.shape(), &[2]);

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

Errors

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

Examples

let pseudoinverse = host.with_backend_session(|session| { TensorRead::from_tensor(&a).pinv_read(session) })?;
assert_eq!(pseudoinverse.shape(), &[2, 2]);

fn pinv_with_rtol_read( 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_read.

Examples

let pseudoinverse = host.with_backend_session(|session| { TensorRead::from_tensor(&a).pinv_with_rtol_read(1.0e-12, session) })?;
assert_eq!(pseudoinverse.shape(), &[2, 2]);

fn norm_read( 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 read/backend operations.

Examples

let frobenius = host.with_backend_session(|session| { TensorRead::from_tensor(&a).norm_read(None, None, false, session) })?;
assert_eq!(frobenius.shape(), &[]);

Provided Methods

fn solve_read_into( self, b: TensorRead<'_>, out: TensorWrite<'_>, session: &mut dyn BackendSession, ) -> Result<()>

where Self: Sized,

Solve into a caller-owned destination without allocating the result at the public API boundary.

Backends with a native path may write directly into a compatible target; the trait default preserves the ordinary solve-read plus copy behavior.

Errors

Returns tenferro_tensor_core::ShapeMismatch or tenferro_tensor_core::ValidationError::DTypeMismatch for incompatible destination metadata, tenferro_tensor_core::ValidationError::InvalidArgument for aliasing or placement violations, Error::Unsupported when the extension implementation or provider is unavailable, and Error::Singular for a singular system.

Examples

host.with_backend_session(|session| {
        TensorRead::from_tensor(&a).solve_read_into(
            TensorRead::from_tensor(&b),
            TensorWrite::from_tensor(&mut out),
            session,
        )
    })?;
assert_eq!(out.as_slice::<f64>()?, &[2.0, 2.0]);

Dyn Compatibility

This trait is dyn compatible.

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

Implementors

impl TensorReadLinalgExt for TensorRead<'_>