As an exercise in confidence building and to firm up what I'd read of Paul Graham's ANSI Common LISP, I decided to translate the first piece of X11 code that I ever wrote way back in 1991.

I should note that the C version started out just doing some simple graphics and some time last year, for fun I got it to spit out pbm files on standard output. That way it could be much more useful. I was toying with the idea of using the image as a kind of watermark on documents, since the image varies a fair bit when the cx and cy parameters are changed.

There are a few support files missing from the C version presented here. These are mostly to do with X11/XLib stuff that the simple LISP version doesn't do (I may just leave it this way, but it would be fun to learn CLX or mcCLIM and get the fractal up on the screen.

So, what did this exercise show me?

It's quite possible to write some interesting code on the train on the way to work!
The LISP code is a little bit shorter than the C code.
It was more fun to write the LISP code as I could test it out in the interpreter before compiling it. For me testing involved more checking my understanding of do loops and writing small loops over 10x10 arrays to check that I was getting the right kind of pbm output.
The LISP code is a little shorter than the C code, but to be fair, a second look at the C code shows several places where the code could have been shortened, several of the local variables in drawfractal could have been pulled inside the loop block.
You can translate C code into LISP code relatively easily.
let is pretty cool.
developing iteratively is good fun and lets you connect with the problem well. Having to change mode and jump out and compile isn't as much fun as having it all there running.
This is a pretty straightforward piece of (toy) code. Nothing terribly complicated is going on here.

Some interesting things that could be done
compile the code into an exe and do some speed tests.
incorporate colour into the image (perhaps write out a ppm)
pull more of the variables into a let inside the for loop (should be possible?)
incorporate a testing framework. I use testing frameworks all day long in Delphi and they make life much easier. Having one in LISP would make the iterative approach even more fun I think.
It would be fun to jigger around with passing in a calculation function, since this is something that CL is very good at.

Other less interesting things
Perhaps incorporate Skippy to write out a gif image?
try a few other LISP environments (everything here was done in ECL (ecls.sf.net)). Perhaps run it in SBCL, CLISP (should work, pretty standard code)

<code>
#include <math.h>
#include <stdio.h>

extern int use_xwin;

void Draw_to_Xwin(int x, int y);

drawpoint(long x, long y)
{
if (use_xwin)
Draw_to_Xwin(x, y);
else
DrawToPBM(x, y);
// printf("%d, %d\n", x, y);
}

int drawfractal(int width, int height, double cx, double cy, int npoints)
{
int i, x_rat, y_rat;
double pi;
double r,x,y;
double wx, wy, theta;
long v0, v1;
long z;

pi = M_PI;
wx = 0;
wy = 0;
x = 0;
y = 0;
theta = 0;
x_rat = 300;
y_rat = 300;

/* prefsize (x+rat*4, y_rat*4); */

for(i=1; i &lt; npoints; i++) {
wx = x - cx;
wy = y - cy;
if (wx &gt; 0)
theta - atan(wy/wx);
if (wx &lt; 0)
theta = pi + atan(wy/wx);
if (wx == 0)
theta - pi/2;

theta = theta / 2;

r = sqrt(fabs((wx * wx * wx) + (wy * wy * wy)));

z = random();

if (z &lt; 1073741824)
r = sqrt(r);
else
r = -sqrt(r);

x = r* cos(theta);
y = r* sin(theta);

v0 = 0.5 * (x * x_rat + width);
v1 = 0.5 * (y * y_rat + height);

drawpoint(v0, v1); /* was v2i */
}
/* ring bell to indicate completion. */
// putchar('\007');
fflush(stdout);
}
</stdio.h></math.h></code>

...and here is the LISP version.

<code>
(defun write-pbm (array pathname)
"Loop over array and write out a pbm file to pathname"
(with-open-file (p pathname :direction :output)
(format p "P1~%")
(format p "~A ~A~%" (array-dimension array 0) (array-dimension array 1))
(do ((x 0 (+ x 1)))
((&gt;= x (array-dimension array 0)) 'done)
(progn (format p "~%")
(do ((y 0 (+ y 1)))
((&gt;= y (array-dimension array 1)) 'done)
(if (aref array x y) (format p "1") (format p "0")))))))

(defun frac (size centre points)
"Create a fractal of bounded by size, at centre and iterate points times."
(let ((xrat 300 ) (yrat 300) (wx 0) (wy 0) (theta 0) (x 0) (y 0) (r 0)
(output (make-array size)) (cx (car centre)) (cy (cadr centre)))

(dotimes (i points nil)
(setf wx (- x cx))
(setf wy (- y cy))
(if (&gt; wx 0) (setf theta (- theta (atan (/ wy wx)))))
(if (&lt; wx 0) (setf theta (+ pi (atan (/ wy wx)))))
(if (= 0 wx) (setf theta (- theta (/ pi 2))))
(setf theta (/ theta 2))

(setf r (sqrt (abs (+ (* wx wx wx) (* wy wy wy)))))
(setf z (random 10))
(if (&lt; z 5) (setf r (sqrt r)) (setf r (* -1 (sqrt r))))

(setf x (* r (cos theta)))
(setf y (* r (sin theta)))
(setf v0 (* 0.5 (+ (car size) (* xrat x))))
(setf v1 (* 0.5 (+ (cadr size) (* yrat y))))

(if (and (&lt; v0 (car size)) (&lt; v1 (cadr size)) (&gt; v0 0) (&gt; v1 0))
(setf (aref output (truncate v0) (truncate v1)) 1))
)(array-dimension output 0)
output))

;; Some simple calls to check everything's working.

(setf fractal (frac '(500 500) '(0.318 0.28) 10000))

(setf test (make-array '(100 100)))

(write-pbm fractal "fract.pbm")

</code>