Skip to main content

section_properties/fea/solver/impls/
cg.rs

1//! Conjugate Gradient iterative solver
2use crate::fea::SparseMatrix;
3use crate::fea::solver::{LinearSolver, SolverCapabilities, SolverError};
4
5/// Conjugate Gradient iterative solver
6pub struct CgSolver {
7    n: usize,
8    max_iter: usize,
9    tol: f64,
10    matrix: Option<SparseMatrix>,
11}
12
13impl CgSolver {
14    pub fn new() -> Self {
15        Self {
16            n: 0,
17            max_iter: 10000,
18            tol: 1e-10,
19            matrix: None,
20        }
21    }
22
23    pub fn with_params(mut self, max_iter: usize, tol: f64) -> Self {
24        self.max_iter = max_iter;
25        self.tol = tol;
26        self
27    }
28}
29
30impl LinearSolver for CgSolver {
31    fn name(&self) -> &'static str {
32        "cg"
33    }
34
35    fn capabilities(&self) -> SolverCapabilities {
36        SolverCapabilities::cg()
37    }
38
39    fn factor(&mut self, matrix: &SparseMatrix) -> Result<(), SolverError> {
40        // Invalidate any previous factorization first, so a failed factor()
41        // cannot leave stale state usable by a later solve().
42        self.matrix = None;
43        self.n = 0;
44
45        let n = matrix.n;
46        if n == 0 {
47            return Err(SolverError::invalid_input("Empty matrix"));
48        }
49
50        // Check symmetry
51        if !matrix.is_symmetric(1e-12) {
52            return Err(SolverError::not_symmetric());
53        }
54
55        // Symmetry is verified above. Positive definiteness is NOT checked
56        // here: diagonal dominance is only a sufficient condition, and
57        // rejecting non-diagonally-dominant matrices would wrongly refuse
58        // many valid SPD systems. Instead, non-SPD is detected at solve time
59        // via the p^T A p <= 0 test, which returns SolverError::SingularMatrix.
60
61        self.n = n;
62        self.matrix = Some(matrix.clone());
63
64        Ok(())
65    }
66
67    fn solve(&self, rhs: &[f64]) -> Result<Vec<f64>, SolverError> {
68        let matrix = self
69            .matrix
70            .as_ref()
71            .ok_or_else(|| SolverError::not_factorized())?;
72        let n = self.n;
73
74        if rhs.len() != n {
75            return Err(SolverError::dimension_mismatch(n, rhs.len()));
76        }
77
78        // Check for NaN/Inf
79        for (i, &val) in rhs.iter().enumerate() {
80            if !val.is_finite() {
81                return Err(SolverError::non_finite(i));
82            }
83        }
84
85        // Scale-aware convergence: use relative residual ||r|| / ||b|| < tol,
86        // matching the raw cg_solve() semantics.  This prevents scale-dependent
87        // behaviour where small ||b|| causes premature "convergence" and large
88        // ||b|| prevents convergence.
89        let b_norm = rhs.iter().map(|v| v * v).sum::<f64>().sqrt();
90        if b_norm == 0.0 || !b_norm.is_finite() {
91            return Ok(vec![0.0f64; n]);
92        }
93        let conv_tol = self.tol * b_norm;
94
95        let mut x = vec![0.0f64; n];
96        let mut r = rhs.to_vec();
97        let mut p = r.clone();
98        let mut rsold = r.iter().map(|v| v * v).sum::<f64>();
99
100        if rsold.sqrt() < conv_tol {
101            return Ok(x);
102        }
103
104        for _iter in 0..self.max_iter {
105            // A * p
106            let mut ap = vec![0.0f64; n];
107            for i in 0..n {
108                let mut sum = 0.0;
109                for k in matrix.row_ptr[i]..matrix.row_ptr[i + 1] {
110                    let j = matrix.csr_cols[k];
111                    sum += matrix.csr_vals[k] * p[j];
112                }
113                ap[i] = sum;
114            }
115
116            let p_ap: f64 = p.iter().zip(ap.iter()).map(|(pi, api)| pi * api).sum();
117            if p_ap <= 0.0 {
118                return Err(SolverError::singular(
119                    "Matrix not positive definite (p^T A p <= 0)".to_string(),
120                ));
121            }
122
123            let alpha = rsold / p_ap;
124
125            for i in 0..n {
126                x[i] += alpha * p[i];
127                r[i] -= alpha * ap[i];
128            }
129
130            let rsnew = r.iter().map(|v| v * v).sum::<f64>();
131
132            if rsnew.sqrt() < conv_tol {
133                return Ok(x);
134            }
135
136            let beta = rsnew / rsold;
137            for i in 0..n {
138                p[i] = r[i] + beta * p[i];
139            }
140
141            rsold = rsnew;
142        }
143
144        Err(SolverError::not_converged())
145    }
146}