**SMALLIFYING IMAGES SO THE REAL "REAL TRUE" 3D FORMULA CAN TAKE PRECEDENCE** it will be posted below in new post

Works great hybridized with the Mandelbox, lots of interesting patterns, and for whatever reason it is smoother...

It's a modification of my Type B1 formula. Doesn't have the whispyness of the old "true mandy" formula, rather it is fractally and zoomable in many locations (although doing 20+ iterations takes a long time, so the higher z^n variations are still going to dominate my fractalling until I get a new computer).

Note that it uses different code for the z^3 version (posted at bottom of message). Not sure about which code segment should be used for each one beyond z^3 (yet)... The even n z^n (2,4,6,8....) use the original code. The odd n z^n (3,5,7,9....) use the new code. I'm not sure where the flaw is (maybe accumulated errors, but I doubt it) but there is distortion in all versions. We are using 2 x pixel additions and switching them to achieve balance (between the 2 magnitudes) which leads to accumulated errors as we iterate.

Anyways, the main point being that the farther you get from the x-axis, the more distorted the fractal gets.

Here is my type B3 version of

David Makin's minibrot which I think would have a lot more branches if I rendered it better (slower):

Anyways, I posted the code in another thread, but figured I should post it here as well (was thinking about "Search for the holy grail" thread, but saw that jehovajah said it was getting a little too long, and as I just re-read the original 37 page thread, I wholeheartedly agree).

Here is the code, followed by a zoom (to be posted when done with render... about 1 hour and 50 minutes for a 24 iteration 800x800) into either the period 2 or 4 bulb (can't remember which- it is calculating now, maybe even a sub bulb of the 2 or 4):

Including mathematical translations of code after actual ChaosPro code. Consider thanking Martin Pfingstl for creating freeware software that allows people with limited resources to do mathematical exploration (and thank the Maxima team).

**Use z^2 version for even n (z^2,4,6,8....) and z^3 version for odd (in other words, z^2 code is z^even code and z^3 code is z^odd code)**

r2=(sqr(sx)+sqr(sy)+sqr(sz))^(n/2); // r2= ( sx1^2 + sy^2 + sz^2) ^ (n/2)

r3=(sqr(sx2)+sqr(sy)+sqr(sz))^(n/2); // r3= ( sx2^2 + sy^2 + sz^2) ^ (n/2)

theta=atan2(sx+flip(sy)); // atan2 (in ChaosPro syntax) calculates the arctangent of real x plus imaginary y

tango=atan2(sx2+flip(sz)); // flip (in ChaosPro syntax) multiplies a real value by [i]i[/i]

// so the previous 2 statements calculate the angle between real x and imaginary y for the first angle "theta"

// and 'imaginary" z for the second angle "tango"

if (pixelr>0) { // If the x value of the pixel is greater than zero, use the r3 radius for value nx (the one with the sx2 component)

nx=r3*cos(theta*v); // this calculates our rotational component, just like in the regular Mandelbulbs you guys know

} else { // if the x value is 0 or less, use the r2 radius for value nx (the one with the sx component)

nx=r2*cos(theta*v); // in other words: nx = r2 * cosine (angle theta * v) v is the rotations which is set = to n

}

if (pixelr>0) { // If the x value of the pixel is greater than zero, use the r2 radius for value nx2 (the one with the sx component)

nx2=r2*cos(tango*v);

} else { // if the x value is 0 or less, use the r3 radius for value nx2 (the one with the sx2 component)

nx2=r3*cos(tango*v);

}

ny=r2*sin(theta*v); // these are pretty much standard, as are the rest

nz=r3*sin(tango*v);

if (juliaMode) { // just a standard if/else statement... if the boolean variable juliaMode is true use the perturbation variables

sx=nx+cr; // cr is the real perturbation value

sx2=nx2+cr; // cr is used for both x values

sy=ny+ci; // ci is used for the y: The c is pretty standard for fractals, the i is form imaginary

sz=nz+cj; // cj is used for the z: the j is used because it pretty much standard for quaternions, and I still use it for z axis

} else { // if you didn't set the boolean juliaMode=true (hitting the checkbox) you will do standard Mandelbrot addition

sx=nx+(pixelr); // of pixel values.. once again use the real (x axis) pixel component for

sx2=nx2+(pixelr); // both x values

sy=ny+abs(pixeli); // the y axis pixel component

sz=nz+abs(pixelj); // the z axis pixel component

}

z=quaternion (sx,sy,sz,sx2); //This statement feeds information to ChaosPro's orbital coloring scheme which allows you to use

// orbital values of the variables at whatever iteration you pick to assign colors (picks them from a palette you set)

bail=abs(sx)+abs(sy)+abs(sz)+abs(sx2); // and of course bail is the variable I send to the bailout check within ChaosPro

// I tend to set bail a bit high ~12-22 just because I do. Probably eats a few more iterations... but I am not sure of the

// exact value for 4 variables (8? 16? 12 seems to work... but so does 4... so... hrm...).

Image will be posted later (1:10:xx left).

Anyways, the image is crappy. Just a bad zoom, so I picked out David's old minibrot (more or less) to do a render which should take about 45 minutes to an hour. I also have a neat area of elephant valley (don't follow the axes, instead pick areas between them for maximum interesting fractallyness) getting done, but the coloring scheme is to show details (set to 3 iterations less than total and .1 speed, offset 55 gives nice details (where it is slightly lower it is dark) but it doesn't give good differences between the big areas. I'll see if I can get it to show the big details too, but... my coloring scheme skills are severely lacking, just ask Trifox).

Here is the elephant valley, and I'll throw in a couple of ... crappy seahorse valley ones afterwords.

Seahorse (actually, now that I think about it, I wasn't in between the axes, which isn't as awesome for elephant valley, so... there you go, that's why they are boring):

then here is the period 4 bulb zoom (crappy render, should have picked a better angle/location):

Modified z^3 code segment (do an if statement, or whatever):

QUICK NOTE: z^3 uses a different setup than z^2 (to be like a z^3 2d Mandelbrot over both z and y axis):

if (pixelr>0) {

nx=-r2*cos(theta*v);

} else {

nx=-r2*cos(theta*v);

}

if (pixelr>0) {

nx2=-r3*cos(tango*v);

} else {

nx2=-r3*cos(tango*v);

}

ny=-r2*sin(theta*v);

nz=-r3*sin(tango*v);