use crate::fea::SparseMatrix;
use crate::fea::solver::{LinearSolver, SolverCapabilities, SolverError};
pub struct SkylineLdltSolver {
inner: Option<crate::fea::SkylineLdlt>,
n: usize,
}
impl SkylineLdltSolver {
pub fn new() -> Self {
Self { inner: None, n: 0 }
}
}
impl Default for SkylineLdltSolver {
fn default() -> Self {
Self::new()
}
}
impl LinearSolver for SkylineLdltSolver {
fn name(&self) -> &'static str {
"skyline_ldlt"
}
fn capabilities(&self) -> SolverCapabilities {
SolverCapabilities::skyline_ldlt()
}
fn factor(&mut self, matrix: &SparseMatrix) -> Result<(), SolverError> {
self.inner = None;
self.n = 0;
let n = matrix.n;
if n == 0 {
return Err(SolverError::invalid_input("Empty matrix"));
}
if !matrix.is_symmetric(1e-12) {
return Err(SolverError::not_symmetric());
}
let ldlt = crate::fea::SkylineLdlt::factor(matrix).map_err(|e| match e {
crate::fea::FemError::SingularMatrix => SolverError::singular(e.to_string()),
_ => SolverError::factorization_failed(e.to_string()),
})?;
self.inner = Some(ldlt);
self.n = n;
Ok(())
}
fn solve(&self, rhs: &[f64]) -> Result<Vec<f64>, SolverError> {
let ldlt = self
.inner
.as_ref()
.ok_or_else(SolverError::not_factorized)?;
if rhs.len() != self.n {
return Err(SolverError::dimension_mismatch(self.n, rhs.len()));
}
for (i, &val) in rhs.iter().enumerate() {
if !val.is_finite() {
return Err(SolverError::non_finite(i));
}
}
ldlt.solve(rhs)
.map_err(|e| SolverError::solve_failed(e.to_string()))
}
}