screen Orbit Delay.
{=HT_BARNS barnsleyj1}
~Label=HF_BARNSJ1
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
{=HT_BARNS barnsleyj2}
~Label=HF_BARNSJ2
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
{=HT_BARNS barnsleyj3}
~Label=HF_BARNSJ3
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.
{=HT_BARNS barnsleym1}
~Label=HF_BARNSM1
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)
{=HT_BARNS barnsleym2}
~Label=HF_BARNSM2
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)
{=HT_BARNS barnsleym3}
~Label=HF_BARNSM3
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)
{=HT_BIF bifurcation}
~Label=HF_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.
{=HT_BIF bif+sinpi}
~Label=HF_BIFPLUSSINPI
Bifurcation variation: model is: P = p + r*fn(PI*p).
Three parameters: Filter Cycles, Seed Population, and Function.
{=HT_BIF bif=sinpi}
~Label=HF_BIFEQSINPI
Bifurcation variation: model is: P = r*fn(PI*p).
Three parameters: Filter Cycles, Seed Population, and Function.
{=HT_BIF biflambda}
~Label=HF_BIFLAMBDA
Bifurcation variation: model is: P = r*fn(p)*(1-fn(p)).
Three parameters: Filter Cycles, Seed Population, and Function.
{=HT_BIF bifstewart}
~Label=HF_BIFSTEWART
Bifurcation variation: model is: P = (r*fn(p)*fn(p)) - 1.
Three parameters: Filter Cycles, Seed Population, and Function.
{=HT_BIF bifmay}
~Label=HF_BIFMAY
Bifurcation variation: model is: P = r*p / ((1+p)^beta).
Three parameters: Filter Cycles, Seed Population, and Beta.
~OnlineFF
{=HT_CELLULAR cellular}
~Label=HF_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
{=HT_MARTIN chip}
~Label=HF_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.
~OnlineFF
{=HT_CIRCLE circle}
~Label=HF_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)
{=HT_MARKS cmplxmarksjul}
~Label=HF_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.
{=HT_MARKS cmplxmarksmand}
~Label=HF_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.
~OnlineFF
{=HT_NEWTCMPLX complexnewton\, complexbasin}
~Label=HF_COMPLEXNEWT
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.
{=HT_DIFFUS diffusion}
~Label=HF_DIFFUS
Diffusion Limited Aggregation. Randomly moving points
accumulate. Three parameters: border width (default 10), type,
and color change rate.
~OnlineFF
{=HT_DYNAM dynamic}
~Label=HF_DYNAM
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.
{=HT_SCOTSKIN fn(z)+fn(pix)}
~Label=HF_FNPLUSFNPIX
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.
{=HT_SCOTSKIN fn(z*z)}
~Label=HF_FNZTIMESZ
z(0) = pixel;
z(n+1) = fn(z(n)*z(n))
One parameter: the function fn.
~OnlineFF
{=HT_SCOTSKIN fn*fn}
~Label=HF_FNTIMESFN
z(0) = pixel; z(n+1) = fn1(n)*fn2(n)
Two parameters: the functions fn1 and fn2.
{=HT_SCOTSKIN fn*z+z}
~Label=HF_FNXZPLUSZ
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.
{=HT_SCOTSKIN fn+fn}
~Label=HF_FNPLUSFN
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.
{=HT_FORMULA formula}
Formula interpreter - write your own formulas as text files!
~OnlineFF
{=HT_FROTH frothybasin}
~Label=HF_FROTH
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...
{=HT_GINGER gingerbread}
~Label=HF_GINGER
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).
{=HT_HALLEY halley}
~Label=HF_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.
~OnlineFF
{=HT_HENON henon}
~Label=HF_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
{=HT_MARTIN hopalong}
~Label=HF_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.
~FF
{=HT_HYPERC hypercomplex}
~Label=HF_HYPERC
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)
{=HT_HYPERC hypercomplexj}
~Label=HF_HYPERCJ
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)
~OnlineFF
{=HT_ICON icon, icon3d}
~Label=HF_ICON
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
{=HT_IFS IFS}
Barnsley IFS (Iterated Function System) fractals. Apply
contractive affine mappings.
{=HT_PICKMJ julfn+exp}
~Label=HF_JULFNPLUSEXP
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
{=HT_PICKMJ julfn+zsqrd}
~Label=HF_JULFNPLUSZSQRD
z(0) = pixel;
z(n+1) = fn(z(n)) + z(n)^2 + c
Three parameters: real & imaginary parts of c, and fn
{=HT_JULIA julia}
~Label=HF_JULIA
Classic Julia set fractal.
z(0) = pixel; z(n+1) = z(n)^2 + c.
Two parameters: real and imaginary parts of c.
{=HT_INVERSE julia_inverse}
~Label=HF_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.
~OnlineFF
{=HT_FNORFN julia(fn||fn)}
~Label=HF_JULIAFNFN
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, fn2.
{=HT_MANDJUL4 julia4}
~Label=HF_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.
{=HT_JULIBROT julibrot}
'Julibrot' 4-dimensional fractals.
{=HT_PICKMJ julzpower}
~Label=HF_JULZPOWER
z(0) = pixel;
z(n+1) = z(n)^m + c.
Three parameters: real & imaginary parts of c, exponent m
{=HT_PICKMJ julzzpwr}
~Label=HF_JULZZPWR
z(0) = pixel;
z(n+1) = z(n)^z(n) + z(n)^m + c.
Three parameters: real & imaginary parts of c, exponent m
{=HT_KAM kamtorus, kamtorus3d}
~Label=HF_KAM
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.
{=HT_LAMBDA lambda}
~Label=HF_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.
{=HT_LAMBDAFN lambdafn}
~Label=HF_LAMBDAFN
z(0) = pixel;
z(n+1) = lambda * fn(z(n)).
Three parameters: real, imag portions of lambda, and fn
{=HT_FNORFN lambda(fn||fn)}
~Label=HF_LAMBDAFNFN
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, imag portions of lambda, shift value, fn1, fn2
{=HT_LATOO latoocarfian}
~Label=HF_LATOO
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)
~OnlineFF
{=HT_LORENZ lorenz, lorenz3d}
~Label=HF_LORENZ
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.
{=HT_LORENZ lorenz3d1}
~Label=HF_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.
~OnlineFF
{=HT_LORENZ lorenz3d3}
~Label=HF_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.
~OnlineFF
{=HT_LORENZ lorenz3d4}
~Label=HF_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.
{=HT_LSYS 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 result.
{=HT_LYAPUNOV 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.
{=HT_MAGNET magnet1j}
~Label=HF_MAGJ1
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
{=HT_MAGNET magnet1m}
~Label=HF_MAGM1
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)
{=HT_MAGNET magnet2j}
~Label=HF_MAGJ2
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
~OnlineFF
{=HT_MAGNET magnet2m}
~Label=HF_MAGM2
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)
{=HT_MANDEL mandel}
~Label=HF_MANDEL
Classic Mandelbrot set fractal.
z(0) = c = pixel;
z(n+1) = z(n)^2 + c.
Two parameters: real & imaginary perturbations of z(0)
{=HT_FNORFN mandel(fn||fn)}
~Label=HF_MANDELFNFN
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.
{=HT_MANDELCLOUD mandelcloud}
~Label=HF_MANDELCLOUD
Displays orbits of Mandelbrot set:
z(0) = c = pixel;
z(n+1) = z(n)^2 + c.
One parameter: number of intervals
{=HT_MANDJUL4 mandel4}
~Label=HF_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)
{=HT_MANDFN mandelfn}
~Label=HF_MANDFN
z(0) = c = pixel;
z(n+1) = c*fn(z(n)).
Parameters: real & imaginary perturbations of z(0), and fn
~OnlineFF
{=HT_FNORFN manlam(fn||fn)}
~Label=HF_MANLAMFNFN
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.
{=HT_MARTIN Martin}
~Label=HF_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)
{=HT_MLAMBDA mandellambda}
~Label=HF_MLAMBDA
z(0) = .5; lambda = pixel;
z(n+1) = lambda*z(n)*(1 - z(n)).
Parameters: real & imaginary perturbations of z(0)
~OnlineFF
{=HT_PHOENIX mandphoenix}
~Label=HF_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.
{=HT_PHOENIX mandphoenixclx}
~Label=HF_MANDPHOENIXCPLX
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.
{=HT_PICKMJ manfn+exp}
~Label=HF_MANDFNPLUSEXP
'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
{=HT_PICKMJ manfn+zsqrd}
~Label=HF_MANDFNPLUSZSQRD
'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
{=HT_SCOTSKIN manowar}
~Label=HF_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)
~OnlineFF
{=HT_SCOTSKIN manowarj}
~Label=HF_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
{=HT_PICKMJ manzpower}
~Label=HF_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.
{=HT_PICKMJ manzzpwr}
~Label=HF_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
~OnlineFF
{=HT_MARKS marksjulia}
~Label=HF_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
{=HT_MARKS marksmandel}
~Label=HF_MARKSMAND
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
{=HT_MARKS marksmandelpwr}
~Label=HF_MARKSMANDPWR
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
~OnlineFF
{=HT_NEWTBAS newtbasin}
~Label=HF_NEWTBAS
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.
{=HT_NEWT newton}
~Label=HF_NEWT
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.
~OnlineFF
{=HT_PHOENIX phoenix}
~Label=HF_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.
{=HT_PHOENIX phoenixcplx}
~Label=HF_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.
~OnlineFF
{=HT_PICK pickover}
~Label=HF_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.
{=HT_PLASMA plasma}
~Label=HF_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' (0, 0.125 to 100, default = 2),
old/new algorithm, seed value used, 16-bit out output selection.
~OnlineFF
{=HT_POPCORN popcorn}
~Label=HF_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).
{=HT_POPCORN popcornjul}
~Label=HF_POPCJUL
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).
~OnlineFF
{=HT_MARTIN quadruptwo}
~Label=HF_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.
{=HT_QUAT quatjul}
~Label=HF_QUATJ
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)
{=HT_QUAT quat}
~Label=HF_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)
{=HT_ROSS rossler3D}
~Label=HF_ROSS
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.
{=HT_SIER sierpinski}
~Label=HF_SIER
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.
{=HT_SCOTSKIN spider}
~Label=HF_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)
{=HT_SCOTSKIN sqr(1/fn)}
~Label=HF_SQROVFN
z(0) = pixel;
z(n+1) = (1/fn(z(n))^2
One parameter: the function fn.
{=HT_SCOTSKIN sqr(fn)}
~Label=HF_SQRFN
z(0) = pixel;
z(n+1) = fn(z(n))^2
One parameter: the function fn.
{=HT_TEST test}
~Label=HF_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).
{=HT_SCOTSKIN tetrate}
~Label=HF_TETRATE
z(0) = c = pixel;
z(n+1) = c^z(n)
Parameters: real & imaginary perturbation of z(0)
~OnlineFF
{=HT_MARTIN threeply}
~Label=HF_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.
{=HT_MARKS tim's_error}
~Label=HF_TIMSERR
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
~OnlineFF
{=HT_UNITY unity}
~Label=HF_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.
{=HT_VL volterra-lotka}
~Label=HF_VL
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
~OnlineFF
{=HT_ESCHER escher_julia}
~Label=HF_ESCHER
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.
~CompressSpaces+
;
;
;
~Topic=Fractal Types
A list of the fractal types and their mathematics can be found in the
{Summary of Fractal Types}. Some notes about how Fractint calculates
them are in "A Little Code" in {"Fractals and the PC"}.
Fractint starts by default with the Mandelbrot set. You can change that by
using the command-line argument "TYPE=" followed by one of the
fractal type names, or by using the

Enter new pixel coordinates directly\
~~ Saves the fractal, cursor, orbits, and numbers.\
<<> or <,> Zoom inverse julia image smaller.\
<>> or <.> Zoom inverse julia image larger.\
~~* from main screen will allow you to modify
these values. The defaults are the same as for regular 3D, and are not
always optimum for 3D IFS. With the 3dfern IFS type, try
rotation=30/30/30. Note that applying shift when using perspective changes
the picture -- your "point of view" is moved.
A truly wild variation of 3D may be seen by entering "2" for the stereo
mode (see {"Stereo 3D Viewing"}),
putting on red/blue "funny glasses", and watching the fern develop
with full depth perception right there before your eyes!
This feature USED to be dedicated to Bruce Goren, as a bribe to get him to
send us MORE knockout stereo slides of 3D ferns, now that we have made it
so easy! Bruce, what have you done for us *LATELY* ?? (Just kidding,
really!)
Each line in an IFS definition (look at FRACTINT.IFS with your editor for
examples) contains the parameters for one of the generating functions,
e.g. in FERN:
~Format-
a b c d e f p
___________________________________
0 0 0 .16 0 0 .01
.85 .04 -.04 .85 0 1.6 .85
.2 -.26 .23 .22 0 1.6 .07
-.15 .28 .26 .24 0 .44 .07
The values on each line define a matrix, vector, and probability:
matrix vector prob
|a b| |e| p
|c d| |f|
~Format+
The "p" values are the probabilities assigned to each function (how often
it is used), which add up to one. Fractint supports up to 32 functions,
although usually three or four are enough.
3D IFS definitions are a bit different. The name is followed by (3D) in
the definition file, and each line of the definition contains 13 numbers:
a b c d e f g h i j k l p, defining:
matrix vector prob\
|a b c| |j| p\
|d e f| |k|\
|g h i| |l|\
;You can experiment with changes to IFS definitions interactively by using
;Fractint's command. After selecting an IFS definition, hit to
;bring up the IFS editor. This editor displays the current IFS values, lets
;you modify them, and lets you save your modified values as a text file
;which you can then merge into an XXX.IFS file for future use with
;Fractint.
;
The program FDESIGN can be used to design IFS fractals - see
{=@FDESIGN FDESIGN}.
You can save the points in your IFS fractal in the file ORBITS.RAW which is
overwritten each time a fractal is generated. The program Acrospin can
read this file and will let you view the fractal from any angle using
the cursor keys. See {=@ACROSPIN Acrospin}.
;
;
~Topic=Sierpinski Gasket, Label=HT_SIER
(type=sierpinski)
Another pre-Mandelbrot classic, this one found by W. Sierpinski around
World War I. It is generated by dividing a triangle into four congruent
smaller triangles, doing the same to each of them, and so on, yea, even
unto infinity. (Notice how hard we try to avoid reiterating "iterating"?)
If you think of the interior triangles as "holes", they occupy more and
more of the total area, while the "solid" portion becomes as hopelessly
fragile as that gasket you HAD to remove without damaging it -- you
remember, that Sunday afternoon when all the parts stores were closed?
There's a three-dimensional equivalent using nested tetrahedrons instead
of triangles, but it generates too much pyramid power to be safely
unleashed yet.
There are no parameters for this type. We were able to implement it with
integer math routines, so it runs fairly quickly even without an FPU.
;
;
~Topic=Quartic Mandelbrot/Julia, Label=HT_MANDJUL4
(type=mandel4/julia4)
These fractal types are the moral equivalent of the original M and J sets,
except that they use the formula Z(n+1) = Z(n)^4 + C, which adds
additional pseudo-symmetries to the plots. The "Mandel4" set maps to the
"Julia4" set via -- surprise! -- the spacebar toggle. The M4 set is kind
of boring at first (the area between the "inside" and the "outside" of the
set is pretty thin, and it tends to take a few zooms to get to any
interesting sections), but it looks nice once you get there. The Julia
sets look nice right from the start.
Other powers, like Z(n)^3 or Z(n)^7, work in exactly the same fashion. We
used this one only because we're lazy, and Z(n)^4 = (Z(n)^2)^2.
;
;
~Topic=Distance Estimator
(distest=nnn/nnn)
This used to be type=demm and type=demj. These types have not died, but
are only hiding! They are equivalent to the mandel and julia types with
the "distest=" option selected with a predetermined value.
The {Distance Estimator Method}
can be used to produce higher quality images of M and J sets,
especially suitable for printing in black and white.
If you have some *.fra files made with the old types demm/demj, you may
want to convert them to the new form. See the {=HT_MANDFN Mandelfn}
section for directions to carry out the conversion.
;
;
~Topic=Pickover Mandelbrot/Julia Types, Label=HT_PICKMJ
(type=manfn+zsqrd/julfn+zsqrd, manzpowr/julzpowr, manzzpwr/julzzpwr,
manfn+exp/julfn+exp - formerly included man/julsinzsqrd and
man/julsinexp which have now been generalized)
These types have been explored by Clifford A. Pickover, of the IBM Thomas
J. Watson Research center. As implemented in Fractint, they are regular
Mandelbrot/Julia set pairs that may be plotted with or without the
{=@Biomorphs "biomorph"} option Pickover used to create organic-looking
beasties (see
below). These types are produced with formulas built from the functions
z^z, z^n, sin(z), and e^z for complex z. Types with "power" or "pwr" in
their name have an exponent value as a third parameter. For example,
type=manzpower params=0/0/2 is our old friend the classical Mandelbrot,
and type=manzpower params=0/0/4 is the Quartic Mandelbrot. Other values of
the exponent give still other fractals. Since these WERE the original
"biomorph" types, we should give an example. Try:
FRACTINT type=manfn+zsqrd biomorph=0 corners=-8/8/-6/6 function=sin
to see a big biomorph digesting little biomorphs!
;
;
~Topic=Pickover Popcorn, Label=HT_POPCORN
(type=popcorn/popcornjul)
Here is another Pickover idea. This one computes and plots the orbits of
the dynamic system defined by:
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) ))
In the original the functions were: sin, tan, sin, tan, and C was 3.
The initializers x(0) and y(0) equal to ALL the complex values within
the "corners" values, and h=.01. ALL these orbits are superimposed,
resulting in "popcorn" effect. You may want to use a maxiter value less
than normal - Pickover recommends a value of 50. Although you can zoom and
rotate popcorn, the results may not be what you'd expect, due to the
superimposing of orbits and arbitrary use of color. The orbits frequently
occur outside of the screen boundaries. To view the fractal in its entirety,
set the preview display to "yes" using the "V" command.
As a bonus, type=popcornjul shows the Julia set generated by these same
equations with the usual escape-time coloring. Turn on orbit viewing with
the "O" command, and as you watch the orbit pattern you may get some insight
as to where the popcorn comes from.
;
;
~Topic=Dynamic System, Label=HT_DYNAM
(type=dynamic, dynamic2)
These fractals are based on a cyclic system of differential equations:
x'(t) = -f(y(t))\
y'(t) = f(x(t))\
These equations are approximated by using a small time step dt, forming
a time-discrete dynamic system:
x(n+1) = x(n) - dt*f(y(n))\
y(n+1) = y(n) + dt*f(x(n))\
The initial values x(0) and y(0) are set to various points in the plane,
the dynamic system is iterated, and the resulting orbit points are plotted.
In fractint, the function f is restricted to:
f(k) = sin(k + a*fn1(b*k))
The parameters are the spacing of the initial points, the time step dt,
and the parameters (a,b,fn1) that affect the function f.
Normally the orbit points are plotted individually, but for a negative
spacing the points are connected.
This fractal is similar to the {=HT_POPCORN Pickover Popcorn}.
~OnlineFF
A variant is the implicit Euler approximation:
y(n+1) = y(n) + dt*f(x(n))\
x(n+1) = x(n) - dt*f(y(n+1))\
This variant results in complex orbits. The implicit Euler approximation
is selected by entering dt<0.
There are two options that have unusual effects on these fractals. The
Orbit Delay value controls how many initial points are computed before
the orbits are displayed on the screen. This allows the orbit to settle
down. The outside=summ option causes each pixel to increment color every
time an orbit touches it; the resulting display is a 2-d histogram.
These fractals are discussed in Chapter 14 of Pickover's "Computers,
Pattern, Chaos, and Beauty".
;
;
~Topic=Mandelcloud, Label=HT_MANDELCLOUD
(type=mandelcloud)
This fractal computes the Mandelbrot function, but displays it differently.
It starts with regularly spaced initial pixels and displays the resulting
orbits. This idea is somewhat similar to the {=HT_DYNAM Dynamic System}.
There are two options that have unusual effects on this fractal. The
Orbit Delay value controls how many initial points are computed before
the orbits are displayed on the screen. This allows the orbit to settle
down. The outside=summ option causes each pixel to increment color every
time an orbit touches it; the resulting display is a 2-d histogram.
This fractal was invented by Noel Giffin.
;
;
~Topic=Peterson Variations, Label=HT_MARKS
(type=marksmandel, marksjulia, cmplxmarksmand, cmplxmarksjul, marksmandelpwr,
tim's_error)
These fractal types are contributions of Mark Peterson. MarksMandel and
MarksJulia are two families of fractal types that are linked in the same
manner as the classic Mandelbrot/Julia sets: each MarksMandel set can be
considered as a mapping into the MarksJulia sets, and is linked with the
spacebar toggle. The basic equation for these sets is:
Z(n+1) = (lambda^(exp-1) * Z(n)^2) + lambda\
where Z(0) = 0.0 and lambda is (x + iy) for MarksMandel. For MarksJulia,
Z(0) = (x + iy) and lambda is a constant (taken from the MarksMandel
spacebar toggle, if that method is used). The exponent is a positive
integer or a complex number. We call these "families" because each value
of the exponent yields a different MarksMandel set, which turns out to be
a kinda-polygon with (exponent) sides. The exponent value is the third
parameter, after the "initialization warping" values. Typically one would
use null warping values, and specify the exponent with something like
"PARAMS=0/0/5", which creates an unwarped, pentagonal MarksMandel set.
In the process of coding MarksMandelPwr formula type, Tim Wegner
created the type "tim's_error" after making an interesting coding mistake.
;
;
~Topic=Unity, Label=HT_UNITY
(type=unity)
This Peterson variation began with curiosity about other "Newton-style"
approximation processes. A simple one,
One = (x * x) + (y * y); y = (2 - One) * x; x = (2 - One) * y;
produces the fractal called Unity.
One of its interesting features is the "ghost lines." The iteration loop
bails out when it reaches the number 1 to within the resolution of a
screen pixel. When you zoom a section of the image, the bailout criterion
is adjusted, causing some lines to become thinner and others thicker.
Only one line in Unity that forms a perfect circle: the one at a radius of
1 from the origin. This line is actually infinitely thin. Zooming on it
reveals only a thinner line, up (down?) to the limit of accuracy for the
algorithm. The same thing happens with other lines in the fractal, such as
those around |x| = |y| = (1/2)^(1/2) = .7071
Try some other tortuous approximations using the {=HT_TEST TEST stub} and
let us know what you come up with!
;
;
~Topic=Scott Taylor / Lee Skinner Variations, Label=HT_SCOTSKIN
(type=fn(z*z), fn*fn, fn*z+z, fn+fn, fn+fn(pix), sqr(1/fn), sqr(fn), spider,
tetrate, manowar)
Two of Fractint's faithful users went bonkers when we introduced the
"formula" type, and came up with all kinds of variations on escape-time
fractals using trig functions. We decided to put them in as regular
types, but there were just too many! So we defined the types with variable
functions and let you, the overwhelmed user, specify what the functions
should be! Thus Scott Taylor's "z = sin(z) + z^2" formula type is now the
"fn+fn" regular type, and EITHER function can be one of sin, cos, tan, cotan,
sinh, cosh, tanh, cotanh, exp, log, sqr, recip, ident, zero, one, conj,
flip, cosxx, asin, asinh, acos, acosh, atan, atanh, sqrt, abs, or cabs.
Plus we give you 4 parameters to set, the complex
coefficients of the two functions! Thus the innocent-looking "fn+fn" type
is really 729 different types in disguise, not counting the damage
done by the parameters!
Lee informs us that you should not judge fractals by their "outer"
appearance. For example, the images produced by z = sin(z) + z^2 and z =
sin(z) - z^2 look very similar, but are different when you zoom in.
;
;
~Topic=Kam Torus, Label=HT_KAM
(type=kamtorus, kamtorus3d)
This type is created by superimposing orbits generated by a set of
equations, with a variable incremented each time.
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. The parameters
are angle "a", step size for incrementing 'orbit', stop value for 'orbit',
and points per orbit. Try this with a stop value of 5 with sound=x for
some weird fractal music (ok, ok, fractal noise)! You will also see the
KAM Torus head into some chaotic territory that Scott Taylor wanted to
hide from you by setting the defaults the way he did, but now we have
revealed all!
The 3D variant is created by treating 'orbit' as the z coordinate.
With both variants, you can adjust the "maxiter" value (*

* screen Orbit Delay - try 10.
The 6th parameter accepts a random seed, allowing you to duplicate images
using random values (empty rule string or 0 maximum ants.
Try rule string 10. In this case, the ant moves in a seemingly random pattern,
then suddenly marches off in a straight line. This happens for many other
rule strings. The default 1100 produces symmetrical images.
If the screen initially contains an image, the path of the ant changes. To
try this, generate a fractal, and press . Note that images
seeded with an image are not (yet) reproducible in PAR files. When started
using the keys, after the ant is finished the default fractal
type reverts to that of the underlying fractal.
~Label=ANTCOMMANDS
Special keystrokes are in effect during the ant's march. The *

* screen) is set to 1, the step
mode is the default.
If you press the right or left arrow during the ant's journey, you can
adjust the orbit delay factor with the arrow keys (increment by 10) or
ctrl-arrow keys (increment by 100). Press any other key to get out of the
orbit delay adjustment mode. Higher values cause slower motion. Changed values
are not saved after the ant is finished, but you can set the orbit delay
value in advance from the *

* screen.
;
;
;
~Topic=Test, Label=HT_TEST
(type=test)
This is a stub that we (and you!) use for trying out new fractal types.
"Type=test" fractals make use of Fractint's structure and features for
whatever code is in the routine 'testpt()' (located in the small source
file TESTPT.C) to determine the color of a particular pixel.
If you have a favorite fractal type that you believe would fit nicely into
Fractint, just rewrite the C function in TESTPT.C (or use the prototype
function there, which is a simple M-set implementation) with an algorithm
that computes a color based on a point in the complex plane.
After you get it working, send your code to one of the authors and we
might just add it to the next release of Fractint, with full credit to
you. Our criteria are: 1) an interesting image and 2) a formula
significantly different from types already supported. (Bribery may also
work. THIS author is completely honest, but I don't trust those other
guys.) Be sure to include an explanation of your algorithm and the
parameters supported, preferably formatted as you see here to simplify
folding it into the documentation.
;
;
~Topic=Formula, Label=HT_FORMULA
(type=formula)
This is a "roll-your-own" fractal interpreter - you don't even need a
compiler!
To run a "type=formula" fractal, you first need a text file containing
formulas (there's a sample file - FRACTINT.FRM - included with this
distribution). When you select the "formula" fractal type, Fractint scans
the current formula file (default is FRACTINT.FRM) for formulas, then
prompts you for the formula name you wish to run. After prompting for any
parameters, the formula is parsed for syntax errors and then the fractal
is generated. If you want to use a different formula file, press when
you are prompted to select a formula name.
There are two command-line options that work with type=formula
("formulafile=" and "formulaname="), useful when you are using this
fractal type in batch mode.
The following documentation is supplied by Mark Peterson, who wrote the
formula interpreter:
Formula fractals allow you to create your own fractal formulas. The
general format is:
Mandelbrot(XAXIS) \{ z = Pixel: z = sqr(z) + pixel, |z| <= 4 \}\
| | | | |\
Name Symmetry Initial Iteration Bailout\
Condition Criteria\
Initial conditions are set, then the iterations performed while the
bailout criteria remains true or until 'z' turns into a periodic loop.
All variables are created automatically by their usage and treated as
complex. If you declare 'v = 2' then the variable 'v' is treated as a
complex with an imaginary value of zero.
NOTE: For periodicity checking, inside options, outside options, and
the passes=o option to work correctly it is necessary to leave the result
of the orbit calculation in the variable z.
~OnlineFF
Sequential processing of the formula can be altered with the flow control\
instructions
IF(expr1)\
statements\
ELSEIF(expr2)\
statements\
.\
.\
ELSEIF(exprn)\
statements\
ELSE\
statements\
ENDIF\
where the expressions are evaluated and the statements executed are those\
immediately following the first "true" expression (the real part of the\
complex variable being nonzero). Nesting of IF..ENDIF blocks is permitted.\
~OnlineFF
~Format-
Predefined Variables (x, y)
--------------------------------------------
z used for periodicity checking
p1 parameters 1 and 2
p2 parameters 3 and 4
p3 parameters 5 and 6
p4 parameters 7 and 8
p5 parameters 9 and 10
pixel complex coordinates
LastSqr Modulus from the last sqr() function
rand Complex random number
pi (3.14159..., 0.0)
e (2.71828..., 0.0)
maxit (maxit, 0) maximum iterations
scrnmax (xdots, ydots) max horizontal/vertical resolution.
e.g. for SF7 scrnmax = (1024,768)
scrnpix (col, row) pixel screen coordinates. (col, row) ranges
from (0,0) to (xdots-1, ydots-1)
whitesq ((col+row) modulo 2, 0) i.e. thinking of the screen
coordinates as a large checker board, whitesq is (1,0)
for the white squares and (0,0) for the black ones.
~OnlineFF
Predefined Variables (Continued)
--------------------------------------------
ismand 1 (true) by default, changes to 0 when the Mandelbrot/
Julia SPACE toggle is pressed. This allows writing
formulas that have both "Mandelbrot" and "Julia" behavior.
~LABEL=@PREDEFCENTERMAG
center Zoom box (Xcenter, Ycenter) (see {=@CENTERMAG center-mag})
magxmag Zoom box (Mag, Xmagnitude) (see {=@CENTERMAG center-mag})
rotskew Zoom box (Rotation, Skew) (see {=@CENTERMAG center-mag})
Precedence
--------------------------------------------
1 sin(), cos(), sinh(), cosh(), cosxx(), tan(), cotan(),
tanh(), cotanh(), sqr(), log(), exp(), abs(), conj(),
real(), imag(), flip(), fn1(), fn2(), fn3(), fn4(),
srand(), asin(), asinh(), acos(), acosh(), atan(),
atanh(), sqrt(), cabs(), floor(), ceil(), trunc(),
round()
2 - (negation), ^ (power)
3 * (multiplication), / (division)
4 + (addition), - (subtraction)
5 = (assignment)
~OnlineFF
Precedence (Continued)
--------------------------------------------
6 < (less than), <= (less than or equal to)
> (greater than), >= (greater than or equal to)
== (equal to), != (not equal to)
7 && (logical AND), || (logical OR)
~Format+
Precedence may be overridden by use of parenthesis. Note the modulus squared
operator |z| is also parenthetic and always sets the imaginary component to
zero. This means 'c * |z - 4|' first subtracts 4 from z, calculates the
modulus squared then multiplies times 'c'. Nested modulus squared operators
require overriding parenthesis:
c * |z + (|pixel|)|\
The functions fn1(...) to fn4(...) are variable functions - when used,
the user is prompted at run time (on the *