### How *CrunchJr* Works

*CrunchJr* is a powerful computational engine.
It allows you to enter an expression in the Submit box, and evaluate
it for multiple values of the variables. For example,

**beta***sin(**x**-sqrt(**beta**))/(PI***x**)

has two variables (**beta** and **x**).
Entering 4.002 and 3.73 for **beta** and 4.11, 4.7, 4.447 for
**x** produces the output on the right (note that the
highlighting of rows 3 and 4 is only to make it easier to read).
This page describes how the computation is performed.

*CrunchJr* reads expressions in the standard infix form,
but stores them in postfix ("Reverse Polish") form. Reverse
Polish is named for the Polish mathematician, Jan
Lukasiewicz.

Infix | | | Postfix |

X + Y | | | X Y + |

X * Y + Z | | | X Y * Z + |

X + Y * Z | | | X Y Z * + |

(X - Y) / Sin(R - T) | | | X Y - R T - Sin / |

Sqrt(A+R)*Max(R,R-A,A+1) | | | A R + Sqrt R R A - A 1 + Max * |

Postfix representation has several advantages over infix for
computer evaluation: Postfix is expressed without parentheses,
postfix is easy to evaluate using stacks, and postfix does not have
precedence rules. The translation of infix to postfix notation
handles the parentheses and precedence rules once, so that multiple
evaluations of the expression with different values for the
variables can be more efficient. Note that by convention,
Expression 3 above, **X+Y*Z** is evaluated as **X+(Y*Z)** and not
**(X+Y)*Z**. That is, multiplication has a higher precedence
than addition.

The valid operators are ** + − * /
% ** ^ **(and function calls).
The precedence rules are

Operator |
Precedence |
Description |

( | 1 | Open Parenthesis |

) | 1 | Close Parenthesis |

Func() | 2 | Functions |

** | 3 | Exponentiation |

^ | 3 | Exponentiation |

* | 4 | Multiplication |

/ | 4 | Division |

% | 4 | Remainder |

+ | 5 | Addition |

− | 5 | Subtraction |

#### Operators of equal precedence are resolved
left-to-right

During evaluation, *CrunchJr* "pops" items off the
stack from left to right.
Each item is either a constant, a variable, or an operator.
Each variable is replaced with one of its values.
Each time an operator is encountered, it operates on the appropriate
number of "popped" values, and "pushes" the result back onto the stack.
These steps are repeated until only the final result remains
on the stack. Then the whole procedure is repeated for the
next set of
variable values.

###### ~~~//~~~