9209 Rate this article:
No rating

List extensions, part II


(Note: This is the second part of Ron Kneusel’s discussion of his extensions to the IDL 8 list datatype.) At this point, we have extended the List class in several ways. Now, let's take a quick look at using the List class to do some symbolic math in IDL. Download the files dx_plot.pro and dx.pro. Since they use both list_extensions.pro and lisp.pro, make sure you have these, as well. This small application accepts a symbolic expression as an S-expression (the Function) and calculates the first derivative symbolically; it then plots the derivative. Before we start, note that DX_PLOT is an example of how to create an IDL application using objects. Now, let's consider a plot of the derivative of:

y = 3 cos(5x2)

which as an S-expression is written as:

(* 3 (cos (* 5 (^ x 2))))

The derivative is computed in the function DX (in dx.pro) which accepts a list representing the entered S-expression, calls DX_DERIV and then passes the derivative output list to DX_INFIX which converts it to a fully parenthesized infix expression. No simplification of the output of DX_DERIV is performed, but this does not matter since IDL will interpret it properly anyway. (For the moment we are ignoring how this happens, but see the file lambda.pro. More on LAMBDA in a future post.) The derivative is found using the standard rules:

 function dx_deriv, f compile_opt idl2 on_error, 2 case 1 of (~is_list(f)) : ans = (size(f,/type) ne 7) ? '0' : (f eq 'x') ? '1' : '0' (f[0] eq '+') : ans = list('+', dx_deriv(f[1]), dx_deriv(f[2])) (f[0] eq '-') : ans = list('-', dx_deriv(f[1]), dx_deriv(f[2])) (f[0] eq '*') : ans = list('+', list('*', dx_deriv(f[1]), f[2]), list('*', f[1], dx_deriv(f[2]))) (f[0] eq '/') : ans = list('/', list('-', list('*', dx_deriv(f[1]), f[2]), list('*', dx_deriv(f[2]), f[1])), list('*', f[2], f[2])) (f[0] eq 'sin') : ans = list('*', list('cos', f[1]), dx_deriv(f[1])) (f[0] eq 'cos') : ans = list('*', list('_', list('sin', f[1])), dx_deriv(f[1])) (f[0] eq 'tan') : ans = list('*', list('sec^2', f[1]), dx_deriv(f[1])) (f[0] eq 'exp') : ans = list('*', list('exp', f[1]), dx_deriv(f[1])) (f[0] eq 'ln') : ans = list('/', dx_deriv(f[1]), f[1]) (f[0] eq '_') : ans = list('_', dx_deriv(f[1])) (f[0] eq '^') : ans = list('*', list('*', f[2], list('^', f[1], list('-', f[2], 1))), dx_deriv(f[1])) else: ans = 'Syntax error!' endcase return, ans end

Note here how the IDL CASE statement is being used. In this form it operates exactly like the Lisp (cond ...) function which allows us to test conditions sequentially. Note also the recursive nature of the calls which automatically handle evaluating sublists and that we are using '_' (underscore) as negation reserving '-' (minus) exclusively for subtraction. Conversion to infix is done with DX_INFIX:

 function dx_infix, f compile_opt idl2 on_error, 2 case 1 of (~is_list(f)) : ans = f (f[0] eq '+') : ans = list(dx_infix(f[1]), '+', dx_infix(f[2])) (f[0] eq '-') : ans = list(dx_infix(f[1]), '-', dx_infix(f[2])) (f[0] eq '*') : ans = list(dx_infix(f[1]), '*', dx_infix(f[2])) (f[0] eq '/') : ans = list(dx_infix(f[1]), '/', dx_infix(f[2])) (f[0] eq '_') : ans = list('-', dx_infix(f[1])) (f[0] eq 'sin') : ans = list('sin(', dx_infix(f[1]),')') (f[0] eq 'cos') : ans = list('cos(', dx_infix(f[1]),')') (f[0] eq 'tan') : ans = list('tan(', dx_infix(f[1]),')') (f[0] eq 'sec^2') : ans = list('(1.0/cos(', dx_infix(f[1]),'))^2') (f[0] eq 'exp') : ans = list('exp(', dx_infix(f[1]),')') (f[0] eq 'ln') : ans = list('log(', dx_infix(f[1]),')') (f[0] eq '^') : ans = list(dx_infix(f[1]), '^', dx_infix(f[2])) else: ans = 'Syntax error!' endcase return, ans end

This function also makes use of the "cond" CASE statement and recursion. Lastly, the plot of the derivative is shown with the DX_PLOT application: Ron Kneusel's DX_PLOT window Since the derivative of y = 3cos(5x2) is, as an S-expression:

 ( (0 * (cos( (5 * (x ^ 2)) ))) + (3 * ( (- (sin( (5 * (x ^ 2)) ))) * ( (0 * (x ^ 2)) + (5 * ( (2 * (x ^ (2 - 1))) * 1))))))

It is not hard to add easy simplification rules to the output to remove things like multiply by 0 and 1. We leave this as an exercise for the reader. :) We have given here a potpourri of List examples. We hope that they are useful to you and encourage you to explore the power of IDL's List (and Hash!) classes. In a future post we will use List in implementing higher-order functions which brings some of the power of functional programming to IDL.