A julia fractal object is a 3D slice of a 4D object created by generalizing the process used to
create the classic Julia sets. You can make a wide variety of strange objects using the julia_fractal
statement including some that look like bizarre blobs of twisted taffy. The julia_fractal syntax is:
JULIA_FRACTAL:
julia_fractal
{
<4D_Julia_Parameter>
[JF_ITEM...] [OBJECT_MODIFIER...]
}
JF_ITEM:
ALGEBRA_TYPE  FUNCTION_TYPE  max_iteration Count 
precision Amt  slice <4D_Normal>, Distance
ALGEBRA_TYPE:
quaternion  hypercomplex
FUNCTION_TYPE:
QUATERNATION:
sqr  cube
HYPERCOMPLEX:
sqr  cube  exp  reciprocal  sin  asin  sinh 
asinh  cos  acos  cosh  acosh  tan  atan tanh 
atanh  ln  pwr( X_Val, Y_Val )
Julia Fractal default values:
ALGEBRA_TYPE : quaternion
FUNCTION_TYPE : sqr
max_iteration : 20
precision : 20
slice, DISTANCE : <0,0,0,1>, 0.0
The required 4D vector <4D_Julia_Parameter> is the classic Julia parameter p
in the iterated formula f(h) + p . The julia fractal object is calculated by using an algorithm
that determines whether an arbitrary point h(0) in 4D space is inside or outside the object.
The algorithm requires generating the sequence of vectors h(0), h(1), ... by iterating the
formula h(n+1) = f(h(n)) + p (n = 0, 1, ..., max_iteration1) where p is
the fixed 4D vector parameter of the julia fractal and f() is one of the functions sqr ,
cube , ... specified by the presence of the corresponding keyword. The point h(0)
that begins the sequence is considered inside the julia fractal object if none of the vectors in the sequence escapes
a hypersphere of radius 4 about the origin before the iteration number reaches the integer max_iteration
value. As you increase max_iteration , some points escape that did not previously escape, forming the
julia fractal. Depending on the <4D_Julia_Parameter> , the julia fractal object is not
necessarily connected; it may be scattered fractal dust. Using a low max_iteration can fuse together the
dust to make a solid object. A high max_iteration is more accurate but slows rendering. Even though it is
not accurate, the solid shapes you get with a low max_iteration value can be quite interesting. If none
is specified, the default is max_iteration 20 .
Since the mathematical object described by this algorithm is
fourdimensional and POVRay renders three dimensional objects, there must be a way to reduce the number of dimensions
of the object from four dimensions to three. This is accomplished by intersecting the 4D fractal with a 3D
"plane" defined by the slice modifier and then projecting the intersection to 3D space. The
keyword is followed by 4D vector and a float separated by a comma. The slice plane is the 3D space that is
perpendicular to <4D_Normal> and is Distance units from the
origin. Zero length <4D_Normal> vectors or a <4D_Normal>
vector with a zero fourth component are illegal. If none is specified, the default is slice <0,0,0,1>,0 .
You can get a good feel for the four dimensional nature of a julia fractal by using POVRay's animation feature to
vary a slice's Distance parameter. You can make the julia fractal appear from nothing, grow,
then shrink to nothing as Distance changes, much as the cross section of a 3D object changes
as it passes through a plane.
The precision parameter is a tolerance used in
the determination of whether points are inside or outside the fractal object. Larger values give more accurate results
but slower rendering. Use as low a value as you can without visibly degrading the fractal object's appearance but note
values less than 1.0 are clipped at 1.0. The default if none is specified is precision 20 .
The
presence of the keywords quaternion or hypercomplex determine which 4D algebra is used to
calculate the fractal. The default is quaternion . Both are 4D generalizations of the complex numbers but
neither satisfies all the field properties (all the properties of real and complex numbers that many of us slept
through in high school). Quaternions have noncommutative multiplication and hypercomplex numbers can fail to have a
multiplicative inverse for some nonzero elements (it has been proved that you cannot successfully generalize complex
numbers to four dimensions with all the field properties intact, so something has to break). Both of these algebras
were discovered in the 19th century. Of the two, the quaternions are much better known, but one can argue that
hypercomplex numbers are more useful for our purposes, since complex valued functions such as sin, cos, etc. can be
generalized to work for hypercomplex numbers in a uniform way.
For the mathematically curious, the algebraic properties of these two algebras can be derived from the
multiplication properties of the unit basis vectors 1 = <1,0,0,0>, i=< 0,1,0,0>, j=<0,0,1,0> and
k=< 0,0,0,1>. In both algebras 1 x = x 1 = x for any x (1 is the multiplicative identity). The basis vectors 1
and i behave exactly like the familiar complex numbers 1 and i in both algebras.
Quaternion basis vector multiplication rules
ij = k

jk = i

ki = j

ji = k

kj = i

ik = j

ii = jj = kk = 1

ijk = 1


Hypercomplex basis vector multiplication rules
ij = k

jk = i

ki = j

ji = k

kj = i

ik = j

ii = jj = kk = 1

ijk = 1


A distance estimation calculation is used with the quaternion calculations to speed them up. The proof that this
distance estimation formula works does not generalize from two to four dimensions but the formula seems to work well
anyway, the absence of proof notwithstanding!
The presence of one of
the function keywords sqr , cube , etc. determines which function is used for f(h)
in the iteration formula h(n+1) = f(h(n)) + p . The default is sqr. Most of the
function keywords work only if the hypercomplex keyword is present. Only sqr and cube
work with quaternion . The functions are all familiar complex functions generalized to four dimensions.
Function Keyword Maps 4D value h to:
Function Keyword Maps 4D value of h
sqr

h*h

cube

h*h*h

exp

e raised to the power h

reciprocal

1/h

sin

sine of h

asin

arcsine of h

sinh

hyperbolic sine of h

asinh

inverse hyperbolic sine of h

cos

cosine of h

acos

arccosine of h

cosh

hyperbolic cos of h

acosh

inverse hyperbolic cosine of h

tan

tangent of h

atan

arctangent of h

tanh

hyperbolic tangent of h

atanh

inverse hyperbolic tangent of h

ln

natural logarithm of h

pwr(x,y)

h raised to the complex power x+iy

A simple example of a julia fractal object is:
julia_fractal {
<0.083,0.0,0.83,0.025>
quaternion
sqr
max_iteration 8
precision 15
}
The first renderings of julia fractals using quaternions were done by Alan Norton and later by John Hart in the
'80's. This POVRay implementation follows Fractint in pushing beyond what is known in the literature by
using hypercomplex numbers and by generalizing the iterating formula to use a variety of transcendental functions
instead of just the classic Mandelbrot z2 + c formula. With an extra two dimensions and eighteen functions to
work with, intrepid explorers should be able to locate some new fractal beasts in hyperspace, so have at it!
