Mailing List Archive: 49091 messages

# operator precedence, just curious...

### [1/7] from: tag-yer-it::mailandnews::com at: 5-Oct-2001 14:43

Hi guys, Whats up with this? I'm just curious, and probably missing something simple... REBOL/Core 2.5.0.4.2 23-Mar-2001 Copyright 2000-2001 REBOL Technologies. All rights reserved. REBOL >>> 6 * 7 - 3 / 4 == 9.75 Python 1.5.2 (#0, Dec 27 2000, 13:59:38) [GCC 2.95.2 20000220 (Debian GNU/Linux)] on linux2 Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> 6 * 7 - 3 / 4
42 -- signature sneezing: "achoo!" -tom

### [2/7] from: geza67:freestart:hu at: 5-Oct-2001 20:58

Hello Tom, REBOL >>>> 6 * 7 - 3 / 4
> == 9.75
There is no such thing as operator precedence in REBOL. Expressions are _always_ evaluated from left to right. If you would like to achieve the usual result in the mathematical sense, use parentheses to group subexpressions. -- Best regards, Geza mailto:[geza67--freestart--hu]

### [3/7] from: greggirwin:starband at: 5-Oct-2001 13:38

Hi Tom, << Whats up with this? I'm just curious, and probably missing something simple...>> You have to use parens in REBOL to force operator precedence:
>> (6 * 7) - (3 / 4)
== 41.25 Or you could also do it this way if you're an RPN kinda' guy:
>> subtract multiply 6 7 divide 3 4
== 41.25 --Gregg

### [4/7] from: ryanc:iesco-dms at: 5-Oct-2001 12:36

Hey Tom, I actually like the REBOL way better myself, but I have never liked operator precedence rules either. My guess is that RT figured operator precedence interfered with the interpreters design too much. Instead they compromised on the op type. Where most functions in rebol take thier arguments subsequently, op types take an argument from the previous word, as well as the following word. The result is a left to right evaluated equation, or as one might say "no precedence", though I am sure Joel has a more appropriate term for this. : ) I like it no precedence becuase it works exactly like how you would enter it into a calculator. so the expression:
>> 6 * 7 - 3 / 4
is computed (((6 * 7) - 3) / 4) or just as if you typed "6 * 7 - 3 / 4" into a calculator. If you still miss those operator precedence rules, somebody did write a dialect that does it, I am sure its easy to find. --Ryan Tom Foster wrote:
> Hi guys, > Whats up with this? I'm just curious, and probably missing
<<quoted lines omitted: 14>>
> [rebol-request--rebol--com] with "unsubscribe" in the > subject, without the quotes.
-- Ryan Cole Programmer Analyst www.iesco-dms.com 707-468-5400

### [5/7] from: joel:neely:fedex at: 5-Oct-2001 17:59

Hi, all, Gregg Irwin wrote:
> You have to use parens in REBOL to force operator precedence: > > >> (6 * 7) - (3 / 4) > == 41.25 > > Or you could also do it this way if you're an RPN kinda' guy: > > >> subtract multiply 6 7 divide 3 4 > == 41.25 >
Not that I'd ever be picky... ;-) ... but that's actually PN (Polish Notation, in which the operator comes before its operands), not RPN (Reverse Polish Notation, in which the operator follows its operands). RPN is most commonly seen in FORTH (and certain H-P calculators), where the above expression would have been written as 6 7 * 3 4 / - (Elvis has backed out of the building!) -jn- -- The only thing scarier than a sysadmin with a screwdriver is a programmer with the root password. -- Matt Korth joel^FIX^PUNCTUATION^dot^neely^at^fedex^dot^com

### [6/7] from: g:santilli:tiscalinet:it at: 6-Oct-2001 15:21

Hello Ryan! On 05-Ott-01, you wrote: RC> If you still miss those operator precedence rules, somebody RC> did write a dialect that does it, I am sure its easy to find. It is not online, but maybe I should put it on my REB site?
>> eval [6 * 7 - 3 / 4]
== 41.25 To avoid the overhead of parsing when doing calculation in a loop you can use the /translate refinement to translate from infix to prefix notation.
>> eval/translate [6 * 7 - 3 / 4]
== [subtract multiply 6 7 divide 3 4] Regards, Gabriele. -- Gabriele Santilli <[giesse--writeme--com]> - Amigan - REBOL programmer Amiga Group Italia sez. L'Aquila -- http://www.amyresource.it/AGI/ REBOL [ Title: "Expression evaluator" Author: "Gabriele Santilli <[giesse--writeme--com]>" Comment: { Evaluates expressions taking usual operator precedence into account. 1. (...) 2. - [negation], ! [factorial] 3. ^ [power] 4. *, / 5. +, - [subtraction] } ] ; A simple iterative implementation; returns 1 for negative ; numbers. FEEL FREE TO IMPROVE THIS! factorial: func [n [integer!] /local res] [ if n < 2 [return 1] res: 1 ; should avoid doing the loop for i = 1... repeat i n [res: res * i] ] expression-parser: make object! [ slash: to-lit-word first [ / ] expr-val: expr-op: none expression: [ term (expr-val: term-val) any [ ['+ (expr-op: 'add) | '- (expr-op: 'subtract)] term (expr-val: compose [(expr-op) (expr-val) (term-val)]) ] ] term-val: term-op: none term: [ pow (term-val: power-val) any [ ['* (term-op: 'multiply) | slash (term-op: 'divide)] pow (term-val: compose [(term-op) (term-val) (power-val)]) ] ] power-val: none pow: [ unary (power-val: unary-val) opt ['^ unary (power-val: compose [power (power-val) (unary-val)])] ] unary-val: pre-uop: post-uop: none unary: [ (post-uop: pre-uop: []) opt ['- (pre-uop: 'negate)] primary opt ['! (post-uop: 'factorial)] (unary-val: compose [(post-uop) (pre-uop) (prim-val)]) ] prim-val: none ; WARNING: uses recursion for parens. primary: [ set prim-val [number! | word!] | set prim-val paren! (prim-val: translate to-block :prim-val) ] translate: func [expr [block!] /local res recursion] [ ; to allow recursive calling, we need to preserve our state recursion: reduce [ :expr-val :expr-op :term-val :term-op :power-val :unary-val :pre-uop :post-uop :prim-val ] res: if parse expr expression [expr-val] set [ expr-val expr-op term-val term-op power-val unary-val pre-uop post-uop prim-val ] recursion res ] set 'eval func [expr [block!] /translate] [ expr: self/translate expr either translate [expr] [do expr] ] ]

### [7/7] from: greggirwin:starband at: 6-Oct-2001 11:40

Hi Joel, << ... but that's actually PN (Polish Notation, in which the operator comes before its operands), not RPN (Reverse Polish Notation, in which the operator follows its operands). >> DOH! Of course you are correct. My little HP20S doesn't work quite like the old ones did (my Dad had an HP65, programmable, with the magnetic strip reader) so I'm out of practice. :) --Gregg

Notes
• Quoted lines have been omitted from some messages.
View the message alone to see the lines that have been omitted