section_properties/fea/solver/impls/
cg.rs1use crate::fea::SparseMatrix;
3use crate::fea::solver::{LinearSolver, SolverCapabilities, SolverError};
4
5pub 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 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 if !matrix.is_symmetric(1e-12) {
52 return Err(SolverError::not_symmetric());
53 }
54
55 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 for (i, &val) in rhs.iter().enumerate() {
80 if !val.is_finite() {
81 return Err(SolverError::non_finite(i));
82 }
83 }
84
85 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 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}