STK_MatrixLowerTriangular.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2007  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
 * Purpose:  Define the MatrixLowerTriangular class.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_MATRIXLOWERTRIANGULAR_H
#define STK_MATRIXLOWERTRIANGULAR_H

#include "STK_Vector.h"
#include "STK_Point.h"

#include "STK_ITArray2D.h"
#include "STK_Display2D.h"

#include "../../Sdk/include/STK_ContainerTraits.h"

namespace STK
{
class MatrixLowerTriangular;
template<>
struct ContainerTraits<Real, MatrixLowerTriangular>
{
   typedef Point TContainerHo;
   typedef Vector TContainerVe;
};


class MatrixLowerTriangular : public ITArray2D< Real, MatrixLowerTriangular>
{
  private:
    const Real defaultConst_;

    Real default_;

  public:
    typedef ITArray2D<Real, MatrixLowerTriangular> _ITArray2DType;

    MatrixLowerTriangular( Range const& I = Range(), Range const& J = Range());

    MatrixLowerTriangular( Range const& I, Range const& J, Real const& v);

    MatrixLowerTriangular( const MatrixLowerTriangular &T, bool ref=false);

    MatrixLowerTriangular( const _ITArray2DType& T, Range const& I, Range const& J);

    MatrixLowerTriangular( Real** q, Range const& I, Range const& J);

    virtual ~MatrixLowerTriangular();

    inline Integer compFirstVe( Integer const& icol) const
    {
      return max( this->firstRow()+ icol - this->firstCol(), this->firstRow());
    }

    inline Integer compLastVe( Integer const& icol) const
    {
      return this->lastRow();
    }

    inline Integer compSizeVe( Integer const& icol) const
    {
      return max(this->lastRow()-compFirstVe(icol)+1, Integer(0));
    }

    inline Range compRangeVe( Integer const& icol) const
    {
      return Range(compFirstVe(icol), this->lastRow());
    }

    inline Integer compFirstHo( Integer const& irow) const
    {
      return this->firstCol();
    }

    inline Integer compLastHo( Integer const& irow) const
    {
      return min( this->firstCol()+ irow - this->firstRow(),
                 this->lastCol());
    }

    inline Integer compSizeHo( Integer const& irow) const
    {
      return max(compLastHo(irow)-this->firstCol()+1, Integer(0));
    }

    inline Range compRangeHo( Integer const& irow) const
    {
      return Range(this->firstCol(), this->compLastHo(irow));
    }

    inline bool isInside(Integer const& i, Integer const& j) const
    {
      return (i>=compFirstVe(j));
    }

    inline Real& elt(Integer i, Integer j)
    {
      return isInside(i, j) ? this->data(j)[i] : default_;
    }

    inline Real const& elt(Integer i, Integer j) const
    {
      // we dont use ? : operator in order to avoid a message from the compiler:
      // return reference to temporary (???)
      if (isInside(i, j))
      {
        return this->data(j)[i];
      }
      else
      {
        return defaultConst_;
      }
    }

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

    inline Vector col(Range const& I, Integer j) const
    {
      return Vector( this->data(j), Range::inf(I, compRangeVe(j)), j);
    }

    inline Vector col( Integer j) const
    {
      return Vector( this->data(j), compRangeVe(j), j);
    }

    inline Point row(Integer i, Range const& J) const
    {
      return Point(*this, Range::inf(J, compRangeHo(i)), i);
    }

    inline Point row( Integer i) const
    {
      return Point(*this, compRangeHo(i), i);
    }

    MatrixLowerTriangular& operator=( MatrixLowerTriangular const& T);

    inline MatrixLowerTriangular& operator=(Real const& v)
    {
      for (Integer j=this->firstCol(); j<=this->lastCol(); j++)
      {
        Real* p(this->data(j));
        Integer beg(this->rangeCols_[j].first());
        Integer end(this->rangeCols_[j].last());

        for (Integer i=beg; i<=end; i++) p[i]= v;
      }
      return *this;
    }
};

ostream& operator<<(ostream& s, MatrixLowerTriangular const& V);

} // namespace STK

#endif
// STK_MATRIXLOWERTRIANGULAR_H