    // @(#)root/matrix:$Name:  $:$Id: TMatrixDLazy.h,v 1.4 2004/01/26 20:57:35 brun Exp $
    // 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_TMatrixDLazy
    #define ROOT_TMatrixDLazy

    //////////////////////////////////////////////////////////////////////////
    //                                                                      //
    // Lazy Matrix classes.                                                 //
    //                                                                      //
    //   TMatrixDLazy                                                       //
    //   TMatrixDSymLazy                                                    //
    //   THilbertMatrixD                                                    //
    //   THaarMatrixD                                                       //
    //                                                                      //
    //////////////////////////////////////////////////////////////////////////

    #ifndef ROOT_TMatrixDBase
    #include "TMatrixDBase.h"
    #endif

    class TVectorD;
    class TMatrixDBase;
    class TMatrixD;
    class TMatrixDSym;

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

    class TMatrixDLazy : public TObject {

    friend class TMatrixDBase;
    friend class TMatrixD;
    friend class TVectorD;

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

      TMatrixDLazy(const TMatrixDLazy &) : TObject() { }
      void operator=(const TMatrixDLazy &) { }

    private:
      virtual void FillIn(TMatrixD &m) const = 0;

    public:
      TMatrixDLazy() { fRowUpb = fRowLwb = fColUpb = fColLwb = 0; }
      TMatrixDLazy(Int_t nrows, Int_t ncols)
         : fRowUpb(nrows-1),fRowLwb(0),fColUpb(ncols-1),fColLwb(0) { }
      TMatrixDLazy(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 ~TMatrixDLazy() {}

      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(TMatrixDLazy,2)  // Lazy matrix with double precision
    };

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

    class TMatrixDSymLazy : public TObject {

    friend class TMatrixDBase;
    friend class TMatrixDSym;
    friend class TVectorD;

    protected:
      Int_t fRowUpb;
      Int_t fRowLwb;

      TMatrixDSymLazy(const TMatrixDSymLazy &) : TObject() { }
      void operator=(const TMatrixDSymLazy &) { }

    private:
      virtual void FillIn(TMatrixDSym &m) const = 0;

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

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

      ClassDef(TMatrixDSymLazy,1)  // Lazy symmeytric matrix with double precision
    };

    //////////////////////////////////////////////////////////////////////////
    //                                                                      //
    // THaarMatrixD                                                         //
    //                                                                      //
    //////////////////////////////////////////////////////////////////////////

    class THaarMatrixD : public TMatrixDLazy {

    private:
      void FillIn(TMatrixD &m) const;

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

      ClassDef(THaarMatrixD,1)  // Haar matrix with double precision
    };

    //////////////////////////////////////////////////////////////////////////
    //                                                                      //
    // THilbertMatrixD                                                      //
    //                                                                      //
    //////////////////////////////////////////////////////////////////////////

    class THilbertMatrixD : public TMatrixDLazy {

    private:
      void FillIn(TMatrixD &m) const;

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

      ClassDef(THilbertMatrixD,1)  // (no_rows x no_cols) Hilbert matrix with double precision
    };

    //////////////////////////////////////////////////////////////////////////
    //                                                                      //
    // THilbertMatrixDSym                                                   //
    //                                                                      //
    //////////////////////////////////////////////////////////////////////////

    class THilbertMatrixDSym : public TMatrixDSymLazy {

    private:
      void FillIn(TMatrixDSym &m) const;

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

      ClassDef(THilbertMatrixDSym,1)  // (no_rows x no_rows) Hilbert matrix with double precision
    };

    #endif