// @(#)root/matrix:$Id$
// Authors: Fons Rademakers, Eddy Offermann   Nov 2003

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TMatrixTLazy
#define ROOT_TMatrixTLazy

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Templates of Lazy Matrix classes.                                    //
//                                                                      //
//   TMatrixTLazy                                                       //
//   TMatrixTSymLazy                                                    //
//   THaarMatrixT                                                       //
//   THilbertMatrixT                                                    //
//   THilbertMatrixTSym                                                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TMatrixTBase
#include "TMatrixTBase.h"
#endif

template<class Element> class TVectorT;
template<class Element> class TMatrixTBase;
template<class Element> class TMatrixT;
template<class Element> class TMatrixTSym;

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTLazy                                                         //
//                                                                      //
// Class used to make a lazy copy of a matrix, i.e. only copy matrix    //
// when really needed (when accessed).                                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class TMatrixTLazy : public TObject {

friend class TMatrixTBase<Element>;
friend class TMatrixT    <Element>;
friend class TVectorT    <Element>;

protected:
   Int_t fRowUpb;
   Int_t fRowLwb;
   Int_t fColUpb;
   Int_t fColLwb;

   TMatrixTLazy(const TMatrixTLazy<Element> &) : TObject(), fRowUpb(0),fRowLwb(0),fColUpb(0),fColLwb(0) { }
   void operator=(const TMatrixTLazy<Element> &) { }

private:
   virtual void FillIn(TMatrixT<Element> &m) const = 0;

public:
   TMatrixTLazy() { fRowUpb = fRowLwb = fColUpb = fColLwb = 0; }
   TMatrixTLazy(Int_t nrows, Int_t ncols)
       : fRowUpb(nrows-1),fRowLwb(0),fColUpb(ncols-1),fColLwb(0) { }
   TMatrixTLazy(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb)
       : fRowUpb(row_upb),fRowLwb(row_lwb),fColUpb(col_upb),fColLwb(col_lwb) { }
   virtual ~TMatrixTLazy() {}

   inline Int_t GetRowLwb() const { return fRowLwb; }
   inline Int_t GetRowUpb() const { return fRowUpb; }
   inline Int_t GetColLwb() const { return fColLwb; }
   inline Int_t GetColUpb() const { return fColUpb; }

   ClassDef(TMatrixTLazy,3)  // Template of Lazy Matrix class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMatrixTSymLazy                                                      //
//                                                                      //
// Class used to make a lazy copy of a matrix, i.e. only copy matrix    //
// when really needed (when accessed).                                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class TMatrixTSymLazy : public TObject {

friend class TMatrixTBase<Element>;
friend class TMatrixTSym <Element>;
friend class TVectorT    <Element>;

protected:
   Int_t fRowUpb;
   Int_t fRowLwb;

   TMatrixTSymLazy(const TMatrixTSymLazy<Element> &) : TObject(), fRowUpb(0),fRowLwb(0)  { }
   void operator=(const TMatrixTSymLazy<Element> &) { }

private:
   virtual void FillIn(TMatrixTSym<Element> &m) const = 0;

public:
   TMatrixTSymLazy() { fRowUpb = fRowLwb = 0; }
   TMatrixTSymLazy(Int_t nrows)
       : fRowUpb(nrows-1),fRowLwb(0) { }
   TMatrixTSymLazy(Int_t row_lwb,Int_t row_upb)
       : fRowUpb(row_upb),fRowLwb(row_lwb) { }
   virtual ~TMatrixTSymLazy() {}

   inline Int_t GetRowLwb() const { return fRowLwb; }
   inline Int_t GetRowUpb() const { return fRowUpb; }

   ClassDef(TMatrixTSymLazy,2)  // Template of Lazy Symmeytric class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// THaarMatrixT                                                         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class THaarMatrixT: public TMatrixTLazy<Element> {

private:
   void FillIn(TMatrixT<Element> &m) const;

public:
   THaarMatrixT() {}
   THaarMatrixT(Int_t n,Int_t no_cols = 0);
   virtual ~THaarMatrixT() {}

   ClassDef(THaarMatrixT,2)  // Template of Haar Matrix class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// THilbertMatrixT                                                      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class THilbertMatrixT : public TMatrixTLazy<Element> {

private:
   void FillIn(TMatrixT<Element> &m) const;

public:
   THilbertMatrixT() {}
   THilbertMatrixT(Int_t no_rows,Int_t no_cols);
   THilbertMatrixT(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb);
   virtual ~THilbertMatrixT() {}

   ClassDef(THilbertMatrixT,2)  // Template of Hilbert Matrix class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// THilbertMatrixTSym                                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

template<class Element> class THilbertMatrixTSym : public TMatrixTSymLazy<Element> {

private:
   void FillIn(TMatrixTSym<Element> &m) const;

public:
   THilbertMatrixTSym() {}
   THilbertMatrixTSym(Int_t no_rows);
   THilbertMatrixTSym(Int_t row_lwb,Int_t row_upb);
   virtual ~THilbertMatrixTSym() {}

   ClassDef(THilbertMatrixTSym,2)  // Template of Symmetric Hilbert Matrix class
};

#endif
 TMatrixTLazy.h:1
 TMatrixTLazy.h:2
 TMatrixTLazy.h:3
 TMatrixTLazy.h:4
 TMatrixTLazy.h:5
 TMatrixTLazy.h:6
 TMatrixTLazy.h:7
 TMatrixTLazy.h:8
 TMatrixTLazy.h:9
 TMatrixTLazy.h:10
 TMatrixTLazy.h:11
 TMatrixTLazy.h:12
 TMatrixTLazy.h:13
 TMatrixTLazy.h:14
 TMatrixTLazy.h:15
 TMatrixTLazy.h:16
 TMatrixTLazy.h:17
 TMatrixTLazy.h:18
 TMatrixTLazy.h:19
 TMatrixTLazy.h:20
 TMatrixTLazy.h:21
 TMatrixTLazy.h:22
 TMatrixTLazy.h:23
 TMatrixTLazy.h:24
 TMatrixTLazy.h:25
 TMatrixTLazy.h:26
 TMatrixTLazy.h:27
 TMatrixTLazy.h:28
 TMatrixTLazy.h:29
 TMatrixTLazy.h:30
 TMatrixTLazy.h:31
 TMatrixTLazy.h:32
 TMatrixTLazy.h:33
 TMatrixTLazy.h:34
 TMatrixTLazy.h:35
 TMatrixTLazy.h:36
 TMatrixTLazy.h:37
 TMatrixTLazy.h:38
 TMatrixTLazy.h:39
 TMatrixTLazy.h:40
 TMatrixTLazy.h:41
 TMatrixTLazy.h:42
 TMatrixTLazy.h:43
 TMatrixTLazy.h:44
 TMatrixTLazy.h:45
 TMatrixTLazy.h:46
 TMatrixTLazy.h:47
 TMatrixTLazy.h:48
 TMatrixTLazy.h:49
 TMatrixTLazy.h:50
 TMatrixTLazy.h:51
 TMatrixTLazy.h:52
 TMatrixTLazy.h:53
 TMatrixTLazy.h:54
 TMatrixTLazy.h:55
 TMatrixTLazy.h:56
 TMatrixTLazy.h:57
 TMatrixTLazy.h:58
 TMatrixTLazy.h:59
 TMatrixTLazy.h:60
 TMatrixTLazy.h:61
 TMatrixTLazy.h:62
 TMatrixTLazy.h:63
 TMatrixTLazy.h:64
 TMatrixTLazy.h:65
 TMatrixTLazy.h:66
 TMatrixTLazy.h:67
 TMatrixTLazy.h:68
 TMatrixTLazy.h:69
 TMatrixTLazy.h:70
 TMatrixTLazy.h:71
 TMatrixTLazy.h:72
 TMatrixTLazy.h:73
 TMatrixTLazy.h:74
 TMatrixTLazy.h:75
 TMatrixTLazy.h:76
 TMatrixTLazy.h:77
 TMatrixTLazy.h:78
 TMatrixTLazy.h:79
 TMatrixTLazy.h:80
 TMatrixTLazy.h:81
 TMatrixTLazy.h:82
 TMatrixTLazy.h:83
 TMatrixTLazy.h:84
 TMatrixTLazy.h:85
 TMatrixTLazy.h:86
 TMatrixTLazy.h:87
 TMatrixTLazy.h:88
 TMatrixTLazy.h:89
 TMatrixTLazy.h:90
 TMatrixTLazy.h:91
 TMatrixTLazy.h:92
 TMatrixTLazy.h:93
 TMatrixTLazy.h:94
 TMatrixTLazy.h:95
 TMatrixTLazy.h:96
 TMatrixTLazy.h:97
 TMatrixTLazy.h:98
 TMatrixTLazy.h:99
 TMatrixTLazy.h:100
 TMatrixTLazy.h:101
 TMatrixTLazy.h:102
 TMatrixTLazy.h:103
 TMatrixTLazy.h:104
 TMatrixTLazy.h:105
 TMatrixTLazy.h:106
 TMatrixTLazy.h:107
 TMatrixTLazy.h:108
 TMatrixTLazy.h:109
 TMatrixTLazy.h:110
 TMatrixTLazy.h:111
 TMatrixTLazy.h:112
 TMatrixTLazy.h:113
 TMatrixTLazy.h:114
 TMatrixTLazy.h:115
 TMatrixTLazy.h:116
 TMatrixTLazy.h:117
 TMatrixTLazy.h:118
 TMatrixTLazy.h:119
 TMatrixTLazy.h:120
 TMatrixTLazy.h:121
 TMatrixTLazy.h:122
 TMatrixTLazy.h:123
 TMatrixTLazy.h:124
 TMatrixTLazy.h:125
 TMatrixTLazy.h:126
 TMatrixTLazy.h:127
 TMatrixTLazy.h:128
 TMatrixTLazy.h:129
 TMatrixTLazy.h:130
 TMatrixTLazy.h:131
 TMatrixTLazy.h:132
 TMatrixTLazy.h:133
 TMatrixTLazy.h:134
 TMatrixTLazy.h:135
 TMatrixTLazy.h:136
 TMatrixTLazy.h:137
 TMatrixTLazy.h:138
 TMatrixTLazy.h:139
 TMatrixTLazy.h:140
 TMatrixTLazy.h:141
 TMatrixTLazy.h:142
 TMatrixTLazy.h:143
 TMatrixTLazy.h:144
 TMatrixTLazy.h:145
 TMatrixTLazy.h:146
 TMatrixTLazy.h:147
 TMatrixTLazy.h:148
 TMatrixTLazy.h:149
 TMatrixTLazy.h:150
 TMatrixTLazy.h:151
 TMatrixTLazy.h:152
 TMatrixTLazy.h:153
 TMatrixTLazy.h:154
 TMatrixTLazy.h:155
 TMatrixTLazy.h:156
 TMatrixTLazy.h:157
 TMatrixTLazy.h:158
 TMatrixTLazy.h:159
 TMatrixTLazy.h:160
 TMatrixTLazy.h:161
 TMatrixTLazy.h:162
 TMatrixTLazy.h:163
 TMatrixTLazy.h:164
 TMatrixTLazy.h:165
 TMatrixTLazy.h:166
 TMatrixTLazy.h:167
 TMatrixTLazy.h:168
 TMatrixTLazy.h:169
 TMatrixTLazy.h:170
 TMatrixTLazy.h:171
 TMatrixTLazy.h:172
 TMatrixTLazy.h:173
 TMatrixTLazy.h:174
 TMatrixTLazy.h:175
 TMatrixTLazy.h:176
 TMatrixTLazy.h:177