muParserXInterface.hpp

Go to the documentation of this file.

#ifndef HH_MUPARSERXINTERFACE_HH
#define HH_MUPARSERXINTERFACE_HH
#include "mpParser.h"
#include <array>
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <stdexcept>
 
namespace mc::utils
 
{
template <int N, class ArgumentType = std::array<double, N> >
class muParserXInterface
{
public:
  muParserXInterface()
    : My_e(),
      M_parser(mup::pckALL_NON_COMPLEX | mup::pckMATRIX), M_value{N, 0.0}
  {
    M_parser.DefineVar("x", mup::Variable(&M_value));
  }
  muParserXInterface(const std::string expression) : muParserXInterface()
  {
    My_e = expression;
    M_parser.SetExpr(My_e.c_str());
  }
 
  muParserXInterface(muParserXInterface const &mpi)
    : My_e(mpi.My_e),
      M_parser(mup::pckALL_NON_COMPLEX | mup::pckMATRIX), M_value{N, 0.0}
  {
    M_parser.DefineVar("x", mup::Variable(&M_value));
    M_parser.SetExpr(My_e.c_str());
  }
  muParserXInterface
  operator=(muParserXInterface const &mpi)
  {
    if(this != &mpi)
      {
        this->My_e = mpi.My_e;
        this->M_parser.ClearVar(); // clear the variables!
        this->M_value = mpi.M_value;
        M_parser.DefineVar("x", mup::Variable(&M_value));
        M_parser.SetExpr(My_e.c_str());
      }
    return *this;
  }
 
 
  static muParserXInterface fromFile(const std::string &filename)
  {
    std::ifstream file(filename);
    if (!file.is_open())
    {
      throw std::runtime_error("Cannot open function file: " + filename);
    }
 
    std::string expression;
    // Legge l'intero contenuto o solo la prima riga.
    // Qui leggiamo la prima riga non vuota.
    while(std::getline(file, expression)) {
      if(!expression.empty()) break;
    }
 
    file.close();
 
    if(expression.empty()) {
      throw std::runtime_error("File is empty or contains no expression: " + filename);
    }
 
    std::cout << "Read expression from file: " << expression << std::endl;
 
    // Chiama il costruttore normale passando la stringa letta
    return muParserXInterface(expression);
  }
 
 
  void
  set_expression(const std::string &e)
  {
    My_e = e;
    M_parser.SetExpr(e.c_str());
  }
 
  auto
  operator()(ArgumentType const &x) const
  {
    for(int i = 0; i < N; ++i)
      {
        M_value.At(i) = x[i];
      }
    mup::Value ans;
    try
      {
        ans = M_parser.Eval();
      }
    catch(mup::ParserError &error)
      {
        std::cerr << "Muparsex error with code:" << error.GetCode()
                  << std::endl;
        ;
        std::cerr << "While processing expression: " << error.GetExpr()
                  << std::endl;
        std::cerr << "Error Message: " << error.GetMsg() << std::endl;
        throw error;
      }
    return ans.GetFloat();
  }
 
private:
  // a copy of the muparserX expression, used for the copy operations
  std::string My_e;
  // The muparseX engine
  mup::ParserX M_parser;
  // The muparserX value used to set the variables in the engine
  mutable mup::Value M_value;
};
} // namespace mc::utils
#endif