Der Text wurde aus fractint 18.2 für DOS 6 übernommen.
____________________________________________________

Fractal Formula Selection 

Using the Options Formula option, you can select any of over 80 fractal types 
(virtually every fractal type that is available in version 18.2 of Fractint-for-DOS). 

After selecting a fractal type, a dialogue box pops up and prompts you for any formula 
parameters and the screen corners (all with reasonable default values).  

A partial list of Fractal types and their formulas included in this release 
("partial" only because I haven't yet gotten off my duff and updated this list to 
include the new fractal types added in version 18.x - sorry about that):

barnsleyj1
      z(0) = pixel;
      z(n+1) = (z-1)*c if real(z) >= 0, else
      z(n+1) = (z+1)*modulus(c)/c
    Two parameters: real and imaginary parts of c

barnsleyj2
      z(0) = pixel;
      if real(z(n)) * imag(c) + real(c) * imag(z((n)) >= 0
	 z(n+1) = (z(n)-1)*c
      else
	 z(n+1) = (z(n)+1)*c
    Two parameters: real and imaginary parts of c

barnsleyj3
      z(0) = pixel;
      if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
	 + i * (2*real(z((n)) * imag(z((n))) else
      z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
	     + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))
    Two parameters: real and imaginary parts of c.

barnsleym1
      z(0) = c = pixel;
      if real(z) >= 0 then
	z(n+1) = (z-1)*c
      else
	z(n+1) = (z+1)*modulus(c)/c.
    Parameters are perturbations of z(0)


barnsleym2
      z(0) = c = pixel;
      if real(z)*imag(c) + real(c)*imag(z) >= 0
	z(n+1) = (z-1)*c
      else
	z(n+1) = (z+1)*c
    Parameters are perturbations of z(0)

barnsleym3
      z(0) = c = pixel;
      if real(z(n) > 0 then z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1)
	 + i * (2*real(z((n)) * imag(z((n))) else
      z(n+1) = (real(z(n))^2 - imag(z(n))^2 - 1 + real(c) * real(z(n))
	 + i * (2*real(z((n)) * imag(z((n)) + imag(c) * real(z(n))
    Parameters are pertubations of z(0)

bifurcation
    Pictoral representation of a population growth model.
      Let P = new population, p = oldpopulation, r = growth rate
      The model is: P = p +  r*p*(1-p).
    Two parameters: Filter Cycles and Seed Population.

bif+sinpi
    Bifurcation variation: model is: P = p + r*sin(PI*p).
    Two parameters: Filter Cycles and Seed Population.

bif=sinpi
    Bifurcation variation: model is: P = r*sin(PI*p).

    Two parameters: Filter Cycles and Seed Population.

biflambda
    Bifurcation variation: model is: P = r*p*(1-p)P.
    Two parameters: Filter Cycles and Seed Population.

bifstewart
    Bifurcation variation: model is: P = (r*p*p) - 1.
    Two parameters: Filter Cycles and Seed Population.

Circle
    Circle pattern by John Connett
      x + iy = pixel
      z = a*(x^2 + y^2)
      c = integer part of z
      color = c modulo(number of colors)

cmplxmarksjul
    A generalization of the marksjulia fractal.
      z(0) = pixel;
      z(n+1) = (c^exp)*z(n) + c.
    Four parameters: real and imaginary parts of c and exp.

cmplxmarksmand
    A generalization of the marksmandel fractal.
      z(0) = c = pixel;
      z(n+1) = (c^exp)*z(n) + c.
    Four parameters: real and imaginary parts of
    perturbation of z(0) and exp.


complexnewton, complexbasin
    Newton fractal types extended to complex degrees. Complexnewton
    colors pixels according to the number of iterations required to
    escape to a root. Complexbasin colors pixels according to which
    root captures the orbit. The equation is based on the newton
    formula for solving the equation z^p = r
      z(0) = pixel;
      z(n+1) = ((p - 1) * z(n)^p + r)/(p * z(n)^(p - 1)).
    Four parameters: real & imaginary parts of degree p and root r

diffusion
    Diffusion Limited Aggregation.  Randomly moving points
    accumulate.  One parameter: border width (default 10)

fn+fn(pix)
      c = z(0) = pixel;
      z(n+1) = fn1(z) + p*fn2(c)

    Six parameters: real and imaginary parts of the perturbation
    of z(0) and factor p, and the functions fn1, and fn2.

fn(z*z)
      z(0) = pixel;
      z(n+1) = fn(z(n)*z(n))
    One parameter: the function fn.

fn*fn
      z(0) = pixel; z(n+1) = fn1(n)*fn2(n)
    Two parameters: the functions fn1 and fn2.

fn*z+z
      z(0) = pixel; z(n+1) = p1*fn(z(n))*z(n) + p2*z(n)
    Six parameters: the real and imaginary components of
    p1 and p2, and the functions fn1 and fn2.

fn+fn
      z(0) = pixel;
      z(n+1) = p1*fn1(z(n))+p2*fn2(z(n))
    Six parameters: The real and imaginary components of
    p1 and p2, and the functions fn1 and fn2.

formula
    Formula interpreter - write your own formulas as text files!

gingerbread
    Orbit in two dimensions defined by:

      x(n+1) = 1 - y(n) + |x(n)|
      y(n+1) = x(n)
    Two parameters: initial values of x(0) and y(0).

henon
    Orbit in two dimensions defined by:
      x(n+1) = 1 + y(n) - a*x(n)*x(n)
      y(n+1) = b*x(n)
    Two parameters: a and b

Hopalong
    Hopalong attractor by Barry Martin - orbit in two dimensions.
      z(0) = y(0) = 0;
      x(n+1) = y(n) - sign(x(n))*sqrt(abs(b*x(n)-c))
      y(n+1) = a - x(n)
    Parameters are a, b, and c.

IFS
    Barnsley IFS fractals.

julfn+exp
    A generalized Clifford Pickover fractal.
      z(0) = pixel;
      z(n+1) = fn(z(n)) + e^z(n) + c.
    Three parameters: real & imaginary parts of c, and fn

julfn+zsqrd
      z(0) = pixel;
      z(n+1) = fn(z(n)) + z(n)^2 + c

    Three parameters: real & imaginary parts of c, and fn

julia
    Classic Julia set fractal.
      z(0) = pixel; z(n+1) = z(n)^2 + c.
    Two parameters: real and imaginary parts of c.

julia4
    Fourth-power Julia set fractals, a special case
    of julzpower kept for speed.
      z(0) = pixel;
      z(n+1) = z(n)^4 + c.
    Two parameters: real and imaginary parts of c.

julibrot
    'Julibrot' 4-dimensional fractals.

julzpower
      z(0) = pixel;
      z(n+1) = z(n)^m + c.
    Three parameters: real & imaginary parts of c, exponent m

julzzpwr
      z(0) = pixel;
      z(n+1) = z(n)^z(n) + z(n)^m + c.
    Three parameters: real & imaginary parts of c, exponent m

kamtorus, kamtorus3d
    Series of orbits superimposed.
    3d version has 'orbit' the z dimension.
      x(0) = y(0) = orbit/3;
      x(n+1) = x(n)*cos(a) + (x(n)*x(n)-y(n))*sin(a)

      y(n+1) = x(n)*sin(a) - (x(n)*x(n)-y(n))*cos(a)
    After each orbit, 'orbit' is incremented by a step size.
    Parameters: a, step size, stop value for 'orbit', and
    points per orbit.

lambda
    Classic Lambda fractal. 'Julia' variant of Mandellambda.
      z(0) = pixel;
      z(n+1) = lambda*z(n)*(1 - z(n)^2).
    Two parameters: real and imaginary parts of lambda.

lambdafn
      z(0) = pixel;
      z(n+1) = lambda * fn(z(n)).
    Three parameters: real, imag portions of lambda, and fn

lorenz, lorenz3d
    Lorenz two lobe attractor - orbit in three dimensions.
    In 2d the x and y components are projected to form the image.
      z(0) = y(0) = z(0) = 1;
      x(n+1) = x(n) + (-a*x(n)*dt) + (	 a*y(n)*dt)
      y(n+1) = y(n) + ( b*x(n)*dt) - (	   y(n)*dt) - (z(n)*x(n)*dt)

      z(n+1) = z(n) + (-c*z(n)*dt) + (x(n)*y(n)*dt)
    Parameters are dt, a, b, and c.

lorenz3d1
    Lorenz one lobe attractor - orbit in three dimensions.
    The original formulas were developed by Rick Miranda and Emily Stone.
      z(0) = y(0) = z(0) = 1; norm = sqrt(x(n)^2 + y(n)^2)
      x(n+1) = x(n) + (-a*dt-dt)*x(n) + (a*dt-b*dt)*y(n) 
         + (dt-a*dt)*norm + y(n)*dt*z(n)
      y(n+1) = y(n) + (b*dt-a*dt)*x(n) - (a*dt+dt)*y(n) 
         + (b*dt+a*dt)*norm - x(n)*dt*z(n) - norm*z(n)*dt
      z(n+1) = z(n) +(y(n)*dt/2) - c*dt*z(n)
    Parameters are dt, a, b, and c.

lorenz3d3
    Lorenz three lobe attractor - orbit in three dimensions.
    The original formulas were developed by Rick Miranda and Emily Stone.
      z(0) = y(0) = z(0) = 1; norm = sqrt(x(n)^2 + y(n)^2)
      x(n+1) = x(n) +(-(a*dt+dt)*x(n) + (a*dt-b*dt+z(n)*dt)*y(n))/3 
          + ((dt-a*dt)*(x(n)^2-y(n)^2) 

          + 2*(b*dt+a*dt-z(n)*dt)*x(n)*y(n))/(3*norm)
      y(n+1) = y(n) +((b*dt-a*dt-z(n)*dt)*x(n) - (a*dt+dt)*y(n))/3 
          + (2*(a*dt-dt)*x(n)*y(n) 
          + (b*dt+a*dt-z(n)*dt)*(x(n)^2-y(n)^2))/(3*norm)
      z(n+1) = z(n) +(3*x(n)*dt*x(n)*y(n)-y(n)*dt*y(n)^2)/2 - c*dt*z(n)
    Parameters are dt, a, b, and c.

lorenz3d4
    Lorenz four lobe attractor - orbit in three dimensions.
    The original formulas were developed by Rick Miranda and Emily Stone.
      z(0) = y(0) = z(0) = 1; 
      x(n+1) = x(n) +(-a*dt*x(n)^3 
         + (2*a*dt+b*dt-z(n)*dt)*x(n)^2*y(n) + (a*dt-2*dt)*x(n)*y(n)^2 
         + (z(n)*dt-b*dt)*y(n)^3) / (2 * (x(n)^2+y(n)^2))
      y(n+1) = y(n) +((b*dt-z(n)*dt)*x(n)^3 + (a*dt-2*dt)*x(n)^2*y(n) 

         + (-2*a*dt-b*dt+z(n)*dt)*x(n)*y(n)^2 
         - a*dt*y(n)^3) / (2 * (x(n)^2+y(n)^2))
      z(n+1) = z(n) +(2*x(n)*dt*x(n)^2*y(n) - 2*x(n)*dt*y(n)^3 - c*dt*z(n))
    Parameters are dt, a, b, and c.

lsystem
    Using a turtle-graphics control language and starting with
    an initial axiom string, carries out string substitutions the
    specified number of times (the order), and plots the resulting.

lyapunov
    Derived from the Bifurcation fractal, the Lyapunov plots the Lyapunov
    Exponent for a population model where the Growth parameter varies between
    two values in a periodic manner.

magnet1j
      z(0) = pixel;

	       / z(n)^2 + (c-1) \
      z(n+1) = | --------------------- | ^ 2
	       \ 2*z(n) + (c-2)  /
    Parameters: the real and imaginary parts of c

magnet1m
      z(0) = 0; c = pixel;
	       / z(n)^2 + (c-1)  \
      z(n+1) = | --------------------- | ^ 2
	      \ 2*z(n) + (c-2)   /
    Parameters: the real & imaginary parts of perturbation of z(0)

magnet2j
      z(0) = pixel;
	       / z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)              \
      z(n+1) = |  ---------------------------------------------------------- | ^ 2
	       \ 3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) - 1 /
    Parameters: the real and imaginary parts of c

magnet2m
      z(0) = 0; c = pixel;
	      / z(n)^3 + 3*(C-1)*z(n) + (C-1)*(C-2)              \
      z(n+1) = |  --------------------------------------------------------- | ^ 2
	      \ 3*(z(n)^2) + 3*(C-2)*z(n) + (C-1)*(C-2) - 1 /
    Parameters: the real and imaginary parts of perturbation of z(0)

mandel
    Classic Mandelbrot set fractal.
      z(0) = c = pixel;

      z(n+1) = z(n)^2 + c.
    Two parameters: real & imaginary perturbations of z(0)

mandel4
    Special case of mandelzpower kept for speed.
      z(0) = c = pixel;
      z(n+1) = z(n)^4 + c.
    Parameters: real & imaginary perturbations of z(0)

mandelfn
      z(0) = c = pixel;
      z(n+1) = c*fn(z(n)).
    Parameters: real & imaginary perturbations of z(0), and fn

Martin
    Attractor fractal by Barry Martin - orbit in two dimensions.
      z(0) = y(0) = 0;
      x(n+1) = y(n) - sin(x(n))
      y(n+1) = a - x(n)
    Parameter is a (try a value near pi)

mandellambda
      z(0) = .5; lambda = pixel;
      z(n+1) = lambda*z(n)*(1 - z(n)^2).
    Parameters: real & imaginary perturbations of z(0)

manfn+exp
    'Mandelbrot-Equivalent' for the julfn+exp fractal.

      z(0) = c = pixel;
      z(n+1) = fn(z(n)) + e^z(n) + C.
    Parameters: real & imaginary perturbations of z(0), and fn

manfn+zsqrd
    'Mandelbrot-Equivalent' for the Julfn+zsqrd fractal.
      z(0) = c = pixel;
      z(n+1) = fn(z(n)) + z(n)^2 + c.
    Parameters: real & imaginary perturbations of z(0), and fn

manowar
      c = z1(0) = z(0) = pixel;
      z(n+1) = z(n)^2 + z1(n) + c;
      z1(n+1) = z(n);
    Parameters: real & imaginary perturbations of z(0)

manowarj
      z1(0) = z(0) = pixel;
      z(n+1) = z(n)^2 + z1(n) + c;
      z1(n+1) = z(n);
    Parameters: real & imaginary perturbations of z(0)

manzpower
    'Mandelbrot-Equivalent' for julzpower.
      z(0) = c = pixel;
      z(n+1) = z(n)^exp + c; try exp = e = 2.71828...
    Parameters: real & imaginary perturbations of z(0), real &
    imaginary parts of exponent exp.

manzzpwr

    'Mandelbrot-Equivalent' for the julzzpwr fractal.
      z(0) = c = pixel
      z(n+1) = z(n)^z(n) + z(n)^exp + C.
    Parameters: real & imaginary perturbations of z(0), and exponent

marksjulia
    A variant of the julia-lambda fractal.
      z(0) = pixel;
      z(n+1) = (c^exp)*z(n) + c.
    Parameters: real & imaginary parts of c, and exponent

marksmandel
    A variant of the mandel-lambda fractal.
      z(0) = c = pixel;
      z(n+1) = (c^exp)*z(n) + c.
    Parameters: real & imaginary perturbations of z(0), and exponent

marksmandelpwr
    The marksmandelpwr formula type generalized (it previously
    had fn=sqr hard coded).
      z(0) = pixel, c = z(0) ^ (z(0) - 1):
      z(n+1) = c * fn(z(n)) + pixel,
    Parameters: real and imaginary pertubations of z(0), and fn

newtbasin
    Based on the Newton formula for finding the roots of z^p - 1.
    Pixels are colored according to which root captures the orbit.

      z(0) = pixel;
      z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).
    Two parameters: the polynomial degree p, and a flag to turn
    on color stripes to show alternate iterations.

newton
    Based on the Newton formula for finding the roots of z^p - 1.
    Pixels are colored according to the iteration when the orbit
    is captured by a root.
      z(0) = pixel;
      z(n+1) = ((p-1)*z(n)^p + 1)/(p*z(n)^(p - 1)).
    One parameter: the polynomial degree p.

pickover
    Orbit in three dimensions defined by:
      x(n+1) = sin(a*y(n)) - z(n)*cos(b*x(n))
      y(n+1) = z(n)*sin(c*x(n)) - cos(d*y(n))
      z(n+1) = sin(x(n))
    Parameters: a, b, c, and d.

plasma
    Random, cloud-like formations.  Requires 4 or more colors.
    A recursive algorithm repeatedly subdivides the screen and

    colors pixels according to an average of surrounding pixels
    and a random color, less random as the grid size decreases.
    Three parameters: 'graininess' (.5 to 50, default = 2), old/new
    algorithm, seed value used.

popcorn
    The orbits in two dimensions defined by:
      x(0) = xpixel, y(0) = ypixel;
      x(n+1) = x(n) - h*sin(y(n) + tan(3*y(n))
      y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n))
    are plotted for each screen pixel and superimposed.
    One parameter: step size h.

popcornjul
    Conventional Julia using the popcorn formula:
      x(0) = xpixel, y(0) = ypixel;
      x(n+1) = x(n) - h*sin(y(n) + tan(3*y(n))
      y(n+1) = y(n) - h*sin(x(n) + tan(3*x(n))
    One parameter: step size h.

rossler3D
    Orbit in three dimensions defined by:
      x(0) = y(0) = z(0) = 1;
      x(n+1) = x(n) - y(n)*dt -   z(n)*dt
      y(n+1) = y(n) + x(n)*dt + a*y(n)*dt

      z(n+1) = z(n) + b*dt + x(n)*z(n)*dt - c*z(n)*dt
    Parameters are dt, a, b, and c.

sierpinski
    Sierpinski gasket - Julia set producing a 'Swiss cheese triangle'
      z(n+1) = (2*x,2*y-1) if y > .5;
	  else (2*x-1,2*y) if x > .5;
	  else (2*x,2*y)
    No parameters.

spider
      c(0) = z(0) = pixel;
      z(n+1) = z(n)^2 + c(n);
      c(n+1) = c(n)/2 + z(n+1)
    Parameters: real & imaginary perturbation of z(0)

sqr(1/fn)
      z(0) = pixel;
      z(n+1) = (1/fn(z(n))^2
    One parameter: the function fn.

sqr(fn)
      z(0) = pixel;
      z(n+1) = fn(z(n))^2
    One parameter: the function fn.


test
    'test' point letting us (and you!) easily add fractal types via
    the c module testpt.c.  Default set up is a mandelbrot fractal.
    Four parameters: user hooks (not used by default testpt.c).

tetrate
      z(0) = c = pixel;
      z(n+1) = c^z(n)
    Parameters: real & imaginary perturbation of z(0)

tim's_error
    A serendipitous coding error in marksmandelpwr brings to life
    an ancient pterodactyl!  (Try setting fn to sqr.)
      z(0) = pixel, c = z(0) ^ (z(0) - 1):
      tmp = fn(z(n))
      real(tmp) = real(tmp) * real(c) - imag(tmp) * imag(c);
      imag(tmp) = real(tmp) * imag(c) - imag(tmp) * real(c);
      z(n+1) = tmp + pixel;
    Parameters: real & imaginary pertubations of z(0) and function fn


unity
      z(0) = pixel;
      x = real(z(n)), y = imag(z(n))
      One = x^2 + y^2;
      y = (2 - One) * x;
      x = (2 - One) * y;
      z(n+1) = x + i*y

    No parameters.