include/root/TMatrixTLazy.h

0001 // @(#)root/matrix:$Id$
0002 // Authors: Fons Rademakers, Eddy Offermann   Nov 2003
0003
0004 /*************************************************************************
0005  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
0006  * All rights reserved.                                                  *
0007  *                                                                       *
0008  * For the licensing terms see $ROOTSYS/LICENSE.                         *
0009  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
0010  *************************************************************************/
0011
0012 #ifndef ROOT_TMatrixTLazy
0013 #define ROOT_TMatrixTLazy
0014
0015 //////////////////////////////////////////////////////////////////////////
0016 //                                                                      //
0017 // Templates of Lazy Matrix classes.                                    //
0018 //                                                                      //
0019 //   TMatrixTLazy                                                       //
0020 //   TMatrixTSymLazy                                                    //
0021 //   THaarMatrixT                                                       //
0022 //   THilbertMatrixT                                                    //
0023 //   THilbertMatrixTSym                                                 //
0024 //                                                                      //
0025 //////////////////////////////////////////////////////////////////////////
0026
0027 #include "TMatrixTBase.h"
0028
0029 template<class Element> class TVectorT;
0030 template<class Element> class TMatrixTBase;
0031 template<class Element> class TMatrixT;
0032 template<class Element> class TMatrixTSym;
0033
0034 //////////////////////////////////////////////////////////////////////////
0035 //                                                                      //
0036 // TMatrixTLazy                                                         //
0037 //                                                                      //
0038 // Class used to make a lazy copy of a matrix, i.e. only copy matrix    //
0039 // when really needed (when accessed).                                  //
0040 //                                                                      //
0041 //////////////////////////////////////////////////////////////////////////
0042
0043 template<class Element> class TMatrixTLazy : public TObject {
0044
0045 friend class TMatrixTBase<Element>;
0046 friend class TMatrixT    <Element>;
0047 friend class TVectorT    <Element>;
0048
0049 protected:
0050    Int_t fRowUpb;
0051    Int_t fRowLwb;
0052    Int_t fColUpb;
0053    Int_t fColLwb;
0054
0055    TMatrixTLazy(const TMatrixTLazy<Element> &) : TObject(), fRowUpb(0),fRowLwb(0),fColUpb(0),fColLwb(0) { }
0056    void operator=(const TMatrixTLazy<Element> &) { }
0057
0058 private:
0059    virtual void FillIn(TMatrixT<Element> &m) const = 0;
0060
0061 public:
0062    TMatrixTLazy() { fRowUpb = fRowLwb = fColUpb = fColLwb = 0; }
0063    TMatrixTLazy(Int_t nrows, Int_t ncols)
0064        : fRowUpb(nrows-1),fRowLwb(0),fColUpb(ncols-1),fColLwb(0) { }
0065    TMatrixTLazy(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb)
0066        : fRowUpb(row_upb),fRowLwb(row_lwb),fColUpb(col_upb),fColLwb(col_lwb) { }
0067    ~TMatrixTLazy() override {}
0068
0069    inline Int_t GetRowLwb() const { return fRowLwb; }
0070    inline Int_t GetRowUpb() const { return fRowUpb; }
0071    inline Int_t GetColLwb() const { return fColLwb; }
0072    inline Int_t GetColUpb() const { return fColUpb; }
0073
0074    ClassDefOverride(TMatrixTLazy,3)  // Template of Lazy Matrix class
0075 };
0076
0077 //////////////////////////////////////////////////////////////////////////
0078 //                                                                      //
0079 // TMatrixTSymLazy                                                      //
0080 //                                                                      //
0081 // Class used to make a lazy copy of a matrix, i.e. only copy matrix    //
0082 // when really needed (when accessed).                                  //
0083 //                                                                      //
0084 //////////////////////////////////////////////////////////////////////////
0085
0086 template<class Element> class TMatrixTSymLazy : public TObject {
0087
0088 friend class TMatrixTBase<Element>;
0089 friend class TMatrixTSym <Element>;
0090 friend class TVectorT    <Element>;
0091
0092 protected:
0093    Int_t fRowUpb;
0094    Int_t fRowLwb;
0095
0096    TMatrixTSymLazy(const TMatrixTSymLazy<Element> &) : TObject(), fRowUpb(0),fRowLwb(0)  { }
0097    void operator=(const TMatrixTSymLazy<Element> &) { }
0098
0099 private:
0100    virtual void FillIn(TMatrixTSym<Element> &m) const = 0;
0101
0102 public:
0103    TMatrixTSymLazy() { fRowUpb = fRowLwb = 0; }
0104    TMatrixTSymLazy(Int_t nrows)
0105        : fRowUpb(nrows-1),fRowLwb(0) { }
0106    TMatrixTSymLazy(Int_t row_lwb,Int_t row_upb)
0107        : fRowUpb(row_upb),fRowLwb(row_lwb) { }
0108    ~TMatrixTSymLazy() override {}
0109
0110    inline Int_t GetRowLwb() const { return fRowLwb; }
0111    inline Int_t GetRowUpb() const { return fRowUpb; }
0112
0113    ClassDefOverride(TMatrixTSymLazy,2)  // Template of Lazy Symmeytric class
0114 };
0115
0116 //////////////////////////////////////////////////////////////////////////
0117 //                                                                      //
0118 // THaarMatrixT                                                         //
0119 //                                                                      //
0120 //////////////////////////////////////////////////////////////////////////
0121
0122 template<class Element> class THaarMatrixT: public TMatrixTLazy<Element> {
0123
0124 private:
0125    void FillIn(TMatrixT<Element> &m) const override;
0126
0127 public:
0128    THaarMatrixT() {}
0129    THaarMatrixT(Int_t n,Int_t no_cols = 0);
0130    virtual ~THaarMatrixT() {}
0131
0132    ClassDefOverride(THaarMatrixT,2)  // Template of Haar Matrix class
0133 };
0134
0135 //////////////////////////////////////////////////////////////////////////
0136 //                                                                      //
0137 // THilbertMatrixT                                                      //
0138 //                                                                      //
0139 //////////////////////////////////////////////////////////////////////////
0140
0141 template<class Element> class THilbertMatrixT : public TMatrixTLazy<Element> {
0142
0143 private:
0144    void FillIn(TMatrixT<Element> &m) const override;
0145
0146 public:
0147    THilbertMatrixT() {}
0148    THilbertMatrixT(Int_t no_rows,Int_t no_cols);
0149    THilbertMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
0150    virtual ~THilbertMatrixT() {}
0151
0152    ClassDefOverride(THilbertMatrixT,2)  // Template of Hilbert Matrix class
0153 };
0154
0155 //////////////////////////////////////////////////////////////////////////
0156 //                                                                      //
0157 // THilbertMatrixTSym                                                   //
0158 //                                                                      //
0159 //////////////////////////////////////////////////////////////////////////
0160
0161 template<class Element> class THilbertMatrixTSym : public TMatrixTSymLazy<Element> {
0162
0163 private:
0164    void FillIn(TMatrixTSym<Element> &m) const override;
0165
0166 public:
0167    THilbertMatrixTSym() {}
0168    THilbertMatrixTSym(Int_t no_rows);
0169    THilbertMatrixTSym(Int_t row_lwb,Int_t row_upb);
0170    virtual ~THilbertMatrixTSym() {}
0171
0172    ClassDefOverride(THilbertMatrixTSym,2)  // Template of Symmetric Hilbert Matrix class
0173 };
0174
0175 #endif