Here is a way to display a fractal form without plotting every
pixel. I developed the following procedure
at a time when generating a good mandelbrot graphic on a macintosh 68000 
based system took several hours.  

The idea is to trace the edge of a fractal, rather than plotting
every point.  The algorithm used is that which is used for tracing
a path through a maze. It is in essence, always move forward, keeping
the wall of the maze on your right shoulder.  
When you touch a wall and cannot move forward, turn to the left. 
Continue to try to move forward in this manner, always keeping the wall
on your right.
 
To trace a fractal region, consider the edge of the fractal region, as the
wall. First locate a point on the edge of the fractal region.  Probe to 
the left to determine if that is a point OUTSIDE of the region.  
If it is possible to move the current point to that location 
while the point ahead and to the right is in the fractal region, do it. 
Otherwise rotate the current direction by 90 degrees and repeat 
(try to move forward, etc)

The following listing provides a c version of this procedure. 

julia(j,i)
int j, i ;
{
	int vstep, hstep, vpos, hpos, temporary ;
	int vs, hs, vp, hp, it, jt ;
	p = j ;
	q = i ;
	vstep = -1 ;
	hstep = 0 ;
	vs = 1 ;
	hs = 0 ;
	for(i = 0,j = 0 ; jvalue(j,i) >= terrace ; j++) ;
	it = i ;
	jt = j ;
while(0 == 0) {
	while(kbhit() == 0)  {
		hpos = j + hstep ;
		vpos = i + vstep ;
		if(jvalue(hpos,vpos) < terrace)  {
			temporary = vstep ;
			vstep = -hstep ;
			hstep = temporary ;
			_setcolor(2) ;
			_setpixel(j,i) ;
			continue ;
		}
		hpos = j - vstep ;
		vpos = i+ hstep ;
		if(jvalue(hpos,vpos) >= terrace)  {
			i = i + vstep ;
			j = j + hstep ;
			_setcolor(2) ;
			_setpixel(j,i) ;
			continue ;
		}
		i = i + vstep ;
		j = j + hstep ;
		_setcolor(2) ;
		_setpixel(j,i) ;
		i = i + hstep ;
		j = j - vstep ;
		temporary = vstep ;
		vstep = hstep ;
		hstep = -temporary ;
		_setcolor(2) ;
		_setpixel(j,i) ;
		hp = jt + hs ;
		vp = it + vs ;
		if(jvalue(hp,vp) < terrace)  {
			temporary = vs ;
			vs = hs ;
			hs = -temporary ;
			_setcolor(3) ;
			_setpixel(jt,it) ;
			continue ;
}
Using this kind of procedure, a very detailed outline of a Julia set
can be generated in under 30 seconds.  A pixel-by-pixel image at the same
resolution on the same processor might require 10 minutes.

I wrote another version of this, which is used to create a sequence
of postscript commands which outlines an area that is then filled
using the postscript fill command. That version is not as handy as
this (its on another system) but if you have a specific interest, just
drop me a line and I will pass it along.

John Bailey
http://www.servtech.com/public/jmb184/