Bodmas | calculator application is a simple terminal | Apps library

There are lot of ways you can do this. You can save it as plain text, create separate table for each expression and use those when you're doing any sort of mathematical calculations.

What I did a few months back is save the entire expressions as rich text.

So I saved it like this: Expression 1: (A / B) * C + D / (E - D) + J^2

Expression 2: (A / B) * C + D * (E + D) + J^2 Etc etc

My project was pretty simple which required me to save entire expressions in one line for quiz purposes.

You can use tinymce as rich text editor.

Another way is to save it as LaTeX. Look here for more details:

How to store mathematical expressions/explanations into database

MathJax for client side equation rendering

In C++ we not follow BODMAS strictly, + - has less priority than * /. But + and - has same priority. It means one which will appear first from left to right will be evaluated first. Similary * / has same priority.

So cout << 8*7/2 ; is eqivalent to cout << 56/2 ;. Because * / both has same priority but * appeared first, so * is evaluated first.

And to achieve what you want you can use cout << 8*(7/2) ;.

Just take parenteses and omit curly brackets.

I gather that the problem is not that you don't know how to write BNF grammars. Rather, you don't know which grammar you should write. In other words, if someone told you the precedence order for your operators, you would have no trouble writing down a grammar which parsed the operators with that particular precedence order. But you don't know which precedence order you should use.

Unfortunately there is not an International High Commission on Operator Precedence, and neither does any religion that I know of offer a spiritual reference including divinely inspired operator precedence rules.

For some operators, the precedence order is reasonably clear: BODMAS was adopted for good reasons, for example, but the main reason is that most people already wrote arithmetic according to those rules. You can certainly make a plausible mathematical argument based on group theory as to why it seems natural to give multiplication precedence over addition, but there will always be the suspicion that the argument was produced post facto to justify an already-made decision. Be that as it may, the argument for making multiplication bind more tightly than addition also works for giving bitwise-and precedence over bitwise-or, or boolean-and precedence over boolean-or. (Although I note that C compiler writers don't trust that programmers will have that particular intuition, since most modern compilers issue a warning if you omit redundant parentheses in such expressions.)

One precedence relationship which I think just about everyone would agree was intuitive is giving arithmetic operators precedence over comparison operators, and comparison operators precedence operators precedence over boolean operators. Most programmers would find a language which chose to interpret a > b + 7 as meaning "add seven to the boolean value of comparing a with b". Similarly, it might be considered outrageous to interpret a > 0 || b > 0 in any way other than (a > 0) || (b > 0). But other precedence choices seem a lot more arbitrary, and not all languages make them the same. (For example, the relative precedence of "not equal to" and "greater than", or of "exclusive or" and "inclusive or".

So what's a novice language designer to do? Well, first appeal to your own intuitions, particularly if you have used the operators in question a lot. Also, ask your friends, contacts, and potential language users what they think. Look at what other languages have done, but look with a critical eye. Search for complaints on language-specific forums. It may well be that the original language designer made an unfortunate (or even stupid) choice, and that choice now cannot be changed because it would break too many existing programs. (Which is why it is a good thing that you are worrying about operator precedence: getting it wrong can bring serious future problems.)

Direct experimentation can help, too, particularly with operators which are rarely used together. Define a plausible expression using the operators, and then write it out two (or more) times leaving out parentheses according to the various possible rules. Which of those looks more understandable? (Again, recruit your friends and ask them the same question.)

If, in the end, you really cannot decide what the precedence order between a particular pair of operators is, you can consider one more solution: Make parentheses mandatory for these operators. (Which is the intent of the C compiler whining about leaving out redundant parentheses in boolean expressions.)

Well, not the most elegant solution, but I think it works

You did not implement BODMAS, so all operations are performed sequentially, left to right.

To implement operator precedence, you should:

• provide an expression somehow (fluent way that you use is not enough)
• parse the expression (for example with antlr4)
• and finally, execute operation in required order (e.g. BODMAS)

This is a long (but powerful and correct) way. Python has built-in eval function, so it is possible to use it for your purposes:

If you have the pattern