Method inverse

perro_source/core/perro_structs/src/structs/matrix/mod.rs:1131–1205

(self)

    #[inline]
    pub fn inverse(self) -> Option<Self> {
        if N == 2 {
            if self.determinant().abs() <= f32::EPSILON {
                return None;
            }
            return Some(Self(matrix_from_rows_2(
                Matrix2::from_rows(matrix_rows_2(self.0))
                    .inverse()
                    .to_rows(),
            )));
        }
        if N == 3 {
            if self.determinant().abs() <= f32::EPSILON {
                return None;
            }
            return Some(Self(matrix_from_rows_3(
                Matrix3::from_rows(matrix_rows_3(self.0))
                    .inverse()
                    .to_rows(),
            )));
        }
        if N == 4 {
            if self.determinant().abs() <= f32::EPSILON {
                return None;
            }
            return Some(Self(matrix_from_rows_4(
                Matrix4::from_rows(matrix_rows_4(self.0))
                    .inverse()
                    .to_rows(),
            )));
        }

        let mut lhs = self.0;
        let mut rhs = Self::identity().0;
        for pivot in 0..N {
            let mut best = pivot;
            let mut best_abs = lhs[pivot][pivot].abs();
            for (r, row) in lhs.iter().enumerate().skip(pivot + 1) {
                let abs = row[pivot].abs();
                if abs > best_abs {
                    best = r;
                    best_abs = abs;
                }
            }
            if best_abs <= f32::EPSILON {
                return None;
            }
            if best != pivot {
                lhs.swap(pivot, best);
                rhs.swap(pivot, best);
            }

            let pivot_value = lhs[pivot][pivot];
            for c in 0..N {
                lhs[pivot][c] /= pivot_value;
                rhs[pivot][c] /= pivot_value;
            }