home *** CD-ROM | disk | FTP | other *** search
/ Photo CD Demo 1 / Demo.bin / fractint / fras1611.zip / HELP2.SRC < prev    next >
Text File  |  1991-06-03  |  81KB  |  1,886 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_BARNS barnsleyj1}
  23. ~Label=HF_BARNSJ1
  24.       z(0) = pixel;
  25.       z(n+1) = (z-1)*c if real(z) >= 0, else
  26.       z(n+1) = (z+1)*modulus(c)/c
  27.     Two parameters: real and imaginary parts of c
  28. {=HT_BARNS barnsleyj2}
  29. ~Label=HF_BARNSJ2
  30.       z(0) = pixel;
  31.       if real(z(n)) * imag(c) + real(c) * imag(z((n)) >= 0
  32.      z(n+1) = (z(n)-1)*c
  33.       else
  34.      z(n+1) = (z(n)+1)*c
  35.     Two parameters: real and imaginary parts of c
  36. {=HT_BARNS barnsleyj3}
  37. ~Label=HF_BARNSJ3
  38.       z(0) = pixel;
  39.       if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
  40.      + i * (2*real(z((n)) * imag(z((n))) else
  41.       z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
  42.          + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))
  43.     Two parameters: real and imaginary parts of c.
  44. ~OnlineFF
  45. {=HT_BARNS barnsleym1}
  46. ~Label=HF_BARNSM1
  47.       z(0) = c = pixel;
  48.       if real(z) >= 0 then
  49.     z(n+1) = (z-1)*c
  50.       else
  51.     z(n+1) = (z+1)*modulus(c)/c.
  52.     Parameters are perturbations of z(0)
  53. {=HT_BARNS barnsleym2}
  54. ~Label=HF_BARNSM2
  55.       z(0) = c = pixel;
  56.       if real(z)*imag(c) + real(c)*imag(z) >= 0
  57.     z(n+1) = (z-1)*c
  58.       else
  59.     z(n+1) = (z+1)*c
  60.     Parameters are perturbations of z(0)
  61. {=HT_BARNS barnsleym3}
  62. ~Label=HF_BARNSM3
  63.       z(0) = c = pixel;
  64.       if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
  65.      + i * (2*real(z((n)) * imag(z((n))) else
  66.       z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
  67.      + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))
  68.     Parameters are pertubations of z(0)
  69. ~OnlineFF
  70.  
  71. {=HT_BIF bifurcation}
  72. ~Label=HF_BIFURCATION
  73.     Pictoral representation of a population growth model.
  74.       Let P = new population, p = oldpopulation, r = growth rate
  75.       The model is: P = p +  r*p*(1-p).
  76.     No parameters.
  77. {=HT_BIF bif+sinpi}
  78. ~Label=HF_BIFPLUSSINPI
  79.     Bifurcation variation: model is: P = p + r*sin(PI*p).
  80.     No parameters.
  81. {=HT_BIF bif=sinpi}
  82. ~Label=HF_BIFEQSINPI
  83.     Bifurcation variation: model is: P = r*sin(PI*p).
  84.     No parameters.
  85. {=HT_BIF biflambda}
  86. ~Label=HF_BIFLAMBDA
  87.     Bifurcation variation: model is: P = r*p*(1-p)P.
  88.     No parameters.
  89.  
  90. ~OnlineFF
  91. {=HT_MARKS cmplxmarksjul}
  92. ~Label=HF_CMPLXMARKSJUL
  93.     A generalization of the marksjulia fractal.
  94.       z(0) = pixel;
  95.       z(n+1) = (c^exp)*z(n) + c.
  96.     Four parameters: real and imaginary parts of c and exp.
  97. {=HT_MARKS cmplxmarksmand}
  98. ~Label=HF_CMPLXMARKSMAND
  99.     A generalization of the marksmandel fractal.
  100.       z(0) = c = pixel;
  101.       z(n+1) = (c^exp)*z(n) + c.
  102.     Four parameters: real and imaginary parts of
  103.     perturbation of z(0) and exp.
  104.  
  105. {=HT_NEWTCMPLX complexnewton\, complexbasin}
  106. ~Label=HF_COMPLEXNEWT
  107.     Newton fractal types extended to complex degrees. Complexnewton
  108.     colors pixels according to the number of iterations required to
  109.     escape to a root. Complexbasin colors pixels according to which
  110.     root captures the orbit. The equation is based on the newton
  111.     formula for solving the equation z^p = r
  112.       z(0) = pixel;
  113.       z(n+1) = ((p - 1) * z(n)^p + r)/(p * z(n)^(p - 1)).
  114.     Four parameters: real & imaginary parts of degree p and root r
  115. ~OnlineFF
  116.  
  117. {=HT_DIFFUS diffusion}
  118. ~Label=HF_DIFFUS
  119.     Diffusion Limited Aggregation.  Randomly moving points
  120.     accumulate.  One parameter: border width (default 10)
  121.  
  122. {=HT_SCOTSKIN fn+fn(pix)}
  123. ~Label=HF_FNPLUSFNPIX
  124.       c = z(0) = pixel;
  125.       z(n+1) = fn1(z) + p*fn2(c)
  126.     Six parameters: real and imaginary parts of the perturbation
  127.     of z(0) and factor p, and the functions fn1, and fn2.
  128.  
  129. {=HT_SCOTSKIN fn(z*z)}
  130. ~Label=HF_FNZTIMESZ
  131.       z(0) = pixel;
  132.       z(n+1) = fn(z(n)*z(n))
  133.     One parameter: the function fn.
  134.  
  135. {=HT_SCOTSKIN fn*fn}
  136. ~Label=HF_FNTIMESFN
  137.       z(0) = pixel; z(n+1) = fn1(n)*fn2(n)
  138.     Two parameters: the functions fn1 and fn2.
  139. ~OnlineFF
  140.  
  141. {=HT_SCOTSKIN fn*z+z}
  142. ~Label=HF_FNXZPLUSZ
  143.       z(0) = pixel; z(n+1) = p1*fn(z(n))*z(n) + p2*z(n)
  144.     Six parameters: the real and imaginary components of
  145.     p1 and p2, and the functions fn1 and fn2.
  146.  
  147. {=HT_SCOTSKIN fn+fn}
  148. ~Label=HF_FNPLUSFN
  149.       z(0) = pixel;
  150.       z(n+1) = p1*fn1(z(n))+p2*fn2(z(n))
  151.     Six parameters: The real and imaginary components of
  152.     p1 and p2, and the functions fn1 and fn2.
  153.  
  154. {=HT_FORMULA formula}
  155.     Formula interpreter - write your own formulas as text files!
  156.  
  157. {=HT_GINGER gingerbread}
  158. ~Label=HF_GINGER
  159.     Orbit in two dimensions defined by:
  160.       x(n+1) = 1 - y(n) + |x(n)|
  161.       y(n+1) = x(n)
  162.     Two parameters: initial values of x(0) and y(0).
  163. ~OnlineFF
  164.  
  165. {=HT_HENON henon}
  166. ~Label=HF_HENON
  167.     Orbit in two dimensions defined by:
  168.       x(n+1) = 1 + y(n) - a*x(n)*x(n)
  169.       y(n+1) = b*x(n)
  170.     Two parameters: a and b
  171.  
  172. {=HT_IFS Barnsley IFS}
  173.     Barnsley IFS fractals.
  174.  
  175. {=HT_PICKMJ julfn+exp}
  176. ~Label=HF_JULFNPLUSEXP
  177.     A generalized Clifford Pickover fractal.
  178.       z(0) = pixel;
  179.       z(n+1) = fn(z(n)) + e^z(n) + c.
  180.     Three parameters: real & imaginary parts of c, and fn
  181.  
  182. {=HT_PICKMJ julfn+zsqrd}
  183. ~Label=HF_JULFNPLUSZSQRD
  184.       z(0) = pixel;
  185.       z(n+1) = fn(z(n)) + z(n)^2 + c
  186.     Three parameters: real & imaginary parts of c, and fn
  187. ~OnlineFF
  188.  
  189. {=HT_JULIA julia}
  190. ~Label=HF_JULIA
  191.     Classic Julia set fractal.
  192.       z(0) = pixel; z(n+1) = z(n)^2 + c.
  193.     Two parameters: real and imaginary parts of c.
  194.  
  195. {=HT_MANDJUL4 julia4}
  196. ~Label=HF_JULIA4
  197.     Fourth-power Julia set fractals, a special case
  198.     of julzpower kept for speed.
  199.       z(0) = pixel;
  200.       z(n+1) = z(n)^4 + c.
  201.     Two parameters: real and imaginary parts of c.
  202.  
  203. {=HT_JULIBROT julibrot}
  204.     'Julibrot' 4-dimensional fractals.
  205.  
  206. {=HT_PICKMJ julzpower}
  207. ~Label=HF_JULZPOWER
  208.       z(0) = pixel;
  209.       z(n+1) = z(n)^m + c.
  210.     Three parameters: real & imaginary parts of c, exponent m
  211. ~OnlineFF
  212.  
  213. {=HT_PICKMJ julzzpwr}
  214. ~Label=HF_JULZZPWR
  215.       z(0) = pixel;
  216.       z(n+1) = z(n)^z(n) + z(n)^m + c.
  217.     Three parameters: real & imaginary parts of c, exponent m
  218.  
  219. {=HT_KAM kamtorus, kamtorus3d}
  220. ~Label=HF_KAM
  221.     Series of orbits superimposed.
  222.     3d version has 'orbit' the z dimension.
  223.       x(0) = y(0) = orbit/3;
  224.       x(n+1) = x(n)*cos(a) + (x(n)*x(n)-y(n))*sin(a)
  225.       y(n+1) = x(n)*sin(a) - (x(n)*x(n)-y(n))*cos(a)
  226.     After each orbit, 'orbit' is incremented by a step size.
  227.     Parameters: a, step size, stop value for 'orbit', and
  228.     points per orbit.
  229.  
  230. {=HT_LAMBDA lambda}
  231. ~Label=HF_LAMBDA
  232.     Classic Lambda fractal. 'Julia' variant of Mandellambda.
  233.       z(0) = pixel;
  234.       z(n+1) = lambda*z(n)*(1 - z(n)^2).
  235.     Two parameters: real and imaginary parts of lambda.
  236. ~OnlineFF
  237.  
  238. {=HT_LAMBDAFN lambdafn}
  239. ~Label=HF_LAMBDAFN
  240.       z(0) = pixel;
  241.       z(n+1) = lambda * fn(z(n)).
  242.     Three parameters: real, imag portions of lambda, and fn
  243.  
  244. {=HT_LORENZ lorenz, lorenz3d}
  245. ~Label=HF_LORENZ
  246.     Lorenz attractor - orbit in three dimensions.
  247.     In 2d the x and y components are projected to form the image.
  248.       z(0) = y(0) = z(0) = 1;
  249.       x(n+1) = x(n) + (-a*x(n)*dt) + (     a*y(n)*dt)
  250.       y(n+1) = y(n) + ( b*x(n)*dt) - (       y(n)*dt) - (z(n)*x(n)*dt)
  251.       z(n+1) = z(n) + (-c*z(n)*dt) + (x(n)*y(n)*dt)
  252.     Parameters are dt, a, b, and c.
  253.  
  254. {=HT_LSYS lsystem}
  255.     Using a turtle-graphics control language and starting with
  256.     an initial axiom string, carries out string substitutions the
  257.     specified number of times (the order), and plots the resulting.
  258. ~OnlineFF
  259.  
  260. {=HT_MAGNET magnet1j}
  261. ~Label=HF_MAGJ1
  262.       z(0) = pixel;
  263.         / z(n)^2 + (c-1) \\
  264.       z(n+1) = | ---------------- | ^ 2
  265.         \\ 2*z(n) + (c-2) /
  266.     Parameters: the real and imaginary parts of c
  267. {=HT_MAGNET magnet1m}
  268. ~Label=HF_MAGM1
  269.       z(0) = 0; c = pixel;
  270.         / z(n)^2 + (c-1) \\
  271.       z(n+1) = | ---------------- | ^ 2
  272.         \\ 2*z(n) + (c-2) /
  273.     Parameters: the real & imaginary parts of perturbation of z(0)
  274. {=HT_MAGNET magnet2j}
  275. ~Label=HF_MAGJ2
  276.       z(0) = pixel;
  277.         / z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)          \\
  278.       z(n+1) = |  -------------------------------------------- | ^ 2
  279.         \ 3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) - 1 /
  280.     Parameters: the real and imaginary parts of c
  281. ~OnlineFF
  282.  
  283. {=HT_MAGNET magnet2m}
  284. ~Label=HF_MAGM2
  285.       z(0) = 0; c = pixel;
  286.         / z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)          \\
  287.       z(n+1) = |  -------------------------------------------- | ^ 2
  288.         \ 3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) - 1 /
  289.     Parameters: the real and imaginary parts of perturbation of z(0)
  290.  
  291. {=HT_MANDEL mandel}
  292. ~Label=HF_MANDEL
  293.     Classic Mandelbrot set fractal.
  294.       z(0) = c = pixel;
  295.       z(n+1) = z(n)^2 + c.
  296.     Two parameters: real & imaginary perturbations of z(0)
  297.  
  298. {=HT_MANDJUL4 mandel4}
  299. ~Label=HF_MANDEL4
  300.     Special case of mandelzpower kept for speed.
  301.       z(0) = c = pixel;
  302.       z(n+1) = z(n)^4 + c.
  303.     Parameters: real & imaginary perturbations of z(0)
  304.  
  305. ~OnlineFF
  306. {=HT_MANDFN mandelfn}
  307. ~Label=HF_MANDFN
  308.       z(0) = c = pixel;
  309.       z(n+1) = c*fn(z(n)).
  310.     Parameters: real & imaginary perturbations of z(0), and fn
  311.  
  312. {=HT_MLAMBDA mandellambda}
  313. ~Label=HF_MLAMBDA
  314.       z(0) = .5; lambda = pixel;
  315.       z(n+1) = lambda*z(n)*(1 - z(n)^2).
  316.     Parameters: real & imaginary perturbations of z(0)
  317.  
  318. {=HT_PICKMJ manfn+exp}
  319. ~Label=HF_MANDFNPLUSEXP
  320.     'Mandelbrot-Equivalent' for the julfn+exp fractal.
  321.       z(0) = c = pixel;
  322.       z(n+1) = fn(z(n)) + e^z(n) + C.
  323.     Parameters: real & imaginary perturbations of z(0), and fn
  324.  
  325. {=HT_PICKMJ manfn+zsqrd}
  326. ~Label=HF_MANDFNPLUSZSQRD
  327.     'Mandelbrot-Equivalent' for the Julfn+zsqrd fractal.
  328.       z(0) = c = pixel;
  329.       z(n+1) = fn(z(n)) + z(n)^2 + c.
  330.     Parameters: real & imaginary perturbations of z(0), and fn
  331. ~OnlineFF
  332.  
  333. {=HT_SCOTSKIN manowar}
  334. ~Label=HF_MANOWAR
  335.       c = z1(0) = z(0) = pixel;
  336.       z(n+1) = z(n)^2 + z1(n) + c;
  337.       z1(n+1) = z(n);
  338.     Parameters: real & imaginary perturbations of z(0)
  339. {=HT_SCOTSKIN manowar}
  340. ~Label=HF_MANOWARJ
  341.       z1(0) = z(0) = pixel;
  342.       z(n+1) = z(n)^2 + z1(n) + c;
  343.       z1(n+1) = z(n);
  344.     Parameters: real & imaginary perturbations of z(0)
  345.  
  346. {=HT_PICKMJ manzpower}
  347. ~Label=HF_MANZPOWER
  348.     'Mandelbrot-Equivalent' for julzpower.
  349.       z(0) = c = pixel;
  350.       z(n+1) = z(n)^exp + c; try exp = e = 2.71828...
  351.     Parameters: real & imaginary perturbations of z(0), real &
  352.     imaginary parts of exponent exp.
  353. ~OnlineFF
  354.  
  355. {=HT_PICKMJ manzzpwr}
  356. ~Label=HF_MANZZPWR
  357.     'Mandelbrot-Equivalent' for the julzzpwr fractal.
  358.       z(0) = c = pixel
  359.       z(n+1) = z(n)^z(n) + z(n)^exp + C.
  360.     Parameters: real & imaginary perturbations of z(0), and exponent
  361.  
  362. {=HT_MARKS marksjulia}
  363. ~Label=HF_MARKSJULIA
  364.     A variant of the julia-lambda fractal.
  365.       z(0) = pixel;
  366.       z(n+1) = (c^exp)*z(n) + c.
  367.     Parameters: real & imaginary parts of c, and exponent
  368. {=HT_MARKS marksmandel}
  369. ~Label=HF_MARKSMAND
  370.     A variant of the mandel-lambda fractal.
  371.       z(0) = c = pixel;
  372.       z(n+1) = (c^exp)*z(n) + c.
  373.     Parameters: real & imaginary perturbations of z(0), and exponent
  374.  
  375. ~OnlineFF
  376. {=HT_MARKS marksmandelpwr}
  377. ~Label=HF_MARKSMANDPWR
  378.     The marksmandelpwr formula type generalized (it previously
  379.     had fn=sqr hard coded).
  380.       z(0) = pixel, c = z(0) ^ (z(0) - 1):
  381.       z(n+1) = c * fn(z(n)) + pixel,
  382.     Parameters: real and imaginary pertubations of z(0), and fn
  383.  
  384. {=HT_NEWTBAS newtbasin}
  385. ~Label=HF_NEWTBAS
  386.     Based on the Newton formula for finding the roots of z^p - 1.
  387.     Pixels are colored according to which root captures the orbit.
  388.       z(0) = pixel;
  389.       z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).
  390.     Two parameters: the polynomial degree p, and a flag to turn
  391.     on color stripes to show alternate iterations.
  392. {=HT_NEWT newton}
  393. ~Label=HF_NEWT
  394.     Based on the Newton formula for finding the roots of z^p - 1.
  395.     Pixels are colored according to the iteration when the orbit
  396.     is captured by a root.
  397.       z(0) = pixel;
  398.       z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).
  399.     One parameter: the polynomial degree p.
  400.  
  401. ~OnlineFF
  402. {=HT_PICK pickover}
  403. ~Label=HF_PICKOVER
  404.     Orbit in three dimensions defined by:
  405.       x(n+1) = sin(a*y(n)) - z(n)*cos(b*x(n))
  406.       y(n+1) = z(n)*sin(c*x(n)) - cos(d*y(n))
  407.       z(n+1) = sin(x(n))
  408.     Parameters: a, b, c, and d.
  409.  
  410. {=HT_PLASMA plasma}
  411. ~Label=HF_PLASMA
  412.     Random, cloud-like formations.  Requires 4 or more colors.
  413.     A recursive algorithm repeatedly subdivides the screen and
  414.     colors pixels according to an average of surrounding pixels
  415.     and a random color, less random as the grid size decreases.
  416.     One parameter: 'graininess' (.5 to 50, default = 2).
  417.  
  418. {=HT_POPCORN popcorn}
  419. ~Label=HF_POPCORN
  420.     The orbits in two dimensions defined by:
  421.       x(0) = xpixel, y(0) = ypixel;
  422.       x(n+1) = x(n) - h*sin(y(n) + tan(3*y(n))
  423.       y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n))
  424.     are plotted for each screen pixel and superimposed.
  425.     One parameter: step size h.
  426. ~OnlineFF
  427.  
  428. {=HT_POPCORN popcornjul}
  429. ~Label=HF_POPCJUL
  430.     Conventional Julia using the popcorn formula:
  431.       x(0) = xpixel, y(0) = ypixel;
  432.       x(n+1) = x(n) - h*sin(y(n) + tan(3*y(n))
  433.       y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n))
  434.     One parameter: step size h.
  435.  
  436. {=HT_ROSS rossler3D}
  437. ~Label=HF_ROSS
  438.     Orbit in three dimensions defined by:
  439.       x(0) = y(0) = z(0) = 1;
  440.       x(n+1) = x(n) - y(n)*dt -   z(n)*dt
  441.       y(n+1) = y(n) + x(n)*dt + a*y(n)*dt
  442.       z(n+1) = z(n) + b*dt + x(n)*z(n)*dt - c*z(n)*dt
  443.     Parameters are dt, a, b, and c.
  444.  
  445. {=HT_SIER sierpinski}
  446. ~Label=HF_SIER
  447.     Sierpinski gasket - Julia set producing a 'Swiss cheese triangle'
  448.       z(n+1) = (2*x,2*y-1) if y > .5;
  449.       else (2*x-1,2*y) if x > .5;
  450.       else (2*x,2*y)
  451.     No parameters.
  452. ~OnlineFF
  453.  
  454. {=HT_SCOTSKIN spider}
  455. ~Label=HF_SPIDER
  456.       c(0) = z(0) = pixel;
  457.       z(n+1) = z(n)^2 + c(n);
  458.       c(n+1) = c(n)/2 + z(n+1)
  459.     Parameters: real & imaginary perturbation of z(0)
  460.  
  461. {=HT_SCOTSKIN sqr(1/fn)}
  462. ~Label=HF_SQROVFN
  463.       z(0) = pixel;
  464.       z(n+1) = (1/fn(z(n))^2
  465.     One parameter: the function fn.
  466.  
  467. {=HT_SCOTSKIN sqr(fn)}
  468. ~Label=HF_SQRFN
  469.       z(0) = pixel;
  470.       z(n+1) = fn(z(n))^2
  471.     One parameter: the function fn.
  472. ~OnlineFF
  473.  
  474. {=HT_TEST test}
  475. ~Label=HF_TEST
  476.     'test' point letting us (and you!) easily add fractal types via
  477.     the c module testpt.c.  Default set up is a mandelbrot fractal.
  478.     Four parameters: user hooks (not used by default testpt.c).
  479.  
  480. {=HT_SCOTSKIN tetrate}
  481. ~Label=HF_TETRATE
  482.       z(0) = c = pixel;
  483.       z(n+1) = c^z(n)
  484.     Parameters: real & imaginary perturbation of z(0)
  485.  
  486. {=HT_MARKS tim's_error}
  487. ~Label=HF_TIMSERR
  488.     A serendipitous coding error in marksmandelpwr brings to life
  489.     an ancient pterodactyl!  (Try setting fn to sqr.)
  490.       z(0) = pixel, c = z(0) ^ (z(0) - 1):
  491.       tmp = fn(z(n))
  492.       real(tmp) = real(tmp) * real(c) - imag(tmp) * imag(c);
  493.       imag(tmp) = real(tmp) * imag(c) - imag(tmp) * real(c);
  494.       z(n+1) = tmp + pixel;
  495.     Parameters: real & imaginary pertubations of z(0) and function fn
  496. ~OnlineFF
  497.  
  498. {=HT_UNITY unity}
  499. ~Label=HF_UNITY
  500.       z(0) = pixel;
  501.       x = real(z(n)), y = imag(z(n))
  502.       One = x^2 + y^2;
  503.       y = (2 - One) * x;
  504.       x = (2 - One) * y;
  505.       z(n+1) = x + i*y
  506.     No parameters.
  507. ~CompressSpaces+
  508. ;
  509. ;
  510. ;
  511. ~Topic=Fractal Types
  512.  
  513. A list of the fractal types and their mathematics can be found in the
  514. {Summary of Fractal Types}.  Some notes about how Fractint calculates
  515. them are in "A Little Code" in {"Fractals and the PC"}.
  516.  
  517. Fractint starts by default with the Mandelbrot set. You can change that by
  518. using the command-line argument "TYPE=" followed by one of the
  519. fractal type names, or by using the <T> command and
  520. selecting the type - if parameters are needed, you will be prompted for
  521. them.
  522.  
  523. In the text that follows, due to the limitations of the ASCII character
  524. set, "a*b" means "a times b", and "a^b" means "a to the power b".
  525.  
  526. ~Doc-
  527. Press <PageDown> for type selection list.
  528. ~FF
  529. Select a fractal type:
  530.  
  531. ~Table=40 2 0
  532. { The Mandelbrot Set }
  533. { Julia Sets }
  534. { Newton domains of attraction }
  535. { Newton }
  536. { Complex Newton }
  537. { Lambda Sets }
  538. { Mandellambda Sets }
  539. { Plasma Clouds }
  540. { Lambdafn }
  541. { Mandelfn }
  542. { Barnsley Mandelbrot/Julia Sets }
  543. { Barnsley IFS Fractals }
  544. { Sierpinski Gasket }
  545. { Quartic Mandelbrot/Julia }
  546. { Distance Estimator }
  547. { Pickover Mandelbrot/Julia Types }
  548. { Pickover Popcorn }
  549. { Peterson Variations }
  550. { Unity }
  551. { Scott Taylor / Lee Skinner Variations }
  552. { Kam Torus }
  553. { Bifurcation }
  554. { Orbit Fractals }
  555. { Lorenz Attractors }
  556. { Rossler Attractors }
  557. { Henon Attractors }
  558. { Pickover Attractors }
  559. { Gingerbreadman }
  560. { Test }
  561. { Formula }
  562. { Julibrots }
  563. { Diffusion Limited Aggregation }
  564. { Magnetic Fractals }
  565. { L-Systems }
  566. ~EndTable
  567. ~Doc+
  568. ;
  569. ;
  570. ~Topic=The Mandelbrot Set, Label=HT_MANDEL
  571. (type=mandel)
  572.  
  573. This set is the classic: the only one implemented in many plotting
  574. programs, and the source of most of the printed fractal images published
  575. in recent years. Like most of the other types in Fractint, it is simply a
  576. graph: the x (horizontal) and y (vertical) coordinate axes represent
  577. ranges of two independent quantities, with various colors used to
  578. symbolize levels of a third quantity which depends on the first two. So
  579. far, so good: basic analytic geometry.
  580.  
  581. Now things get a bit hairier. The x axis is ordinary, vanilla real
  582. numbers. The y axis is an imaginary number, i.e. a real number times i,
  583. where i is the square root of -1. Every point on the plane -- in this
  584. case, your PC's display screen -- represents a complex number of the form:
  585.  
  586.     x-coordinate + i * y-coordinate
  587.  
  588. If your math training stopped before you got to imaginary and complex
  589. numbers, this is not the place to catch up. Suffice it to say that they
  590. are just as "real" as the numbers you count fingers with (they're used
  591. every day by electrical engineers) and they can undergo the same kinds of
  592. algebraic operations.
  593.  
  594. OK, now pick any complex number -- any point on the complex plane -- and
  595. call it C, a constant. Pick another, this time one which can vary, and
  596. call it Z. Starting with Z=0 (i.e., at the origin, where the real and
  597. imaginary axes cross), calculate the value of the expression
  598.  
  599.     Z^2 + C
  600.  
  601. Take the result, make it the new value of the variable Z, and calculate
  602. again. Take that result, make it Z, and do it again, and so on: in
  603. mathematical terms, iterate the function Z(n+1) = Z(n)^2 + C. For certain
  604. values of C, the result "levels off" after a while. For all others, it
  605. grows without limit. The Mandelbrot set you see at the start -- the solid-
  606. colored lake (blue by default), the blue circles sprouting from it, and
  607. indeed every point of that color -- is the set of all points C for which
  608. the value of Z is less than 2 after 150 iterations (150 is the default setting,
  609. changeable via the <X> options screen or "maxiter=" parameter).
  610. All the surrounding "contours" of other colors represent points for which Z
  611. exceeds 2 after 149 iterations (the contour closest to the M-set itself),
  612. 148 iterations, (the next one out), and so on.
  613.  
  614. We actually don't test for Z exceeding 2 - we test Z squared against 4
  615. instead because it is easier.  This value (FOUR usually) is known as the
  616. "bailout" value for the calculation, because we stop iterating for the
  617. point when it is reached.  The bailout value can be changed on the <Z>
  618. options screen but the default is usually best.
  619.  
  620. Some features of interest:
  621.  
  622. 1. Use the <X> options screen to increase the maximum number of iterations.
  623. Notice that the boundary of the M-set becomes more and more convoluted (the
  624. technical terms are "wiggly," "squiggly," and "utterly bizarre") as the Z-
  625. values for points that were still within the set after 150 iterations turn
  626. out to exceed 2 after 200, 500, or 1200. In fact, it can be proven that
  627. the true boundary is infinitely long: detail without limit.
  628.  
  629. 2. Although there appear to be isolated "islands" of blue, zoom in -- that
  630. is, plot for a smaller range of coordinates to show more detail -- and
  631. you'll see that there are fine "causeways" of blue connecting them to the
  632. main set. As you zoomed, smaller islands became visible; the same is true
  633. for them. In fact, there are no isolated points in the M-set: it is
  634. "connected" in a strict mathematical sense.
  635.  
  636. 3. The upper and lower halves of the first image are symmetric (a fact
  637. that Fractint makes use of here and in some other fractal types to speed
  638. plotting). But notice that the same general features -- lobed discs,
  639. spirals, starbursts -- tend to repeat themselves (although never exactly)
  640. at smaller and smaller scales, so that it can be impossible to judge by
  641. eye the scale of a given image.
  642.  
  643. 4. In a sense, the contour colors are window-dressing: mathematically, it
  644. is the properties of the M-set itself that are interesting, and no
  645. information about it would be lost if all points outside the set were
  646. assigned the same color. If you're a serious, no-nonsense type, you may
  647. want to cycle the colors just once to see the kind of silliness that other
  648. people enjoy, and then never do it again. Go ahead. Just once, now. We
  649. trust you.
  650. ;
  651. ;
  652. ~Topic=Julia Sets, Label=HT_JULIA
  653. (type=julia)
  654.  
  655. These sets were named for mathematician Gaston Julia, and can be generated
  656. by a simple change in the iteration process described for the
  657. {=HT_MANDEL Mandelbrot Set}.  Start with a
  658. specified value of C, "C-real + i * C-imaginary"; use as the initial value
  659. of Z "x-coordinate + i * y-coordinate"; and repeat the same iteration,
  660. Z(n+1) = Z(n)^2 + C.
  661.  
  662. There is a Julia set corresponding to every point on the complex plane --
  663. an infinite number of Julia sets. But the most visually interesting tend
  664. to be found for the same C values where the M-set image is busiest, i.e.
  665. points just outside the boundary. Go too far inside, and the corresponding
  666. Julia set is a circle; go too far outside, and it breaks up into scattered
  667. points. In fact, all Julia sets for C within the M-set share the
  668. "connected" property of the M-set, and all those for C outside lack it.
  669.  
  670. Fractint's spacebar toggle lets you "flip" between any view of the M-set
  671. and the Julia set for the point C at the center of that screen. You can
  672. then toggle back, or zoom your way into the Julia set for a while and then
  673. return to the M-set. So if the infinite complexity of the M-set palls,
  674. remember: each of its infinite points opens up a whole new Julia set.
  675.  
  676. Historically, the Julia sets came first: it was while looking at the M-set
  677. as an "index" of all the Julia sets' origins that Mandelbrot noticed its
  678. properties.
  679.  
  680. The relationship between the {=HT_MANDEL Mandelbrot} set and Julia set can
  681. hold between
  682. other sets as well.  Many of Fractint's types are "Mandelbrot/Julia" pairs
  683. (sometimes called "M-sets" or "J-sets". All these are generated by
  684. equations that are of the form z(k+1) = f(z(k),c), where the function
  685. orbit is the sequence z(0), z(1), ..., and the variable c is a complex
  686. parameter of the equation. The value c is fixed for "Julia" sets and is
  687. equal to the first two parameters entered with the "params=Creal/Cimag"
  688. command. The initial orbit value z(0) is the complex number corresponding
  689. to the screen pixel. For Mandelbrot sets, the parameter c is the complex
  690. number corresponding to the screen pixel. The value z(0) is c plus a
  691. perturbation equal to the values of the first two parameters.  See
  692. the discussion of {=HT_MLAMBDA Mandellambda Sets}.
  693. This approach may or may not be the
  694. "standard" way to create "Mandelbrot" sets out of "Julia" sets.
  695.  
  696. Some equations have additional parameters.  These values is entered as the
  697. third for fourth params= value for both Julia and Mandelbrot sets. The
  698. variables x and y refer to the real and imaginary parts of z; similarly,
  699. cx and cy are the real and imaginary parts of the parameter c and fx(z)
  700. and fy(z) are the real and imaginary parts of f(z). The variable c is
  701. sometimes called lambda for historical reasons.
  702.  
  703. NOTE: if you use the "PARAMS=" argument to warp the M-set by starting with
  704. an initial value of Z other than 0, the M-set/J-sets correspondence breaks
  705. down and the spacebar toggle no longer works.
  706. ;
  707. ;
  708. ~Topic=Newton domains of attraction, Label=HT_NEWTBAS
  709. (type=newtbasin)
  710.  
  711. The Newton formula is an algorithm used to find the roots of polynomial
  712. equations by successive "guesses" that converge on the correct value as
  713. you feed the results of each approximation back into the formula. It works
  714. very well -- unless you are unlucky enough to pick a value that is on a
  715. line BETWEEN two actual roots. In that case, the sequence explodes into
  716. chaos, with results that diverge more and more wildly as you continue the
  717. iteration.
  718.  
  719. This fractal type shows the results for the polynomial Z^n - 1, which has
  720. n roots in the complex plane. Use the <T>ype command and enter "newtbasin"
  721. in response to the prompt. You will be asked for a parameter, the "order"
  722. of the equation (an integer from 3 through 10 -- 3 for x^3-1, 7 for x^7-1,
  723. etc.). A second parameter is a flag to turn on alternating shades showing
  724. changes in the number of iterations needed to attract an orbit. Some
  725. people like stripes and some don't, as always, Fractint gives you a
  726. choice!
  727.  
  728. The coloring of the plot shows the "basins of attraction" for each root of
  729. the polynomial -- i.e., an initial guess within any area of a given color
  730. would lead you to one of the roots. As you can see, things get a bit weird
  731. along certain radial lines or "spokes," those being the lines between
  732. actual roots. By "weird," we mean infinitely complex in the good old
  733. fractal sense. Zoom in and see for yourself.
  734.  
  735. This fractal type is symmetric about the origin, with the number of
  736. "spokes" depending on the order you select. It uses floating-point math if
  737. you have an FPU, or a somewhat slower integer algorithm if you don't have
  738. one.
  739. ~Doc-
  740.  
  741. See also: {Newton}
  742. ~Doc+
  743. ;
  744. ;
  745. ~Topic=Newton, Label=HT_NEWT
  746. (type=newton)
  747.  
  748. The generating formula here is identical to that for {=HT_NEWTBAS newtbasin},
  749. but the
  750. coloring scheme is different. Pixels are colored not according to the root
  751. that would be "converged on" if you started using Newton's formula from
  752. that point, but according to the iteration when the value is close to a
  753. root.  For example, if the calculations for a particular pixel converge to
  754. the 7th root on the 23rd iteration, NEWTBASIN will color that pixel using
  755. color #7, but NEWTON will color it using color #23.
  756.  
  757. If you have a 256-color mode, use it: the effects can be much livelier
  758. than those you get with type=newtbasin, and color cycling becomes, like,
  759. downright cosmic. If your "corners" choice is symmetrical, Fractint
  760. exploits the symmetry for faster display. There is symmetry in newtbasin,
  761. too, but the current version of the software isn't smart enough to exploit
  762. it.
  763.  
  764. The applicable "params=" values are the same as newtbasin. Try "params=4."
  765. Other values are 3 through 10. 8 has twice the symmetry and is faster. As
  766. with newtbasin, an FPU helps.
  767. ;
  768. ;
  769. ~Topic=Complex Newton, Label=HT_NEWTCMPLX
  770. (type=complexnewton/complexbasin)
  771.  
  772. Well, hey, "Z^n - 1" is so boring when you can use "Z^a - b" where "a" and
  773. "b" are complex numbers!  The new "complexnewton" and "complexbasin"
  774. fractal types are just the old {=HT_NEWT "newton"} and
  775. {=HT_NEWTBAS "newtbasin"} fractal types with
  776. this little added twist.  When you select these fractal types, you are
  777. prompted for four values (the real and imaginary portions of "a" and "b").
  778. If "a" has a complex portion, the fractal has a discontinuity along the
  779. negative axis - relax, we finally figured out that it's *supposed* to be
  780. there!
  781. ;
  782. ;
  783. ~Topic=Lambda Sets, Label=HT_LAMBDA
  784. (type=lambda)
  785.  
  786. This type calculates the Julia set of the formula lambda*Z*(1-Z). That is,
  787. the value Z[0] is initialized with the value corresponding to each pixel
  788. position, and the formula iterated. The pixel is colored according to the
  789. iteration when the sum of the squares of the real and imaginary parts
  790. exceeds 4.
  791.  
  792. Two parameters, the real and imaginary parts of lambda, are required. Try
  793. 0 and 1 to see the classical fractal "dragon". Then try 0.2 and 1 for a
  794. lot more detail to zoom in on.
  795.  
  796. It turns out that all quadratic Julia-type sets can be calculated using
  797. just the formula z^2+c (the "classic" Julia"), so that this type is
  798. redundant, but we include it for reason of it's prominence in the history
  799. of fractals.
  800. ;
  801. ;
  802. ~Topic=Mandellambda Sets, Label=HT_MLAMBDA
  803. (type=mandellambda)
  804.  
  805. This type is the "Mandelbrot equivalent" of the {=HT_LAMBDA lambda} set.
  806. A comment is
  807. in order here. Almost all the Fractint "Mandelbrot" sets are created from
  808. orbits generated using formulas like z(n+1) = f(z(n),C), with z(0) and C
  809. initialized to the complex value corresponding to the current pixel. Our
  810. reasoning was that "Mandelbrots" are maps of the corresponding "Julias".
  811. Using this scheme each pixel of a "Mandelbrot" is colored the same as the
  812. Julia set corresponding to that pixel. However, Kevin Allen informs us
  813. that the MANDELLAMBDA set appears in the literature with z(0) initialized
  814. to a critical point (a point where the derivative of the formula is zero),
  815. which in this case happens to be the point (.5,0). Since Kevin knows more
  816. about Dr. Mandelbrot than we do, and Dr. Mandelbrot knows more about
  817. fractals than we do, we defer! Starting with version 14 Fractint
  818. calculates MANDELAMBDA Dr. Mandelbrot's way instead of our way. But ALL
  819. THE OTHER "Mandelbrot" sets in Fractint are still calculated OUR way!
  820. (Fortunately for us, for the classic Mandelbrot Set these two methods are
  821. the same!)
  822.  
  823. Well now, folks, apart from questions of faithfulness to fractals named in
  824. the literature (which we DO take seriously!), if a formula makes a
  825. beautiful fractal, it is not wrong. In fact some of the best fractals in
  826. Fractint are the results of mistakes! Nevertheless, thanks to Kevin for
  827. keeping us accurate!
  828.  
  829. (See description of "initorbit=" command in {Image Calculation Parameters}
  830. for a way to experiment with different orbit intializations).
  831. ;
  832. ;
  833. ~Topic=Plasma Clouds, Label=HT_PLASMA
  834. (type=plasma)
  835.  
  836. Plasma clouds ARE real live fractals, even though we didn't know it at
  837. first. They are generated by a recursive algorithm that randomly picks
  838. colors of the corner of a rectangle, and then continues recursively
  839. quartering previous rectangles. Random colors are averaged with those of
  840. the outer rectangles so that small neighborhoods do not show much change,
  841. for a smoothed-out, cloud-like effect. The more colors your video mode
  842. supports, the better.  The result, believe it or not, is a fractal
  843. landscape viewed as a contour map, with colors indicating constant
  844. elevation.  To see this, save and view with the <3> command
  845. (see {\"3D\" Images})
  846. and your "cloud" will be converted to a mountain!
  847.  
  848. You've GOT to try {=@ColorCycling color cycling} on these (hit "+" or "-").
  849. If you
  850. haven't been hypnotized by the drawing process, the writhing colors will
  851. do it for sure. We have now implemented subliminal messages to exploit the
  852. user's vulnerable state; their content varies with your bank balance,
  853. politics, gender, accessibility to a Fractint programmer, and so on. A
  854. free copy of Microsoft C to the first person who spots them.
  855.  
  856. This type accepts a single parameter, which determines how abruptly the
  857. colors change. A value of .5 yields bland clouds, while 50 yields very
  858. grainy ones. The default value is 2. Zooming is ignored, as each plasma-
  859. cloud screen is generated randomly.
  860.  
  861. The random number seed used for each plasma image is displayed on the
  862. <tab> information screen, and can be entered with the command line
  863. parameter "rseed=" to recreate a particular image.
  864.  
  865. The algorithm is based on the Pascal program distributed by Bret Mulvey as
  866. PLASMA.ARC. We have ported it to C and integrated it with Fractint's
  867. graphics and animation facilities. This implementation does not use
  868. floating-point math.
  869.  
  870. Saved plasma-cloud screens are EXCELLENT starting images for fractal
  871. "landscapes" created with the {\"3D\" commands}.
  872. ;
  873. ;
  874. ~Topic=Lambdafn, Label=HT_LAMBDAFN
  875. (type=lambdafn)
  876.  
  877. Function=[sin|cos|sinh|cosh|exp|log|sqr|...]) is specified with this type.
  878. Prior to version 14, these types were lambdasine, lambdacos, lambdasinh,
  879. lambdacos, and lambdaexp.  Where we say "lambdasine" or some such below,
  880. the good reader knows we mean "lambdafn with function=sin".)
  881.  
  882. These types calculate the Julia set of the formula lambda*fn(Z), for
  883. various values of the function "fn", where lambda and Z are both complex.
  884. Two values, the real and imaginary parts of lambda, should be given in the
  885. "params=" option.  For the feathery, nested spirals of LambdaSines and the
  886. frost-on-glass patterns of LambdaCosines, make the real part = 1, and try
  887. values for the imaginary part ranging from 0.1 to 0.4 (hint: values near
  888. 0.4 have the best patterns). In these ranges the Julia set "explodes". For
  889. the tongues and blobs of LambdaExponents, try a real part of 0.379 and an
  890. imaginary part of 0.479.
  891.  
  892. A co-processor used to be almost mandatory: each LambdaSine/Cosine
  893. iteration calculates a hyperbolic sine, hyperbolic cosine, a sine, and a
  894. cosine (the LambdaExponent iteration "only" requires an exponent, sine,
  895. and cosine operation)!    However, Fractint now computes these
  896. transcendental functions with fast integer math. In a few cases the fast
  897. math is less accurate, so we have kept the old slow floating point code.
  898. To use the old code, invoke with the float=yes option, and, if you DON'T
  899. have a co-processor, go on a LONG vacation!
  900. ;
  901. ;
  902. ~Topic=Mandelfn, Label=HT_MANDFN
  903. (type=mandelfn)
  904.  
  905. Function=[sin|cos|sinh|cosh|exp|log|sqr|...]) is specified with this type.
  906. Prior to version 14, these types were mandelsine, mandelcos, mandelsinh,
  907. mandelcos, and mandelexp. Same comment about our lapses into the old
  908. terminology as above!
  909.  
  910. These are "pseudo-Mandelbrot" mappings for the {=HT_LAMBDAFN LambdaFn}
  911. Julia functions.
  912. They map to their corresponding Julia sets via the spacebar command in
  913. exactly the same fashion as the original M/J sets.  In general, they are
  914. interesting mainly because of that property (the function=exp set in
  915. particular is rather boring). Generate the appropriate "Mandelfn" set,
  916. zoom on a likely spot where the colors are changing rapidly, and hit the
  917. spacebar key to plot the Julia set for that particular point.
  918.  
  919. Try "FRACTINT TYPE=MANDELFN CORNERS=4.68/4.76/-.03/.03 FUNCTION=COS" for a
  920. graphic demonstration that we're not taking Mandelbrot's name in vain
  921. here. We didn't even know these little buggers were here until Mark
  922. Peterson found this a few hours before the version incorporating Mandelfns
  923. was released.
  924.  
  925. Note: If you created images using the lambda or mandel "fn" types prior to
  926. version 14, and you wish to update the fractal information in the "*.fra"
  927. file, simply read the files and save again. You can do this in batch mode
  928. via a command line like:
  929.  
  930.      "fractint oldfile.fra savename=newfile.gif batch=yes"
  931.  
  932. For example, this procedure can convert a version 13 "type=lambdasine"
  933. image to a version 14 "type=lambdafn function=sin" GIF89a image.  We do
  934. not promise to keep this "backward compatibility" past version 14 - if you
  935. want to keep the fractal information in your *.fra files accurate, we
  936. recommend conversion.  See {GIF Save File Format}.
  937. ;
  938. ;
  939. ~Topic=Barnsley Mandelbrot/Julia Sets, Label=HT_BARNS
  940. (type=barnsleym1/.../j3)
  941.  
  942. Michael Barnsley has written a fascinating college-level text, "Fractals
  943. Everywhere," on fractal geometry and its graphic applications. (See
  944. {Bibliography}.) In it, he applies the principle of the M and J
  945. sets to more general functions of two complex variables.
  946.  
  947. We have incorporated three of Barnsley's examples in Fractint. Their
  948. appearance suggests polarized-light microphotographs of minerals, with
  949. patterns that are less organic and more crystalline than those of the M/J
  950. sets. Each example has both a "Mandelbrot" and a "Julia" type. Toggle
  951. between them using the spacebar.
  952.  
  953. The parameters have the same meaning as they do for the "regular"
  954. Mandelbrot and Julia. For types M1, M2, and M3, they are used to "warp"
  955. the image by setting the initial value of Z. For the types J1 through J3,
  956. they are the values of C in the generating formulas.
  957.  
  958. Be sure to try the <O>rbit function while plotting these types.
  959. ;
  960. ;
  961. ~Topic=Barnsley IFS Fractals, Label=HT_IFS
  962. (type=ifs)
  963.  
  964. One of the most remarkable spin-offs of fractal geometry is the ability to
  965. "encode" realistic images in very small sets of numbers -- parameters for
  966. a set of functions that map a region of two-dimensional space onto itself.
  967. In principle (and increasingly in practice), a scene of any level of
  968. complexity and detail can be stored as a handful of numbers, achieving
  969. amazing "compression" ratios... how about a super-VGA image of a forest,
  970. more than 300,000 pixels at eight bits apiece, from a 1-KB "seed" file?
  971.  
  972. Again, Michael Barnsley and his co-workers at the Georgia Institute of
  973. Technology are to be thanked for pushing the development of these iterated
  974. function systems (IFS).
  975.  
  976. When you select this fractal type, Fractint scans the current IFS file
  977. (default is FRACTINT.IFS, a set of definitions supplied with Fractint) for
  978. IFS definitions, then prompts you for the IFS name you wish to run. Fern
  979. and 3dfern are good ones to start with. You can press <F6> at the
  980. selection screen if you want to select a different .IFS file you've
  981. written.
  982.  
  983. Note that some Barnsley IFS values generate images quite a bit smaller
  984. than the initial (default) screen. Just bring up the zoom box, center it
  985. on the small image, and hit <Enter> to get a full-screen image.
  986.  
  987. To change the number of dots Fractint generates for an IFS image before
  988. stopping, you can change the "maximum iterations" parameter on the <X>
  989. options screen.
  990.  
  991. Fractint supports two types of IFS images: 2D and 3D. In order to fully
  992. appreciate 3D IFS images, since your monitor is presumably 2D, we have
  993. added rotation, translation, and perspective capabilities. These share
  994. values with the same variables used in Fractint's other 3D facilities; for
  995. their meaning see {"Rectangular Coordinate Transformation"}.
  996. You can enter these values from the command line using:
  997.  
  998. rotation=xrot/yrot/zrot       (try 30/30/30)\
  999. shift=xshift/yshift          (shifts BEFORE applying perspective!)\
  1000. perspective=viewerposition    (try 200)\
  1001.  
  1002. Alternatively, entering <I> from main screen will allow you to modify
  1003. these values. The defaults are the same as for regular 3D, and are not
  1004. always optimum for 3D IFS. With the 3dfern IFS type, try
  1005. rotation=30/30/30. Note that applying shift when using perspective changes
  1006. the picture -- your "point of view" is moved.
  1007.  
  1008. A truly wild variation of 3D may be seen by entering "2" for the stereo
  1009. mode (see {"Stereo 3D Viewing"}),
  1010. putting on red/blue "funny glasses", and watching the fern develop
  1011. with full depth perception right there before your eyes!
  1012.  
  1013. This feature USED to be dedicated to Bruce Goren, as a bribe to get him to
  1014. send us MORE knockout stereo slides of 3D ferns, now that we have made it
  1015. so easy! Bruce, what have you done for us *LATELY* ?? (Just kidding,
  1016. really!)
  1017.  
  1018. Each line in an IFS definition (look at FRACTINT.IFS with your editor for
  1019. examples) contains the parameters for one of the generating functions,
  1020. e.g. in FERN:
  1021. ~Format-
  1022.    a    b     c    d    e    f      p
  1023.  ___________________________________
  1024.    0     0    0  .16    0    0     .01
  1025.  .85   .04 -.04  .85    0  1.6     .85
  1026.  .2   -.26  .23  .22    0  1.6     .07
  1027. -.15   .28  .26  .24    0  .44     .07
  1028.  
  1029. The values on each line define a matrix, vector, and probability:
  1030.     matrix   vector  prob
  1031.     |a b|     |e|     p
  1032.     |c d|     |f|
  1033. ~Format+
  1034.  
  1035. The "p" values are the probabilities assigned to each function (how often
  1036. it is used), which add up to one. Fractint supports up to 32 functions,
  1037. although usually three or four are enough.
  1038.  
  1039. 3D IFS definitions are a bit different.  The name is followed by (3D) in
  1040. the definition file, and each line of the definition contains 13 numbers:
  1041. a b c d e f g h i j k l p, defining:
  1042.     matrix   vector  prob\
  1043.     |a b c|   |j|     p\
  1044.     |d e f|   |k|\
  1045.     |g h i|   |l|\
  1046.  
  1047. You can experiment with changes to IFS definitions interactively by using
  1048. Fractint's <Z> command.  After selecting an IFS definition, hit <Z> to
  1049. bring up the IFS editor. This editor displays the current IFS values, lets
  1050. you modify them, and lets you save your modified values as a text file
  1051. which you can then merge into an XXX.IFS file for future use with
  1052. Fractint.
  1053.  
  1054. The program FDESIGN can be used to design IFS fractals - see
  1055. {=@FDESIGN FDESIGN}.
  1056.  
  1057. You can save the points in your IFS fractal in the file ORBITS.RAW which is
  1058. overwritten each time a fractal is generated. The program Acrospin can
  1059. read this file and will let you view the fractal from in any angle using
  1060. the cursor keys. See {=@ACROSPIN Acrospin}.
  1061. ;
  1062. ;
  1063. ~Topic=Sierpinski Gasket, Label=HT_SIER
  1064. (type=sierpinski)
  1065.  
  1066. Another pre-Mandelbrot classic, this one found by W. Sierpinski around
  1067. World War I. It is generated by dividing a triangle into four congruent
  1068. smaller triangles, doing the same to each of them, and so on, yea, even
  1069. unto infinity. (Notice how hard we try to avoid reiterating "iterating"?)
  1070.  
  1071. If you think of the interior triangles as "holes", they occupy more and
  1072. more of the total area, while the "solid" portion becomes as hopelessly
  1073. fragile as that gasket you HAD to remove without damaging it -- you
  1074. remember, that Sunday afternoon when all the parts stores were closed?
  1075. There's a three-dimensional equivalent using nested tetrahedrons instead
  1076. of triangles, but it generates too much pyramid power to be safely
  1077. unleashed yet.
  1078.  
  1079. There are no parameters for this type. We were able to implement it with
  1080. integer math routines, so it runs fairly quickly even without an FPU.
  1081. ;
  1082. ;
  1083. ~Topic=Quartic Mandelbrot/Julia, Label=HT_MANDJUL4
  1084. (type=mandel4/julia4)
  1085.  
  1086. These fractal types are the moral equivalent of the original M and J sets,
  1087. except that they use the formula Z(n+1) = Z(n)^4 + C, which adds
  1088. additional pseudo-symmetries to the plots. The "Mandel4" set maps to the
  1089. "Julia4" set via -- surprise! -- the spacebar toggle. The M4 set is kind
  1090. of boring at first (the area between the "inside" and the "outside" of the
  1091. set is pretty thin, and it tends to take a few zooms to get to any
  1092. interesting sections), but it looks nice once you get there. The Julia
  1093. sets look nice right from the start.
  1094.  
  1095. Other powers, like Z(n)^3 or Z(n)^7, work in exactly the same fashion. We
  1096. used this one only because we're lazy, and Z(n)^4 = (Z(n)^2)^2.
  1097. ;
  1098. ;
  1099. ~Topic=Distance Estimator
  1100. (distest=nnn/nnn)
  1101.  
  1102. This used to be type=demm and type=demj.  These types have not died, but
  1103. are only hiding!  They are equivalent to the mandel and julia types with
  1104. the "distest=" option selected with a predetermined value.
  1105.  
  1106. The {Distance Estimator Method}
  1107. can be used to produce higher quality images of M and J sets,
  1108. especially suitable for printing in black and white.
  1109.  
  1110. If you have some *.fra files made with the old types demm/demj, you may
  1111. want to convert them to the new form.  See the {=HT_MANDFN Mandelfn}
  1112. section for directions to carry out the conversion.
  1113. ;
  1114. ;
  1115. ~Topic=Pickover Mandelbrot/Julia Types, Label=HT_PICKMJ
  1116. (type=manfn+zsqrd/julfn+zsqrd, manzpowr/julzpowr, manzzpwr/julzzpwr,
  1117. manfn+exp/julfn+exp - formerly included man/julsinzsqrd and
  1118. man/julsinexp which have now been generalized)
  1119.  
  1120. These types have been explored by Clifford A. Pickover, of the IBM Thomas
  1121. J. Watson Research center. As implemented in Fractint, they are regular
  1122. Mandelbrot/Julia set pairs that may be plotted with or without the
  1123. {=@Biomorphs "biomorph"} option Pickover used to create organic-looking
  1124. beasties (see
  1125. below). These types are produced with formulas built from the functions
  1126. z^z, z^n, sin(z), and e^z for complex z. Types with "power" or "pwr" in
  1127. their name have an exponent value as a third parameter. For example,
  1128. type=manzpower params=0/0/2 is our old friend the classical Mandelbrot,
  1129. and type=manzpower params=0/0/4 is the Quartic Mandelbrot. Other values of
  1130. the exponent give still other fractals.  Since these WERE the original
  1131. "biomorph" types, we should give an example.  Try:
  1132.  
  1133.     FRACTINT type=manfn+zsqrd biomorph=0 corners=-8/8/-6/6 function=sin
  1134.  
  1135. to see a big biomorph digesting little biomorphs!
  1136. ;
  1137. ;
  1138. ~Topic=Pickover Popcorn, Label=HT_POPCORN
  1139. (type=popcorn/popcornjul)
  1140.  
  1141. Here is another Pickover idea. This one computes and plots the orbits of
  1142. the dynamic system defined by:
  1143.  
  1144.      x(n+1) = x(n) - h*sin(y(n)+tan(3*y(n))\
  1145.      y(n+1) = y(n) - h*sin(x(n)+tan(3*x(n))\
  1146.  
  1147. with the initializers x(0) and y(0) equal to ALL the complex values within
  1148. the "corners" values, and h=.01.  ALL these orbits are superimposed,
  1149. resulting in "popcorn" effect.  You may want to use a maxiter value less
  1150. than normal - Pickover recommends a value of 50.  As a bonus,
  1151. type=popcornjul shows the Julia set generated by these same equations with
  1152. the usual escape-time coloring. Turn on orbit viewing with the "O"
  1153. command, and as you watch the orbit pattern you may get some insight as to
  1154. where the popcorn comes from. Although you can zoom and rotate popcorn,
  1155. the results may not be what you'd expect, due to the superimposing of
  1156. orbits and arbitrary use of color. Just for fun we added type popcornjul,
  1157. which is the plain old Julia set calculated from the same formula.
  1158. ;
  1159. ;
  1160. ~Topic=Peterson Variations, Label=HT_MARKS
  1161. (type=marksmandel, marksjulia, cmplxmarksmand, cmplxmarksjul, marksmandelpwr,
  1162. tim's_error)
  1163.  
  1164. These fractal types are contributions of Mark Peterson. MarksMandel and
  1165. MarksJulia are two families of fractal types that are linked in the same
  1166. manner as the classic Mandelbrot/Julia sets: each MarksMandel set can be
  1167. considered as a mapping into the MarksJulia sets, and is linked with the
  1168. spacebar toggle. The basic equation for these sets is:
  1169.       Z(n+1) = ((lambda^n) * Z(n)^2) + lambda
  1170. where Z(0) = 0.0 and lambda is (x + iy) for MarksMandel. For MarksJulia,
  1171. Z(0) = (x + iy) and lambda is a constant (taken from the MarksMandel
  1172. spacebar toggle, if that method is used). The exponent is a positive
  1173. integer or a complex number. We call these "families" because each value
  1174. of the exponent yields a different MarksMandel set, which turns out to be
  1175. a kinda-polygon with (exponent+1) sides. The exponent value is the third
  1176. parameter, after the "initialization warping" values. Typically one would
  1177. use null warping values, and specify the exponent with something like
  1178. "PARAMS=0/0/4", which creates an unwarped, pentagonal MarksMandel set.
  1179.  
  1180. In the process of coding MarksMandelPwr formula type, Tim Wegner
  1181. created the type "tim's_error" after making an interesting coding mistake.
  1182. ;
  1183. ;
  1184. ~Topic=Unity, Label=HT_UNITY
  1185. (type=unity)
  1186.  
  1187. This Peterson variation began with curiosity about other "Newton-style"
  1188. approximation processes. A simple one,
  1189.  
  1190.    One = (x * x) + (y * y); y = (2 - One) * x;     x = (2 - One) * y;
  1191.  
  1192. produces the fractal called Unity.
  1193.  
  1194. One of its interesting features is the "ghost lines." The iteration loop
  1195. bails out when it reaches the number 1 to within the resolution of a
  1196. screen pixel. When you zoom a section of the image, the bailout criterion
  1197. is adjusted, causing some lines to become thinner and others thicker.
  1198.  
  1199. Only one line in Unity that forms a perfect circle: the one at a radius of
  1200. 1 from the origin. This line is actually infinitely thin. Zooming on it
  1201. reveals only a thinner line, up (down?) to the limit of accuracy for the
  1202. algorithm. The same thing happens with other lines in the fractal, such as
  1203. those around |x| = |y| = (1/2)^(1/2) = .7071
  1204.  
  1205. Try some other tortuous approximations using the {=HT_TEST TEST stub} and
  1206. let us know what you come up with!
  1207. ;
  1208. ;
  1209. ~Topic=Scott Taylor / Lee Skinner Variations, Label=HT_SCOTSKIN
  1210. (type=fn(z*z), fn*fn, fn*z+z, fn+fn, sqr(1/fn), sqr(fn), spider,
  1211. tetrate, manowar)
  1212.  
  1213. Two of Fractint's faithful users went bonkers when we introduced the
  1214. "formula" type, and came up with all kinds of variations on escape-time
  1215. fractals using trig functions.    We decided to put them in as regular
  1216. types, but there were just too many! So we defined the types with variable
  1217. functions and let you, the, overwhelmed user, specify what the functions
  1218. should be! Thus Scott Taylor's "z = sin(z) + z^2" formula type is now the
  1219. "fn+fn" regular type, and EITHER function can be one of sin, cos, tan, cotan,
  1220. sinh, cosh, tanh, cotanh, exp, log, sqr, recip, ident, or cosxx.
  1221. Plus we give you 4 parameters to set, the complex
  1222. coefficients of the two functions!  Thus the innocent-looking "fn+fn" type
  1223. is really 66 different types in disguise, not counting the damage
  1224. done by the parameters!
  1225.  
  1226. Lee informs us that you should not judge fractals by their "outer"
  1227. appearance. For example, the images produced by z = sin(z) + z^2 and z =
  1228. sin(z) - z^2 look very similar, but are different when you zoom in.
  1229. ;
  1230. ;
  1231. ~Topic=Kam Torus, Label=HT_KAM
  1232. (type=kamtorus, kamtorus3d)
  1233.  
  1234. This type is created by superimposing orbits generated by a set of
  1235. equations, with a variable incremented each time.
  1236.  
  1237.      x(0) = y(0) = orbit/3;\
  1238.      x(n+1) = x(n)*cos(a) + (x(n)*x(n)-y(n))*sin(a)\
  1239.      y(n+1) = x(n)*sin(a) - (x(n)*x(n)-y(n))*cos(a)\
  1240.  
  1241. After each orbit, 'orbit' is incremented by a step size. The parameters
  1242. are angle "a", step size for incrementing 'orbit', stop value for 'orbit',
  1243. and points per orbit. Try this with a stop value of 5 with sound=x for
  1244. some weird fractal music (ok, ok, fractal noise)! You will also see the
  1245. KAM Torus head into some chaotic territory that Scott Taylor wanted to
  1246. hide from you by setting the defaults the way he did, but now we have
  1247. revealed all!
  1248.  
  1249. The 3D variant is created by treating 'orbit' as the z coordinate.
  1250.  
  1251. With both variants, you can adjust the "maxiter" value (<X> options
  1252. screen or parameter maxiter=) to change the number of orbits plotted.
  1253. ;
  1254. ;
  1255. ~Topic=Bifurcation, Label=HT_BIF
  1256. (type=bifxxx)
  1257.  
  1258. The wonder of fractal geometry is that such complex forms can arise from
  1259. such simple generating processes. A parallel surprise has emerged in the
  1260. study of dynamical systems: that simple, deterministic equations can yield
  1261. chaotic behavior, in which the system never settles down to a steady state
  1262. or even a periodic loop. Often such systems behave normally up to a
  1263. certain level of some controlling parameter, then go through a transition
  1264. in which there are two possible solutions, then four, and finally a
  1265. chaotic array of possibilities.
  1266.  
  1267. This emerged many years ago in biological models of population growth.
  1268. Consider a (highly over-simplified) model in which the rate of growth is
  1269. partly a function of the size of the current population:
  1270.  
  1271. New Population =  Growth Rate * Old Population * (1 - Old Population)
  1272.  
  1273. where population is normalized to be between 0 and 1. At growth rates less
  1274. than 200 percent, this model is stable: for any starting value, after
  1275. several generations the population settles down to a stable level. But for
  1276. rates over 200 percent, the equation's curve splits or "bifurcates" into
  1277. two discrete solutions, then four, and soon becomes chaotic.
  1278.  
  1279. Type=bifurcation illustrates this model. (Although it's now considered a
  1280. poor one for real populations, it helped get people thinking about chaotic
  1281. systems.) The horizontal axis represents growth rates, from 190 percent
  1282. (far left) to 400 percent; the vertical axis normalized population values,
  1283. from 0 to 4/3. Notice that within the chaotic region, there are narrow
  1284. bands where there is a small, odd number of stable values. It turns out
  1285. that the geometry of this branching is fractal; zoom in where changing
  1286. pixel colors look suspicious, and see for yourself.
  1287.  
  1288. The default display has been filtered by allowing the population to settle
  1289. from its initial value for 5000 cycles before plotting maxiter population
  1290. values. To override this filter value, specify a new (smaller) one as the
  1291. first "PARAMS=" value. "PARAMS=1" produces an unfiltered map.
  1292.  
  1293. Many formulae can be used to produce bifurcations.  Mitchel Feigenbaum
  1294. studied lots of bifurcations in the mid-70's, using a HP-65 calculator
  1295. (IBM PCs, Fractals, and Fractint, were all Sci-Fi then !). He studied
  1296. where bifurcations occurred, for the formula r*p*(1-p), the one described
  1297. above.    He found that the ratios of lengths of adjacent areas of
  1298. bifurcation were four and a bit.  These ratios vary, but, as the growth
  1299. rate increases, they tend to a limit of 4.669+.  This helped him guess
  1300. where bifurcation points would be, and saved lots of time.
  1301.  
  1302. When he studied bifurcations of r*sin(PI*p) he found a similar pattern,
  1303. which is not surprising in itself.  However, 4.669+ popped out, again.
  1304. Different formulae, same number ?  Now, THAT's surprising !  He tried many
  1305. other formulae and ALWAYS got 4.669+ - Hot Damn !!!  So hot, in fact, that
  1306. he phoned home and told his Mom it would make him Famous ! He also went on
  1307. to tell other scientists.  The rest is History...
  1308.  
  1309. (It has been conjectured that if Feigenbaum had a copy of Fractint, and
  1310. used it to study bifurcations, he may never have found his Number, as it
  1311. only became obvious from long perusal of hand-written lists of values,
  1312. without the distraction of wild color-cycling effects !).
  1313.  
  1314. We now know that this number is as universal as PI or E. It appears in
  1315. situations ranging from fluid-flow turbulence, electronic oscillators,
  1316. chemical reactions, and even the Mandelbrot Set - yup, fraid so:
  1317. "budding" of the Mandelbrot Set along the negative real axis occurs at
  1318. intervals determined by Feigenbaum's Number, 4.669201660910.....
  1319.  
  1320. Fractint does not make direct use of the Feigenbaum Number (YET !).
  1321. However, it does now reflect the fact that there is a whole sub-species of
  1322. Bifurcation-type fractals.  Those implemented to date, and the related
  1323. formulae, (writing P for pop[n+1] and p for pop[n]) are :
  1324.  
  1325.   bifurcation    P =  p + r*p*(1-p)    Verhulst Bifurcations.\
  1326.   biflambda    P =     r*p*(1-p)    Real equivalent of Lambda Sets.\
  1327.   bif+sinpi    P =  p + r*sin(PI*p)    Population scenario based on...\
  1328.   bif=sinpi    P =     r*sin(PI*p)    ...Feigenbaum's second formula.\
  1329.  
  1330. It took a while for bifurcations to appear here, despite them being over a
  1331. century old, and intimately related to chaotic systems. However, they are
  1332. now truly alive and well in Fractint!
  1333. ;
  1334. ;
  1335. ~Topic=Orbit Fractals
  1336.  
  1337. Orbit Fractals are generated by plotting an orbit path in two or three
  1338. dimensional space.
  1339.  
  1340. See {Lorenz Attractors}, {Rossler Attractors},
  1341. {Henon Attractors}, {Pickover Attractors}, and {Gingerbreadman}.
  1342.  
  1343. The orbit trajectory for these types can be saved in the file ORBITS.RAW
  1344. by invoking
  1345. Fractint with the "orbitsave=yes" command-line option.  This file will
  1346. be overwritten each time you generate a new fractal, so rename it if you
  1347. want to save it.  A nifty program called Acrospin can read these files and
  1348. rapidly rotate them in 3-D - see {=@ACROSPIN Acrospin}.
  1349. ;
  1350. ;
  1351. ~Topic=Lorenz Attractors, Label=HT_LORENZ
  1352. (type=lorenz/lorenz3d)
  1353.  
  1354. The "Lorenz Attractor" is a "simple" set of three deterministic equations
  1355. developed by Edward Lorenz while studying the non- repeatability of
  1356. weather patterns.  The weather forecaster's basic problem is that even
  1357. very tiny changes in initial patterns ("the beating of a butterfly's
  1358. wings" - the official term is "sensitive dependence on initial
  1359. conditions") eventually reduces the best weather forecast to rubble.
  1360.  
  1361. The lorenz attractor is the plot of the orbit of a dynamic system
  1362. consisting of three first order non-linear differential equations. The
  1363. solution to the differential equation is vector-valued function of one
  1364. variable.  If you think of the variable as time, the solution traces an
  1365. orbit.    The orbit is made up of two spirals at an angle to each other in
  1366. three dimensions. We change the orbit color as time goes on to add a
  1367. little dazzle to the image.  The equations are:
  1368.  
  1369.         dx/dt = -a*x + a*y\
  1370.         dy/dt =  b*x - y   -z*x\
  1371.         dz/dt = -c*z + x*y\
  1372.  
  1373. We solve these differential equations approximately using a method known
  1374. as the first order taylor series.  Calculus teachers everywhere will kill
  1375. us for saying this, but you treat the notation for the derivative dx/dt as
  1376. though it really is a fraction, with "dx" the small change in x that
  1377. happens when the time changes "dt".  So multiply through the above
  1378. equations by dt, and you will have the change in the orbit for a small
  1379. time step. We add these changes to the old vector to get the new vector
  1380. after one step. This gives us:
  1381.  
  1382.          xnew = x + (-a*x*dt) + (a*y*dt)\
  1383.          ynew = y + (b*x*dt) - (y*dt) - (z*x*dt)\
  1384.          znew = z + (-c*z*dt) + (x*y*dt)\
  1385.  
  1386.          (default values: dt = .02, a = 5, b = 15, c = 1)
  1387.  
  1388. We connect the successive points with a line, project the resulting 3D
  1389. orbit onto the screen, and voila! The Lorenz Attractor!
  1390.  
  1391. We have added two versions of the Lorenz Attractor.  "Type=lorenz" is the
  1392. Lorenz attractor as seen in everyday 2D.  "Type=lorenz3d" is the same set
  1393. of equations with the added twist that the results are run through our
  1394. perspective 3D routines, so that you get to view it from different angles
  1395. (you can modify your perspective "on the fly" by using the <I> command.)
  1396. If you set the "stereo" option to "2", and have red/blue funny glasses on,
  1397. you will see the attractor orbit with depth perception.
  1398.  
  1399. Hint: the default perspective values (x = 60, y = 30, z = 0) aren't the
  1400. best ones to use for fun Lorenz Attractor viewing.  Experiment a bit -
  1401. start with rotation values of 0/0/0 and then change to 20/0/0 and 40/0/0
  1402. to see the attractor from different angles.- and while you're at it, use a
  1403. non-zero perspective point Try 100 and see what happens when you get
  1404. *inside* the Lorenz orbits.  Here comes one - Duck!  While you are at it,
  1405. turn on the sound with the "X". This way you'll at least hear it coming!
  1406.  
  1407. Different Lorenz attractors can be created using different parameters.
  1408. Four parameters are used. The first is the time-step (dt). The default
  1409. value is .02. A smaller value makes the plotting go slower; a larger value
  1410. is faster but rougher. A line is drawn to connect successive orbit values.
  1411. The 2nd, third, and fourth parameters are coefficients used in the
  1412. differential equation (a, b, and c). The default values are 5, 15, and 1.
  1413. Try changing these a little at a time to see the result.
  1414. ;
  1415. ;
  1416. ~Topic=Rossler Attractors, Label=HT_ROSS
  1417. (type=rossler3D)
  1418.  
  1419. This fractal is named after the German Otto Rossler, a non-practicing
  1420. medical doctor who approached chaos with a bemusedly philosophical
  1421. attitude.  He would see strange attractors as philosophical objects. His
  1422. fractal namesake looks like a band of ribbon with a fold in it. All we can
  1423. say is we used the same calculus-teacher-defeating trick of multiplying
  1424. the equations by "dt" to solve the differential equation and generate the
  1425. orbit.    This time we will skip straight to the orbit generator - if you
  1426. followed what we did above with type {=HT_LORENZ Lorenz} you can easily
  1427. reverse engineer the differential equations.
  1428.  
  1429.          xnew = x - y*dt -     z*dt\
  1430.          ynew = y + x*dt + a*y*dt\
  1431.          znew = z + b*dt + x*z*dt - c*z*dt\
  1432.  
  1433. Default parameters are dt = .04, a = .2, b = .2, c = 5.7
  1434. ;
  1435. ;
  1436. ~Topic=Henon Attractors, Label=HT_HENON
  1437. (type=henon)
  1438.  
  1439. Michel Henon was an astronomer at Nice observatory in southern France. He
  1440. came to the subject of fractals via investigations of the orbits of
  1441. astronomical objects.  The strange attractor most often linked with
  1442. Henon's name comes not from a differential equation, but from the world of
  1443. discrete mathematics - difference equations. The Henon map is an example
  1444. of a very simple dynamic system that exhibits strange behavior. The orbit
  1445. traces out a characteristic banana shape, but on close inspection, the
  1446. shape is made up of thicker and thinner parts.    Upon magnification, the
  1447. thicker bands resolve to still other thick and thin components.  And so it
  1448. goes forever! The equations that generate this strange pattern perform the
  1449. mathematical equivalent of repeated stretching and folding, over and over
  1450. again.
  1451.  
  1452.          xnew =  1 + y - a*x*x\
  1453.          ynew =  b*x\
  1454.  
  1455. The default parameters are a=1.4 and b=.3.
  1456. ;
  1457. ;
  1458. ~Topic=Pickover Attractors, Label=HT_PICK
  1459. (type=pickover)
  1460.  
  1461. Clifford A. Pickover of the IBM Thomas J. Watson Research center is such a
  1462. creative source for fractals that we attach his name to this one only with
  1463. great trepidation.  Probably tomorrow he'll come up with another one and
  1464. we'll be back to square one trying to figure out a name!
  1465.  
  1466. This one is the three dimensional orbit defined by:
  1467.  
  1468.          xnew = sin(a*y) - z*cos(b*x)\
  1469.          ynew = z*sin(c*x) - cos(d*y)\
  1470.          znew = sin(x)\
  1471.  
  1472. Default parameters are: a = 2.24, b = .43, c = -.65, d = -2.43
  1473. ;
  1474. ;
  1475. ~Topic=Gingerbreadman, Label=HT_GINGER
  1476. (type=gingerbreadman)
  1477.  
  1478. This simple fractal is a charming example stolen from "Science of Fractal
  1479. Images", p. 149.
  1480.  
  1481.          xnew = 1 - y + |x|\
  1482.          ynew = x
  1483.  
  1484. The initial x and y values are set by parameters, defaults x=-.1, y = 0.
  1485. ;
  1486. ;
  1487. ~Topic=Test, Label=HT_TEST
  1488. (type=test)
  1489.  
  1490. This is a stub that we (and you!) use for trying out new fractal types.
  1491. "Type=test" fractals make use of Fractint's structure and features for
  1492. whatever code is in the routine 'testpt()' (located in the small source
  1493. file TESTPT.C) to determine the color of a particular pixel.
  1494.  
  1495. If you have a favorite fractal type that you believe would fit nicely into
  1496. Fractint, just rewrite the C function in TESTPT.C (or use the prototype
  1497. function there, which is a simple M-set implementation) with an algorithm
  1498. that computes a color based on a point in the complex plane.
  1499.  
  1500. After you get it working, send your code to one of the authors and we
  1501. might just add it to the next release of Fractint, with full credit to
  1502. you. Our criteria are: 1) an interesting image and 2) a formula
  1503. significantly different from types already supported. (Bribery may also
  1504. work. THIS author is completely honest, but I don't trust those other
  1505. guys.) Be sure to include an explanation of your algorithm and the
  1506. parameters supported, preferably formatted as you see here to simplify
  1507. folding it into the documentation.
  1508. ;
  1509. ;
  1510. ~Topic=Formula, Label=HT_FORMULA
  1511. (type=formula)
  1512.  
  1513. This is a "roll-your-own" fractal interpreter - you don't even need a
  1514. compiler!
  1515.  
  1516. To run a "type=formula" fractal, you first need a text file containing
  1517. formulas (there's a sample file - FRACTINT.FRM - included with this
  1518. distribution).    When you select the "formula" fractal type, Fractint scans
  1519. the current formula file (default is FRACTINT.FRM) for formulas, then
  1520. prompts you for the formula name you wish to run.  After prompting for any
  1521. parameters, the formula is parsed for syntax errors and then the fractal
  1522. is generated. If you want to use a different formula file, press <F6> when
  1523. you are prompted to select a formula name.
  1524.  
  1525. There are two command-line options that work with type=formula
  1526. ("formulafile=" and "formulaname="), useful when you are using this
  1527. fractal type in batch mode.
  1528.  
  1529. The following documentation is supplied by Mark Peterson, who wrote the
  1530. formula interpreter:
  1531.  
  1532. Formula fractals allow you to create your own fractal formulas.  The
  1533. general format is:
  1534.  
  1535.    Mandelbrot(XAXIS) \{ z = Pixel:  z = sqr(z) + pixel, |z| <= 4 \}\
  1536.       |     |       |            |           |\
  1537.      Name     Symmetry      Initial      Iteration      Bailout\
  1538.               Condition              Criteria\
  1539.  
  1540. Initial conditions are set, then the iterations performed until the
  1541. bailout criteria is true or 'z' turns into a periodic loop.
  1542. All variables are created automatically by their usage and treated as
  1543. complex.  If you declare 'v = 2' then the variable 'v' is treated as a
  1544. complex with an imaginary value of zero.
  1545.  
  1546. ~Format-
  1547.       Predefined Variables (x, y)
  1548.       --------------------------------------------
  1549.       z         used for periodicity checking
  1550.       p1         parameters 1 and 2
  1551.       p2         parameters 3 and 4
  1552.       pixel      screen coordinates
  1553.  
  1554.       Precedence
  1555.       --------------------------------------------
  1556.       1         sin(), cos(), sinh(), cosh(), cosxx(),
  1557.              tan(), cotan(), tanh(), cotanh(),
  1558.              sqr, log(), exp(), abs(), conj(), real(),
  1559.              imag(), flip(), fn1(), fn2(), fn3(), fn4()
  1560.       2         - (negation), ^ (power)
  1561.       3         * (multiplication), / (division)
  1562.       4         + (addition), - (subtraction)
  1563.       5         = (assignment)
  1564.       6         < (less than), <= (less than or equal to)
  1565. ~Format+
  1566.  
  1567. Precedence may be overridden by use of parenthesis.  Note the modulus
  1568. squared operator |z| is also parenthetic and always sets the imaginary
  1569. component to zero.  This means 'c * |z - 4|' first subtracts 4 from z,
  1570. calculates the modulus squared then multiplies times 'c'.  Nested modulus
  1571. squared operators require overriding parenthesis:
  1572.  
  1573.       c * |z + (|pixel|)|
  1574.  
  1575. The functions fn1(...) to fn4(...) are variable functions - when used,
  1576. the user is prompted at run time (on the <Z> screen) to specify one of
  1577. sin, cos, sinh, cosh, exp, log, sqr, etc. for each required variable function.
  1578.  
  1579. The formulas are performed using either integer or floating point
  1580. mathematics depending on the <F> floating point toggle.  If you do not
  1581. have an FPU then type MPC math is performed in lieu of traditional
  1582. floating point.
  1583.  
  1584. Remember that when using integer math there is a limited dynamic range, so
  1585. what you think may be a fractal could really be just a limitation of the
  1586. integer math range.  God may work with integers, but His dynamic range is
  1587. many orders of magnitude greater than our puny 32 bit mathematics!  Always
  1588. verify with the floating point <F> toggle.
  1589. ;
  1590. ;
  1591. ~Topic=Julibrots, Label=HT_JULIBROT
  1592. (type=julibrot)
  1593.  
  1594. The following documentation is supplied by Mark Peterson, who "invented"
  1595. the Julibrot algorithm.
  1596.  
  1597. There is a very close relationship between the Mandelbrot set and Julia
  1598. sets of the same equation.  To draw a Julia set you take the basic
  1599. equation and vary the initial value according to the two dimensions of
  1600. screen leaving the constant untouched.    This method diagrams two
  1601. dimensions of the equation, 'x' and 'iy', which I refer to as the Julia x
  1602. and y.
  1603.  
  1604.      z(0) = screen coordinate (x + iy)\
  1605.      z(1) = (z(0) * z(0)) + c, where c = (a + ib)\
  1606.      z(2) = (z(1) * z(0)) + c\
  1607.      z(3) = . . . .\
  1608.  
  1609. The Mandelbrot set is a composite of all the Julia sets.  If you take the
  1610. center pixel of each Julia set and plot it on the screen coordinate
  1611. corresponding to the value of c, a + ib, then you have the Mandelbrot set.
  1612.  
  1613.      z(0) = 0\
  1614.      z(1) = (z(0) * z(0)) + c, where c = screen coordinate (a + ib)\
  1615.      z(2) = (z(1) * z(1)) + c\
  1616.      z(3) = . . . .\
  1617.  
  1618. I refer to the 'a' and 'ib' components of 'c' as the Mandelbrot 'x' and
  1619. 'y'.
  1620.  
  1621. All the 2 dimensional Julia sets correspond to a single point on the 2
  1622. dimensional Mandelbrot set, making a total of 4 dimensions associated with
  1623. our equation.  Visualizing 4 dimensional objects is not as difficult as it
  1624. may sound at first if you consider we live in a 4 dimensional world.  The
  1625. room around you is three dimensions and as you read this text you are
  1626. moving through the fourth dimension of time. You and everything around
  1627. your are 4 dimensional objects - which is to say 3 dimensional objects
  1628. moving through time.  We can think of the 4 dimensions of our equation in
  1629. the same manner, this is as a 3 dimensional object evolving over time -
  1630. sort of a 3 dimensional fractal movie.    The fun part of it is you get to
  1631. pick the dimension representing time!
  1632.  
  1633. To construct the 4 dimensional object into something you can view on the
  1634. computer screen you start with the simple 2 dimensions of the Julia set.
  1635. I'll treat the two Julia dimensions as the spatial dimensions of height
  1636. and width, and the Mandelbrot 'y' dimension as the third spatial dimension
  1637. of depth.  This leaves the Mandelbrot 'x' dimension as time.  Draw the
  1638. Julia set associated with the Mandelbrot coordinate (-.83, -.25), but
  1639. instead of setting the color according to the iteration level it bailed
  1640. out on, make it a two color drawing where the pixels are black for
  1641. iteration levels less than 30, and another color for iteration levels
  1642. greater than or equal to 30.  Now increment the Mandelbrot 'y' coordinate
  1643. by a little bit, say (-.83, -.2485), and draw another Julia set in the
  1644. same manner using a different color for bailout values of 30 or greater.
  1645. Continue doing this until you reach (-.83, .25).  You now have a three
  1646. dimensional representation of the equation at time -.83.  If you make the
  1647. same drawings for points in time before and after -.83 you can construct a
  1648. 3 dimensional movie of the equation which essentially is a full 4
  1649. dimensional representation.
  1650.  
  1651. In the Julibrot fractal available with this release of Fractint the
  1652. spatial dimensions of height and width are always the Julia dimensions.
  1653. The dimension of depth is determined by the Mandelbrot coordinates.  The
  1654. program will consider the dimension of depth as the line between the two
  1655. Mandelbrot points.  To draw the image in our previous example you would
  1656. set the 'From Mandelbrot' to (-.83, .25) and the 'To Mandelbrot' as (-.83,
  1657. -.25).    If you set the number of 'z' pixels to 128 then the program will
  1658. draw the 128 Julia sets found between Mandelbrot points (-.83, .25) and (-
  1659. .83, -.25).  To speed things up the program doesn't actually calculate ALL
  1660. the coordinates of the Julia sets.  It starts with the a pixel a the Julia
  1661. set closest to the observer and moves into the screen until it either
  1662. reaches the required bailout or the limit to the range of depth.  Zooming
  1663. can be done in the same manner as with other fractals.    The visual effect
  1664. (with other values unchanged) is similar to putting the boxed section
  1665. under a pair of magnifying glasses.
  1666.  
  1667. The variable associated with penetration level is the level of bailout
  1668. there you decide to make the fractal solid.  In other words all bailout
  1669. levels less than the penetration level are considered to be transparent,
  1670. and those equal or greater to be opaque.  The farther away the apparent
  1671. pixel is the dimmer the color.
  1672.  
  1673. The remainder of the parameters are needed to construct the red/blue
  1674. picture so that the fractal appears with the desired depth and proper 'z'
  1675. location.  With the origin set to 8 inches beyond the screen plane and the
  1676. depth of the fractal at 8 inches the default fractal will appear to start
  1677. at 4 inches beyond the screen and extend to 12 inches if your eyeballs are
  1678. 2.5 inches apart and located at a distance of 24 inches from the screen.
  1679. The screen dimensions provide the reference frame.
  1680.  
  1681. To the human eye blue appears brighter than red.  The Blue:Red ratio is
  1682. used to compensate for this fact.  If the image appears reddish through
  1683. the glasses raise this value until the image appears to be in shades of
  1684. gray.  If it appears bluish lower the ratio.  Julibrots can only be shown
  1685. in 256 red/blue colors for viewing in either stereo-graphic (red/blue
  1686. funny glasses) or gray-scaled.    Fractint automatically loads either
  1687. GLASSES1.MAP or ALTERN.MAP as appropriate.
  1688. ;
  1689. ;
  1690. ~Topic=Diffusion Limited Aggregation, Label=HT_DIFFUS
  1691. (type=diffusion)
  1692.  
  1693. This type begins with a single point in the center of the screen.
  1694. Subsequent points move around randomly until coming into contact with the
  1695. first point, at which time their locations are fixed and they are colored
  1696. randomly.  This process repeats until the fractals reaches the edge of the
  1697. screen.  Use the show orbits function to see the points' random motion.
  1698.  
  1699. One unfortunate problem is that on a large screen, this process will tend
  1700. to take eons.  To speed things up, the points are restricted to a box
  1701. around the initial point.  The first and only parameter to diffusion
  1702. contains the size of the border between the fractal and the edge of the
  1703. box.  If you make this number small, the fractal will look more solid and
  1704. will be generated more quickly.
  1705.  
  1706. Diffusion was inspired by a Scientific American article a couple of years
  1707. back which includes actual pictures of real physical phenomena that behave
  1708. like this.
  1709.  
  1710. Thanks to Adrian Mariano for providing the diffusion code and
  1711. documentation.
  1712. ;
  1713. ;
  1714. ~Topic=Magnetic Fractals, Label=HT_MAGNET
  1715. (type=magnet1m/.../magnet2j)
  1716.  
  1717. These fractals use formulae derived from the study of hierarchical
  1718. lattices, in the context of magnetic renormalisation transformations.
  1719. This kinda stuff is useful in an area of theoretical physics that deals
  1720. with magnetic phase-transitions (predicting at which temperatures a given
  1721. substance will be magnetic, or non-magnetic).  In an attempt to clarify
  1722. the results obtained for Real temperatures (the kind that you and I can
  1723. feel), the study moved into the realm of Complex Numbers, aiming to spot
  1724. Real phase-transitions by finding the intersections of lines representing
  1725. Complex phase-transitions with the Real Axis.  The first people to try
  1726. this were two physicists called Yang and Lee, who found the situation a
  1727. bit more complex than first expected, as the phase boundaries for Complex
  1728. temperatures are (surprise!) fractals.
  1729.  
  1730. And that's all the technical (?) background you're getting here!  For more
  1731. details (are you SERIOUS ?!) read "The Beauty of Fractals".  When you
  1732. understand it all, you might like to re-write this section, before you
  1733. start your new job as a professor of theoretical physics...
  1734.  
  1735. In Fractint terms, the important bits of the above are "Fractals",
  1736. "Complex Numbers", "Formulae", and "The Beauty of Fractals".  Lifting the
  1737. Formulae straight out of the Book and iterating them over the Complex
  1738. plane (just like the Mandelbrot set) produces Fractals.
  1739.  
  1740. The formulae are a bit more complicated than the Z^2+C used for the
  1741. Mandelbrot Set, that's all.  They are :
  1742.  
  1743. ~Format-
  1744. ; Use this for the document...
  1745. ~Online-
  1746.            /  Z^2 + (C-1)  \\
  1747.     MAGNET1 : |  -------------  | ^ 2
  1748.            \\  2*Z + (C-2)  /
  1749.  
  1750.            /      Z^3 + 3*(C-1)*Z + (C-1)*(C-2)      \\
  1751.     MAGNET2 : |  ---------------------------------------  | ^ 2
  1752.            \\  3*(Z^2) + 3*(C-2)*Z + (C-1)*(C-2) - 1  /
  1753. ~Online+,Doc-
  1754. ; And this for online...
  1755.           ┌          ┐
  1756.           │  Z^2 + (C-1)  │
  1757.     MAGNET1 : │ ───────────── │ ^ 2
  1758.           │  2∙Z + (C-2)  │
  1759.           └          ┘
  1760.           ┌                        ┐
  1761.           │     Z^3 + 3∙(C-1)∙Z + (C-1)∙(C-2)        │
  1762.     MAGNET2 : │ ─────────────────────────────────────── │ ^ 2
  1763.           │  3∙(Z^2) + 3∙(C-2)∙Z + (C-1)∙(C-2) - 1  │
  1764.           └                        ┘
  1765. ~Doc+
  1766. ~Format+
  1767.  
  1768. These aren't quite as horrific as they look (oh yeah ?!) as they only
  1769. involve two variables (Z and C), but cubing things, doing division, and
  1770. eventually squaring the result (all in Complex Numbers) don't exactly
  1771. spell S-p-e-e-d !  These are NOT the fastest fractals in Fractint !
  1772.  
  1773. As you might expect, for both formulae there is a single related
  1774. Mandelbrot-type set (magnet1m, magnet2m) and an infinite number of related
  1775. Julia-type sets (magnet1j, magnet2j), with the usual toggle between the
  1776. corresponding Ms and Js via the spacebar.
  1777.  
  1778. If you fancy delving into the Julia-types by hand, you will be prompted
  1779. for the Real and Imaginary parts of the parameter denoted by C.  The
  1780. result is symmetrical about the Real axis (and therefore the initial image
  1781. gets drawn in half the usual time) if you specify a value of Zero for the
  1782. Imaginary part of C.
  1783.  
  1784. Fractint Historical Note:  Another complication (besides the formulae) in
  1785. implementing these fractal types was that they all have a finite attractor
  1786. (1.0 + 0.0i), as well as the usual one (Infinity).  This fact spurred the
  1787. development of Finite Attractor logic in Fractint.  Without this code you
  1788. can still generate these fractals, but you usually end up with a pretty
  1789. boring image that is mostly deep blue "lake", courtesy of Fractint's
  1790. standard {Periodicity Logic}.
  1791. See {Finite Attractors} for more
  1792. information on this aspect of Fractint internals.
  1793.  
  1794. (Thanks to Kevin Allen for Magnetic type documentation above).
  1795. ;
  1796. ;
  1797. ~Topic=L-Systems, Label=HT_LSYS
  1798. (type=lsystem)
  1799.  
  1800. These fractals are constructed from line segments using rules specified in
  1801. drawing commands.  Starting with an initial string, the axiom,
  1802. transformation rules are applied a specified number of times, to produce
  1803. the final command string which is used to draw the image.
  1804.  
  1805. Like the type=formula fractals, this type requires a separate data file.
  1806. A sample file, FRACTINT.L, is included with this distribution.    When you
  1807. select type lsystem, the current lsystem file is read and you are asked
  1808. for the lsystem name you wish to run. Press <F6> at this point if you wish
  1809. to use a different lsystem file. After selecting an lsystem, you are asked
  1810. for one parameter - the "order", or number of times to execute all the
  1811. transformation rules.  It is wise to start with small orders, because the
  1812. size of the substituted command string grows exponentially and it is very
  1813. easy to exceed your resolution.  (Higher orders take longer to generate
  1814. too.)  The command line options "lname=" and "lfile=" can be used to over-
  1815. ride the default file name and lsystem name.
  1816.  
  1817. Each L-System entry in the file contains a specification of the angle, the
  1818. axiom, and the transformation rules.  Each item must appear on its own
  1819. line and each line must be less than 160 characters long.
  1820.  
  1821. The statement "angle n" sets the angle to 360/n degrees; n must be an
  1822. integer greater than two and less than fifty.
  1823.  
  1824. "Axiom string" defines the axiom.
  1825.  
  1826. Transformation rules are specified as "a=string" and convert the single
  1827. character 'a' into "string."  If more than one rule is specified for a
  1828. single character all of the strings will be added together.  This allows
  1829. specifying transformations longer than the 160 character limit.
  1830. Transformation rules may operate on any characters except space, tab or
  1831. '}'.
  1832.  
  1833. Any information after a ; (semi-colon) on a line is treated as a comment.
  1834.  
  1835. Here is a sample lsystem:
  1836.  
  1837. ~Format-
  1838. Dragon \{      ; Name of lsystem, \{ indicates start
  1839.   Angle 8     ; Specify the angle increment to 45 degrees
  1840.   Axiom FX     ; Starting character string
  1841.   F=         ; First rule:    Delete 'F'
  1842.   y=+FX--FY+     ; Change 'y' into  "+fx--fy+"
  1843.   x=-FX++FY-     ; Similar transformation on 'x'
  1844. }         ; final } indicates end
  1845.  
  1846. The standard drawing commands are:
  1847.     F Draw forward
  1848.     G Move forward (without drawing)
  1849.     + Increase angle
  1850.     - Decrease angle
  1851.     | Try to turn 180 degrees. (If angle is odd, the turn
  1852.       will be the largest possible turn less than 180 degrees.)
  1853. ~Format+
  1854.  
  1855. These commands increment angle by the user specified angle value. They
  1856. should be used when possible because they are fast. If greater flexibility
  1857. is needed, use the following commands which keep a completely separate
  1858. angle pointer which is specified in degrees.
  1859.  
  1860. ~Format-
  1861.     D    Draw forward
  1862.     M    Move forward
  1863.     \nn Increase angle nn degrees
  1864.     /nn Decrease angle nn degrees
  1865.  
  1866. Color control:
  1867.     Cnn Select color nn
  1868.     <nn Increment color by nn
  1869.     >nn decrement color by nn
  1870.  
  1871. Advanced commands:
  1872.     !      Reverse directions (Switch meanings of +, - and \, /)
  1873.     @nnn  Multiply line segment size by nnn
  1874.       nnn may be a plain number, or may be preceded by
  1875.           I for inverse, or Q for square root.
  1876.           (e.g.  @IQ2 divides size by the square root of 2)
  1877.     [      Push.  Stores current angle and position on a stack
  1878.     ]      Pop.    Return to location of last push
  1879. ~Format+
  1880.  
  1881. Other characters are perfectly legal in command strings.  They are ignored
  1882. for drawing purposes, but can be used to achieve complex translations.
  1883. ;
  1884. ;
  1885. ;
  1886.