STK_ExprBase.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_EXPRBASE_H
#define STK_EXPRBASE_H
 
namespace STK
{
// forward declaration
template<class Derived> class ExprBase;
template<class Derived> class ArrayBase;
}
 
 
#include <STatistiK/include/STK_Law_IUnivLaw.h>
#include <STatistiK/include/STK_Law_Functors.h>
#include "STK_ArraysTraits.h"
#include "STK_Arrays_Util.h"
#include "STK_ITContainer.h"
#include "STK_IContainerRef.h"
#include "operators/STK_BinaryImpl.h"
#include "products/STK_ProductDispatcher.h"
#include "products/STK_ProductOperators.h"
#include "products/STK_DotProduct.h"
#include "operators/STK_SlicingOperators.h"
#include "operators/STK_TransposeOperator.h"
#include "operators/STK_ReshapeOperators.h"
#include "operators/STK_UnaryOperators.h"
#include "operators/STK_BinaryOperators.h"
 
// forward declarations
namespace STK
{
template<class Derived> class ArrayInitializer;
 
namespace hidden
{
  template<typename Lhs, typename Rhs, int LStructure_, int RStructure_> struct ProductSelector;
  template<typename Lhs, typename Rhs, int operatorType_> struct OperatorSelector;
} // namespace hidden
 
} // namespace STK
 
 
#define DEFINE_BINARY_OPERATOR(OPERATORNAME, BINARYOPERATORNAME) \
template<typename Rhs> \
typename hidden::OperatorSelector<Derived, Rhs, Arrays::BINARYOPERATORNAME>::Result const \
OPERATORNAME( ExprBase<Rhs> const& other) const;
 
#define MAKE_UNARY_OPERATOR_NOARG(FUNCTION, FUNCTOR) \
  inline UnaryOperator<FUNCTOR<Type>, Derived> FUNCTION() const \
  { return UnaryOperator<FUNCTOR<Type>, Derived>(this->asDerived()); }
 
#define MAKE_UNARY_OPERATOR_1ARG(FUNCTION, FUNCTOR) \
  inline UnaryOperator<FUNCTOR<Type>, Derived> FUNCTION(Type const& value) const \
  { return UnaryOperator<FUNCTOR<Type>, Derived>(this->asDerived(), FUNCTOR<Type>(value)); }
 
#define MAKE_RESHAPE_OPERATOR(OPERATOR, SHAPE) \
  inline OPERATOR##Operator< Derived> const SHAPE() const \
  { return OPERATOR##Operator< Derived>(this->asDerived()); }
 
 
namespace STK
{
 
template<class Derived>
class ExprBase: public ITContainer<Derived, hidden::Traits<Derived>::structure_>
{
  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 ITContainer<Derived, structure_> Base;
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
 
  protected:
    inline ExprBase(): Base() {}
    inline ~ExprBase() {}
 
  public:
    //--------------
    // Start Visitors
    template<typename Visitor>
    typename Visitor::TypeConst visit(Visitor& visitor) const;
    int count() const;
    bool const any() const;
    bool const all() const;
    int nbAvailableValues() const;
 
    Type const minElt( int& row, int& col) const;
    Type const minEltSafe( int& row, int& col) const;
    Type const maxElt( int& row, int& col) const;
    Type const maxEltSafe( int& row, int& col) const;
    Type const minElt( int& pos) const;
    Type const minEltSafe( int& pos) const;
    Type const maxElt( int& pos) const;
    Type const maxEltSafe( int& pos) const;
    Type const minElt() const;
    Type const minEltSafe() const;
    Type const maxElt() const;
    Type const maxEltSafe() const;
 
    Type const sum() const;
    Type const sumSafe() const;
 
    Type const norm() const;
    Type const normSafe() const;
    Type const norm2() const;
    Type const norm2Safe() const;
    Type const normInf() const;
 
    Type const mean() const;
    Type const meanSafe() const;
    Type const variance() const;
    Type const varianceSafe() const;
    Type const variance(Type const& mean) const;
    Type const varianceSafe(Type const& mean) const;
 
    template<typename Rhs>
    Type const wsum(ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wsumSafe(ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wnorm(ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wnormSafe(ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wnorm2(ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wnorm2Safe(ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wmean(ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wmeanSafe(ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wvariance(ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wvarianceSafe(ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wvariance(Type const& mean, ExprBase<Rhs> const& weights) const;
    template<typename Rhs>
    Type const wvarianceSafe(Type const& mean, ExprBase<Rhs> const& weights) const;
    // Visitors terminated
    //--------------------
    // BinaryOperators
    DEFINE_BINARY_OPERATOR(operator==,equalOp_)
    DEFINE_BINARY_OPERATOR(operator!=,notEqualOp_)
    DEFINE_BINARY_OPERATOR(operator>,greaterThanOp_)
    DEFINE_BINARY_OPERATOR(operator<,lessThanOp_)
    DEFINE_BINARY_OPERATOR(operator>=,greaterThanOrEqualOp_)
    DEFINE_BINARY_OPERATOR(operator<=,lessThanOrEqualOp_)
 
    
    DEFINE_BINARY_OPERATOR(operator+,sumOp_)
    DEFINE_BINARY_OPERATOR(operator-,differenceOp_)
    DEFINE_BINARY_OPERATOR(prod,productOp_)
    DEFINE_BINARY_OPERATOR(operator/,divisionOp_)
    DEFINE_BINARY_OPERATOR(operator%,moduloOp_)
 
    
    DEFINE_BINARY_OPERATOR(min,minOp_)
    DEFINE_BINARY_OPERATOR(max,maxOp_)
 
    
    DEFINE_BINARY_OPERATOR(operator&&,logicalAndOp_)
    DEFINE_BINARY_OPERATOR(operator||,logicalOrOp_)
 
    
    DEFINE_BINARY_OPERATOR(operator&,bitwiseAndOp_)
    DEFINE_BINARY_OPERATOR(operator|,bitwiseOrOp_)
    DEFINE_BINARY_OPERATOR(operator^,bitwiseXorOp_)
    // BinaryOperators terminated
    //--------------------
    // UnaryOperators
    MAKE_UNARY_OPERATOR_NOARG(operator-, OppositeOp)
    MAKE_UNARY_OPERATOR_NOARG(isNA, IsNaOp)
    MAKE_UNARY_OPERATOR_NOARG(neg, NegOp)
    MAKE_UNARY_OPERATOR_NOARG(isFinite, IsFiniteOp)
    MAKE_UNARY_OPERATOR_NOARG(isInfinite, IsInfiniteOp)
    MAKE_UNARY_OPERATOR_NOARG(abs, AbsOp)
    MAKE_UNARY_OPERATOR_NOARG(exp, ExpOp)
    MAKE_UNARY_OPERATOR_NOARG(log, LogOp)
    MAKE_UNARY_OPERATOR_NOARG(sqrt, SqrtOp)
    MAKE_UNARY_OPERATOR_NOARG(cos, CosOp)
    MAKE_UNARY_OPERATOR_NOARG(sin, SinOp)
    MAKE_UNARY_OPERATOR_NOARG(acos, AcosOp)
    MAKE_UNARY_OPERATOR_NOARG(asin, AsinOp)
    MAKE_UNARY_OPERATOR_NOARG(tan, TanOp)
    MAKE_UNARY_OPERATOR_NOARG(inverse, InverseOp)
    MAKE_UNARY_OPERATOR_NOARG(square, SquareOp)
    MAKE_UNARY_OPERATOR_NOARG(cube, CubeOp)
 
    // boolean operations
    MAKE_UNARY_OPERATOR_1ARG(operator==, EqualWithOp)
    MAKE_UNARY_OPERATOR_1ARG(operator!=, NotEqualWithOp)
    MAKE_UNARY_OPERATOR_1ARG(operator>, GreaterThanOp)
    MAKE_UNARY_OPERATOR_1ARG(operator<, LessThanOp)
    MAKE_UNARY_OPERATOR_1ARG(operator<=, LeqThanOp)
    MAKE_UNARY_OPERATOR_1ARG(operator>=, GeqThanOp)
 
    MAKE_UNARY_OPERATOR_1ARG(min, MinWithOp)
    MAKE_UNARY_OPERATOR_1ARG(max, MaxWithOp)
 
    MAKE_UNARY_OPERATOR_1ARG(operator+, SumWithOp)
    MAKE_UNARY_OPERATOR_1ARG(operator-, DifferenceWithOp)
    MAKE_UNARY_OPERATOR_1ARG(operator*, ProductWithOp)
    MAKE_UNARY_OPERATOR_1ARG(operator/, DivisionWithOp)
    MAKE_UNARY_OPERATOR_1ARG(operator%, ModuloWithOp)
 
    MAKE_UNARY_OPERATOR_1ARG(operator&&, LogicalAndWithOp)
    MAKE_UNARY_OPERATOR_1ARG(operator||, LogicalOrWithOp)
 
    MAKE_UNARY_OPERATOR_1ARG(operator&, BitwiseAndWithOp)
    MAKE_UNARY_OPERATOR_1ARG(operator|, BitwiseOrWithOp)
    MAKE_UNARY_OPERATOR_1ARG(operator^, BitwiseXorWithOp)
 
    MAKE_UNARY_OPERATOR_1ARG(pow, PowOp)
    MAKE_UNARY_OPERATOR_1ARG(safeInverse, SafeInverseOp)
 
    inline UnaryOperator<SafeOp<Type>, Derived> const safe(Type const value = Type()) const
    { return UnaryOperator<SafeOp<Type>, Derived>(this->asDerived(), SafeOp<Type>(value)); }
 
    // friends
    inline friend UnaryOperator<SumWithOp<Type>, Derived> const
    operator+(Type const& value, ExprBase<Derived> const& other)
    { return other.asDerived() + value;}
    inline friend UnaryOperator<SubstractToOp<Type>, Derived > const
    operator-(Type const value, ExprBase<Derived> const& other)
    { return UnaryOperator<SubstractToOp<Type>, Derived>(other.asDerived(), SubstractToOp<Type>(value));}
    inline friend UnaryOperator< ProductWithOp<Type>, Derived> const
    operator*(Type const value, ExprBase<Derived> const& other)
    { return other.asDerived()*value; }
 
    template<typename OtherType>
    inline UnaryOperator<CastOp<Type, OtherType>, Derived> const cast() const
    { return UnaryOperator<CastOp<Type, OtherType>, Derived>(this->asDerived());}
 
    // pdf, lpdf, cdf, icdf
    inline UnaryOperator<Law::PdfOp<Type>, Derived> pdf( Law::IUnivLaw<Type> const& law) const
    { return UnaryOperator<Law::PdfOp<Type>, Derived>(this->asDerived(), Law::PdfOp<Type>(law));}
    inline UnaryOperator<Law::LogPdfOp<Type>, Derived> lpdf( Law::IUnivLaw<Type> const& law) const
    { return UnaryOperator<Law::LogPdfOp<Type>, Derived>(this->asDerived(), Law::LogPdfOp<Type>(law));}
    inline UnaryOperator<Law::CdfOp<Type>, Derived> cdf( Law::IUnivLaw<Type> const& law) const
    { return UnaryOperator<Law::CdfOp<Type>, Derived>(this->asDerived(), Law::CdfOp<Type>(law));}
    inline UnaryOperator<Law::LogCdfOp<Type>, Derived> lcdf( Law::IUnivLaw<Type> const& law) const
    { return UnaryOperator<Law::LogCdfOp<Type>, Derived>(this->asDerived(), Law::LogCdfOp<Type>(law));}
    inline UnaryOperator<Law::CdfcOp<Type>, Derived> cdfc( Law::IUnivLaw<Type> const& law) const
    { return UnaryOperator<Law::CdfcOp<Type>, Derived>(this->asDerived(), Law::CdfcOp<Type>(law));}
    inline UnaryOperator<Law::LogCdfcOp<Type>, Derived> lcdfc( Law::IUnivLaw<Type> const& law) const
    { return UnaryOperator<Law::LogCdfcOp<Type>, Derived>(this->asDerived(), Law::LogCdfcOp<Type>(law));}
    inline UnaryOperator<Law::IcdfOp<Type>, Derived> icdf( Law::IUnivLaw<Type> const& law) const
    { return UnaryOperator<Law::IcdfOp<Type>, Derived>(this->asDerived(), Law::IcdfOp<Type>(law));}
 
    // extension
    template< template<typename> class OtherOperator>
    inline UnaryOperator<OtherOperator<Type>, Derived> const funct0() const
    { return UnaryOperator<OtherOperator<Type>, Derived>(this->asDerived());}
    template< template<typename> class OtherOperator>
    inline UnaryOperator<OtherOperator<Type>, Derived> const funct1(Type const value) const
    { return UnaryOperator<OtherOperator<Type>, Derived>(this->asDerived(), OtherOperator<Type>(value));}
 
    // reshape operations
    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
    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);
    }
 
    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 SubOperator<Derived, sizeRows_, Size_> const col(TRange<Size_> const& J) const
    { return SubOperator<Derived, sizeRows_, Size_> (this->asDerived(), this->rows(), J);}
    template<int Size_>
    inline SubOperator<Derived, Size_, sizeCols_> const row(TRange<Size_> const& I) const
    { return SubOperator<Derived, Size_, sizeCols_> (this->asDerived(), I, this->cols());}
 
    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);
    }
 
    // dot operations
    template<class Rhs>
    typename hidden::Promote<Type, typename Rhs::Type>::result_type const
    dot(ExprBase<Rhs> const& other) const;
    template<class Rhs>
    typename hidden::Promote<Type, typename Rhs::Type>::result_type const
    dotSafe(ExprBase<Rhs> const& other) const;
 
    template<typename Rhs>
    typename hidden::ProductSelector<Derived, Rhs, hidden::Traits<Derived>::structure_, hidden::Traits<Rhs>::structure_>::ProductType const
    operator*( ExprBase<Rhs> const& other) const;
};
 
} // namespace STK
 
#undef DEFINE_BINARY_OPERATOR
#undef MAKE_UNARY_OPERATOR_NOARG
#undef MAKE_UNARY_OPERATOR_1ARG
#undef MAKE_RESHAPE_OPERATOR
 
#include "STK_ExprBaseVisitor.h"
#include "STK_ExprBaseDot.h"
#include "STK_ExprBaseProduct.h"
#include "STK_ExprBaseOperators.h"
 
 
#endif /* STK_EXPRBASE_H_ */