Expression.h

Go to the documentation of this file.

#ifndef AMPGEN_EXPRESSION_H
#define AMPGEN_EXPRESSION_H


#define ADD_DEBUG( X, Y )                                               \
  if ( Y != 0 ) Y->push_back( DebugSymbol( std::string( #X ), X ) );    \


#define DEFINE_CAST( X )                                    \
  X::operator Expression() const                            \
{ return Expression( std::make_shared<X>( *this ) ); }  
 
#define DEFINE_BINARY_OPERATOR( X ) \
  X::X( const AmpGen::Expression& l, const AmpGen::Expression& r ) : IBinaryExpression(l,r ) {} \
  X::X( const AmpGen::Expression& expr) : IBinaryExpression(expr) {} \
  X::operator Expression() const { return Expression( std::make_shared<X>(*this) ) ; } 
 
#define DEFINE_UNARY_OPERATOR( X, F ) \
  X::X( const AmpGen::Expression& expression) : IUnaryExpression(expression) {} \
  X::operator Expression() const { return Expression( std::make_shared<X>(*this) ) ; } \
  complex_t X::operator()() const { return F( m_expression() ); } \
  std::string X::to_string(const ASTResolver* resolver) const { return std::string(#F)+"("+ m_expression.to_string(resolver)+")";}
 
#define DEFINE_UNARY_OPERATOR_NO_RESOLVER( X, F ) \
  X::X( const AmpGen::Expression& expression) : IUnaryExpression(expression) {} \
  X::operator Expression() const { return Expression( std::make_shared<X>(*this) ) ; } \
  complex_t X::operator()() const { return F( m_expression() ); }  

#define DECLARE_UNARY_OPERATOR( X )                         \
  class X : public IUnaryExpression {                       \
    public:                                                 \
    explicit X( const Expression& other );                  \
    virtual std::string to_string(const ASTResolver* resolver=nullptr) const override;         \
    virtual Expression d() const override;                  \
    operator Expression() const;                            \
    virtual complex_t operator()() const override;          \
  }

#define DECLARE_BINARY_OPERATOR( X )                        \
  class X : public IBinaryExpression {                      \
    public:                                                 \
    X( const Expression& l, const Expression& r );          \
    X( const Expression& expr);                             \
    virtual std::string to_string(const ASTResolver* resolver=nullptr) const override ;        \
    operator Expression() const ;                           \
    virtual complex_t operator()() const override;          \
  }
 
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#include <functional>
#include "AmpGen/MsgService.h"
#include "AmpGen/MetaUtils.h"
#include "AmpGen/Types.h"
 
namespace AmpGen
{
  class ASTResolver;
  class Expression;
  class Parameter;
 
  typedef std::pair<std::string, Expression> DebugSymbol;
  typedef std::vector<DebugSymbol> DebugSymbols;

  class IExpression {
    public:
      virtual std::string to_string(const ASTResolver* resolver=nullptr) const = 0;
      virtual void resolve( ASTResolver& resolver ) const = 0;
      virtual ~IExpression() = default;
      virtual complex_t operator()() const = 0;
  };

  class Expression { 
    public:
    Expression();
    Expression( const real_t& value );
    Expression( const complex_t& value );
    Expression( const std::shared_ptr<IExpression>& expression ) ;
    ~Expression() = default;
    std::string to_string(const ASTResolver* resolver=nullptr) const;
    IExpression* get() const;
    void resolve( ASTResolver& resolver ) const;
    Expression operator+=( const Expression& other );
    Expression operator*=( const Expression& other );
    Expression operator-=( const Expression& other );
    Expression operator/=( const Expression& other );
    Expression operator-() const;
    complex_t operator()() const; 
 
  private:
    std::shared_ptr<IExpression> m_expression;
  };

   class Constant : public IExpression {
    public:
    template <typename T1, 
              typename T2,
              typename = std::enable_if_t< std::is_constructible< complex_t, T1, T2 >::value > >
    Constant( const T1& real, const T2& imag=0 ) : m_value(real,imag) {}
 
    Constant( const complex_t& value ) : m_value(value) {}
    std::string to_string(const ASTResolver* resolver=nullptr) const override;
    void resolve( ASTResolver& resolver ) const override;
    operator Expression() const;
    complex_t operator()() const override { return m_value; }
    private:
    complex_t m_value;
  };

  class Parameter : public IExpression {
    public:
    Parameter(const std::string& name     = "", 
              const double&  defaultValue = 0 , 
              const bool&        resolved = false);
    std::string to_string(const ASTResolver* resolver = nullptr) const override;
    void resolve( ASTResolver& resolver ) const override;
    virtual operator Expression() const;
    complex_t operator()() const override { return complex_t( m_defaultValue, 0 ); }
    std::string name() const { return m_name; }
    const double& defaultValue() const { return m_defaultValue ; }
    double& defaultValue() { return m_defaultValue ; }
    bool isResolved() const { return m_resolved ;}
    private:
    std::string  m_name;
    double       m_defaultValue;
    bool         m_resolved; 
  };
 
  class ComplexParameter : public IExpression {
    public:
    ComplexParameter( const Parameter& real, const Parameter& imag );
    std::string to_string(const ASTResolver* resolver = nullptr ) const override;
    void resolve( ASTResolver& resolver ) const override;
    operator Expression() const ;
    complex_t operator()() const override;  
    private:
    Parameter m_real;
    Parameter m_imag;
  };

  class LambdaExpression : public IExpression {
    public: 
      template <typename function_type>
      LambdaExpression( const function_type& function) : m_function(function), m_name(type_string<function_type>()) {}
      std::string to_string(const ASTResolver* resolver = nullptr) const override; 
      void resolve( ASTResolver& resolver) const override;
      operator Expression() const; 
      complex_t operator()() const override; 
      std::function<double(void)> m_function; 
      std::string m_name; 
  }; 

  class Ternary : public IExpression {
    public:
    Ternary( const Expression& cond, const Expression& v1, const Expression& v2 );
    std::string to_string(const ASTResolver* resolver = nullptr ) const override;
    void resolve( ASTResolver& resolver ) const override;
    operator Expression() const ;
    complex_t operator()() const override { return std::real(m_cond()) ? m_v1() : m_v2(); }
    private: 
    Expression m_cond;
    Expression m_v1;
    Expression m_v2;
  };

  struct SubTree : public IExpression { 
    SubTree( const Expression& other ) ;
    std::string to_string(const ASTResolver* resolver = nullptr ) const override ;
    void resolve( ASTResolver& resolver ) const override;
    operator Expression() const ;
    complex_t operator()() const override { return m_expression(); }
    uint64_t key() const;
    void setKey( const size_t& new_key ); 
    Expression expression() const { return m_expression; }
    Expression  m_expression;
    uint64_t    m_key; 
  };
 
  struct Function : public IExpression {
    Function( const std::string& name, const std::vector<Expression>& args ) ;
    std::string to_string(const ASTResolver* resolver = nullptr ) const override ;
    void resolve( ASTResolver& resolver ) const override;
    operator Expression() const ;
    complex_t operator()() const override { return 0; }  
    std::string m_name;
    std::vector<Expression> m_args;
  };

  
  class ExpressionPack : public IExpression {
    public:
      explicit ExpressionPack( const std::vector<Expression>& expressions ): m_expressions(expressions) {}
      ExpressionPack( const Expression& A, const Expression& B );
      std::string to_string(const ASTResolver* resolver=nullptr) const override;
      void resolve( ASTResolver& resolver ) const override;
      complex_t operator()() const override;
      operator Expression() const ;
      const std::vector<Expression>& expressions() const { return m_expressions ; }
    private:
      std::vector<Expression> m_expressions;
  };

  class IBinaryExpression : public IExpression {
    public:
    IBinaryExpression( const Expression& l, const Expression& r ) : lval( l ), rval( r ){};
    IBinaryExpression( const Expression& pack )
    {
      auto as_pack = static_cast< const ExpressionPack*>(pack.get() );
      if( as_pack != nullptr )
      {
        auto expr = as_pack->expressions();
        if( expr.size() != 2 ) FATAL("Wrong number of inputs");
        lval = expr[0]; 
        rval = expr[1]; 
      }
      else {
        FATAL("wrong number of inputs" ); 
      }
    }
    void resolve( ASTResolver& resolver ) const override;
    complex_t operator()() const override = 0;
    Expression l() const { return lval ; }
    Expression r() const { return rval ; }
    protected:
    Expression lval;
    Expression rval;
  };

  DECLARE_BINARY_OPERATOR( Sum );

  DECLARE_BINARY_OPERATOR( Sub );
  
  DECLARE_BINARY_OPERATOR( Product );
  
  DECLARE_BINARY_OPERATOR( Divide );
  
  DECLARE_BINARY_OPERATOR( Pow );
  
  DECLARE_BINARY_OPERATOR( Fmod );
  
  DECLARE_BINARY_OPERATOR( LessThan );
  
  DECLARE_BINARY_OPERATOR( GreaterThan );

  DECLARE_BINARY_OPERATOR( LessThanEqualTo );
  
  DECLARE_BINARY_OPERATOR( GreaterThanEqualTo );

  DECLARE_BINARY_OPERATOR( And );
  
  DECLARE_BINARY_OPERATOR( Or );
  DECLARE_BINARY_OPERATOR( Equal );
 
  DECLARE_BINARY_OPERATOR( ATan2 );
  class IUnaryExpression : public IExpression {
    public:
    IUnaryExpression( const Expression& other ) : m_expression( other ){};
    void resolve( ASTResolver& resolver ) const override;
    complex_t operator()() const override = 0;
    virtual Expression d() const = 0; 
    Expression arg() const { return m_expression ;} 
    protected:
    Expression m_expression;
  };

  DECLARE_UNARY_OPERATOR( Log );

  DECLARE_UNARY_OPERATOR( Exp );

  DECLARE_UNARY_OPERATOR( Sqrt );

  DECLARE_UNARY_OPERATOR( Abs );

  DECLARE_UNARY_OPERATOR( Norm );

  DECLARE_UNARY_OPERATOR( Conj );

  DECLARE_UNARY_OPERATOR( Real );

  DECLARE_UNARY_OPERATOR( Imag );

  DECLARE_UNARY_OPERATOR( Sin );

  DECLARE_UNARY_OPERATOR( Cos );

  DECLARE_UNARY_OPERATOR( Tan );

  DECLARE_UNARY_OPERATOR( ASin );

  DECLARE_UNARY_OPERATOR( ACos );
  DECLARE_UNARY_OPERATOR( ATan );
  
  DECLARE_UNARY_OPERATOR( ISqrt );
  
  DECLARE_UNARY_OPERATOR( LGamma );
 
  Expression operator<( const Expression& A, const Expression& B );
  Expression operator>( const Expression& A, const Expression& B );
  Expression operator<=( const Expression& A, const Expression& B );
  Expression operator>=( const Expression& A, const Expression& B );
 
  Expression operator+( const Expression& A, const Expression& B );
  Expression operator-( const Expression& A, const Expression& B );
  Expression operator*( const Expression& A, const Expression& B );
  Expression operator/( const Expression& A, const Expression& B );
 
  template < class T, typename std::enable_if_t< hasConstructor<Constant, T>() > >
  Expression operator+( const Expression& A, const T& B ){ return A + Constant(B); }
  template < class T, typename std::enable_if_t< hasConstructor<Constant, T>() > >
  Expression operator-( const Expression& A, const T& B ){ return A - Constant(B); }
  template < class T, typename std::enable_if_t< hasConstructor<Constant, T>() > >
  Expression operator*( const Expression& A, const T& B ){ return A * Constant(B); } 
  template < class T, typename std::enable_if_t< hasConstructor<Constant, T>() > >
  Expression operator/( const Expression& A, const T& B ){ return A / Constant(B); }
 
  template < class T, typename std::enable_if_t< hasConstructor<Constant, T>() > >
  Expression operator+( const T& A, const Expression& B ){ return Constant(A) + B; }
  template < class T, typename std::enable_if_t< hasConstructor<Constant, T>() > >
  Expression operator-( const T& A, const Expression& B ){ return Constant(A) - B; }
  template < class T, typename std::enable_if_t< hasConstructor<Constant, T>() > >
  Expression operator*( const T& A, const Expression& B ){ return Constant(A) * B; }
  template < class T, typename std::enable_if_t< hasConstructor<Constant, T>() > >
  Expression operator/( const T& A, const Expression& B ){ return Constant(A) / B; }
 
  Expression operator&&( const Expression& A, const Expression& B );
  Expression operator||( const Expression& A, const Expression& B );
  Expression operator==( const Expression& A, const Expression& B );
  Expression operator==( const Expression& A, const double& B );
  Expression operator==( const double& A, const Expression& B );
 
  std::ostream& operator<<( std::ostream& os, const Expression& expression ) ;
  namespace fcn {  
    Expression sqrt( const Expression& expression ); 
    Expression safe_sqrt( const Expression& expression );
    Expression complex_sqrt( const Expression& expression );
    Expression isqrt( const Expression& expression );
    Expression cos( const Expression& expression );
    Expression sin( const Expression& expression );
    Expression tan( const Expression& expression );
    Expression abs( const Expression& expression );
    Expression acos( const Expression& expression );
    Expression asin( const Expression& expression );
    Expression atan( const Expression& expression );
    Expression pow( const Expression& expression, const Expression& co );
    Expression fpow( const Expression& expression, const int& n );
    Expression norm( const Expression& expression );
    Expression conj( const Expression& expression );
    Expression exp( const Expression& expression );
    Expression log( const Expression& expression );
    Expression atan2( const Expression& y, const Expression& x);
  }
 
  template < class T > bool is( const Expression& expression ){
    return dynamic_cast< const T* >( expression.get() ) != nullptr;
  }
  template < class T > T cast( const Expression& expression ){
    return *static_cast< const T*>(expression.get() );
  }
  
  Expression make_cse( const Expression& A , bool simplify = false);
 
} // namespace AmpGen
 
#endif