MathMatrixClass.h

#ifndef _MathMatrixClass_H_
#define _MathMatrixClass_H_
 
#include <vector>
#include <cstdlib>
#include <iostream>
#include <set>
#include <stack>
#include <sstream>
#include <unordered_map>
#include <list>
 
class MathMatrixClass
{
    public:
        using VectorDouble = std::vector<double>;
        using pVectorDouble = std::vector<double*>;
 
        using Matrix = std::vector<VectorDouble>;
        using pMatrix = std::vector<pVectorDouble>;
 
        using VectorIndex = std::vector<size_t>;
        using pVectorIndex = std::vector<size_t*>;
 
        using BipartiteGraph = std::unordered_map<std::string, std::set<std::string>>;
 
        pMatrix *pA = nullptr;
        pVectorDouble *pB = nullptr;
        pVectorDouble *pSolution = nullptr;
        pVectorIndex *pSolutionBeloneNetlistIndex = nullptr;
 
        MathMatrixClass(Matrix* , VectorDouble* , VectorDouble* , VectorIndex* );
        MathMatrixClass(MathMatrixClass* , const VectorIndex& , const VectorIndex& );
        ~MathMatrixClass();
 
        void showDescription();
 
        void solveBigQuestion();
 
    private:
 
        size_t n = 0;
 
        void copyMatrix(Matrix*, pMatrix*);
        void copyVectorDouble(VectorDouble*, pVectorDouble*);
        void copyVectorIndex(VectorIndex*, pVectorIndex*);
 
        void copyMatrix(pMatrix*, pMatrix*, const VectorIndex&, const VectorIndex&);
        void copyVectorDouble(pVectorDouble*, pVectorDouble*, const VectorIndex&);
        void copyVectorIndex(pVectorIndex*, pVectorIndex*, const VectorIndex&);
 
        void printMatrix(const pMatrix* );
        void printVector(const pVectorDouble* );
        void printVector(const pVectorIndex* );
 
        std::list<MathMatrixClass*> splitToMultiSubQuestions();
 
        BipartiteGraph buildBipartiteGraph();
        void dfs(const std::string& , BipartiteGraph& , std::set<std::string>& , std::vector<std::string>& );
 
        bool solve();
        bool isSingularMatrix();
        bool isSquareMatrix();
        double determinant(const Matrix& matrix);
 
        bool solveLinearSystem();
 
        void luDecomposition( Matrix& , Matrix& );
 
        VectorDouble forwardSubstitution( const Matrix& );
 
        VectorDouble backwardSubstitution(const Matrix& , const VectorDouble&);
};
#endif