// =====================< FACTORED.HPP >====================== // * basic class for factorisations * // * Description: Chapter 15 * // * Scientific C++ Building Numerical Libraries * // * the Object-Oriented Way * // * by G. Buzzi-Ferraris * // * Addison-Wesley (1993) * // =========================================================== // * factorizationStatus matrixStatus * // * initially UNFACTORED AVAILABLE * // * * // * OnlySolve FACTORED DESTROYED * // * Solve FACTORED AVAILABLE * // * TRansposeSolve FACTORED AVAILABLE * // * HyperSolve FACTORED AVAILABLE * // *********************************************************** // * The matrix is used for solving linear systems * // * and connected problems * // * Valid functions for all factorisations: * // * Solve(A,b,&x); * // * Solve(A,&bx); else Solve(A,b,&b); * // * Solve(&A,b,&x); * // * Solve(&A,&bx); else Solve(&A,b,&b); * // * Solve(A,B,&X); * // * Solve(A,&BX); else Solve(A,B,&B); * // * Solve(&A,B,&X); * // * Solve(&A,&BX); else Solve(&A,B,&B); * // * HyperSolve(A,b,&x); * // * HyperSolve(A,&bx); or HyperSolve(A,b,&b); * // * double det = A.Determinant(void) * // * float cond = A.ConditionNumber(void) * // * char s = A.Singular(void) * // * Matrix inv; A.Inverse(&inv) * // * Matrix inv = A.Inverse(void) * // *********************************************************** // * Valid functions for PLR factorisations: * // * TransposeSolve(A,b,&x); * // * TransposeSolve(A,&bx); or TransposeSolve(A,b,&b); * // * TransposeSolve(&A,b,&x); * // * TransposeSolve(&A,&bx); or TransposeSolve(&A,b,&b); * // *********************************************************** // * Can be defined as objects of the classes: * // * FactoredGauss, FactoredCrout * // * FactoredQR, FactoredLQ * // * See ESGAUSS.CPP for initialising * // *********************************************************** // * The coefficients of the matrix are accessible if * // * matrixStatus != DESTROYED * // * float val = A(i,j); * // * val = A.GetValue(i,j); * // * Vector v = A.GetRow(i); * // * v = A.GetColumn(j); * // *********************************************************** // *The matrix can be modified * // * only if matrixStatus != DESTROYED * // * A.SetValue(i,j,val); * // * A(i,j) = val; * // * A.SetRow(i,v); * // * A.SetColumn(j,v); * // * if factoredStatus = FACTORED * // * puts matrixStatus = MODIFIED * // * and refactorised when necessary * // *********************************************************** // * The derived classes must have: * // * FurtherInit * // * initialises to 0 specific vectors (es indx) * // * SpecificInitialize(void) * // * initialises specific vectors * // * SpecificDeinitialize(void) * // * deinitialise specific vectors * // * Factorization(void) * // * for factorising the factored matrix * // * Solution(Vector *bx) * // * solving the system and putting the solution in bx * // * Solution(const Vector &b,Vector *x) * // * solving the system and putting the solution in x * // * TransposeSolution(Vector *bx) * // * solving the system with AT * // * TransposeSolution(const Vector &b,Vector *x) * // * solving the system with AT * // * Solution(Matrix *BX) * // * solving the system for a matrix * // * Solution(const Matrix &B,Matrix *X) * // * solving the system for a matrix * // * Condition(void) * // * calculating the condition number * // * DeterminantEvaluation(void) * // * calculating the determinant * // *********************************************************** #ifndef FACTORED_HPP #define FACTORED_HPP // =========================================================== // ================== class Factored ===================== // =========================================================== class Factored { // =========================================================== // ========== Functions for linear algebra =============== // =========================================================== friend void Solve (Factored &A,const Vector &b,Vector *x); friend void Solve (Factored &A,Vector *bx); friend void Solve (Factored *A,const Vector &b,Vector *x); friend void Solve (Factored *A,Vector *bx); friend void Solve (Factored &A,const Matrix &B,Matrix *X); friend void Solve (Factored &A,Matrix *BX); friend void Solve (Factored *A,const Matrix &B,Matrix *X); friend void Solve (Factored *A,Matrix *BX); friend void Solve(FactoredSVD &A,const Vector &b,Vector *x, int numD); friend void Solve(FactoredSVD *A,const Vector &b,Vector *x, int numD); friend void TransposeSolve (Factored &A,const Vector &b,Vector *x); friend void TransposeSolve (Factored &A,Vector *bx); friend void TransposeSolve (Factored *A,const Vector &b,Vector *x); friend void TransposeSolve (Factored *A,Vector *bx); friend void HyperSolve (Factored &A,const Vector &b,Vector *x); friend void HyperSolve (Factored &A,Vector *bx); protected: enum FactorizationStatus { UNFACTORED, FACTORED }factorizationStatus; enum MatrixStatus { AVAILABLE, DESTROYED, MODIFIED }matrixStatus; static const char *const ERROR; static const char *const ERR_DESTROYED; static int count; // for whoAmI float **matrix; float **factored; int numRows,numColumns; int size; int whoAmI; char singular; // singular = 1 and singular float norm; // initialising constructors void Initialize(int mrows,int ncolumns); // initialise factored if requested void FactoredInitialize(void); // deinitialisation void Deinitialize(void); // deinitialise factored if requested void FactoredDeinitialize(void); // preparing assignments void PrepCopy(int rRows,int rColumns); // protected constructor type Factored A('*',3,5); Factored(char,int rows,int columns); // preparing the OnlySolve void PrepOnlySolve(void); // preparing the Solve void PrepSolve(void); // calculating the Condition norm void Norm(void); // =========================================================== // ========== Functions for linear algebra =============== // =========================================================== // For each PLR factorisation, Gauss, Qr, SVD virtual void Factorization(void) = 0; virtual void SpecificInitialize(void) = 0; virtual void SpecificDeinitialize(void) = 0; virtual void Solution(const Vector &b,Vector *x) = 0; virtual void Solution(Vector *bx) = 0; virtual void TransposeSolution (const Vector &b,Vector *x) = 0; virtual void TransposeSolution(Vector *bx) = 0; virtual void Solution(const Matrix &B,Matrix *X) = 0; virtual void Solution(Matrix *BX) = 0; virtual float Condition(void) = 0; virtual double DeterminantEvaluation(void) = 0; public: // =========================================================== // ****************** constructors *********************** // =========================================================== // default constructor type Factored A; Factored(void); // copy constructor Factored(const Factored &rval); // constructor A(3,5); Factored(int rows,int columns); // constructor A(3,5,w); Factored(int rows,int columns,float *initvalues); // constructor from Matrix Factored(const Matrix &rval); // make a submatrix with rows,columns Factored(int rows,int columns,const Matrix &rval); // as above, starting from irow,jcol Factored(int rows,int columns, int irow,int jcol,const Matrix &rval); // =========================================================== // ******************** destructor *********************** // =========================================================== virtual ~Factored(void); // =========================================================== // ************ Non-modifying access functions *********** // =========================================================== // number of rows int Rows(void) const {return numRows;} // number of columns int Columns(void) const {return numColumns;} int WhoAmI(void) const {return whoAmI;} // receives values with control float GetValue(int row,int col) const; Vector GetRow(int i) const; // row i of matrix Vector GetColumn(int j) const; // column j of matrix // =========================================================== // ************ Modifying access functions *************** // =========================================================== //assigning values with control void SetValue(int row,int column,float val); // assigning and receiving values of vectors with control float &operator () (int row,int col); // row i = rval void SetRow(int i,const Vector &rval); // column j = rval void SetColumn(int j,const Vector &rval); // =========================================================== // *************** assignment operators ******************* // =========================================================== // transforms a Matrix in Factored // creates an independent matrix virtual void CopyFromMatrix(const Matrix &rval); // transforms a Matrix in Factored // Matrix is destroyed friend void CommuteMatrixToFactored (Matrix *lval,Factored *rval); // =========================================================== // =========== Non-modifying functions =================== // =========================================================== // ***********************< Print >*************************** void Print(char *msg=""); // =========================================================== // =========== Modifying functions ======================= // =========================================================== friend void Delete(Factored *result); double Determinant(void); float ConditionNumber(void); char Singular(void); // 1 if singular 0 if not singular void Inverse(Matrix *inv); Matrix Inverse(void); }; #endif FACTORED_HPP