home *** CD-ROM | disk | FTP | other *** search
/ Computerworld 1996 March / Computerworld_1996-03_cd.bin / idg_cd3 / grafika / fraktaly / frasr192 / help2.src < prev    next >
Text File  |  1995-04-08  |  127KB  |  2,895 lines
  1. ~Topic=Summary of Fractal Types, Label=HELPFRACTALS
  2. ~Format-
  3. ~Doc-
  4. For detailed descriptions, select a hot-link below, see {Fractal Types},
  5. or use <F2> from the fractal type selection screen.
  6. ~Doc+,Online-
  7. SUMMARY OF FRACTAL TYPES
  8. ~Online+
  9. ~CompressSpaces-
  10. ;
  11. ; Note that prompts.c pulls formulas out of the following for <Z> screen,
  12. ; using the HF_xxx labels.  It assumes a rigid formatting structure for
  13. ; the formulas:
  14. ;    4 leading blanks (which get stripped on <Z> screen)
  15. ;    lines no wider than 76 characters (not counting initial 4 spaces)
  16. ;    formula ends at any of:
  17. ;    blank line
  18. ;    line which begins in column 1
  19. ;    format ctl char (~xxx, {xxx}, \x)
  20. ;
  21.  
  22. {=HT_ANT ant}
  23. ~Label=HF_ANT
  24.     Generalized Ant Automaton as described in the July 1994 Scientific
  25.     American. Some ants wander around the screen. A rule string (the first
  26.     parameter) determines the ant's direction. When the type 1 ant leaves a
  27.     cell of color k, it turns right if the kth symbol in the first parameter
  28.     is a 1, or left otherwise. Then the color in the old cell is incremented.
  29.     The 2nd parameter is a maximum iteration to guarantee that the fractal
  30.     will terminate. The 3rd parameter is the number of ants. The 4th is the
  31.     ant type 1 or 2. The 5th parameter determines if the ants wrap the screen
  32.     or stop at the edge.  The 6th parameter is a random seed. You can slow 
  33.     down the ants to see them better using the <x> screen Orbit Delay.
  34. {=HT_BARNS barnsleyj1}
  35. ~Label=HF_BARNSJ1
  36.       z(0) = pixel;
  37.       z(n+1) = (z-1)*c if real(z) >= 0, else
  38.       z(n+1) = (z+1)*c
  39.     Two parameters: real and imaginary parts of c
  40. ~OnlineFF
  41. {=HT_BARNS barnsleyj2}
  42. ~Label=HF_BARNSJ2
  43.       z(0) = pixel;
  44.       if real(z(n)) * imag(c) + real(c) * imag(z((n)) >= 0
  45.      z(n+1) = (z(n)-1)*c
  46.       else
  47.      z(n+1) = (z(n)+1)*c
  48.     Two parameters: real and imaginary parts of c
  49. {=HT_BARNS barnsleyj3}
  50. ~Label=HF_BARNSJ3
  51.       z(0) = pixel;
  52.       if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
  53.      + i * (2*real(z((n)) * imag(z((n))) else
  54.       z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
  55.          + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))
  56.     Two parameters: real and imaginary parts of c.
  57. {=HT_BARNS barnsleym1}
  58. ~Label=HF_BARNSM1
  59.       z(0) = c = pixel;
  60.       if real(z) >= 0 then
  61.     z(n+1) = (z-1)*c
  62.       else
  63.     z(n+1) = (z+1)*c.
  64.     Parameters are perturbations of z(0)
  65. ~OnlineFF
  66. {=HT_BARNS barnsleym2}
  67. ~Label=HF_BARNSM2
  68.       z(0) = c = pixel;
  69.       if real(z)*imag(c) + real(c)*imag(z) >= 0
  70.     z(n+1) = (z-1)*c
  71.       else
  72.     z(n+1) = (z+1)*c
  73.     Parameters are perturbations of z(0)
  74.  
  75. {=HT_BARNS barnsleym3}
  76. ~Label=HF_BARNSM3
  77.       z(0) = c = pixel;
  78.       if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
  79.      + i * (2*real(z((n)) * imag(z((n))) else
  80.       z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
  81.      + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))
  82.     Parameters are perturbations of z(0)
  83.  
  84. {=HT_BIF bifurcation}
  85. ~Label=HF_BIFURCATION
  86.     Pictorial representation of a population growth model.
  87.       Let P = new population, p = oldpopulation, r = growth rate
  88.       The model is: P = p + r*fn(p)*(1-fn(p)).
  89.     Three parameters: Filter Cycles, Seed Population, and Function.
  90.  
  91. ~OnlineFF
  92. {=HT_BIF bif+sinpi}
  93. ~Label=HF_BIFPLUSSINPI
  94.     Bifurcation variation: model is: P = p + r*fn(PI*p).
  95.     Three parameters: Filter Cycles, Seed Population, and Function.
  96.  
  97. {=HT_BIF bif=sinpi}
  98. ~Label=HF_BIFEQSINPI
  99.     Bifurcation variation: model is: P = r*fn(PI*p).
  100.     Three parameters: Filter Cycles, Seed Population, and Function.
  101.  
  102. {=HT_BIF biflambda}
  103. ~Label=HF_BIFLAMBDA
  104.     Bifurcation variation: model is: P = r*fn(p)*(1-fn(p)).
  105.     Three parameters: Filter Cycles, Seed Population, and Function.
  106.  
  107. {=HT_BIF bifstewart}
  108. ~Label=HF_BIFSTEWART
  109.     Bifurcation variation: model is: P = (r*fn(p)*fn(p)) - 1.
  110.     Three parameters: Filter Cycles, Seed Population, and Function.
  111.  
  112. {=HT_BIF bifmay}
  113. ~Label=HF_BIFMAY
  114.     Bifurcation variation: model is: P = r*p / ((1+p)^beta).
  115.     Three parameters: Filter Cycles, Seed Population, and Beta.
  116.  
  117. ~OnlineFF
  118. {=HT_CELLULAR cellular}
  119. ~Label=HF_CELLULAR
  120.     One-dimensional cellular automata or line automata.  The type of CA
  121.     is given by kr, where k is the number of different states of the
  122.     automata and r is the radius of the neighborhood.  The next generation
  123.     is determined by the sum of the neighborhood and the specified rule.
  124.     Four parameters: Initial String, Rule, Type, and Starting Row Number.
  125.     For Type = 21, 31, 41, 51, 61, 22, 32, 42, 23, 33, 24, 25, 26, 27
  126.         Rule =  4,  7, 10, 13, 16,  6, 11, 16,  8, 15, 10, 12, 14, 16 digits
  127. {=HT_MARTIN chip}
  128. ~Label=HF_CHIP
  129.     Chip attractor from Michael Peters - orbit in two dimensions.
  130.       z(0) = y(0) = 0;
  131.       x(n+1) = y(n) - sign(x(n)) * cos(sqr(ln(abs(b*x(n)-c))))        
  132.                                  * arctan(sqr(ln(abs(c*x(n)-b))))
  133.       y(n+1) = a - x(n)
  134.     Parameters are a, b, and c.
  135. {=HT_CIRCLE circle}
  136. ~Label=HF_CIRCLE
  137.     Circle pattern by John Connett
  138.       x + iy = pixel
  139.       z = a*(x^2 + y^2)
  140.       c = integer part of z
  141.       color = c modulo(number of colors)
  142. ~OnlineFF
  143. {=HT_MARKS cmplxmarksjul}
  144. ~Label=HF_CMPLXMARKSJUL
  145.     A generalization of the marksjulia fractal.
  146.       z(0) = pixel;
  147.       z(n+1) = (c^exp-1)*z(n)^2 + c.
  148.     Four parameters: real and imaginary parts of c,
  149.     and real and imaginary parts of exponent.
  150. {=HT_MARKS cmplxmarksmand}
  151. ~Label=HF_CMPLXMARKSMAND
  152.     A generalization of the marksmandel fractal.
  153.       z(0) = c = pixel;
  154.       z(n+1) = (c^exp-1)*z(n)^2 + c.
  155.     Four parameters: real and imaginary parts of perturbation
  156.     of z(0), and real and imaginary parts of exponent.
  157.  
  158. {=HT_NEWTCMPLX complexnewton\, complexbasin}
  159. ~Label=HF_COMPLEXNEWT
  160.     Newton fractal types extended to complex degrees. Complexnewton
  161.     colors pixels according to the number of iterations required to
  162.     escape to a root. Complexbasin colors pixels according to which
  163.     root captures the orbit. The equation is based on the newton
  164.     formula for solving the equation z^p = r
  165.       z(0) = pixel;
  166.       z(n+1) = ((p - 1) * z(n)^p + r)/(p * z(n)^(p - 1)).
  167.     Four parameters: real & imaginary parts of degree p and root r.
  168.  
  169. {=HT_DIFFUS diffusion}
  170. ~Label=HF_DIFFUS
  171.     Diffusion Limited Aggregation.  Randomly moving points
  172.     accumulate.  Two parameters: border width (default 10), type.
  173.  
  174. {=HT_DYNAM dynamic}
  175. ~Label=HF_DYNAM
  176.     Time-discrete dynamic system.
  177.       x(0) = y(0) = start position.
  178.       y(n+1) = y(n) + f( x(n) )
  179.       x(n+1) = x(n) - f( y(n) )
  180.       f(k) = sin(k + a*fn1(b*k))
  181.     For implicit Euler approximation: x(n+1) = x(n) - f( y(n+1) )
  182.     Five parameters: start position step, dt, a, b, and the function fn1.
  183.  
  184. {=HT_SCOTSKIN fn(z)+fn(pix)}
  185. ~Label=HF_FNPLUSFNPIX
  186.       c = z(0) = pixel;
  187.       z(n+1) = fn1(z) + p*fn2(c)
  188.     Six parameters: real and imaginary parts of the perturbation
  189.     of z(0) and factor p, and the functions fn1, and fn2.
  190. {=HT_SCOTSKIN fn(z*z)}
  191. ~Label=HF_FNZTIMESZ
  192.       z(0) = pixel;
  193.       z(n+1) = fn(z(n)*z(n))
  194.     One parameter: the function fn.
  195. ~OnlineFF
  196.  
  197. {=HT_SCOTSKIN fn*fn}
  198. ~Label=HF_FNTIMESFN
  199.       z(0) = pixel; z(n+1) = fn1(n)*fn2(n)
  200.     Two parameters: the functions fn1 and fn2.
  201.  
  202. {=HT_SCOTSKIN fn*z+z}
  203. ~Label=HF_FNXZPLUSZ
  204.       z(0) = pixel; z(n+1) = p1*fn(z(n))*z(n) + p2*z(n)
  205.     Five parameters: the real and imaginary components of
  206.     p1 and p2, and the function fn.
  207.  
  208. {=HT_SCOTSKIN fn+fn}
  209. ~Label=HF_FNPLUSFN
  210.       z(0) = pixel;
  211.       z(n+1) = p1*fn1(z(n))+p2*fn2(z(n))
  212.     Six parameters: The real and imaginary components of
  213.     p1 and p2, and the functions fn1 and fn2.
  214.  
  215. {=HT_FORMULA formula}
  216.     Formula interpreter - write your own formulas as text files!
  217. ~OnlineFF
  218.  
  219. {=HT_FROTH frothybasin}
  220. ~Label=HF_FROTH
  221.     Pixel color is determined by which attractor captures the orbit.  The
  222.     shade of color is determined by the number of iterations required to
  223.     capture the orbit.
  224.       Z(0) = pixel;  Z(n+1) = Z(n)^2 - C*conj(Z(n))
  225.       where C = 1 + A*i, critical value of A = 1.028713768218725...
  226.  
  227. {=HT_GINGER gingerbread}
  228. ~Label=HF_GINGER
  229.     Orbit in two dimensions defined by:
  230.       x(n+1) = 1 - y(n) + |x(n)|
  231.       y(n+1) = x(n)
  232.     Two parameters: initial values of x(0) and y(0).
  233.  
  234. {=HT_HALLEY halley}
  235. ~Label=HF_HALLEY
  236.       Halley map for the function: F = z(z^a - 1) = 0
  237.       z(0) = pixel;
  238.       z(n+1) = z(n) - R * F / [F' - (F" * F / 2 * F')]
  239.       bailout when: abs(mod(z(n+1)) - mod(z(n)) < epsilon
  240.     Four parameters: order a, real part of R, epsilon,
  241.        and imaginary part of R.
  242. ~OnlineFF
  243. {=HT_HENON henon}
  244. ~Label=HF_HENON
  245.     Orbit in two dimensions defined by:
  246.       x(n+1) = 1 + y(n) - a*x(n)*x(n)
  247.       y(n+1) = b*x(n)
  248.     Two parameters: a and b
  249.  
  250. {=HT_MARTIN hopalong}
  251. ~Label=HF_HOPALONG
  252.     Hopalong attractor by Barry Martin - orbit in two dimensions.
  253.       z(0) = y(0) = 0;
  254.       x(n+1) = y(n) - sign(x(n))*sqrt(abs(b*x(n)-c))
  255.       y(n+1) = a - x(n)
  256.     Parameters are a, b, and c.
  257.  
  258. {=HT_HYPERC hypercomplex}
  259. ~Label=HF_HYPERC
  260.     HyperComplex Mandelbrot set.
  261.       h(0)   = (0,0,0,0)
  262.       h(n+1) = fn(h(n)) + C.
  263.       where "fn" is sin, cos, log, sqr etc.
  264.     Two parameters: cj, ck
  265.     C = (xpixel,ypixel,cj,ck)
  266. ~OnlineFF
  267.  
  268. {=HT_HYPERC hypercomplexj}
  269. ~Label=HF_HYPERCJ
  270.     HyperComplex Julia set.
  271.       h(0)   = (xpixel,ypixel,zj,zk)
  272.       h(n+1) = fn(h(n)) + C.
  273.       where "fn" is sin, cos, log, sqr etc.
  274.     Six parameters: c1, ci, cj, ck
  275.     C = (c1,ci,cj,ck)
  276.  
  277. {=HT_ICON icon, icon3d}
  278. ~Label=HF_ICON
  279.     Orbit in three dimensions defined by:
  280.       p = lambda + alpha * magnitude + beta * (x(n)*zreal - y(n)*zimag)
  281.       x(n+1) = p * x(n) + gamma * zreal - omega * y(n)
  282.       y(n+1) = p * y(n) - gamma * zimag + omega * x(n)
  283.       (3D version uses magnitude for z)
  284.       Parameters:  Lambda, Alpha, Beta, Gamma, Omega, and Degree
  285.  
  286. {=HT_IFS IFS}
  287.     Barnsley IFS (Iterated Function System) fractals. Apply
  288.     contractive affine mappings.
  289. ~OnlineFF
  290.  
  291. {=HT_PICKMJ julfn+exp}
  292. ~Label=HF_JULFNPLUSEXP
  293.     A generalized Clifford Pickover fractal.
  294.       z(0) = pixel;
  295.       z(n+1) = fn(z(n)) + e^z(n) + c.
  296.     Three parameters: real & imaginary parts of c, and fn
  297.  
  298. {=HT_PICKMJ julfn+zsqrd}
  299. ~Label=HF_JULFNPLUSZSQRD
  300.       z(0) = pixel;
  301.       z(n+1) = fn(z(n)) + z(n)^2 + c
  302.     Three parameters: real & imaginary parts of c, and fn
  303.  
  304. {=HT_JULIA julia}
  305. ~Label=HF_JULIA
  306.     Classic Julia set fractal.
  307.       z(0) = pixel; z(n+1) = z(n)^2 + c.
  308.     Two parameters: real and imaginary parts of c.
  309. ~OnlineFF
  310.  
  311. {=HT_INVERSE julia_inverse}
  312. ~Label=HF_INVERSE
  313.     Inverse Julia function - "orbit" traces Julia set in two dimensions.
  314.       z(0) = a point on the Julia Set boundary; z(n+1) = +- sqrt(z(n) - c)
  315.     Parameters: Real and Imaginary parts of c
  316.            Maximum Hits per Pixel (similar to max iters)
  317.            Breadth First, Depth First or Random Walk Tree Traversal
  318.            Left or Right First Branching (in Depth First mode only)
  319.         Try each traversal method, keeping everything else the same.
  320.         Notice the differences in the way the image evolves.  Start with
  321.         a fairly low Maximum Hit limit, then increase it.  The hit limit
  322.         cannot be higher than the maximum colors in your video mode.
  323.  
  324. {=HT_FNORFN julia(fn||fn)}
  325. ~Label=HF_JULIAFNFN
  326.       z(0) = pixel;
  327.       if modulus(z(n)) < shift value, then
  328.          z(n+1) = fn1(z(n)) + c,
  329.       else
  330.          z(n+1) = fn2(z(n)) + c.
  331.     Five parameters: real, imaginary portions of c, shift value,
  332.                      fn1 and fn2.
  333. ~OnlineFF
  334.  
  335. {=HT_MANDJUL4 julia4}
  336. ~Label=HF_JULIA4
  337.     Fourth-power Julia set fractals, a special case
  338.     of julzpower kept for speed.
  339.       z(0) = pixel;
  340.       z(n+1) = z(n)^4 + c.
  341.     Two parameters: real and imaginary parts of c.
  342.  
  343. {=HT_JULIBROT julibrot}
  344.     'Julibrot' 4-dimensional fractals.
  345.  
  346. {=HT_PICKMJ julzpower}
  347. ~Label=HF_JULZPOWER
  348.       z(0) = pixel;
  349.       z(n+1) = z(n)^m + c.
  350.     Three parameters: real & imaginary parts of c, exponent m
  351.  
  352. {=HT_PICKMJ julzzpwr}
  353. ~Label=HF_JULZZPWR
  354.       z(0) = pixel;
  355.       z(n+1) = z(n)^z(n) + z(n)^m + c.
  356.     Three parameters: real & imaginary parts of c, exponent m
  357. ~OnlineFF
  358.  
  359. {=HT_KAM kamtorus, kamtorus3d}
  360. ~Label=HF_KAM
  361.     Series of orbits superimposed.
  362.     3d version has 'orbit' the z dimension.
  363.       x(0) = y(0) = orbit/3;
  364.       x(n+1) = x(n)*cos(a) + (x(n)*x(n)-y(n))*sin(a)
  365.       y(n+1) = x(n)*sin(a) - (x(n)*x(n)-y(n))*cos(a)
  366.     After each orbit, 'orbit' is incremented by a step size.
  367.     Parameters: a, step size, stop value for 'orbit', and
  368.     points per orbit.
  369.  
  370. {=HT_LAMBDA lambda}
  371. ~Label=HF_LAMBDA
  372.     Classic Lambda fractal. 'Julia' variant of Mandellambda.
  373.       z(0) = pixel;
  374.       z(n+1) = lambda*z(n)*(1 - z(n)).
  375.     Two parameters: real and imaginary parts of lambda.
  376.  
  377. {=HT_LAMBDAFN lambdafn}
  378. ~Label=HF_LAMBDAFN
  379.       z(0) = pixel;
  380.       z(n+1) = lambda * fn(z(n)).
  381.     Three parameters: real, imag portions of lambda, and fn
  382. ~OnlineFF
  383.  
  384. {=HT_FNORFN lambda(fn||fn)}
  385. ~Label=HF_LAMBDAFNFN
  386.       z(0) = pixel;
  387.       if modulus(z(n)) < shift value, then
  388.          z(n+1) = lambda * fn1(z(n)),
  389.       else
  390.          z(n+1) = lambda * fn2(z(n)).
  391.     Five parameters: real, imaginary portions of lambda, shift value,
  392.                      fn1 and fn2.
  393.  
  394. {=HT_LORENZ lorenz, lorenz3d}
  395. ~Label=HF_LORENZ
  396.     Lorenz two lobe attractor - orbit in three dimensions.
  397.     In 2d the x and y components are projected to form the image.
  398.       z(0) = y(0) = z(0) = 1;
  399.       x(n+1) = x(n) + (-a*x(n)*dt) + (     a*y(n)*dt)
  400.       y(n+1) = y(n) + ( b*x(n)*dt) - (       y(n)*dt) - (z(n)*x(n)*dt)
  401.       z(n+1) = z(n) + (-c*z(n)*dt) + (x(n)*y(n)*dt)
  402.     Parameters are dt, a, b, and c.
  403. ~OnlineFF
  404. {=HT_LORENZ lorenz3d1}
  405. ~Label=HF_LORENZ3D1
  406.     Lorenz one lobe attractor - orbit in three dimensions.
  407.     The original formulas were developed by Rick Miranda and Emily Stone.
  408.       z(0) = y(0) = z(0) = 1; norm = sqrt(x(n)^2 + y(n)^2)
  409.       x(n+1) = x(n) + (-a*dt-dt)*x(n) + (a*dt-b*dt)*y(n) 
  410.          + (dt-a*dt)*norm + y(n)*dt*z(n)
  411.       y(n+1) = y(n) + (b*dt-a*dt)*x(n) - (a*dt+dt)*y(n) 
  412.          + (b*dt+a*dt)*norm - x(n)*dt*z(n) - norm*z(n)*dt
  413.       z(n+1) = z(n) +(y(n)*dt/2) - c*dt*z(n)
  414.     Parameters are dt, a, b, and c.
  415. {=HT_LORENZ lorenz3d3}
  416. ~Label=HF_LORENZ3D3
  417.     Lorenz three lobe attractor - orbit in three dimensions.
  418.     The original formulas were developed by Rick Miranda and Emily Stone.
  419.       z(0) = y(0) = z(0) = 1; norm = sqrt(x(n)^2 + y(n)^2)
  420.       x(n+1) = x(n) +(-(a*dt+dt)*x(n) + (a*dt-b*dt+z(n)*dt)*y(n))/3 
  421.           + ((dt-a*dt)*(x(n)^2-y(n)^2) 
  422.           + 2*(b*dt+a*dt-z(n)*dt)*x(n)*y(n))/(3*norm)
  423.       y(n+1) = y(n) +((b*dt-a*dt-z(n)*dt)*x(n) - (a*dt+dt)*y(n))/3 
  424.           + (2*(a*dt-dt)*x(n)*y(n) 
  425.           + (b*dt+a*dt-z(n)*dt)*(x(n)^2-y(n)^2))/(3*norm)
  426.       z(n+1) = z(n) +(3*x(n)*dt*x(n)*y(n)-y(n)*dt*y(n)^2)/2 - c*dt*z(n)
  427.     Parameters are dt, a, b, and c.
  428. ~OnlineFF
  429. {=HT_LORENZ lorenz3d4}
  430. ~Label=HF_LORENZ3D4
  431.     Lorenz four lobe attractor - orbit in three dimensions.
  432.     The original formulas were developed by Rick Miranda and Emily Stone.
  433.       z(0) = y(0) = z(0) = 1; 
  434.       x(n+1) = x(n) +(-a*dt*x(n)^3 
  435.          + (2*a*dt+b*dt-z(n)*dt)*x(n)^2*y(n) + (a*dt-2*dt)*x(n)*y(n)^2 
  436.          + (z(n)*dt-b*dt)*y(n)^3) / (2 * (x(n)^2+y(n)^2))
  437.       y(n+1) = y(n) +((b*dt-z(n)*dt)*x(n)^3 + (a*dt-2*dt)*x(n)^2*y(n) 
  438.          + (-2*a*dt-b*dt+z(n)*dt)*x(n)*y(n)^2 
  439.          - a*dt*y(n)^3) / (2 * (x(n)^2+y(n)^2))
  440.       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))
  441.     Parameters are dt, a, b, and c.
  442.  
  443. {=HT_LSYS lsystem}
  444.     Using a turtle-graphics control language and starting with
  445.     an initial axiom string, carries out string substitutions the
  446.     specified number of times (the order), and plots the resulting.
  447.  
  448. {=HT_LYAPUNOV lyapunov}
  449.     Derived from the Bifurcation fractal, the Lyapunov plots the Lyapunov
  450.     Exponent for a population model where the Growth parameter varies between
  451.     two values in a periodic manner.
  452. ~OnlineFF
  453.  
  454. {=HT_MAGNET magnet1j}
  455. ~Label=HF_MAGJ1
  456.       z(0) = pixel;
  457.         [  z(n)^2 + (c-1)  ] 2
  458.       z(n+1) =    | ---------------- | 
  459.         [  2*z(n) + (c-2)  ]
  460.     Parameters: the real and imaginary parts of c
  461.  
  462. {=HT_MAGNET magnet1m}
  463. ~Label=HF_MAGM1
  464.       z(0) = 0; c = pixel;
  465.         [  z(n)^2 + (c-1)  ] 2
  466.       z(n+1) =    | ---------------- | 
  467.         [  2*z(n) + (c-2)  ]
  468.     Parameters: the real & imaginary parts of perturbation of z(0)
  469.  
  470. {=HT_MAGNET magnet2j}
  471. ~Label=HF_MAGJ2
  472.       z(0) = pixel;
  473.         [  z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)           ] 2
  474.       z(n+1) =    |  -------------------------------------------- |
  475.         [  3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) + 1 ]
  476.     Parameters: the real and imaginary parts of c
  477. ~OnlineFF
  478. {=HT_MAGNET magnet2m}
  479. ~Label=HF_MAGM2
  480.       z(0) = 0; c = pixel;
  481.         [  z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)           ] 2
  482.       z(n+1) =    |  -------------------------------------------- |
  483.         [  3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) + 1 ]
  484.     Parameters: the real and imaginary parts of perturbation of z(0)
  485.  
  486. {=HT_MANDEL mandel}
  487. ~Label=HF_MANDEL
  488.     Classic Mandelbrot set fractal.
  489.       z(0) = c = pixel;
  490.       z(n+1) = z(n)^2 + c.
  491.     Two parameters: real & imaginary perturbations of z(0)
  492.  
  493. {=HT_FNORFN mandel(fn||fn)}
  494. ~Label=HF_MANDELFNFN
  495.       c = pixel;
  496.       z(0) = p1
  497.       if modulus(z(n)) < shift value, then
  498.          z(n+1) = fn1(z(n)) + c,
  499.       else
  500.          z(n+1) = fn2(z(n)) + c.
  501.     Five parameters: real, imaginary portions of p1, shift value,
  502.                      fn1 and fn2.
  503. ~OnlineFF
  504.  
  505. {=HT_MANDELCLOUD mandelcloud}
  506. ~Label=HF_MANDELCLOUD
  507.     Displays orbits of Mandelbrot set:
  508.       z(0) = c = pixel;
  509.       z(n+1) = z(n)^2 + c.
  510.     One parameter: number of intervals
  511.  
  512. {=HT_MANDJUL4 mandel4}
  513. ~Label=HF_MANDEL4
  514.     Special case of mandelzpower kept for speed.
  515.       z(0) = c = pixel;
  516.       z(n+1) = z(n)^4 + c.
  517.     Parameters: real & imaginary perturbations of z(0)
  518.  
  519. {=HT_MANDFN mandelfn}
  520. ~Label=HF_MANDFN
  521.       z(0) = c = pixel;
  522.       z(n+1) = c*fn(z(n)).
  523.     Parameters: real & imaginary perturbations of z(0), and fn
  524. ~OnlineFF
  525.  
  526. {=HT_FNORFN manlam(fn||fn)}
  527. ~Label=HF_MANLAMFNFN
  528.       c = pixel;
  529.       z(0) = p1
  530.       if modulus(z(n)) < shift value, then
  531.          z(n+1) = fn1(z(n)) * c, else
  532.          z(n+1) = fn2(z(n)) * c.
  533.     Five parameters: real, imaginary parts of p1, shift value, fn1, fn2.
  534.  
  535. {=HT_MARTIN Martin}
  536. ~Label=HF_MARTIN
  537.     Attractor fractal by Barry Martin - orbit in two dimensions.
  538.       z(0) = y(0) = 0;
  539.       x(n+1) = y(n) - sin(x(n))
  540.       y(n+1) = a - x(n)
  541.     Parameter is a (try a value near pi)
  542.  
  543. {=HT_MLAMBDA mandellambda}
  544. ~Label=HF_MLAMBDA
  545.       z(0) = .5; lambda = pixel;
  546.       z(n+1) = lambda*z(n)*(1 - z(n)).
  547.     Parameters: real & imaginary perturbations of z(0)
  548. ~OnlineFF
  549. {=HT_PHOENIX mandphoenix}
  550. ~Label=HF_MANDPHOENIX
  551.     z(0) = c = pixel, y(0) = 0;
  552.     For degree = 0:
  553.       z(n+1) = z(n)^2 + c.x + c.y*y(n), y(n+1) = z(n)
  554.     For degree >= 2:
  555.       z(n+1) = z(n)^degree + c.x*z(n)^(degree-1) + c.y*y(n)
  556.       y(n+1) = z(n)
  557.     For degree <= -3:
  558.       z(n+1) = z(n)^|degree| + c.x*z(n)^(|degree|-2) + c.y*y(n)
  559.       y(n+1) = z(n)
  560.     Three parameters: real & imaginary perturbations of z(0), and degree.
  561.  
  562. {=HT_PHOENIX mandphoenixclx}
  563. ~Label=HF_MANDPHOENIXCPLX
  564.     z(0) = c = pixel, y(0) = 0;
  565.     For degree = 0:
  566.       z(n+1) = z(n)^2 + c + p2*y(n), y(n+1) = z(n)
  567.     For degree >= 2:
  568.       z(n+1) = z(n)^degree + c*z(n)^(degree-1) + p2*y(n), y(n+1) = z(n)
  569.     For degree <= -3:
  570.       z(n+1) = z(n)^|degree| + c*z(n)^(|degree|-2) + p2*y(n), y(n+1) = z(n)
  571.     Five parameters: real & imaginary perturbations of z(0), real &
  572.       imaginary parts of p2, and degree.
  573. ~OnlineFF
  574. {=HT_PICKMJ manfn+exp}
  575. ~Label=HF_MANDFNPLUSEXP
  576.     'Mandelbrot-Equivalent' for the julfn+exp fractal.
  577.       z(0) = c = pixel;
  578.       z(n+1) = fn(z(n)) + e^z(n) + C.
  579.     Parameters: real & imaginary perturbations of z(0), and fn
  580.  
  581. {=HT_PICKMJ manfn+zsqrd}
  582. ~Label=HF_MANDFNPLUSZSQRD
  583.     'Mandelbrot-Equivalent' for the Julfn+zsqrd fractal.
  584.       z(0) = c = pixel;
  585.       z(n+1) = fn(z(n)) + z(n)^2 + c.
  586.     Parameters: real & imaginary perturbations of z(0), and fn
  587.  
  588. {=HT_SCOTSKIN manowar}
  589. ~Label=HF_MANOWAR
  590.       c = z1(0) = z(0) = pixel;
  591.       z(n+1) = z(n)^2 + z1(n) + c;
  592.       z1(n+1) = z(n);
  593.     Parameters: real & imaginary perturbations of z(0)
  594. {=HT_SCOTSKIN manowarj}
  595. ~Label=HF_MANOWARJ
  596.       z1(0) = z(0) = pixel;
  597.       z(n+1) = z(n)^2 + z1(n) + c;
  598.       z1(n+1) = z(n);
  599.     Parameters: real & imaginary parts of c
  600. ~OnlineFF
  601.  
  602. {=HT_PICKMJ manzpower}
  603. ~Label=HF_MANZPOWER
  604.     'Mandelbrot-Equivalent' for julzpower.
  605.       z(0) = c = pixel;
  606.       z(n+1) = z(n)^exp + c; try exp = e = 2.71828...
  607.     Parameters: real & imaginary perturbations of z(0), real &
  608.     imaginary parts of exponent exp.
  609.  
  610. {=HT_PICKMJ manzzpwr}
  611. ~Label=HF_MANZZPWR
  612.     'Mandelbrot-Equivalent' for the julzzpwr fractal.
  613.       z(0) = c = pixel
  614.       z(n+1) = z(n)^z(n) + z(n)^exp + C.
  615.     Parameters: real & imaginary perturbations of z(0), and exponent
  616.  
  617. {=HT_MARKS marksjulia}
  618. ~Label=HF_MARKSJULIA
  619.     A variant of the julia-lambda fractal.
  620.       z(0) = pixel;
  621.       z(n+1) = (c^exp-1)*z(n)^2 + c.
  622.     Parameters: real & imaginary parts of c, and exponent
  623. ~OnlineFF
  624.  
  625. {=HT_MARKS marksmandel}
  626. ~Label=HF_MARKSMAND
  627.     A variant of the mandel-lambda fractal.
  628.       z(0) = c = pixel;
  629.       z(n+1) = (c^exp-1)*z(n)^2 + c.
  630.     Parameters: real & imaginary parts of perturbations of z(0),
  631.     and exponent
  632.  
  633. {=HT_MARKS marksmandelpwr}
  634. ~Label=HF_MARKSMANDPWR
  635.     The marksmandelpwr formula type generalized (it previously
  636.     had fn=sqr hard coded).
  637.       z(0) = pixel, c = z(0) ^ (z(0) - 1):
  638.       z(n+1) = c * fn(z(n)) + pixel,
  639.     Parameters: real and imaginary perturbations of z(0), and fn
  640.  
  641. {=HT_NEWTBAS newtbasin}
  642. ~Label=HF_NEWTBAS
  643.     Based on the Newton formula for finding the roots of z^p - 1.
  644.     Pixels are colored according to which root captures the orbit.
  645.       z(0) = pixel;
  646.       z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).
  647.     Two parameters: the polynomial degree p, and a flag to turn
  648.     on color stripes to show alternate iterations.
  649. ~OnlineFF
  650.  
  651. {=HT_NEWT newton}
  652. ~Label=HF_NEWT
  653.     Based on the Newton formula for finding the roots of z^p - 1.
  654.     Pixels are colored according to the iteration when the orbit
  655.     is captured by a root.
  656.       z(0) = pixel;
  657.       z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).
  658.     One parameter: the polynomial degree p.
  659.  
  660. {=HT_PHOENIX phoenix}
  661. ~Label=HF_PHOENIX
  662.     z(0) = pixel, y(0) = 0;
  663.     For degree = 0: z(n+1) = z(n)^2 + p1.x + p2.x*y(n), y(n+1) = z(n)
  664.     For degree >= 2:
  665.      z(n+1) = z(n)^degree + p1.x*z(n)^(degree-1) + p2.x*y(n), y(n+1) = z(n)
  666.     For degree <= -3:
  667.      z(n+1) = z(n)^|degree| + p1.x*z(n)^(|degree|-2) + p2.x*y(n), y(n+1) = z(n)
  668.     Three parameters: real parts of p1 & p2, and degree.
  669. ~OnlineFF
  670.  
  671. {=HT_PHOENIX phoenixcplx}
  672. ~Label=HF_PHOENIXCPLX
  673.     z(0) = pixel, y(0) = 0;
  674.     For degree = 0: z(n+1) = z(n)^2 + p1 + p2*y(n), y(n+1) = z(n)
  675.     For degree >= 2:
  676.       z(n+1) = z(n)^degree + p1*z(n)^(degree-1) + p2*y(n), y(n+1) = z(n)
  677.     For degree <= -3:
  678.       z(n+1) = z(n)^|degree| + p1*z(n)^(|degree|-2) + p2*y(n), y(n+1) = z(n)
  679.     Five parameters: real & imaginary parts of p1 & p2, and degree.
  680. {=HT_PICK pickover}
  681. ~Label=HF_PICKOVER
  682.     Orbit in three dimensions defined by:
  683.       x(n+1) = sin(a*y(n)) - z(n)*cos(b*x(n))
  684.       y(n+1) = z(n)*sin(c*x(n)) - cos(d*y(n))
  685.       z(n+1) = sin(x(n))
  686.     Parameters: a, b, c, and d.
  687. {=HT_PLASMA plasma}
  688. ~Label=HF_PLASMA
  689.     Random, cloud-like formations.  Requires 4 or more colors.
  690.     A recursive algorithm repeatedly subdivides the screen and
  691.     colors pixels according to an average of surrounding pixels
  692.     and a random color, less random as the grid size decreases.
  693.     Four parameters: 'graininess' (.5 to 50, default = 2), old/new
  694.     algorithm, seed value used, 16-bit out output selection.
  695.  
  696. {=HT_POPCORN popcorn}
  697. ~Label=HF_POPCORN
  698.     The orbits in two dimensions defined by:
  699.       x(0) = xpixel, y(0) = ypixel;
  700.       x(n+1) = x(n) - h*sin(y(n) + tan(3*y(n))
  701.       y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n))
  702.     are plotted for each screen pixel and superimposed.
  703.     One parameter: step size h.
  704.  
  705. {=HT_POPCORN popcornjul}
  706. ~Label=HF_POPCJUL
  707.     Conventional Julia using the popcorn formula:
  708.       x(0) = xpixel, y(0) = ypixel;
  709.       x(n+1) = x(n) - h*sin(y(n) + tan(3*y(n))
  710.       y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n))
  711.     One parameter: step size h.
  712.  
  713. {=HT_MARTIN quadruptwo}
  714. ~Label=HF_QUADRUPTWO
  715.     Quadruptwo attractor from Michael Peters - orbit in two dimensions.
  716.       z(0) = y(0) = 0;
  717.       x(n+1) = y(n) - sign(x(n)) * sin(ln(abs(b*x(n)-c)))             
  718.                                  * arctan(sqr(ln(abs(c*x(n)-b))))
  719.       y(n+1) = a - x(n)
  720.     Parameters are a, b, and c.
  721. ~OnlineFF
  722. {=HT_QUAT quatjul}
  723. ~Label=HF_QUATJ
  724.     Quaternion Julia set.
  725.       q(0)   = (xpixel,ypixel,zj,zk)
  726.       q(n+1) = q(n)*q(n) + c.
  727.     Four parameters: c, ci, cj, ck
  728.     c = (c1,ci,cj,ck)
  729.  
  730. {=HT_QUAT quat}
  731. ~Label=HF_QUAT
  732.     Quaternion Mandelbrot set.
  733.       q(0)   = (0,0,0,0)
  734.       q(n+1) = q(n)*q(n) + c.
  735.     Two parameters: cj,ck
  736.     c = (xpixel,ypixel,cj,ck)
  737.  
  738. {=HT_ROSS rossler3D}
  739. ~Label=HF_ROSS
  740.     Orbit in three dimensions defined by:
  741.       x(0) = y(0) = z(0) = 1;
  742.       x(n+1) = x(n) - y(n)*dt -   z(n)*dt
  743.       y(n+1) = y(n) + x(n)*dt + a*y(n)*dt
  744.       z(n+1) = z(n) + b*dt + x(n)*z(n)*dt - c*z(n)*dt
  745.     Parameters are dt, a, b, and c.
  746. ~OnlineFF
  747. {=HT_SIER sierpinski}
  748. ~Label=HF_SIER
  749.     Sierpinski gasket - Julia set producing a 'Swiss cheese triangle'
  750.       z(n+1) = (2*x,2*y-1) if y > .5;
  751.       else (2*x-1,2*y) if x > .5;
  752.       else (2*x,2*y)
  753.     No parameters.
  754.  
  755. {=HT_SCOTSKIN spider}
  756. ~Label=HF_SPIDER
  757.       c(0) = z(0) = pixel;
  758.       z(n+1) = z(n)^2 + c(n);
  759.       c(n+1) = c(n)/2 + z(n+1)
  760.     Parameters: real & imaginary perturbation of z(0)
  761.  
  762. {=HT_SCOTSKIN sqr(1/fn)}
  763. ~Label=HF_SQROVFN
  764.       z(0) = pixel;
  765.       z(n+1) = (1/fn(z(n))^2
  766.     One parameter: the function fn.
  767.  
  768. {=HT_SCOTSKIN sqr(fn)}
  769. ~Label=HF_SQRFN
  770.       z(0) = pixel;
  771.       z(n+1) = fn(z(n))^2
  772.     One parameter: the function fn.
  773. ~OnlineFF
  774. {=HT_TEST test}
  775. ~Label=HF_TEST
  776.     'test' point letting us (and you!) easily add fractal types via
  777.     the c module testpt.c.  Default set up is a mandelbrot fractal.
  778.     Four parameters: user hooks (not used by default testpt.c).
  779.  
  780. {=HT_SCOTSKIN tetrate}
  781. ~Label=HF_TETRATE
  782.       z(0) = c = pixel;
  783.       z(n+1) = c^z(n)
  784.     Parameters: real & imaginary perturbation of z(0)
  785.  
  786. {=HT_MARTIN threeply}
  787. ~Label=HF_THREEPLY
  788.     Threeply attractor by Michael Peters - orbit in two dimensions.
  789.       z(0) = y(0) = 0;
  790.       x(n+1) = y(n) - sign(x(n)) * (abs(sin(x(n))*cos(b)                
  791.                                     +c-x(n)*sin(a+b+c)))
  792.       y(n+1) = a - x(n)
  793.     Parameters are a, b, and c.
  794. ~OnlineFF
  795. {=HT_MARKS tim's_error}
  796. ~Label=HF_TIMSERR
  797.     A serendipitous coding error in marksmandelpwr brings to life
  798.     an ancient pterodactyl!  (Try setting fn to sqr.)
  799.       z(0) = pixel, c = z(0) ^ (z(0) - 1):
  800.       tmp = fn(z(n))
  801.       real(tmp) = real(tmp) * real(c) - imag(tmp) * imag(c);
  802.       imag(tmp) = real(tmp) * imag(c) - imag(tmp) * real(c);
  803.       z(n+1) = tmp + pixel;
  804.     Parameters: real & imaginary perturbations of z(0) and function fn
  805.  
  806. {=HT_UNITY unity}
  807. ~Label=HF_UNITY
  808.       z(0) = pixel;
  809.       x = real(z(n)), y = imag(z(n))
  810.       One = x^2 + y^2;
  811.       y = (2 - One) * x;
  812.       x = (2 - One) * y;
  813.       z(n+1) = x + i*y
  814.     No parameters.
  815. ~CompressSpaces+
  816. ;
  817. ;
  818. ;
  819. ~Topic=Fractal Types
  820.  
  821. A list of the fractal types and their mathematics can be found in the
  822. {Summary of Fractal Types}.  Some notes about how Fractint calculates
  823. them are in "A Little Code" in {"Fractals and the PC"}.
  824.  
  825. Fractint starts by default with the Mandelbrot set. You can change that by
  826. using the command-line argument "TYPE=" followed by one of the
  827. fractal type names, or by using the <T> command and
  828. selecting the type - if parameters are needed, you will be prompted for
  829. them.
  830.  
  831. In the text that follows, due to the limitations of the ASCII character
  832. set, "a*b" means "a times b", and "a^b" means "a to the power b".
  833.  
  834. ~Doc-
  835. Press <PageDown> for type selection list.
  836. ~FF
  837. Select a fractal type:
  838.  
  839. ~Table=40 2 0
  840. { The Mandelbrot Set }
  841. { Julia Sets }
  842. { Inverse Julias }
  843. { Newton domains of attraction }
  844. { Newton }
  845. { Complex Newton }
  846. { Lambda Sets }
  847. { Mandellambda Sets }
  848. { Plasma Clouds }
  849. { Lambdafn }
  850. { Mandelfn }
  851. { Barnsley Mandelbrot/Julia Sets }
  852. { Barnsley IFS Fractals }
  853. { Sierpinski Gasket }
  854. { Quartic Mandelbrot/Julia }
  855. { Distance Estimator }
  856. { Pickover Mandelbrot/Julia Types }
  857. { Pickover Popcorn }
  858. { Dynamic System }
  859. { Quaternion }
  860. { Peterson Variations }
  861. { Unity }
  862. { Circle }
  863. { Scott Taylor / Lee Skinner Variations }
  864. { Kam Torus }
  865. { Bifurcation }
  866. { Orbit Fractals }
  867. { Lorenz Attractors }
  868. { Rossler Attractors }
  869. { Henon Attractors }
  870. { Pickover Attractors }
  871. { Martin Attractors }
  872. { Gingerbreadman }
  873. { Test }
  874. { Formula }
  875. { Julibrots }
  876. { Diffusion Limited Aggregation }
  877. { Magnetic Fractals }
  878. { L-Systems }
  879. { Lyapunov Fractals }
  880. { fn||fn Fractals }
  881. { Halley }
  882. { Cellular Automata }
  883. { Phoenix }
  884. { Frothy Basins }
  885. { Icon }
  886. { Hypercomplex }
  887. ~EndTable
  888. ~Doc+
  889. ;
  890. ;
  891. ~Topic=The Mandelbrot Set, Label=HT_MANDEL
  892. (type=mandel)
  893.  
  894. This set is the classic: the only one implemented in many plotting
  895. programs, and the source of most of the printed fractal images published
  896. in recent years. Like most of the other types in Fractint, it is simply a
  897. graph: the x (horizontal) and y (vertical) coordinate axes represent
  898. ranges of two independent quantities, with various colors used to
  899. symbolize levels of a third quantity which depends on the first two. So
  900. far, so good: basic analytic geometry.
  901.  
  902. Now things get a bit hairier. The x axis is ordinary, vanilla real
  903. numbers. The y axis is an imaginary number, i.e. a real number times i,
  904. where i is the square root of -1. Every point on the plane -- in this
  905. case, your PC's display screen -- represents a complex number of the form:
  906.  
  907.     x-coordinate + i * y-coordinate
  908.  
  909. If your math training stopped before you got to imaginary and complex
  910. numbers, this is not the place to catch up. Suffice it to say that they
  911. are just as "real" as the numbers you count fingers with (they're used
  912. every day by electrical engineers) and they can undergo the same kinds of
  913. algebraic operations.
  914.  
  915. OK, now pick any complex number -- any point on the complex plane -- and
  916. call it C, a constant. Pick another, this time one which can vary, and
  917. call it Z. Starting with Z=0 (i.e., at the origin, where the real and
  918. imaginary axes cross), calculate the value of the expression
  919.  
  920.     Z^2 + C
  921.  
  922. Take the result, make it the new value of the variable Z, and calculate
  923. again. Take that result, make it Z, and do it again, and so on: in
  924. mathematical terms, iterate the function Z(n+1) = Z(n)^2 + C. For certain
  925. values of C, the result "levels off" after a while. For all others, it
  926. grows without limit. The Mandelbrot set you see at the start -- the solid-
  927. colored lake (blue by default), the blue circles sprouting from it, and
  928. indeed every point of that color -- is the set of all points C for which
  929. the magnitude of Z is less than 2 after 150 iterations (150 is the default
  930. setting, changeable via the <X> options screen or "maxiter=" parameter).
  931. All the surrounding "contours" of other colors represent points for which
  932. the magnitude of Z exceeds 2 after 149 iterations (the contour closest to
  933. the M-set itself), 148 iterations, (the next one out), and so on.
  934.  
  935. We actually don't test for the magnitude of Z exceeding 2 - we test the
  936. magnitude of Z squared against 4 instead because it is easier.  This value
  937. (FOUR usually) is known as the "bailout" value for the calculation, because
  938. we stop iterating for the point when it is reached.  The bailout value can
  939. be changed on the <Z> options screen but the default is usually best.  See
  940. also {Bailout Test}.
  941.  
  942. Some features of interest:
  943.  
  944. 1. Use the <X> options screen to increase the maximum number of iterations.
  945. Notice that the boundary of the M-set becomes more and more convoluted (the
  946. technical terms are "wiggly," "squiggly," and "utterly bizarre") as the Z-
  947. magnitudes for points that were still within the set after 150 iterations turn
  948. out to exceed 2 after 200, 500, or 1200. In fact, it can be proven that
  949. the true boundary is infinitely long: detail without limit.
  950.  
  951. 2. Although there appear to be isolated "islands" of blue, zoom in -- that
  952. is, plot for a smaller range of coordinates to show more detail -- and
  953. you'll see that there are fine "causeways" of blue connecting them to the
  954. main set. As you zoomed, smaller islands became visible; the same is true
  955. for them. In fact, there are no isolated points in the M-set: it is
  956. "connected" in a strict mathematical sense.
  957.  
  958. 3. The upper and lower halves of the first image are symmetric (a fact
  959. that Fractint makes use of here and in some other fractal types to speed
  960. plotting). But notice that the same general features -- lobed discs,
  961. spirals, starbursts -- tend to repeat themselves (although never exactly)
  962. at smaller and smaller scales, so that it can be impossible to judge by
  963. eye the scale of a given image.
  964.  
  965. 4. In a sense, the contour colors are window-dressing: mathematically, it
  966. is the properties of the M-set itself that are interesting, and no
  967. information about it would be lost if all points outside the set were
  968. assigned the same color. If you're a serious, no-nonsense type, you may
  969. want to cycle the colors just once to see the kind of silliness that other
  970. people enjoy, and then never do it again. Go ahead. Just once, now. We
  971. trust you.
  972. ;
  973. ;
  974. ~Topic=Julia Sets, Label=HT_JULIA
  975. (type=julia)
  976.  
  977. These sets were named for mathematician Gaston Julia, and can be generated
  978. by a simple change in the iteration process described for the
  979. {=HT_MANDEL Mandelbrot Set}.  Start with a
  980. specified value of C, "C-real + i * C-imaginary"; use as the initial value
  981. of Z "x-coordinate + i * y-coordinate"; and repeat the same iteration,
  982. Z(n+1) = Z(n)^2 + C.
  983.  
  984. There is a Julia set corresponding to every point on the complex plane --
  985. an infinite number of Julia sets. But the most visually interesting tend
  986. to be found for the same C values where the M-set image is busiest, i.e.
  987. points just outside the boundary. Go too far inside, and the corresponding
  988. Julia set is a circle; go too far outside, and it breaks up into scattered
  989. points. In fact, all Julia sets for C within the M-set share the
  990. "connected" property of the M-set, and all those for C outside lack it.
  991.  
  992. Fractint's spacebar toggle lets you "flip" between any view of the M-set
  993. and the Julia set for the point C at the center of that screen. You can
  994. then toggle back, or zoom your way into the Julia set for a while and then
  995. return to the M-set. So if the infinite complexity of the M-set palls,
  996. remember: each of its infinite points opens up a whole new Julia set.
  997.  
  998. Historically, the Julia sets came first: it was while looking at the M-set
  999. as an "index" of all the Julia sets' origins that Mandelbrot noticed its
  1000. properties.
  1001.  
  1002. The relationship between the {=HT_MANDEL Mandelbrot} set and Julia set can
  1003. hold between
  1004. other sets as well.  Many of Fractint's types are "Mandelbrot/Julia" pairs
  1005. (sometimes called "M-sets" or "J-sets". All these are generated by
  1006. equations that are of the form z(k+1) = f(z(k),c), where the function
  1007. orbit is the sequence z(0), z(1), ..., and the variable c is a complex
  1008. parameter of the equation. The value c is fixed for "Julia" sets and is
  1009. equal to the first two parameters entered with the "params=Creal/Cimag"
  1010. command. The initial orbit value z(0) is the complex number corresponding
  1011. to the screen pixel. For Mandelbrot sets, the parameter c is the complex
  1012. number corresponding to the screen pixel. The value z(0) is c plus a
  1013. perturbation equal to the values of the first two parameters.  See
  1014. the discussion of {=HT_MLAMBDA Mandellambda Sets}.
  1015. This approach may or may not be the
  1016. "standard" way to create "Mandelbrot" sets out of "Julia" sets.
  1017.  
  1018. Some equations have additional parameters.  These values are entered as the
  1019. third or fourth params= value for both Julia and Mandelbrot sets. The
  1020. variables x and y refer to the real and imaginary parts of z; similarly,
  1021. cx and cy are the real and imaginary parts of the parameter c and fx(z)
  1022. and fy(z) are the real and imaginary parts of f(z). The variable c is
  1023. sometimes called lambda for historical reasons.
  1024.  
  1025. NOTE: if you use the "PARAMS=" argument to warp the M-set by starting with
  1026. an initial value of Z other than 0, the M-set/J-sets correspondence breaks
  1027. down and the spacebar toggle no longer works.
  1028. ;
  1029. ;
  1030. ~Topic=Julia Toggle Spacebar Commands, Label=HELP_JIIM
  1031. The spacebar toggle has been enhanced for the classic Mandelbrot and Julia 
  1032. types. When viewing the Mandelbrot, the spacebar turns on a window mode that 
  1033. displays the Inverse Julia corresponding to the cursor position in a window. 
  1034. Pressing the spacebar then causes the regular Julia escape time fractal 
  1035. corresponding to the cursor position to be generated. The following keys 
  1036. take effect in Inverse Julia mode. 
  1037.  
  1038. <Space>     Generate the escape-time Julia Set corresponding to the cursor\
  1039.             position. Only works if fractal is a "Mandelbrot" type.\
  1040. <n>         Numbers toggle - shows coordinates of the cursor on the\ 
  1041.             screen. Press <n> again to turn off numbers.\
  1042. <p>         Enter new pixel coordinates directly\ 
  1043. <h>         Hide fractal toggle. Works only if View Windows is turned on\ 
  1044.             and set for a small window (such as the default size.) Hides \ 
  1045.             the fractal, allowing the orbit to take up the whole screen. \
  1046.             Press <h> again to uncover the fractal.\
  1047. <s>         Saves the fractal, cursor, orbits, and numbers.\
  1048. <<> or <,>  Zoom inverse julia image smaller.\
  1049. <>> or <.>  Zoom inverse julia image larger.\
  1050. <z>         Restore default zoom.\
  1051.  
  1052. The Julia Inverse window is only implemented for the classic Mandelbrot
  1053. (type=mandel). For other "Mandelbrot" types <space> turns on the cursor 
  1054. without the Julia window, and allows you to select coordinates of the
  1055. matching Julia set in a way similar to the use of the zoom box with the 
  1056. Mandelbrot/Julia toggle in previous Fractint versions.
  1057. ;
  1058. ;
  1059. ~Topic=Inverse Julias, Label=HT_INVERSE
  1060. (type=julia_inverse)
  1061.  
  1062. Pick a function, such as the familiar Z(n) = Z(n-1) squared plus C
  1063. (the defining function of the Mandelbrot Set).  If you pick a point Z(0)
  1064. at random from the complex plane, and repeatedly apply the function to it,
  1065. you get a sequence of new points called an orbit, which usually either 
  1066. zips out toward infinity or zooms in toward one or more "attractor" points
  1067. near the middle of the plane.  The set of all points that are "attracted"
  1068. to infinity is called the "Basin of Attraction" of infinity.  Each of the
  1069. other attractors also has its own Basin of Attraction.  Why is it called
  1070. a Basin?  Imagine a lake, and all the water in it "draining" into the
  1071. attractor.  The boundary between these basins is called the Julia Set of
  1072. the function.
  1073.  
  1074. The boundary between the basins of attraction is sort of like a 
  1075. repeller; all orbits move away from it, toward one of the attractors.
  1076. But if we define a new function as the inverse of the old one, as for
  1077. instance Z(n) = sqrt(Z(n-1) minus C), then the old attractors become
  1078. repellers, and the former boundary itself becomes the attractor!  Now,
  1079. starting from any point, all orbits are drawn irresistibly to the Julia
  1080. Set!  In fact, once an orbit reaches the boundary, it will continue to
  1081. hop about until it traces the entire Julia Set!  This method for drawing
  1082. Julia Sets is called the Inverse Iteration Method, or IIM for short.
  1083.  
  1084. Unfortunately, some parts of each Julia Set boundary are far more 
  1085. attractive to inverse orbits than others are, so that as an orbit 
  1086. traces out the set, it keeps coming back to these attractive parts
  1087. again and again, only occasionally visiting the less attractive parts.
  1088. Thus it may take an infinite length of time to draw the entire set.
  1089. To hasten the process, we can keep track of how many times each pixel
  1090. on our computer screen is visited by an orbit, and whenever an orbit
  1091. reaches a pixel that has already been visited more than a certain number
  1092. of times, we can consider that orbit finished and move on to another one.
  1093. This "hit limit" thus becomes similar to the iteration limit used in the
  1094. traditional escape-time fractal algorithm.  This is called the Modified
  1095. Inverse Iteration Method, or MIIM, and is much faster than the IIM.
  1096.  
  1097. Now, the inverse of Mandelbrot's classic function is a square root, and
  1098. the square root actually has two solutions; one positive, one negative.
  1099. Therefore at each step of each orbit of the inverse function there is
  1100. a decision; whether to use the positive or the negative square root.  
  1101. Each one gives rise to a new point on the Julia Set, so each is a good
  1102. choice.  This series of choices defines a binary decision tree, each
  1103. point on the Julia Set giving rise to two potential child points.  
  1104. There are many interesting ways to traverse a binary tree, among them
  1105. Breadth first, Depth first (left or negative first), Depth first (right
  1106. or positive first), and completely at random.  It turns out that most 
  1107. traversal methods lead to the same or similar pictures, but that how the
  1108. image evolves as the orbits trace it out differs wildly depending on the
  1109. traversal method chosen.  As far as we know, this fact is an original 
  1110. discovery by Michael Snyder, and version 18.2 of FRACTINT was its first 
  1111. publication.
  1112.  
  1113. Pick a Julia constant such as Z(0) = (-.74543, .11301), the popular
  1114. Seahorse Julia, and try drawing it first Breadth first, then Depth first
  1115. (right first), Depth first (left first), and finally with Random Walk.
  1116.  
  1117. Caveats: the video memory is used in the algorithm, to keep track of 
  1118. how many times each pixel has been visited (by changing it's color). 
  1119. Therefore the algorithm will not work well if you zoom in far enough that
  1120. part of the Julia Set is off the screen.
  1121.  
  1122. Bugs:   Not working with Disk Video.
  1123.         Not resumeable.
  1124.  
  1125. The <J> key toggles between the Inverse Julia orbit and the 
  1126. corresponding Julia escape time fractal.
  1127. ;
  1128. ;
  1129. ~Topic=Newton domains of attraction, Label=HT_NEWTBAS
  1130. (type=newtbasin)
  1131.  
  1132. The Newton formula is an algorithm used to find the roots of polynomial
  1133. equations by successive "guesses" that converge on the correct value as
  1134. you feed the results of each approximation back into the formula. It works
  1135. very well -- unless you are unlucky enough to pick a value that is on a
  1136. line BETWEEN two actual roots. In that case, the sequence explodes into
  1137. chaos, with results that diverge more and more wildly as you continue the
  1138. iteration.
  1139.  
  1140. This fractal type shows the results for the polynomial Z^n - 1, which has
  1141. n roots in the complex plane. Use the <T>ype command and enter "newtbasin"
  1142. in response to the prompt. You will be asked for a parameter, the "order"
  1143. of the equation (an integer from 3 through 10 -- 3 for x^3-1, 7 for x^7-1,
  1144. etc.). A second parameter is a flag to turn on alternating shades showing
  1145. changes in the number of iterations needed to attract an orbit. Some
  1146. people like stripes and some don't, as always, Fractint gives you a
  1147. choice!
  1148.  
  1149. The coloring of the plot shows the "basins of attraction" for each root of
  1150. the polynomial -- i.e., an initial guess within any area of a given color
  1151. would lead you to one of the roots. As you can see, things get a bit weird
  1152. along certain radial lines or "spokes," those being the lines between
  1153. actual roots. By "weird," we mean infinitely complex in the good old
  1154. fractal sense. Zoom in and see for yourself.
  1155.  
  1156. This fractal type is symmetric about the origin, with the number of
  1157. "spokes" depending on the order you select. It uses floating-point math if
  1158. you have an FPU, or a somewhat slower integer algorithm if you don't have
  1159. one.
  1160. ~Doc-
  1161.  
  1162. See also: {Newton}
  1163. ~Doc+
  1164. ;
  1165. ;
  1166. ~Topic=Newton, Label=HT_NEWT
  1167. (type=newton)
  1168.  
  1169. The generating formula here is identical to that for {=HT_NEWTBAS newtbasin},
  1170. but the
  1171. coloring scheme is different. Pixels are colored not according to the root
  1172. that would be "converged on" if you started using Newton's formula from
  1173. that point, but according to the iteration when the value is close to a
  1174. root.  For example, if the calculations for a particular pixel converge to
  1175. the 7th root on the 23rd iteration, NEWTBASIN will color that pixel using
  1176. color #7, but NEWTON will color it using color #23.
  1177.  
  1178. If you have a 256-color mode, use it: the effects can be much livelier
  1179. than those you get with type=newtbasin, and color cycling becomes, like,
  1180. downright cosmic. If your "corners" choice is symmetrical, Fractint
  1181. exploits the symmetry for faster display.
  1182.  
  1183. The applicable "params=" values are the same as newtbasin. Try "params=4."
  1184. Other values are 3 through 10. 8 has twice the symmetry and is faster. As
  1185. with newtbasin, an FPU helps.
  1186. ;
  1187. ;
  1188. ~Topic=Complex Newton, Label=HT_NEWTCMPLX
  1189. (type=complexnewton/complexbasin)
  1190.  
  1191. Well, hey, "Z^n - 1" is so boring when you can use "Z^a - b" where "a" and
  1192. "b" are complex numbers!  The new "complexnewton" and "complexbasin"
  1193. fractal types are just the old {=HT_NEWT "newton"} and
  1194. {=HT_NEWTBAS "newtbasin"} fractal types with
  1195. this little added twist.  When you select these fractal types, you are
  1196. prompted for four values (the real and imaginary portions of "a" and "b").
  1197. If "a" has a complex portion, the fractal has a discontinuity along the
  1198. negative axis - relax, we finally figured out that it's *supposed* to be
  1199. there!
  1200. ;
  1201. ;
  1202. ~Topic=Lambda Sets, Label=HT_LAMBDA
  1203. (type=lambda)
  1204.  
  1205. This type calculates the Julia set of the formula lambda*Z*(1-Z). That is,
  1206. the value Z[0] is initialized with the value corresponding to each pixel
  1207. position, and the formula iterated. The pixel is colored according to the
  1208. iteration when the sum of the squares of the real and imaginary parts
  1209. exceeds 4.
  1210.  
  1211. Two parameters, the real and imaginary parts of lambda, are required. Try
  1212. 0 and 1 to see the classical fractal "dragon". Then try 0.2 and 1 for a
  1213. lot more detail to zoom in on.
  1214.  
  1215. It turns out that all quadratic Julia-type sets can be calculated using
  1216. just the formula z^2+c (the "classic" Julia"), so that this type is
  1217. redundant, but we include it for reason of it's prominence in the history
  1218. of fractals.
  1219. ;
  1220. ;
  1221. ~Topic=Mandellambda Sets, Label=HT_MLAMBDA
  1222. (type=mandellambda)
  1223.  
  1224. This type is the "Mandelbrot equivalent" of the {=HT_LAMBDA lambda} set.
  1225. A comment is
  1226. in order here. Almost all the Fractint "Mandelbrot" sets are created from
  1227. orbits generated using formulas like z(n+1) = f(z(n),C), with z(0) and C
  1228. initialized to the complex value corresponding to the current pixel. Our
  1229. reasoning was that "Mandelbrots" are maps of the corresponding "Julias".
  1230. Using this scheme each pixel of a "Mandelbrot" is colored the same as the
  1231. Julia set corresponding to that pixel. However, Kevin Allen informs us
  1232. that the MANDELLAMBDA set appears in the literature with z(0) initialized
  1233. to a critical point (a point where the derivative of the formula is zero),
  1234. which in this case happens to be the point (.5,0). Since Kevin knows more
  1235. about Dr. Mandelbrot than we do, and Dr. Mandelbrot knows more about
  1236. fractals than we do, we defer! Starting with version 14 Fractint
  1237. calculates MANDELAMBDA Dr. Mandelbrot's way instead of our way. But ALL
  1238. THE OTHER "Mandelbrot" sets in Fractint are still calculated OUR way!
  1239. (Fortunately for us, for the classic Mandelbrot Set these two methods are
  1240. the same!)
  1241.  
  1242. Well now, folks, apart from questions of faithfulness to fractals named in
  1243. the literature (which we DO take seriously!), if a formula makes a
  1244. beautiful fractal, it is not wrong. In fact some of the best fractals in
  1245. Fractint are the results of mistakes! Nevertheless, thanks to Kevin for
  1246. keeping us accurate!
  1247.  
  1248. (See description of "initorbit=" command in {Image Calculation Parameters}
  1249. for a way to experiment with different orbit intializations).
  1250. ;
  1251. ;
  1252. ~Topic=Circle, Label=HT_CIRCLE
  1253. (type=circle)
  1254.  
  1255. This fractal types is from A. K. Dewdney's "Computer Recreations" column
  1256. in "Scientific American". It is attributed to John Connett of the 
  1257. University of Minnesota.
  1258.  
  1259. (Don't tell anyone, but this fractal type is not really a fractal!)
  1260.  
  1261. Fascinating Moire patterns can be formed by calculating x^2 + y^2 for
  1262. each pixel in a piece of the complex plane. After multiplication by a 
  1263. magnification factor (the parameter), the number is truncated to an integer 
  1264. and mapped to a color via color = value modulo (number of colors). That is, 
  1265. the integer is divided by the number of colors, and the remainder is the 
  1266. color index value used.  The resulting image is not a fractal because all 
  1267. detail is lost after zooming in too far. Try it with different resolution 
  1268. video modes - the results may surprise you!
  1269. ;
  1270. ;
  1271. ~Topic=Plasma Clouds, Label=HT_PLASMA
  1272. (type=plasma)
  1273.  
  1274. Plasma clouds ARE real live fractals, even though we didn't know it at
  1275. first. They are generated by a recursive algorithm that randomly picks
  1276. colors of the corner of a rectangle, and then continues recursively
  1277. quartering previous rectangles. Random colors are averaged with those of
  1278. the outer rectangles so that small neighborhoods do not show much change,
  1279. for a smoothed-out, cloud-like effect. The more colors your video mode
  1280. supports, the better.  The result, believe it or not, is a fractal
  1281. landscape viewed as a contour map, with colors indicating constant
  1282. elevation.  To see this, save and view with the <3> command
  1283. (see {\"3D\" Images})
  1284. and your "cloud" will be converted to a mountain!
  1285.  
  1286. You've GOT to try {=@ColorCycling color cycling} on these (hit "+" or "-").
  1287. If you
  1288. haven't been hypnotized by the drawing process, the writhing colors will
  1289. do it for sure. We have now implemented subliminal messages to exploit the
  1290. user's vulnerable state; their content varies with your bank balance,
  1291. politics, gender, accessibility to a Fractint programmer, and so on. A
  1292. free copy of Microsoft C to the first person who spots them.
  1293.  
  1294. This type accepts four parameters.
  1295.  
  1296. The first determines how abruptly the colors change. A value of .5 yields
  1297. bland clouds, while 50 yields very grainy ones. The default value is 2.
  1298.  
  1299. The second determines whether to use the original algorithm (0) or a
  1300. modified one (1). The new one gives the same type of images but draws
  1301. the dots in a different order. It will let you see
  1302. what the final image will look like much sooner than the old one.
  1303.  
  1304. The third determines whether to use a new seed for generating the
  1305. next plasma cloud (0) or to use the previous seed (1).
  1306.  
  1307. The fourth parameter turns on 16-bit .POT output which provides much
  1308. smoother height gradations. This is especially useful for creating 
  1309. mountain landscapes when using the plasma output with a ray tracer
  1310. such as POV-Ray.
  1311.  
  1312. With parameter three set to 1, the next plasma cloud generated will be 
  1313. identical to the previous but at whatever new resolution is desired.
  1314.  
  1315. Zooming is ignored, as each plasma-cloud screen is generated randomly.
  1316.  
  1317. The random number seed used for each plasma image is displayed on the
  1318. <tab> information screen, and can be entered with the command line
  1319. parameter "rseed=" to recreate a particular image. 
  1320.  
  1321. The algorithm is based on the Pascal program distributed by Bret Mulvey as
  1322. PLASMA.ARC. We have ported it to C and integrated it with Fractint's
  1323. graphics and animation facilities. This implementation does not use
  1324. floating-point math. The algorithm was modified starting with version 18 
  1325. so that the plasma effect is independent of screen resolution.
  1326.  
  1327. Saved plasma-cloud screens are EXCELLENT starting images for fractal
  1328. "landscapes" created with the {\"3D\" commands}.
  1329. ;
  1330. ;
  1331. ~Topic=Lambdafn, Label=HT_LAMBDAFN
  1332. (type=lambdafn)
  1333.  
  1334. Function=[sin|cos|sinh|cosh|exp|log|sqr|...]) is specified with this type.
  1335. Prior to version 14, these types were lambdasine, lambdacos, lambdasinh,
  1336. lambdacos, and lambdaexp.  Where we say "lambdasine" or some such below,
  1337. the good reader knows we mean "lambdafn with function=sin".)
  1338.  
  1339. These types calculate the Julia set of the formula lambda*fn(Z), for
  1340. various values of the function "fn", where lambda and Z are both complex.
  1341. Two values, the real and imaginary parts of lambda, should be given in the
  1342. "params=" option.  For the feathery, nested spirals of LambdaSines and the
  1343. frost-on-glass patterns of LambdaCosines, make the real part = 1, and try
  1344. values for the imaginary part ranging from 0.1 to 0.4 (hint: values near
  1345. 0.4 have the best patterns). In these ranges the Julia set "explodes". For
  1346. the tongues and blobs of LambdaExponents, try a real part of 0.379 and an
  1347. imaginary part of 0.479.
  1348.  
  1349. A coprocessor used to be almost mandatory: each LambdaSine/Cosine
  1350. iteration calculates a hyperbolic sine, hyperbolic cosine, a sine, and a
  1351. cosine (the LambdaExponent iteration "only" requires an exponent, sine,
  1352. and cosine operation)!    However, Fractint now computes these
  1353. transcendental functions with fast integer math. In a few cases the fast
  1354. math is less accurate, so we have kept the old slow floating point code.
  1355. To use the old code, invoke with the float=yes option, and, if you DON'T
  1356. have a coprocessor, go on a LONG vacation!
  1357. ;
  1358. ;
  1359. ~Topic=Halley, Label=HT_HALLEY
  1360. (type=halley)
  1361.  
  1362. The Halley map is an algorithm used to find the roots of polynomial
  1363. equations by successive "guesses" that converge on the correct value as
  1364. you feed the results of each approximation back into the formula. It works
  1365. very well -- unless you are unlucky enough to pick a value that is on a
  1366. line BETWEEN two actual roots. In that case, the sequence explodes into
  1367. chaos, with results that diverge more and more wildly as you continue the
  1368. iteration.
  1369.  
  1370. This fractal type shows the results for the polynomial Z(Z^a - 1), which
  1371. has a+1 roots in the complex plane. Use the <T>ype command and enter
  1372. "halley" in response to the prompt. You will be asked for a parameter, the
  1373. "order" of the equation (an integer from 2 through 10 -- 2 for Z(Z^2 - 1),
  1374. 7 for Z(Z^7 - 1), etc.). A second parameter is the relaxation coefficient,
  1375. and is used to control the convergence stability. A number greater than
  1376. one increases the chaotic behavior and a number less than one decreases the
  1377. chaotic behavior. The third parameter is the value used to determine when
  1378. the formula has converged. The test for convergence is
  1379. ||Z(n+1)|^2 - |Z(n)|^2| < epsilon. This convergence test produces the
  1380. whisker-like projections which generally point to a root.
  1381. ;
  1382. ;
  1383. ~Topic=Phoenix, Label=HT_PHOENIX
  1384. (type=phoenix, mandphoenix, phoenixcplx, mandphoenixclx)
  1385.  
  1386. The phoenix type defaults to the original phoenix curve discovered by
  1387. Shigehiro Ushiki, "Phoenix", IEEE Transactions on Circuits and Systems,
  1388. Vol. 35, No. 7, July 1988, pp. 788-789.  These images do not have the
  1389. X and Y axis swapped as is normal for this type.
  1390.  
  1391. The mandphoenix type is the corresponding Mandelbrot set image of the
  1392. phoenix type.  The spacebar toggles between the two as long as the
  1393. mandphoenix type has an initial z(0) of (0,0).  The mandphoenix is not
  1394. an effective index to the phoenix type, so explore the wild blue yonder.
  1395.  
  1396. To reproduce the Mandelbrot set image of the phoenix type as shown in
  1397. Stevens' book, "Fractal Programming in C", set initorbit=0/0 on the
  1398. command line or with the <g> key.  The colors need to be rotated one
  1399. position because Stevens uses the values from the previous calculation
  1400. instead of the current calculation to determine when to bailout.
  1401.  
  1402. The phoenixcplx type is implemented using complex constants instead of the
  1403. real constants that Stevens used.  This recreates the mapping as
  1404. originally presented by Ushiki.
  1405.  
  1406. The mandphoenixclx type is the corresponding Mandelbrot set image of the
  1407. phoenixcplx type.  The spacebar toggles between the two as long as the
  1408. mandphoenixclx type has a perturbation of z(0) = (0,0).  The mandphoenixclx
  1409. is an effective index to the phoenixcplx type.
  1410. ;
  1411. ;
  1412. ~Topic=fn||fn Fractals, Label=HT_FNORFN
  1413. (type=lambda(fn||fn), manlam(fn||fn), julia(fn||fn), mandel(fn||fn))
  1414.  
  1415. Two functions=[sin|cos|sinh|cosh|exp|log|sqr|...]) are specified with
  1416. these types.  The two functions are alternately used in the calculation
  1417. based on a comparison between the modulus of the current Z and the
  1418. shift value.  The first function is used if the modulus of Z is less
  1419. than the shift value and the second function is used otherwise.
  1420.  
  1421. The lambda(fn||fn) type calculates the Julia set of the formula
  1422. lambda*fn(Z), for various values of the function "fn", where lambda
  1423. and Z are both complex.  Two values, the real and imaginary parts of
  1424. lambda, should be given in the "params=" option.  The third value is
  1425. the shift value.  The space bar will generate the corresponding
  1426. "pseudo Mandelbrot" set, manlam(fn||fn).
  1427.  
  1428. The manlam(fn||fn) type calculates the "pseudo Mandelbrot" set of the
  1429. formula fn(Z)*C, for various values of the function "fn", where C
  1430. and Z are both complex.  Two values, the real and imaginary parts of
  1431. Z(0), should be given in the "params=" option.  The third value is
  1432. the shift value.  The space bar will generate the corresponding
  1433. julia set, lamda(fn||fn).
  1434.  
  1435. The julia(fn||fn) type calculates the Julia set of the formula
  1436. fn(Z)+C, for various values of the function "fn", where C
  1437. and Z are both complex.  Two values, the real and imaginary parts of
  1438. C, should be given in the "params=" option.  The third value is
  1439. the shift value.  The space bar will generate the corresponding
  1440. mandelbrot set, mandel(fn||fn).
  1441.  
  1442. The mandel(fn||fn) type calculates the Mandelbrot set of the formula
  1443. fn(Z)+C, for various values of the function "fn", where C
  1444. and Z are both complex.  Two values, the real and imaginary parts of
  1445. Z(0), should be given in the "params=" option.  The third value is
  1446. the shift value.  The space bar will generate the corresponding
  1447. julia set, julia(fn||fn).
  1448. ;
  1449. ;
  1450. ~Topic=Mandelfn, Label=HT_MANDFN
  1451. (type=mandelfn)
  1452.  
  1453. Function=[sin|cos|sinh|cosh|exp|log|sqr|...]) is specified with this type.
  1454. Prior to version 14, these types were mandelsine, mandelcos, mandelsinh,
  1455. mandelcos, and mandelexp. Same comment about our lapses into the old
  1456. terminology as above!
  1457.  
  1458. These are "pseudo-Mandelbrot" mappings for the {=HT_LAMBDAFN LambdaFn}
  1459. Julia functions.
  1460. They map to their corresponding Julia sets via the spacebar command in
  1461. exactly the same fashion as the original M/J sets.  In general, they are
  1462. interesting mainly because of that property (the function=exp set in
  1463. particular is rather boring). Generate the appropriate "Mandelfn" set,
  1464. zoom on a likely spot where the colors are changing rapidly, and hit the
  1465. spacebar key to plot the Julia set for that particular point.
  1466.  
  1467. Try "FRACTINT TYPE=MANDELFN CORNERS=4.68/4.76/-.03/.03 FUNCTION=COS" for a
  1468. graphic demonstration that we're not taking Mandelbrot's name in vain
  1469. here. We didn't even know these little buggers were here until Mark
  1470. Peterson found this a few hours before the version incorporating Mandelfns
  1471. was released.
  1472.  
  1473. Note: If you created images using the lambda or mandel "fn" types prior to
  1474. version 14, and you wish to update the fractal information in the "*.fra"
  1475. file, simply read the files and save again. You can do this in batch mode
  1476. via a command line such as:
  1477.  
  1478.      "fractint oldfile.fra savename=newfile.gif batch=yes"
  1479.  
  1480. For example, this procedure can convert a version 13 "type=lambdasine"
  1481. image to a version 14 "type=lambdafn function=sin" GIF89a image.  We do
  1482. not promise to keep this "backward compatibility" past version 14 - if you
  1483. want to keep the fractal information in your *.fra files accurate, we
  1484. recommend conversion.  See {GIF Save File Format}.
  1485. ;
  1486. ;
  1487. ~Topic=Barnsley Mandelbrot/Julia Sets, Label=HT_BARNS
  1488. (type=barnsleym1/.../j3)
  1489.  
  1490. Michael Barnsley has written a fascinating college-level text, "Fractals
  1491. Everywhere," on fractal geometry and its graphic applications. (See
  1492. {Bibliography}.) In it, he applies the principle of the M and J
  1493. sets to more general functions of two complex variables.
  1494.  
  1495. We have incorporated three of Barnsley's examples in Fractint. Their
  1496. appearance suggests polarized-light microphotographs of minerals, with
  1497. patterns that are less organic and more crystalline than those of the M/J
  1498. sets. Each example has both a "Mandelbrot" and a "Julia" type. Toggle
  1499. between them using the spacebar.
  1500.  
  1501. The parameters have the same meaning as they do for the "regular"
  1502. Mandelbrot and Julia. For types M1, M2, and M3, they are used to "warp"
  1503. the image by setting the initial value of Z. For the types J1 through J3,
  1504. they are the values of C in the generating formulas.
  1505.  
  1506. Be sure to try the <O>rbit function while plotting these types.
  1507. ;
  1508. ;
  1509. ~Topic=Barnsley IFS Fractals, Label=HT_IFS
  1510. (type=ifs)
  1511.  
  1512. One of the most remarkable spin-offs of fractal geometry is the ability to
  1513. "encode" realistic images in very small sets of numbers -- parameters for
  1514. a set of functions that map a region of two-dimensional space onto itself.
  1515. In principle (and increasingly in practice), a scene of any level of
  1516. complexity and detail can be stored as a handful of numbers, achieving
  1517. amazing "compression" ratios... how about a super-VGA image of a forest,
  1518. more than 300,000 pixels at eight bits apiece, from a 1-KB "seed" file?
  1519.  
  1520. Again, Michael Barnsley and his co-workers at the Georgia Institute of
  1521. Technology are to be thanked for pushing the development of these iterated
  1522. function systems (IFS).
  1523.  
  1524. When you select this fractal type, Fractint scans the current IFS file
  1525. (default is FRACTINT.IFS, a set of definitions supplied with Fractint) for
  1526. IFS definitions, then prompts you for the IFS name you wish to run. Fern
  1527. and 3dfern are good ones to start with. You can press <F6> at the
  1528. selection screen if you want to select a different .IFS file you've
  1529. written.
  1530.  
  1531. Note that some Barnsley IFS values generate images quite a bit smaller
  1532. than the initial (default) screen. Just bring up the zoom box, center it
  1533. on the small image, and hit <Enter> to get a full-screen image.
  1534.  
  1535. To change the number of dots Fractint generates for an IFS image before
  1536. stopping, you can change the "maximum iterations" parameter on the <X>
  1537. options screen.
  1538.  
  1539. Fractint supports two types of IFS images: 2D and 3D. In order to fully
  1540. appreciate 3D IFS images, since your monitor is presumably 2D, we have
  1541. added rotation, translation, and perspective capabilities. These share
  1542. values with the same variables used in Fractint's other 3D facilities; for
  1543. their meaning see {"Rectangular Coordinate Transformation"}.
  1544. You can enter these values from the command line using:
  1545.  
  1546. rotation=xrot/yrot/zrot       (try 30/30/30)\
  1547. shift=xshift/yshift          (shifts BEFORE applying perspective!)\
  1548. perspective=viewerposition    (try 200)\
  1549.  
  1550. Alternatively, entering <I> from main screen will allow you to modify
  1551. these values. The defaults are the same as for regular 3D, and are not
  1552. always optimum for 3D IFS. With the 3dfern IFS type, try
  1553. rotation=30/30/30. Note that applying shift when using perspective changes
  1554. the picture -- your "point of view" is moved.
  1555.  
  1556. A truly wild variation of 3D may be seen by entering "2" for the stereo
  1557. mode (see {"Stereo 3D Viewing"}),
  1558. putting on red/blue "funny glasses", and watching the fern develop
  1559. with full depth perception right there before your eyes!
  1560.  
  1561. This feature USED to be dedicated to Bruce Goren, as a bribe to get him to
  1562. send us MORE knockout stereo slides of 3D ferns, now that we have made it
  1563. so easy! Bruce, what have you done for us *LATELY* ?? (Just kidding,
  1564. really!)
  1565.  
  1566. Each line in an IFS definition (look at FRACTINT.IFS with your editor for
  1567. examples) contains the parameters for one of the generating functions,
  1568. e.g. in FERN:
  1569. ~Format-
  1570.    a    b     c    d    e    f      p
  1571.  ___________________________________
  1572.    0     0    0  .16    0    0     .01
  1573.  .85   .04 -.04  .85    0  1.6     .85
  1574.  .2   -.26  .23  .22    0  1.6     .07
  1575. -.15   .28  .26  .24    0  .44     .07
  1576.  
  1577. The values on each line define a matrix, vector, and probability:
  1578.     matrix   vector  prob
  1579.     |a b|     |e|     p
  1580.     |c d|     |f|
  1581. ~Format+
  1582.  
  1583. The "p" values are the probabilities assigned to each function (how often
  1584. it is used), which add up to one. Fractint supports up to 32 functions,
  1585. although usually three or four are enough.
  1586.  
  1587. 3D IFS definitions are a bit different.  The name is followed by (3D) in
  1588. the definition file, and each line of the definition contains 13 numbers:
  1589. a b c d e f g h i j k l p, defining:
  1590.     matrix   vector  prob\
  1591.     |a b c|   |j|     p\
  1592.     |d e f|   |k|\
  1593.     |g h i|   |l|\
  1594.  
  1595. ;You can experiment with changes to IFS definitions interactively by using
  1596. ;Fractint's <Z> command.  After selecting an IFS definition, hit <Z> to
  1597. ;bring up the IFS editor. This editor displays the current IFS values, lets
  1598. ;you modify them, and lets you save your modified values as a text file
  1599. ;which you can then merge into an XXX.IFS file for future use with
  1600. ;Fractint.
  1601. ;
  1602. The program FDESIGN can be used to design IFS fractals - see
  1603. {=@FDESIGN FDESIGN}.
  1604.  
  1605. You can save the points in your IFS fractal in the file ORBITS.RAW which is
  1606. overwritten each time a fractal is generated. The program Acrospin can
  1607. read this file and will let you view the fractal from any angle using
  1608. the cursor keys. See {=@ACROSPIN Acrospin}.
  1609. ;
  1610. ;
  1611. ~Topic=Sierpinski Gasket, Label=HT_SIER
  1612. (type=sierpinski)
  1613.  
  1614. Another pre-Mandelbrot classic, this one found by W. Sierpinski around
  1615. World War I. It is generated by dividing a triangle into four congruent
  1616. smaller triangles, doing the same to each of them, and so on, yea, even
  1617. unto infinity. (Notice how hard we try to avoid reiterating "iterating"?)
  1618.  
  1619. If you think of the interior triangles as "holes", they occupy more and
  1620. more of the total area, while the "solid" portion becomes as hopelessly
  1621. fragile as that gasket you HAD to remove without damaging it -- you
  1622. remember, that Sunday afternoon when all the parts stores were closed?
  1623. There's a three-dimensional equivalent using nested tetrahedrons instead
  1624. of triangles, but it generates too much pyramid power to be safely
  1625. unleashed yet.
  1626.  
  1627. There are no parameters for this type. We were able to implement it with
  1628. integer math routines, so it runs fairly quickly even without an FPU.
  1629. ;
  1630. ;
  1631. ~Topic=Quartic Mandelbrot/Julia, Label=HT_MANDJUL4
  1632. (type=mandel4/julia4)
  1633.  
  1634. These fractal types are the moral equivalent of the original M and J sets,
  1635. except that they use the formula Z(n+1) = Z(n)^4 + C, which adds
  1636. additional pseudo-symmetries to the plots. The "Mandel4" set maps to the
  1637. "Julia4" set via -- surprise! -- the spacebar toggle. The M4 set is kind
  1638. of boring at first (the area between the "inside" and the "outside" of the
  1639. set is pretty thin, and it tends to take a few zooms to get to any
  1640. interesting sections), but it looks nice once you get there. The Julia
  1641. sets look nice right from the start.
  1642.  
  1643. Other powers, like Z(n)^3 or Z(n)^7, work in exactly the same fashion. We
  1644. used this one only because we're lazy, and Z(n)^4 = (Z(n)^2)^2.
  1645. ;
  1646. ;
  1647. ~Topic=Distance Estimator
  1648. (distest=nnn/nnn)
  1649.  
  1650. This used to be type=demm and type=demj.  These types have not died, but
  1651. are only hiding!  They are equivalent to the mandel and julia types with
  1652. the "distest=" option selected with a predetermined value.
  1653.  
  1654. The {Distance Estimator Method}
  1655. can be used to produce higher quality images of M and J sets,
  1656. especially suitable for printing in black and white.
  1657.  
  1658. If you have some *.fra files made with the old types demm/demj, you may
  1659. want to convert them to the new form.  See the {=HT_MANDFN Mandelfn}
  1660. section for directions to carry out the conversion.
  1661. ;
  1662. ;
  1663. ~Topic=Pickover Mandelbrot/Julia Types, Label=HT_PICKMJ
  1664. (type=manfn+zsqrd/julfn+zsqrd, manzpowr/julzpowr, manzzpwr/julzzpwr,
  1665. manfn+exp/julfn+exp - formerly included man/julsinzsqrd and
  1666. man/julsinexp which have now been generalized)
  1667.  
  1668. These types have been explored by Clifford A. Pickover, of the IBM Thomas
  1669. J. Watson Research center. As implemented in Fractint, they are regular
  1670. Mandelbrot/Julia set pairs that may be plotted with or without the
  1671. {=@Biomorphs "biomorph"} option Pickover used to create organic-looking
  1672. beasties (see
  1673. below). These types are produced with formulas built from the functions
  1674. z^z, z^n, sin(z), and e^z for complex z. Types with "power" or "pwr" in
  1675. their name have an exponent value as a third parameter. For example,
  1676. type=manzpower params=0/0/2 is our old friend the classical Mandelbrot,
  1677. and type=manzpower params=0/0/4 is the Quartic Mandelbrot. Other values of
  1678. the exponent give still other fractals.  Since these WERE the original
  1679. "biomorph" types, we should give an example.  Try:
  1680.  
  1681.     FRACTINT type=manfn+zsqrd biomorph=0 corners=-8/8/-6/6 function=sin
  1682.  
  1683. to see a big biomorph digesting little biomorphs!
  1684. ;
  1685. ;
  1686. ~Topic=Pickover Popcorn, Label=HT_POPCORN
  1687. (type=popcorn/popcornjul)
  1688.  
  1689. Here is another Pickover idea. This one computes and plots the orbits of
  1690. the dynamic system defined by:
  1691.  
  1692.      x(n+1) = x(n) - h*sin(y(n)+tan(3*y(n))\
  1693.      y(n+1) = y(n) - h*sin(x(n)+tan(3*x(n))\
  1694.  
  1695. with the initializers x(0) and y(0) equal to ALL the complex values within
  1696. the "corners" values, and h=.01.  ALL these orbits are superimposed,
  1697. resulting in "popcorn" effect.  You may want to use a maxiter value less
  1698. than normal - Pickover recommends a value of 50.  As a bonus,
  1699. type=popcornjul shows the Julia set generated by these same equations with
  1700. the usual escape-time coloring. Turn on orbit viewing with the "O"
  1701. command, and as you watch the orbit pattern you may get some insight as to
  1702. where the popcorn comes from. Although you can zoom and rotate popcorn,
  1703. the results may not be what you'd expect, due to the superimposing of
  1704. orbits and arbitrary use of color. Just for fun we added type popcornjul,
  1705. which is the plain old Julia set calculated from the same formula.
  1706. ;
  1707. ;
  1708. ~Topic=Dynamic System, Label=HT_DYNAM
  1709. (type=dynamic, dynamic2)
  1710.  
  1711. These fractals are based on a cyclic system of differential equations:
  1712.      x'(t) = -f(y(t))\
  1713.      y'(t) = f(x(t))\
  1714. These equations are approximated by using a small time step dt, forming
  1715. a time-discrete dynamic system:
  1716.      x(n+1) = x(n) - dt*f(y(n))\
  1717.      y(n+1) = y(n) + dt*f(x(n))\
  1718. The initial values x(0) and y(0) are set to various points in the plane, 
  1719. the dynamic system is iterated, and the resulting orbit points are plotted.
  1720.  
  1721. In fractint, the function f is restricted to:
  1722.       f(k) = sin(k + a*fn1(b*k))
  1723. The parameters are the spacing of the initial points, the time step dt,
  1724. and the parameters (a,b,fn1) that affect the function f.
  1725. Normally the orbit points are plotted individually, but for a negative
  1726. spacing the points are connected.
  1727.  
  1728. This fractal is similar to the {=HT_POPCORN Pickover Popcorn}.
  1729. ~OnlineFF
  1730. A variant is the implicit Euler approximation:
  1731.      y(n+1) = y(n) + dt*f(x(n))\
  1732.      x(n+1) = x(n) - dt*f(y(n+1))\
  1733. This variant results in complex orbits.  The implicit Euler approximation
  1734. is selected by entering dt<0.
  1735.  
  1736. There are two options that have unusual effects on these fractals.  The
  1737. Orbit Delay value controls how many initial points are computed before
  1738. the orbits are displayed on the screen.  This allows the orbit to settle
  1739. down.  The outside=summ option causes each pixel to increment color every
  1740. time an orbit touches it; the resulting display is a 2-d histogram.
  1741.  
  1742. These fractals are discussed in Chapter 14 of Pickover's "Computers,
  1743. Pattern, Chaos, and Beauty".
  1744. ;
  1745. ;
  1746. ~Topic=Mandelcloud, Label=HT_MANDELCLOUD
  1747. (type=mandelcloud)
  1748.  
  1749. This fractal computes the Mandelbrot function, but displays it differently.
  1750. It starts with regularly spaced initial pixels and displays the resulting
  1751. orbits.  This idea is somewhat similar to the {=HT_DYNAM Dynamic System}.
  1752.  
  1753. There are two options that have unusual effects on this fractal.  The
  1754. Orbit Delay value controls how many initial points are computed before
  1755. the orbits are displayed on the screen.  This allows the orbit to settle
  1756. down.  The outside=summ option causes each pixel to increment color every
  1757. time an orbit touches it; the resulting display is a 2-d histogram.
  1758.  
  1759. This fractal was invented by Noel Giffin.
  1760.  
  1761. ;
  1762. ;
  1763. ~Topic=Peterson Variations, Label=HT_MARKS
  1764. (type=marksmandel, marksjulia, cmplxmarksmand, cmplxmarksjul, marksmandelpwr,
  1765. tim's_error)
  1766.  
  1767. These fractal types are contributions of Mark Peterson. MarksMandel and
  1768. MarksJulia are two families of fractal types that are linked in the same
  1769. manner as the classic Mandelbrot/Julia sets: each MarksMandel set can be
  1770. considered as a mapping into the MarksJulia sets, and is linked with the
  1771. spacebar toggle. The basic equation for these sets is:
  1772.       Z(n+1) = ((lambda^exp-1) * Z(n)^2) + lambda
  1773. where Z(0) = 0.0 and lambda is (x + iy) for MarksMandel. For MarksJulia,
  1774. Z(0) = (x + iy) and lambda is a constant (taken from the MarksMandel
  1775. spacebar toggle, if that method is used). The exponent is a positive
  1776. integer or a complex number. We call these "families" because each value
  1777. of the exponent yields a different MarksMandel set, which turns out to be
  1778. a kinda-polygon with (exponent) sides. The exponent value is the third
  1779. parameter, after the "initialization warping" values. Typically one would
  1780. use null warping values, and specify the exponent with something like
  1781. "PARAMS=0/0/5", which creates an unwarped, pentagonal MarksMandel set.
  1782.  
  1783. In the process of coding MarksMandelPwr formula type, Tim Wegner
  1784. created the type "tim's_error" after making an interesting coding mistake.
  1785. ;
  1786. ;
  1787. ~Topic=Unity, Label=HT_UNITY
  1788. (type=unity)
  1789.  
  1790. This Peterson variation began with curiosity about other "Newton-style"
  1791. approximation processes. A simple one,
  1792.  
  1793.    One = (x * x) + (y * y); y = (2 - One) * x;     x = (2 - One) * y;
  1794.  
  1795. produces the fractal called Unity.
  1796.  
  1797. One of its interesting features is the "ghost lines." The iteration loop
  1798. bails out when it reaches the number 1 to within the resolution of a
  1799. screen pixel. When you zoom a section of the image, the bailout criterion
  1800. is adjusted, causing some lines to become thinner and others thicker.
  1801.  
  1802. Only one line in Unity that forms a perfect circle: the one at a radius of
  1803. 1 from the origin. This line is actually infinitely thin. Zooming on it
  1804. reveals only a thinner line, up (down?) to the limit of accuracy for the
  1805. algorithm. The same thing happens with other lines in the fractal, such as
  1806. those around |x| = |y| = (1/2)^(1/2) = .7071
  1807.  
  1808. Try some other tortuous approximations using the {=HT_TEST TEST stub} and
  1809. let us know what you come up with!
  1810. ;
  1811. ;
  1812. ~Topic=Scott Taylor / Lee Skinner Variations, Label=HT_SCOTSKIN
  1813. (type=fn(z*z), fn*fn, fn*z+z, fn+fn, fn+fn(pix), sqr(1/fn), sqr(fn), spider,
  1814. tetrate, manowar)
  1815.  
  1816. Two of Fractint's faithful users went bonkers when we introduced the
  1817. "formula" type, and came up with all kinds of variations on escape-time
  1818. fractals using trig functions.    We decided to put them in as regular
  1819. types, but there were just too many! So we defined the types with variable
  1820. functions and let you, the overwhelmed user, specify what the functions
  1821. should be! Thus Scott Taylor's "z = sin(z) + z^2" formula type is now the
  1822. "fn+fn" regular type, and EITHER function can be one of sin, cos, tan, cotan,
  1823. sinh, cosh, tanh, cotanh, exp, log, sqr, recip, ident, conj, flip, cosxx,
  1824. asin, asinh, acos, acosh, atan, atanh, sqrt, abs, or cabs.
  1825.  
  1826. Plus we give you 4 parameters to set, the complex
  1827. coefficients of the two functions!  Thus the innocent-looking "fn+fn" type
  1828. is really 256 different types in disguise, not counting the damage
  1829. done by the parameters!
  1830.  
  1831.  Some functions that require further explanation:
  1832.  
  1833.  conj()   - returns the complex conjugate of the argument. That is, changes
  1834.             sign of the imaginary component of argument: (x,y) becomes (x,-y)
  1835.  ident()  - identity function. Leaves the value of the argument unchanged,
  1836.             acting like a "z" term in a formula.
  1837. ~OnlineFF
  1838.  flip()   - Swap the real and imaginary components of the complex number.
  1839.             e.g. (4,5) would become (5,4)
  1840.  
  1841. Lee informs us that you should not judge fractals by their "outer"
  1842. appearance. For example, the images produced by z = sin(z) + z^2 and z =
  1843. sin(z) - z^2 look very similar, but are different when you zoom in.
  1844. ;
  1845. ;
  1846. ~Topic=Kam Torus, Label=HT_KAM
  1847. (type=kamtorus, kamtorus3d)
  1848.  
  1849. This type is created by superimposing orbits generated by a set of
  1850. equations, with a variable incremented each time.
  1851.  
  1852.      x(0) = y(0) = orbit/3;\
  1853.      x(n+1) = x(n)*cos(a) + (x(n)*x(n)-y(n))*sin(a)\
  1854.      y(n+1) = x(n)*sin(a) - (x(n)*x(n)-y(n))*cos(a)\
  1855.  
  1856. After each orbit, 'orbit' is incremented by a step size. The parameters
  1857. are angle "a", step size for incrementing 'orbit', stop value for 'orbit',
  1858. and points per orbit. Try this with a stop value of 5 with sound=x for
  1859. some weird fractal music (ok, ok, fractal noise)! You will also see the
  1860. KAM Torus head into some chaotic territory that Scott Taylor wanted to
  1861. hide from you by setting the defaults the way he did, but now we have
  1862. revealed all!
  1863.  
  1864. The 3D variant is created by treating 'orbit' as the z coordinate.
  1865.  
  1866. With both variants, you can adjust the "maxiter" value (<X> options
  1867. screen or parameter maxiter=) to change the number of orbits plotted.
  1868. ;
  1869. ;
  1870. ~Topic=Bifurcation, Label=HT_BIF
  1871. (type=bifxxx)
  1872.  
  1873. The wonder of fractal geometry is that such complex forms can arise from
  1874. such simple generating processes. A parallel surprise has emerged in the
  1875. study of dynamical systems: that simple, deterministic equations can yield
  1876. chaotic behavior, in which the system never settles down to a steady state
  1877. or even a periodic loop. Often such systems behave normally up to a
  1878. certain level of some controlling parameter, then go through a transition
  1879. in which there are two possible solutions, then four, and finally a
  1880. chaotic array of possibilities.
  1881.  
  1882. This emerged many years ago in biological models of population growth.
  1883. Consider a (highly over-simplified) model in which the rate of growth is
  1884. partly a function of the size of the current population:
  1885.  
  1886. New Population =  Growth Rate * Old Population * (1 - Old Population)
  1887.  
  1888. where population is normalized to be between 0 and 1. At growth rates less
  1889. than 200 percent, this model is stable: for any starting value, after
  1890. several generations the population settles down to a stable level. But for
  1891. rates over 200 percent, the equation's curve splits or "bifurcates" into
  1892. two discrete solutions, then four, and soon becomes chaotic.
  1893.  
  1894. Type=bifurcation illustrates this model. (Although it's now considered a
  1895. poor one for real populations, it helped get people thinking about chaotic
  1896. systems.) The horizontal axis represents growth rates, from 190 percent
  1897. (far left) to 400 percent; the vertical axis normalized population values,
  1898. from 0 to 4/3. Notice that within the chaotic region, there are narrow
  1899. bands where there is a small, odd number of stable values. It turns out
  1900. that the geometry of this branching is fractal; zoom in where changing
  1901. pixel colors look suspicious, and see for yourself.
  1902.  
  1903. Three parameters apply to bifurcations: Filter Cycles, Seed Population,
  1904. and Function or Beta.
  1905.  
  1906. Filter Cycles (default 1000) is the number of iterations to be done before
  1907. plotting maxiter population values. This gives the iteration time to settle
  1908. into the characteristic patterns that constitute the bifurcation diagram,
  1909. and results in a clean-looking plot.  However, using lower values produces
  1910. interesting results too. Set Filter Cycles to 1 for an unfiltered map.
  1911.  
  1912. Seed Population (default 0.66) is the initial population value from which
  1913. all others are calculated. For filtered maps the final image is independent
  1914. of Seed Population value in the valid range (0.0 < Seed Population < 1.0).
  1915. ~OnlineFF
  1916. Seed Population becomes effective in unfiltered maps - try setting Filter
  1917. Cycles to 1 (unfiltered) and Seed Population to 0.001 ("PARAMS=1/.001" on
  1918. the command line). This results in a map overlaid with nice curves. Each
  1919. Seed Population value results in a different set of curves.
  1920.  
  1921. Function (default "ident") is the function applied to the old population
  1922. before the new population is determined. The "ident" function calculates
  1923. the same bifurcation fractal that was generated before these formulae
  1924. were generalized.
  1925.  
  1926. Beta is used in the bifmay bifurcations and is the power to which the
  1927. denominator is raised.
  1928.  
  1929. Note that fractint normally uses periodicity checking to speed up
  1930. bifurcation computation.  However, in some cases a better quality image
  1931. will be obtained if you turn off periodicity checking with "periodicity=no";
  1932. for instance, if you use a high number of iterations and a smooth
  1933. colormap.
  1934.  
  1935. Many formulae can be used to produce bifurcations.  Mitchel Feigenbaum
  1936. studied lots of bifurcations in the mid-70's, using a HP-65 calculator
  1937. (IBM PCs, Fractals, and Fractint, were all Sci-Fi then !). He studied
  1938. where bifurcations occurred, for the formula r*p*(1-p), the one described
  1939. above.    He found that the ratios of lengths of adjacent areas of
  1940. bifurcation were four and a bit.  These ratios vary, but, as the growth
  1941. rate increases, they tend to a limit of 4.669+.  This helped him guess
  1942. where bifurcation points would be, and saved lots of time.
  1943.  
  1944. When he studied bifurcations of r*sin(PI*p) he found a similar pattern,
  1945. which is not surprising in itself.  However, 4.669+ popped out, again.
  1946. Different formulae, same number ?  Now, THAT's surprising !  He tried many
  1947. other formulae and ALWAYS got 4.669+ - Hot Damn !!!  So hot, in fact, that
  1948. he phoned home and told his Mom it would make him Famous ! He also went on
  1949. to tell other scientists.  The rest is History...
  1950.  
  1951. (It has been conjectured that if Feigenbaum had a copy of Fractint, and
  1952. used it to study bifurcations, he may never have found his Number, as it
  1953. only became obvious from long perusal of hand-written lists of values,
  1954. without the distraction of wild color-cycling effects !).
  1955. ~OnlineFF
  1956. We now know that this number is as universal as PI or E. It appears in
  1957. situations ranging from fluid-flow turbulence, electronic oscillators,
  1958. chemical reactions, and even the Mandelbrot Set - yup, fraid so:
  1959. "budding" of the Mandelbrot Set along the negative real axis occurs at
  1960. intervals determined by Feigenbaum's Number, 4.669201660910.....
  1961.  
  1962. Fractint does not make direct use of the Feigenbaum Number (YET !).
  1963. However, it does now reflect the fact that there is a whole sub-species of
  1964. Bifurcation-type fractals.  Those implemented to date, and the related
  1965. formulae, (writing P for pop[n+1] and p for pop[n]) are :
  1966.  
  1967.   bifurcation  P =  p + r*fn(p)*(1-fn(p))  Verhulst Bifurcations.\
  1968.   biflambda    P =      r*fn(p)*(1-fn(p))  Real equivalent of Lambda Sets.\
  1969.   bif+sinpi    P =  p + r*fn(PI*p)         Population scenario based on...\
  1970.   bif=sinpi    P =      r*fn(PI*p)         ...Feigenbaum's second formula.\
  1971.   bifstewart   P =      r*fn(p)*fn(p) - 1  Stewart Map.\
  1972.   bifmay       P =      r*p / ((1+p)^b)    May Map.\
  1973.  
  1974. It took a while for bifurcations to appear here, despite them being over a
  1975. century old, and intimately related to chaotic systems. However, they are
  1976. now truly alive and well in Fractint!
  1977. ;
  1978. ;
  1979. ~Topic=Orbit Fractals
  1980.  
  1981. Orbit Fractals are generated by plotting an orbit path in two or three
  1982. dimensional space.
  1983.  
  1984. See {Lorenz Attractors}, {Rossler Attractors},
  1985. {Henon Attractors}, {Pickover Attractors}, {Gingerbreadman},
  1986. and {Martin Attractors}.
  1987.  
  1988. The orbit trajectory for these types can be saved in the file ORBITS.RAW
  1989. by invoking
  1990. Fractint with the "orbitsave=yes" command-line option.  This file will
  1991. be overwritten each time you generate a new fractal, so rename it if you
  1992. want to save it.  A nifty program called Acrospin can read these files and
  1993. rapidly rotate them in 3-D - see {=@ACROSPIN Acrospin}.
  1994. ;
  1995. ;
  1996. ~Topic=Lorenz Attractors, Label=HT_LORENZ
  1997. (type=lorenz/lorenz3d)
  1998.  
  1999. The "Lorenz Attractor" is a "simple" set of three deterministic equations
  2000. developed by Edward Lorenz while studying the non- repeatability of
  2001. weather patterns.  The weather forecaster's basic problem is that even
  2002. very tiny changes in initial patterns ("the beating of a butterfly's
  2003. wings" - the official term is "sensitive dependence on initial
  2004. conditions") eventually reduces the best weather forecast to rubble.
  2005.  
  2006. The lorenz attractor is the plot of the orbit of a dynamic system
  2007. consisting of three first order non-linear differential equations. The
  2008. solution to the differential equation is vector-valued function of one
  2009. variable.  If you think of the variable as time, the solution traces an
  2010. orbit.    The orbit is made up of two spirals at an angle to each other in
  2011. three dimensions. We change the orbit color as time goes on to add a
  2012. little dazzle to the image.  The equations are:
  2013.  
  2014.         dx/dt = -a*x + a*y\
  2015.         dy/dt =  b*x - y   -z*x\
  2016.         dz/dt = -c*z + x*y\
  2017.  
  2018. We solve these differential equations approximately using a method known
  2019. as the first order taylor series.  Calculus teachers everywhere will kill
  2020. us for saying this, but you treat the notation for the derivative dx/dt as
  2021. though it really is a fraction, with "dx" the small change in x that
  2022. happens when the time changes "dt".  So multiply through the above
  2023. equations by dt, and you will have the change in the orbit for a small
  2024. time step. We add these changes to the old vector to get the new vector
  2025. after one step. This gives us:
  2026.  
  2027.          xnew = x + (-a*x*dt) + (a*y*dt)\
  2028.          ynew = y + (b*x*dt) - (y*dt) - (z*x*dt)\
  2029.          znew = z + (-c*z*dt) + (x*y*dt)\
  2030.  
  2031.          (default values: dt = .02, a = 5, b = 15, c = 1)
  2032.  
  2033. We connect the successive points with a line, project the resulting 3D
  2034. orbit onto the screen, and voila! The Lorenz Attractor!
  2035.  
  2036. We have added two versions of the Lorenz Attractor.  "Type=lorenz" is the
  2037. Lorenz attractor as seen in everyday 2D.  "Type=lorenz3d" is the same set
  2038. of equations with the added twist that the results are run through our
  2039. perspective 3D routines, so that you get to view it from different angles
  2040. (you can modify your perspective "on the fly" by using the <I> command.)
  2041. If you set the "stereo" option to "2", and have red/blue funny glasses on,
  2042. you will see the attractor orbit with depth perception.
  2043.  
  2044. Hint: the default perspective values (x = 60, y = 30, z = 0) aren't the
  2045. best ones to use for fun Lorenz Attractor viewing.  Experiment a bit -
  2046. start with rotation values of 0/0/0 and then change to 20/0/0 and 40/0/0
  2047. to see the attractor from different angles.- and while you're at it, use a
  2048. non-zero perspective point Try 100 and see what happens when you get
  2049. *inside* the Lorenz orbits.  Here comes one - Duck!  While you are at it,
  2050. turn on the sound with the "X". This way you'll at least hear it coming!
  2051.  
  2052. Different Lorenz attractors can be created using different parameters.
  2053. Four parameters are used. The first is the time-step (dt). The default
  2054. value is .02. A smaller value makes the plotting go slower; a larger value
  2055. is faster but rougher. A line is drawn to connect successive orbit values.
  2056. The 2nd, third, and fourth parameters are coefficients used in the
  2057. differential equation (a, b, and c). The default values are 5, 15, and 1.
  2058. Try changing these a little at a time to see the result.
  2059. ;
  2060. ;
  2061. ~Topic=Rossler Attractors, Label=HT_ROSS
  2062. (type=rossler3D)
  2063.  
  2064. This fractal is named after the German Otto Rossler, a non-practicing
  2065. medical doctor who approached chaos with a bemusedly philosophical
  2066. attitude.  He would see strange attractors as philosophical objects. His
  2067. fractal namesake looks like a band of ribbon with a fold in it. All we can
  2068. say is we used the same calculus-teacher-defeating trick of multiplying
  2069. the equations by "dt" to solve the differential equation and generate the
  2070. orbit.    This time we will skip straight to the orbit generator - if you
  2071. followed what we did above with type {=HT_LORENZ Lorenz} you can easily
  2072. reverse engineer the differential equations.
  2073.  
  2074.          xnew = x - y*dt -     z*dt\
  2075.          ynew = y + x*dt + a*y*dt\
  2076.          znew = z + b*dt + x*z*dt - c*z*dt\
  2077.  
  2078. Default parameters are dt = .04, a = .2, b = .2, c = 5.7
  2079. ;
  2080. ;
  2081. ~Topic=Henon Attractors, Label=HT_HENON
  2082. (type=henon)
  2083.  
  2084. Michel Henon was an astronomer at Nice observatory in southern France. He
  2085. came to the subject of fractals via investigations of the orbits of
  2086. astronomical objects.  The strange attractor most often linked with
  2087. Henon's name comes not from a differential equation, but from the world of
  2088. discrete mathematics - difference equations. The Henon map is an example
  2089. of a very simple dynamic system that exhibits strange behavior. The orbit
  2090. traces out a characteristic banana shape, but on close inspection, the
  2091. shape is made up of thicker and thinner parts.    Upon magnification, the
  2092. thicker bands resolve to still other thick and thin components.  And so it
  2093. goes forever! The equations that generate this strange pattern perform the
  2094. mathematical equivalent of repeated stretching and folding, over and over
  2095. again.
  2096.  
  2097.          xnew =  1 + y - a*x*x\
  2098.          ynew =  b*x\
  2099.  
  2100. The default parameters are a=1.4 and b=.3.
  2101. ;
  2102. ;
  2103. ~Topic=Pickover Attractors, Label=HT_PICK
  2104. (type=pickover)
  2105.  
  2106. Clifford A. Pickover of the IBM Thomas J. Watson Research center is such a
  2107. creative source for fractals that we attach his name to this one only with
  2108. great trepidation.  Probably tomorrow he'll come up with another one and
  2109. we'll be back to square one trying to figure out a name!
  2110.  
  2111. This one is the three dimensional orbit defined by:
  2112.  
  2113.          xnew = sin(a*y) - z*cos(b*x)\
  2114.          ynew = z*sin(c*x) - cos(d*y)\
  2115.          znew = sin(x)\
  2116.  
  2117. Default parameters are: a = 2.24, b = .43, c = -.65, d = -2.43
  2118. ;
  2119. ;
  2120. ~Topic=Gingerbreadman, Label=HT_GINGER
  2121. (type=gingerbreadman)
  2122.  
  2123. This simple fractal is a charming example stolen from "Science of Fractal
  2124. Images", p. 149.
  2125.  
  2126.          xnew = 1 - y + |x|\
  2127.          ynew = x
  2128.  
  2129. The initial x and y values are set by parameters, defaults x=-.1, y = 0.
  2130. ;
  2131. ;
  2132. ~Topic=Martin Attractors, Label=HT_MARTIN
  2133. (type=hopalong/martin)
  2134.  
  2135. These fractal types are from A. K. Dewdney's "Computer Recreations" column
  2136. in "Scientific American". They are attributed to Barry Martin of Aston 
  2137. University in Birmingham, England. 
  2138.  
  2139. Hopalong is an "orbit" type fractal like lorenz. The image is obtained by 
  2140. iterating this formula after setting z(0) = y(0) = 0:\
  2141.       x(n+1) = y(n) - sign(x(n))*sqrt(abs(b*x(n)-c))\
  2142.       y(n+1) = a - x(n)\
  2143. Parameters are a, b, and c. The function "sign()"  returns 1 if the argument 
  2144. is positive, -1 if argument is negative.
  2145.  
  2146. This fractal continues to develop in surprising ways after many iterations.
  2147.  
  2148. Another Martin fractal is simpler. The iterated formula is:\
  2149.       x(n+1) = y(n) - sin(x(n))\
  2150.       y(n+1) = a - x(n)\
  2151. The parameter is "a". Try values near the number pi.
  2152.  
  2153. Michael Peters has based the HOP program on variations of these Martin types.
  2154. You will find three of these here: chip, quadruptwo, and threeply.
  2155. ;
  2156. ;
  2157. ;
  2158. ~Topic=Icon, Label=HT_ICON
  2159. (type=icon/icon3d)
  2160.  
  2161.   This fractal type was inspired by the book "Symmetry in Chaos"
  2162.   by Michael Field and Martin Golubitsky (ISBN 0-19-853689-5, Oxford Press)
  2163.  
  2164.   To quote from the book's jacket,
  2165.  
  2166.     "Field and Golubitsky describe how a chaotic process eventually can
  2167.     lead to symmetric patterns (in a river, for instance, photographs of
  2168.     the turbulent movement of eddies, taken over time, often reveal
  2169.     patterns on the average."
  2170.  
  2171.   The Icon type implemented here maps the classic population logistic
  2172.   map of bifurcation fractals onto the complex plane in Dn symmetry.
  2173.  
  2174.   The initial points plotted are the more chaotic initial orbits, but
  2175.   as you wait, delicate webs will begin to form as the orbits settle
  2176.   into a more periodic pattern.  Since pixels are colored by the number
  2177.   of times they are hit, the more periodic paths will become clarified
  2178.   with time.  These fractals run continuously.
  2179.  
  2180. There are 6 parameters:  Lambda, Alpha, Beta, Gamma, Omega, and Degree
  2181.     Omega  0 = Dn, or dihedral (rotation + reflectional) symmetry
  2182.           !0 = Zn, or cyclic (rotational) symmetry
  2183.     Degree = n, or Degree of symmetry
  2184. ;
  2185. ;
  2186. ;
  2187. ~Topic=Quaternion, Label=HT_QUAT
  2188. (type=quat,quatjul)
  2189.  
  2190. These fractals are based on quaternions.  Quaternions are an extension of
  2191. complex numbers, with 4 parts instead of 2.  That is, a quaternion Q
  2192. equals a+ib+jc+kd, where a,b,c,d are reals.  Quaternions have rules for
  2193. addition and multiplication.  The normal Mandelbrot and Julia formulas
  2194. can be generalized to use quaternions instead of complex numbers.
  2195.  
  2196. There is one complication.  Complex numbers have 2 parts, so they can
  2197. be displayed on a plane.  Quaternions have 4 parts, so they require 4
  2198. dimensions to view.  That is, the quaternion Mandelbrot set is actually a
  2199. 4-dimensional object.  Each quaternion C generates a 4-dimensional Julia set.
  2200.  
  2201. One method of displaying the 4-dimensional object is to take a 3-dimensional
  2202. slice and render the resulting object in 3-dimensional perspective.
  2203. Fractint isn't that sophisticated, so it merely displays a 2-dimensional
  2204. slice of the resulting object. (Note: Now Fractint is that sophisticated! 
  2205. See the Julibrot type!)
  2206.  
  2207. In fractint, for the Julia set, you can specify the four parameters
  2208. of the quaternion constant: c=(c1,ci,cj,ck), but the 2-dimensional slice 
  2209. of the z-plane Julia set is fixed to (xpixel,ypixel,0,0).
  2210.  
  2211. For the Mandelbrot set, you can specify the position of the c-plane slice:
  2212. (xpixel,ypixel,cj,ck).
  2213.  
  2214. These fractals are discussed in Chapter 10 of Pickover's "Computers,
  2215. Pattern, Chaos, and Beauty".
  2216.  
  2217. See also {HyperComplex} and { Quaternion and Hypercomplex Algebra }
  2218.  
  2219. ;
  2220. ;
  2221. ~Topic=HyperComplex, Label=HT_HYPERC
  2222. (type=hypercomplex,hypercomplexj)
  2223.  
  2224. These fractals are based on hypercomplex numbers, which like quaternions
  2225. are a four dimensional generalization of complex numbers. It is not 
  2226. possible to fully generalize the complex numbers to four dimensions without
  2227. sacrificing some of the algebraic properties shared by real and complex 
  2228. numbers. Quaternions violate the commutative law of multiplication, which 
  2229. says z1*z2 = z2*z1. Hypercomplex numbers fail the rule that says all non-zero
  2230. elements have multiplicative inverses - that is, if z is not 0, there
  2231. should be a number 1/z such that (1/z)*(z) = 1. This law holds most of the
  2232. time but not all the time for hypercomplex numbers. 
  2233.  
  2234. However hypercomplex numbers have a wonderful property for fractal purposes.
  2235. Every function defined for complex numbers has a simple generalization 
  2236. to hypercomplex numbers. Fractint's implementation takes advantage of this
  2237. by using "fn" variables - the iteration formula is\
  2238.     h(n+1) = fn(h(n)) + C.\
  2239. where "fn" is the hypercomplex generalization of sin, cos, log, sqr etc.
  2240. ~OnlineFF
  2241. You can see 3D versions of these fractals using fractal type Julibrot.
  2242. Hypercomplex numbers were brought to our attention by Clyde Davenport,
  2243. author of "A Hypercomplex Calculus with Applications to Relativity",
  2244. ISBN 0-9623837-0-8.
  2245.  
  2246. See also {Quaternion} and { Quaternion and Hypercomplex Algebra }
  2247.  
  2248. ;
  2249. ;
  2250.  
  2251. ~Topic=Cellular Automata, Label=HT_CELLULAR
  2252. (type=cellular)
  2253.  
  2254. These fractals are generated by 1-dimensional cellular automata.  Consider
  2255. a 1-dimensional line of cells, where each cell can have the value 0 or 1.
  2256. In each time step, the new value of a cell is computed from the old value
  2257. of the cell and the values of its neighbors.  On the screen, each horizontal
  2258. row shows the value of the cells at any one time.  The time axis proceeds
  2259. down the screen, with each row computed from the row above.
  2260.  
  2261. Different classes of cellular automata can be described by how many different
  2262. states a cell can have (k), and how many neighbors on each side are examined
  2263. (r).  Fractint implements the binary nearest neighbor cellular automata
  2264. (k=2,r=1), the binary next-nearest neighbor cellular automata (k=2,r=2),
  2265. and the ternary nearest neighbor cellular automata (k=3,r=1) and several
  2266. others.
  2267.  
  2268. The rules used here determine the next state of a given cell by using the
  2269. sum of the states in the cell's neighborhood.  The sum of the cells in the
  2270. neighborhood are mapped by rule to the new value of the cell.  For the
  2271. binary nearest neighbor cellular automata, only the closest neighbor on
  2272. each side is used.  This results in a 4 digit rule controlling the
  2273. generation of each new line:  if each of the cells in the neighborhood is
  2274. 1, the maximum sum is 1+1+1 = 3 and the sum can range from 0 to 3, or 4
  2275. values.  This results in a 4 digit rule.  For instance, in the rule 1010,
  2276. starting from the right we have 0->0, 1->1, 2->0, 3->1.  If the cell's
  2277. neighborhood sums to 2, the new cell value would be 0.
  2278.  
  2279. For the next-nearest cellular automata (kr = 22), each pixel is determined
  2280. from the pixel value and the two neighbors on each side.  This results in
  2281. a 6 digit rule.
  2282.  
  2283. For the ternary nearest neighbor cellular automata (kr = 31), each cell
  2284. can have the value 0, 1, or 2.  A single neighbor on each side is examined,
  2285. resulting in a 7 digit rule.
  2286.  
  2287.   kr  #'s in rule  example rule     | kr  #'s in rule  example rule\
  2288.   21      4        1010             | 42     16        2300331230331001\
  2289.   31      7        1211001          | 23      8        10011001\
  2290.   41     10        3311100320       | 33     15        021110101210010\
  2291.   51     13        2114220444030    | 24     10        0101001110\
  2292.   61     16        3452355321541340 | 25     12        110101011001\
  2293.   22      6        011010           | 26     14        00001100000110\
  2294.   32     11        21212002010      | 27     16        0010000000000110\
  2295.  
  2296. The starting row of cells can be set to a pattern of up to 16 digits or to a
  2297. random pattern.  The borders are set to zeros if a pattern is entered or are
  2298. set randomly if the starting row is set randomly.
  2299.  
  2300. A zero rule will randomly generate the rule to use.
  2301.  
  2302. Hitting the space bar toggles between continuously generating the cellular
  2303. automata and stopping at the end of the current screen.
  2304.  
  2305. Recommended reading:
  2306. "Computer Software in Science and Mathematics", Stephen Wolfram, Scientific
  2307. American, September, 1984.
  2308. "Abstract Mathematical Art", Kenneth E. Perry, BYTE, December, 1986.
  2309. "The Armchair Universe", A. K. Dewdney, W. H. Freeman and Company, 1988.
  2310. "Complex Patterns Generated by Next Nearest Neighbors Cellular Automata",
  2311. Wentian Li, Computers & Graphics, Volume 13, Number 4.
  2312. ;
  2313. ;
  2314. ~Topic=Ant Automaton, Label=HT_ANT
  2315. (type=ant)
  2316.  
  2317. This fractal type is the generalized Ant Automaton described in the "Computer
  2318. Recreations" column of the July 1994 Scientific American. The article 
  2319. attributes this automaton to Greg Turk of Stanford University, Leonid A.
  2320. Bunivomitch of the Georgia Institute of Technology, and S. E. Troubetzkoy of
  2321. the University of Bielefeld. 
  2322.  
  2323. The ant wanders around the screen, starting at the middle. A rule string, 
  2324. which the user can input as Fractint's first parameter, determines the ant's 
  2325. direction. This rule string is stored as a double precision number in our 
  2326. implementation. Only the digit 1 is significant -- all other digits are 
  2327. treated as 0. When the type 1 ant leaves a cell (a pixel on the screen) of 
  2328. color k, it turns right if the kth symbol in the rule string is a 1, or left 
  2329. otherwise. Then the color in the abandoned cell is incremented. The type 2
  2330. ant uses only the rule string to move around. If the digit of the rule string
  2331. is a 1, the ant turns right and puts a zero in current cell, otherwise it 
  2332. turns left and put a number in the current cell. An empty rule string causes
  2333. the rule to be generated randomly.
  2334.  
  2335. Fractint's 2nd parameter is a maximum iteration to guarantee that the fractal 
  2336. will terminate. 
  2337.  
  2338. The 3rd parameter is the number of ants (up to 256). If you select 0 ants,
  2339. then the number oif ants is random. 
  2340.  
  2341. The 4th paramter allows you to select ant type 1 (the original), or type 2. 
  2342.  
  2343. The 5th parameter determines whether the ant's progress stops when the edge 
  2344. of the screen is reaches (as in the original implementation), or whether the 
  2345. ant's path wraps to the opposite side of the screen. You can slow down the 
  2346. ant to see her better using the <x> screen Orbit Delay - try 10.
  2347.  
  2348. The 6th parameter accepts a random seed, allowing you to duplicate images
  2349. using random values (empty rule string or 0 maximum ants.
  2350.  
  2351. Try rule string 10. In this case, the ant moves in a seemingly random pattern,
  2352. then suddenly marches off in a straight line. This happens for many other
  2353. rule strings. The default 1100 produces symmetrical images.
  2354.  
  2355. If the screen initially contains an image, the path of the ant changes. To
  2356. try this, generate a fractal, and press <Ctrl-a>. Note that images 
  2357. seeded with an image are not (yet) reproducible in PAR files. When started 
  2358. using the <Ctrl-a> keys, after the ant is finished the default fractal 
  2359. type reverts to that of the underlying fractal.
  2360.  
  2361. ~Label=ANTCOMMANDS
  2362. Special keystrokes are in effect during the ant's march. The <space> key
  2363. toggles a step-by-step mode. When in this mode, press <enter> to see each step
  2364. of the ant's progress. When orbit delay (on <x> screen) is set to 1, the step 
  2365. mode is the default.
  2366.  
  2367. If you press the right or left arrow during the ant's journey, you can
  2368. adjust the orbit delay factor with the arrow keys (increment by 10) or 
  2369. ctrl-arrow keys (increment by 100). Press any other key to get out of the 
  2370. orbit delay adjustment mode. Higher values cause slower motion. Changed values
  2371. are not saved after the ant is finished, but you can set the orbit delay
  2372. value in advance from the <x> screen.
  2373. ;
  2374. ;
  2375. ;
  2376. ~Topic=Test, Label=HT_TEST
  2377. (type=test)
  2378.  
  2379. This is a stub that we (and you!) use for trying out new fractal types.
  2380. "Type=test" fractals make use of Fractint's structure and features for
  2381. whatever code is in the routine 'testpt()' (located in the small source
  2382. file TESTPT.C) to determine the color of a particular pixel.
  2383.  
  2384. If you have a favorite fractal type that you believe would fit nicely into
  2385. Fractint, just rewrite the C function in TESTPT.C (or use the prototype
  2386. function there, which is a simple M-set implementation) with an algorithm
  2387. that computes a color based on a point in the complex plane.
  2388.  
  2389. After you get it working, send your code to one of the authors and we
  2390. might just add it to the next release of Fractint, with full credit to
  2391. you. Our criteria are: 1) an interesting image and 2) a formula
  2392. significantly different from types already supported. (Bribery may also
  2393. work. THIS author is completely honest, but I don't trust those other
  2394. guys.) Be sure to include an explanation of your algorithm and the
  2395. parameters supported, preferably formatted as you see here to simplify
  2396. folding it into the documentation.
  2397. ;
  2398. ;
  2399. ~Topic=Formula, Label=HT_FORMULA
  2400. (type=formula)
  2401.  
  2402. This is a "roll-your-own" fractal interpreter - you don't even need a
  2403. compiler!
  2404.  
  2405. To run a "type=formula" fractal, you first need a text file containing
  2406. formulas (there's a sample file - FRACTINT.FRM - included with this
  2407. distribution).    When you select the "formula" fractal type, Fractint scans
  2408. the current formula file (default is FRACTINT.FRM) for formulas, then
  2409. prompts you for the formula name you wish to run.  After prompting for any
  2410. parameters, the formula is parsed for syntax errors and then the fractal
  2411. is generated. If you want to use a different formula file, press <F6> when
  2412. you are prompted to select a formula name.
  2413.  
  2414. There are two command-line options that work with type=formula
  2415. ("formulafile=" and "formulaname="), useful when you are using this
  2416. fractal type in batch mode.
  2417.  
  2418. The following documentation is supplied by Mark Peterson, who wrote the
  2419. formula interpreter:
  2420.  
  2421. Formula fractals allow you to create your own fractal formulas.  The
  2422. general format is:
  2423.  
  2424.    Mandelbrot(XAXIS) \{ z = Pixel:  z = sqr(z) + pixel, |z| <= 4 \}\
  2425.       |     |       |            |           |\
  2426.      Name     Symmetry      Initial      Iteration      Bailout\
  2427.               Condition              Criteria\
  2428.  
  2429. Initial conditions are set, then the iterations performed while the
  2430. bailout criteria remains true or until 'z' turns into a periodic loop.
  2431. All variables are created automatically by their usage and treated as
  2432. complex.  If you declare 'v = 2' then the variable 'v' is treated as a
  2433. complex with an imaginary value of zero.
  2434.  
  2435. ~Format-
  2436.       Predefined Variables (x, y)
  2437.       --------------------------------------------
  2438.       z          used for periodicity checking
  2439.       p1         parameters 1 and 2
  2440.       p2         parameters 3 and 4
  2441.       p3         parameters 5 and 6
  2442.       pixel      screen coordinates
  2443.           LastSqr    Modulus from the last sqr() function
  2444.           rand       Complex random number
  2445.  
  2446.           Precedence
  2447.           --------------------------------------------
  2448.           1          sin(), cos(), sinh(), cosh(), cosxx(), tan(), cotan(), 
  2449.                      tanh(), cotanh(), sqr(), log(), exp(), abs(), conj(), 
  2450.                      real(), imag(), flip(), fn1(), fn2(), fn3(), fn4(), 
  2451.                      srand(), asin(), asinh(), acos(), acosh(), atan(), 
  2452.                      atanh(), sqrt(), cabs()
  2453.           2          - (negation), ^ (power)
  2454.           3          * (multiplication), / (division)
  2455.           4          + (addition), - (subtraction)
  2456.           5          = (assignment)
  2457.           6          < (less than), <= (less than or equal to)
  2458.                      > (greater than), >= (greater than or equal to)
  2459.                      == (equal to), != (not equal to)
  2460.           7          && (logical AND), || (logical OR)
  2461. ~Format+
  2462.  
  2463. Precedence may be overridden by use of parenthesis.  Note the modulus squared 
  2464. operator |z| is also parenthetic and always sets the imaginary component to 
  2465. zero.  This means 'c * |z - 4|' first subtracts 4 from z, calculates the 
  2466. modulus squared then multiplies times 'c'.  Nested modulus squared operators 
  2467. require overriding parenthesis: c * |z + (|pixel|)|\
  2468.  
  2469. The functions fn1(...) to fn4(...) are variable functions - when used,
  2470. the user is prompted at run time (on the <Z> screen) to specify one of
  2471. sin, cos, sinh, cosh, exp, log, sqr, etc. for each required variable function.
  2472.  
  2473. Most of the functions have their conventional meaning, here are a few notes on
  2474. others that are not conventional. The function cosxx() duplicates a bug in the 
  2475. version 16 cos() function. Then abs(x+iy) = abs(x)+i*abs(y), flip(x+iy) = 
  2476. y+i*x, and |x+iy| = x*x+y*y. 
  2477.  
  2478. The formulas are performed using either integer or floating point
  2479. mathematics depending on the <F> floating point toggle.  If you do not
  2480. have an FPU then type MPC math is performed in lieu of traditional
  2481. floating point.
  2482.  
  2483. The 'rand' predefined variable is changed with each iteration to a new
  2484. random number with the real and imaginary components containing a value
  2485. between zero and 1. Use the srand() function to initialize the random
  2486. numbers to a consistent random number sequence.  If a formula does not
  2487. contain the srand() function, then the formula compiler will use the system
  2488. time to initialize the sequence.  This could cause a different fractal to be
  2489. generated each time the formula is used depending on how the formula is
  2490. written.
  2491.  
  2492. Remember that when using integer math there is a limited dynamic range, so
  2493. what you think may be a fractal could really be just a limitation of the
  2494. integer math range.  God may work with integers, but His dynamic range is
  2495. many orders of magnitude greater than our puny 32 bit mathematics!  Always
  2496. verify with the floating point <F> toggle.
  2497.  
  2498. The possible values for symmetry are:\
  2499.  
  2500. XAXIS,  XAXIS_NOPARM\
  2501. YAXIS,  YAXIS_NOPARM\
  2502. XYAXIS, XYAXIS_NOPARM\
  2503. ORIGIN, ORIGIN_NOPARM\
  2504. PI_SYM, PI_SYM_NOPARM\
  2505. XAXIS_NOREAL\
  2506. XAXIS_NOIMAG\
  2507.  
  2508. These will force the symmetry even if no symmetry is actually present, so try
  2509. your formulas without symmetry before you use these.
  2510.  
  2511. For mathematical formulas of functions used in the parser language, see\
  2512. { Trig Identities}
  2513. ;
  2514. ;
  2515. ~Topic=Frothy Basins, Label=HT_FROTH
  2516. (type=frothybasin)
  2517.  
  2518. Frothy Basins, or Riddled Basins, were discovered by James C. Alexander of
  2519. the University of Maryland.  The discussion below is derived from a two page
  2520. article entitled "Basins of Froth" in Science News, November 14, 1992 and
  2521. from correspondence with others, including Dr. Alexander.
  2522.  
  2523. The equations that generate this fractal are not very different from those
  2524. that generate many other orbit fractals.
  2525.  
  2526. ~Format-
  2527.       Z(0) = pixel;
  2528.       Z(n+1) = Z(n)^2 - C*conj(Z(n))
  2529.       where C = 1 + A*i
  2530. ~Format+
  2531.  
  2532. One of the things that makes this fractal so interesting is the shape of
  2533. the dynamical system's attractors.  It is not at all uncommon for a
  2534. dynamical system to have non-point attractors.  Shapes such as circles are
  2535. very common.  Strange attractors are attractors which are themselves
  2536. fractal.  What is unusual about this system, however, is that the
  2537. attractors intersect.  This is the first case in which such a phenomenon
  2538. has been observed.  The attractors for this system are made up of line
  2539. segments which overlap to form an equilateral triangle.  This attractor
  2540. triangle can be seen by using the "show orbits" option (the 'o' key) or
  2541. the "orbits window" option (the ctrl-'o' key).
  2542.  
  2543. The number of attractors present is dependant on the value of A, the
  2544. imaginary part of C.  For values where A <= 1.028713768218725..., there
  2545. are three attractors.  When A is larger than this critical value, two of
  2546. attractors merge into one, leaving only two attractors.  An interesting
  2547. variation on this fractal can be generated by applying the above mapping
  2548. twice per each iteration.  The result is that some of the attractors are
  2549. split into two parts, giving the system either six or three attractors,
  2550. depending on whether A is less than or greater than the critical value.
  2551.  
  2552. These are also called "Riddled Basins" because each basin is riddled with
  2553. holes.  Which attractor a point is eventually pulled into is extremely
  2554. sensitive to its initial position.  A very slight change in any direction
  2555. may cause it to end up on a different attractor.  As a result, the basins
  2556. are thoroughly intermingled. The effect appears to be a frothy mixture that
  2557. has been subjected to lots of stirring and folding.
  2558.  
  2559. Pixel color is determined by which attractor captures the orbit.  The shade
  2560. of color is determined by the number of iterations required to capture the
  2561. orbit.  In Fractint, the actual shade of color used depends on how many
  2562. colors are available in the video mode being used.  If 256 colors are
  2563. available, the default coloring scheme is determined by the number of
  2564. iterations that were required to capture the orbit.  An alternative
  2565. coloring scheme can be used where the shade is determined by the
  2566. iterations required divided by the maximum iterations.  This method is
  2567. especially useful on deeply zoomed images.  If only 16 colors are
  2568. available, then only the alternative coloring scheme is used.  If fewer
  2569. than 16 colors are available, then Fractint just colors the basins without
  2570. any shading.
  2571. ;
  2572. ;
  2573. ~Topic=Julibrots, Label=HT_JULIBROT
  2574. (type=julibrot)
  2575.  
  2576. The Julibrot fractal type uses a general-purpose renderer for visualizing 
  2577. three dimensional solid fractals. Originally Mark Peterson developed
  2578. this rendering mechanism to view a 3-D sections of a 4-D structure he
  2579. called a "Julibrot".  This structure, also called "layered Julia set" in 
  2580. the fractal literature, hinges on the relationship between the Mandelbrot 
  2581. and Julia sets. Each Julia set is created using a fixed value c in the 
  2582. iterated formula z^2 + c. The Julibrot is created by layering Julia sets 
  2583. in the x-y plane and continuously varying c, creating new Julia sets as z is
  2584. incremented. The solid shape thus created is rendered by shading the surface 
  2585. using a brightness inversely proportional to the virtual viewer's eye. 
  2586.  
  2587. Starting with Fractint version 18, the Julibrot engine can be used
  2588. with other Julia formulas besides the classic z^2 + c. The first field on 
  2589. the Julibrot parameter screen lets you select which orbit formula to use.
  2590.  
  2591. You can also use the Julibrot renderer to visualize 3D cross sections of
  2592. true four dimensional Quaternion and Hypercomplex fractals. 
  2593.  
  2594. The Julibrot Parameter Screens
  2595.  
  2596. Orbit Algorithm - select the orbit algorithm to use. The available 
  2597.    possibilities include 2-D Julia and both mandelbrot and Julia variants
  2598.    of the 4-D Quaternion and Hypercomplex fractals.
  2599.  
  2600. Orbit parameters - the next screen lets you fill in any parameters 
  2601.    belonging to the orbit algorithm. This list of parameters is not
  2602.    necessarily the same as the list normally presented for the orbit
  2603.    algorithm, because some of these parameters are used in the Julibrot
  2604.    layering process. 
  2605.  
  2606.    From/To Parameters
  2607.    These parameters allow you to specify the "Mandelbrot" values used to
  2608.    generate the layered Julias. The parameter c in the Julia formulas will
  2609.    be incremented in steps ranging from the "from" x and y values to the
  2610.    "to" x and y values. If the orbit formula is one of the "true" four 
  2611.    dimensional fractal types quat, quatj, hypercomplex, or hypercomplexj, 
  2612.    then these numbers are used with the 3rd and 4th dimensional values.
  2613.  
  2614.    The "from/to" variables are different for the different kinds of orbit
  2615.    algorithm.
  2616.  
  2617.       2D Julia sets - complex number formula z' = f(z) + c\
  2618.          The "from/to" parameters change the values of c.\
  2619.       4D Julia sets - Quaternion or Hypercomplex formula z' = f(z) + c\
  2620.          The four dimensions of c are set by the orbit parameters.\
  2621.          The first two dimensions of z are determined by the corners values.\
  2622.          The third and fourth dimensions of z are the "to/from" variables.\
  2623.       4D Mandelbrot sets - Quaternion or Hypercomplex formula z' = f(z) + c\
  2624.          The first two dimensions of c are determined by the corners values.\
  2625.          The third and fourth dimensions of c are the "to/from" variables.\
  2626.  
  2627. Distance between the eyes - set this to 2.5 if you want a red/blue
  2628.    anaglyph image, 0 for a normal greyscale image.
  2629.  
  2630. Number of z pixels - this sets how many layers are rendered in the screen
  2631.    z-axis. Use a higher value with higher resolution video modes.
  2632.  
  2633. The remainder of the parameters are needed to construct the red/blue
  2634. picture so that the fractal appears with the desired depth and proper 'z'
  2635. location.  With the origin set to 8 inches beyond the screen plane and the
  2636. depth of the fractal at 8 inches the default fractal will appear to start
  2637. at 4 inches beyond the screen and extend to 12 inches if your eyeballs are
  2638. 2.5 inches apart and located at a distance of 24 inches from the screen.
  2639. The screen dimensions provide the reference frame.
  2640.  
  2641. ;
  2642. ;
  2643. ~Topic=Diffusion Limited Aggregation, Label=HT_DIFFUS
  2644. (type=diffusion)
  2645.  
  2646. This type begins with a single point in the center of the screen.
  2647. Subsequent points move around randomly until coming into contact with the
  2648. first point, at which time their locations are fixed and they are colored
  2649. randomly.  This process repeats until the fractals reaches the edge of the
  2650. screen.  Use the show orbits function to see the points' random motion.
  2651.  
  2652. One unfortunate problem is that on a large screen, this process will tend
  2653. to take eons.  To speed things up, the points are restricted to a box
  2654. around the initial point.  The first and only parameter to diffusion
  2655. contains the size of the border between the fractal and the edge of the
  2656. box.  If you make this number small, the fractal will look more solid and
  2657. will be generated more quickly.
  2658.  
  2659. Diffusion was inspired by a Scientific American article a couple of years
  2660. back which includes actual pictures of real physical phenomena that behave
  2661. like this.
  2662.  
  2663. Thanks to Adrian Mariano for providing the diffusion code and
  2664. documentation. Juan J. Buhler added the additional options.
  2665. ;
  2666. ;
  2667. ~Topic=Lyapunov Fractals, Label=HT_LYAPUNOV
  2668. (type=lyapunov)
  2669.  
  2670. The Bifurcation fractal illustrates what happens in a simple population
  2671. model as the growth rate increases.  The Lyapunov fractal expands that model
  2672. into two dimensions by letting the growth rate vary in a periodic fashion
  2673. between two values.  Each pair of growth rates is run through a logistic
  2674. population model and a value called the Lyapunov Exponent is calculated for
  2675. each pair and is plotted. The Lyapunov Exponent is calculated by adding up
  2676. log | r - 2*r*x| over many cycles of the population model and dividing by the
  2677. number of cycles. Negative Lyapunov exponents indicate a stable, periodic
  2678. behavior and are plotted in color. Positive Lyapunov exponents indicate
  2679. chaos (or a diverging model) and are colored black.
  2680.  
  2681. Order parameter.
  2682. Each possible periodic sequence yields a two dimensional space to explore.
  2683. The Order parameter selects a sequence.  The default value 0 represents the
  2684. sequence ab which alternates between the two values of the growth parameter.
  2685. On the screen, the a values run vertically and the b values run
  2686. horizontally. Here is how to calculate the space parameter for any desired
  2687. sequence.  Take your sequence of a's and b's and arrange it so that it starts
  2688. with at least 2 a's and ends with a b. It may be necessary to rotate the
  2689. sequence or swap a's and b's. Strike the first a and the last b off the list
  2690. and replace each remaining a with a 1 and each remaining b with a zero.
  2691. Interpret this as a binary number and convert it into decimal.
  2692.  
  2693. An Example.
  2694. I like sonnets.  A sonnet is a poem with fourteen lines that has the
  2695. following rhyming sequence: abba abba abab cc.  Ignoring the rhyming couplet
  2696. at the end, let's calculate the Order parameter for this pattern.
  2697.  
  2698.   abbaabbaabab         doesn't start with at least 2 a's \
  2699.   aabbaabababb         rotate it \
  2700.   1001101010           drop the first and last, replace with 0's and 1's \
  2701.   512+64+32+8+2 = 618
  2702.  
  2703. An Order parameter of 618 gives the Lyapunov equivalent of a sonnet.  "How do
  2704. I make thee? Let me count the ways..."
  2705.  
  2706. Population Seed.
  2707. When two parts of a Lyapunov overlap, which spike overlaps which is strongly
  2708. dependent on the initial value of the population model.  Any changes from
  2709. using a different starting value between 0 and 1 may be subtle. The values 0
  2710. and 1 are interpreted in a special manner. A Seed of 1 will choose a random
  2711. number between 0 and 1 at the start of each pixel. A Seed of 0 will suppress
  2712. resetting the seed value between pixels unless the population model diverges
  2713. in which case a random seed will be used on the next pixel.
  2714.  
  2715. Filter Cycles.
  2716. Like the Bifurcation model, the Lyapunov allow you to set the number of
  2717. cycles that will be run to allow the model to approach equilibrium before
  2718. the lyapunov exponent calculation is begun. The default value of 0 uses one
  2719. half of the iterations before beginning the calculation of the exponent.
  2720.  
  2721. Reference.
  2722. A.K. Dewdney, Mathematical Recreations, Scientific American, Sept. 1991
  2723. ;
  2724. ;
  2725. ~Topic=Magnetic Fractals, Label=HT_MAGNET
  2726. (type=magnet1m/.../magnet2j)
  2727.  
  2728. These fractals use formulae derived from the study of hierarchical
  2729. lattices, in the context of magnetic renormalisation transformations.
  2730. This kinda stuff is useful in an area of theoretical physics that deals
  2731. with magnetic phase-transitions (predicting at which temperatures a given
  2732. substance will be magnetic, or non-magnetic).  In an attempt to clarify
  2733. the results obtained for Real temperatures (the kind that you and I can
  2734. feel), the study moved into the realm of Complex Numbers, aiming to spot
  2735. Real phase-transitions by finding the intersections of lines representing
  2736. Complex phase-transitions with the Real Axis.  The first people to try
  2737. this were two physicists called Yang and Lee, who found the situation a
  2738. bit more complex than first expected, as the phase boundaries for Complex
  2739. temperatures are (surprise!) fractals.
  2740.  
  2741. And that's all the technical (?) background you're getting here!  For more
  2742. details (are you SERIOUS ?!) read "The Beauty of Fractals".  When you
  2743. understand it all, you might like to rewrite this section, before you
  2744. start your new job as a professor of theoretical physics...
  2745.  
  2746. In Fractint terms, the important bits of the above are "Fractals",
  2747. "Complex Numbers", "Formulae", and "The Beauty of Fractals".  Lifting the
  2748. Formulae straight out of the Book and iterating them over the Complex
  2749. plane (just like the Mandelbrot set) produces Fractals.
  2750.  
  2751. The formulae are a bit more complicated than the Z^2+C used for the
  2752. Mandelbrot Set, that's all.  They are :
  2753.  
  2754. ~Format-
  2755.           [          ] 2
  2756.           |  Z^2 + (C-1)  |
  2757.     MAGNET1 : | ------------- | 
  2758.           |  2*Z + (C-2)  |
  2759.           [          ]
  2760.  
  2761.           [                        ] 2
  2762.           |     Z^3 + 3*(C-1)*Z + (C-1)*(C-2)        |
  2763.     MAGNET2 : | --------------------------------------- | 
  2764.           |  3*(Z^2) + 3*(C-2)*Z + (C-1)*(C-2) + 1  |
  2765.           [                        ]
  2766. ~Format+
  2767.  
  2768. These aren't quite as horrific as they look (oh yeah ?!) as they only
  2769. involve two variables (Z and C), but cubing things, doing division, and
  2770. eventually squaring the result (all in Complex Numbers) don't exactly
  2771. spell S-p-e-e-d !  These are NOT the fastest fractals in Fractint !
  2772.  
  2773. As you might expect, for both formulae there is a single related
  2774. Mandelbrot-type set (magnet1m, magnet2m) and an infinite number of related
  2775. Julia-type sets (magnet1j, magnet2j), with the usual toggle between the
  2776. corresponding Ms and Js via the spacebar.
  2777.  
  2778. If you fancy delving into the Julia-types by hand, you will be prompted
  2779. for the Real and Imaginary parts of the parameter denoted by C.  The
  2780. result is symmetrical about the Real axis (and therefore the initial image
  2781. gets drawn in half the usual time) if you specify a value of Zero for the
  2782. Imaginary part of C.
  2783.  
  2784. Fractint Historical Note:  Another complication (besides the formulae) in
  2785. implementing these fractal types was that they all have a finite attractor
  2786. (1.0 + 0.0i), as well as the usual one (Infinity).  This fact spurred the
  2787. development of Finite Attractor logic in Fractint.  Without this code you
  2788. can still generate these fractals, but you usually end up with a pretty
  2789. boring image that is mostly deep blue "lake", courtesy of Fractint's
  2790. standard {Periodicity Logic}.
  2791. See {Finite Attractors} for more
  2792. information on this aspect of Fractint internals.
  2793.  
  2794. (Thanks to Kevin Allen for Magnetic type documentation above).
  2795. ;
  2796. ;
  2797. ~Topic=L-Systems, Label=HT_LSYS
  2798. (type=lsystem)
  2799.  
  2800. These fractals are constructed from line segments using rules specified in
  2801. drawing commands.  Starting with an initial string, the axiom,
  2802. transformation rules are applied a specified number of times, to produce
  2803. the final command string which is used to draw the image.
  2804.  
  2805. Like the type=formula fractals, this type requires a separate data file.
  2806. A sample file, FRACTINT.L, is included with this distribution.    When you
  2807. select type lsystem, the current lsystem file is read and you are asked
  2808. for the lsystem name you wish to run. Press <F6> at this point if you wish
  2809. to use a different lsystem file. After selecting an lsystem, you are asked
  2810. for one parameter - the "order", or number of times to execute all the
  2811. transformation rules.  It is wise to start with small orders, because the
  2812. size of the substituted command string grows exponentially and it is very
  2813. easy to exceed your resolution.  (Higher orders take longer to generate
  2814. too.)  The command line options "lname=" and "lfile=" can be used to over-
  2815. ride the default file name and lsystem name.
  2816.  
  2817. Each L-System entry in the file contains a specification of the angle, the
  2818. axiom, and the transformation rules.  Each item must appear on its own
  2819. line and each line must be less than 160 characters long.
  2820.  
  2821. The statement "angle n" sets the angle to 360/n degrees; n must be an
  2822. integer greater than two and less than fifty.
  2823.  
  2824. "Axiom string" defines the axiom.
  2825.  
  2826. Transformation rules are specified as "a=string" and convert the single
  2827. character 'a' into "string."  If more than one rule is specified for a
  2828. single character all of the strings will be added together.  This allows
  2829. specifying transformations longer than the 160 character limit.
  2830. Transformation rules may operate on any characters except space, tab or
  2831. '}'.
  2832.  
  2833. Any information after a ; (semi-colon) on a line is treated as a comment.
  2834.  
  2835. Here is a sample lsystem:
  2836.  
  2837. ~Format-
  2838. Dragon \{      ; Name of lsystem, \{ indicates start
  2839.   Angle 8     ; Specify the angle increment to 45 degrees
  2840.   Axiom FX     ; Starting character string
  2841.   F=         ; First rule:    Delete 'F'
  2842.   y=+FX--FY+     ; Change 'y' into  "+fx--fy+"
  2843.   x=-FX++FY-     ; Similar transformation on 'x'
  2844. }         ; final } indicates end
  2845.  
  2846. The standard drawing commands are:
  2847.     F Draw forward
  2848.     G Move forward (without drawing)
  2849.     + Increase angle
  2850.     - Decrease angle
  2851.     | Try to turn 180 degrees. (If angle is odd, the turn
  2852.       will be the largest possible turn less than 180 degrees.)
  2853. ~Format+
  2854.  
  2855. These commands increment angle by the user specified angle value. They
  2856. should be used when possible because they are fast. If greater flexibility
  2857. is needed, use the following commands which keep a completely separate
  2858. angle pointer which is specified in degrees.
  2859.  
  2860. ~Format-
  2861.     D    Draw forward
  2862.     M    Move forward
  2863.     \\nn Increase angle nn degrees
  2864.     /nn Decrease angle nn degrees
  2865.  
  2866. Color control:
  2867.     Cnn Select color nn
  2868.     <nn Increment color by nn
  2869.     >nn decrement color by nn
  2870.  
  2871. Advanced commands:
  2872.     !      Reverse directions (Switch meanings of +, - and \, /)
  2873.     @nnn  Multiply line segment size by nnn
  2874.       nnn may be a plain number, or may be preceded by
  2875.           I for inverse, or Q for square root.
  2876.           (e.g.  @IQ2 divides size by the square root of 2)
  2877.     [      Push.  Stores current angle and position on a stack
  2878.     ]      Pop.    Return to location of last push
  2879. ~Format+
  2880.  
  2881. Other characters are perfectly legal in command strings.  They are ignored
  2882. for drawing purposes, but can be used to achieve complex translations.
  2883.  
  2884. The characters '+', '-', '<', '>', '[', ']', '|', '!', '@', '/', '\\',
  2885. and 'c' are reserved symbols and cannot be redefined.  For example, c=f+f
  2886. and <= , are syntax errors.
  2887.  
  2888. The integer code produces incorrect results in five known instances, Peano2
  2889. with order >= 7, SnowFlake1 with order >=6, and SnowFlake2, SnowFlake3, and
  2890. SnowflakeColor with order >= 5.  If you see strange results, switch to the
  2891. floating point code.
  2892. ;
  2893. ;
  2894. ;
  2895.