Reverse Polish Notation (RPN) is a mathematical notation where operators follow their operands, enabling efficient evaluation using a stack. It eliminates the need for parentheses and reduces ambiguity in expression parsing.
RPN was developed in the 1920s by Polish logician Jan Łukasiewicz, who introduced prefix notation. The reverse form-postfix notation-was later adopted in computing due to its efficiency in algorithmic processing. Unlike standard infix notation (e.g., 3 + 4), RPN writes expressions as 3 4 +, where the operator acts on the two most recent values.
The core principle: each operand is pushed onto a stack, and when an operator appears, it pops the required number of operands, computes the result, and pushes it back. This model is deterministic and avoids precedence conflicts entirely.
In standard arithmetic, operations depend on order and grouping. For example, 3 + 4 × 5 evaluates as 3 + (4 × 5) = 23 due to multiplication taking precedence. In RPN, this becomes 3 4 5 × +, which processes left to right:
The final value is 23. No parentheses needed. No precedence rules to memorize.
This stack-based execution is ideal for machines. A CPU or interpreter doesn't need to track nesting levels or parse complex grammar. Each token is processed sequentially, making RPN well-suited for compilers, virtual machines, and embedded systems.
RPN is primarily used in two forms: binary and n-ary. Binary RPN applies to operations with two inputs (like +, −, ×, ÷). N-ary RPN supports functions with multiple arguments, such as min(2, 3, 4) written as 2 3 4 min.
| Expression Type | Infix Form | RPN Form | Use Case |
|---|---|---|---|
| Simple Addition | 5 + 3 | 5 3 + | Basic calculator |
| Complex Expression | (2 + 3) × (4 − 1) | 2 3 + 4 1 − × | Compiler intermediate code |
| Function Call | sqrt(16) | 16 sqrt | PostScript, Lua scripting |
Some systems extend RPN with special operators. For example, HP calculators use RPN with a four-level stack (X, Y, Z, T registers), allowing users to manipulate values without re-entering numbers. This design reduced keystrokes in engineering workflows.
RPN remains in use today in specialized domains. Hewlett-Packard's line of scientific calculators (HP-15C, HP-48GX) relied on RPN for decades. Engineers and programmers preferred it because it minimized errors during long calculations and allowed easy correction of intermediate steps.
Modern applications include:
A common misconception is that RPN is only for old calculators. In reality, it's still used in embedded systems and domain-specific languages where performance and predictability matter. For example, the Lua scripting language allows stack-based operations via its C API, and some game engines use RPN-style expression evaluation for changing behavior trees.
Many assume RPN is inherently harder to learn. But research shows that experienced users process RPN faster than infix. A 1978 study comparing HP-12C users with standard calculator users found that RPN users completed complex financial calculations 18% faster on average, with fewer errors in multi-step problems.
Another misunderstanding: RPN requires manual stack management. While early implementations did, modern tools automate this. For example, the Go programming language's built-in evaluation engine handles RPN-like expressions internally when compiling expressions involving constants and variables.
Also, RPN is not limited to binary operations. Functions with variable arity-such as sum(a,b,c)-can be expressed cleanly in RPN: a b c sum. This flexibility makes RPN suitable for symbolic computation and functional programming.
Suppose you need to calculate compound interest: A = P(1 + r)^t, where P = $1,000, r = 5% annual rate, t = 10 years.
In infix: 1000 × (1 + 0.05)^10
In RPN: 1000 1 0.05 + 10 ^ ×
Step-by-step:
This sequence executes in 10 steps. No parentheses. No precedence confusion. On a physical HP-12C calculator, this takes under 15 seconds to enter and verify.
I used an HP-12C emulator during a finance course. After two days of practice, I could enter complex time-value-of-money formulas faster than peers using standard calculators. The stack gave me visibility into intermediate results-critical when debugging a loan amortization schedule.
What is a RPN? It is a postfix notation system that evaluates mathematical expressions using a stack, eliminating ambiguity and reducing computational overhead. Its structure enables precise, predictable execution-ideal for machines and skilled users alike.