Struct ComplexLinSolver 

pub struct ComplexLinSolver<'a> {
    pub actual: Box<dyn Send + ComplexLinSolTrait + 'a>,
}

Unifies the access to linear system solvers

Fields

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

Holds the actual implementation

Implementations

impl<'a> ComplexLinSolver<'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 ComplexVector, mat: &ComplexCooMatrix, rhs: &ComplexVector, params: Option<LinSolParams>, ) -> Result<Self, StrError>

Computes the solution of a complex 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 crate::Sym::YesLower
2. For symmetric matrices, UMFPACK requires crate::Sym::YesFull
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::{complex_vec_approx_eq, cpx, ComplexVector};
use russell_sparse::prelude::*;
use russell_sparse::StrError;

fn main() -> Result<(), StrError> {
    let ndim = 3;
    let nnz = 7;

    // allocate the coefficient matrix
    //   ┌                      ┐
    //   │  2+1i  -1-1i     0   │
    //   │ -1-1i   2+2i  -1+1i  │
    //   │   0    -1+1i   2-1i  │
    //   └                      ┘
    let mut mat = ComplexCooMatrix::new(ndim, ndim, nnz, Sym::No)?;
    mat.put(0, 0, cpx!(2.0, 1.0))?;
    mat.put(0, 1, cpx!(-1.0, -1.0))?;
    mat.put(1, 0, cpx!(-1.0, -1.0))?;
    mat.put(1, 1, cpx!(2.0, 2.0))?;
    mat.put(1, 2, cpx!(-1.0, 1.0))?;
    mat.put(2, 1, cpx!(-1.0, 1.0))?;
    mat.put(2, 2, cpx!(2.0, -1.0))?;

    let rhs = ComplexVector::from(&[cpx!(-3.0, 3.0), cpx!(2.0, -2.0), cpx!(9.0, 7.0)]);

    let mut x = ComplexVector::new(ndim);
    ComplexLinSolver::compute(Genie::Umfpack, &mut x, &mat, &rhs, None)?;

    let correct = &[cpx!(1.0, 1.0), cpx!(2.0, -2.0), cpx!(3.0, 3.0)];
    complex_vec_approx_eq(&x, correct, 1e-14);
    Ok(())
}