Struct MatrixLUCI 

pub struct MatrixLUCI<T: Scalar + MatrixLuciScalar> { /* private fields */ }

Matrix LU-based Cross Interpolation.

This is a higher-level Matrix wrapper around the lower-level matrixluci substrate.

Examples

use tensor4all_core::{AbstractMatrixCI, MatrixLUCI};
use tensor4all_tensorbackend::from_vec2d;

let m = from_vec2d(vec![
    vec![1.0_f64, 2.0, 3.0],
    vec![4.0, 5.0, 6.0],
    vec![7.0, 8.0, 9.0],
]);

let ci = MatrixLUCI::from_matrix(&m, None).unwrap();
// The approximation must have at most rank min(nrows, ncols)
assert!(ci.rank() <= 3);
// Reconstructed matrix should match original at pivot positions
let row_indices = ci.row_indices().to_vec();
let col_indices = ci.col_indices().to_vec();
for (&i, &j) in row_indices.iter().zip(col_indices.iter()) {
    let approx = ci.evaluate(i, j);
    let exact = m[[i, j]];
    assert!((approx - exact).abs() < 1e-10);
}

Implementations

impl<T> MatrixLUCI<T>

where T: Scalar + MatrixLuciScalar,

pub fn from_matrix(a: &Matrix<T>, options: Option<RrLUOptions>) -> Result<Self>

Create a MatrixLUCI from a dense matrix.

Errors

Returns an error when the construction or conversion fails (a shape or /// index mismatch, or a backend failure).

Examples

use tensor4all_core::{AbstractMatrixCI, MatrixLUCI};
use tensor4all_tensorbackend::from_vec2d;

let m = from_vec2d(vec![
    vec![2.0_f64, 0.0],
    vec![0.0, 3.0],
]);
let ci = MatrixLUCI::from_matrix(&m, None).unwrap();
assert!(ci.rank() >= 1);

pub fn left(&self) -> Matrix<T>

Left CI factor (shape: nrows x rank).

The approximation is left * right.

Examples

use tensor4all_core::{AbstractMatrixCI, MatrixLUCI};
use tensor4all_tensorbackend::{from_vec2d, mat_mul};

let m = from_vec2d(vec![
    vec![1.0_f64, 2.0],
    vec![3.0, 4.0],
]);
let ci = MatrixLUCI::from_matrix(&m, None).unwrap();
let reconstructed = mat_mul(&ci.left(), &ci.right()).unwrap();
for i in 0..2 {
    for j in 0..2 {
        assert!((reconstructed[[i, j]] - m[[i, j]]).abs() < 1e-10);
    }
}

pub fn right(&self) -> Matrix<T>

Right CI factor (shape: rank x ncols).

The approximation is left * right.

Examples

use tensor4all_core::{AbstractMatrixCI, MatrixLUCI};
use tensor4all_tensorbackend::{from_vec2d, mat_mul};

let m = from_vec2d(vec![vec![1.0_f64, 2.0], vec![3.0, 4.0]]);
let ci = MatrixLUCI::from_matrix(&m, None).unwrap();
let r = ci.right();
assert_eq!(r.nrows(), ci.rank());
assert_eq!(r.ncols(), ci.ncols());
// left * right reconstructs the matrix
let recon = mat_mul(&ci.left(), &r).unwrap();
for i in 0..2 {
    for j in 0..2 {
        assert!((recon[[i, j]] - m[[i, j]]).abs() < 1e-10);
    }
}

pub fn pivot_errors(&self) -> Vec<f64>

Pivot error history (one entry per pivot, plus a final residual estimate).

Examples

use tensor4all_core::MatrixLUCI;
use tensor4all_tensorbackend::from_vec2d;

let m = from_vec2d(vec![vec![1.0_f64, 2.0], vec![3.0, 4.0]]);
let ci = MatrixLUCI::from_matrix(&m, None).unwrap();
let errs = ci.pivot_errors();
assert!(!errs.is_empty());
// All errors are non-negative
for &e in &errs {
    assert!(e >= 0.0);
}

pub fn last_pivot_error(&self) -> f64

Last pivot error (the residual estimate after all pivots).

Examples

use tensor4all_core::MatrixLUCI;
use tensor4all_tensorbackend::from_vec2d;

let m = from_vec2d(vec![vec![1.0_f64, 2.0], vec![3.0, 4.0]]);
let ci = MatrixLUCI::from_matrix(&m, None).unwrap();
let err = ci.last_pivot_error();
assert!(err >= 0.0);

Trait Implementations

impl<T> AbstractMatrixCI<T> for MatrixLUCI<T>

where T: Scalar + MatrixLuciScalar,

fn nrows(&self) -> usize

Number of rows in the approximated matrix

fn ncols(&self) -> usize

Number of columns in the approximated matrix

fn rank(&self) -> usize

Current rank of the approximation (number of pivots)

fn row_indices(&self) -> &[usize]

Row indices selected as pivots (I set)

fn col_indices(&self) -> &[usize]

Column indices selected as pivots (J set)

fn evaluate(&self, i: usize, j: usize) -> T

Evaluate the approximation at position (i, j)

fn submatrix(&self, rows: &[usize], cols: &[usize]) -> Matrix<T>

Get a submatrix of the approximation

fn is_empty(&self) -> bool

Check if the approximation is empty (no pivots)

fn row(&self, i: usize) -> Vec<T>

Get a row of the approximation

fn col(&self, j: usize) -> Vec<T>

Get a column of the approximation

fn to_matrix(&self) -> Matrix<T>

Get the full approximated matrix

fn available_rows(&self) -> Vec<usize>

Get available row indices (rows without pivots)

fn available_cols(&self) -> Vec<usize>

Get available column indices (columns without pivots)

fn local_error( &self, a: &Matrix<T>, rows: &[usize], cols: &[usize], ) -> Matrix<T>

where T: Sub<Output = T>,

Compute local error |A - CI| for given indices

fn find_new_pivot(&self, a: &Matrix<T>) -> Result<((usize, usize), T)>

where T: Sub<Output = T>,

Find a new pivot that maximizes the local error

fn find_new_pivot_in( &self, a: &Matrix<T>, rows: &[usize], cols: &[usize], ) -> Result<((usize, usize), T)>

where T: Sub<Output = T>,

Find a new pivot in the given row/column subsets

impl<T: Clone + Scalar + MatrixLuciScalar> Clone for MatrixLUCI<T>

fn clone(&self) -> MatrixLUCI<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Scalar + MatrixLuciScalar> Debug for MatrixLUCI<T>

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

Formats the value using the given formatter.