STK_MatrixUpperTriangular.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 Upper Triangular Matrix class.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_MATRIXUPPERTRIANGULAR_H
#define STK_MATRIXUPPERTRIANGULAR_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 MatrixUpperTriangular;
template<>
struct ContainerTraits<Real, MatrixUpperTriangular>
{
   typedef Point TContainerHo;
   typedef Vector TContainerVe;
};


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

    Real default_;

  public:
    typedef Array1D<Real> Vector;

    typedef ArrayHo<Real> Point;

    typedef AllocatorBase<Real*> _AllocatorBaseType_;

    typedef ITArray2D< Real, MatrixUpperTriangular >
           _ITArray2DType;

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

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

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

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

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

    virtual ~MatrixUpperTriangular();

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

    inline Integer compLastHo( Integer const& irow) const
    {
      return this->lastCol();
    }

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

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

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

    inline Integer compLastVe( Integer const& icol) const
    {
      return min( this->firstRow() + icol - this->firstCol()
                , this->lastRow()
                );
    }

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

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

   inline bool isInside(Integer const& i, Integer const& j) const
   { return (i<=this->rangeCols_[j].last());}

    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
    {
      if (isInside(i,j)) { return this->data(j)[i];}
      else               { return defaultConst_;}
    }
    inline MatrixUpperTriangular sub(Range const& I, Range const& J) const
    { return MatrixUpperTriangular(*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);
    }

    MatrixUpperTriangular& operator=(const MatrixUpperTriangular &T);

    inline MatrixUpperTriangular& 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, MatrixUpperTriangular const& V);

} // namespace STK

#endif
// STK_MATRIXUPPERTRIANGULAR_H