Struct russell_sparse::LinSolver

pub struct LinSolver<'a> {
    pub actual: Box<dyn Send + LinSolTrait + 'a>,
}

Unifies the access to linear system solvers

Fields

actual: Box<dyn Send + LinSolTrait + 'a>

Holds the actual implementation

Implementations

impl<'a> LinSolver<'a>

pub fn new(genie: Genie) -> Result<Self, StrError>

Allocates a new instance

Input

• genie – the actual implementation that does all the magic

pub fn compute( genie: Genie, x: &mut Vector, mat: &mut SparseMatrix, rhs: &Vector, params: Option<LinSolParams> ) -> Result<Self, StrError>

Computes the solution of a linear system

Solves the linear system:

  A   · x = rhs
(m,n)  (n)  (m)

Output

• x – the vector of unknown values with dimension equal to mat.ncol

Input

• genie – the actual implementation that does all the magic
• mat – the matrix representing the sparse coefficient matrix A (see Notes below)
• rhs – the right-hand side vector with know values an dimension equal to coo.nrow
• verbose – shows messages

Notes

1. For symmetric matrices, MUMPS requires that the symmetry/storage be Lower or Full.
2. For symmetric matrices, UMFPACK requires that the symmetry/storage be Full.
3. This function calls the actual implementation (genie) via the functions factorize, and solve.
4. This function is best for a single-use, whereas the actual solver should be considered for a recurrent use (e.g., inside a loop).

Examples

use russell_lab::{vec_approx_eq, Vector};
use russell_sparse::prelude::*;
use russell_sparse::StrError;

fn main() -> Result<(), StrError> {
    // constants
    let ndim = 3; // number of rows = number of columns
    let nnz = 5; // number of non-zero values

    // allocate the coefficient matrix
    let mut mat = SparseMatrix::new_coo(ndim, ndim, nnz, Sym::No)?;
    mat.put(0, 0, 0.2)?;
    mat.put(0, 1, 0.2)?;
    mat.put(1, 0, 0.5)?;
    mat.put(1, 1, -0.25)?;
    mat.put(2, 2, 0.25)?;

    // print matrix
    let mut a = mat.as_dense();
    let correct = "┌                   ┐\n\
                   │   0.2   0.2     0 │\n\
                   │   0.5 -0.25     0 │\n\
                   │     0     0  0.25 │\n\
                   └                   ┘";
    assert_eq!(format!("{}", a), correct);

    // allocate the right-hand side vector
    let rhs = Vector::from(&[1.0, 1.0, 1.0]);

    // calculate the solution
    let mut x = Vector::new(ndim);
    LinSolver::compute(Genie::Umfpack, &mut x, &mut mat, &rhs, None)?;
    let correct = vec![3.0, 2.0, 4.0];
    vec_approx_eq(&x, &correct, 1e-14);
    Ok(())
}