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 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 (*