ExpressionParser.h

Go to the documentation of this file.

#ifndef AMPGEN_EXPRESSIONPARSER_H
#define AMPGEN_EXPRESSIONPARSER_H 1
 
#include <complex>
#include <functional>
#include <map>
#include <string>
#include <utility>
#include <vector>
 
#include "AmpGen/Expression.h"
#include "AmpGen/MetaUtils.h"
#include "AmpGen/Types.h"
#include "AmpGen/enum.h"
#include "AmpGen/MsgService.h"
 
namespace AmpGen {
  class ASTResolver;
  class MinuitParameter;
  class MinuitParameterSet;
 
  declare_enum(coordinateType, cartesian, polar);
  declare_enum(angType, deg, rad);
 
  template <typename arg_type> void set_tuple_from_expression(arg_type &arg, const Expression &expr) {
    if constexpr(std::is_same<arg_type, Expression>::value) {
      arg = expr;
    } else if constexpr(std::is_same<arg_type, std::string>::value) {
      arg = is<Variable>(expr) ? cast<Variable>(expr).name() : "ERROR";
    } else if constexpr(std::is_same<arg_type, int>::value) {
      arg = int(std::real(expr()));
    } else if constexpr(std::is_same<arg_type, double>::value) {
      arg = double(std::real(expr()));
    } else if constexpr(std::is_same<arg_type, std::complex<double>>::value) {
      arg = expr();
    } else
      FATAL("Unrecognised type: " << type_string<arg_type>());
  }
 
  template <typename... types> std::tuple<types...> unpack(const Expression &expression) {
    std::tuple<types...> rt;
    unsigned int counter = 0;
    if(!is<ExpressionPack>(expression)) FATAL("Not a packed expression");
    auto as_pack = cast<ExpressionPack>(expression).expressions();
    if(as_pack.size() != std::tuple_size<std::tuple<types...>>::value) FATAL("Wrong number of expressions");
    for_each(rt, [&as_pack, &counter](auto &element) {
      set_tuple_from_expression(element, as_pack[counter]);
      counter++;
    });
    return rt;
  }
 
  class ExpressionParser {
  public:
    typedef std::function<Expression(const Expression &)> unaryFCN;
    typedef std::function<Expression(const Expression &, const Expression &)> binaryFCN;
 
    void add_unary(const std::string &name, const unaryFCN &op) { m_unaryFunctions[name] = op; }
    template <typename OP> void add_unary(const std::string &name) {
      add_unary(name, [](const auto &expression) { return OP(expression); });
    }
    template <typename... args> void add_multi_arg(const std::string &name, const std::function<Expression(args...)> &fcn) {
      add_unary(name, [fcn](const auto &expression) { return std::apply(fcn, unpack<args...>(expression)); });
    }
 
    void add_binary(const std::string &name, binaryFCN op) { m_binaryFunctions.emplace_back(name, op); }
 
    static Expression parse(const std::string &str, const MinuitParameterSet *mps = nullptr);
    static Expression
    parse(std::vector<std::string>::const_iterator begin, std::vector<std::string>::const_iterator end, const MinuitParameterSet *mps = nullptr);
    static ExpressionParser *gExpressionParser;
    static ExpressionParser *getMe() {
      if(!gExpressionParser) gExpressionParser = new ExpressionParser();
      return gExpressionParser;
    }
 
  private:
    ExpressionParser();
 
    Expression processEndPoint(const std::string &name, const MinuitParameterSet *mps = nullptr);
    Expression
    parseTokens(std::vector<std::string>::const_iterator begin, std::vector<std::string>::const_iterator end, const MinuitParameterSet *mps = nullptr);
 
    void processBinaryOperators(std::vector<std::string> &opCodes, std::vector<Expression> &expressions);
    void processUnaryOperators(std::vector<std::string> &opCodes, std::vector<Expression> &expressions);
 
    std::map<std::string, unaryFCN> m_unaryFunctions;
    std::vector<std::pair<std::string, binaryFCN>> m_binaryFunctions;
    bool m_isCartesian = {true};
    double m_sf = {1};
  };
} // namespace AmpGen
 
#endif