STK_Const_Arrays.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.org (see copyright for ...)
*/
 
/*
 * Project:  stkpp::Arrays
 * created on: 25 juil. 2013
 * Author:   iovleff, serge.iovleff@stkpp.org
 **/
 
#ifndef STK_CONST_ARRAYS_H
#define STK_CONST_ARRAYS_H
 
#include "STK_ExprBase.h"
 
namespace STK
{
 
// forward declaration
namespace Const
{
template< typename Type_, int Size_ = UnknownSize> class Identity;
template< typename Type_, int Size_ = UnknownSize> class Square;
template< typename Type_, int Size_ = UnknownSize> class Vector;
template< typename Type_, int Size_ = UnknownSize> class Point;
template< typename Type_, int SizeRows_ = UnknownSize, int SizeCols_ = UnknownSize> class Array;
template< typename Type_, int SizeRows_ = UnknownSize, int SizeCols_ = UnknownSize> class UpperTriangular;
template< typename Type_, int SizeRows_ = UnknownSize, int SizeCols_ = UnknownSize> class LowerTriangular;
 
typedef Vector<Real, UnknownSize>   VectorX;
typedef Vector<Real, 3>             Vector3;
typedef Vector<Real, 2>             Vector2;
typedef Vector<double, UnknownSize> VectorXd;
typedef Vector<double, 3>           Vector3d;
typedef Vector<double, 2>           Vector2d;
typedef Vector<int, UnknownSize>    VectorXi;
typedef Vector<int, 3>              Vector3i;
typedef Vector<int, 2>              Vector2i;
 
typedef Vector<Real, UnknownSize>   ConstVectorX;
typedef Vector<Real, 3>             ConstVector3;
typedef Vector<Real, 2>             ConstVector2;
typedef Vector<double, UnknownSize> ConstVectorXd;
typedef Vector<double, 3>           ConstVector3d;
typedef Vector<double, 2>           ConstVector2d;
typedef Vector<int, UnknownSize>    ConstVectorXi;
typedef Vector<int, 3>              ConstVector3i;
typedef Vector<int, 2>              ConstVector2i;
 
typedef Point<Real, UnknownSize>   PointX;
typedef Point<Real, 3>             Point3;
typedef Point<Real, 2>             Point2;
typedef Point<double, UnknownSize> PointXd;
typedef Point<double, 3>           Point3d;
typedef Point<double, 2>           Point2d;
typedef Point<int, UnknownSize>    PointXi;
typedef Point<int, 3>              Point3i;
typedef Point<int, 2>              Point2i;
 
typedef Point<Real, UnknownSize>   ConstPointX;
typedef Point<Real, 3>             ConstPoint3;
typedef Point<Real, 2>             ConstPoint2;
typedef Point<double, UnknownSize> ConstPointXd;
typedef Point<double, 3>           ConstPoint3d;
typedef Point<double, 2>           ConstPoint2d;
typedef Point<int, UnknownSize>    ConstPointXi;
typedef Point<int, 3>              ConstPoint3i;
typedef Point<int, 2>              ConstPoint2i;
}
 
namespace hidden
{
template< typename Type_, int Size_>
struct Traits< Const::Identity <Type_, Size_> >
{
  enum
  {
    structure_ = Arrays::diagonal_,
    sizeRows_  = Size_,
    sizeCols_  = Size_,
    size_      = Size_,
    orient_    = Arrays::by_col_,
    storage_   = Arrays::sparse_
  };
 
  typedef Type_                Type;
  typedef typename RemoveConst<Type>::Type TypeConst;
};
template< typename Type_, int Size_>
struct Traits< Const::Vector <Type_, Size_> >
{
  enum
  {
    structure_ = Arrays::vector_,
    sizeRows_  = Size_,
    sizeCols_  = 1,
    size_      = Size_,
    orient_    = Arrays::by_col_,
    storage_   = Arrays::sparse_
  };
  typedef Type_                Type;
  typedef typename RemoveConst<Type>::Type TypeConst;
};
template< typename Type_, int Size_>
struct Traits< Const::Point <Type_, Size_> >
{
  enum
  {
    structure_ = Arrays::point_,
    sizeRows_  = 1,
    sizeCols_  = Size_,
    size_      = Size_,
    orient_    = Arrays::by_row_,
    storage_   = Arrays::sparse_
  };
  typedef Type_                Type;
  typedef typename RemoveConst<Type>::Type TypeConst;
};
template< typename Type_, int Size_>
struct Traits< Const::Square <Type_, Size_> >
{
  enum
  {
    structure_ = Arrays::square_,
    sizeRows_  = Size_,
    sizeCols_  = Size_,
    size_      = Size_,
    orient_    = Arrays::by_col_,
    storage_   = Arrays::sparse_
  };
  typedef Type_                Type;
  typedef typename RemoveConst<Type>::Type TypeConst;
};
template< typename Type_, int SizeRows_, int SizeCols_>
struct Traits< Const::Array<Type_, SizeRows_, SizeCols_> >
{
  enum
  {
    structure_ = Arrays::array2D_,
    sizeRows_  = SizeRows_,
    sizeCols_  = SizeCols_,
    orient_    = Arrays::by_col_,
    storage_   = Arrays::sparse_
  };
  typedef Type_                Type;
  typedef typename RemoveConst<Type>::Type TypeConst;
};
template< typename Type_, int SizeRows_, int SizeCols_>
struct Traits< Const::UpperTriangular<Type_, SizeRows_, SizeCols_> >
{
  enum
  {
    structure_ = Arrays::upper_triangular_,
    sizeRows_  = SizeRows_,
    sizeCols_  = SizeCols_,
    orient_    = Arrays::by_col_,
    storage_   = Arrays::sparse_
  };
  typedef Type_                Type;
  typedef typename RemoveConst<Type>::Type TypeConst;
};
template< typename Type_, int SizeRows_, int SizeCols_>
struct Traits< Const::LowerTriangular<Type_, SizeRows_, SizeCols_> >
{
  enum
  {
    structure_ = Arrays::lower_triangular_,
    sizeRows_  = SizeRows_,
    sizeCols_  = SizeCols_,
    orient_    = Arrays::by_col_,
    storage_   = Arrays::sparse_
  };
  typedef Type_                Type;
  typedef typename RemoveConst<Type>::Type TypeConst;
};
 
} // namespace hidden
 
namespace Const
{
template< class Derived>
class IConstArray: protected IContainer2D<hidden::Traits<Derived>::sizeRows_, hidden::Traits<Derived>::sizeCols_>, public ExprBase<Derived>
{
  public:
    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;
    typedef IContainer2D<sizeRows_, sizeCols_ > Base2D;
    typedef ExprBase<Derived> Base;
    typedef typename hidden::Traits< Derived >::TypeConst TypeConst;
 
  protected:
    IConstArray(): Base2D(), Base() {}
    IConstArray(Range const& rows, Range const& cols): Base2D(rows, cols), Base() {}
    ~IConstArray() {}
 
  public:
    inline RowRange const& rowsImpl() const { return Base2D::rows();}
    inline RowRange const& rows() const { return Base2D::rows();}
    inline int beginRows() const { return Base2D::beginRows();}
    inline int endRows() const { return Base2D::endRows();}
    inline int sizeRows() const { return Base2D::sizeRows();}
 
    inline ColRange const&colsImpl() const { return Base2D::cols();}
    inline ColRange const&cols() const { return Base2D::cols();}
    inline int beginCols() const { return Base2D::beginCols();}
    inline int endCols() const { return Base2D::endCols();}
    inline int sizeCols() const { return Base2D::sizeCols();}
 
    inline int lastIdxCols() const { return Base2D::lastIdxCols();}
    inline int lastIdxRows() const { return Base2D::lastIdxRows();}
 
    bool empty() const { return Base2D::empty();}
};
 
template< typename Type_, int Size_ >
class Identity: public IConstArray<Identity<Type_, Size_> >
{
  public:
    typedef IConstArray<Identity<Type_, Size_> > Base;
    typedef typename hidden::Traits< Identity<Type_, Size_> >::Type Type;
    typedef typename hidden::Traits< Identity<Type_, Size_> >::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits< Identity <Type_, Size_> >::structure_,
      orient_    = hidden::Traits< Identity <Type_, Size_> >::orient_,
      sizeRows_  = hidden::Traits< Identity <Type_, Size_> >::sizeRows_,
      sizeCols_  = hidden::Traits< Identity <Type_, Size_> >::sizeCols_,
      storage_   = hidden::Traits< Identity <Type_, Size_> >::storage_
    };
    Identity(): Base() {}
    Identity(Range I): Base(I,I) {}
    inline TypeConst elt2Impl(int i, int j) const { return (i==j ? Type(1) : Type(0));}
    inline TypeConst elt1Impl(int i) const { return Type(1);}
};
 
template< typename Type_, int Size_ >
class Square: public IConstArray<Square<Type_, Size_> >
{
  public:
    typedef IConstArray<Square<Type_, Size_> > Base;
    typedef typename hidden::Traits< Square<Type_, Size_> >::Type Type;
    typedef typename hidden::Traits< Square<Type_, Size_> >::TypeConst TypeConst;
    enum
    {
      structure_ = hidden::Traits< Square <Type_, Size_> >::structure_,
      orient_    = hidden::Traits< Square <Type_, Size_> >::orient_,
      sizeRows_  = hidden::Traits< Square <Type_, Size_> >::sizeRows_,
      sizeCols_  = hidden::Traits< Square <Type_, Size_> >::sizeCols_,
      storage_   = hidden::Traits< Square <Type_, Size_> >::storage_
    };
    Square(): Base() {}
    Square(Range I): Base(I, I) {}
    inline TypeConst elt2Impl(int i, int j) const { return (Type(1));}
};
 
template< typename Type_, int SizeRows_, int SizeCols_ >
class Array: public IConstArray<Array<Type_, SizeRows_, SizeCols_> >
{
  public:
    typedef IConstArray<Array<Type_, SizeRows_, SizeCols_> > Base;
    typedef typename hidden::Traits< Array<Type_, SizeRows_, SizeCols_> >::Type Type;
    typedef typename hidden::Traits< Array<Type_, SizeRows_, SizeCols_> >::TypeConst TypeConst;
 
    enum
    {
      structure_ = hidden::Traits< Array <Type_, SizeRows_, SizeCols_> >::structure_,
      orient_    = hidden::Traits< Array <Type_, SizeRows_, SizeCols_> >::orient_,
      sizeRows_  = hidden::Traits< Array <Type_, SizeRows_, SizeCols_> >::sizeRows_,
      sizeCols_  = hidden::Traits< Array <Type_, SizeRows_, SizeCols_> >::sizeCols_,
      storage_   = hidden::Traits< Array <Type_, SizeRows_, SizeCols_> >::storage_
    };
    Array(): Base() {}
    Array(Range rangeRows, Range rangeCols): Base(rangeRows, rangeCols) {}
    inline TypeConst elt2Impl(int i, int j) const { return (Type(1));}
};
 
template< typename Type_, int SizeRows_, int SizeCols_ >
class UpperTriangular: public IConstArray<UpperTriangular<Type_, SizeRows_, SizeCols_> >
{
  public:
    typedef IConstArray<UpperTriangular<Type_, SizeRows_, SizeCols_> > Base;
    typedef typename hidden::Traits< UpperTriangular<Type_, SizeRows_, SizeCols_> >::Type Type;
    typedef typename hidden::Traits< UpperTriangular<Type_, SizeRows_, SizeCols_> >::TypeConst TypeConst;
 
    enum
    {
      structure_ = hidden::Traits< UpperTriangular <Type_, SizeRows_, SizeCols_> >::structure_,
      orient_    = hidden::Traits< UpperTriangular <Type_, SizeRows_, SizeCols_> >::orient_,
      sizeRows_  = hidden::Traits< UpperTriangular <Type_, SizeRows_, SizeCols_> >::sizeRows_,
      sizeCols_  = hidden::Traits< UpperTriangular <Type_, SizeRows_, SizeCols_> >::sizeCols_,
      storage_   = hidden::Traits< UpperTriangular <Type_, SizeRows_, SizeCols_> >::storage_
    };
    UpperTriangular(): Base() {}
    UpperTriangular(Range rangeRows, Range rangeCols): Base(rangeRows, rangeCols) {}
    inline TypeConst elt2Impl(int i, int j) const { return i<j ? (Type(1)) : Type(0);}
};
 
template< typename Type_, int SizeRows_, int SizeCols_ >
class LowerTriangular: public IConstArray<LowerTriangular<Type_, SizeRows_, SizeCols_> >
{
  public:
    typedef IConstArray<LowerTriangular<Type_, SizeRows_, SizeCols_> > Base;
    typedef typename hidden::Traits< LowerTriangular<Type_, SizeRows_, SizeCols_> >::Type Type;
    typedef typename hidden::Traits< LowerTriangular<Type_, SizeRows_, SizeCols_> >::TypeConst TypeConst;
 
    enum
    {
      structure_ = hidden::Traits< LowerTriangular <Type_, SizeRows_, SizeCols_> >::structure_,
      orient_    = hidden::Traits< LowerTriangular <Type_, SizeRows_, SizeCols_> >::orient_,
      sizeRows_  = hidden::Traits< LowerTriangular <Type_, SizeRows_, SizeCols_> >::sizeRows_,
      sizeCols_  = hidden::Traits< LowerTriangular <Type_, SizeRows_, SizeCols_> >::sizeCols_,
      storage_   = hidden::Traits< LowerTriangular <Type_, SizeRows_, SizeCols_> >::storage_
    };
    LowerTriangular(): Base() {}
    LowerTriangular(Range rangeRows, Range rangeCols): Base(rangeRows, rangeCols) {}
    inline TypeConst elt2Impl(int i, int j) const { return (Type(1));}
};
 
template< typename Type_, int Size_ >
class Point: public IConstArray<Point<Type_, Size_> >
{
  public:
    typedef IConstArray<Point<Type_, Size_> > Base;
    typedef typename hidden::Traits< Point<Type_, Size_> >::Type Type;
    typedef typename hidden::Traits< Point<Type_, Size_> >::TypeConst TypeConst;
 
    enum
    {
      structure_ = hidden::Traits< Point <Type_, Size_> >::structure_,
      orient_    = hidden::Traits< Point <Type_, Size_> >::orient_,
      sizeRows_  = hidden::Traits< Point <Type_, Size_> >::sizeRows_,
      sizeCols_  = hidden::Traits< Point <Type_, Size_> >::sizeCols_,
      storage_   = hidden::Traits< Point <Type_, Size_> >::storage_
    };
    Point(): Base() {}
    Point(Range I): Base(1, I) {}
    inline TypeConst elt1Impl(int j) const { return (Type(1));}
    inline TypeConst elt2Impl(int i, int j) const { return (Type(1));}
};
 
template< typename Type_, int Size_ >
class Vector: public IConstArray<Vector<Type_, Size_> >
{
  public:
    typedef IConstArray<Vector<Type_, Size_> > Base;
    typedef typename hidden::Traits< Vector<Type_, Size_> >::Type Type;
    typedef typename hidden::Traits< Vector<Type_, Size_> >::TypeConst TypeConst;
 
    enum
    {
      structure_ = hidden::Traits< Vector <Type_, Size_> >::structure_,
      orient_    = hidden::Traits< Vector <Type_, Size_> >::orient_,
      sizeRows_  = hidden::Traits< Vector <Type_, Size_> >::sizeRows_,
      sizeCols_  = hidden::Traits< Vector <Type_, Size_> >::sizeCols_,
      storage_   = hidden::Traits< Vector <Type_, Size_> >::storage_
    };
    Vector(): Base() {}
    Vector(Range I): Base(I, 1) {}
    inline TypeConst elt1Impl(int i) const { return (Type(1));}
    inline TypeConst elt2Impl(int i, int j) const { return (Type(1));}
};
 
 
} // namespace const
 
} // namespace STK
 
#endif /* STK_CONST_ARRAYS_H */