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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#[derive(Clone, Default, Debug)]
pub struct PcStats {
    pub name: &'static str,
    pub n: usize,
    pub build_ms: f64,
    pub nnz_pc: usize,
    pub fill_ratio: f64,
    pub applies: u64,
}

pub trait PcIntrospect {
    fn stats(&self) -> PcStats;
    fn enable_logging(&mut self, _on: bool) {}
}

#[cfg(feature = "logging")]
#[macro_export]
macro_rules! pc_log {
    ($stats:expr) => {
        log::info!(
            "PC {}: n={}, build_ms={:.3}, nnz_pc={}, fill={:.3}",
            $stats.name,
            $stats.n,
            $stats.build_ms,
            $stats.nnz_pc,
            $stats.fill_ratio
        );
    };
}

#[derive(Debug, Clone)]
pub struct ParIluIterSample {
    pub iter: u32,
    pub residual: f64,
    pub time_s: f64,
}

#[derive(Debug, Clone)]
pub struct ParIluHistory {
    pub used: u32,
    pub buf: Vec<ParIluIterSample>,
}

impl ParIluHistory {
    pub fn with_capacity(cap: usize) -> Self {
        let buf = Vec::with_capacity(cap);
        Self { used: 0, buf }
    }

    #[inline]
    pub fn push(&mut self, s: ParIluIterSample) {
        self.buf.push(s);
        self.used += 1;
    }

    pub fn as_slice(&self) -> &[ParIluIterSample] {
        &self.buf[..self.used as usize]
    }
}