STK_MatrixSquare.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 MatrixSquare class.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_MATRIXSQUARE_H
#define STK_MATRIXSQUARE_H

#include "STK_Matrix.h"

namespace STK
{

class MatrixSquare;

template<>
struct ContainerTraits<Real, MatrixSquare >
{
   typedef Point TContainerHo;
   typedef Vector TContainerVe;
};


class MatrixSquare : public Matrix
{
  public:
    MatrixSquare( Range const& I = Range());

    MatrixSquare( Range const& I, Real const& v);

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

    MatrixSquare( Matrix const& T, Range const& I);

    virtual ~MatrixSquare();

    inline Range const& range() const
    { return rangeVe();}

    inline Integer const& first() const
    { return firstCol();}

    inline Integer const& last() const
    { return lastCol();}

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

    inline void shift(Integer beg)
    { Matrix::shift(beg, beg);}

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

    inline void insert( Integer const& pos, Integer const& n =1)
    {
      Matrix::insertRows(pos, n);
      Matrix::insertCols(pos, n);
    }

    inline void erase( Integer const& pos, Integer const& n=1)
    {
      Matrix::eraseCols(pos, n);
      Matrix::eraseRows(pos, n);
    }

    inline void pushBack(Integer n=1)
    {
      Matrix::pushBackRows(n);
      Matrix::pushBackCols(n);
    }

    inline void popBack(Integer const& n=1)
    {
      Matrix::popBackCols(n);
      Matrix::popBackRows(n);
    }

    inline MatrixSquare& operator=( MatrixSquare const& T)
    {
            Matrix *p1(this); // convert this to Array2D
      const Matrix *p2(&T);   // convert T    to Array2D
      (*p1) = (*p2);                   // use = of Array2D class

      return *this;
    }

    inline MatrixSquare& operator=(Real const& v)
    {
      Matrix *p1(this); // convert this to Array2D
      (*p1) = v;        // use = of Array2D class

      return *this;
    }

    template < class TContainer2D>
    inline MatrixSquare& operator=( ITArray2D< Real, TContainer2D> const& T)
    {
      if (T.rangeVe() != T.rangeHo())
      { throw runtime_error("MatrixSquare::operator=(T) "
                                 "dimensions of T are not square.");
      }
      // use Matrix = operator
      Matrix *p1(this); // convert this to Matrix
      (*p1) = T;        // use = of Matrix class
      return *this;
    }

  private:
    inline void resize( Range const& I, Range const& J)
    {
      if (I != J)
      { throw runtime_error("MatrixSquare::resize(I, J) "
                                 "I != J");
      }
      Matrix::resize(I, J);
    }

    inline void shift(Integer rbeg, Integer cbeg)
    {
      if (rbeg != cbeg)
      { throw runtime_error("MatrixSquare::shift(rbeg, cbeg) "
                                 "rbeg != cbeg");
      }
      Matrix::shift(rbeg, cbeg);
    }



};

} // namespace STK


#endif
// STK_MATRIXSQUARE_H