use super::super::lu_symbolic::SymbolicLu;
use super::types::NumericLu;
use crate::domain::real::RealScalar;
use leto::{Array1, ArrayView1, ArrayViewMut1, LetoError, Result};
impl<'a, T: RealScalar> NumericLu<'a, T> {
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!("NumericLu::solve internal shape error: {e}"),
})?;
self.solve_into(rhs, &mut x.view_mut())?;
Ok(x)
}
pub fn solve_into(
&self,
rhs: &ArrayView1<'_, T>,
out: &mut ArrayViewMut1<'_, T>,
) -> Result<()> {
let n = self.symbolic.n;
let identity_perm_owned;
let col_perm: &[usize] = match &self.symbolic.amd_col_perm {
Some(p) => p,
None => {
identity_perm_owned = (0..n).collect::<Vec<_>>();
&identity_perm_owned
}
};
triangular_solve_into(
self.symbolic,
&self.l_values,
&self.u_values,
&self.row_perm,
col_perm,
rhs,
out,
)
}
}
pub(in crate::application::sparse) fn triangular_solve_into<T: RealScalar>(
symbolic: &SymbolicLu,
l_values: &[T],
u_values: &[T],
row_perm: &[usize],
col_perm: &[usize],
rhs: &ArrayView1<'_, T>,
out: &mut ArrayViewMut1<'_, T>,
) -> Result<()> {
let n = symbolic.n();
if rhs.shape()[0] != n {
return Err(LetoError::ShapeMismatch {
lhs: vec![rhs.shape()[0]],
rhs: vec![n],
});
}
if out.shape()[0] != n {
return Err(LetoError::ShapeMismatch {
lhs: vec![out.shape()[0]],
rhs: vec![n],
});
}
let mut y = vec![T::ZERO; n];
for (slot, &orig_row) in row_perm.iter().enumerate() {
y[slot] = rhs.get([orig_row]).copied().unwrap_or(T::ZERO);
}
let mut row_inv = vec![0usize; n];
for (slot, &orig) in row_perm.iter().enumerate() {
row_inv[orig] = slot;
}
let l_col_ptr = &symbolic.l_col_ptr;
let l_row_indices = &symbolic.l_row_indices;
for j in 0..n {
let yj = y[j];
for (p, &orig_i) in l_row_indices
.iter()
.enumerate()
.take(l_col_ptr[j + 1])
.skip(l_col_ptr[j])
{
let slot_i = row_inv[orig_i];
y[slot_i] -= l_values[p] * yj;
}
}
let u_col_ptr = &symbolic.u_col_ptr;
let u_row_indices = &symbolic.u_row_indices;
let mut x = y; for j in (0..n).rev() {
let u_diag = u_row_indices
.iter()
.enumerate()
.take(u_col_ptr[j + 1])
.skip(u_col_ptr[j])
.find(|(_, &r)| r == j)
.map(|(p, _)| p);
if let Some(p) = u_diag {
x[j] = x[j] / u_values[p];
}
let xj = x[j];
for (p, &orig_i) in u_row_indices
.iter()
.enumerate()
.take(u_col_ptr[j + 1])
.skip(u_col_ptr[j])
{
if orig_i < j {
let slot_i = row_inv[orig_i];
x[slot_i] -= u_values[p] * xj;
}
}
}
let natural = col_perm.iter().enumerate().all(|(i, &p)| p == i);
if natural {
for (slot, &orig_row) in row_perm.iter().enumerate() {
*out.get_mut([orig_row])
.expect("invariant: orig_row < n and out length checked above") = x[slot];
}
} else {
for (slot, &perm_row) in row_perm.iter().enumerate() {
let orig_row = col_perm[perm_row];
*out.get_mut([orig_row])
.expect("invariant: orig_row < n and out length checked above") = x[slot];
}
}
Ok(())
}