Welcome to Fractal Forums

Ok, I freely admit that I've only skimmed the original thread, and may have missed parts or misunderstood.  So now that we have a fresh, sparkly new board and thread, let me ask here:

What is the 3D Mandelbulb formula, in algebra (i.e., not code or implementation specific)?  And why, in words, is this THE 3D analog to the standard 2D Mandelbrot set?

Thanks, and I promise to pay better attention,
Kerry

Hi Kerry, first off I don't think Daniel White (twinbee) or Paul Nylander (bugman) have actually claimed it to be *the* 3D analog of the 2D Mandelbrot, it's just that Daniels investigations (see beginning of *the* thread) which produced something like what we're looking for in the case of z^2+c produced the startling results at higher "power"/degree as discovered by Paul.

As to what is it, well see Paul's post of his latest suggestion for a "correct" version of the formula:

http://www.fractalforums.com/3d-fractal-generation/true-3d-mandlebrot-type-fractal/msg8680/#msg8680 (http://www.fractalforums.com/3d-fractal-generation/true-3d-mandlebrot-type-fractal/msg8680/#msg8680)

If that's not sufficiently algebraic I'm not sure exactly what you're after, here's the same thing described in a mix of complex/real form as could be coded in UF or other software that handles complex, though this is less optimum even than the trig version in some cases (depending how the compiler handles ^@mpwr):

Kerry,

A UF 5 version is in reb.ulb (need the latest update to see it) If you do a search for spower at the top of the file the search will take you right to it.

Kerry,

Here is an example of z^5 + c rendered in Ultrafractal.

@ron, where (the heck  :dink:) do i increase the bulb iteration depth ?!
 O0

@ron, additionally, i was browsing through your methods, with the goal of implementing an "alternated bulb" , i see
you are using the base class "Quat" as formula base class, i have some questions about it

for the alternate method i would like to know when a formula is first used in an iteration loop ( for reseting a counter ), or
the current iteration depth value ...

have you ever thought about using the quat class for more simple functions, like a generic add or mul? , i wanted to start, but stopped
because i have not the right math book at my fingertips for reference of derivative functions ... but i believe it could be done so
that it would work in many cases ...

The Quat class is called such because it was originally for quaternion plugins, which was almost immediately broadened to include hypercomplex, juliabrots, and most recently the twinbee formula. Don't let the name fool you. Its really a wrapper to deal with 3D/4D objects and puts no conditions on the mathematics other than representing a 3D/4D number as a vector. The wrapper has built in functions for conversion between the vector representation and complex numbers. The actual math is carried out in other classes. The nested loops you are looking at have a counter reset. The inner loop is the actual iterations loop and is the iteration depth. The outer loop is for stepping in towards the fractal surface.

I hope this helps and makes some sense.

There is a class in reb.ulb called QH which holds a large collection of static functions for quaternion and hypercomplex operations, such as multiply, power, exponential, log, etc. I recently added a new class called MD which has the static functions for power and multiply for the twinbee method and for Dave Makin's 4D number approach.

To Kerry:

From what I understood (someone correct me if I'm wrong), you switch to spherical coordinates, square the radius and double the two angles (without caring if you get out of the usual range for theta), and switch back to cartesian coordinates. Then you perform a parity transformation. See this post:
http://www.fractalforums.com/3d-fractal-generation/true-3d-mandlebrot-type-fractal/msg8726/#msg8726
I could get an answer about how crucial the parity transformation is. Did any body tried to drop it?
Note that Jos Leys answered to my second question in the post above, look a little bit further in the thread.

Best,

Sam

I could get...

I meant "I couldn't..."

Not quite (at least with my method), but close. For example, if I want the z^8 + c mandelbulb, The radius is taken to the 8th power and the two angles are multiplied by 8 before conversion back to cartesian coordinates.

Not quite (at least with my method), but close. For example, if I want the z^8 + c mandelbulb, The radius is taken to the 8th power and the two angles are multiplied by 8 before conversion back to cartesian coordinates.

Of course, my explanation was only to "square" a vector. I also forgot to mention that the two angles are the usual azimut running from 0 to 2pi and the elevation, running from -pi/2 to pi/2 and equal to zero at the equator.

But this is interesting in the case of the power 8, you don't use any parity transformation?

Sam

Back in one of the earlier threads there is a statement that with the corrected twinbee formula, no parity transformation is needed.

Forgot to mention, I don't worry about effects of the elevation outside its normal range. I some of my early coding, I took that into account, and it didn't seem to have any effect on the image.

Quote from: David Makin on November 03, 2009, 12:56:44 AM
Hi all, you may remember I had a 3D based suggestion for a "true 3D" Mandy using the following:

 *  |    r    i    j
-----------------
  r  |    r    i    j
  i  |    i   -r  -j
  j  |   j   -j   -r

Which gives a square of (x,y,z):

new x = x^2 - y^2 - z^2
new y = 2*x*y
new z = 2*z*(x-y)
==========================================================================


I attempt to be explicit and thorough.
 *  x       iy     jz     -iy    -jz
------------------------------------
x:     x²   xiy   xjz   -xiy   -xjz
iy:   iyx   -y²   iyjz  -iyiy  -iyjz
jz:    jzx   jziy   -z²  -jziy   -jzjz
-iy:   -iyx  -iyiy -iyjz  -y²  -iy(-jz)
-jz:   -jzx  -jziy -jzjz  -jz(-iy)  -z²


The rules are:
     i² = j² = (-j)² = (-i)² = -1
  
     -ii = -jj = +1

The manipulations are:

 yix = yxi = xyi = xiy = ixy = iyx

 zjx = zxj = xzj = xjz = jxz = jzx

-yix = -yxi = -xyi = -xiy = -ixy = -iyx

-zjx = -zxj = -xzj = -xjz = -jxz = -jzx


double operator manipulations non commutative :

ziyj =zyij = yzij = yizj = iyzj = [iyjz = -iy(-jz)] = ijyz = ijzy= izjy

+y² = -y²i² = -yiyi = -iy²i = [-iyiy = iy(-iy)] = -i²y² = +y²
-ziyj = -zyij = -yzij = -iyzj = [-iyjz = iy(-jz)] = -ijyz = -ijzy = -izjy

yjzi = yzji = zyji = zjyi = jzyi = [jziy = -jz(-iy)] = jizy = jiyz = jyiz

-yjzi = -yzji = -zyji = -zjyi = -jzyi = [-jziy = jz(-iy)] = -jizy = -jiyz = -jyiz

+z² = -z²j² = -zjzj = -jz2j = [-jzjz = jz(-jz)] = -j²z² = +z²


summary of main manipulations:
yzij  = ijyz        (±jz)² = -z²      yxi = iyx
-yzij = -ijyz      (±iy)² = -y²     zxj = jzx
yzji  = jiyx     -(iy)² = +y²     -yxi = -iyx
yzji  = jiyz     -(jz)²  = +z²     -zxj = -jzx
-yzji   = -jiyz



So (x + iy +jz)² gives the following parts

x² + (iy)² + (jz)²


i(xy + yx)

j(xz + zx)

yz(ij + ji)

So for the function the last term which i am calling the handedness term is decided by the programmer.

For the geometrical space mandelbrot iteration

newx =x² - y² - z²

newy = 2xy

newz = 2xz

handedness term affects either x or y or z or 2 out of the 3 and has magnitude yz so:
if ij / ji

newyz =y.z.


for the handedness term
 if ij = ji
newyz = 2yz

I will suggest in another post how the handedness term might be applied but i think there is enough here for you to play with.

   Report to moderator    81.108.14.116

May you delight in orgasms and know peace joy vigorous health and feelings of grat

But all you have there is the cut-down quaternion which just produces the "lathed" Mandelbrot.

My my! How things have changed in a few short weeks!

As i promised i have a few suggestions about the so called handedness term

                         ijyz + jizy

To be plotable ij and ji have to take on values from the following set
                      
                        {1, -1,i, -i,j, -j}

Setting out the possibilities in table form to facilitate exploration:

if ij =	1	-1	i	-i	j	-j
ji may =	1	i	-i	j	-j	i
or	-j	-1	1	i	-i	j
or	-i	j	i	-j	-1	1
or	j	-i	-j	-i	1	-1
or	-1	-j	j	1	j	-i
or	i	1	-1	-1	i	-j

 

Or an alternative layout

if ij =	1  -1    i   -i    j   -j
ji may =	1   1    1   1   1   1
or	-1  -1  -1  -1  -1  -1
or	i     i     i     i    i    i
or	-i    -i   -i    -i   -i   -i
or	j     j     j     j    j    j
or	-j    -j    -j   -j   -j   -j

In both cases the diagonal represents commutativity  
                                        
                                 ij = ji

and in this case the handedness term becomes 2yz and is added to or subtracted from the appropriate axis (or axes in case of non commutativity).

If David or somebody is prepared to run these transforms i would be interested to see the results.


I have designed a transform for the triplex ie ³ which is inspired by the transform on² and the notion of i being a transform in a set of transforms which include + - * / () and all algorithms. The syntax above the set imbues i with an additional property: that of a signal. Cardano when he first discussed these transforms used them as such. i will post the right handed transform later. There is of course a left handed transform which if the right handed one is interesting  i will derive from the construction process.

Hiya David. Thanks for replying. I hope you follow my subsequent post. I am interested in the experiments you discarded when coming up with your alternative formula and would like to see what the results were if possible.

Your reference to the quaternion is interesting because the triplex transform i have designed is power 4 and so not quaternionic, but all attempts so far have therefore been as you say some modification of the quaternion. The analysis above introduces a handedness term exactly because the transform signals a fourth term is needed. On the basis of that and pending your investigations of the above, i  am prepared to say no power 2 formula is ever going to be adequate.

Will get back to using the unit vector multiplication method shortly, am just trying some alternatives closer to the Mandelbulb method.

I have tried all the commutative ones in quasz
http://www.fractalforums.com/mystic-fractal-programs-gallery/mandelbrotin-3d/.
http://www.fractalforums.com/3d-fractal-generation/truerer-true-3d-mandelbrot-fractal-(search-for-the-holy-grail-continues)/60/
I am going to have a go at the non commutative ones.

Recently looked at Terry Gintz idynamasz as a more appropriate programme for this exploration.