// Created by Jamie /* Scientific Calculator Author: Jamie reference profile: https://www.sololearn.com/Profile/5274042/?ref=app original code link : https://code.sololearn.com/cBVsQw3izizM/?ref=app Version: 20180103.1245 ( duplicate😂😂) Input: Accepts real numbers, parentheses, functions, constants and operators. Ex1: 1 + -1.5 * 3 ^ (1 + 1) Ex2: abs(-2) * pi ^ 2 Demonstrates tokenization of input and evaluation with recursion. Order of operation sequence: Parentheses aa Exponents Mul/Div/Mod (left to right) Add/Sub (left to right) Operators: +, -, *, /, %, ^, ! The others are pretty obvious but I wanted to note the '!' operator. '!' is factorial and is used like this: n! Ex: (2+2)! Constants: e 2.71828182846 pi 3.14159265359 Functions: abs(n) absolute ceil(n) ceiling exp(n) exponent flor(n) floor ln(n) natural log log(n) logarithm rnd(n) round sqrt(n) square root Trig Functions: cos(r) cosine rad(d) degree to radian sin(r) sine tan(r) tangent ToDo: - fix error checking */ #include #include #include #include #include #include #define _USE_MATH_DEFINES #include #include using std::cin; using std::cout; using std::endl; using std::numeric_limits; using std::string; using std::vector; // token type enum tok_t { Beg, // beginning End, // end Lit, // literal number Opr, // operator Par, // parentheses Fnc // function }; // token struct tok { tok_t t; // type char c; // character double v; // value }; typedef vector tok_v; typedef string::iterator str_i; typedef tok_v::iterator tok_i; typedef numeric_limits dbl_l; #define T (*(_ti)) // curr #define N (*(_ti + 1)) // next #define P (*(_ti - 1)) // prev // radians 2 degrees #define R2D(r) (r * 180 / M_PI) // degrees 2 radians #define D2R(d) (d * M_PI / 180) // constants #define E 1 #define PI 2 // functions #define ABS 20 #define CEIL 21 #define EXP 22 #define FLOR 23 #define LN 24 #define LOG 25 #define RND 26 #define SQRT 27 // trig functions #define COS 40 #define RAD 41 #define SIN 42 #define TAN 43 static tok_v _tv; static tok_i _ti; void lex(string); double eval(int = 0); bool cnst(char, double &); bool func(char, double &); double fact(double); void err(string); void test(); int main() { string str; // uncomment to test changes //test(); //cout << "Input: "; getline(cin, str); lex(str); // allow more digits in output cout.precision( dbl_l::max_digits10); cout << "Answer: " << eval() << endl; return 0; } /* Tokenize input. @str string representation of expression to be tokenized. */ void lex(string str) { string s; str_i i; char f; // clear any existing tokens _tv.clear(); // add the beginning token _tv.push_back({ tok_t::Beg }); for (i = str.begin(); i != str.end(); i++) { // ignore whitespace if (isspace(*i)) continue; // parse function/constant if (isalpha(*i)) { s += toupper(*i); if(isalpha(*(i + 1))) continue; // done with the func/const if (s == "ABS") f = ABS; if (s == "CEIL") f = CEIL; if (s == "COS") f = COS; if (s == "E") f = E; if (s == "EXP") f = EXP; if (s == "FLOR") f = FLOR; if (s == "LN") f = LN; if (s == "LOG") f = LOG; if (s == "PI") f = PI; if (s == "RAD") f = RAD; if (s == "RND") f = RND; if (s == "SIN") f = SIN; if (s == "SQRT") f = SQRT; if (s == "TAN") f = TAN; _tv.push_back({ tok_t::Fnc, f }); s.clear(); continue; } // parse numbers and decimals if (isdigit(*i) || *i == '.') { s += *i; if (isdigit(*(i + 1)) || *(i + 1) == '.') continue; // done with the number _tv.push_back({ tok_t::Lit, 0, atof(s.c_str()) }); s.clear(); continue; } switch (*i) { case '+': case '-': case '*': case '/': case '%': case '^': case '!': _tv.push_back({ tok_t::Opr, *i }); break; case '(': case ')': _tv.push_back({ tok_t::Par, *i }); break; default: err("Invalid."); break; } } // add the ending token _tv.push_back({ tok_t::End }); _ti = _tv.begin(); } /* Evaluate expression based on operator order level. Called recursively for each term until level 3 where either a parenthesis, number, constant or function is reached. Then we return back towards level 0 until we find a matching operator. @lvl level of recursion. returns the result of the evaluated term. */ double eval(int lvl) { double val = 0; double neg = 1; char f; // skip beginning token if (T.t == tok_t::Beg) _ti++; // quit at ending token if (T.t == tok_t::End) return val; switch (lvl) { case 0: // add/sub case 1: // mul/div/mod case 2: // exponents // evaluate the left term val = eval(lvl + 1); // check for operator if (T.t == tok_t::Opr || T.t == tok_t::Par && T.c == '(') { // if on the correct // level, evaluate the // right them switch (T.c) { case '+': if (lvl != 0) break; _ti++; val += eval(lvl); break; case '-': if (lvl != 0) break; _ti++; val -= eval(lvl); break; case '*': if (lvl != 1) break; _ti++; val *= eval(lvl); break; case '/': if (lvl != 1) break; _ti++; val /= eval(lvl); break; case '%': if (lvl != 1) break; _ti++; val = fmod(val, eval(lvl)); break; case '^': if (lvl != 2) break; _ti++; val = pow(val, eval(lvl)); break; case '(': val *= eval(lvl); break; } } break; case 3: // handle term modifiers if (T.t == tok_t::Opr) { switch (T.c) { case '-': neg = -1; break; default: err("Invalid."); break; } _ti++; } // check for function if (T.t == tok_t::Fnc) { f = T.c; _ti++; // try to eval constant if (cnst(f, val)) break; if (T.t != tok_t::Par || T.c != '(') err("Missing '('."); // evaluate contents of // parentheses _ti++; val = eval(); // try to eval function if (!func(f, val)) err("Invalid."); if (T.t != tok_t::Par || T.c != ')') err("Missing ')'."); } // check for parenthesis else if (T.t == tok_t::Par) { if (T.c != '(') err("Missing '('."); // evaluate contents of // parentheses _ti++; val = eval(); if (T.c != ')') err("Missing ')'."); } else if (T.t == tok_t::Lit) // found a literal number val = T.v; else err("Invalid."); _ti++; break; } if (T.t == tok_t::Opr && T.c == '!') { val = fact(val); _ti++; } // adjust precision within // tolerance if (fabs(val) < FLT_EPSILON) val = 0; else if (fabs(round(val) - val) < FLT_EPSILON) val = round(val); return neg * val; } /* Try to evaluate given constant. @c constant to use. @v reference to variable to store constant in. returns true is the constant evaluation was successful. */ bool cnst(char c, double &v) { switch (c) { case E: v = M_E; break; case PI: v = M_PI; break; default: return false; } return true; } /* Try to evaluate given function. @f function to use. @v reference to variable to store function result in. returns true is the function evaluation was successful. */ bool func(char f, double &v) { switch (f) { case ABS: v = fabs(v); break; case CEIL:v = ceil(v); break; case COS: v = cos(v); break; case EXP: v = exp(v); break; case FLOR:v = floor(v);break; case LN: v = log(v); break; case LOG: v = log10(v);break; case RAD: v = D2R(v); break; case RND: v = round(v);break; case SIN: v = sin(v); break; case SQRT:v = sqrt(v); break; case TAN: v = tan(v); break; default: return false; } return true; } /* Calculate factorial. @v a non-negative number. returns result of factorial. */ double fact(double v) { double r, i; if (v < 0) err("Factorial error."); for (i = 1, r = 1; i <= v; r *= i, i++); return r; } /* Throw an error and end program. @str error description. */ void err(string str) { cout << str << endl; throw; } /* Test cases to verify I didn't break anything after making changes. */ void test() { lex("1+1"); assert(eval() == 2); lex("-1+-1"); assert(eval() == -2); lex("1.5*2"); assert(eval() == 3); lex("-2^3"); assert(eval() == -8); lex("2*(1+1)"); assert(eval() == 4); lex("1+2(1+1)^3"); assert(eval() == 17); lex("2(2(2(2(1+1))))"); assert(eval() == 32); lex("sqrt(3^abs(-2))"); assert(eval() == 3); lex("-(2^2)--2"); assert(eval() == -2); lex("2(2+2)!*2"); assert(eval() == 96); lex("tan(rad(360))"); assert(eval() == 0); lex("tan(rad(45))"); assert(eval() == 1); lex("sin(rad(90))"); assert(eval() == 1); lex("pi*2^2"); assert( eval() == M_PI * pow(2, 2)); }

math lover