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 Variable;
 
  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 Variable : public IExpression {
  public:
    Variable(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 ComplexVariable : public IExpression {
  public:
    ComplexVariable(const Variable &real, const Variable &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:
    Variable m_real;
    Variable 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