RowPivotLU.hpp

Go to the documentation of this file.

#pragma once
 
#include "Matrix.hpp"
#include "PermutationMatrix.hpp"
 
class RowPivotLU {
  public:
 
    RowPivotLU() = default;
    RowPivotLU(const SquareMatrix &matrix) { compute(matrix); }
    RowPivotLU(SquareMatrix &&matrix) { compute(std::move(matrix)); }
 
 
  public:
 
    void compute(SquareMatrix &&matrix);
    void compute(const SquareMatrix &matrix);
 
 
  public:
 
    SquareMatrix &&steal_L();
 
    void get_L_inplace(Matrix &L) const;
    SquareMatrix get_L() const &;
    SquareMatrix &&get_L() && { return steal_L(); }
 
 
  public:
 
    SquareMatrix &&steal_U();
 
    void get_U_inplace(Matrix &U) const;
    SquareMatrix get_U() const &;
    SquareMatrix &&get_U() && { return steal_U(); }
 
 
  public:
 
    PermutationMatrix &&steal_P();
 
    PermutationMatrix get_P() const & { return P; }
    PermutationMatrix &&get_P() && { return steal_P(); }
 
 
  public:
 
    void solve_inplace(Matrix &B) const;
    Matrix solve(const Matrix &B) const;
    Matrix &&solve(Matrix &&B) const;
    Vector solve(const Vector &B) const;
    Vector &&solve(Vector &&B) const;
 
 
  public:
 
    bool is_factored() const { return state == Factored; }
 
    bool has_LU() const { return valid_LU; }
 
    bool has_P() const { return valid_P; }
 
    SquareMatrix &&steal_LU();
 
    const SquareMatrix &get_LU() const & { return LU; }
    SquareMatrix &&get_LU() && { return steal_LU(); }
 
 
  private:
    void compute_factorization();
    void back_subs(const Matrix &B, Matrix &X) const;
    void forward_subs(const Matrix &B, Matrix &X) const;
 
  private:
    SquareMatrix LU;
    PermutationMatrix P = PermutationMatrix::RowPermutation;
 
    enum State {
        NotFactored = 0,
        Factored = 1,
    } state = NotFactored;
 
    bool valid_LU = false;
    bool valid_P = false;
};
 
std::ostream &operator<<(std::ostream &os, const RowPivotLU &lu);