Reference:Julia Fractal - Revision history

Clipka: indexentry fix

2016-05-03T23:21:31Z

indexentry fix

Jholsenback: moved images to proper section

2013-02-10T14:42:27Z

moved images to proper section

Jholsenback: added images

2013-02-10T14:16:35Z

added images

Jholsenback: 1 revision: Reference Migration Initial Load

2012-03-15T19:07:12Z

1 revision: Reference Migration Initial Load

Jholsenback: 1 revision: Initial Load (TF)

2012-03-11T22:26:59Z

1 revision: Initial Load (TF)

New page

[[Category:Objects]]
[[Category:Finite Solid Primitives]]
{{#indexentry:fractal object}}
{{#indexentry:fractal}}
{{#indexentry:julia_fractal, keyword}}
{{#indexentry:keyword, julia_fractal}}
A julia fractal object is a 3-D slice of a 4-D object
created by generalizing the process used to create the classic Julia sets.
You can make a wide variety of strange objects using the <code>
julia_fractal</code> statement including some that look like bizarre blobs of
twisted taffy. The <code>julia_fractal</code> syntax is:
<pre>
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 )
</pre>

{{#indexentry:default values, julia fractal}}
Julia Fractal default values:
<pre>
ALGEBRA_TYPE : quaternion
FUNCTION_TYPE : sqr
max_iteration : 20
precision : 20
slice, DISTANCE : <0,0,0,1>, 0.0
</pre>

{{#indexentry:max_iteration, julia_fractal}}
{{#indexentry:keyword, max_iteration}}
The required 4-D vector <code><4D_Julia_Parameter></code>
is the classic Julia parameter <code>p</code> in the iterated
formula <code>f(h) + p</code>. The julia fractal object is
calculated by using an algorithm that determines whether an arbitrary point
<code>h(0)</code> in 4-D space is inside or outside the object. The
algorithm requires generating the sequence of vectors <code>h(0), h(1),
...</code> by iterating the formula <code>h(n+1) = f(h(n)) + p (n =
0, 1, ..., max_iteration-1)</code> where <code> p</code> is the
fixed 4-D vector parameter of the julia fractal and <code>f()</code>
is one of the functions <code>sqr</code>, <code> cube</code>, ... specified
by the presence of the corresponding keyword. The point <code>
h(0)</code> 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
<code>max_iteration</code> value. As you increase <code>max_iteration</code>,
some points escape that did not previously escape, forming the julia fractal.
Depending on the <code> <4D_Julia_Parameter></code>, the julia
fractal object is not necessarily connected; it may be scattered fractal
dust. Using a low <code> max_iteration</code> can fuse together the dust to
make a solid object. A high <code>max_iteration</code> is more accurate but
slows rendering. Even though it is not accurate, the solid shapes you get
with a low <code>max_iteration</code> value can be quite interesting. If
none is specified, the default is <code>max_iteration 20</code>.

{{#indexentry:slice, julia_fractal}}
{{#indexentry:keyword,slice}}
Since the mathematical object described by this algorithm is four-dimensional
and POV-Ray 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 4-D fractal with a 3-D plane defined by the <code>slice</code> modifier and then projecting the
intersection to 3-D space. The keyword is followed by 4-D vector and a float
separated by a comma. The slice plane is the 3-D space that is perpendicular
to <code> <4D_Normal></code> and is <code>
Distance</code> units from the origin. Zero length <code>
<4D_Normal></code> vectors or a <code>
<4D_Normal></code> vector with a zero fourth component are
illegal. If none is specified, the default is <code> slice
<0,0,0,1>,0</code>.

You can get a good feel for the four dimensional nature of a julia fractal by
using POV-Ray's animation feature to vary a slice's <code>
Distance</code> parameter. You can make the julia fractal appear from
nothing, grow, then shrink to nothing as <code>
Distance</code> changes, much as the cross section of a 3-D object
changes as it passes through a plane.

{{#indexentry:precision, julia_fractal}}
{{#indexentry:keyword, precision}}
The <code> precision</code> 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 <code>precision 20</code>.

{{#indexentry:quaternion, julia_fractal}}
{{#indexentry:keyword, quaternion}}
{{#indexentry:hypercomplex, julia_fractal}}
{{#indexentry:keyword, hypercomplex}}
The presence of the keywords <code> quaternion</code> or <code>
hypercomplex</code> determine which 4-D algebra is used to calculate the
fractal. The default is <code>quaternion</code>. Both are 4-D 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 non-commutative multiplication and
hypercomplex numbers can fail to have a multiplicative inverse for some
non-zero 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.

<table SUMMARY="Quaternion basis vector multiplication rules" width="75%">
<tr>
<td width="33%"><code>ij = k</code></td>
<td width="33%"><code>jk = i</code></td>
<td width="33%"><code>ki = j</code></td>
</tr>

<tr>
<td><code>ji = -k</code></td>
<td><code>kj = -i</code></td>
<td><code>ik = -j</code></td>
</tr>

<tr>
<td><code>ii = jj = kk = -1</code></td>
<td><code>ijk = -1</code></td>
<td>   </td>
</tr>
</table>

<table SUMMARY="Hypercomplex basis vector multiplication rules" width="75%">
<tr>
<td width="33%"><code>ij = k</code></td>
<td width="33%"><code>jk = -i</code></td>
<td width="33%"><code>ki = -j</code></td>
</tr>

<tr>
<td><code>ji = k</code></td>
<td><code>kj = -i</code></td>
<td><code>ik = -j</code></td>
</tr>

<tr>
<td><code>ii = jj = kk = -1</code></td>
<td><code>ijk = 1</code></td>
<td>   </td>
</tr>
</table>

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!

{{#indexentry:sqr, julia_fractal}}
{{#indexentry:keyword, sqr}}
{{#indexentry:cube, julia_fractal}}
{{#indexentry:keyword, cube}}
The presence of one of the function keywords <code>sqr</code>, <code>
cube</code>, etc. determines which function is used for <code>
f(h)</code> in the iteration formula <code>h(n+1) = f(h(n)) +
p</code>. The default is <code>sqr.</code> Most of the function keywords
work only if the <code>hypercomplex</code> keyword is present. Only <code>
sqr</code> and <code>cube</code> work with <code> quaternion</code>. The
functions are all familiar complex functions generalized to four dimensions.
Function Keyword Maps 4-D value h to:

<table SUMMARY="Function Keyword Maps 4-D value of h" width="75%">
<tr>
<td width="30%"><code>sqr</code></td>
<td width="70%">h*h</td>
</tr>

<tr>
<td><code>cube</code></td>
<td>h*h*h</td>
</tr>

<tr>
{{#indexentry:exp, julia_fractal}}
{{#indexentry:keyword, exp}}
<td><code>exp</code></td>
<td>e raised to the power h</td>
</tr>

<tr>
{{#indexentry:reciprocal, julia_fractal}}
{{#indexentry:keyword, reciprocal}}
<td><code>reciprocal</code></td>
<td>1/h</td>
</tr>

<tr>
{{#indexentry:sin, julia_fractal}}
{{#indexentry:keyword, sin}}
<td><code>sin</code></td>
<td>sine of h</td>
</tr>

<tr>
{{#indexentry:asin, julia_fractal}}
{{#indexentry:keyword, asin}}
<td><code>asin</code></td>
<td>arcsine of h</td>
</tr>

<tr>
{{#indexentry:sinh, julia_fractal}}
{{#indexentry:keyword, sinh}}
<td><code>sinh</code></td>
<td>hyperbolic sine of h</td>
</tr>

<tr>
{{#indexentry:asinh, julia_fractal}}
{{#indexentry:keyword, asinh}}
<td><code>asinh</code></td>
<td>inverse hyperbolic sine of h</td>
</tr>

<tr>
{{#indexentry:cos, julia_fractal}}
{{#indexentry:keyword, cos}}
<td><code>cos</code></td>
<td>cosine of h</td>
</tr>

<tr>
{{#indexentry:acos, julia_fractal}}
{{#indexentry:keyword, acos}}
<td><code>acos</code></td>
<td>arccosine of h</td>
</tr>

<tr>
{{#indexentry:cosh, julia_fractal}}
{{#indexentry:keyword, cosh}}
<td><code>cosh</code></td>
<td>hyperbolic cos of h</td>
</tr>

<tr>
{{#indexentry:acosh, julia_fractal}}
{{#indexentry:keyword, acosh}}
<td><code>acosh</code></td>
<td>inverse hyperbolic cosine of h</td>
</tr>

<tr>
{{#indexentry:tan, julia_fractal}}
{{#indexentry:keyword, tan}}
<td><code>tan</code></td>
<td>tangent of h</td>
</tr>

<tr>
{{#indexentry:atan, julia_fractal}}
{{#indexentry:keyword, atan}}
<td><code>atan</code></td>
<td>arctangent of h</td>
</tr>

<tr>
{{#indexentry:tanh, julia_fractal}}
{{#indexentry:keyword, tanh}}
<td><code>tanh</code></td>
<td>hyperbolic tangent of h</td>
</tr>

<tr>
{{#indexentry:atanh, julia_fractal}}
{{#indexentry:keyword, atanh}}
<td><code>atanh</code></td>
<td>inverse hyperbolic tangent of h</td>
</tr>

<tr>
{{#indexentry:ln, julia_fractal}}
{{#indexentry:keyword, ln}}
<td><code>ln</code></td>
<td>natural logarithm of h</td>
</tr>

<tr>
{{#indexentry:pwr, julia_fractal}}
{{#indexentry:keyword, pwr}}
<td><code>pwr(x,y)</code></td>
<td>h raised to the complex power x+iy</td>
</tr>
</table>

A simple example of a julia fractal object is:
<pre>
julia_fractal {
<-0.083,0.0,-0.83,-0.025>
quaternion
sqr
max_iteration 8
precision 15
}
</pre>

The first renderings of julia fractals using quaternions were done by Alan
Norton and later by John Hart in the '80's. This POV-Ray
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!

@@ Line 9: / Line 9: @@
 You can make a wide variety of strange objects using the <code>
 julia_fractal</code> statement including some that look like bizarre blobs of
-twisted taffy.</p>
+twisted taffy. The <code>julia_fractal</code> syntax is:</p>
 <pre>
 JULIA_FRACTAL:
@@ Line 53: / Line 39: @@
 slice, DISTANCE : &lt;0,0,0,1&gt;, 0.0
 </pre>
 {{#indexentry:max_iteration, julia_fractal}}
@@ Line 351: / Line 324: @@
 dimensions and eighteen functions to work with, intrepid explorers should be
 able to locate some new fractal beasts in hyperspace, so have at it!</p>

@@ Line 67: / Line 67: @@
 {{#indexentry:slice, julia_fractal}}
-{{#indexentry:keyword,slice}}
+{{#indexentry:keyword, slice}}
 <p>Since the mathematical object described by this algorithm is four-dimensional
 and POV-Ray renders three dimensional objects, there must be a way to reduce

← Older revision	Revision as of 19:07, 15 March 2012
(No difference)