pssmathparser.h

Go to the documentation of this file.

#ifndef PSSMATHPARSER_H
#define PSSMATHPARSER_H

#include "pssmathparser_global.h"
#include <math.h>
#include <stdlib.h>
#include <iostream>
#include <stdint.h>
#include <unordered_map>
#include <vector>
#include <string>
#include <ctype.h>
#include <algorithm>
#include <iomanip>
#include <sstream>

namespace PssMathParser {

using namespace std;

enum class EntityType {
    None,
    Operator,
    OperatorInDoubleOutDouble,
    OperatorInIntOutInt,
    OperatorInDoubleDoubleOutDouble,
    OperatorInDoubleIntOutDouble,
    Argument,
    ArgumentConstant,
    ArgumentUserConstant,
    ArgumentVariable,
    ArgumentGenerated,
    ArgumentGeneratedFromOneArg,
    ArgumentGeneratedFromTwoArg
};

enum class OperatorPrecedence {
    Function = 9,
    Multiplication = 6,
    Addition = 3
};

class Entity {

public:
    Entity(const string &a_name,
           const EntityType a_type = EntityType::None);
    ~Entity();

    const Entity *getEntity() const;
    EntityType entityType() const;    

protected:
    string  m_name; 
    EntityType m_type; 
};

class Operator : public Entity {

public:
    Operator(const string &a_name,
             EntityType a_type = EntityType::Operator,
             OperatorPrecedence m_precedence = OperatorPrecedence::Function,
             double (*a_ddOperator)(const double) = nullptr,
             double (*a_dddOperator)(const double, const double) = nullptr,
             double (*a_ddiOperator)(const double, const int) = nullptr);

    double dddOperator(double a_arg1, double a_arg2) const;
    double ddOperator(double a_arg1) const;
    uint16_t precedence() const;
private:
    OperatorPrecedence m_precedence;  
    double (*m_ddOperator)(const double); 
    double (*m_dddOperator)(const double, const double); 
    double (*m_ddiOperator)(const double, const int); 
};

class Argument : public Entity {
public:
    Argument(const string &a_name,
             EntityType a_type = EntityType::Argument,
             int a_ivalue = 0,
             double a_dvalue = 0);

    void setDoubleValue(const double a_dvalue);
    double getDoubleValue() const;
    void setIntValue(const int a_ivalue);
    int getIntValue();
private:
    double m_dvalue; 
    int m_ivalue; 
};

class Generator : public Entity {
public:
    Generator(const string &a_name,
              EntityType a_entityType,
              const Operator *a_op = nullptr,
              const Argument *a_arg1 = nullptr,
              const Argument *a_arg2 = nullptr,
               Argument *a_myArg = nullptr);

    double generateDoubleValue() const;
    const string &getName() const;

private:
    const Operator *m_op; 
    const Argument *m_arg1; 
    const Argument *m_arg2; 
    Argument *m_myArg; 
};

class PSSMATHPARSER_EXPORT_PUBLIC MathParser
{
public:

    virtual ~MathParser() = 0;

    static MathParser *makeMathParser();

    virtual const string expression() const = 0;
    virtual void setExpression(const string &a_expression) = 0;
    virtual void setMath(const string &a_expression) = 0;
    virtual const string reversePolish() const = 0;
    virtual bool setArgumentMap(const string &a_reversePolish) = 0;
    virtual bool setArgumentMap() = 0;
    virtual bool expressionToReversePolish() = 0;
    virtual const string mathToString() const = 0;
    virtual const string mathToStringFull() const = 0;
    virtual void setVariableDouble(const string &a_name,
                                   const double a_value) = 0;
    virtual bool expandMathExpression() = 0;
    virtual double calculateExpression() = 0;
    virtual void setMathPrintPrecision(const uint16_t &mathPrintPrecision) = 0;
    virtual uint16_t getMathPrintPrecision() const = 0;
    virtual uint16_t getVariableSize() const = 0;
    virtual void clear() = 0;
};


class MathExpression : public MathParser
{
public:

    MathExpression();
    ~MathExpression();

    static vector<char> specialChars; 
    static unordered_map<string, Operator> operatorMap; 
    static unordered_map<string, Argument> constantMap; 
    static double add(const double a_arg1, const double a_arg2);
    static double subtract(const double a_arg1, const double a_arg2);
    static double multiply(const double a_arg1, const double a_arg2);
    static double divide(const double a_arg1, const double a_arg2);
    static bool isNumber(const string &a_str);
    static bool isSpecialCharacter(const char &a_char);
    static bool isSpecialNoParenthesis(const char &a_char);
    static double convertStringToDouble(const string &a_str);
    static double getResultdddOperator(
            double a_arg1,
            double a_arg2,
            const string &a_operatorKey);

    const string expression() const;
    void setExpression(const string &a_expression);

    void setMath(const string &a_expression);

    const string reversePolish() const;
    bool setArgumentMap(const string &a_reversePolish);
    bool setArgumentMap();

    bool expressionToReversePolish();

    double calculateExpression();

    uint32_t reversePolishErrorNum();
    const string reversePolishErrorString();

    uint32_t expressionErrorNum();
    const string expressionErrorString();

    const string mathToString() const;
    const string mathToStringFull() const;

    bool expandMathExpression();

    void clear();

    void setMathPrintPrecision(const uint16_t &mathPrintPrecision);
    uint16_t getMathPrintPrecision() const;

    void setVariableDouble(const string &a_name, const double a_value);

    uint16_t getVariableSize() const;

private:
    size_t operatorMapSize();
    bool hasOperatorMap(const string &a_operatorName) const;
    bool hasConstantMap(const string &a_constantName) const;
    bool hasArgumentMap(const string &a_argumentName) const;
    bool hasGeneratorMap(const string &a_generatorName) const;
    bool isOperator(const string a_entityName) const;
    bool isArgument(const string a_entityName) const;
    bool isGenerator(const string a_entityName) const;
    bool isOperatorOneArg(const string a_entityName) const;
    bool isOperatorTwoArg(const string a_entityName) const;
    bool generateArgArgOp(const string &a_key1,
                                const string &a_key2,
                                const string &a_key3);
    bool generateArgOp(const string &a_key1,
                             const string &a_key2);
    double getArgumentDoubleValue(const string &a_key) const;
    double getConstantDoubleValue(const string &a_key) const;
    const Argument *getConstant(const string &a_key) const;
    const Operator *getOperator(const string &a_key) const;
    Generator *getGenerator(const string &a_key);
    const Argument *getArgument(const string &a_key) const;
    uint16_t getEntitySize(EntityType a_entityType) const;
    EntityType entityType(const string &a_key) const;
    void setDoubleValueToArgument(const string &a_key, const double a_value);
    const string createNewUserConstantName() const;
    bool pushToReversePolish(const string &a_str, const char &a_char);
    void appendToReversePolishString(const string &a_str);

    uint32_t m_reversePolishError; 
    string m_reversePolishErrorString; 
    uint32_t m_expressionError; 
    string m_expressionErrorString; 
    string m_expression; 
    string m_reversePolish; 
    uint16_t m_mathPrintPrecision; 
    unordered_map<string, Argument> m_argumentMap; 
    vector<Generator> m_generatorVec;
    vector<string> m_math; 
    vector<string> m_RPstack; 
};

}

#endif // PSSMATHPARSER_H