FractInt Fractal Types

ant

Generalized Ant Automaton as described in the July 1994 Scientific American. Some ants wander around the screen. A rule string (the first parameter) determines the ant's direction. When the type 1 ant leaves a cell of color k, it turns right if the kth symbol in the first parameter is a 1, or left otherwise. Then the color in the old cell is incremented. The 2nd parameter is a maximum iteration to guarantee that the fractal will terminate. The 3rd parameter is the number of ants. The 4th is the ant type 1 or 2. The 5th parameter determines if the ants wrap the screen or stop at the edge. The 6th parameter is a random seed. You can slow down the ants to see them better using the [x] screen Orbit Delay.

barnsleyj1

Two parameters: real and imaginary parts of c

	z(0) = pixel;
	if real(z) >= 0
	   z(n+1) = (z-1)*c
	else
	   z(n+1) = (z+1)*c

barnsleyj2

Two parameters: real and imaginary parts of c

        z(0) = pixel;
        if real(z(n)) * imag(c) + real(c) * imag(z((n)) >= 0
           z(n+1) = (z(n)-1)*c
        else
           z(n+1) = (z(n)+1)*c

barnsleyj3

Two parameters: real and imaginary parts of c.

        z(0) = pixel;
        if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
           + i * (2*real(z((n)) * imag(z((n))) else
        z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
               + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))

barnsleym1

Parameters are perturbations of z(0)

        z(0) = c = pixel;
        if real(z) >= 0 then
          z(n+1) = (z-1)*c
        else
          z(n+1) = (z+1)*c.

barnsleym2

Parameters are perturbations of z(0)

        z(0) = c = pixel;
        if real(z)*imag(c) + real(c)*imag(z) >= 0
          z(n+1) = (z-1)*c
        else
          z(n+1) = (z+1)*c

barnsleym3

Parameters are perturbations of z(0)

        z(0) = c = pixel;
        if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
           + i * (2*real(z((n)) * imag(z((n))) else
        z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
           + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))

bifurcation

Pictorial representation of a population growth model. Let P = new population, p = oldpopulation, r = growth rate The model is: P = p + r*fn(p)*(1-fn(p)). Three parameters: Filter Cycles, Seed Population, and Function.

bif+sinpi

Bifurcation variation: model is: P = p + r*fn(PI*p). Three parameters: Filter Cycles, Seed Population, and Function.

bif=sinpi

Bifurcation variation: model is: P = r*fn(PI*p). Three parameters: Filter Cycles, Seed Population, and Function.

biflambda

Bifurcation variation: model is: P = r*fn(p)*(1-fn(p)). Three parameters: Filter Cycles, Seed Population, and Function.

bifstewart

Bifurcation variation: model is: P = (r*fn(p)*fn(p)) - 1. Three parameters: Filter Cycles, Seed Population, and Function.

bifmay

Bifurcation variation: model is: P = r*p / ((1+p)^beta). Three parameters: Filter Cycles, Seed Population, and Beta.

cellular

One-dimensional cellular automata or line automata. The type of CA is given by kr, where k is the number of different states of the automata and r is the radius of the neighborhood. The next generation is determined by the sum of the neighborhood and the specified rule. Four parameters: Initial String, Rule, Type, and Starting Row Number.
For Type = 21, 31, 41, 51, 61, 22, 32, 42, 23, 33, 24, 25, 26, 27
Rule = 4, 7, 10, 13, 16, 6, 11, 16, 8, 15, 10, 12, 14, 16 digits

chip

Chip attractor from Michael Peters - orbit in two dimensions.

        z(0) = y(0) = 0;
        x(n+1) = y(n) - sign(x(n)) * cos(sqr(ln(abs(b*x(n)-c))))
                                   * arctan(sqr(ln(abs(c*x(n)-b))))
        y(n+1) = a - x(n)

Parameters are a, b, and c.

circle

      Circle pattern by John Connett
        x + iy = pixel
        z = a*(x^2 + y^2)
        c = integer part of z
        color = c modulo(number of colors)

cmplxmarksjul

      A generalization of the marksjulia fractal.
        z(0) = pixel;
        z(n+1) = (c^exp-1)*z(n)^2 + c.

Four parameters: real and imaginary parts of c, and real and imaginary parts of exponent.

cmplxmarksmand

      A generalization of the marksmandel fractal.
        z(0) = c = pixel;
        z(n+1) = (c^exp-1)*z(n)^2 + c.

Four parameters: real and imaginary parts of perturbation of z(0), and real and imaginary parts of exponent.

complexnewton, complexbasin

Newton fractal types extended to complex degrees. Complexnewton colors pixels according to the number of iterations required to escape to a root. Complexbasin colors pixels according to which root captures the orbit. The equation is based on the newton formula for solving the equation z^p = r

        z(0) = pixel;
        z(n+1) = ((p - 1) * z(n)^p + r)/(p * z(n)^(p - 1)).

Four parameters: real & imaginary parts of degree p and root r.

diffusion

Diffusion Limited Aggregation. Randomly moving points accumulate. Three parameters: border width (default 10), type, and color change rate.

dynamic

Time-discrete dynamic system.

        x(0) = y(0) = start position.
        y(n+1) = y(n) + f( x(n) )
        x(n+1) = x(n) - f( y(n) )
        f(k) = sin(k + a*fn1(b*k))

For implicit Euler approximation: x(n+1) = x(n) - f( y(n+1) ) Five parameters: start position step, dt, a, b, and the function fn1.

fn(z)+fn(pix)

        c = z(0) = pixel;
        z(n+1) = fn1(z) + p*fn2(c)

Six parameters: real and imaginary parts of the perturbation of z(0) and factor p, and the functions fn1, and fn2.

fn(z*z)

        z(0) = pixel;
        z(n+1) = fn(z(n)*z(n))

One parameter: the function fn.

fn*fn

        z(0) = pixel; z(n+1) = fn1(n)*fn2(n)

Two parameters: the functions fn1 and fn2.

fn*z+z

        z(0) = pixel; z(n+1) = p1*fn(z(n))*z(n) + p2*z(n)

Five parameters: the real and imaginary components of p1 and p2, and the function fn.

fn+fn

        z(0) = pixel;
        z(n+1) = p1*fn1(z(n))+p2*fn2(z(n))

Six parameters: The real and imaginary components of p1 and p2, and the functions fn1 and fn2.

formula

Formula interpreter - write your own formulas as text files!

frothybasin

Pixel color is determined by which attractor captures the orbit. The shade of color is determined by the number of iterations required to capture the orbit.

        Z(0) = pixel;  Z(n+1) = Z(n)^2 - C*conj(Z(n))
        where C = 1 + A*i, critical value of A = 1.028713768218725...

gingerbread

Orbit in two dimensions defined by:

        x(n+1) = 1 - y(n) + |x(n)|
        y(n+1) = x(n)

Two parameters: initial values of x(0) and y(0).

halley

        Halley map for the function: F = z(z^a - 1) = 0
        z(0) = pixel;
        z(n+1) = z(n) - R * F / [F' - (F" * F / 2 * F')]
        bailout when: abs(mod(z(n+1)) - mod(z(n)) < epsilon

Four parameters: order a, real part of R, epsilon, and imaginary part of R.

henon

Orbit in two dimensions defined by:

        x(n+1) = 1 + y(n) - a*x(n)*x(n)
        y(n+1) = b*x(n)

Two parameters: a and b

hopalong

Hopalong attractor by Barry Martin - orbit in two dimensions.

        z(0) = y(0) = 0;
        x(n+1) = y(n) - sign(x(n))*sqrt(abs(b*x(n)-c))
        y(n+1) = a - x(n)

Parameters are a, b, and c.

hypercomplex

HyperComplex Mandelbrot set.

        h(0)   = (0,0,0,0)
        h(n+1) = fn(h(n)) + C.
        where "fn" is sin, cos, log, sqr etc.

Two parameters: cj, ck C = (xpixel,ypixel,cj,ck)

hypercomplexj

HyperComplex Julia set.

        h(0)   = (xpixel,ypixel,zj,zk)
        h(n+1) = fn(h(n)) + C.
        where "fn" is sin, cos, log, sqr etc.

Six parameters: c1, ci, cj, ck C = (c1,ci,cj,ck)

icon, icon3d

Orbit in three dimensions defined by:

        p = lambda + alpha * magnitude + beta * (x(n)*zreal - y(n)*zimag)
        x(n+1) = p * x(n) + gamma * zreal - omega * y(n)
        y(n+1) = p * y(n) - gamma * zimag + omega * x(n)
        (3D version uses magnitude for z)

Parameters: Lambda, Alpha, Beta, Gamma, Omega, and Degree

IFS

Barnsley IFS (Iterated Function System) fractals. Apply contractive affine mappings.

julfn+exp

A generalized Clifford Pickover fractal.

        z(0) = pixel;
        z(n+1) = fn(z(n)) + e^z(n) + c.

Three parameters: real & imaginary parts of c, and fn

julfn+zsqrd

        z(0) = pixel;
        z(n+1) = fn(z(n)) + z(n)^2 + c

Three parameters: real & imaginary parts of c, and fn

julia

Classic Julia set fractal.

        z(0) = pixel; z(n+1) = z(n)^2 + c.

Two parameters: real and imaginary parts of c.

julia_inverse

Inverse Julia function - "orbit" traces Julia set in two dimensions. z(0) = a point on the Julia Set boundary; z(n+1) = +- sqrt(z(n) - c) Parameters: Real and Imaginary parts of c Maximum Hits per Pixel (similar to max iters) Breadth First, Depth First or Random Walk Tree Traversal Left or Right First Branching (in Depth First mode only) Try each traversal method, keeping everything else the same. Notice the differences in the way the image evolves. Start with a fairly low Maximum Hit limit, then increase it. The hit limit cannot be higher than the maximum colors in your video mode.

julia(fn||fn)

z(0) = pixel;

        if modulus(z(n)) < shift value, then
           z(n+1) = fn1(z(n)) + c,
        else
           z(n+1) = fn2(z(n)) + c.

Five parameters: real, imag portions of c, shift value, fn1 and fn2.

julia4

Fourth-power Julia set fractals, a special case of julzpower kept for speed.

        z(0) = pixel;
        z(n+1) = z(n)^4 + c.

Two parameters: real and imaginary parts of c.

julibrot

'Julibrot' 4-dimensional fractals.

julzpower

        z(0) = pixel;
        z(n+1) = z(n)^m + c.

Three parameters: real & imaginary parts of c, exponent m

julzzpwr

        z(0) = pixel;
        z(n+1) = z(n)^z(n) + z(n)^m + c.

Three parameters: real & imaginary parts of c, exponent m

kamtorus, kamtorus3d

Series of orbits superimposed. 3d version has 'orbit' the z dimension.

        x(0) = y(0) = orbit/3;
        x(n+1) = x(n)*cos(a) + (x(n)*x(n)-y(n))*sin(a)
        y(n+1) = x(n)*sin(a) - (x(n)*x(n)-y(n))*cos(a)

After each orbit, 'orbit' is incremented by a step size. Parameters: a, step size, stop value for 'orbit', and points per orbit.

lambda

Classic Lambda fractal. 'Julia' variant of Mandellambda.

        z(0) = pixel;
        z(n+1) = lambda*z(n)*(1 - z(n)).

Two parameters: real and imaginary parts of lambda.

lambdafn

        z(0) = pixel;
        z(n+1) = lambda * fn(z(n)).

Three parameters: real, imag portions of lambda, and fn

lambda(fn||fn)

        z(0) = pixel;
        if modulus(z(n)) < shift value, then
           z(n+1) = lambda * fn1(z(n)),
        else
           z(n+1) = lambda * fn2(z(n)).

Five parameters: real, imaginary portions of lambda, shift value, fn1 and fn2.

latoocarfian

Orbit in two dimensions defined by:

         x(n+1) = fn1 (y(n) * b) + c * fn2(x(n) * b)
         y(n+1) = fn3 (x(n) * a) + d * fn4(y(n) * a)

Parameters: a, b, c, d fn1..4 (all sin=original)

lorenz, lorenz3d

Lorenz two lobe attractor - orbit in three dimensions. In 2d the x and y components are projected to form the image.

        z(0) = y(0) = z(0) = 1;
        x(n+1) = x(n) + (-a*x(n)*dt) + (   a*y(n)*dt)
        y(n+1) = y(n) + ( b*x(n)*dt) - (     y(n)*dt) - (z(n)*x(n)*dt)
        z(n+1) = z(n) + (-c*z(n)*dt) + (x(n)*y(n)*dt)

Parameters are dt, a, b, and c.

lorenz3d1

Lorenz one lobe attractor, 3D orbit (Rick Miranda and Emily Stone)

        z(0) = y(0) = z(0) = 1; norm = sqrt(x(n)^2 + y(n)^2)
        x(n+1) = x(n) + (-a*dt-dt)*x(n) + (a*dt-b*dt)*y(n)
           + (dt-a*dt)*norm + y(n)*dt*z(n)
        y(n+1) = y(n) + (b*dt-a*dt)*x(n) - (a*dt+dt)*y(n)
           + (b*dt+a*dt)*norm - x(n)*dt*z(n) - norm*z(n)*dt
        z(n+1) = z(n) +(y(n)*dt/2) - c*dt*z(n)

Parameters are dt, a, b, and c.

lorenz3d3

Lorenz three lobe attractor, 3D orbit (Rick Miranda and Emily Stone)

        z(0) = y(0) = z(0) = 1; norm = sqrt(x(n)^2 + y(n)^2)
        x(n+1) = x(n) +(-(a*dt+dt)*x(n) + (a*dt-b*dt+z(n)*dt)*y(n))/3
            + ((dt-a*dt)*(x(n)^2-y(n)^2)
            + 2*(b*dt+a*dt-z(n)*dt)*x(n)*y(n))/(3*norm)
        y(n+1) = y(n) +((b*dt-a*dt-z(n)*dt)*x(n) - (a*dt+dt)*y(n))/3
            + (2*(a*dt-dt)*x(n)*y(n)
            + (b*dt+a*dt-z(n)*dt)*(x(n)^2-y(n)^2))/(3*norm)
        z(n+1) = z(n) +(3*x(n)*dt*x(n)*y(n)-y(n)*dt*y(n)^2)/2 - c*dt*z(n)

Parameters are dt, a, b, and c.

lorenz3d4

Lorenz four lobe attractor, 3D orbit (Rick Miranda and Emily Stone)

        z(0) = y(0) = z(0) = 1;
        x(n+1) = x(n) +(-a*dt*x(n)^3
           + (2*a*dt+b*dt-z(n)*dt)*x(n)^2*y(n) + (a*dt-2*dt)*x(n)*y(n)^2
           + (z(n)*dt-b*dt)*y(n)^3) / (2 * (x(n)^2+y(n)^2))
        y(n+1) = y(n) +((b*dt-z(n)*dt)*x(n)^3 + (a*dt-2*dt)*x(n)^2*y(n)
           + (-2*a*dt-b*dt+z(n)*dt)*x(n)*y(n)^2
           - a*dt*y(n)^3) / (2 * (x(n)^2+y(n)^2))
        z(n+1) = z(n) +(2*x(n)*dt*x(n)^2*y(n) - 2*x(n)*dt*y(n)^3 - c*dt*z(n))

Parameters are dt, a, b, and c.

lsystem

Using a turtle-graphics control language and starting with an initial axiom string, carries out string substitutions the specified number of times (the order), and plots the resulting.

lyapunov

Derived from the Bifurcation fractal, the Lyapunov plots the Lyapunov Exponent for a population model where the Growth parameter varies between two values in a periodic manner.

magnet1j

        z(0) = pixel;
                  [  z(n)^2 + (c-1)  ] 2
        z(n+1) =  | ---------------- |
                  [  2*z(n) + (c-2)  ]

Parameters: the real and imaginary parts of c

magnet1m

        z(0) = 0; c = pixel;
                  [  z(n)^2 + (c-1)  ] 2
        z(n+1) =  | ---------------- |
                  [  2*z(n) + (c-2)  ]

Parameters: the real & imaginary parts of perturbation of z(0)

magnet2j

        z(0) = pixel;
                  [  z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)         ] 2
        z(n+1) =  |  -------------------------------------------- |
                  [  3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) + 1 ]

Parameters: the real and imaginary parts of c

magnet2m

        z(0) = 0; c = pixel;
                  [  z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)         ] 2
        z(n+1) =  |  -------------------------------------------- |
                  [  3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) + 1 ]

Parameters: the real and imaginary parts of perturbation of z(0)

mandel

Classic Mandelbrot set fractal.

        z(0) = c = pixel;
        z(n+1) = z(n)^2 + c.

Two parameters: real & imaginary perturbations of z(0)

mandel(fn||fn)

        c = pixel;
        z(0) = p1
        if modulus(z(n)) < shift value, then
           z(n+1) = fn1(z(n)) + c,
        else
           z(n+1) = fn2(z(n)) + c.

Five parameters: real, imaginary portions of p1, shift value, fn1 and fn2.

mandelcloud

Displays orbits of Mandelbrot set:

        z(0) = c = pixel;
        z(n+1) = z(n)^2 + c.

One parameter: number of intervals

mandel4

Special case of mandelzpower kept for speed.

        z(0) = c = pixel;
        z(n+1) = z(n)^4 + c.

Parameters: real & imaginary perturbations of z(0)

mandelfn

        z(0) = c = pixel;
        z(n+1) = c*fn(z(n)).

Parameters: real & imaginary perturbations of z(0), and fn

manlam(fn||fn)

        c = pixel;
        z(0) = p1
        if modulus(z(n)) < shift value, then
           z(n+1) = fn1(z(n)) * c, else
           z(n+1) = fn2(z(n)) * c.

Five parameters: real, imaginary parts of p1, shift value, fn1, fn2.

Martin

Attractor fractal by Barry Martin - orbit in two dimensions.

        z(0) = y(0) = 0;
        x(n+1) = y(n) - sin(x(n))
        y(n+1) = a - x(n)

Parameter is a (try a value near pi)

mandellambda

        z(0) = .5; lambda = pixel;
        z(n+1) = lambda*z(n)*(1 - z(n)).

Parameters: real & imaginary perturbations of z(0)

mandphoenix

      z(0) = c = pixel, y(0) = 0;
      For degree = 0:
        z(n+1) = z(n)^2 + c.x + c.y*y(n), y(n+1) = z(n)
      For degree >= 2:
        z(n+1) = z(n)^degree + c.x*z(n)^(degree-1) + c.y*y(n)
        y(n+1) = z(n)
      For degree <= -3:
        z(n+1) = z(n)^|degree| + c.x*z(n)^(|degree|-2) + c.y*y(n)
        y(n+1) = z(n)

Three parameters: real & imaginary perturbations of z(0), and degree.

mandphoenixclx

      z(0) = c = pixel, y(0) = 0;
      For degree = 0:
        z(n+1) = z(n)^2 + c + p2*y(n), y(n+1) = z(n)
      For degree >= 2:
        z(n+1) = z(n)^degree + c*z(n)^(degree-1) + p2*y(n), y(n+1) = z(n)
      For degree <= -3:
        z(n+1) = z(n)^|degree| + c*z(n)^(|degree|-2) + p2*y(n), y(n+1) = z(n)

Five parameters: real & imaginary perturbations of z(0), real & imaginary parts of p2, and degree.

manfn+exp

'Mandelbrot-Equivalent' for the julfn+exp fractal.

        z(0) = c = pixel;
        z(n+1) = fn(z(n)) + e^z(n) + C.

Parameters: real & imaginary perturbations of z(0), and fn

manfn+zsqrd

'Mandelbrot-Equivalent' for the Julfn+zsqrd fractal.

        z(0) = c = pixel;
        z(n+1) = fn(z(n)) + z(n)^2 + c.

Parameters: real & imaginary perturbations of z(0), and fn

manowar

        c = z1(0) = z(0) = pixel;
        z(n+1) = z(n)^2 + z1(n) + c;
        z1(n+1) = z(n);

Parameters: real & imaginary perturbations of z(0)

manowarj

        z1(0) = z(0) = pixel;
        z(n+1) = z(n)^2 + z1(n) + c;
        z1(n+1) = z(n);

Parameters: real & imaginary parts of c

manzpower

'Mandelbrot-Equivalent' for julzpower.

        z(0) = c = pixel;
        z(n+1) = z(n)^exp + c; try exp = e = 2.71828...

Parameters: real & imaginary perturbations of z(0), real & imaginary parts of exponent exp.

manzzpwr

'Mandelbrot-Equivalent' for the julzzpwr fractal.

        z(0) = c = pixel
        z(n+1) = z(n)^z(n) + z(n)^exp + C.

Parameters: real & imaginary perturbations of z(0), and exponent

marksjulia

A variant of the julia-lambda fractal.

        z(0) = pixel;
        z(n+1) = (c^exp-1)*z(n)^2 + c.

Parameters: real & imaginary parts of c, and exponent

marksmandel

A variant of the mandel-lambda fractal.

        z(0) = c = pixel;
        z(n+1) = (c^exp-1)*z(n)^2 + c.

Parameters: real & imaginary parts of perturbations of z(0), and exponent

marksmandelpwr

The marksmandelpwr formula type generalized (it previously had fn=sqr hard coded).

        z(0) = pixel, c = z(0) ^ (z(0) - 1):
        z(n+1) = c * fn(z(n)) + pixel,

Parameters: real and imaginary perturbations of z(0), and fn

newtbasin

Based on the Newton formula for finding the roots of z^p - 1. Pixels are colored according to which root captures the orbit.

        z(0) = pixel;
        z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).

Two parameters: the polynomial degree p, and a flag to turn on color stripes to show alternate iterations.

newton

Based on the Newton formula for finding the roots of z^p - 1. Pixels are colored according to the iteration when the orbit is captured by a root.

        z(0) = pixel;
        z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).

One parameter: the polynomial degree p.

phoenix

      z(0) = pixel, y(0) = 0;
      For degree = 0: z(n+1) = z(n)^2 + p1.x + p2.x*y(n), y(n+1) = z(n)
      For degree >= 2:
       z(n+1) = z(n)^degree + p1.x*z(n)^(degree-1) + p2.x*y(n), y(n+1) = z(n)
      For degree <= -3:
       z(n+1) = z(n)^|degree| + p1.x*z(n)^(|degree|-2) 
	    + p2.x*y(n), y(n+1) = z(n)

Three parameters: real parts of p1 & p2, and degree.

phoenixcplx

      z(0) = pixel, y(0) = 0;
      For degree = 0: z(n+1) = z(n)^2 + p1 + p2*y(n), y(n+1) = z(n)
      For degree >= 2:
        z(n+1) = z(n)^degree + p1*z(n)^(degree-1) + p2*y(n), y(n+1) = z(n)
      For degree <= -3:
        z(n+1) = z(n)^|degree| + p1*z(n)^(|degree|-2) + p2*y(n), y(n+1) = z(n)

Five parameters: real & imaginary parts of p1 & p2, and degree.

pickover

Orbit in three dimensions defined by:

        x(n+1) = sin(a*y(n)) - z(n)*cos(b*x(n))

        y(n+1) = z(n)*sin(c*x(n)) - cos(d*y(n))
        z(n+1) = sin(x(n))

Parameters: a, b, c, and d.

plasma

Random, cloud-like formations. Requires 4 or more colors. A recursive algorithm repeatedly subdivides the screen and colors pixels according to an average of surrounding pixels and a random color, less random as the grid size decreases. Four parameters: 'graininess' (.5 to 50, default = 2), old/new algorithm, seed value used, 16-bit out output selection.

popcorn

The orbits in 2D are plotted superimposed:

		  x(0) = xpixel, y(0) = ypixel;
		  x(n+1) = x(n) - real(h * fn1( y(n) + fn2(C * y(n) ))
						- imag(h * fn3( x(n) + fn4(C * x(n) ))
		  y(n+1) = y(n) - real(h * fn3( x(n) + fn4(C * x(n) ))
						- imag(h * fn1( y(n) + fn2(C * y(n) ))

Parameters: step size h, C, functions fn1..4 (original: sin,tan,sin,tan).

popcornjul

		  x(0) = xpixel, y(0) = ypixel;
		  x(n+1) = x(n) - real(h * fn1( y(n) + fn2(C * y(n) ))
						- imag(h * fn3( x(n) + fn4(C * x(n) ))
		  y(n+1) = y(n) - real(h * fn3( x(n) + fn4(C * x(n) ))
						- imag(h * fn1( y(n) + fn2(C * y(n) ))

quadruptwo

Quadruptwo attractor from Michael Peters - orbit in two dimensions.

        z(0) = y(0) = 0;
        x(n+1) = y(n) - sign(x(n)) * sin(ln(abs(b*x(n)-c)))
                                   * arctan(sqr(ln(abs(c*x(n)-b))))
        y(n+1) = a - x(n)

Parameters are a, b, and c.

quatjul

Quaternion Julia set.

        q(0)   = (xpixel,ypixel,zj,zk)
        q(n+1) = q(n)*q(n) + c.

Four parameters: c, ci, cj, ck c = (c1,ci,cj,ck)

quat

Quaternion Mandelbrot set.

        q(0)   = (0,0,0,0)
        q(n+1) = q(n)*q(n) + c.

Two parameters: cj,ck c = (xpixel,ypixel,cj,ck)

rossler3D

Orbit in three dimensions defined by:

        x(0) = y(0) = z(0) = 1;
        x(n+1) = x(n) - y(n)*dt -   z(n)*dt
        y(n+1) = y(n) + x(n)*dt + a*y(n)*dt
        z(n+1) = z(n) + b*dt + x(n)*z(n)*dt - c*z(n)*dt

Parameters are dt, a, b, and c.

sierpinski

Sierpinski gasket - Julia set producing a 'Swiss cheese triangle'

        z(n+1) = (2*x,2*y-1) if y > .5;
            else (2*x-1,2*y) if x > .5;
            else (2*x,2*y)

No parameters.

spider

        c(0) = z(0) = pixel;
        z(n+1) = z(n)^2 + c(n);
        c(n+1) = c(n)/2 + z(n+1)

Parameters: real & imaginary perturbation of z(0)

sqr(1/fn)

        z(0) = pixel;
        z(n+1) = (1/fn(z(n))^2

One parameter: the function fn.

sqr(fn)

        z(0) = pixel;
        z(n+1) = fn(z(n))^2

One parameter: the function fn.

test

'test' point letting us (and you!) easily add fractal types via the c module testpt.c. Default set up is a mandelbrot fractal. Four parameters: user hooks (not used by default testpt.c).

tetrate

        z(0) = c = pixel;
        z(n+1) = c^z(n)

Parameters: real & imaginary perturbation of z(0)

threeply

Threeply attractor by Michael Peters - orbit in two dimensions.

        z(0) = y(0) = 0;
        x(n+1) = y(n) - sign(x(n)) * (abs(sin(x(n))*cos(b)
                                      +c-x(n)*sin(a+b+c)))
        y(n+1) = a - x(n)

Parameters are a, b, and c.

tim's_error

A serendipitous coding error in marksmandelpwr brings to life an ancient pterodactyl! (Try setting fn to sqr.)

        z(0) = pixel, c = z(0) ^ (z(0) - 1):
        tmp = fn(z(n))
        real(tmp) = real(tmp) * real(c) - imag(tmp) * imag(c);
        imag(tmp) = real(tmp) * imag(c) - imag(tmp) * real(c);
        z(n+1) = tmp + pixel;

Parameters: real & imaginary perturbations of z(0) and function fn

unity

        z(0) = pixel;
        x = real(z(n)), y = imag(z(n))
        One = x^2 + y^2;
        y = (2 - One) * x;
        x = (2 - One) * y;
        z(n+1) = x + i*y

No parameters.

volterra-lotka

Volterra-Lotka fractal from The Beauty of Fractals

        x(0) = xpixel, y(0) = ypixel;
        dx/dt =  x - xy = f(x,y)
        dy/dt = -y + xy = g(x,y)
        x(new) = x + h/2 * [ f(x,y) + f[x + pf(x,y), y + pg(x,y)] ]
        y(new) = y + h/2 * [ g(x,y) + g[x + pf(x,y), y + pg(x,y)] ]

Two parameters: h and p
Recommended: zmag or bof60 inside coloring options

escher_julia

Escher-like tiling of Julia sets from The Science of Fractal Images

        z(0) = pixel
        z(n+1) = z(n)^2 + (0, 0i)

The target set is a second, scaled, Julia set:

        T = [ z: | (z * 15.0)^2 + c | < BAILOUT ]

Two parameters: real and imaginary parts of c
Iteration count and bailout size apply to both Julia sets.

Summary of Fractal Types