STK_ArrayBase.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: 13 oct. 2012
 * Author:   iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_ARRAYBASE_H
#define STK_ARRAYBASE_H
 
#include "STK_ExprBase.h"
#include "operators/STK_SlicingAccessors.h"
#include "operators/STK_TransposeAccessor.h"
#include "operators/STK_ReshapeAccessors.h"
 
#define MAKE_RESHAPE_OPERATOR(OPERATOR, SHAPE) \
  inline OPERATOR##Operator< Derived> const SHAPE() const \
  { return OPERATOR##Operator< Derived>(this->asDerived()); } \
  inline OPERATOR##Accessor< Derived> SHAPE() \
  { return OPERATOR##Accessor< Derived>(this->asDerived()); }
 
namespace STK
{
 
template< class Derived>
class ArrayBase: public ExprBase<Derived>
{
  public:
    typedef ExprBase<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_
    };
 
  protected:
    ArrayBase(): Base() {}
    ~ArrayBase() {}
 
  public:
    // start appliers
    template<typename Visitor>
    void apply(Visitor& visitor);
    Derived& randUnif();
    Derived& randGauss();
    Derived& rand( Law::IUnivLaw<Type> const& law);
    Derived& setOnes();
    Derived& setZeros();
    Derived& ones();
    Derived& zeros();
 
    Derived& setValue(TypeConst value);
    inline void setValue(int i, TypeConst value)
    { this->asDerived().setValueImpl(i, value);}
    inline void setValue(int i, int j, TypeConst value)
    { this->asDerived().setValueImpl(i, j, value);}
 
    template<class Rhs> Derived& assign(ExprBase<Rhs> const& rhs);
 
    Derived& operator=( Type const& value);
    Derived& operator=( Derived const& rhs);
    template<typename Rhs>
    Derived& operator=( ExprBase<Rhs> const& rhs);
 
    template<typename Rhs>
    Derived& operator+=( ExprBase<Rhs> const& other);
    template<typename Rhs>
    Derived& operator-=( ExprBase<Rhs> const& other);
    template<typename Rhs>
    Derived& operator/=( ExprBase<Rhs> const& other);
    template<typename Rhs>
    Derived& operator%=( ExprBase<Rhs> const& other);
    template<typename Rhs>
    Derived& operator*=( ExprBase<Rhs> const& other);
 
    Derived& operator+=( Type const& other);
    Derived& operator-=( Type const& other);
    Derived& operator*=( Type const& other);
    Derived& operator/=( Type const& other);
    Derived& operator%=( Type const& other);
 
    template<class Rhs>
    Derived& copy( ExprBase<Rhs> const& rhs);
 
    MAKE_RESHAPE_OPERATOR(Transpose,transpose)
    MAKE_RESHAPE_OPERATOR(Diagonalize,diagonalize)
    MAKE_RESHAPE_OPERATOR(DiagonalGetter,getDiagonal)
    MAKE_RESHAPE_OPERATOR(UpperTriangularize,upperTriangularize)
    MAKE_RESHAPE_OPERATOR(LowerTriangularize,lowerTriangularize)
    MAKE_RESHAPE_OPERATOR(Symmetrize,symmetrize)
    MAKE_RESHAPE_OPERATOR(UpperSymmetrize,upperSymmetrize)
    MAKE_RESHAPE_OPERATOR(LowerSymmetrize,lowerSymmetrize)
 
    // slice operators and accessors
    inline ColOperator<Derived> const col(int j) const
    { return ColOperator<Derived> (this->asDerived(), j);}
    inline RowOperator<Derived> const row(int i) const
    { return RowOperator<Derived> (this->asDerived(), i);}
    template<int Size_>
    inline SubVectorOperator<Derived, Size_> const sub(TRange<Size_> const& I) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
      return SubVectorOperator<Derived, Size_>(this->asDerived(), I);
    }
    template<int SizeRows_, int SizeCols_>
    inline SubOperator<Derived, SizeRows_, SizeCols_> const sub(TRange<SizeRows_> const& I,TRange<SizeCols_> const& J) const
    {
      STK_STATIC_ASSERT_TWO_DIMENSIONS_ONLY(Derived);
      return SubOperator<Derived, SizeRows_, SizeCols_>(this->asDerived(), I, J);
    }
    inline ColAccessor<Derived> col(int j)
    { return ColAccessor<Derived> (this->asDerived(), j);}
    inline RowAccessor<Derived> row(int i)
    { return RowAccessor<Derived> (this->asDerived(), i);}
    template<int Size_>
    inline SubVectorAccessor<Derived, Size_> sub(TRange<Size_> const& I)
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
      return SubVectorAccessor<Derived, Size_>(this->asDerived(), I);
    }
    template<int SizeRows_, int SizeCols_>
    inline SubAccessor<Derived, SizeRows_, SizeCols_> sub(TRange<SizeRows_> const& I,TRange<SizeCols_> const& J)
    {
      STK_STATIC_ASSERT_TWO_DIMENSIONS_ONLY(Derived);
      return SubAccessor<Derived, SizeRows_, SizeCols_>(this->asDerived(), I, J);
    }
 
    // overloaded operators
    inline TypeConst operator()(int i, int j) const
    {
#ifdef STK_BOUNDS_CHECK
       if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(IArrayBase::elt, i, j, beginRows() > i);}
       if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(IArrayBase::elt, i, j, endRows() <= i);}
       if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(IArrayBase::elt, i, j, beginCols() > j);}
       if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(IArrayBase::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(IArrayBase::elt, i, j, beginRows() > i);}
       if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(IArrayBase::elt, i, j, endRows() <= i);}
       if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(IArrayBase::elt, i, j, beginCols() > j);}
       if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(IArrayBase::elt, i, j, endCols() <= j);}
#endif
      return this->elt(i,j);
    }
    inline TypeConst operator[](int i) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
#ifdef STK_BOUNDS_CHECK
      if (this->begin() > i) { STKOUT_OF_RANGE_1ARG(IArrayBase::elt, i, begin() > i);}
      if (this->end() <= i)  { STKOUT_OF_RANGE_1ARG(IArrayBase::elt, 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->begin() > i) { STKOUT_OF_RANGE_1ARG(IArrayBase::elt, i, begin() > i);}
      if (this->end() <= i)  { STKOUT_OF_RANGE_1ARG(IArrayBase::elt, i, end() <= i);}
#endif
      return this->elt(i);
    }
    inline TypeConst operator()() const { return this->elt();}
    inline Type& operator()() { return this->elt();}
    ArrayInitializer<Derived> operator<<(Type const& s);
 
    template<typename Rhs>
    ArrayInitializer<Derived> operator<<(ArrayBase<Rhs> const& other);
};
 
} // namespace STK
 
#undef MAKE_RESHAPE_OPERATOR
 
#include "STK_ArrayBaseApplier.h"
#include "STK_ArrayBaseAssign.h"
#include "STK_ArrayBaseInitializer.h"
 
#endif /* STK_ARRAYBASE_H_ */