math_parser.hpp

#ifndef MATHPARSER_HPP
#define MATHPARSER_HPP

#include <string>
#include <list>
#include <vector>
#include <complex>
#include "shared_ptr.hpp"

class loadable_Object;
typedef STD_TR1::shared_ptr<const loadable_Object> loadable_Object_const_ref;

typedef std::complex<double> complex;

//Base object, supports multiple parameters and complex numbers
class ncexpression{
public:
    typedef STD_TR1::shared_ptr<ncexpression> ref;
    typedef STD_TR1::shared_ptr<const ncexpression> const_ref;

    typedef STD_TR1::shared_ptr<std::vector<double> > parameters;
    typedef STD_TR1::shared_ptr<std::vector<std::string> > parameternames;

    virtual ~ncexpression(){};

    static ref parse(const std::string&,parameternames);
    static ref parse(const std::string&,parameternames,loadable_Object_const_ref);

    static complex evaluate(const std::string&, 
               loadable_Object_const_ref,
                           parameternames,
               parameters);

    static void replace_variables(std::string&, loadable_Object_const_ref);

    static void replace_strings(std::string&, loadable_Object_const_ref);

    complex value(parameters p) const;
    void code(std::ostream& ofs) const;


protected:
    ncexpression(){};

private:
    virtual complex value_(parameters p) const = 0;
    virtual void code_(std::ostream& ofs) const = 0;
    
    
};

//Wrapper object, takes 1 parameter and supports complex numbers
class cexpression  {
public:
    typedef STD_TR1::shared_ptr<cexpression> ref;
    typedef STD_TR1::shared_ptr<const cexpression> const_ref;



    cexpression(ncexpression::ref new_nex) : nex(new_nex){};

    static cexpression::ref parse(const std::string& s)
    {
       ncexpression::parameternames pnames(new std::vector<std::string>(1,"x")); 
       
       return cexpression::ref(new cexpression(ncexpression::parse(s,pnames)));
    }

    static cexpression::ref parse(const std::string& s, 
                  loadable_Object_const_ref obj,
                  char var_char = 'x')
    {
        std::string vs("");
        vs += var_char;
        ncexpression::parameternames pnames(new std::vector<std::string>(1,vs)); 
        return cexpression::ref(new cexpression(ncexpression::parse(s,pnames,obj)));
    }

    static complex evaluate(const std::string& s, 
               loadable_Object_const_ref obj,
               double x)
    {
       ncexpression::parameters p(new std::vector<double>(1,x));
       ncexpression::parameternames pnames(new std::vector<std::string>(1,"x")); 
       return real(ncexpression::evaluate(s,obj,pnames,p));
    }


    complex value(double x) const 
    {
       ncexpression::parameters p(new std::vector<double>(1,x)); 
       return nex->value(p);
    }

protected:
    cexpression(){};

private:
    ncexpression::ref nex;

};

//Wrapper object, takes one parameter and gives back a double number. Identical to cexpression, exists
//for backward compatibility
class expression {
public:
    typedef STD_TR1::shared_ptr<expression> ref;
    typedef STD_TR1::shared_ptr<const expression> const_ref;



    expression(ncexpression::ref new_nex) : nex(new_nex) {};

    static expression::ref parse(const std::string& s)
    {
       ncexpression::parameternames pnames(new std::vector<std::string>(1,"x")); 
       
       return expression::ref(new expression(ncexpression::parse(s,pnames)));
    }

    static expression::ref parse(const std::string& s, 
                 loadable_Object_const_ref obj,
                 char var_char = 'x')
    {
        std::string vs("");
        vs += var_char;
        ncexpression::parameternames pnames(new std::vector<std::string>(1,vs)); 
        return expression::ref(new expression(ncexpression::parse(s,pnames,obj)));
    }

    static double evaluate(const std::string& s, 
               loadable_Object_const_ref obj,
               double x)
    {
       ncexpression::parameters p(new std::vector<double>(1,x));
       ncexpression::parameternames pnames(new std::vector<std::string>(1,"x")); 
       return real(ncexpression::evaluate(s,obj,pnames,p));
    }


    double value(double x) const ;

private:
    expression(){};
    expression(const expression&){};

private:
    ncexpression::ref nex;

};

#endif