STK_ITContainer.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2016  Serge Iovleff, Université Lille 1, Inria
 
    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 : S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
*/
 
/*
 * Project:  stkpp::Arrays
 * created on: 26 nov. 2011
 * Author:   Serge Iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_ITCONTAINER_H
#define STK_ITCONTAINER_H
 
namespace STK
{
 
namespace hidden
{
class NoAssignOperator
{ private:
    NoAssignOperator& operator=(const NoAssignOperator&);
};
 
} // hidden namespace
 
template <class Derived>
class ITContainerBase: public IRecursiveTemplate<Derived>, hidden::NoAssignOperator
{
  public:
    typedef IRecursiveTemplate<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
  protected:
    ITContainerBase(): Base() {}
    ~ITContainerBase() {}
 
  public:
    inline ColRange const& cols() const { return this->asDerived().colsImpl();};
    inline int beginCols() const { return cols().begin();}
    inline int endCols() const { return cols().end();}
    inline int sizeCols() const { return cols().size();}
 
    inline RowRange const& rows() const { return this->asDerived().rowsImpl();}
    inline int beginRows() const { return rows().begin();}
    inline int endRows() const { return rows().end();}
    inline int sizeRows() const { return rows().size();}
 
    // for backward compatibility
    inline int firstIdxCols() const { return beginCols();}
    inline int firstIdxRows() const { return beginRows();}
    inline int lastIdxCols() const { return endCols()-1;}
    inline int lastIdxRows() const { return endRows()-1;}
 
    inline RowRange const& rangeRowsInCol(int) const { return rows();}
    inline ColRange const& rangeColsInRow(int) const { return cols();}
 
    bool empty() const { return (sizeCols()<=0 || sizeRows()<=0);}
 
    inline int size() const { return sizeRows()*sizeCols();}
 
    // const accesses
    inline TypeConst elt(int i, int j) const
    {
#ifdef STK_BOUNDS_CHECK
      if (beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainerBase::elt, i, j, beginRows() > i);}
      if (endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainerBase::elt, i, j, endRows() <= i);}
      if (beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainerBase::elt, i, j, beginCols() > j);}
      if (endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainerBase::elt, i, j, endCols() <= j);}
#endif
      return this->asDerived().elt2Impl(i,j);
    }
    inline TypeConst elt(int i) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
#ifdef STK_BOUNDS_CHECK
      if (this->asDerived().begin() > i) { STKOUT_OF_RANGE_1ARG(ITContainerBase::elt, i, begin() > i);}
      if (this->asDerived().end() <= i)  { STKOUT_OF_RANGE_1ARG(ITContainerBase::elt, i, end() <= i);}
#endif
return this->asDerived().elt1Impl(i);
    }
    inline TypeConst elt() const { return this->asDerived().elt0Impl();}
    // not-const accesses
    inline Type& elt(int i, int j)
    {
#ifdef STK_BOUNDS_CHECK
      if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainer::elt, i, j, beginRows() > i);}
      if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainer::elt, i, j, endRows() <= i);}
      if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainer::elt, i, j, beginCols() > j);}
      if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainer::elt, i, j, endCols() <= j);}
#endif
      return this->asDerived().elt2Impl(i,j);
    }
    inline Type& elt(int i)
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
#ifdef STK_BOUNDS_CHECK
      if (this->asDerived().begin() > i) { STKOUT_OF_RANGE_1ARG(ITContainerBase::elt, i, begin() > i);}
      if (this->asDerived().end() <= i)  { STKOUT_OF_RANGE_1ARG(ITContainerBase::elt, i, end() <= i);}
#endif
      return this->asDerived().elt1Impl(i);
    }
    inline Type& elt() { return this->asDerived().elt0Impl();}
 
    TypeConst at(int i, int j) const
    {
      if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainerBase::at, i, j, beginRows() > i);}
      if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainerBase::at, i, j, endRows() <= i);}
      if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainerBase::at, i, j, beginCols() > j);}
      if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainerBase::at, i, j, endCols() <= j);}
      return this->asDerived().elt2Impl(i, j);
    }
    TypeConst at(int i) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
      if (this->asDerived().begin() > i) { STKOUT_OF_RANGE_1ARG(ITContainerBase::at, i, begin() > i);}
      if (this->asDerived().end() <= i)  { STKOUT_OF_RANGE_1ARG(ITContainerBase::at, i, end() <= i);}
      return this->asDerived().elt1Impl(i);
    }
    Type& at(int i, int j)
    {
      if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainerBase::at, i, j, beginRows() > i);}
      if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainerBase::at, i, j, endRows() <= i);}
      if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainerBase::at, i, j, beginCols() > j);}
      if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainerBase::at, i, j, endCols() <= j);}
      return this->asDerived().elt2Impl(i,j);
    }
    Type& at(int i)
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
      if (this->asDerived().begin() > i) { STKOUT_OF_RANGE_1ARG(ITContainerBase::at, i, begin() > i);}
      if (this->asDerived().end() <= i)  { STKOUT_OF_RANGE_1ARG(ITContainerBase::at, i, end() <= i);}
      return this->asDerived().elt1Impl(i);
    }
    // overloaded operators
     inline TypeConst operator()(int i, int j) const
     {
#ifdef STK_BOUNDS_CHECK
       if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainerBase::elt, i, j, beginRows() > i);}
       if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainerBase::elt, i, j, endRows() <= i);}
       if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainerBase::elt, i, j, beginCols() > j);}
       if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainerBase::elt, i, j, endCols() <= j);}
#endif
       return this->elt(i,j);
     }
     inline Type& operator()(int i, int j)
     {
 #ifdef STK_BOUNDS_CHECK
       if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainer::operator(), i, j, beginRows() > i);}
       if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainer::operator(), i, j, endRows() <= i);}
       if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainer::operator(), i, j, beginCols() > j);}
       if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainer::eoperator()lt, i, j, endCols() <= j);}
 #endif
       return this->asDerived().elt2Impl(i,j);
     }
     inline TypeConst operator[](int i) const
     {
       STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
#ifdef STK_BOUNDS_CHECK
      if (this->asDerived().begin() > i) { STKOUT_OF_RANGE_1ARG(ITContainer::operator[], i, begin() > i);}
      if (this->asDerived().end() <= i)  { STKOUT_OF_RANGE_1ARG(ITContainer::operator[], i, end() <= i);}
#endif
       return this->elt(i);
     }
     inline Type& operator[](int i)
     {
       STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
#ifdef STK_BOUNDS_CHECK
      if (this->asDerived().begin() > i) { STKOUT_OF_RANGE_1ARG(ITContainer::operator[], i, begin() > i);}
      if (this->asDerived().end() <= i)  { STKOUT_OF_RANGE_1ARG(ITContainer::operator[], i, end() <= i);}
#endif
       return this->elt(i);
     }
     inline TypeConst operator()() const
     {
       STK_STATIC_ASSERT_ZERO_DIMENSION_ONLY(Derived);
       return this->elt();
     }
     inline Type& operator()()
     {
       STK_STATIC_ASSERT_ZERO_DIMENSION_ONLY(Derived);
       return this->elt();
     }
};
 
template < class Derived, int Structure_ = hidden::Traits<Derived>::structure_ >
class ITContainer;
 
template <class Derived>
class ITContainer<Derived, Arrays::array2D_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
};
 
template <class Derived>
class ITContainer<Derived, Arrays::square_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
 
  public:
    inline RowRange const& range() const { return this->rows();}
    inline int begin() const { return range().begin();}
    inline int end() const { return range().end();}
    inline int size() const { return range().size();}
 
    // for backward compatibility
    inline int firstIdx() const { return this->beginRows();}
    inline int lastIdx() const { return this->endRows()-1;}
 
    Type trace() const
    {
      Type sum = 0.0;
      for (int k = begin(); k< end(); k++) sum += this->elt(k, k);
      return sum;
    }
};
 
template <class Derived>
class ITContainer<Derived, Arrays::lower_triangular_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
 
  public:
    inline Range rangeRowsInCol( int icol) const
    { return Range(icol, this->lastIdxRows(), 0);}
    inline Range rangeColsInRow( int irow) const
    { return Range(this->beginCols(), std::min(irow, this->lastIdxCols()), 0);}
    Type at(int i, int j) const
    {
      if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginRows() > i);}
      if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endRows() <= i);}
      if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginCols() > j);}
      if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endCols() <= j);}
      return (j>i) ? Type() : this->asDerived().elt2Impl(i, j);
    }
    Type& at(int i, int j)
    {
      if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginRows() > i);}
      if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endRows() <= i);}
      if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginCols() > j);}
      if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endCols() <= j);}
      if (j > i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, j > i);}
      return this->asDerived().elt2Impl(i,j);
    }
};
 
template <class Derived>
class ITContainer<Derived, Arrays::upper_triangular_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
 
  public:
    Range rangeColsInRow( int irow) const
    { return Range(irow, this->lastIdxCols(), 0);}
    Range rangeRowsInCol( int icol) const
    { return Range(this->beginRows(), std::min(icol, this->lastIdxRows()), 0);}
    Type at(int i, int j) const
    {
      if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginRows() > i);}
      if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endRows() <= i);}
      if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginCols() > j);}
      if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endCols() <= j);}
      return (i>j) ? Type() : this->asDerived().elt2Impl(i, j);
    }
    Type& at(int i, int j)
    {
      if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginRows() > i);}
      if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endRows() <= i);}
      if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginCols() > j);}
      if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endCols() <= j);}
      if (i > j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, i > j);}
      return this->asDerived().elt2Impl(i,j);
    }
};
 
template <class Derived>
class ITContainer<Derived, Arrays::symmetric_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
 
  public:
    inline RowRange const& range() const { return this->rows();}
    inline int begin() const { return range().begin();}
    inline int end() const { return range().end();}
    inline int size() const { return range().size();}
 
    // for backward compatibility
    inline int firstIdx() const { return this->beginRows();}
    inline int lastIdx() const { return this->endRows()-1;}
 
    Type trace() const
    {
      Type sum = 0.0;
      for (int k = begin(); k< end(); k++) sum += this->elt(k, k);
      return sum;
    }
};
 
template <class Derived>
class ITContainer<Derived, Arrays::lower_symmetric_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
 
  public:
    inline RowRange const& range() const { return this->rows();}
    inline int begin() const { return range().begin();}
    inline int end() const { return range().end();}
    inline int size() const { return range().size();}
 
    // for backward compatibility
    inline int firstIdx() const { return this->beginRows();}
    inline int lastIdx() const { return this->endRows()-1;}
 
    Type trace() const
    {
      Type sum = 0.0;
      for (int k = begin(); k< end(); k++) sum += this->elt(k, k);
      return sum;
    }
    TypeConst at(int i, int j) const
    {
      if (this->beginRows() > i){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginRows() > i);}
      if (this->endRows() <= i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endRows() <= i);}
      if (this->beginCols() > j){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginCols() > j);}
      if (this->endCols() <= j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endCols() <= j);}
      return (i<j) ? this->asDerived().elt2Impl(j, i) : this->asDerived().elt2Impl(i, j);
    }
    Type& at(int i, int j)
    {
      if (this->beginRows() > i){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginRows() > i);}
      if (this->endRows() <= i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endRows() <= i);}
      if (this->beginCols() > j){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginCols() > j);}
      if (this->endCols() <= j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endCols() <= j);}
      if (i < j){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, i < j);}
      return this->asDerived().elt2Impl(i,j);
    }
};
 
template <class Derived>
class ITContainer<Derived, Arrays::upper_symmetric_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
 
  public:
    inline RowRange const& range() const { return this->rows();}
    inline int begin() const { return range().begin();}
    inline int end() const { return range().end();}
    inline int size() const { return range().size();}
 
    // for backward compatibility
    inline int firstIdx() const { return this->beginRows();}
    inline int lastIdx() const { return this->endRows()-1;}
 
    Type trace() const
    {
      Type sum = 0.0;
      for (int k = begin(); k< end(); k++) sum += this->elt(k, k);
      return sum;
    }
    TypeConst at(int i, int j) const
    {
      if (this->beginRows() > i){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginRows() > i);}
      if (this->endRows() <= i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endRows() <= i);}
      if (this->beginCols() > j){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginCols() > j);}
      if (this->endCols() <= j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endCols() <= j);}
      return (i>j) ?this->asDerived().elt2Impl(j, i) : this->asDerived().elt2Impl(i, j);
    }
    Type& at(int i, int j)
    {
      if (this->beginRows() > i){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginRows() > i);}
      if (this->endRows() <= i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endRows() <= i);}
      if (this->beginCols() > j){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginCols() > j);}
      if (this->endCols() <= j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endCols() <= j);}
      if (i>j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, i>j);}
      return this->asDerived().elt2Impl(i,j);
    }
};
 
template <class Derived>
class ITContainer<Derived, Arrays::diagonal_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
 
  public:
    inline RowRange const& range() const { return this->rows();}
    inline int begin() const { return range().begin();}
    inline int end() const  { return range().end();}
    inline int size() const  { return range().size();}
 
    // for backward compatibility
    inline int firstIdx() const { return begin();}
    inline int lastIdx() const { return end()-1;}
 
    inline Range rangeRowsInCol(int pos) const { return Range(pos,1);}
    inline Range rangeColsInRow(int pos) const { return Range(pos,1);}
 
    inline TypeConst front() const { return this->elt(firstIdx());}
    inline TypeConst back() const { return this->elt(lastIdx());}
 
    inline Type& front() { return this->elt(firstIdx());}
    inline Type& back() { return this->elt(lastIdx());}
 
    Type at(int i, int j) const
    {
      if (this->beginRows() > i){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginRows() > i);}
      if (this->endRows() <= i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endRows() <= i);}
      if (this->beginCols() > j){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginCols() > j);}
      if (this->endCols() <= j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endCols() <= j);}
      return (i==j) ? this->asDerived().elt2Impl(i,j) : Type();
    }
    TypeConst at(int i) const
    {
      if (this->begin() > i)   { STKOUT_OF_RANGE_1ARG(ITContainer::at, i, begin() > i);}
      if (this->lastIdx() < i) { STKOUT_OF_RANGE_1ARG(ITContainer::at, i, lastIdx() < i);}
      return this->asDerived().elt1Impl(i);
    }
    Type& at(int i, int j)
    {
      if (this->beginRows() > i){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginRows() > i);}
      if (this->endRows() <= i) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endRows() <= i);}
      if (this->beginCols() > j){ STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, beginCols() > j);}
      if (this->endCols() <= j) { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, endCols() <= j);}
      if (i != j)
      { STKOUT_OF_RANGE_2ARG(ITContainer::at, i, j, i != j);}
      return this->asDerived().elt2Impl(i,j);
    }
    Type& at(int i)
    {
      if (this->begin() > i) { STKOUT_OF_RANGE_1ARG(ITContainerBase::at, i, begin() > i);}
      if (this->end() <= i)  { STKOUT_OF_RANGE_1ARG(ITContainerBase::at, i, end() <= i);}
      return this->asDerived().elt1Impl(i);
    }
};
 
template <class Derived>
class ITContainer<Derived, Arrays::vector_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
 
  public:
    inline RowRange const& range() const  { return this->rows();}
    inline int begin() const { return range().begin();}
    inline int end() const  { return range().end();}
    inline int size() const  { return range().size();}
 
    // for backward compatibility
    inline int firstIdx() const { return begin();}
    inline int lastIdx() const { return end()-1;}
 
    inline int colIdx() const { return this->beginCols();}
 
    inline TypeConst front() const { return this->elt(firstIdx());}
    inline TypeConst back() const { return this->elt(lastIdx());}
 
    inline Type& front() { return this->elt(firstIdx());}
    inline Type& back() { return this->elt(lastIdx());}
};
 
template <class Derived>
class ITContainer<Derived, Arrays::point_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
 
  public:
    inline ColRange const& range() const  { return this->asDerived().cols();}
    inline int begin() const { return range().begin();}
    inline int end() const  { return range().end();}
    inline int size() const  { return range().size();}
 
    inline int rowIdx() const { return this->beginRows();}
 
    // for backward compatibility
    inline int firstIdx() const { return begin();}
    inline int lastIdx() const { return end()-1;}
 
    inline TypeConst front() const { return this->elt(firstIdx());}
    inline TypeConst back() const { return this->elt(lastIdx());}
 
    inline Type& front() { return this->elt(firstIdx());}
    inline Type& back() { return this->elt(lastIdx());}
};
template <class Derived>
class ITContainer<Derived, Arrays::number_>: public ITContainerBase<Derived>
{
  public:
    typedef ITContainerBase<Derived> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
 
  protected:
    ITContainer(): Base() {}
    ~ITContainer() {}
 
  public:
    inline ColRange const& range() const  { return this->asDerived().rows();}
    inline int begin() const { return range().begin();}
    inline int end() const  { return range().end();}
    inline int size() const  { return 1;}
    operator TypeConst const() const {return this->asDerived().elt0Impl();}
};
 
} // namespace STK
 
#endif /* STK_ITCONTAINER_H */