Conversion: Algebraic - Polish - Reverse Polish - LISP ?

[Albert Chan]

Hi, Martin Hepperle

I am unfamiliar with LISP macros, but I made calc macro for Chez scheme.
It by-passed Scheme built-in syntax extensions, work directly with syntax-objects, thus compile very fast.

Of course, same code work with quoted objects too.
Here, I strip out Scheme syntax-object manipulations, to produce equivalent function '$'

Code:

(define ^ expt)
(define (process e) (scan (cdr  e) ($ (car e)) '()))
(define (rest e)    (scan (cddr e) ($ (cadr e)) '()))
(define (do-term a term)    (set-car! (cdr term) a) term)
(define (build a term)      (fold-left do-term a term))

(define (scan e a term)
    (cond
        ((null? e)
            (build a term))
        ((memq (car e) '(+ -))
            (if (null? (cdr e))
                (build (list (car e) a) term)       ; unary +/- in front
                (if (memq (cadr e) '(+ - * / ^))    ; unary +/- after op
                    (scan (cdr e) (list (car e) a) term)
                    (list (car e) (rest e) (build a term)))))
        ((memq (car e) '(* /))
            (scan (cddr e) ($ (cadr e)) (cons (list (car e) #f a) term)))
        ((eq? (car e) '^)
            (scan (cddr e) (list (car e) ($ (cadr e)) a) term))
        (else  ; implied multiply
            (scan (cdr  e) ($ (car e)) (cons (list '* #f a) term)))))

(define ($ e) ; infix -> prefix
    (cond
        ((atom? e)               e)     ; nothing to do
        ((eq? (car e) '@)   (cdr e))    ; (@ ...) --> (...)
        (else (process (reverse e)))))  ; process in reverse

scheme> ($ '(x (1 + x (1 - x)) (@ sin x)))
(* (* x (+ 1 (* x (- 1 x)))) (sin x))

(12-23-2022 02:59 AM)Albert Chan Wrote:  And, for Mach number test. Spaces are needed to separate the tokens.

scheme> (sqrt (calc 5 *(((((1 + .2 *(350 / 661.5)^ 2)^ 3.5 - 1)* (1 - 6.875E-6 * 25500)^ - 5.2656)+ 1)^ .286 - 1)))
0.8357245351752515

scheme> (def v ($ '(5 *(((((1 + .2 *(350 / 661.5)^ 2)^ 3.5 - 1)* (1 - 6.875E-6 * 25500)^ - 5.2656)+ 1)^ .286 - 1))))
scheme> (sqrt (eval v))
0.8357245351752515

Note: this is not the right way to evaluate complicated expression. It should have broken up.