## SICP – cap. 2 – Esempio: differenziazione simbolica – 76 – esercizio Continuo da qui, copio qui.

Exercise 2.58: Suppose we want to modify the differentiation program so that it works with ordinary mathematical notation, in which `+` and `*` are infix rather than prefix operators. Since the differentiation program is defined in terms of abstract data, we can modify it to work with different representations of expressions solely by changing the predicates, selectors, and constructors that define the representation of the algebraic expressions on which the differentiator is to operate.

• Show how to do this in order to differentiate algebraic expressions presented in infix form, such as `(x + (3 * (x + (y + 2))))`. To simplify the task, assume that `+` and `*` always take two arguments and that expressions are fully parenthesized.
• The problem becomes substantially harder if we allow standard algebraic notation, such as `(x + 3 * (x + y + 2))`, which drops unnecessary parentheses and assumes that multiplication is done before addition. Can you design appropriate predicates, selectors, and constructors for this notation such that our derivative program still works?

S- M-expressions! 😯 panico ⚡ Meglio vedere cosa dice Bill the Lizard 👽

We can solve the first part of the problem simply by changing the procedures that define how a sum is represented. Instead of the `+` symbol appearing first in an expression, it will now appear second.

``````(define (make-sum a1 a2)
(cond ((=number? a1 0) a2)
((=number? a2 0) a1)
((and (number? a1) (number? a2)) (+ a1 a2))
(else (list a1 '+ a2))))

(define (sum? x)
(and (pair? x) (eq? (cadr x) '+)))

The definitions for products are equivalent.

``````(define (make-product m1 m2)
(cond ((or (=number? m1 0) (=number? m2 0)) 0)
((=number? m1 1) m2)
((=number? m2 1) m1)
((and (number? m1) (number? m2)) (* m1 m2))
(else (list m1 '* m2))))

(define (product? x)
(and (pair? x) (eq? (cadr x) '*)))

(define (multiplier p) (car p))

a. We can test with a few simple examples before moving to the more complicated example given in the text.

La lista dei `load` diventa lunga ma i files sono sempre quelli dei post precedenti (+ il nuovo `agg-infix.rkt`). b. Only a few additional changes are necessary in order to correctly interpret expressions where unnecessary parentheses are excluded. In part a above we defined both the `augend` and `multiplicand` of an expression using `caddr`. We were able to do this because we knew all expressions would be two parameters separated by an operator, and that the expression would be contained in parentheses.

Since this is no longer the case, we now want the `augend` and `multiplicand` procedures to return an entire subexpression, so we’d like to use `cddr`. The only problem with this is that `cddr` always returns a list, so it will fail in those cases where the `augend` or `multiplicand` is a single value or symbol, as would be the case in fully-parenthesized expressions. We can get around this limitation by introducing a procedure that will simplify sub-expressions of this form by returning a single value or symbol if that’s all there is to an expression.

``````(define (simplify exp)
(if (null? (cdr exp)) (car exp) exp))``````

Now we can define `augend` and `multiplicand` in terms of simplify and `cddr`.

``````(define (augend s) (simplify (cddr s)))
(define (multiplicand p) (simplify (cddr p)))``````

We can test a few different expressions, starting with the example given. Finally, we should also test a few simpler cases to make sure our changes didn’t break anything. Ottimo lavoro da parte di sicp-ex 😁, Drewiki sviluppa solo la prima parte.

🤢

Posta un commento o usa questo indirizzo per il trackback.