Formula

(type=formula)

This is a "roll-your-own" fractal interpreter - you don't even need a compiler!

To run a "type=formula" fractal, you first need a text file containing formulas (there's a sample file - FRACTINT.FRM - included with this distribution). When you select the "formula" fractal type, Fractint scans the current formula file (default is FRACTINT.FRM) for formulas, then prompts you for the formula name you wish to run. After prompting for any parameters, the formula is parsed for syntax errors and then the fractal is generated. If you want to use a different formula file, press [F6] when you are prompted to select a formula name.

There are two command-line options that work with type=formula ("formulafile=" and "formulaname="), useful when you are using this fractal type in batch mode.

The following documentation is supplied by Mark Peterson, who wrote the formula interpreter:

Formula fractals allow you to create your own fractal formulas. The general format is:

     Mandelbrot(XAXIS) { z = Pixel:  z = sqr(z) + pixel, |z| <= 4 }
        |         |          |                |              |
       Name     Symmetry    Initial         Iteration       Bailout
                            Condition                       Criteria

Initial conditions are set, then the iterations performed while the bailout criteria remains true or until 'z' turns into a periodic loop. All variables are created automatically by their usage and treated as complex. If you declare 'v = 2' then the variable 'v' is treated as a complex with an imaginary value of zero.

Sequential processing of the formula can be altered with the flow control instructions

      IF(expr1)
        statements
      ELSEIF(expr2)
         statements
      .
      .
      ELSEIF(exprn)
         statements
      ELSE
        statements
      ENDIF

where the expressions are evaluated and the statements executed are those immediately following the first "true" expression (the real part of the complex variable being nonzero). Nesting of IF..ENDIF blocks is permitted.


	Predefined Variables (x, y)
	--------------------------------------------
	z          used for periodicity checking
	p1         parameters 1 and 2
	p2         parameters 3 and 4
	p3         parameters 5 and 6
	pixel      complex coordinates
	LastSqr    Modulus from the last sqr() function
	rand       Complex random number
	pi         (3.14159..., 0.0)
	e          (2.71828..., 0.0)
	maxit      (maxit, 0) maximum iterations
	scrnmax    (xdots, ydots) max horizontal/vertical resolution.
                   e.g. for SF7 scrnmax = (1024,768)
	scrnpix    (col, row) pixel screen coordinates. (col, row) ranges
                   from (0,0) to (xdots-1, ydots-1)
	whitesq    ((col+row) modulo 2, 0) i.e. thinking of the screen
                   coordinates as a large checker board, whitesq is (1,0)
                   for the white squares and (0,0) for the black ones.
	ismand	  1 (true) by default, changes to 0 when the Mandelbrot/
				  Julia SPACE toggle is pressed. This allows writing
				  formulas that have both "Mandelbrot" and "Julia" behavior.
	Precedence
	--------------------------------------------
	1	sin(), cos(), sinh(), cosh(), cosxx(), tan(), cotan(),
		tanh(), cotanh(), sqr(), log(), exp(), abs(), conj(),
		real(), imag(), flip(), fn1(), fn2(), fn3(), fn4(),
		srand(), asin(), asinh(), acos(), acosh(), atan(),
		atanh(), sqrt(), cabs(), floor(), ceil(), trunc(), round()
	2	- (negation), ^ (power)
	3	* (multiplication), / (division)
	4	+ (addition), - (subtraction)
	5	= (assignment)
	6	< (less than), <= (less than or equal to)
		> (greater than), >= (greater than or equal to)
		== (equal to), != (not equal to)
	7	&& (logical AND), || (logical OR)

Precedence may be overridden by use of parenthesis. Note the modulus squared operator |z| is also parenthetic and always sets the imaginary component to zero. This means 'c * |z - 4|' first subtracts 4 from z, calculates the modulus squared then multiplies times 'c'. Nested modulus squared operators require overriding parenthesis:

c * |z + (|pixel|)|

The functions fn1(...) to fn4(...) are variable functions - when used, the user is prompted at run time (on the [Z] screen) to specify one of sin, cos, sinh, cosh, exp, log, sqr, etc. for each required variable function.

Most of the functions have their conventional meaning, here are a few notes on others that are not conventional.

   abs()    - returns abs(x)+i*abs(y)
   |x+iy|   - returns x*x+y*y
   cabs()   - returns sqrt(x*x+y*y)
   conj()   - returns the complex conjugate of the argument. That is, changes
              sign of the imaginary component of argument: (x,y) becomes (x,-y)
   cosxx()  - duplicates a bug in the version 16 cos() function
   flip()   - Swap the real and imaginary components of the complex number.
              e.g. (4,5) would become (5,4)
   ident()  - identity function. Leaves the value of the argument unchanged,
              acting like a "z" term in a formula.
	zero()	- returns 0.
	one()	- returns 1.			  
   floor()  - largest integer not greater than the argument
              floor(x+iy) = floor(x) + i*floor(y)
   ceil()   - smallest integer not less than the argument
   trunc()  - truncate fraction part toward zero
   round()  - round to nearest integer or up. e.g. round(2.5,3.4) = (3,3)

The formulas are performed using either integer or floating point mathematics depending on the [F] floating point toggle. If you do not have an FPU then type MPC math is performed in lieu of traditional floating point.

The 'rand' predefined variable is changed with each iteration to a new random number with the real and imaginary components containing a value between zero and 1. Use the srand() function to initialize the random numbers to a consistent random number sequence. If a formula does not contain the srand() function, then the formula compiler will use the system time to initialize the sequence. This could cause a different fractal to be generated each time the formula is used depending on how the formula is written.

A formula containing one of the predefined variables "maxit", "scrnpix" or "scrnmax" will be automatically run in floating point mode.

The rounding functions must be used cautiously; formulas that depend on exact values of numbers will not work reliably in all cases. For example, in floating point mode, trunc(6/3) returns 1 while trunc(6/real(3)) returns 2.
Note that if x is an integer, floor(x) = ceil(x) = trunc(x) = round(x) = x.

Remember that when using integer math there is a limited dynamic range, so what you think may be a fractal could really be just a limitation of the integer math range. God may work with integers, but God's dynamic range is many orders of magnitude greater than our puny 32 bit mathematics! Always verify with the floating point [F] toggle.

  The possible values for symmetry are:

  XAXIS,  XAXIS_NOPARM
  YAXIS,  YAXIS_NOPARM
  XYAXIS, XYAXIS_NOPARM
  ORIGIN, ORIGIN_NOPARM
  PI_SYM, PI_SYM_NOPARM
  XAXIS_NOREAL
  XAXIS_NOIMAG

These will force the symmetry even if no symmetry is actually present, so try your formulas without symmetry before you use these.

For mathematical formulas of functions used in the parser language, see Trig Identities


Back to The Fractint Home Page. or back to The Fractint Index Page.

This page maintained by

Noel Giffin,
noel@triumf.ca