// Online C++ compiler to run C++ program online
#include <iostream>
#include <vector>
#include <sstream>
#include <algorithm>

double factorial(double val){
    double base=1.0;
    for(double i=0.0;i<val;i+=1.0){
        base*=val;
        val-=1.0;
    }
    return base;
}

class Expression{
    public:
        virtual double eval()=0;
};

class UnaryExpression: public Expression{
    private:
        double data;
        char symbol;
        
    public:
        UnaryExpression(double d){
            data=d;
            symbol='+';
        }
        UnaryExpression(double d,char sym){
            data=d;
            symbol=sym;
        }
        double eval() override{
            if(symbol=='-'){
                return -data;
            }
            if(symbol=='!'){
                return factorial(data);
            }
            return data;
        }
};

class BinaryExpression: public Expression{
    private:
    
    Expression* o1=nullptr;
    Expression* o2=nullptr;
    char sym;
    
    public:
    
    BinaryExpression(){}
    
    BinaryExpression(double a, double b, char _sym){
        o1= new UnaryExpression(a);
        o2= new UnaryExpression(b);
        sym=_sym;
    }
    
    BinaryExpression(Expression* e1,Expression* e2, char _sym){
        o1= e1;
        o2= e2;
        sym=_sym;
    }
    
    ~BinaryExpression(){
        if(o1!=nullptr){
            delete(o1);
        }
        if(o2!=nullptr){
            delete(o2);
        }
    }
    double eval() override{
        if(sym=='+'){
            return o1->eval()+o2->eval();
        }
        if(sym=='-'){
            return o1->eval()-o2->eval();
        }
        if(sym=='*'){
            return o1->eval()*o2->eval();
        }
        if(sym=='/'){
            return o1->eval()/o2->eval();
        }
        if(sym=='%'){
            return (double)((int)(o1->eval())%(int)(o2->eval()));
        }
        return o1->eval();
        
    }
};

bool is_number(const std::string& s){
    try
    {
        std::stod(s);
    }
    catch(std::exception e){
        return false;
    }
    return true;
}

double eval_expression(std::string ops){
    std::string token;
    std::vector<std::string> tokens;
    
    std::istringstream iss(ops);
    
    while (std::getline(iss, token, ' ')) {
        tokens.push_back(token);
    }
    
    double o1=0.0;
    double o2=0.0;
    bool o1_passed=false;
    char cur_simbol=' ';
    
    
    for(size_t i=0;i<tokens.size();i++){
        if(is_number(tokens[i])==true){
            double parsed = std::stod(tokens[i]);

            if(o1_passed==true){
                o2=parsed;
                
                o1=BinaryExpression(new UnaryExpression(o1),new UnaryExpression(o2),cur_simbol).eval();
            } else {
                o1=parsed;
                o1_passed=true;
            }
        } else if(tokens[i].size()==1){
            cur_simbol=tokens[i][0];
        } else {//Parse and eval unary
        
            char token=tokens[i][0];
            double parsed = std::stod(tokens[i].substr(1, tokens[i].size()));
            
            if(o1_passed==true){
                o2=UnaryExpression(parsed,token).eval();
                
                o1=BinaryExpression(new UnaryExpression(o1),new UnaryExpression(o2),cur_simbol).eval();
            } else {
                o1=UnaryExpression(parsed,token).eval();
                o1_passed=true;
            }
        }
    }
    
    return o1;
}

int main() {
    std::cout << eval_expression("4.0 + 5.5 - 1 / -2 * 1.5 * !4");

    return 0;
}