STK_ICArray.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::Array
 * created on: 10 août 2012
 * Author:   iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_ICARRAY_H
#define STK_ICARRAY_H
 
#include "STK_ArrayBase.h"
#include "STK_IContainer2D.h"
#include "STK_ITContainer2D.h"
#include "allocators/STK_MemAllocator.h"
#include "allocators/STK_CAllocator.h"
 
namespace STK
{
// forward declaration of all CArray classes
template< typename Type, int SizeRows_, int SizeCols_, bool Orient_> class CArray;
template< typename Type, int Size_, bool Orient_> class CArraySquare;
template< typename Type, int SizeCols_, bool Orient_> class CArrayPoint;
template< typename Type, int SizeRows_, bool Orient_> class CArrayVector;
template< typename Type, bool Orient_> class CArrayNumber;
 
namespace hidden
{
template<typename Derived, int SizeRows, int SizeCols>
struct CSlice
{
    typedef typename Traits< Derived >::Type Type;
    enum
    {
      structure_ = Traits<Derived>::structure_,
      orient_    = Traits<Derived>::orient_,
      sizeRows_  = Traits<Derived>::sizeRows_,
      sizeCols_  = Traits<Derived>::sizeCols_,
      storage_   = Traits<Derived>::storage_,
 
      isNumber_ = (SizeRows==1)&&(SizeCols==1),
      isVector_ = (SizeCols == 1)&&(!isNumber_),
      isPoint_  = (SizeRows == 1)&&(!isNumber_),
      isSquare_ = (SizeRows==SizeCols)&&(SizeRows!=UnknownSize)&&(!isNumber_),
      isArray_  = (SizeRows!=SizeCols)&&(!isNumber_) // not used
    };
   typedef typename If< (isNumber_), CArrayNumber<Type, orient_>
                      , typename If< isVector_, CArrayVector<Type, SizeRows, orient_>
                          , typename If< isPoint_, CArrayPoint<Type, SizeCols, orient_>
                              , typename If< isSquare_, CArraySquare<Type, SizeRows, orient_>
                                           , CArray<Type, SizeRows, SizeCols, orient_>
                                           >::Result
                                       >::Result
                                   >::Result
                      >::Result Result;
};
 
template<typename Derived, int Size>
struct CSliceDispatcher
{
    enum
    { structure_ = Traits<Derived>::structure_};
    typedef typename If< structure_ == (int)Arrays::vector_
                       , typename CSlice<Derived, Size, 1>::Result
                       , typename CSlice<Derived, 1, Size>::Result
                       >::Result Result;
};
 
}
template<class Derived>
 
class ICArray: public ArrayBase<Derived>
{
  public:
    typedef ArrayBase<Derived> Base;
    typedef typename hidden::Traits< Derived >::Allocator Allocator;
 
    typedef typename hidden::Traits< Derived >::Row Row;
    typedef typename hidden::Traits< Derived >::Col Col;
    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:
    Allocator allocator_;
    ICArray(): Base(), allocator_() {}
    ICArray( int sizeRows, int sizeCols): Base(), allocator_(sizeRows, sizeCols) {}
    ICArray( int sizeRows, int sizeCols, Type const& value): Base(), allocator_(sizeRows, sizeCols, value) {}
    ICArray( Derived const& T, bool ref = false): Base(), allocator_(T.allocator_, ref) {}
    ICArray( Type* const& q, int sizeRows, int sizeCols): Base(), allocator_(q, sizeRows, sizeCols){}
    template<class OtherAllocator>
    inline ICArray( ITContainer2D<OtherAllocator> const& allocator, Range const& I, Range const& J)
                 : Base(), allocator_(allocator.asDerived(), I, J)
    {}
    template< class OtherAllocator>
    inline ICArray( ITContainer2D<OtherAllocator> const& allocator)
                  : Base(), allocator_(allocator.asDerived(), true)
    {}
    ~ICArray() {}
  public:
    inline ColRange const& colsImpl() const { return allocator_.cols();};
    inline RowRange const& rowsImpl() const { return allocator_.rows();}
 
    void clear() { allocator_.clear();}
 
    bool empty() const { return allocator_.empty();}
    bool isRef() const { return allocator_.isRef();}
 
    inline Allocator const& allocator() const { return allocator_;}
    inline Type* const& p_data() const { return allocator_.p_data();}
 
    inline Type& elt2Impl( int i, int j) { return allocator_.elt(i, j);}
    inline TypeConst elt2Impl( int i, int j) const { return allocator_.elt(i, j);}
 
    inline Type& elt1Impl( int j) { return allocator_.elt(j);}
    inline TypeConst elt1Impl( int j) const{ return allocator_.elt(j);}
 
    inline Type& elt0Impl() { return allocator_.elt();}
    inline TypeConst elt0Impl() const { return allocator_.elt();}
 
    inline void setValueImpl( int j, TypeConst value) { allocator_.elt(j) = value ;}
    inline void setValueImpl( int i, int j, TypeConst value) { allocator_.elt(i,j) = value ;}
 
    // overloaded operators
    inline Type& operator()(int i, int j)
    {
#ifdef STK_BOUNDS_CHECK
       if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ICArray::operator(), i, j, beginRows() > i);}
       if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ICArray::operator(), i, j, endRows() <= i);}
       if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ICArray::operator(), i, j, beginCols() > j);}
       if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ICArray::operator(), i, j, endCols() <= j);}
#endif
      return this->elt(i,j);
    }
    inline TypeConst operator()(int i, int j) const
    {
#ifdef STK_BOUNDS_CHECK
       if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(ICArray::operator(), i, j, beginRows() > i);}
       if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(ICArray::operator(), i, j, endRows() <= i);}
       if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(ICArray::operator(), i, j, beginCols() > j);}
       if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(ICArray::operator(), i, j, endCols() <= j);}
#endif
      return this->elt(i,j);
    }
 
    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(ICArray::operator[], i, begin() > i);}
      if (this->asDerived().end() <= i)  { STKOUT_OF_RANGE_1ARG(ICArray::operator[], i, end() <= i);}
#endif
      return this->elt(i);
    }
    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(ICArray::operator[], i, begin() > i);}
      if (this->asDerived().end() <= i)  { STKOUT_OF_RANGE_1ARG(ICArray::operator[], i, end() <= i);}
#endif
      return this->elt(i);
    }
 
    inline Type& operator()() { return this->elt();}
    inline TypeConst operator()() const { return this->elt();}
 
    // row operators
    inline typename hidden::CSlice<Derived, 1, sizeCols_>::Result row(int i) const
    { return typename hidden::CSlice<Derived, 1, sizeCols_>::Result( allocator_.row(i));}
    template<int Size_>
    inline typename hidden::CSlice<Derived, 1, Size_>::Result row(int i, TRange<Size_> const& J) const
    { return typename hidden::CSlice<Derived, 1, Size_>::Result( allocator_.row( i, J));}
    template<int Size_>
    inline typename hidden::CSlice<Derived, 1, Size_>::Result operator()(int i, TRange<Size_> const& J) const
    { return row(i, J);}
    template<int Size_>
    inline typename hidden::CSlice<Derived, Size_, sizeCols_>::Result row(TRange<Size_> const& I) const
    { return typename hidden::CSlice<Derived, Size_, sizeCols_>::Result( allocator_.sub(I, this->cols()));}
 
    // col operators
    inline typename hidden::CSlice<Derived, sizeRows_, 1>::Result col(int j) const
    { return typename hidden::CSlice<Derived, sizeRows_, 1>::Result( allocator_.col(j));}
    template<int Size_ >
    inline typename hidden::CSlice<Derived, Size_, 1>::Result col(TRange<Size_> const& I, int j) const
    { return typename hidden::CSlice<Derived, Size_, 1>::Result( allocator_.col( I, j));}
    template<int Size_>
    inline typename hidden::CSlice<Derived, sizeRows_, Size_>::Result col(TRange<Size_> const& J) const
    { return typename hidden::CSlice<Derived, sizeRows_, Size_>::Result( allocator_.sub(this->rows(), J));}
    template<int Size_>
    inline typename hidden::CSlice<Derived, Size_, 1>::Result operator()(TRange<Size_> const& I, int j) const
    { return col(I, j);}
 
    // sub operators
    template<int Size>
    inline typename hidden::CSliceDispatcher<Derived, Size>::Result sub( TRange<Size> const& J) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
      return typename hidden::CSliceDispatcher<Derived, Size>::Result( allocator_.subVector(J));
    }
    template<int Size>
    inline typename hidden::CSliceDispatcher<Derived, Size>::Result operator[](TRange<Size> const& I) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
      return sub(I);
    }
    template<int OtherRows_, int OtherCols_>
    inline typename hidden::CSlice<Derived, OtherRows_, OtherCols_>::Result sub(TRange<OtherRows_> const& I, TRange<OtherCols_> const& J) const
    { return typename hidden::CSlice<Derived, OtherRows_, OtherCols_>::Result(allocator_.sub(I, J));}
    template<int OtherRows_, int OtherCols_>
    inline typename hidden::CSlice<Derived, OtherRows_, OtherCols_>::Result operator()(TRange<OtherRows_> const& I, TRange<OtherCols_> const& J) const
    { return sub(I, J);}
 
    void swap(int i, int  j) { std::swap(this->elt(i), this->elt(j)); }
    void swapCols(int pos1, int pos2)
    {
#ifdef STK_BOUNDS_CHECK
      if (this->beginCols() > pos1)
      { STKOUT_OF_RANGE_2ARG(ICArray::swapCols,pos1, pos2,beginCols() > pos1);}
      if (this->endCols() <= pos1)
      { STKOUT_OF_RANGE_2ARG(ICArray::swapCols,pos1, pos2,endCols() <= pos1);}
      if (this->beginCols() > pos2)
      { STKOUT_OF_RANGE_2ARG(ICArray::swapCols,pos1, pos2,beginCols() > pos2);}
      if (this->endCols() <= pos2)
      { STKOUT_OF_RANGE_2ARG(ICArray::swapCols,pos1, pos2,endCols() <= pos2);}
#endif
      // swap allocator
      allocator_.swapCols(pos1, pos2);
    }
    void swapRows(int pos1, int pos2)
    {
#ifdef STK_BOUNDS_CHECK
      if (this->beginRows() > pos1)
      { STKOUT_OF_RANGE_2ARG(ICArray::swapRows,pos1, pos2,beginRows() > pos1);}
      if (this->endRows() <= pos1)
      { STKOUT_OF_RANGE_2ARG(ICArray::swapRows,pos1, pos2,endRows() <= pos1);}
      if (this->beginRows() > pos2)
      { STKOUT_OF_RANGE_2ARG(ICArray::swapRows,pos1, pos2,beginRows() > pos2);}
      if (this->endRows() <= pos2)
      { STKOUT_OF_RANGE_2ARG(ICArray::swapRows,pos1, pos2,endRows() <= pos2);}
#endif
      // swap allocator
      allocator_.swapRows(pos1, pos2);
    }
    void exchange(Derived& T) { allocator_.exchange(T.allocator_);}
    void move(Derived const& T) { allocator_.move(T.allocator_);}
    Derived& shift(int beginRows, int beginCols)
    {
      STK_STATIC_ASSERT((structure_ == (int)Arrays::array2D_)
                      ||(structure_ == (int)Arrays::lower_triangular_)
                      ||(structure_ == (int)Arrays::upper_triangular_)
                      ,YOU_CANNOT_USED_THIS_METHOD_WITH_THIS_KIND_OF_ARRAY);
      if (!hidden::CheckShift<Derived, structure_>::shift(this->asDerived(), beginRows, beginCols)) return this->asDerived();
      if (this->isRef())
      { STKRUNTIME_ERROR_2ARG(ICArray::shift,beginRows,beginCols,cannot operate on reference);}
      allocator_.shift(beginRows, beginCols);
      return this->asDerived();
    }
    Derived& shift(int firstIdx)
    {
      if (!hidden::CheckShift<Derived, structure_>::shift(this->asDerived(), firstIdx)) return this->asDerived();
      if (this->isRef())
      { STKRUNTIME_ERROR_1ARG(ICArray::shift,firstIdx,cannot operate on reference);}
      allocator_.shift(firstIdx);
      return this->asDerived();
    }
    Derived& resize(Range const& I, Range const& J)
    {
      STK_STATIC_ASSERT( (structure_ == (int)Arrays::array2D_)
                       ||(structure_ == (int)Arrays::square_)
                       ||(structure_ == (int)Arrays::diagonal_)
                       ||(structure_ == (int)Arrays::lower_triangular_)
                       ||(structure_ == (int)Arrays::upper_triangular_)
                       ||(structure_ == (int)Arrays::symmetric_)
                       ||(structure_ == (int)Arrays::lower_symmetric_)
                       ||(structure_ == (int)Arrays::upper_symmetric_)
                      ,YOU_CANNOT_USED_THIS_METHOD_WITH_THIS_KIND_OF_ARRAY);
      if (!hidden::CheckShift<Derived, structure_>::isAllowed(this->asDerived(), I, J))
      { STKRUNTIME_ERROR_2ARG(ICArray::resize,I,J,not permited);}
      if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), I, J)) return this->asDerived();
      if (this->isRef())
      { STKRUNTIME_ERROR_2ARG(ICArray::resize,I,J,cannot operate on reference);}
      allocator_.resize(I.size(), J.size()).shift(I.begin(), J.begin());
      return this->asDerived();
    }
    template<int Size_>
    Derived& resize(TRange<Size_> const& I)
    {
      if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), I)) return this->asDerived();
      if (this->isRef())
      { STKRUNTIME_ERROR_1ARG(ICArray::resize,I,cannot operate on reference);}
      allocator_.resize(I.size()).shift(I.begin());
      return this->asDerived();
    }
    Derived& resize(int size)
    {
      if (!hidden::CheckShift<Derived, structure_>::resize(this->asDerived(), size)) return this->asDerived();
      if (this->isRef())
      { STKRUNTIME_ERROR_1ARG(ICArray::resize,size,cannot operate on reference);}
      allocator_.resize(size);
      return this->asDerived();
    }
};
 
} // namespace STK
 
#endif /* STK_ICARRAY_H */