Tekkotsu Homepage

Demos

Overview

Downloads

Dev. Resources

Reference

Credits

newmat.h Go to the documentation of this file. //$$ newmat.h definition file for new version of matrix package // Copyright (C) 1991,2,3,4,7,2000,2,3: R B Davies #ifndef NEWMAT_LIB #define NEWMAT_LIB 0 #include "include.h" #include "myexcept.h" #ifdef use_namespace namespace NEWMAT { using namespace RBD_COMMON; } namespace RBD_LIBRARIES { using namespace NEWMAT; } namespace NEWMAT { #endif //#define DO_REPORT // to activate REPORT #ifdef NO_LONG_NAMES #define UpperTriangularMatrix UTMatrix #define LowerTriangularMatrix LTMatrix #define SymmetricMatrix SMatrix #define DiagonalMatrix DMatrix #define BandMatrix BMatrix #define UpperBandMatrix UBMatrix #define LowerBandMatrix LBMatrix #define SymmetricBandMatrix SBMatrix #define BandLUMatrix BLUMatrix #endif // ************************** general utilities ****************************/ class GeneralMatrix; void MatrixErrorNoSpace(const void*); // no space handler class LogAndSign // Return from LogDeterminant function // - value of the log plus the sign (+, - or 0) { Real log_value; int sign; public: LogAndSign() { log_value=0.0; sign=1; } LogAndSign(Real); void operator*=(Real); void PowEq(int k); // raise to power of k void ChangeSign() { sign = -sign; } Real LogValue() const { return log_value; } int Sign() const { return sign; } Real Value() const; FREE_CHECK(LogAndSign) }; // the following class is for counting the number of times a piece of code // is executed. It is used for locating any code not executed by test // routines. Use turbo GREP locate all places this code is called and // check which ones are not accessed. // Somewhat implementation dependent as it relies on "cout" still being // present when ExeCounter objects are destructed. #ifdef DO_REPORT class ExeCounter { int line; // code line number int fileid; // file identifier long nexe; // number of executions static int nreports; // number of reports public: ExeCounter(int,int); void operator++() { nexe++; } ~ExeCounter(); // prints out reports }; #endif // ************************** class MatrixType *****************************/ // Is used for finding the type of a matrix resulting from the binary operations // +, -, * and identifying what conversions are permissible. // This class must be updated when new matrix types are added. class GeneralMatrix; // defined later class BaseMatrix; // defined later class MatrixInput; // defined later class MatrixType { public: enum Attribute { Valid = 1, Diagonal = 2, // order of these is important Symmetric = 4, Band = 8, Lower = 16, Upper = 32, Square = 64, Skew = 128, LUDeco = 256, Ones = 512 }; enum { US = 0, UT = Valid + Upper + Square, LT = Valid + Lower + Square, Rt = Valid, Sq = Valid + Square, Sm = Valid + Symmetric + Square, Sk = Valid + Skew + Square, Dg = Valid + Diagonal + Band + Lower + Upper + Symmetric + Square, Id = Valid + Diagonal + Band + Lower + Upper + Symmetric + Square + Ones, RV = Valid, // do not separate out CV = Valid, // vectors BM = Valid + Band + Square, UB = Valid + Band + Upper + Square, LB = Valid + Band + Lower + Square, SB = Valid + Band + Symmetric + Square, Ct = Valid + LUDeco + Square, BC = Valid + Band + LUDeco + Square, Mask = ~Square }; static int nTypes() { return 12; } // number of different types // exclude Ct, US, BC public: int attribute; bool DataLossOK; // true if data loss is OK when // this represents a destination public: MatrixType () : DataLossOK(false) {} MatrixType (int i) : attribute(i), DataLossOK(false) {} MatrixType (int i, bool dlok) : attribute(i), DataLossOK(dlok) {} MatrixType (const MatrixType& mt) : attribute(mt.attribute), DataLossOK(mt.DataLossOK) {} void operator=(const MatrixType& mt) { attribute = mt.attribute; DataLossOK = mt.DataLossOK; } void SetDataLossOK() { DataLossOK = true; } int operator+() const { return attribute; } MatrixType operator+(MatrixType mt) const { return MatrixType(attribute & mt.attribute); } MatrixType operator*(const MatrixType&) const; MatrixType SP(const MatrixType&) const; MatrixType KP(const MatrixType&) const; MatrixType operator|(const MatrixType& mt) const { return MatrixType(attribute & mt.attribute & Valid); } MatrixType operator&(const MatrixType& mt) const { return MatrixType(attribute & mt.attribute & Valid); } bool operator>=(MatrixType mt) const { return ( attribute & ~mt.attribute & Mask ) == 0; } bool operator<(MatrixType mt) const // for MS Visual C++ 4 { return ( attribute & ~mt.attribute & Mask ) != 0; } bool operator==(MatrixType t) const { return (attribute == t.attribute); } bool operator!=(MatrixType t) const { return (attribute != t.attribute); } bool operator!() const { return (attribute & Valid) == 0; } MatrixType i() const; // type of inverse MatrixType t() const; // type of transpose MatrixType AddEqualEl() const // Add constant to matrix { return MatrixType(attribute & (Valid + Symmetric + Square)); } MatrixType MultRHS() const; // type for rhs of multiply MatrixType sub() const // type of submatrix { return MatrixType(attribute & Valid); } MatrixType ssub() const // type of sym submatrix { return MatrixType(attribute); } // not for selection matrix GeneralMatrix* New() const; // new matrix of given type GeneralMatrix* New(int,int,BaseMatrix*) const; // new matrix of given type const char* Value() const; // to print type friend bool Rectangular(MatrixType a, MatrixType b, MatrixType c); friend bool Compare(const MatrixType&, MatrixType&); // compare and check conv. bool IsBand() const { return (attribute & Band) != 0; } bool IsDiagonal() const { return (attribute & Diagonal) != 0; } bool IsSymmetric() const { return (attribute & Symmetric) != 0; } bool CannotConvert() const { return (attribute & LUDeco) != 0; } // used by operator== FREE_CHECK(MatrixType) }; // *********************** class MatrixBandWidth ***********************/ class MatrixBandWidth { public: int lower; int upper; MatrixBandWidth(const int l, const int u) : lower(l), upper (u) {} MatrixBandWidth(const int i) : lower(i), upper(i) {} MatrixBandWidth operator+(const MatrixBandWidth&) const; MatrixBandWidth operator*(const MatrixBandWidth&) const; MatrixBandWidth minimum(const MatrixBandWidth&) const; MatrixBandWidth t() const { return MatrixBandWidth(upper,lower); } bool operator==(const MatrixBandWidth& bw) const { return (lower == bw.lower) && (upper == bw.upper); } bool operator!=(const MatrixBandWidth& bw) const { return !operator==(bw); } int Upper() const { return upper; } int Lower() const { return lower; } FREE_CHECK(MatrixBandWidth) }; // ********************* Array length specifier ************************/ // This class is introduced to avoid constructors such as // ColumnVector(int) // being used for conversions class ArrayLengthSpecifier { int value; public: int Value() const { return value; } ArrayLengthSpecifier(int l) : value(l) {} }; // ************************* Matrix routines ***************************/ class MatrixRowCol; // defined later class MatrixRow; class MatrixCol; class MatrixColX; class GeneralMatrix; // defined later class AddedMatrix; class MultipliedMatrix; class SubtractedMatrix; class SPMatrix; class KPMatrix; class ConcatenatedMatrix; class StackedMatrix; class SolvedMatrix; class ShiftedMatrix; class NegShiftedMatrix; class ScaledMatrix; class TransposedMatrix; class ReversedMatrix; class NegatedMatrix; class InvertedMatrix; class RowedMatrix; class ColedMatrix; class DiagedMatrix; class MatedMatrix; class GetSubMatrix; class ReturnMatrix; class Matrix; class SquareMatrix; class nricMatrix; class RowVector; class ColumnVector; class SymmetricMatrix; class UpperTriangularMatrix; class LowerTriangularMatrix; class DiagonalMatrix; class CroutMatrix; class BandMatrix; class LowerBandMatrix; class UpperBandMatrix; class SymmetricBandMatrix; class LinearEquationSolver; class GenericMatrix; #define MatrixTypeUnSp 0 //static MatrixType MatrixTypeUnSp(MatrixType::US); // // AT&T needs this class BaseMatrix : public Janitor // base of all matrix classes { protected: virtual int search(const BaseMatrix*) const = 0; // count number of times matrix // is referred to public: virtual GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp) = 0; // evaluate temporary // for old version of G++ // virtual GeneralMatrix* Evaluate(MatrixType mt) = 0; // GeneralMatrix* Evaluate() { return Evaluate(MatrixTypeUnSp); } AddedMatrix operator+(const BaseMatrix&) const; // results of operations MultipliedMatrix operator*(const BaseMatrix&) const; SubtractedMatrix operator-(const BaseMatrix&) const; ConcatenatedMatrix operator|(const BaseMatrix&) const; StackedMatrix operator&(const BaseMatrix&) const; ShiftedMatrix operator+(Real) const; ScaledMatrix operator*(Real) const; ScaledMatrix operator/(Real) const; ShiftedMatrix operator-(Real) const; TransposedMatrix t() const; // TransposedMatrix t; NegatedMatrix operator-() const; // change sign of elements ReversedMatrix Reverse() const; InvertedMatrix i() const; // InvertedMatrix i; RowedMatrix AsRow() const; ColedMatrix AsColumn() const; DiagedMatrix AsDiagonal() const; MatedMatrix AsMatrix(int,int) const; GetSubMatrix SubMatrix(int,int,int,int) const; GetSubMatrix SymSubMatrix(int,int) const; GetSubMatrix Row(int) const; GetSubMatrix Rows(int,int) const; GetSubMatrix Column(int) const; GetSubMatrix Columns(int,int) const; Real AsScalar() const; // conversion of 1 x 1 matrix virtual LogAndSign LogDeterminant() const; Real Determinant() const; virtual Real SumSquare() const; Real NormFrobenius() const; virtual Real SumAbsoluteValue() const; virtual Real Sum() const; virtual Real MaximumAbsoluteValue() const; virtual Real MaximumAbsoluteValue1(int& i) const; virtual Real MaximumAbsoluteValue2(int& i, int& j) const; virtual Real MinimumAbsoluteValue() const; virtual Real MinimumAbsoluteValue1(int& i) const; virtual Real MinimumAbsoluteValue2(int& i, int& j) const; virtual Real Maximum() const; virtual Real Maximum1(int& i) const; virtual Real Maximum2(int& i, int& j) const; virtual Real Minimum() const; virtual Real Minimum1(int& i) const; virtual Real Minimum2(int& i, int& j) const; virtual Real Trace() const; Real Norm1() const; Real NormInfinity() const; virtual MatrixBandWidth BandWidth() const; // bandwidths of band matrix virtual void CleanUp() {} // to clear store void IEQND() const; // called by ineq. ops // virtual ReturnMatrix Reverse() const; // reverse order of elements //protected: // BaseMatrix() : t(this), i(this) {} friend class GeneralMatrix; friend class Matrix; friend class SquareMatrix; friend class nricMatrix; friend class RowVector; friend class ColumnVector; friend class SymmetricMatrix; friend class UpperTriangularMatrix; friend class LowerTriangularMatrix; friend class DiagonalMatrix; friend class CroutMatrix; friend class BandMatrix; friend class LowerBandMatrix; friend class UpperBandMatrix; friend class SymmetricBandMatrix; friend class AddedMatrix; friend class MultipliedMatrix; friend class SubtractedMatrix; friend class SPMatrix; friend class KPMatrix; friend class ConcatenatedMatrix; friend class StackedMatrix; friend class SolvedMatrix; friend class ShiftedMatrix; friend class NegShiftedMatrix; friend class ScaledMatrix; friend class TransposedMatrix; friend class ReversedMatrix; friend class NegatedMatrix; friend class InvertedMatrix; friend class RowedMatrix; friend class ColedMatrix; friend class DiagedMatrix; friend class MatedMatrix; friend class GetSubMatrix; friend class ReturnMatrix; friend class LinearEquationSolver; friend class GenericMatrix; NEW_DELETE(BaseMatrix) }; // ***************************** working classes **************************/ class GeneralMatrix : public BaseMatrix // declarable matrix types { virtual GeneralMatrix* Image() const; // copy of matrix protected: int tag; // shows whether can reuse int nrows_value, ncols_value; // dimensions int storage; // total store required Real* store; // point to store (0=not set) GeneralMatrix(); // initialise with no store GeneralMatrix(ArrayLengthSpecifier); // constructor getting store void Add(GeneralMatrix*, Real); // sum of GM and Real void Add(Real); // add Real to this void NegAdd(GeneralMatrix*, Real); // Real - GM void NegAdd(Real); // this = this - Real void Multiply(GeneralMatrix*, Real); // product of GM and Real void Multiply(Real); // multiply this by Real void Negate(GeneralMatrix*); // change sign void Negate(); // change sign void ReverseElements(); // internal reverse of elements void ReverseElements(GeneralMatrix*); // reverse order of elements void operator=(Real); // set matrix to constant Real* GetStore(); // get store or copy GeneralMatrix* BorrowStore(GeneralMatrix*, MatrixType); // temporarily access store void GetMatrix(const GeneralMatrix*); // used by = and initialise void Eq(const BaseMatrix&, MatrixType); // used by = void Eq(const GeneralMatrix&); // version with no conversion void Eq(const BaseMatrix&, MatrixType, bool);// used by << void Eq2(const BaseMatrix&, MatrixType); // cut down version of Eq int search(const BaseMatrix*) const; virtual GeneralMatrix* Transpose(TransposedMatrix*, MatrixType); void CheckConversion(const BaseMatrix&); // check conversion OK void ReSize(int, int, int); // change dimensions virtual short SimpleAddOK(const GeneralMatrix* /*gm*/) { return 0; } // see bandmat.cpp for explanation virtual void MiniCleanUp() { store = 0; storage = 0; nrows_value = 0; ncols_value = 0; tag = -1;} // CleanUp when the data array has already been deleted void PlusEqual(const GeneralMatrix& gm); void MinusEqual(const GeneralMatrix& gm); void PlusEqual(Real f); void MinusEqual(Real f); void swap(GeneralMatrix& gm); // swap values public: GeneralMatrix* Evaluate(MatrixType mt=MatrixTypeUnSp); virtual MatrixType Type() const = 0; // type of a matrix int Nrows() const { return nrows_value; } // get dimensions int Ncols() const { return ncols_value; } int Storage() const { return storage; } Real* Store() const { return store; } // updated names int nrows() const { return nrows_value; } // get dimensions int ncols() const { return ncols_value; } int size() const { return storage; } Real* data() { return store; } const Real* data() const { return store; } const Real* const_data() const { return store; } virtual ~GeneralMatrix(); // delete store if set void tDelete(); // delete if tag permits bool reuse(); // true if tag allows reuse void Protect() { tag=-1; } // cannot delete or reuse int Tag() const { return tag; } bool IsZero() const; // test matrix has all zeros void Release() { tag=1; } // del store after next use void Release(int t) { tag=t; } // del store after t accesses void ReleaseAndDelete() { tag=0; } // delete matrix after use void operator<<(const Real*); // assignment from an array void operator<<(const int*); // assignment from an array void operator<<(const BaseMatrix& X) { Eq(X,this->Type(),true); } // = without checking type void Inject(const GeneralMatrix&); // copy stored els only void operator+=(const BaseMatrix&); void operator-=(const BaseMatrix&); void operator*=(const BaseMatrix&); void operator|=(const BaseMatrix&); void operator&=(const BaseMatrix&); void operator+=(Real); void operator-=(Real r) { operator+=(-r); } void operator*=(Real); void operator/=(Real r) { operator*=(1.0/r); } virtual GeneralMatrix* MakeSolver(); // for solving virtual void Solver(MatrixColX&, const MatrixColX&) {} virtual void GetRow(MatrixRowCol&) = 0; // Get matrix row virtual void RestoreRow(MatrixRowCol&) {} // Restore matrix row virtual void NextRow(MatrixRowCol&); // Go to next row virtual void GetCol(MatrixRowCol&) = 0; // Get matrix col virtual void GetCol(MatrixColX&) = 0; // Get matrix col virtual void RestoreCol(MatrixRowCol&) {} // Restore matrix col virtual void RestoreCol(MatrixColX&) {} // Restore matrix col virtual void NextCol(MatrixRowCol&); // Go to next col virtual void NextCol(MatrixColX&); // Go to next col Real SumSquare() const; Real SumAbsoluteValue() const; Real Sum() const; Real MaximumAbsoluteValue1(int& i) const; Real MinimumAbsoluteValue1(int& i) const; Real Maximum1(int& i) const; Real Minimum1(int& i) const; Real MaximumAbsoluteValue() const; Real MaximumAbsoluteValue2(int& i, int& j) const; Real MinimumAbsoluteValue() const; Real MinimumAbsoluteValue2(int& i, int& j) const; Real Maximum() const; Real Maximum2(int& i, int& j) const; Real Minimum() const; Real Minimum2(int& i, int& j) const; LogAndSign LogDeterminant() const; virtual bool IsEqual(const GeneralMatrix&) const; // same type, same values void CheckStore() const; // check store is non-zero virtual void SetParameters(const GeneralMatrix*) {} // set parameters in GetMatrix operator ReturnMatrix() const;