Welcome to Fractal Forums

  //initialization - only need to do this part once per pixel, but you can repeat it if you like to do extra steps.. 
// really, it's up to you

	c=pi/2;

	a=n*c;    //  n is your z^n thingy... called n
	b=c^(3-n);     // sometimes I use b*[(n-1)^-1] but just do the main one there

// iteration part

	r=(x^2+y^2+z^2);
			
	r1=(x^2*b+r)^(n/2);    //changed it after DarkBeam pointed out formula didn't work
	r2=(y^2*b+r)^(n/2);   //   was x*b, y*b, z*b when it should have been
	r3=(z^2*b+r)^(n/2);   //  x^2 * b, y^2*b, and z^2 *b in the magnitudes...  like it is in my formula... lol
			
	r=sqrt(r);

	theta=	atan2 (abs (x) * a + flip (r));  //atan2 is the arg function for gettin' yer angles..
	phi=	atan2 (abs (y) * a + flip (r));  //  flip changes the real value r to the imaginary value to use with 
	tango=	atan2 (abs (z) * a + flip (r));  // the function atan2.   In other words, the flipped part is imaginary

	new_x= r1 * cos (theta * n);
	new_y= r2 * cos (phi * n);
	new_z= r3 * cos (tango * n);

//  now here is the part where I want the switch thrown in, before you add in the pixel or Julia components
//  You might want to disable the switch for n=4,8,12... because it makes discontinuous fractals...
//  but I think I just coded it for you below... anyways..

	if (switch) {
		if (n==2) {
			if (pixelr>0 && x*a>r) {	// pixelr is the x component of the pixel 
				nx=-nx;
			}
			if (pixeli>0 && y*a>r) {	// pixeli is the y component of the pixel
				ny=-ny;
			}
			if (pixelj>0 && z*a>r) {	// pixelj is the z component of the pixel
				nz=-nz;
			}
		} else if (n != 4 && n!==8 && n!=12) {   	// you know... nobody is every gonna use n>15, just like we 
			if (pixelr>0 && x>0) {			// will never need more than 640k on a computer, so we
				nx=-nx;				// don't have to make lots of ! statements.. 
			}						//  !=  means does not equal... in case of questions..
			if (pixeli>0 && y>0) {			//  && means logical and....  maybe you don't need the n!=12?
				ny=-ny;
			}
			if (pixelj>0 && z>0) {
				nz=-nz;
			}
		}
	}

// now add in your pixel or Julia components... measure bail, etc.
// make sure you check squares (for bailout) instead of absolute values of new components,
// it makes a smoother nicer looking fractal..

pi/2=  1.5707963267948966192313216916397514420985846996875529104874722961539082031431044993140174126710585339910740432566411533235469223047752911158626797040642405587251420513509692605527798223114744774651909822144054878329667230642378241168933915826356009545728242834617301743052271633241066968036301245706368622935033031577940874407604604814146270458576821839462951800056652652744102332606920734759707558047165286351828797959765460930586909663058965525592740372311899813747836759428763624456139690915059745649168366812203283215430106974731976123685953510899304718513852696085881465883761923374092338347025660002840635726317804138928856713788948045868185893607342204506124767150732747926855253961398446294617710099780560645109804320172090799068148873856549802593536056749999991864890249755298658664080481592975122297276734541513212611541266723425176309655940855050015689193764432937666041907103085888345736517991267452143777343655797814319411768937968759788909288902660856134033065009639383055979546082100994690476286005327429316394329680766909139841151509760176509264844978868112997069456248608876417395657577874286212270753479754147665584308639279445375491908773187324696596275302004638508355695049244120064291808017818538300523550909714777980994733839187247241276898873634235520237673231040233421295347456466568385144945760523760810284830120290190750967556266912150177938201237482366319570996363021349613983911773908180046708608206099622931575151430914872778533749192527472942934634978454636053987546514776605826724936013779801182403327495599409173988767831849037132712639312759092087873364454888863969000408235300080726245960866086073861750707209867842740806805786762760667378709247342192616619536970716672738812084312594917847427810496096110921362751271284438358952473008267334024943136163958930428921919139839883407270504769418931804753400321125626025586964924480420642443134728021209826425111053305931533721393110195974725235618568934804781821859586437338823287869812069454329163229979066952390137950497328820394756347341991762978549129113102612447

// initialization part

if (juliaMode) {
		sx=pixelr;   //  sx is the starting x value, x for your equations   x=sx
		sy=pixeli;   //  Cx= pixelr, Cy=pixeli, etc...
		sz=pixelj;
	} else {
		sx=cr;	// cr is the x seed component, usually 0 for Mandelbrot mode
		sy=ci;	// ci is the y seed... etc.
		sz=cj;
	}

c=pi/2;  // make sure this is set right
a=n*c;   //  n is your z^n value
b=c^(3-n);

//  iteration part     
r=(sqr(sx)+sqr(sy)+sqr(sz));   //  sqr(sx) means square x component- sqr() is a fast squaring algorithm same as x*x

r1=(sqr(sx)*b+r)^(n/2);  // if you don't take the sqrt of r in the beginning, you avoid 3 squaring operations...
r2=(sqr(sy)*b+r)^(n/2);
r3=(sqr(sz)*b+r)^(n/2);

r=sqrt(r);		//then take your square root to do your atan2 (not atan!)

theta=atan2	(abs(sx) * a + flip(r));   // abs(sx) means take the absolute value of your x component
phi=atan2	(abs(sy) * a + flip(r));	//  Make sure that you use arg or atan2---atan does NOT work because
tango=atan2	(abs(sz) * a + flip(r));  //   of zeros (x,y, and z are initially zero... unless seeded)
						//flip (r) means make r the imaginary component for the atan2 (or arg) function

	// if using arg or atan2, make sure to use it correctly- do not 
	// divide by zero, if using arg make sure to make the r component imaginary
	// to avoid a divide by zero error, I usually multiply and have the divisor taken to ^-1
	//  in other words: x / r = x * r^-1

nx=r1*cos(theta*n);    // nx is new_x... ny is.... new_y, etc..
ny=r2*cos(phi*n);
nz=r3*cos(tango*n);

if (juliaMode) {
		sx=nx+cr;
		sy=ny+ci;
		sz=nz+cj;
	} else {		
		sx=nx+(pixelr);   // for you x= new_x + Cx;
		sy=ny+(pixeli);
		sz=nz+(pixelj);
	}

bailout=sqr(sx)+sqr(sy)+sqr(sz);

66842149     55             PUSH EBP	// intro
6684214A     8BEC           MOV EBP,ESP	// intro
6684214C     81EC 40000000  SUB ESP,40	// allocate memory in the stack
66842152     53             PUSH EBX	// intro
66842153     56             PUSH ESI	// intro
66842154     57             PUSH EDI	// intro
66842155     8B75 08        MOV ESI,DWORD PTR SS:[EBP+8]	// intro
66842158     8B7E 30        MOV EDI,DWORD PTR DS:[ESI+30]	// intro
6684215B     8BD8           MOV EBX,EAX	// intro
6684215D     D9D0           FNOP	// separator
6684215F     DD47 F0        FLD QWORD PTR DS:[EDI-10]	// edi-10 is N
66842162     DC4F E8        FMUL QWORD PTR DS:[EDI-18]	// edi-18 is C
66842165     DD5D F8        FSTP QWORD PTR SS:[EBP-8]	// SAVE into stack room 1
66842168     D9D0           FNOP	// separator
6684216A     90             NOP	// separator
6684216B     DD47 F0        FLD QWORD PTR DS:[EDI-10]	// edi-10 is N
6684216E     DC2F           FSUBR QWORD PTR DS:[EDI]	// 3-N (EDI is constant = 3)
66842170     DD47 E8        FLD QWORD PTR DS:[EDI-18]	// edi-18 is C
66842173     D9F1           FYL2X	// fixed sequence for pow(x,y) - we MUST load exponent then base; else we MUST swap!
66842175     D9E8           FLD1	// fixed sequence for pow(x,y)
66842177     D9C1           FLD ST(1)	// fixed sequence for pow(x,y)
66842179     D9F8           FPREM	// fixed sequence for pow(x,y)
6684217B     D9F0           F2XM1	// fixed sequence for pow(x,y)
6684217D     DEC1           FADDP ST(1),ST	// fixed sequence for pow(x,y)
6684217F     D9FD           FSCALE	// fixed sequence for pow(x,y)
66842181     D9C9           FXCH ST(1)	// fixed sequence for pow(x,y)
66842183     DDD8           FSTP ST	// fixed sequence for pow(x,y) end
66842185     DD5D F0        FSTP QWORD PTR SS:[EBP-10]	// SAVE into stack room 2
66842188     D9D0           FNOP	// separator
6684218A     DD03           FLD QWORD PTR DS:[EBX]	// this block makes: x*x+y*y+z*z
6684218C     D8C8           FMUL ST,ST
6684218E     DD02           FLD QWORD PTR DS:[EDX]
66842190     D8C8           FMUL ST,ST
66842192     DD01           FLD QWORD PTR DS:[ECX]
66842194     D8C8           FMUL ST,ST
66842196     DEC1           FADDP ST(1),ST
66842198     DEC1           FADDP ST(1),ST	// done
6684219A     D9FA           FSQRT	// sqrt(x*x+y*y+z*z). i leave this into fp stack.
6684219C     D9D0           FNOP	// separator
6684219E     DD03           FLD QWORD PTR DS:[EBX]	// EBX is X
668421A0     D9E1           FABS	// ABS(X)
668421A2     DC4D F8        FMUL QWORD PTR SS:[EBP-8]	// EBP-8 = 1ST stack room = a
668421A5     D9C1           FLD ST(1)	// st(1) = 1ST fp stack room(1) = SQRT(R)
668421A7     D9C9           FXCH ST(1)
668421A9     D9F3           FPATAN	// exchange then do atan2(previous arguments)
668421AB     DD5D E8        FSTP QWORD PTR SS:[EBP-18]	// save into room3 + free fp stack - st now is SQRT(R) again
668421AE     D9D0           FNOP
668421B0     DD02           FLD QWORD PTR DS:[EDX]	// EDX is Y
668421B2     D9E1           FABS
668421B4     DC4D F8        FMUL QWORD PTR SS:[EBP-8]	// EBP-8 = 1ST stack room = a
668421B7     D9C1           FLD ST(1)	// EBP-8 = fp stack room(1) = SQRT(R), as before
668421B9     D9C9           FXCH ST(1)
668421BB     D9F3           FPATAN
668421BD     DD5D E0        FSTP QWORD PTR SS:[EBP-20]	// save into room4 + free fp stack - st now is SQRT(R) again
668421C0     D9D0           FNOP
668421C2     DD01           FLD QWORD PTR DS:[ECX]	// ecx is Z. equal to before...
668421C4     D9E1           FABS
668421C6     DC4D F8        FMUL QWORD PTR SS:[EBP-8]
668421C9     D9C1           FLD ST(1)
668421CB     D9C9           FXCH ST(1)
668421CD     D9F3           FPATAN
668421CF     DD5D D8        FSTP QWORD PTR SS:[EBP-28]	// save into room4
668421D2     D9D0           FNOP	// okay now we have a,b,theta, phi, tango saved into the stack
668421D4     DD03           FLD QWORD PTR DS:[EBX]
668421D6     D8C8           FMUL ST,ST			// x*x
668421D8     DC4D F0        FMUL QWORD PTR SS:[EBP-10]	// b again
668421DB     D9C1           FLD ST(1)	// remember that sqrt(R) is still into the fpstack
668421DD     D8C8           FMUL ST,ST	// sqrt(R)*himself=R.
668421DF     DEC1           FADDP ST(1),ST	// R + b*x*x - stop, this is the power base
668421E1     DD47 F0        FLD QWORD PTR DS:[EDI-10]	// N
668421E4     DC4F 08        FMUL QWORD PTR DS:[EDI+8]	// N*0.5 because edi+8 is second constant
668421E7     D9C9           FXCH ST(1)	// but we have to do base^exponent so swap!
668421E9     D9F1           FYL2X	// fixed sequence for pow(x,y)
668421EB     D9E8           FLD1
668421ED     D9C1           FLD ST(1)
668421EF     D9F8           FPREM
668421F1     D9F0           F2XM1
668421F3     DEC1           FADDP ST(1),ST
668421F5     D9FD           FSCALE
668421F7     D9C9           FXCH ST(1)
668421F9     DDD8           FSTP ST	// fixed sequence for pow(x,y) end
668421FB     DD5D D0        FSTP QWORD PTR SS:[EBP-30]	// saves into room for newx
668421FE     D9D0           FNOP
66842200     DD45 E8        FLD QWORD PTR SS:[EBP-18]	// theta
66842203     DC4F F0        FMUL QWORD PTR DS:[EDI-10]	// * n
66842206     DC47 E0        FADD QWORD PTR DS:[EDI-20]  // + phase
66842209     D9FF           FCOS			// cos( that stuff )
6684220B     DC4D D0        FMUL QWORD PTR SS:[EBP-30]	// but multiply by newx
6684220E     DD5D D0        FSTP QWORD PTR SS:[EBP-30]	// and save into newx itself...
66842211     D9D0           FNOP	// I know it's boring but we need to calculate also newy, newz. It's everything like before, with minimal
66842213     D9D0           FNOP	// variations, different rooms / values, I copied and pasted barely.
66842215     DD02           FLD QWORD PTR DS:[EDX]
66842217     D8C8           FMUL ST,ST
66842219     DC4D F0        FMUL QWORD PTR SS:[EBP-10]
6684221C     D9C1           FLD ST(1)
6684221E     D8C8           FMUL ST,ST
66842220     DEC1           FADDP ST(1),ST
66842222     DD47 F0        FLD QWORD PTR DS:[EDI-10]
66842225     DC4F 08        FMUL QWORD PTR DS:[EDI+8]
66842228     D9C9           FXCH ST(1)
6684222A     D9F1           FYL2X
6684222C     D9E8           FLD1
6684222E     D9C1           FLD ST(1)
66842230     D9F8           FPREM
66842232     D9F0           F2XM1
66842234     DEC1           FADDP ST(1),ST
66842236     D9FD           FSCALE
66842238     D9C9           FXCH ST(1)
6684223A     DDD8           FSTP ST
6684223C     DD5D C8        FSTP QWORD PTR SS:[EBP-38]
6684223F     D9D0           FNOP
66842241     DD45 E0        FLD QWORD PTR SS:[EBP-20]
66842244     DC4F F0        FMUL QWORD PTR DS:[EDI-10]
66842247     DC47 E0        FADD QWORD PTR DS:[EDI-20]
6684224A     D9FF           FCOS
6684224C     DC4D C8        FMUL QWORD PTR SS:[EBP-38]
6684224F     DD5D C8        FSTP QWORD PTR SS:[EBP-38]
66842252     D9D0           FNOP
66842254     D9D0           FNOP
66842256     DD01           FLD QWORD PTR DS:[ECX]
66842258     D8C8           FMUL ST,ST
6684225A     DC4D F0        FMUL QWORD PTR SS:[EBP-10]
6684225D     D9C1           FLD ST(1)
6684225F     D8C8           FMUL ST,ST
66842261     DEC1           FADDP ST(1),ST
66842263     DD47 F0        FLD QWORD PTR DS:[EDI-10]
66842266     DC4F 08        FMUL QWORD PTR DS:[EDI+8]
66842269     D9C9           FXCH ST(1)
6684226B     D9F1           FYL2X
6684226D     D9E8           FLD1
6684226F     D9C1           FLD ST(1)
66842271     D9F8           FPREM
66842273     D9F0           F2XM1
66842275     DEC1           FADDP ST(1),ST
66842277     D9FD           FSCALE
66842279     D9C9           FXCH ST(1)
6684227B     DDD8           FSTP ST
6684227D     DD5D C0        FSTP QWORD PTR SS:[EBP-40]
66842280     D9D0           FNOP
66842282     DD45 E8        FLD QWORD PTR SS:[EBP-18]
66842285     DC4F F0        FMUL QWORD PTR DS:[EDI-10]
66842288     DC47 E0        FADD QWORD PTR DS:[EDI-20]
6684228B     D9FF           FCOS
6684228D     DC4D C0        FMUL QWORD PTR SS:[EBP-40]
66842290     DD5D C0        FSTP QWORD PTR SS:[EBP-40]	// FINISHED calculating newx, newy, newz
66842293     D9D0           FNOP	// okay I haven't put the code for Julia variation because I only took care of mset
66842295     D9D0           FNOP	// empty space...
66842297     D9D0           FNOP
66842299     D9D0           FNOP
6684229B     DD45 D0        FLD QWORD PTR SS:[EBP-30]	// room that contains newx. until now, ebx still contains old X. it's needed for Julia set.
6684229E     DC46 18        FADD QWORD PTR DS:[ESI+18]	// it is Cx, we add it
668422A1     DD1B           FSTP QWORD PTR DS:[EBX]	// finally save newx into X, okay
668422A3     90             NOP
668422A4     90             NOP
668422A5     DD45 C8        FLD QWORD PTR SS:[EBP-38]	// same for newy.
668422A8     DC46 20        FADD QWORD PTR DS:[ESI+20]
668422AB     DD1A           FSTP QWORD PTR DS:[EDX]
668422AD     90             NOP
668422AE     90             NOP
668422AF     DD45 C0        FLD QWORD PTR SS:[EBP-40]	// same for newz.
668422B2     DC46 28        FADD QWORD PTR DS:[ESI+28]
668422B5     DD19           FSTP QWORD PTR DS:[ECX]
668422B7     90             NOP
668422B8     90             NOP
668422B9     DDD8           FSTP ST	// but we left R into fp stack. this kills R.
668422BB     8BC3           MOV EAX,EBX	// restore old registers.
668422BD     5F             POP EDI	// restore old registers.
668422BE     5E             POP ESI	// restore old registers.
668422BF     5B             POP EBX	// restore old registers.
668422C0     8BE5           MOV ESP,EBP	// restore old registers.
668422C2     5D             POP EBP	// restore old registers.
668422C3     C2 0800        RETN 8	// goodbye!

//yer gonna set yer (You are going to set your) pixel values slightly differently this time around:

x_pixel_component_for_calculation = x_pixel - y_pixel - z_pixel;
y_pixel_component_for_calculation = y_pixel - x_pixel - z_pixel;
z_pixel_component_for_calculation = z_pixel - x_pixel - y_pixel;

// we do this for... various reasons.  Mainly, it looks cool, and gets us a lot more out of the fractal.

Another variation (less variety, but makes cool towers at the corners of the fractal):
x_pixel_component_for_calculation = sqrt( abs (x_pixel^2 - y_pixel^2 - z_pixel^2));
y_pixel_component_for_calculation = sqrt( abs (y_pixel^2 - x_pixel^2 - z_pixel^2));
z_pixel_component_for_calculation = sqrt( abs (z_pixel^2 - x_pixel^2 - y_pixel^2));

		//  this section assigns variables a and b
		b=pi/2;
		a=b^(3-n);    
		b=(n)*b;
		//////   This section does stuff.... iteration and suchlike...

		r1 = sqrt ( abs ( abs (sy) * sy + abs (sz) * sz ));  // sx set
		r2 = sqrt ( abs ( abs (sx) * sx + abs (sz) * sz ));  // sy
		r3 = sqrt ( abs ( abs (sx) * sx + abs (sy) * sy ));  // sz

		r = ( sqr (sx) + sqr (sy) + sqr (sz) );
			
		r4 = ( sqr (sx) * a + r ) ^ ( n / 2 );
		r5 = ( sqr (sy) * a + r ) ^ ( n / 2 );
		r6 = ( sqr (sz) * a + r ) ^ ( n / 2 );

		theta=	n * atan2	( abs (sx) * b + flip (r1) );     //flip (X) changes real number X to imaginary number X
		phi=		n * atan2	( abs (sy) * b + flip (r2) );     // in other words it multiplies by i
		tango=	n * atan2	( abs (sz) * b + flip (r3) );
			
		nx=	r4 * cos(theta);
		ny=	r5 * cos(phi);
		nz=	r6 * cos(tango);

		if (Change_Structure) {    //expands and changes structure a bit... not necessary but interesting
			if (n==2) {
				if (pixelr>0 && sx*b>r1) {
					nx=-nx;
				}
				if (pixeli>0 && sy*b>r2) {
					ny=-ny;
				}
				if (pixelj>0 && sz*b>r3) {
					nz=-nz;
				}
			} else if (n==3 || n==5 || n==7 || n==9) {
				if (pixelr>0 && sx>0) {
					nx=-nx;
				}
				if (pixeli>0 && sy>0) {
					ny=-ny;
				}
				if (pixelj>0 && sz>0) {
					nz=-nz;
				}
			}
		}
		if (juliaMode) {
			sx= nx + cr;	// Once again, cr is the x-axis Julia component
			sy= ny + ci;	// .... ci is the y-axis Julia component	
			sz= nz + cj;	// .... cj is the z-axis Julia component
		} else {
		sx = nx + (pixelr);		// Once again, pixelr is the x-axis Mandelbrot component
		sy = ny + (pixeli);		// .... pixeli is the y-axis Mandelbrot component
		sz = nz + (pixelj);		// ... pixelj is the z-axis Mandelbrot component
		}

		bail= sqr (sx) + sqr (sy) + sqr (sz);

			// pixel part set up
			//pixel_x= x part of pixel
			//pixel_y= y part of pixel
			//pixel_z= z part of pixel

			//rotation around y axis, no y rotation

			foxtrot=(90-54.7356)/180*pi;      //look up "magic angle"  54.7356 ...  it turns up a lot
			whiskey= cos((foxtrot));             //  sqrt(2/3)
			tango= sin((foxtrot));              // sqrt(1/3)

			pixel_x_temp= pixel_x  * whiskey - pixel_z * tango;    //  I use sx,sy,and sz as variables in my iterations
			sz= pixel_x  * tango     +  pixel_z * whiskey;        // along with temp variables nx,ny, and nz
				

			//rotation around z axis, no z rotation
			
			foxtrot=45/180*pi;
			whiskey= cos((foxtrot));       // in other words, both of these = sqrt(.5)    that's   sqrt ( 1/2 )
			tango= sin((foxtrot));        // just setting it up so you can see the rotation matrix
			
			sx= pixel_x_temp * whiskey - pixel_y * tango;
			sy= pixel_x_temp * tango     +  pixel_y * whiskey;

			// that's it for our initialization values for the pixels, we just need our values for the mag xyz portion
  
			   a= (pi/2)^(3-n)              //  n is of course the exponent of z^n
			   b= n * pi/2          // I sometimes use a different equation- this one is fine for now!!!

			r=(sqr(sx)+sqr(sy)+sqr(sz));
			r1=(sqr(sx)*a+r)^(n/2);    //  you can do different values of n for the different formulas
			r2=(sqr(sy)*a+r)^(n/2);   //   for now, let's just get this main one working
			r3=(sqr(sz)*a+r)^(n/2);    //  btw, here is where "a" is used
			r=sqrt(r);

			theta= atan2  (abs(sx)*b+flip(r));     // here is where "b" is used
			phi=  atan2     (abs(sy)*b+flip(r));
			tango=  atan2  (abs(sz)*b+flip(r));
			
			//  in this next section, I add in a "seed" value... USE -.5  for now!!!  negative point five!!!  :p

			sx=r1*cos(theta*pixeln)      + seed;     // use the same seed for all 3 of these values
			sy=r2*cos(phi*pixeln)     + seed;      //  -.5 is good, keep the seed the same so the fractal 
			sz=r3*cos(tango*pixeln)     + seed;   // does not get distorted

			//now we need to rotate all the components back towards the x-axis for our Mandy portion
			//We will rotate them the OPPOSITE direction than we did before, and in opposite order!!!

			//rotation around z axis, no z rotation
			foxtrot=-45/180*pi;
			whiskey= cos((foxtrot));     // sqrt(.5)
			tango= sin((foxtrot));        // -sqrt(.5)       NEGATIVE... they are not the same!!
			
			nx=sx*whiskey-sy*tango;
			sy=sx*tango+sy*whiskey;    // sy is done!!
			sx=nx;
			
			
			//rotation around y axis, no y rotation
			//whiskey=54.7356/180*pi;
			foxtrot=-(90-54.7356)/180*pi;    //negative!#!@
			whiskey= cos((foxtrot));      //sqrt(2/3)
			tango= sin((foxtrot));       //  - sqrt(1/3)    NEGATIVE!#!@#   RAAARRRRR!@$#!

			nx= sx  * whiskey - sz * tango;        
			sz= sx  * tango     +  sz * whiskey;
			sx=nx;
			

			//  we are totally rotated and ready for the Mandy portion of our 

			r2=(sqr(sx)+sqr(sy)+sqr(sz))^(n/2);
			
			theta=n* atan2((sx)+flip(sqrt(sqr(sy)+sqr(sz))));
			phi=n* atan2((sy)+flip((sz)));
								     // note that you don't have to divide the positive x_pixel by 2
			if (x_pixel>0) {x_pixel=x_pixel/2;}    // x_pixel is the x component of the pixel!!!!
			nx=r2*cos(theta)  + x_pixel;      //  .5 * x_pixel for the positive x axis!!! 
			      //or you need to do my detail switch
			    // otherwise there will be a section of elephant valley without details
			    //   note that using .5* x-pixel on the positive x axis simply reduces the 
			    // smooth singularity in the center of elephant valley, the detail switch eliminates it
			// detail switch:

			if (detail_switch) {
				if (n==2 || n==6) {
					if (pixel_x >0 && sx> sqrt(sqr(sy)+sqr(sz))) {
							nx=-nx;
						}
				} else if (n==3 || n==5  || n==7 || n==9)    {
					if (sx>0) {
							nx=-nx;
						}
				}
			} 
			sx=nx;
			sy=r2*cos(phi)*sin (theta);      //  for even n, switching the y and z parts makes a more
			sz=r2*sin(phi)*sin (theta);       //  symmetric fractal.. it's sort of cool, but I don't
								   //  know if it's better...   I'll post a couple images after this code
								  // you can add in all pixel components at this stage, but it's chaotic

				  //UPDATE:  I'd definite switch the y and z components, maybe make it optional
				  //UPDATE:  I like the symmetry it introduces- you still get TONS of interesting details
				  //UPDATE:  but they are more symmetric (less distorted)

			// time to rotate back towards our other axis of symmetry before we start out next iteration!!
			//we are doing this in the original order, with POSITIVE rotations!

			//rotation around y axis, no y rotation
			
			foxtrot=(90-54.7356)/180*pi;    //positive again        
			whiskey= cos((foxtrot));        //  sqrt(2/3)
			tango= sin((foxtrot));     //   sqrt(1/3)           totally positive... +++++++++
			
			nx= sx  * whiskey - sz * tango;
			sz= sx  * tango     +  sz * whiskey;
			sx=nx;
			
				//rotation around z axis, no z rotation
			foxtrot=45/180*pi;
			whiskey= cos((foxtrot));     //    sqrt(.5)
			tango= sin((foxtrot));    //  sqrt(.5)      ++++++++
			
			nx=sx*whiskey-sy*tango;
			sy=sx*tango+sy*whiskey;
			sx=nx;


			//   time to check bailout!!!!!!     
			bail= sx^2 + sy^2 +sz^2  

			//  if bail > bailout, it's outside of the fractal!!#!@#!
			//  if bail < bailout  &&  you've completed all of your iterations, it's inside!!!
			//  if bail < bailout  &&   you still are iterating, you need to plug 
			//  these new values into the iteration loop

// block for cutout.
parameter int iscuted;
parameter quaternion Ctaxis;
real autobailout, coordX, coordY, coordZ;

void init(void)
//block for cutout. An unelegant code.
autobailout=0;
coordX= real(Ctaxis);
coordY= imag(Ctaxis);
coordZ= part_j(Ctaxis);
if (iscuted == "Larger than") 
{
	if (coordX!=0 && real(pixel) > coordX )
	{
	autobailout= bailout +1;
	}
	if (coordY!=0 && imag(pixel) > coordY )
	{
	autobailout= bailout +1;
	}
	if (coordZ!=0 && part_j(pixel) > coordZ )
	{
	autobailout= bailout +1;
	}
}	
else if (iscuted == "Smaller than")
{
	if (coordX!=0 && real(pixel) < coordX )
	{
	autobailout= bailout +1;
	}
	if (coordY!=0 && imag(pixel) < coordY )
	{
	autobailout= bailout +1;
	}
	if (coordZ!=0 && part_j(pixel) < coordZ )
	{
	autobailout= bailout +1;
	}
}	

bool bailout(void)
return( cabs(z) + autobailout < bailout );


void description(void)
//block for a cutout.	 
separator.label2.caption  = "CUTS along NONZERO coordinates.";		
iscuted.caption="CUTTING";
iscuted.enum="None\nLarger than\nSmaller than";
iscuted.default= 0;
		
Ctaxis.caption ="Coordinates of cut";
Ctaxis.default= (0,0,0,0);
Ctaxis.visible = (iscuted=="Larger than" || iscuted=="Smaller than");

			
			//I decided to use a simpler version of the mag vs. xyz formula
			//  It turned out a bit nicer, and a bit quicker to calculate as well
			// REMEMBER THIS IS ONLY THE z^2 version, so      !!!!   mag_exponent=2    !!!

		d=(mag_exponent + mag_exponent_variable)^2;    //  mag_exponent_variable should default to 1

			//  decreasing the variable makes a spikier fractal, increasing it makes it flatter
			//  In my ChaosPro formula, I like setting d= mag_exponent  * 1.5   as well, for a 
			//  slightly more connected higher mag_exponent fractals
			//  so for n= 4, d=6   I suppose we could default to:
			//  d=(mag_exponent * 1.5 + mag_exponent_variable)^2  with the variable=0 if we wanted

		sx= x axis pixel value
		sy= y axis pixel value
		sz= z axis pixel value

		pixelr=x axis pixel value
		if (pixelr>0)  then  { pixelr = pixelr*.5 ; }

			whiskey= sqrt(2/3);      //this is our rotation for the x-z plane
			tango= sqrt(1/3); 

			nx= sx  * whiskey - sz * tango;
			sz= sx  * tango     +  sz * whiskey;
			sx=nx;

			whiskey=sqrt(.5);		// this is our rotation for the x-y plane
			
			nx= sx * whiskey - sy * whiskey;
			sy= sx * whiskey + sy * whiskey;
			sx=nx;

			sx=sx^2;
			sy=sy^2;
			sz=sz^2;
			r=sx+sy+sz;

			nx= (sx+r) * (d*sx-sy-sz) / (d*sx+sy+sz) + seed;  //seed should default to -.5
			ny= (sy+r) * (d*sy-sx-sz) / (d*sy+sx+sz) + seed;  // that is negative 1/2....
			sz= (sz+r) * (d*sz-sx-sy) / (d*sz+sx+sy) + seed;

			sx=nx;        // make sure you don't try to avoid this step!
			sy=ny;       // 

			whiskey= sqrt(.5); 			//time to rotate to the mandy!!!
			tango= -whiskey;  		// notice the negative in this one!
			
			nx=sx * whiskey -sy * tango;
			sy=sx * tango + sy * whiskey;
			sx=nx;
			

			whiskey= sqrt(2/3);  			
			tango= -sqrt(1/3);   			//notice the negative sqrt in this one?

			nx= sx  * whiskey - sz * tango;
			sz= sx  * tango    +  sz * whiskey;
			sx=nx;	

			// time for our Mandy calculation-  I've tried all kinds, this is the one I like most
			//  USE IT... IT is WAY BETTER!!@!#!@

			sx2=sx^2;   // don't need the additional variable- you can just square more than once
			sy2=sy^2;
			sz2=sz^2;
				
			nx=sx2-sy2-sz2;
			r3=2*sx/sqrt(sy2+sz2);   //as long as sy2+sz2 != 0  of course.... :D

			nz =r3*(sy2-sz2);    // NOTE THAT Y AND Z VALUES ARE SWITCHED!#!@$#!
			ny =r3*2*sy*sz;      // Best for z^2... and other n=even    but for odd n you  
						    //  want ny to be the first one and nz to be the second  (switch back)

			
			sx= nx + pixelr;		//  you might want to allow julia values to be added in
			sy= ny; 			//  as well-- and have the option of leaving out "pixelr"
			sz= nz;			//   if only using julia values

			//check bailout       sx^2+sy^2+sz^2.... etc.

Clock_of_Branches  {
  credits="Asdam1;10/3/2012/20/17"  commentTemplate="Saved on $month$\
  , $day$ $year$ at $hour$:$min$:$sec$\nDate: $date$\nTime: $time$\nR\
  esolution: $xdots$ x $ydots$\nCalculation time: $calctime$\nVersion\
  : $version$"
  CommentText="Saved on Oct, 7 2012 at 14:20:28\nDate: Oct 7, 2012\nT\
  ime: 14:20:28\nResolution: 480 x 360\nCalculation time: 00:05:29.22\
  4\nVersion: 4.0"
  creationTime=2012/10/3/20/17/28 saveTime=2012/10/7/14/20/28
  Creator="Asdam1" ModifiedBy="Asdam1" calcTime=329224 version=4.0
  Type=Quaternion Subtype=0 Width=480 Height=360 DisplayDepth=24
  gamma=+0.9 DOFEnabled=+1 DOFAperture=+0.125
  DOFFocalLength=+0.0776496875522733
  DOFPlaneDistance=+0.155299375104547 FogEnabled=+1 FogRed=220
  FogGreen=220 FogBlue=225 FogFront=+0.0640387280666078
  FogBack=+0.367712871807473 FogDensity=+3.01734853216892
  FogLinear=+0.05 FogSquare=+0.05 FogExp=+0.2
formula:
  filename="Mag xyz forms.cfm" entry="cp_85362" p_bailout=1e+020
  p_inversebailout=0 p_fractaltype="Mag Mandy 2 fast"
  p_colortime="Post Mandy Post Rotation" p_pixelmode="+ no abs"
  p_symmetrymode="YZ Switch     very nice" p_seed=-0.5 p_juliaMode=0
  p_Detail_Switch=0 p_bmode="Pi/2" p_checkvarset=2 p_amode="b^(3-n)"
  p_checkvarsetA=0.1 p_radswitch=0 p_n=2 p_pixeln=2 p_c=0/0/0/0
  p_addyzpixel=0 p_spokes=3 maxiter=8 highresmult=15 backtrace=10
inside:
  filename="NumberSeekerColouring.ccl" entry="LogTrichrome"
  p_pallete="Mixed Harmonic" p_posneg=0/0
  p_lgtype="4- Double logarithm" p_darkness=2 p_postfn="1- None"
  p_switchRB=1 p_baseR=1.35 p_baseG=1.55 p_baseB=1.65 solid=0
  background=0
dimensional:
  observer=0.09852919331003/-0.039523053619068/-1.0256463577236
  topview=0.036309924537838/0.94781697512594/-0.31674054215267
  viewpoint=-0.66014169536182/1.0138011158943/2.0393583267432
  backClippingPlane=3.3285493523157 viewangle=32
lighting:
  lightModel=0 light0Shadow=yes light1Enabled=yes light1Shadow=yes
gradient:
  smooth=yes colormodel=CM_RGB knotmode=all dragknotmode=global
  Offset=0 knotrgb=(8,252,164,80) knotrgb=(20,132,138,32)
  knotrgb=(30,80,118,200) knotrgb=(31,85,116,193)
  knotrgb=(59,252,4,0) knotrgb=(75,80,0,80) knotrgb=(79,84,0,85)
  knotrgb=(107,112,26,120) knotrgb=(109,100,28,107)
  knotrgb=(126,0,1,0) knotrgb=(127,5,0,0) knotrgb=(176,252,164,0)
  knotrgb=(187,252,252,0) knotrgb=(219,252,252,252)
  knotrgb=(220,252,252,248) knotrgb=(251,252,188,128)
}

Clock_of_Branches_2  {
  credits="Asdam1;10/3/2012/20/17"  commentTemplate="Saved on $month$\
  , $day$ $year$ at $hour$:$min$:$sec$\nDate: $date$\nTime: $time$\nR\
  esolution: $xdots$ x $ydots$\nCalculation time: $calctime$\nVersion\
  : $version$"
  CommentText="Saved on Nov, 4 2012 at 01:44:10\nDate: Nov 4, 2012\nT\
  ime: 01:44:10\nResolution: 480 x 360\nCalculation time: 00:02:07.11\
  8\nVersion: 4.0"
  creationTime=2012/10/3/20/17/28 saveTime=2012/11/4/1/44/10
  Creator="Asdam1" ModifiedBy="Asdam1" calcTime=127118 version=4.0
  Type=Quaternion Subtype=0 Width=480 Height=360 DisplayDepth=24
  gamma=+1.1 roughness=+0.03 AOIntensity=+0.4 DOFEnabled=+1
  DOFAperture=+0.125 DOFFocalLength=+0.0692849163391902
  DOFPlaneDistance=+0.13856983267838 FogEnabled=+1 FogRed=23
  FogGreen=21 FogBlue=137 FogFront=+0.0610336979595676
  FogBack=+0.35890555522641 FogDensity=+3.07612387515116
  FogLinear=+0.05 FogSquare=+0.05 FogExp=+0.2
formula:
  filename="Mag xyz forms.cfm" entry="cp_85362" p_bailout=77700000000
  p_inversebailout=0 p_fractaltype="Mag Mandy 2 fast"
  p_colortime="Post Mandy Post Rotation" p_pixelmode="+ no abs"
  p_symmetrymode="YZ Switch     very nice" p_seed=-0.5 p_juliaMode=0
  p_Detail_Switch=1 p_bmode="Pi/2" p_checkvarset=2 p_amode="b^(3-n)"
  p_checkvarsetA=0.1 p_radswitch=0 p_n=2 p_pixeln=2 p_c=0/0/0/0
  p_addyzpixel=0 p_spokes=3 maxiter=7 highresmult=10 backtrace=10
inside:
  filename="NumberSeekerColouring.ccl" entry="LogTrichrome"
  p_pallete="Fractal Explorer like" p_posneg=0/0
  p_lgtype="1- Triple logarithm" p_darkness=3 p_postfn="1- None"
  p_switchRB=0 p_baseR=1.35 p_baseG=1.55 p_baseB=1.65 solid=0
  background=0
dimensional:
  observer=0.09852919331003/-0.039523053619068/-1.0256463577236
  topview=-0.051677551569366/0.94569859380349/-0.32091057997811
  viewpoint=-0.49607723609472/0.98369642435929/2.0854540178502
  backClippingPlane=3.3285493523157 viewangle=36
lighting:
  lightModel=0 light0Shadow=yes light1Enabled=yes light1Shadow=yes
  light4Enabled=yes light4Shadow=yes
gradient:
  smooth=yes colormodel=CM_RGB knotmode=all dragknotmode=global
  Offset=0 knotrgb=(0,255,248,231) knotrgb=(43,128,0,64)
  knotrgb=(85,255,248,231) knotrgb=(127,255,120,70)
  knotrgb=(170,34,33,25) knotrgb=(214,165,217,0)
}

nx= 2*(abs(sx) + seed);   //  with seed around -.5   
ny= 2* (abs(sy)+seed);
nz=2* (abs(sz)+seed);

		// rotate to absolute value axis

			//rotation around y axis
			
			nx= sx  * whiskey -  sz * whiskey;
			sz= sx  * whiskey +  sz * whiskey;
			sx=nx;
			
			//rotation around z axis
			
			nx=sx * whiskey - sy * whiskey;
			sy=sx * whiskey + sy * whiskey;
			sx=nx;

		// ABS portion of the formula

			sx= 2* abs(sx) - 1;     // you can use different values besides 1,  it's a good arbitrary
			sy= 2* abs(sy) - 1;    // starting value... use the same value for all 3 variables!@!!
			sz= 2* abs(sz) - 1;    //  bloop
			
		// rotate back to Mandelbulb x-axis
			
			//rotation around z axis
			
			nx= sx* whiskey + sy*whiskey;
			sy=-sx* whiskey + sy*whiskey;
			sx=nx;
			
			//rotation around y axis
			
			nx= sx  * whiskey +  sz * whiskey;
			sz=-sx  * whiskey +  sz * whiskey;
			sx=nx;	

		// Here is the Mandelbulb part

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

			r1=sqrt(sqr(sy)+sqr(sz));   // for the angle

			theta=atan2((sx)+flip(r1))*n;
			phi=atan2((sy)+flip((sz)))*n;
				
			nx=r2*cos(theta);
			nz=(r2*cos(phi)*sin (theta));     // new z and new y are switched to
			ny=(r2*sin(phi)*sin (theta));   // make it more symmetric- I like it a bit more  

			if (Julia) {
					sx=nx + x_component;
					sy=ny + y_component;
					sz=nz + z_component;
			} else {
				if (x_pixel<0) {
					sx=nx + x_pixel_component;    // whole component below zero
				} else {
					sx=nx+ .5* x_pixel_component;  //  .5 * component above zero
				}

					sy=ny;   // no pixel components for these guys!!!
					sz=nz;
			}
					
// now check bailout, repeat iteration

			r1=1/sqrt(3);
			r2=(1-r1)*.5;
			nx=(sx+sy+sz)*r1;
			ny=r2*(sy-sz)+(sy-sx)*r1;
			sz=r2*(-sy+sz)+(sz-sx)*r1;
			sx=nx;
			sy=ny;
			
				 //rotation around x axis
	
			ny= -sy  * sqrt(1/2) + sz * sqrt(1/2);
			sz= +sy  * sqrt(1/2) + sz * sqrt(1/2);
			sy=ny;

// is more or less the same as:

			//rotation around z axis
			
			nx=sx * sqrt(1/2) + sy * sqrt(1/2);
			sy=-sx * sqrt(1/2) + sy * sqrt(1/2);
			sx=nx;

			//rotation around y axis

			nx= sx  * sqrt(2/3) +  sz * sqrt(1/3);
			sz= -sx  * sqrt(1/3) +  sz * sqrt(2/3);
			sx=nx;	

			
			
//  (as long as I did the correct rotation directions)