Welcome to Fractal Forums

  


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...).

  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);

r2=(sqr(sx)+sqr(sy)+sqr(sz))^(n/2);
			
			theta=atan2(sx+flip(sy));
			tango=atan2(sx+flip(sz)); 
			if ((sy+sz)<0) {     //  this statement really doesn't do anything noticeable... you can scratch it
			whiskey=atan2(sx-flip(sqrt(sqr(sy)+sqr(sz))));
			} else {
			whiskey=atan2(sx+flip(sqrt(sqr(sy)+sqr(sz))));
			}

			nx=r2*cos(whiskey*v);
			ny=r2*sin(theta*v);
			nz=r2*sin(tango*v);
			
			 if (juliaMode) {
			  sx=nx+cr;
			 sy=ny+ci;
			 sz=nz+cj;
			} else {
			 sx=nx+(pixelr);
			 sy=ny+(pixeli);
			 sz=nz+(pixelj);
			}
			z=quaternion (sx,sy,sz,0);
			bail=abs(sx)+abs(sy)+abs(sz);

r2=(sqr(sx)+sqr(sy2)+sqr(sz2))^(n/2);

theta=atan2(sx+flip(sy));
whiskey=atan2(sx+flip(sz));
tango=atan2(sx+flip(sqrt(sy2^2+sz2^2)));
foxtrot=atan2(sy2+flip(sz2));

nx=r2*cos(tango*v);
ny=r2*sin(theta*v);
nz=r2*sin(whiskey*v);
ny2=r2*cos(foxtrot*v)*sin(tango*v);
nz2=r2*sin(foxtrot*v)*sin(tango*v);

if (juliaMode) {
	sx=nx+cr;
	sy=ny+ci;
	sz=nz+cj;
	sy2=ny2+ci;
	sz2=nz2+cj;
} else {
	sx=nx+(pixelr);
	sy=ny+abs(pixeli);
	sz=nz+(pixelj);
	sy2=ny2+abs(pixeli);
	sz2=nz2+(pixelj);
}
	
bail=abs(sx)+abs(sy)+abs(sz);
z=quaternion(sx,sy,sz,0);   // just for ChaosPro orbital coloring scheme

r2=(sx^2+sy^2+sz^2)^(n/2);
theta=atan2(sx+flip(sqrt(sz^2+sy^2)));
phi=atan2(sy+flip(sz));
			
nx=r2*cos(v*theta);
ny=r2*sin(v*theta)*cos(v*phi);
nz=r2*sin(v*theta)*sin(v*phi);
			
			
if (juliaMode) {
	sx=nx+cr;
	sy=ny+ci;
	sz=nz+cj;
} else {
	sx=nx+(pixelr);
	sy=ny+abs(pixeli);
	sz=nz+(pixelj);
	}
z=quaternion(sx,sy,sz,0);
bail=sx^2+sy^2+sz^2;

flip(x) = 0 + ix

atan2(x + flip(y)) = atan2(x + iy) = arctan2(y,x)

theta = arctan2(sqrt(sz^2+sy^2),sx)
phi = arctan2(sz,sy)

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

theta=atan2(sx+flip(sqrt(sqr(sy)+sqr(sz))));
					

phi=atan2(abs(sy)+flip(abs(sz))); 
  or 
phi=atan2 (sy+flip(sz));  // makes nice images as well... I suppose it's the absolute value of the pixel components?

   	nx=r2*cos(theta*v);
	ny=r2*sin(theta*v)*cos(phi*v);
	nz=r2*sin(theta*v)*sin(phi*v);

	if (juliaMode) {
		sx=nx+cr;
		sy=ny+ci;
		sz=nz+cj;
	} else {
		sx=nx+(pixelr);
		sy=ny+abs(pixeli);  // absolute value is your friend
		sz=nz+abs(pixelj);  // 
	}
z=quaternion(sx,sy,sz,0);
bail=sx^2+sy^2+sz^2;

	r1=sqrt(sqr(sy)+sqr(sz));
	r3=r1^(-n);   // take it to the -n so you don't have to divide by r3, as it can equal zero for the first iteration

	victor=complex(sx,r1);
	bravo=complex(sy,sz);  
	victor=victor^n;    // for higher powers, set up a script if n= integer powers for each n so
	bravo=bravo^n;   //  for  n=4   bravo^4 = sqr(sqr(bravo))     ||   for n=6 bravo^6 = sqr(bravo)*sqr(sqr(bravo))
			 
	nx=real(victor);
	ny=imag(victor)*real(bravo)*r3;  // since r3=r1^-n you don't have to divide here.. good if r3=0
	nz=imag(victor)*imag(bravo)*r3; 

	if (juliaMode) {
		sx=nx+cr;
		sy=ny+ci;
		sz=nz+cj;		
	} else {
		sx=nx+(pixelr);
		sy=ny+(pixeli);  // take the abs(pixeli) for a more uniform fractal, although the distortion of the even n
		sz=nz+(pixelj);	//  z^2,4,6....  is to be expected considering the asymmetry of the 2d set for even n
	}
	z=quaternion(sx,sy,sz,0);  //this is not part of the calculation, it just feeds information to ChaosPro's orbital color scheme
	bail=abs(sx)+abs(sy)+abs(sz);		

	r1=sqrt(sqr(sy)+sqr(sz)+sqr(sk));
	r2=sqrt(sqr(sz)+sqr(sk));
	r3=r1^(-n);
	r4=r2^(-n);

	victor=complex(sx,r1);
	bravo=complex(sy,r2);
	cramden=complex(sz,sk);
	victor=victor^n;
	bravo=bravo^n;
	cramden=cramden^n;
			
	nx=part_r(victor);
	ny=part_i(victor)*part_r(bravo)*r3;
	nz=part_i(victor)*part_i(bravo)*r3*part_r(cramden)*r4;
	nk=part_i(victor)*part_i(bravo)*r3*part_i(cramden)*r4;

	if (juliaMode) {
		sx=nx+cr;
		sy=ny+ci;
		sz=nz+cj;
		sk=nk+ck;
	} else {
		sx=nx+(pixelr);
		sy=ny+abs(pixeli);
		sz=nz+abs(pixelj);
		sk=nk+abs(pixelk);
	}
	z=quaternion(sx,sy,sz,sk);
	bail=abs(sx)+abs(sy)+abs(sz)+abs(sk);