---

Matrix.h

Go to the documentation of this file.

//
//    Title     :  Matrix.h
//    Project     :  OSCAR Version 2.0
//    Created     :  2/10/1995
//    Author      :  Chetan Kapoor and S. M. Orlow (NIH), Murat Cetin (MATLAB)
//    Platforms   :  All
//    Copyright   :  Copyright, The University of Texas at Austin, 2002. All rights reserved.
//
//          This software and documentation constitute an unpublished work
//          and contain valuable trade secrets and proprietary information
//          belonging to the University. None of the foregoing material may be
//          copied or duplicated or disclosed without the express, written
//          permission of University. THE UNIVERSITY EXPRESSLY DISCLAIMS ANY
//          AND ALL WARRANTIES CONCERNING THIS SOFTWARE AND DOCUMENTATION,
//          INCLUDING ANY WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//          PARTICULAR PURPOSE, AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY
//          THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF TRADE.
//          NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO THE USE OF
//          THE SOFTWARE OR DOCUMENTATION. Under no circumstances shall the
//          University be liable for incidental, special, indirect, direct or
//          consequential damages or loss of profits, interruption of business,
//          or related expenses which may arise from use of software or documentation,
//          including but not limited to those resulting from defects in software
//          and/or documentation, or loss or inaccuracy of data of any kind.
//
//    Purpose     :  Matrix declares the class Matrix
//
//-----------------------------------------------------------------------------
//
//    Classes     :  Matrix, MatrixCol, MatrixRow
//
//    Global
//    Functions   :  ostream& operator<<(ostream& strm,const Matrix& m);
//             ostream& operator<<(ostream& strm,const MatrixRow& m);
//                   ostream& operator<<(ostream& strm,const MatrixCol& m);
//
//-----------------------------------------------------------------------------
//
//    $Revisions$  1.1 1 /usr/Components/src/SCCS/s.Matrix.hpp /usr/Components/src/SCCS/s.Matrix.hpp
//        Added GetRow, GetCol, SetRow, SetCol on Dec. 17, 2001 - chetan kapoor
//        Added constructor Matrix(unsigned int,unsigned int,const Vector&,
//                                       OSCARError*,const String&) - Troy Harden 1/17/2002
//        Modified constructor Matrix(unsigned int,unsigned int,const Vector&,
//                                       OSCARError&,const String&) - Chetan Kapoor 3/25/2002
//        Added MatrixNorm method that does not require Matlab - Mark Tisius 9/25/2002
//        Removed coFactor methods because they didn't work correctly and they didn't even
//                                       take the determinant - Mark Tisius 10/1/02
//        Removed PolarDecomp method because no implementation existed - Mark Tisius 10/9/02
//        Made inverses virtual and moved global multiply and operator* to utilities - Mark Tisius 10/13/02
//        Changed 'at' and 'operator()' methods to enforce constness, added non-const versions - Ethan Swint 8/12/03
//
//    $Log: Matrix.h,v $
//    Revision 1.32  2005/03/18 23:05:24  chetan
//    Fixed g++ compile warnings. Removed virtual inheritance from Base, added initialization of base class in copy constructors, added newline at EOF
//
//    Revision 1.31  2005/03/14 22:04:21  pmarch
//    Added to namespace OSCAR and removed "RR" from front of class names.
//
//    Revision 1.30  2005/03/10 17:12:41  josh
//    Added LUSolve to Matrix and updated EqnSolver accordingly.
//
//    Revision 1.29  2005/03/07 21:21:01  josh
//    Added Cholesky Decomposition.
//
//    Revision 1.28  2005/01/06 17:54:02  josh
//    Added scratch vectors to help speed up the SpeedInverse method.  Changed constrctuors and destructors accordingly
//
//    Revision 1.27  2005/01/06 16:37:46  chetan
//    Added a scratch matrix to help speed up the SpeedInverse method.  Changed constrctuors and destructors accordingly
//
//    Revision 1.26  2004/11/05 17:31:46  chetan
//    Added method ToFlatString()
//
//    Revision 1.25  2004/07/26 22:25:22  chetan
//    Made changes to compile with Warning Level 4 and also under the latest C++ standard. Also made compilable with VC extensions turned off
//
//    Revision 1.24  2004/07/19 16:46:29  edjung
//    -changed copy and operator= to take a const reference for ANSI compliance
//
//    Revision 1.23  2004/07/19 16:37:01  edjung
//    -made fix to constructors for ANSI C++ compliance with temporary OSCARError objects
//    -added DUMMY_ERROR class
//
//    Revision 1.22  2004/06/10 19:11:56  aspencer
//    Added /ingroup tags.
//
//    Revision 1.21  2004/06/04 21:58:33  chetan
//    using namespace std in CommIncludes.h was removed. std:: was added anywhere STL components such as iostream and vector were being used
//
//    Revision 1.20  2004/06/04 20:09:42  chetan
//    Changed all local Matrix and new int[], new double[] code in method calls to use static Matrix, static VectorI, and static Vector respectively. This change is based on the assumption that an Matrix object cannot be resized
//
//    Revision 1.19  2004/05/26 20:01:58  pmarch
//    Added /defgroup and /ingroup tags.
//
//    Revision 1.18  2004/01/27 17:06:30  pmarch
//    Various commenting fixes.
//
//    Revision 1.17  2004/01/26 20:54:33  pmarch
//    Fixed documentation errors as reported by Doxygen.
//
//    Revision 1.16  2003/10/06 09:13:32  edjung
//    -Changed constructors to use String() instead of String("")
//
//    Revision 1.15  2003/09/11 03:00:20  eswint
//    - Changed signatures of public methods combineRows and upperTriangular to CombineRows and UpperTriangular
//
//    Revision 1.14  2003/09/10 22:53:27  eswint
//    - Changed signature of max() to Max() to avoid naming conflict with macro.
//
//    Revision 1.13  2003/09/09 17:09:36  eswint
//    - Corrected Multply(Vector rhs, Vector result)
//
//    Revision 1.12  2003/09/05 02:08:57  eswint
//    - Corrected documentation for SwitchRows and SwitchCols
//
//    Revision 1.11  2003/09/04 22:53:06  eswint
//    - Changed default arguments: OSCARError(0,"No Error"...) to OSCARError(noError) and String(" ") to String("")
//    - Added GetArray() methods (const & non-const) to allow fast data access
//
//    Revision 1.10  2003/09/02 20:29:13  eswint
//    - Added Multiply methods for matrices and vectors, avoids construction of temporaries
//
//    Revision 1.9  2003/08/28 20:37:17  eswint
//    - Changed unary assignment operators to return a reference to the object
//    - Added default constructor argument bool initMtx = true
//
//    Revision 1.8  2003/08/26 03:29:08  eswint
//    - Changed signature of the norm() method (misnomer) to max()
//
//    Revision 1.7  2003/08/26 01:50:49  eswint
//    - Changed signature of MatrixRow::operator^ to operator* as it is mathematically defined and standard notation
//
//    Revision 1.6  2003/08/26 01:30:17  eswint
//    - Modified MatrixRow and MatrixCol classes to preserve constness of parent matrix
//    - Disallowed copy or assignment from const MatrixRow or const MatrixCol objects
//
//    Revision 1.5  2003/08/25 22:18:54  eswint
//    - Changed signature of switchRows and switchCols to SwitchRows and SwitchCols
//
//    Revision 1.4  2003/08/25 21:07:42  eswint
//    - Added basic math operators
//    - Changed signature of sameSize(int,int) to SameSize(Matrix)
//    - Added operator[] to Matrix and MatrixRow to allow built-in 2-D array syntax to be used
//
//    Revision 1.3  2003/08/19 02:27:20  eswint
//    Modified the .at(int) to maintain const-ness for MatrixRow and MatrixCol.  Required const member function returning const reference to member, and non-const m.f. returning non-const reference.
//
//    Revision 1.2  2003/08/18 18:22:53  eswint
//    Project files updated to include Matlab libs
//
//    Revision 1.1  2003/08/18 15:23:32  eswint
//    Initial Commit
//
//        Checked in at 14:22:35 on 12 Oct 1995
//
#ifndef Matrix_hpp
#define Matrix_hpp

#include "MathDefs.h"
#include "Base/Base.h"
#include "Base/BaseError.h"
#include "MathErrors.h"
#include "Vector.h"

namespace OSCAR {

  class MatrixCol;
  class MatrixRow;

  typedef double* DoubleP;

  class Matrix  : public Base
  {

  public:

    Matrix(unsigned int nr,unsigned int nc, const double* f=0, const String& name = String(),bool initMtx = true);

    Matrix(unsigned int nr,unsigned int nc,const Vector& v,
      OSCARError &err = DUMMY_ERROR(noError),
      const String& name = String());

    Matrix(unsigned int k, double* f, const String& name = String());

    Matrix(const MatrixRow& rhs);

    Matrix(const MatrixCol& rhs);

    Matrix(const Matrix& rhs);

    virtual ~Matrix();

    double& at(unsigned int irow,unsigned int icol);

    const double& at(unsigned int irow,unsigned int icol) const;

    /*
     * \brief Overloaded operator()
     *
     *  This overloaded operator() is used to access an element of an Matrix object. It just internally
     *  calls the .at method. This method is the similar to the .at() method except it performs range
     *  checking in all modes.  This method is slower than .at(), but it will never return garbage if a
     *  cell that is out of range is specified.  An Error is returned if the matrix does not contain the
     *  cell specified.
     * \param irow The row position - 0 is the first row.
     * \param icol The column position - 0 is the first column.
     * \return The Matrix element specified.
     * \exception outOfRange #outOfRange
     */
    double& operator()(unsigned int irow,unsigned int icol);

    /*
     * \brief Overloaded operator()
     *
     *  This overloaded operator() is used to access an element of an Matrix object. It just internally
     *  calls the .at method. This method is the similar to the .at() method except it performs range
     *  checking in all modes.  This method is slower than .at(), but it will never return garbage if a
     *  cell that is out of range is specified.  An Error is returned if the matrix does not contain the
     *  cell specified.
     * \param irow The row position - 0 is the first row.
     * \param icol The column position - 0 is the first column.
     * \return The Matrix element specified.
     * \exception outOfRange #outOfRange
     */
    const double& operator()(unsigned int irow, unsigned int icol) const;

     MatrixRow GetRow(unsigned int row);

     const MatrixRow GetRow(unsigned int row) const;

    MatrixRow operator[](unsigned int row);

    const MatrixRow operator[](unsigned int row) const;

    bool SetRow(unsigned int row,const MatrixRow& rowObject);

    MatrixCol GetCol(unsigned int col);

    const MatrixCol GetCol(unsigned int col) const;

    bool SetCol(unsigned int col,const MatrixCol& colObject);

    unsigned int nRow() const;

    unsigned int nCol() const;

    bool isSquare() const;

    bool SameSize(const Matrix& m) const;

    Matrix& operator=(const Matrix& rhs);

    Matrix& operator=(double rhs);

  
    bool Copy(const Matrix& matrixToCopy);

    bool operator==(const Matrix& rhs) const;

    Matrix& operator*=(double d);

    Matrix& operator/=(double d);

    Matrix& operator+=(const Matrix& rhs);

    Matrix& operator-=(const Matrix& rhs);

    Matrix& operator*=(const Matrix& m);

    Matrix operator+(const Matrix& rhs) const;

    Matrix operator-(const Matrix& rhs) const;

    Matrix operator-() const;

    Matrix operator*(double d) const;

    bool Multiply(const Matrix& rhs, Matrix& result) const;

    bool Multiply(const Vector& vec, Vector& result) const;

    Vector operator*(const Vector& rhs) const;

    Matrix operator*(const Matrix& rhs) const;

    Matrix operator/(double d) const;

    Matrix operator&(const Matrix& rhs) const;

    bool SwitchRows(unsigned int r1, unsigned int r2);

    bool SwitchCols(unsigned int c1, unsigned int c2);

    void CombineRows(unsigned int i, double b, unsigned int j);

    double Max() const;

    bool Identity();

    Matrix t() const;

    bool t(Matrix& rhs) const;

    bool MultiplyWithTranspose(Matrix& result) const;

    bool isUpperTriangle() const;

    Matrix UpperTriangle();

    bool LUDecomposition(int* indx, double* d);

    void LUFowBackSubstitution(const int *indx, double b[]) const;

    bool LUSolve(const Vector& b, Vector& x, double& determinant) const;

    bool CholeskyDecomposition();

    void CholeskyFowBackSubstitution(double b[], double x[]) const;

    bool CholeskySolve(const Vector& b, Vector& x, double& determinant) const;

    bool Determinant(double& det) const;

    virtual bool Inverse(Matrix& inverse) const;

    virtual bool Inverse(Matrix& inverse, double& determinant) const;

    virtual bool SpeedInverse(Matrix& inverse, double& determinant) const;

    Matrix    operator~() const;

    bool PseudoInvSVD(Matrix &inverse, double weight=.0001) const;

    bool SVD(Matrix& U, Vector& W, Matrix& V) const;


    //  The Non-matlab version of EigenValues is not working.

    bool EigenValues(Vector& W) const;

    double MatrixNorm(double P) const;

    String  ToFlatString() const;


  #ifdef MATLAB

    bool EigenVectors(Matrix& EIGVEC, Vector& DIAG) const;

    double CondNo(double P) const;

    double  Subspace(Matrix& A) const;

  #endif // ifdef MATLAB

    virtual void printOn(std::ostream& out) const;

    virtual void dumpOn(std::ostream& out) const;

    void sizeError(char* where,unsigned int a,unsigned int b) const;

    const double* GetArray() const;

    double* GetArray();

  protected:

    unsigned int  nrow, ncol;   //Number of rows, Number of columns in the Matrix

    DoubleP *_row;

    double  *_m;
    mutable Matrix  *scratchMatrix_NbyM;
    mutable VectorI *scratchIndxVectorI_M;
    mutable Vector  *scratchColVector_M;

    Matrix(const String& name = String());

    virtual void m_alloc(unsigned int rows, unsigned int cols);
  };


  class MatrixCol : public virtual Base
  {
  public:

    MatrixCol(unsigned int col, const Matrix& m, const String& name = "");


    MatrixCol(const MatrixCol& rhs);


    unsigned int nRow() const;


    double& at(unsigned int i);

    const double& at(unsigned int i) const;

    double& operator()(unsigned int i);

    const double& operator()(unsigned int i) const;

    Matrix Cross(const MatrixCol& b);


    MatrixCol& operator=(const MatrixCol& rhs);

    void operator+=(const MatrixCol& rhs);


    virtual void printOn(std::ostream& out) const;

  protected:
    const Matrix*   pm;
    unsigned int      _col;    // index of this column
  };





  class MatrixRow : public virtual Base
  {
  public:

    MatrixRow(unsigned int row, const Matrix& m, const String& name = "");


    MatrixRow(const MatrixRow& rhs);


    unsigned int nCol() const;


    double& at(unsigned int i);

    const double& at(unsigned int i) const;

    double& operator()(unsigned int i);

    const double& operator()(unsigned int i) const;

    double operator*(const MatrixCol& rhs) const;

    MatrixRow& operator=(const MatrixRow& rhs);

    double& operator[](unsigned int j);

    const double& operator[](unsigned int j) const;

    virtual void printOn(std::ostream& out) const;

  protected:
    const Matrix* pm;
    unsigned int _row;    // index of this row
  };

  extern std::ostream& operator<<(std::ostream& out, const Matrix& m);

  extern std::ostream& operator<<(std::ostream& out,const MatrixRow& m);

  extern std::ostream& operator<<(std::ostream& out,const MatrixCol& m);

  #include "Matrix.ipp"
}
#endif // ifdef Matrix_hpp

RRG Homepage

OSCAR Overview

OSCAR Tutorials

Simulations