-
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
-
z(0) = pixel;
if real(z) >= 0
z(n+1) = (z-1)*c
else
z(n+1) = (z+1)*c
Two parameters: real and imaginary parts of c
-
barnsleyj2
-
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
Two parameters: real and imaginary parts of c
-
barnsleyj3
-
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))
Two parameters: real and imaginary parts of c.
-
barnsleym1
-
z(0) = c = pixel;
if real(z) >= 0 then
z(n+1) = (z-1)*c
else
z(n+1) = (z+1)*c.
Parameters are perturbations of z(0)
-
barnsleym2
-
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
Parameters are perturbations of z(0)
-
barnsleym3
-
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))
Parameters are perturbations of z(0)
-
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. Two parameters: border width (default 10), type.
-
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.
-
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) - h*sin(y(n) + tan(3*y(n))
y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n))
One parameter: step size h.
-
popcornjul
-
Conventional Julia using the popcorn formula:
x(0) = xpixel, y(0) = ypixel;
x(n+1) = x(n) - h*sin(y(n) + tan(3*y(n))
y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n))
One parameter: step size h.
-
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.