pub fn compute_quasi_inverses(mut self) -> (QuasiInverse, QuasiInverse) {
        let p = self.prime();

        let source_columns = self.end[2] - self.start[2];

        if self.end[0] == 0 {
            let cc_qi = QuasiInverse::new(None, Matrix::new(p, 0, source_columns));
            let res_qi = Matrix::compute_quasi_inverse(&self, self.end[1], self.start[2]);
            (cc_qi, res_qi)
        } else {
            let mut cc_preimage = Matrix::new(p, self.end[0], source_columns);
            for i in 0..self.end[0] {
                cc_preimage[i]
                    .as_slice_mut()
                    .assign(self[i].slice(self.start[2], self.end[2]));
            }
            let cm_qi = QuasiInverse::new(None, cc_preimage);

            let first_kernel_row = self.find_first_row_in_block(self.start[2]);
            self.vectors.truncate(first_kernel_row);

            let mut res_matrix = self.drop_first();
            res_matrix.row_reduce();
            let res_qi = res_matrix.compute_quasi_inverse();

            (cm_qi, res_qi)
        }
    }
/// This function computes quasi-inverses for matrices A, B given a reduced row echelon form of
/// [A|0|B|0|I] such that A is surjective. Moreover, if Q is the quasi-inverse of A, it is
/// guaranteed that the image of QB and B|_{ker A} are disjoint.
///
/// This takes ownership of the matrix since it heavily modifies the matrix. This is not
/// strictly necessary but is fine in most applications.
This function computes quasi-inverses for matrices A, B given a reduced row echelon form of
[A|0|B|0|I] such that A is surjective. Moreover, if Q is the quasi-inverse of A, it is
guaranteed that the image of QB and B|_{ker A} are disjoint.

This takes ownership of the matrix since it heavily modifies the matrix. This is not
strictly necessary but is fine in most applications.
This function computes quasi - inverses for matrices A B given a reduced row echelon form of [ A|0|B|0|I ] such that A is surjective . Moreover if Q is the quasi - inverse of A it is guaranteed that the image of QB and B|_ { ker A } are disjoint . This takes ownership of the matrix since it heavily modifies the matrix . This is not strictly necessary but is fine in most applications .
pub fn compute_quasi_inverses(mut self) -> (QuasiInverse, QuasiInverse) {
        let p = self.prime();
        let source_columns = self.end[2] - self.start[2];
        if self.end[0] == 0 {
            let cc_qi = QuasiInverse::new(None, Matrix::new(p, 0, source_columns));
            let res_qi = Matrix::compute_quasi_inverse(&self, self.end[1], self.start[2]);
            (cc_qi, res_qi)
        } else {
            let mut cc_preimage = Matrix::new(p, self.end[0], source_columns);
            for i in 0..self.end[0] {
                cc_preimage[i]
                    .as_slice_mut()
                    .assign(self[i].slice(self.start[2], self.end[2]));
            }
            let cm_qi = QuasiInverse::new(None, cc_preimage);
            let first_kernel_row = self.find_first_row_in_block(self.start[2]);
            self.vectors.truncate(first_kernel_row);
            let mut res_matrix = self.drop_first();
            res_matrix.row_reduce();
            let res_qi = res_matrix.compute_quasi_inverse();
            (cm_qi, res_qi)
        }
    }
pub fn compute_quasi_inverses ( mut self ) -> ( QuasiInverse , QuasiInverse ) { let p = self . prime ( ) ; let source_columns = self . end [ 2 ] - self . start [ 2 ] ; if self . end [ 0 ] == 0 { let cc_qi = QuasiInverse :: new ( None , Matrix :: new ( p , 0 , source_columns ) ) ; let res_qi = Matrix :: compute_quasi_inverse ( & self , self . end [ 1 ] , self . start [ 2 ] ) ; ( cc_qi , res_qi ) } else { let mut cc_preimage = Matrix :: new ( p , self . end [ 0 ] , source_columns ) ; for i in 0 .. self . end [ 0 ] { cc_preimage [ i ] . as_slice_mut ( ) . assign ( self [ i ] . slice ( self . start [ 2 ] , self . end [ 2 ] ) ) ; } let cm_qi = QuasiInverse :: new ( None , cc_preimage ) ; let first_kernel_row = self . find_first_row_in_block ( self . start [ 2 ] ) ; self . vectors . truncate ( first_kernel_row ) ; let mut res_matrix = self . drop_first ( ) ; res_matrix . row_reduce ( ) ; let res_qi = res_matrix . compute_quasi_inverse ( ) ; ( cm_qi , res_qi ) } }
This function computes quasi-inverses for matrices A, B given a reduced row echelon form of
[A|0|B|0|I] such that A is surjective.
This function computes quasi - inverses for matrices A B given a reduced row echelon form of [ A|0|B|0|I ] such that A is surjective .
mut self
mut self