separator bar
FractInt heading title image.
separator bar

Summary of 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
Julia using the generalized Pickover Popcorn formula:
		  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).

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.

separator bar Return to FractInt's Home Page,   or to the FractInt Information index,   or to Spanky's Home Page. separator bar This page was last updated on:   September 18, 2010
HTML 4.01 Checked!     web page counter     Notepad
separator bar