calculator

// https://github.com/kimwalisch/calculator

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <stack>
#include <cstddef>
#include <cctype>
#include <cmath>

struct Calculator {
    // if error occurs, save it here
    bool error;
    std::string message;
    double x, y, t;
    // eval("3 + 5") => 8
    double eval(const std::string& expr, double x, double y, double t) {
        error = false;
        message.clear();
        double value = 0;
        this->x = x;
        this->y = y;
        this->t = t;
        _index = 0;
        _expr = expr;
        value = parseExpr();
        if (!isEnd()) unexpect("EOF");
        return value;
    }
    double eval(const std::string& expr, double x) {
        return eval(expr, x, x, x);
    }
    double eval(const std::string& expr, double x, double y) {
        return eval(expr, x, y, 0);
    }
    //           +    -    *    /    ^    e
    enum { NONE, ADD, SUB, MUL, DIV, POW, EXP };
    //  +   10  left
    struct Operator {
        int op, prec, assoc;
        Operator(int op, int prec, int assoc) :
            op(op), prec(prec), assoc(assoc) {}
    };
    // <+> = 8 in (3 + 5)
    struct Value {
        Operator op;
        double value;
        Value(const Operator& op, double value) :
            op(op), value(value) {}
        int prec() const {
            return op.prec;
        }
        bool none() const {
            return op.op == NONE;
        }
    };
    // for private use
    std::string _expr;
    std::size_t _index;
    std::stack<Value> _stack;
    Calculator() : error(false) {}
    // return error = true if division by 0
    double checkZero(double value) {
        if (value == 0) {
            std::string divmod = "/%";
            std::size_t position = _expr.find_last_of(divmod, _index - 2);
            error = true;
            message = "division by 0";
            if (position != std::string::npos)
                message += " at\"" + _expr.substr(position) + "\"";
        }
        return value;
    }
    // calc atom
    double calculate(double a, double b, const Operator& op) {
        switch (op.op) {
            case ADD:
                return a + b;
            case SUB:
                return a - b;
            case MUL:
                return a * b;
            case DIV:
                return a / checkZero(b);
            case POW:
                return std::pow(a, b);
            case EXP:
                return a * std::pow(10, b);
            default:
                return 0;
        }
    }
    bool isEnd() {
        return _index >= _expr.length();
    }
    char getChar() {
        if (isEnd()) return 0;
        return _expr[_index];
    }
    void expect(const std::string& str) {
        if (_expr.compare(_index, str.length(), str))
            unexpect(str);
        else _index += str.length();
    }
    void unexpect(const std::string& str) {
        error = true;
        message = "unexpected \"" + _expr.substr(_index) + "\" at " +
                  sizeToString(_index) + ", expect \"" + str + "\"";
    }
    std::string sizeToString(std::size_t size) {
        std::stringstream ss;
        ss << size;
        return ss.str();
    }
    void eatSpaces() {
        while (std::isspace(getChar())) _index++;
    }
    Operator parseOp() {
        eatSpaces();
        switch (getChar()) {
            case '+':
                _index++;
                return Operator(ADD, 10, 'L');
            case '-':
                _index++;
                return Operator(SUB, 10, 'L');
            case '/':
                _index++;
                return Operator(DIV, 20, 'L');
            case '*':
                _index++;
                return Operator(MUL, 20, 'L');
            case '^':
                _index++;
                return Operator(POW, 30, 'R');
            case 'e':
            case 'E':
                _index++;
                return Operator(EXP, 40, 'R');
            default:
                return Operator(NONE, 0, 'L');
        }
    }
    static int toInteger(char c) {
        if (c >= '0' && c <= '9') return c - '0';
        if (c >= 'a' && c <= 'f') return c - 'a' + 0xa;
        if (c >= 'A' && c <= 'F') return c - 'A' + 0xa;
        return 0xf + 1; // not an integer
    }
    int getInteger() {
        return toInteger(getChar());
    }
    int parseDec() {
        int value = 0;
        for (int d; (d = getInteger()) <= 9; _index++)
            value = value * 10 + d;
        return value;
    }
    int parseHex() {
        _index += 2;
        int value = 0;
        for (int h; (h = getInteger()) <= 0xf; _index++)
            value = value * 0x10 + h;
        return value;
    }
    bool isHex() {
        if (_index + 2 < _expr.length()) {
            char x = _expr[_index + 1];
            char h = _expr[_index + 2];
            return (x == 'x' || x == 'X') && toInteger(h) <= 0xf;
        }
        return false;
    }
    double parseReal() {
        int dec = 0, base = 10;
        double real = 0;
        if (getChar() != '.') dec = parseDec();
        _index++;
        for (int d; (d = getInteger()) <= 9; _index++) {
            real += (double) d / base;
            base *= 10;
        }
        return dec + real;
    }
    bool isReal() {
        bool result = false;
        int index_ = _index;
        while (std::isdigit(getChar()))
            _index++;
        if (getChar() == '.') {
            _index++;
            result = std::isdigit(getChar());
        } else
            result = false;
        _index = index_;
        return result;
    }
    bool beginWith(const std::string& a, const std::string& b, int start) {
        unsigned n = b.length();
        if (n + start > a.length()) return false;
        for (unsigned i = 0; i < n; ++i)
            if (a[i + start] != b[i]) return false;
        return true;
    }
    bool isSin() {
        return beginWith(_expr, "sin(", _index);
    }
    bool isSqrt() {
        return beginWith(_expr, "sqrt(", _index);
    }
    double parseValue() {
        double value = 0;
        eatSpaces();
        switch (getChar()) {
            case '.':
                value = parseReal();
                break;
            case '0':
                if (isHex())
                    value = parseHex();
                else if (isReal())
                    value = parseReal();
                else
                    value = parseDec();
                break;
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                if (isReal())
                    value = parseReal();
                else
                    value = parseDec();
                break;
            case '(':
                _index++;
                value = parseExpr();
                eatSpaces();
                expect(")");
                break;
            case '+':
                _index++;
                value = parseValue();
                break;
            case '-':
                _index++;
                value = -parseValue();
                break;
            case 's':
                if (isSin()) {
                    _index += 4;
                    value = std::sin(parseExpr());
                } else if (isSqrt()) {
                    _index += 5;
                    value = std::sqrt(parseExpr());
                } else
                    unexpect("sin( or sqrt(");
                eatSpaces();
                expect(")");
                break;
            case 'c':
                expect("cos(");
                value = std::cos(parseExpr());
                eatSpaces();
                expect(")");
                break;
            case 'l':
                expect("log(");
                value = std::log(parseExpr());
                eatSpaces();
                expect(")");
                break;
            case 'x':
                _index++;
                value = x;
                break;
            case 'y':
                _index++;
                value = y;
                break;
            case 't':
                _index++;
                value = t;
                break;
            default:
                if (!isEnd()) unexpect("value");
        }
        return value;
    }
    double parseExpr() {
        _stack.push(Value(Operator(NONE, 0, 'L'), 0));
        double value = parseValue();
        while (!_stack.empty()) {
            Operator op(parseOp());
            while (op.prec < _stack.top().prec() ||
                    (op.prec == _stack.top().prec() &&
                     op.assoc == 'L')) {
                if (_stack.top().none()) {
                    _stack.pop();
                    return value;
                }
                value = calculate(_stack.top().value, value, _stack.top().op);
                _stack.pop();
            }
            _stack.push(Value(op, value));
            value = parseValue();
        }
        return 0;
    }
};

// sinx + 8y
// -> 2sin(x) + 8y          sinx -> sin(x)
// -> 2 * sin(1) + 8 * 2    x, y -> 1, 2
std::string& gsub(std::string& x, const std::string& p, const std::string& r) {
    std::string::size_type i = 0;
    while ((i = x.find(p, i)) != std::string::npos) {
        x.replace(i, p.length(), r);
        i += r.length();
    }
    return x;
}

// \d\w -> \d * \w
std::string& rewrite(std::string& x) {
    gsub(x, "sinx", "sin(x)");
    gsub(x, "cosx", "cos(x)");
    gsub(x, "logx", "log(x)");
    gsub(x, "sqrtx", "sqrt(x)");
    gsub(x, "siny", "sin(y)");
    gsub(x, "cosy", "cos(y)");
    gsub(x, "logy", "log(y)");
    gsub(x, "sqrty", "sqrt(y)");
    gsub(x, "sint", "sin(t)");
    gsub(x, "cost", "cos(t)");
    gsub(x, "logt", "log(t)");
    gsub(x, "sqrtt", "sqrt(t)");
    for (unsigned i = 0; i < x.length() - 1; ++i)
        if (std::isdigit(x[i]) && std::isalpha(x[i + 1]))
            x.insert(++i, 1, '*');
    return x;
}

int main() {
    Calculator c;
    std::string input = "sqrt(0.2sinx + 8.2y + 7/t) - 5 / 3";
    // std::cin >> input;
    rewrite(input);
    std::cout << input << std::endl;
    std::cout << c.eval(input, 1.2, 0.3, 5) << std::endl;
    return 0;
}