STK_MatrixDiagonal.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2011  Serge Iovleff

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as
 published by the Free Software Foundation; either version 2 of the
 License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this program; if not, write to the
 Free Software Foundation, Inc.,
 59 Temple Place,
 Suite 330,
 Boston, MA 02111-1307
 USA

 Contact : Serge.Iovleff@stkpp.org
 */

/*
 * Project:  stkpp::Arrays
 * created on: 18 août 2011
 * Purpose:  implementation of the diagonal matrix class.
 * Author:   iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_MATRIXDIAGONAL_H
#define STK_MATRIXDIAGONAL_H

#include "../../Sdk/include/STK_ITContainer2D.h"
#include "STK_Vector.h"

namespace STK
{

class MatrixDiagonal: public ITContainer2D<Real, MatrixDiagonal>
                    , protected Vector
{
  typedef ITContainer2D<Real, MatrixDiagonal> ITContainer2DType;
  public:
    MatrixDiagonal( Range const& I = Range()) : ITContainer2DType(I, I)
                                              , Vector(I)
                                              , zero_(0.)
    { ;}

    MatrixDiagonal( Range const& I, Real const& v) : ITContainer2DType(I)
                                                   , Vector(I, v)
                                                   , zero_(0.)
    { }

    MatrixDiagonal( MatrixDiagonal const& T, bool ref=false) : ITContainer2DType(T)
                                                             , Vector(T, ref)
    {}

    MatrixDiagonal( MatrixDiagonal const& T, Range const& I) : ITContainer2DType(T)
                                                             , Vector(T, I)
    {}

    virtual ~MatrixDiagonal();

    inline Range const& range() const
    { return Vector::range();}

    inline Integer const& first() const
    { return Vector::first();}

    inline Integer const& last() const
    { return Vector::last();}

    inline void resize( Range const& I)
    { resize(I, I);}

    inline Real& elt( Integer const& i, Integer const& j)
    {
      (i==j) ? Vector::elt(i) : zero_;
    }

    inline Real const& elt( Integer const& i, Integer const& j) const
    {
     (i==j) ? Vector::elt(i) : zero_;
    }

    inline Vector col( Integer const& j) const
    {
      return Vector(Range(j,j), Vector::elt(j));
    }

    inline Vector col( Range const& I, Integer const& j) const
    {
      return (I.isContaining(j)) ? Vector(Range(j,j), Vector::elt(j)) : Vector();
    }

    inline Point row( Integer const& i) const
    {
      return Point(Range(i,i), Vector::elt(i));
    }
    inline Point row( Integer const& i, Range const& J) const
    {
      return (J.isContaining(i)) ? Point(Range(i,i), Vector::elt(i)) : Point();
    }

    inline MatrixDiagonal sub(Range const& I) const
    { return MatrixDiagonal(*this, I);}

    inline void shift(Integer const& beg)
    { shift(beg, beg);}

  private:
    inline void resize( Range const& I, Range const& J)
    {
      if (I != J)
      {
        throw runtime_error("In MatrixDiagonal::resize(I,J), I!=J");
      }
      Vector::resize(I);
      IContainer2D::resize(I, I);
    }

   inline MatrixDiagonal sub( Range const& I, Range const& J) const
   {
     if (I != J)
     {
       throw runtime_error("In MatrixDiagonal::sub(I,J), I!=J");
     }
     return MatrixDiagonal(*this, I);
   }
    virtual void pushBackCols( Integer const& n =1)
    { incRangeHo(n);}

    virtual void popBackCols( Integer const& n =1)
    { decRangeHo(n); }

    virtual void pushBackRows( Integer const& n =1)
    { incRangeVe(n);}

    virtual void popBackRows( Integer const& n =1)
    { decRangeVe(n);}

    virtual void shift( Integer const& rbeg, Integer const& cbeg)
    {
      if (rbeg != cbeg)
      { throw runtime_error("MatrixDiagonal::shift(rbeg, cbeg) "
                                 "rbeg != cbeg");
      }
      Vector::shift(rbeg);
      incRangeHo(cbeg);
      incRangeVe(rbeg);
    }
    Real zero_;
};

} // namespace STK

#endif /* STK_MATRIXDIAGONAL_H */