Jump to content

Reverse Polish notation

From Wikipedia, the free encyclopedia

This is an old revision of this page, as edited by 24.199.89.159 (talk) at 18:11, 15 August 2007 (→‎See also: add a reference to PostScript). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

Template:Infobox notationReverse Polish notation (or just RPN) by analogy with the related Polish notation, a prefix notation introduced in 1920 by the Polish mathematician Jan Łukasiewicz, is a mathematical notation wherein every operator follows all of its operands. It is also known as Postfix notation. Reverse Polish notation was invented by Australian philosopher and computer scientist Charles Hamblin in the mid-1950s, to enable zero-address memory stores. Hamblin presented his work at a conference in June 1957, and published it in 1957 and 1962.

Most of what follows is about binary operators. A unary operator for which the Reverse Polish notation is the general convention is the factorial.

Explanation

In Reverse Polish notation the operators follow their operands; for instance, to add three and four one would write "3 4 +" rather than "3 + 4". If there are multiple operations, the operator is given immediately after its second operand; so the expression written "3 − 4 + 5" in conventional infix notation would be written "3 4 − 5 +" in RPN: first subtract 4 from 3, then add 5 to that. An advantage of RPN is that it obviates the need for parentheses that are required by infix. While "3 − 4 + 5" can also be written "(3 − 4) + 5", that means something quite different from "3 − (4 + 5)", and only the parentheses disambiguate the two meanings. In postfix, the latter would be written "3 4 5 + −", which unambiguously means "3 (4 5 +) −".

Interpreters of Reverse Polish notation are stack-based; that is, operands are pushed onto a stack, and when an operation is performed, its operands are popped from a stack and its result pushed back on. Stacks, and therefore RPN, have the advantage of being easy to implement and very fast.

Practical implications

  • Reading from left to right, calculations can occur as soon as an operator is read; processing can always begin before the entire expression is read in.
  • Brackets and parentheses are unnecessary.
  • In RPN calculators, no Equals key is required to force computation to occur.
  • RPN calculators do, however, require an Enter key to separate two adjacent numeric operands.
  • The state is always just a stack of values awaiting operation; it is never the case that an operator has already been entered and is still awaiting an operand.

Disadvantages

  • The widespread use of standard ordered equations (infix) in educational systems (and therefore infix electronic calculators being the norm in classrooms) can make RPN impractical, hard, and hindering at times. (However, it is easy for a computer to convert infix notation to postfix, most notably via Dijkstra's Shunting yard algorithm.)
  • Adjacent numbers have to have a space between them, which requires precise handwriting to prevent confusion (for instance, 12 34 + could look a lot like 123 4 +).
  • Most RPN electronic calculators have programmable functions and multiple memory registers. In formal examinations (such as licensing examinations) calculators with such extended functions are often banned, but using a simple infix calculator is allowed.
  • RPN calculators are comparatively expensive and rare. When an RPN calculator is unavailable, frequent users of RPN calculators may find use of infix calculators difficult due to habit. (For example, if one were to attempt to perform additional calculations on a result using an infix calculator, and accidentally entered the next operand as would be expected with RPN, the previous result would be lost.)

The postfix algorithm

The algorithm for evaluating any postfix expression is fairly straightforward:

  • While there are input tokens left
    • Read the next token from input.
    • If the token is a value
      • Push it onto the stack.
    • Otherwise, the token is a function. (Operators, like +, are simply functions taking two arguments.)
      • It is known that the function takes n arguments.
      • So, pop the top n values from the stack.
        • If there are fewer than n values on the stack
          • (Error) The user has not input sufficient values in the expression.
      • Evaluate the function, with the values as arguments.
      • Push the returned results, if any, back onto the stack.
  • If there is only one value in the stack
    • That value is the result of the calculation.
  • If there are more values in the stack
    • (Error) The user input too many values.

Example

The infix expression "5 + ((1 + 2) * 4) − 3" can be written down like this in RPN:

5 1 2 + 4 * + 3 −

The expression is evaluated left-to-right, with the inputs interpreted as shown in the following table (the Stack is the list of values the algorithm is "keeping track of" after the Operation given in the middle column has taken place):

Input Operation Stack Comment
5 Push operand 5
1 Push operand 5, 1
2 Push operand 5, 1, 2
+ Add 5, 3 Pop two values (1, 2) and push result (3)
4 Push operand 5, 3, 4
* Multiply 5, 12 Pop two values (3, 4) and push result (12)
+ Add 17 Pop two values (5, 12) and push result (17)
3 Push operand 17, 3
− Subtract 14 Pop two values (17, 3) and push result (14)

When a computation is finished, its result remains as the top (and only) value in the stack; in this case, 14.

Converting from infix notation

Main article: Shunting yard algorithm

Edsger Dijkstra invented the "shunting yard" algorithm to convert infix expressions to postfix (RPN), so named because its operation resembles that of a railroad shunting yard.

There are other ways of producing postfix expressions from infix notation. Most Operator-precedence parsers can be modified to produce postfix expressions; in particular, once an abstract syntax tree has been constructed, the corresponding postfix expression is given by a simple post-order traversal of that tree.

Implementations

The first computers to implement architectures enabling RPN were the English Electric Company's KDF9 machine, which was announced in 1960 and delivered (i.e. made available commercially) in 1963, and the American Burroughs B5000, announced in 1961 and also delivered in 1963. One of the designers of the B5000, Robert S. Barton, later wrote that he developed RPN independently of Hamblin, sometime in 1958 while reading a textbook on symbolic logic, and before he was aware of Hamblin's work.

Friden introduced RPN to the desktop calculator market with the EC-130 in June of 1963. Hewlett-Packard (HP) engineers designed the 9100A Desktop Calculator in 1968 with RPN. This calculator popularized RPN among the scientific and engineering communities, even though early advertisements for the 9100A failed to mention RPN. The HP-35 handheld scientific calculator brought RPN to the first scientific pocket calculator in 1972. The HP-10C series of calculators, including the famous financial calculator the HP-12C, all used RPN. When Hewlett-Packard introduced a later business calculator, the HP-19B, without RPN, feedback from financiers and others used to using the 12-C compelled them to release the HP-19BII, which gave users the option of using algebraic notation or RPN.

Existing implementations using Reverse Polish notation include:

A Postfix Evaluator Implemented In Visual Basic 6

File: postfix.bas 

 Dim Stack As New ByteStack

 Public Sub Main()
   Dim Answer As Double
   Answer = EvaluatePostfix("3 2 + 5 *")
   MsgBox "Answer is " & CStr(Answer), vbInformation, "Reverse Polish Notation (Postfix) Evaluator"
   End
 End Sub

 Public Function EvaluatePostfix(Expression As String) As Double
   Dim i As Integer
   Dim A As Double
   Dim C As Double
   Dim Expn() As String
   Stack.Initialize 128
   Expression = Replace(Expression, "  ", " ")
   Expn() = Split(Expression, " ")
   For i = 0 To UBound(Expn())
     Select Case Expn(i)
       Case "+"
         Stack.POP VarPtr(C), 8
         A = C + A
       Case "-"
         Stack.POP VarPtr(C), 8
         A = C - A
       Case "*"
         Stack.POP VarPtr(C), 8
         A = C * A
       Case "/", "\"
         Stack.POP VarPtr(C), 8
         A = C / A
       Case "^"
         Stack.POP VarPtr(C), 8
         A = C ^ A
       Case Else
         A = Val(Expn(i))
         Stack.PUSH VarPtr(A), 8
     End Select
   Next i
   EvaluatePostfix = A
 End Function

File: ByteStack.cls 

 Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (ByVal Destination As Long, Source As Any, ByVal Length As Long)
 Private Declare Sub RtlMoveMemory Lib "kernel32" (Destination As Any, ByVal Source As Long, ByVal Length As Long)
 Dim Stack() As Byte
 Dim TOS As Long

 Public Sub Initialize(Bytes As Long)
   ReDim Stack(Bytes - 1)
   TOS = 0
 End Sub

 Public Sub PUSH(ptrDATA As Long, Length As Long)
   If (Length + TOS - 1) > UBound(Stack()) Then
       ReDim Preserve Stack(UBound(Stack()) + Length)
   End If
   RtlMoveMemory Stack(TOS), ptrDATA, Length
   TOS = TOS + Length
 End Sub

 Public Function POP(ptrDATA As Long, Length As Long) As Boolean
   If TOS - Length > -1 Then
     TOS = TOS - Length
     CopyMemory ptrDATA, Stack(TOS), Length
     POP = True
   End If
 End Function

See also

Retrieved from "https://en.wikipedia.org/w/index.php?title=Reverse_Polish_notation&oldid=151433728"