expression.ixx

Go to the documentation of this file.

#ifndef NUMCXX_EXPRESSION_HXX
#define NUMCXX_EXPRESSION_HXX
#include <type_traits>

namespace numcxx
{

  class ExpressionBase  { };

  class MatrixExpressionBase  { };

  class SparseMatrixExpressionBase { };


  template<typename A, typename B,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  class AdditionExpression: public ExpressionBase
  {
    const A& a;
    const B& b;
  public:
    typedef typename A::value_type value_type;
    AdditionExpression(const A& a, const B& b):a(a), b(b){}
    unsigned int size() const { return a.size(); }
    const value_type operator[](const unsigned int i) const {return a[i] + b[i];}
    AdditionExpression& operator=(const AdditionExpression&)=delete;
  };
        
  template<typename A, typename B, 
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  const AdditionExpression<A,B> operator+(const A& a, const B& b)
  {
    return AdditionExpression<A,B>(a, b);
  }


  template<typename A, typename B,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  class SubtractionExpression: public ExpressionBase
  {
    const A& a;
    const B& b;
  public:
    typedef typename A::value_type value_type;
    SubtractionExpression(const A& a, const B& b):a(a), b(b){}
    unsigned int size() const { return a.size(); }
    const value_type operator[](const unsigned int i) const  {   return a[i] - b[i];}
  };
        
  template<typename A, typename B,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  const SubtractionExpression<A,B> operator-(const A& a, const B& b)
  {
    return SubtractionExpression<A,B>(a, b);
  }
        
  template<typename A, typename B, 
           typename= typename std::enable_if<std::is_fundamental<A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  class LeftScalarMultiplicationExpression: public ExpressionBase
  {
    const A a; 
    const B& b;
  public:
    typedef typename B::value_type value_type;
    LeftScalarMultiplicationExpression(const A& a, const B& b):a(a), b(b){}
    unsigned int size() const { return b.size(); }
    const value_type operator[](const unsigned int i) const {return a*b[i];}
  };
        
  template<typename A, typename B,
           typename= typename std::enable_if<std::is_fundamental<A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  const LeftScalarMultiplicationExpression<A,B> operator*(const A& a, const B& b)
  {
    return LeftScalarMultiplicationExpression<A,B>(a, b);
  }


  template<typename A, typename B, 
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_fundamental<B>::value, B>::type>
  class RightScalarMultiplicationExpression: public ExpressionBase
  {
    const A& a;
    const B b; 
  public:
    typedef typename A::value_type value_type;
    RightScalarMultiplicationExpression(const A& a, const B& b):a(a),b(b){;}
    unsigned int size() const { return a.size(); }
    const value_type operator[](const unsigned int i) const   {return a[i]*b; }
  };
        
  template<typename A, typename B,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_fundamental<B>::value, B>::type>
  const RightScalarMultiplicationExpression<A,B> operator*(const A& a, const B& b)
  {
    return RightScalarMultiplicationExpression<A,B>(a, b);
  }
    

        
  template<typename A, typename B,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_fundamental<B>::value, B>::type>
  class RightScalarAdditionExpression: public ExpressionBase
  {
    const A& a;
    const B b; 
  public:
    typedef typename A::value_type value_type;
    RightScalarAdditionExpression(const A& a, const B& b):a(a), b(b){}
    unsigned int size() const { return a.size(); }
    const value_type operator[](const unsigned int i) const   { return a[i]+b; }
  };
        
  template<typename A, typename B,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_fundamental<B>::value, B>::type>
  const RightScalarAdditionExpression<A,B> operator+(const A& a, const B& b)
  {
    return RightScalarAdditionExpression<A,B>(a, b);
  }
        
  template<typename A, typename B,
           typename= typename std::enable_if<std::is_fundamental<A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  class LeftScalarAdditionExpression: public ExpressionBase
  {
    const A a; 
    const B& b;
  public:
    typedef typename B::value_type value_type;
    LeftScalarAdditionExpression(const A& a, const B& b):a(a), b(b){}
    unsigned int size() const { return b.size(); }
    const value_type operator[](const unsigned int i) const { return a+b[i];}
  };

  template<typename A, typename B,
           typename= typename std::enable_if<std::is_fundamental<A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  const LeftScalarAdditionExpression<A,B> operator+(const A& a, const B& b)
  {
    return LeftScalarAdditionExpression<A,B>(a, b);
  }

  template<typename A, typename B,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_fundamental<B>::value, B>::type>
  class RightScalarSubtractionExpression: public ExpressionBase
  {
    const A& a;
    const B b; 
  public:
    typedef typename A::value_type value_type;
    RightScalarSubtractionExpression(const A& a, const B& b):a(a), b(b){}
    unsigned int size() const { return a.size(); }
    const value_type operator[](const unsigned int i) const   { return a[i]-b; }
  };
        
  template<typename A, typename B,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_fundamental<B>::value, B>::type>
  const RightScalarSubtractionExpression<A,B> operator-(const A& a, const B& b)
  {
    return RightScalarSubtractionExpression<A,B>(a, b);
  }
        
  template<typename A, typename B,
           typename= typename std::enable_if<std::is_fundamental<A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  class LeftScalarSubtractionExpression: public ExpressionBase
  {
    const A a; 
    const B& b;
  public:
    typedef typename B::value_type value_type;
    LeftScalarSubtractionExpression(const A& a, const B& b):a(a), b(b){}
    unsigned int size() const { return b.size(); }
    const value_type operator[](const unsigned int i) const { return a-b[i];}
  };

  template<typename A, typename B,
           typename= typename std::enable_if<std::is_fundamental<A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  const LeftScalarSubtractionExpression<A,B> operator-(const A& a, const B& b)
  {
    return LeftScalarSubtractionExpression<A,B>(a, b);
  }

  template<typename A, typename B,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_fundamental<B>::value, B>::type>
  class RightScalarDivisionExpression: public ExpressionBase
  {
    const A& a;
    const B b; 
  public:
    typedef typename A::value_type value_type;
    RightScalarDivisionExpression(const A& a, const B& b):a(a), b(b){}
    unsigned int size() const { return a.size(); }
    const value_type operator[](const unsigned int i) const {  return a[i]/b;}
  };

  template<typename A, typename B,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_fundamental<B>::value, B>::type>
  const RightScalarDivisionExpression<A,B> operator/(const A& a, const B& b)
  {
    return RightScalarDivisionExpression<A,B>(a, b);
  }
        
  template<typename A, typename B, 
           typename= typename std::enable_if<std::is_base_of<MatrixExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  class LeftMatrixMultiplicationExpression: public ExpressionBase
  {
    const A& a;
    const B& b;
  public:
    typedef typename A::value_type value_type;
    LeftMatrixMultiplicationExpression(const A& a, const B& b):a(a), b(b){}
    unsigned int size() const { return b.size(); }
    const value_type operator[](const unsigned int i) const
    { 
      value_type entry=0;  
      for (index j=0;j<a.shape(0);j++)
        entry+=a.xentry(i,j)*b[j];
      return entry;
    }
  };

  template<typename A, typename B, 
           typename= typename std::enable_if<std::is_base_of<MatrixExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  const LeftMatrixMultiplicationExpression<A,B> operator*(const A& a, const B& b)
  {
    return LeftMatrixMultiplicationExpression<A,B>(a, b);
  }

  template<typename A, typename B, 
           typename= typename std::enable_if<std::is_base_of<SparseMatrixExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  class LeftSparseMatrixMultiplicationExpression: public ExpressionBase
  {
    const A& a;
    const B& b;
  public:
    typedef typename A::value_type value_type;
    LeftSparseMatrixMultiplicationExpression(const A& a, const B& b):a(a), b(b){}
    unsigned int size() const { return b.size(); }
    const value_type operator[](const unsigned int i) const
    { 
      value_type entry=0;  
      auto &IA=*(a.pIA);
      auto &JA=*(a.pJA);
      auto &AA=*(a.pA);

      for (index j=IA[i];j<IA[i+1];j++)
        entry+=AA[j]*b[JA[j]];
      return entry;
    }
  };

  template<typename A, typename B, 
           typename= typename std::enable_if<std::is_base_of<SparseMatrixExpressionBase,A>::value, A>::type,
           typename= typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
  const LeftSparseMatrixMultiplicationExpression<A,B> operator*(const A& a, const B& b)
  {
    return LeftSparseMatrixMultiplicationExpression<A,B>(a, b);
  }
}
#endif