use super::super::lu_numeric::triangular_solve_into;
use super::super::lu_symbolic::SymbolicLu;
use crate::application::linalg::lu::LuDecomposition;
use crate::domain::real::RealScalar;
use leto::{Array1, ArrayView1, ArrayViewMut1, LetoError, Result};
#[derive(Debug, Clone)]
#[must_use = "OwnedNumericLu carries the factorization consumed by solve"]
pub struct OwnedNumericLu<T: RealScalar> {
pub(super) repr: OwnedLuRepr<T>,
}
#[derive(Debug, Clone)]
pub(super) enum OwnedLuRepr<T: RealScalar> {
Sparse {
symbolic: SymbolicLu,
l_values: Vec<T>,
u_values: Vec<T>,
row_perm: Vec<usize>,
col_perm: Vec<usize>,
},
Dense(LuDecomposition<T>),
}
impl<T: RealScalar> OwnedNumericLu<T> {
#[must_use]
#[inline]
pub fn n(&self) -> usize {
match &self.repr {
OwnedLuRepr::Sparse { symbolic, .. } => symbolic.n(),
OwnedLuRepr::Dense(lu) => lu.dim(),
}
}
pub fn solve_into(
&self,
rhs: &ArrayView1<'_, T>,
out: &mut ArrayViewMut1<'_, T>,
) -> Result<()> {
match &self.repr {
OwnedLuRepr::Sparse {
symbolic,
l_values,
u_values,
row_perm,
col_perm,
} => triangular_solve_into(symbolic, l_values, u_values, row_perm, col_perm, rhs, out),
OwnedLuRepr::Dense(lu) => lu.solve_into(rhs, out),
}
}
pub fn solve(&self, rhs: &ArrayView1<'_, T>) -> Result<Array1<T>> {
let n = self.n();
let mut x =
Array1::from_shape_vec([n], vec![T::ZERO; n]).map_err(|e| LetoError::StorageError {
reason: format!("OwnedNumericLu::solve internal shape error: {e}"),
})?;
self.solve_into(rhs, &mut x.view_mut())?;
Ok(x)
}
}