Perhaps look at the 'common techniques for generating fractals' section under 'fractal' in wikipedia.

Or

http://library.thinkquest.org/26242/full/types/types.htmlYou could classify them roughly based on what sort of algorithm you use, e.g. Iterated Function System vs Escape Time Fractal, cellular automata etc, but this isn't classifying the fractal itself, just how it is built. For example the Sierpinski triangle can be built using IFS, escape time fractal or a cellular automata... it gives exactly the same shape.

Don't forget "coloring odd/even numbers in Pascal's Triangle".

There seem to be a few broad universality-classes, as well as sporadics, there.

Universality-class 1: traditional Mandelbrot/Julia and similar. Result from iterating pretty much any continuous function from

**C** to

**C**, for reasons that are fairly well understood at this point.

Universality-class 2a: "Ducks" fractal patterns. These likewise result from nonexpanding piecewise-linear functions with V shapes iterated on

**R**^{n}. Examples include the Kaliset, Ducks itself, and the stuff you see inside the Burning Ship interior with exponential smoothing.

Universality-class 2b: using

*expanding* piecewise-linear functions gives nonescaping point sets equal to IFS attractors (IFS being just inverse-iteration of these systems). These systems include the exterior of Burning Ship, too. Class 2 as a whole includes systems like Burning Ship where the behavior changes with a parameter.

Universality-class 3: the "overlapping horns" patterns in parameter spaces of real-valued systems with transitions to chaos. Examples: Henon, discrete Volterra-Lotka, and the system you get by alternating real-valued

*rx*(1 -

*x*) and

*sx*(1 -

*x*) (which has a 2-dimensional parameter space, though a 1-dimensional dynamic space). One can take the latter and change the pattern of alternation of using

*r* and using

*s*; this can be regarded as defining

*F*(

*x*) =

*rx*(1 -

*x*) and

*G*(

*x*) =

*sx*(1 -

*x*) and then

*H*(

*x*) =

*F*(

*G*(

*x*)),

*G*(

*F*(

*F*(

*x*)), or other such function composition of

*F* and

*G* and then iterating

*H*. The resulting parameter-space fractals (plot Lyapunov exponent for nifty results) are in the same class again. Some systems (V-L but none of the others specified above) contain rotation and can produce limit-circle attractors in addition to strange and cyclic attractors. A limit circle is mapped into itself by an irrational rotation, unlike a strange attractor that may look circular but has chaotic motion on it. When limit circles occur, one can also get discrete cycles and a new class of strange attractor alongside the limit circles in parameter space. Plotting Lyapunov exponents can reveal these different behaviors, especially if you measure different parts of the Jacobian.

One more large class of fractals: the shapes found in the Mandelbox, Kalibox, and similar things that combine folds with ballfold. Technically, those are piecewise-linear in one part of their domain but have a 1/(

*x* -

*P*)-like nonlinear hyperbolic behavior in another; call them piecewise-linear-and-hyperbolic. With boxlike folding planes one gets classic Mandelbox/Kalibox architecture; a variety of organic forms with Ducks elements emerge with rotated folding planes, but accompanied by the holes and escaping regions associated with ballfold, producing a wide variety of trusses, sinews, celery-sticks, blobs, landscapey surfaces, and other features, including IFSish features such as trees and Ducksish embossings of surfaces.

And then there's things like the Mandelbulb and other unclassified fractals in, usually, >2 dimensions. If there is a broader class containing the Mandelbulb I'm not sure what it is. The simplest broader class I can think of would treat the order-

*n* bulb iteration function as computing

*x*^{n} and iterate some polynomial in

*x*, where the addition and scalar-multiplication of individual powers of

*x* was vector addition and scalar multiplication in

**R**^{n}. One should be able to generalize further to the equivalent of all analytic functions on

**C** by extending "polynomials", above, to "power series". That would require a monstrous GPU from Captain Kirk's era to be tractable for producing decent, large images in a reasonable time, however! Analogues of exponential, sine, and cosine can certainly be constructed this way, just by using those functions' well-known power series expansions. (One can likewise compute things like the sine of a matrix or the exponential of a

*p*-adic number, strange though that sounds.)