# Symbolic Calculus

CS 231 Lecture Examples

```; ; This is a small example of symbolic differentiation adapted from the Scheme ; version in _Programming_Lanugages_,_Concepts_and_Constructs_, First ; Edition, by Ravi Sethi. ; ; We will represent the expressions as lisp lists using the usual lisp ; prefix syntax. For instance, (+ x 2) will mean x + 2. And, (d '(+ x 2)) ; will yield 2. Note that (+) is legal and means 0, and (*) is legal and ; means 1. ; ; ** Basic parts. ** ; In this section we present some simple functions to identify the basic ; parts. (defun is-constant (x) (numberp x)) (defun is-variable (x) (symbolp x)) (defun is-sum (x) (and (listp x) (equal (car x) '+))) (defun is-product (x) (and (listp x) (equal (car x) '*))) ; The functions numberp, symbolp and listp, are built-in predicates ; identifying, respectively, numbers, symbols, and lists. ; ** Main derivative function ** ; This function takes the derivative of an expression. It actually just ; decides what sort of expression it is and farms the work out to ; specialized functions based on the type of expression. (defun d (x E) (cond ((is-constant E) (diff-constant x E)) ((is-variable E) (diff-variable x E)) ((is-sum E) (diff-sum x E)) ((is-product E) (diff-product x E)) (t (error "d: Cannot parse " E)) ) ) ; The (error) function enters a break loop. ; ** Trivial derivatives. ** ; The derivative of a constant is 0, the derivative of a variable with ; respect to itself is 1, with respect to any other variable is 0. (defun diff-constant (x E) 0) (defun diff-variable (x E) (if (equal x E) 1 0) ) ; ** Derivation of sums ** ; For anyone who recalls calculus, the derivative of a sum is the sum of ; the derivatives of the terms. We use mapcar to go through the list ; and take all the derivatives. (defun diff-sum (x E) (cons '+ ; Result is a sum. (mapcar ; Apply to each term. (lambda (term) (d x term)) ; Take the derivative of the term. (cdr E) ; Extract the terms (discard old +) ) ) ) ; ** Derivation of a product ** ; This is done in two steps. The function diff-product takes care of the ; simple cases where there are zero or one factor: (*) or (* subE). The ; more complex cases it passes off to diff-product-args. This is actually ; done to simplify diff-product-args so that it can be written knowing ; there are at least two factors. (defun diff-product (x E) (let* ( (arg-list (cdr E)) ; Just the args, ma'am (num-args (length arg-list)) ; And how may there are. ) (cond ((= num-args 0) 0) ; (*) is 1, deriv is 0. ((= num-args 1) ; (* M), deriv is deriv of M. (d x (car arg-list)) ) (t (diff-product-args x arg-list)) ; Real work here. ) ) ) ; Here is where the real work of the product differentiation is done. It ; receives a list of factors (the leading * having been removed). ; It computes using the chain rule, which says the derivative of UV is ; U times the derivative of V plus V times the derivative of U. That ; is: d(UV) = UdV + VdU. Note that if the product has multiple factors, ; U will be the first one, and V will be the product of all the remaining ones. (defun diff-product-args (x arg-list) (let* ( (U (car arg-list)) ; U is the head of the list. (dU (d x U)) (V (cons '* (cdr arg-list))) ; V is all the rest, so keep *. (dV (d x V)) (UdV (list '* U dV)) (VdU (list '* V dU)) ) (list '+ UdV VdU) ) ) ; The list function simply returns the list of its arguments. ```