No rating

# List extensions, part II

Mark Alonzo
(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: 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.
MOST RECENT

### Hurricane Florence Support

9/13/2018

Are you or your loved ones in the path of Hurricane Florence, or is it your job to keep people safe?... more »

### Harris Providing real-time access to traffic camera network for hyper-local weather info: open access during Florence

9/12/2018

Hurricane Florence is closing in on the South and North Carolina Coast.  The storm is strong and... more »