MathExpressionGrammar.h

Go to the documentation of this file.

#ifndef _utl_MathExpressionGrammar_h_
#define _utl_MathExpressionGrammar_h_

#include <utl/SymbolTable.h>
#include <utl/ExpressionParser.h>
#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>

//#define BOOST_SPIRIT_DEBUG

#include <boost/version.hpp>
#if BOOST_VERSION >= 103800
#  define BOOST_SPIRIT_USE_OLD_NAMESPACE
#  include <boost/spirit/include/classic.hpp>
#  include <boost/spirit/include/phoenix1_binders.hpp>
#  include <boost/spirit/include/phoenix1_functions.hpp>
#else
#  include <boost/spirit.hpp>
#  include <boost/spirit/phoenix/binders.hpp>
#  include <boost/spirit/phoenix/primitives.hpp>
#  include <boost/spirit/phoenix/functions.hpp>
#endif

#include <string>
#include <cmath>
//#include <iostream>


namespace utl {

  // RU 14 Jul 2017, to someone smarter than me: convert this to templated solution:
#define FIMP_std(name)                                                            \
  struct F_ ## name ## _Impl {                                                    \
    template<typename T1>                                                         \
    struct result { typedef double type; };                                       \
    template<typename T1>                                                         \
    T1 operator()(T1& t1) const { return std::name(t1); }                         \
  };                                                                              \
  const phoenix::function<F_ ## name ## _Impl> F_ ## name = F_ ## name ## _Impl()

  FIMP_std(exp);
  FIMP_std(log10);
  FIMP_std(log);
  FIMP_std(sin);
  FIMP_std(tan);
  FIMP_std(cos);

  struct PowerToImpl2 {
    template<typename T1, typename T2>
    struct result { typedef double type; };
    template<typename T1, typename T2>
    T1 operator()(T1& t1, T2& t2) const { return std::pow(t1, t2); }
  };
  // Create it as a constant Phoenix Function
  const phoenix::function<PowerToImpl2> power2 = PowerToImpl2();


  // MathExpression Grammar Structure
  struct MathExpressionGrammar : public boost::spirit::grammar<MathExpressionGrammar> {

    MathExpressionGrammar(double& result, const utl::SymbolTable& sym)
      : fSymbols(&sym), fResult(&result) { }

    MathExpressionGrammar(double& result, const utl::SymbolTable& sym, utl::SymbolTable& vars)
      : fSymbols(&sym), fVariables(vars), fResult(&result) { }

    void SetResult(double& v) const { fResult = const_cast<double*>(&v); }

    struct SValueClosure : public boost::spirit::closure<SValueClosure, double> {
      member1 value;
    };

    struct SAssignmentClosure : public boost::spirit::closure<SAssignmentClosure, std::string, double> {
      member1 name;
      member2 value;
    };

    struct SStringClosure : public boost::spirit::closure<SStringClosure, std::string> {
      member1 name;
    };

    template<typename ScannerT>
    struct definition {
      definition(const MathExpressionGrammar& self)
      {
        prefix
          =
           (
              ('-' >> multdiv  [prefix.value = -phoenix::arg1])
            | ('+' >> multdiv  [prefix.value =  phoenix::arg1])
            )
          ;

        term
          =
            ('(' >> expression  [term.value = phoenix::arg1] >> ')')
          | prefix  [term.value = phoenix::arg1]
          | literal  [term.value = phoenix::arg1]
          | func  [term.value = phoenix::arg1]
          | identifier  [term.value = phoenix::bind(&MathExpressionGrammar::Lookup)(self, phoenix::arg1)]
          ;

        func
          =(    boost::spirit::str_p("exp")   >> term  [func.value = F_exp(phoenix::arg1)]
              | boost::spirit::str_p("log10") >> term  [func.value = F_log10(phoenix::arg1)]
              | boost::spirit::str_p("log")   >> term  [func.value = F_log(phoenix::arg1)]
              | boost::spirit::str_p("sin")   >> term  [func.value = F_sin(phoenix::arg1)]
              | boost::spirit::str_p("cos")   >> term  [func.value = F_cos(phoenix::arg1)]
              | boost::spirit::str_p("tan")   >> term  [func.value = F_tan(phoenix::arg1)]
            )
        ;

        factor
          = term  [factor.value = phoenix::arg1]
          >> *(
                 ('^' >> factor  [factor.value = power2(factor.value, phoenix::arg1)])
                   //               | (factor  [factor.value *= phoenix::arg1]) // multiplication without * is a pain in the ass
               )
          ;

        multdiv
          = factor  [multdiv.value = phoenix::arg1]
          >> *(
                 ('*' >> factor  [multdiv.value *= phoenix::arg1])
               | ('/' >> factor  [multdiv.value /= phoenix::arg1])
                 )
          ;

        expression
          = multdiv  [expression.value = phoenix::arg1]
          >> *(
                 ('+' >> multdiv  [expression.value += phoenix::arg1])
               | ('-' >> multdiv  [expression.value -= phoenix::arg1])
               )
          ;

        identifier
          = boost::spirit::lexeme_d  [(boost::spirit::alpha_p | '_')
                                     >> *(boost::spirit::alnum_p | '_')][
                                              identifier.name = phoenix::construct_<std::string>(phoenix::arg1, phoenix::arg2)
          ]
        ;

        statement
          = expression  [phoenix::bind(&MathExpressionGrammar::SaveResult)(self, phoenix::arg1)]
          >> (boost::spirit::end_p | ';')
        ;

        literal
          = boost::spirit::longest_d[
                                       boost::spirit::int_p  [literal.value = phoenix::arg1]
                                     | boost::spirit::real_p  [literal.value = phoenix::arg1]
                                    ]
        ;

        /*
        BOOST_SPIRIT_DEBUG_NODE(identifier);
        BOOST_SPIRIT_DEBUG_NODE(statement);
        BOOST_SPIRIT_DEBUG_NODE(literal);

        BOOST_SPIRIT_DEBUG_NODE(term);
        BOOST_SPIRIT_DEBUG_NODE(factor);
        BOOST_SPIRIT_DEBUG_NODE(prefix);
        BOOST_SPIRIT_DEBUG_NODE(multdiv);
        BOOST_SPIRIT_DEBUG_NODE(expression);
        BOOST_SPIRIT_DEBUG_NODE(literal);
        BOOST_SPIRIT_DEBUG_NODE(func);
        */
      }

      boost::spirit::rule<ScannerT> const& start() const { return statement; }

      boost::spirit::rule<ScannerT> statement;
      boost::spirit::rule<ScannerT, SStringClosure::context_t> identifier;
      boost::spirit::rule<ScannerT, SValueClosure::context_t> term, factor, prefix, multdiv, expression, literal, func;

    };

  protected:
    void SaveResult(const double val) const { *fResult = val; }

    double
    Lookup(const std::string& symbol)
      const
    {
      const auto& symbols = *fSymbols; //Symbols::GetSymbolMap();
      const auto it1 = symbols.find(symbol);
      if (it1 != symbols.end())
        return it1->second;

      //if (fVariables)
      {
        const auto it2 = fVariables.find(symbol);
        if (it2 != fVariables.end())
          return it2->second;
      }
      // issue exception
      const std::string err =
        "The symbol '" + symbol + "' " +
        "is not defined during the evaluaion with the MathExpressionGrammer\n";
      ERROR(err);
      throw XMLParseException(err);
      return 1;
    }

  public:
    SymbolTable& GetVariables() { return fVariables; }
    const SymbolTable& GetVariables() const { return fVariables; }
    int GetNVariables() const { return fVariables.size(); }

    bool HasVariable(const std::string& name) const { return fVariables.count(name); }
    void SetVariable(const std::string& name, const double& v) { fVariables[name] = v; }
    double GetVariable(const std::string& name) const { return fVariables.find(name)->second; }

  private:
    const SymbolTable* fSymbols;
    SymbolTable fVariables;
    mutable double* fResult = nullptr;
  };

}


#include <utl/AugerUnits.h>

namespace utl {
  typedef utl::ExpressionParser<MathExpressionGrammar, AugerUnits> FunctionParser;
}


#endif