kryst 3.2.1

Krylov subspace and preconditioned iterative solvers for dense and sparse linear systems, with shared and distributed memory parallelism.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#![cfg(feature = "backend-faer")]
use crate::algebra::prelude::*;
use crate::matrix::op::DenseOp;
use crate::parallel::{NoComm, UniverseComm};
use crate::preconditioner::PcSide;
use crate::solver::tests::util;
use crate::solver::{IdrsBuilder, IdrsSolver, LinearSolver};
use faer::Mat;
use std::sync::Arc;

#[test]
fn idrs_solves_nonsymmetric_system() {
    let a = Mat::from_fn(3, 3, |i, j| match (i, j) {
        (0, 0) => R::from(4.0),
        (0, 1) => R::from(-1.0),
        (1, 0) => R::from(2.0),
        (1, 1) => R::from(3.0),
        (1, 2) => R::from(-1.0),
        (2, 1) => R::from(-2.0),
        (2, 2) => R::from(5.0),
        _ => R::default(),
    });
    let op = DenseOp::<f64>::new(Arc::new(a));
    let b: Vec<R> = vec![R::from(3.0), R::from(7.0), R::from(4.0)];
    let mut x: Vec<R> = vec![R::default(); 3];

    let mut solver: IdrsSolver = IdrsBuilder::new().s(1).build();

    let comm = UniverseComm::NoComm(NoComm);
    let stats = solver
        .solve(&op, None, &b, &mut x, PcSide::Left, &comm, None, None)
        .expect("IDR(s) solve should succeed");

    let true_res = util::true_residual_norm(&op, &x, &b);
    assert!(true_res < 1e-8, "true residual too large: {}", true_res);
    assert!(stats.final_residual < 1e-8, "final residual too large");
}