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

Symmat.hh

Go to the documentation of this file.
00001 #ifndef SYMMAT_TMPL_HEADER
00002 #define SYMMAT_TMPL_HEADER
00003 
00004 // ==== HEADER Symmat.hh ====
00005 
00011 // 8-Dec-2000. Andras Aszodi
00012 
00013 // ---- COMPATIBILITY NOTES ----
00014 
00015 // Exception support is assumed.
00016 // This module depends on the Standard Template Library.
00017  
00018 // ---- COMPILER COMMAND LINE MACROS ----
00019 
00020 // Define the macro INCLUDE_TMPL_DEFS if your compiler
00021 // does not support automatic template source inclusion.
00022 
00023 // ---- MODULE HEADERS ----
00024 
00025 #include "Vector.hh"
00026 #include "Basemat.hh"
00027 #include "Rectmat.hh"
00028 #include "Squarexc.hh"
00029 
00030 // ==== CLASSES ====
00031 
00032 namespace RazorBack {
00033 
00038 template <class T_>
00039 class Symmat_: public Basemat_<T_>
00040 {
00041     // data
00042     private:
00043     
00044     /*
00045      * Layout information:-
00046      * The matrix elements are stored in "triangular" row major order.
00047      * 
00048      * 00
00049      * 10 11    --> 00 10 11 20 21 22
00050      * 20 21 22
00051      * 
00052      */
00053     size_t Size;        //< no. of rows and columns
00054     
00055     // methods
00056     public:
00057     
00059     explicit Symmat_(size_t S=3)
00060     {
00061         if (!S) S=3;
00062         Size=S;
00063         Matstorage_<T_> *Newmat=new Matstorage_<T_>(tri_size(S));
00064         replace_storage(Newmat);        // alloc storage
00065     }
00066     
00068     Symmat_(const Symmat_<T_>& Sm):
00069             Basemat_<T_>(Sm), Size(Sm.rno()) {}
00070     
00075     Symmat_(const T_ *Arr, size_t S):
00076             Size(S)
00077     {
00078         Matstorage_<T_> *Newmat=new Matstorage_<T_>(tri_size(S));
00079         for (register unsigned int i=0; i<tri_size(S); i++)
00080             Newmat->elems()[i]=Arr[i];  // direct copy assuming same layout
00081         replace_storage(Newmat);
00082     }
00083     
00085     virtual ~Symmat_() {}
00086     
00088     
00090     operator Rectmat_<T_>() const;
00091     
00099     Symmat_<T_>& triangle(const Rectmat_<T_>& Rect, bool Low=true);
00100     
00102     
00104     virtual size_t rno() const { return Size; }
00105     virtual size_t cno() const { return Size; }
00106     
00112     virtual typename vector<T_>::const_iterator operator[](size_t Idx) const
00113         { return (elems().begin()+tri_size(Idx)); }
00114     virtual typename vector<T_>::iterator operator[](size_t Idx)
00115         { clone(); return (elems().begin()+tri_size(Idx)); }
00116     
00121     const T_& at(size_t Ridx, size_t Cidx) const
00122     {
00123         if (Ridx<Cidx) swap(Ridx, Cidx);
00124         return(elems(tri_size(Ridx)+Cidx));
00125     }
00126     T_& at(size_t Ridx, size_t Cidx)
00127     {
00128         clone();
00129         if (Ridx<Cidx) swap(Ridx, Cidx);
00130         return(elems(tri_size(Ridx)+Cidx));
00131     }
00132 
00139     virtual const T_& operator()(size_t Ridx, size_t Cidx) const;
00140     virtual T_& operator()(size_t Ridx, size_t Cidx);
00141     
00149     void size(size_t S);
00150 
00158     virtual Vector_<T_> row(size_t Idx) const;
00159     virtual void row(const Vector_<T_>& Vec, size_t Idx);
00160     virtual Vector_<T_> col(size_t Idx) const { return row(Idx); }
00161     virtual void col(const Vector_<T_>& Vec, size_t Idx) { row(Vec, Idx); }
00162 
00164     
00165     Symmat_<T_> operator*(const T_& Factor) const;
00166     Symmat_<T_> operator/(const T_& Div) const;
00167     
00169     
00174     Symmat_<T_>& operator+=(const Symmat_<T_>& Mat);
00175     Symmat_<T_> operator+(const Symmat_<T_>& Mat) const;
00176     Rectmat_<T_> operator+(const Rectmat_<T_>& Mat) const;
00177     Symmat_<T_>& operator-=(const Symmat_<T_>& Mat);
00178     Symmat_<T_> operator-(const Symmat_<T_>& Mat) const;
00180 
00186     Rectmat_<T_> operator*(const Symmat_<T_>& Mat) const;
00187     Rectmat_<T_> operator*(const Rectmat_<T_>& Mat) const;
00188     Vector_<T_> operator*(const Vector_<T_>& Vec) const;
00189 
00191     
00197     virtual Vector_<T_> diag() const;
00198     virtual void diag(const Vector_<T_>& Vec);
00199 
00204     virtual void diag_matrix(const T_& Dval);
00205 
00207     virtual T_ trace() const;
00208 
00210     virtual void read_matrix(istream& In);
00211     
00213     protected:
00214     
00215     void print_rows(ostream& Out, size_t Rw, size_t Jbeg, 
00216         size_t Items, size_t Width, size_t Prec) const;
00217     static unsigned int tri_size(unsigned int X) { return((X*(X+1))/2); }
00218 };
00219 // END OF CLASS Symmat_
00220 
00221 // ---- OUT-OF-CLASS FUNCTIONS ----
00222 
00223 // These were originally friend templates but EGCS 1.1.2
00224 // did not like them. 12-Jul-1999.
00225 
00226 template <class T_>
00227 Rectmat_<T_> operator+(const Rectmat_<T_>& R, const Symmat_<T_>& S)
00228     { return (S+R); }
00229 template <class T_>
00230 Rectmat_<T_> operator-(const Rectmat_<T_>& Mat, const Symmat_<T_>& Sym);
00231 template <class T_>
00232 Symmat_<T_> operator*(const T_& Factor, const Symmat_<T_>& Bm);
00233 template <class T_>
00234 Rectmat_<T_> operator*(const Rectmat_<T_>& Rect, const Symmat_<T_>& Sym);
00235 
00236 // ---- TYPEDEFS ----
00237 
00238 // Float and double matrices (for convenience)
00239 typedef Symmat_<double> Smatdbl_;
00240 typedef Symmat_<float> Smatflt_;
00241 
00242 } // RazorBack
00243 
00244 #ifdef INCLUDE_TMPL_DEFS
00245 #include "Symmat.cc"
00246 #endif
00247 
00248 // ==== END OF TEMPLATE HEADER Symmat.hh ====
00249 
00250 #endif      // SYMMAT_TMPL_HEADER

Generated at Wed Aug 21 09:33:22 2002 for The Razorback C++ Library: Linear Algebra by doxygen1.2.6 written by Dimitri van Heesch, © 1997-2001