LUFactorized Implemented?

[JP-Ellis]

I was having a look at the code behind LUFactorized and it appears that there is no LU factorization done at all. For example, the factorize_into source is

fn factorize_into(mut self) -> Result<LUFactorized<S>> {
    let ipiv = A::lu(self.layout()?, self.as_allocated_mut()?)?;
    Ok(LUFactorized { a: self, ipiv })
}

where self here is the original matrix. While it is fine to be storing the original matrix A (perhaps the LU decomposition is lazily evaluated), the solve_inplace code indicates that this is actually not the case at all. Instead it just uses the standard solve function without actually doing any LU decomposition at any point.

fn solve_inplace<'a, Sb>(
    &self,
    rhs: &'a mut ArrayBase<Sb, Ix1>,
) -> Result<&'a mut ArrayBase<Sb, Ix1>>
where
    Sb: DataMut<Elem = A>,
{
    assert_eq!(
        rhs.len(),
        self.a.len_of(Axis(1)),
        "The length of `rhs` must be compatible with the shape of the factored matrix.",
    );
    A::solve(
        self.a.square_layout()?,
        Transpose::No,
        self.a.as_allocated()?,
        &self.ipiv,
        rhs.as_slice_mut().unwrap(),
    )?;
    Ok(rhs)
}

Am I missing something? Or is this a temporary implementation until an LU factorization can be properly implemented?