Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

/magnus/back_end/Matrix/include/Matrix.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: Matrix.h,v 1.6 2000/02/09 22:39:19 bormotov Exp $
00003  */
00004 
00005 // Copyright (C) 1996 The New York Group Theory Cooperative
00006 // See magnus/doc/COPYRIGHT for the full notice.
00007 //
00008 // Contents: Definition of class Matrix.
00009 //
00010 // Principal Author: Dmitry Bormotov, Alexey Myasnikov
00011 //
00012 // Status: Useable
00013 //
00014 // Usage:
00015 //
00016 // Revision History:
00017 //
00018 //
00019 
00020 
00021 #ifndef _MATRIX_H_
00022 #define _MATRIX_H_
00023 
00024 #include "DArray.h"
00025 #include "DerivedObjectOf.h"
00026 
00027 //------------------------------------------------------------------------//
00028 //------------------------------- MatrixRep ------------------------------//
00029 //------------------------------------------------------------------------//
00030 
00031 
00032 template <class R> class MatrixRep : public DArrayRep<R> {
00033 
00034 public:
00035 
00036 
00037   /////////////////////////////////////////////////////////////////////////
00038   //                                                                     //
00039   // Constructors:                                                       //
00040   //                                                                     //
00041   /////////////////////////////////////////////////////////////////////////
00042   MatrixRep( int height, int width) : DArrayRep<R>(height,width) {}
00043   // Makes MatrixRep with height == h and width == w
00044 
00045   MatrixRep( int n ) : DArrayRep<R>(n) {}
00046   // Makes MatrixRep with height=width=n
00047 
00048   MatrixRep* clone( ) { return new MatrixRep(*this); }
00049   /////////////////////////////////////////////////////////////////////////
00050   //                                                                     //
00051   // Operators:                                                          //
00052   //                                                                     //
00053   /////////////////////////////////////////////////////////////////////////
00054 
00055   MatrixRep& operator += ( const MatrixRep& );
00056 
00057   MatrixRep& operator -= ( const MatrixRep& );
00058 
00059   MatrixRep& operator *= ( const MatrixRep& );  
00060 
00061   MatrixRep operator + ( const MatrixRep& ) const; 
00062 
00063   MatrixRep operator - ( const MatrixRep& ) const; 
00064 
00065   MatrixRep operator * ( const MatrixRep& ) const; 
00066 
00067   MatrixRep operator - ( ) const;
00068 
00069 
00070   /////////////////////////////////////////////////////////////////////////
00071   //                                                                     //
00072   // Accessors:                                                          //
00073   //                                                                     //
00074   /////////////////////////////////////////////////////////////////////////
00075 
00076 private:
00077 
00078   /////////////////////////////////////////////////////////////////////////
00079   //                                                                     //
00080   //  Debugging stuff:                                                   //
00081   //                                                                     //
00082   /////////////////////////////////////////////////////////////////////////
00083 
00084 #ifdef DEBUG
00085 
00086   //friend int main( );
00087 
00088 #endif
00089 
00090 };
00091 
00092 //------------------------------------------------------------------------//
00093 //------------------------------- Matrix    ------------------------------//
00094 //------------------------------------------------------------------------//
00095 
00096 
00097 template <class R> class Matrix : public DerivedObjectOf<DArray<R> ,MatrixRep<R> >{
00098 
00099 public:
00100 
00101 
00102   /////////////////////////////////////////////////////////////////////////
00103   //                                                                     //
00104   // Constructors:                                                       //
00105   //                                                                     //
00106   /////////////////////////////////////////////////////////////////////////
00107   Matrix(int n = 0 ) : DerivedObjectOf<DArray<R>,MatrixRep<R> >(new MatrixRep<R>(n)) { }
00108   // Makes Matrix with height=width=n
00109 
00110 
00111   Matrix(int h, int w) : DerivedObjectOf<DArray<R>,MatrixRep<R> >(new MatrixRep<R>(h, w)){ }
00112   // Makes Matrix with height == h and width == w
00113 
00114   // copy constructor supplied by compiler
00115 
00116   /////////////////////////////////////////////////////////////////////////
00117   //                                                                     //
00118   // Operators:                                                          //
00119   //                                                                     //
00120   /////////////////////////////////////////////////////////////////////////
00121 
00122   Matrix& operator += ( const Matrix& M ) {
00123      *change() += *(M.look());
00124      return *this;
00125   }
00126 
00127   Matrix& operator -= ( const Matrix& M ) {
00128      *change() -= *(M.look());
00129      return *this;
00130   }
00131 
00132   Matrix& operator *= ( const Matrix& M ) {
00133       *change() *= *(M.look());
00134       return *this;
00135   }
00136   Matrix operator + ( const Matrix& M) const {
00137            return Matrix(*look() + *(M.look())); } 
00138 
00139   Matrix operator - ( const Matrix& M ) const {
00140            return Matrix(*look() - *(M.look())); } 
00141 
00142   Matrix operator * ( const Matrix& M ) const {
00143            return Matrix(*look() * *(M.look())); } 
00144 
00145   Matrix operator - ( ) const {return Matrix(- *look());}
00146 
00147 
00148   /////////////////////////////////////////////////////////////////////////
00149   //                                                                     //
00150   // Accessors:                                                          //
00151   //                                                                     //
00152   /////////////////////////////////////////////////////////////////////////
00153 
00154 
00155   /////////////////////////////////////////////////////////////////////////
00156   //                                                                     //
00157   // I/O:                                                                //
00158   //                                                                     //
00159   /////////////////////////////////////////////////////////////////////////
00160 
00161   // Inherited from DArray  
00162 
00163   /////////////////////////////////////////////////////////////////////////
00164   //                                                                     //
00165   // IPC tools:                                                          //
00166   //                                                                     //
00167   /////////////////////////////////////////////////////////////////////////
00168 
00169   // Inherited from DArray  
00170 
00171   protected :
00172         Matrix( MatrixRep<R> newrep ) : 
00173             DerivedObjectOf<DArray<R>,MatrixRep<R> >(new MatrixRep<R>(newrep)) {}
00174         Matrix( MatrixRep<R>* newrep ) : 
00175             DerivedObjectOf<DArray<R>,MatrixRep<R> >(newrep) {}
00176 
00177 };
00178 
00179 #endif
00180 
00181 
00182 
00183 

Generated at Tue Jun 19 09:49:37 2001 for Magnus Classes by doxygen1.2.6 written by Dimitri van Heesch, © 1997-2001