Welcome to Fractal Forums

void IdesIteration(CVector3 &z)
{
    double x2 = z.x * z.x;
    double y2 = z.y * z.y;
    double z2 = z.z * z.z;
    double newx = x2 - 0.5 * (y2 + z2) + z.x;
    double newy = 2.0 * z.x * z.y * z.z + z.y;
    double newz = z2 - 0.5 * (x2 + y2) + z.z;
    z.x = newx;
    z.y = newy;
    z.z = newz;
}

void Ides2Iteration(CVector3 &z, CVector3 &c)
{
    double x2 = z.x * z.x;
    double y2 = z.y * z.y;
    double z2 = z.z * z.z;
    double newx = x2 - 0.5 * (y2 + z2) + c.x;
    double newy = 2.0 * z.x * z.y * z.z + c.y;
    double newz = z2 - 0.5 * (x2 + y2) + c.z;
    z.x = newx;
    z.y = newy;
    z.z = newz;
}

void BuffaloIteration(CVector3 &z)
{
     double x2 = z.x * z.x;
     double y2 = z.y * z.y;
     double z2 = z.z * z.z;
     double temp = 1.0 - z2 / (x2 + y2);
     double newx = (x2 - y2) * temp;
     double newy = 2.0 * z.x * z.y * temp;
     double newz = -2.0 * z.z * sqrt(x2 + y2);
     z.x = fabs(newx);
     z.y = newy;
     z.z = fabs(newz);
}

void Buffalo2Iteration(CVector3 &z, CVector3 &c)
{
     double x2 = z.x * z.x;
     double y2 = z.y * z.y;
     double z2 = z.z * z.z;
     double temp = 1.0 - z2 / (x2 + y2);
     double newx = (x2 - y2) * temp;
     double newy = 2.0 * z.x * z.y * temp;
     double newz = -2.0 * z.z * sqrt(x2 + y2);
     z.x = fabs(newx + c.x);
     z.y = newy + c.y;
     z.z = fabs(newz + c.z);
}

/* http://www.fractalforums.com/3d-fractal-generation/another-shot-at-the-holy-grail/ */
void QuickDudleyIteration(CVector3 &z)
{
    double x2 = z.x * z.x;
    double y2 = z.y * z.y;
    double z2 = z.z * z.z;
    double newx = x2 - 2 * z.y * z.z;
    double newy = z2 + 2 * z.x * z.y;
    double newz = y2 + 2 * z.x * z.z;
    z.x = newx;
    z.y = newy;
    z.z = newz;
}

/* http://www.fractalforums.com/3d-fractal-generation/another-shot-at-the-holy-grail/ */
void LkmitchIteration(CVector3 &z)
{
    double x2 = z.x * z.x;
    double y2 = z.y * z.y;
    double z2 = z.z * z.z;
    double newx = x2 - 2 * z.y * z.z;
    double newy = z2 + 2 * z.x * z.y;
    double newz = y2 - 2 * z.x * z.z;
    z.x = newx;
    z.y = newy;
    z.z = newz;
}

/* Makin3D-2 found through the another shot at the holy grail topic at ff */
void Makin3D2Iteration(CVector3 &z)
{
    double x2 = z.x * z.x;
    double y2 = z.y * z.y;
    double z2 = z.z * z.z;
    double newx =  x2 + 2 * z.y * z.z;
    double newy = -y2 - 2 * z.x * z.z;
    double newz = -z2 + 2 * z.x * z.y;
    z.x = newx;
    z.y = newy;
    z.z = newz;
}

void BuffaloIteration3(CVector3 &z)
{
     double x2 = z.x * z.x;
     double y2 = z.y * z.y;
     double z2 = z.z * z.z;
     double temp = 1.0 - z2 / (x2 + y2);
     double newx = (x2 - y2) * temp;
     double newy = 2.0 * z.x * z.y * temp;
     double newz = -2.0 * z.z * sqrt(x2 + y2);
     z.x = fabs(newx);
     z.y = fabs(newy);
     z.z = fabs(newz);
}

Menger4IFS(x,y,z,w){
   r=x*x+y*y+z*z;
   for(i=0;i<MI && r<bailout;i++){

      x=abs(x);y=abs(y);z=abs(z);w=abs(w);
      if(x-y<0){x1=y;y=x;x=x1;}
      if(x-z<0){x1=z;z=x;x=x1;}
      if(y-z<0){y1=z;z=y;y=y1;}
      if(x-w<0){x1=w;w=x;x=x1;}
      if(y-w<0){x1=w;w=y;y=x1;}
      if(z-w<0){y1=w;w=z;z=y1;}

      rotate4D(x,y,z,w);

      x=scale*x-CX*(scale-1);
      y=scale*y-CY*(scale-1);
      w=scale*w-CW*(scale-1);
      z-=0.5*CZ*(scale-1)/scale;
      z=-abs(-z);
      z+=0.5*CZ*(scale-1)/scale;
      z=scale*z;
      
      r=x*x+y*y+z*z;
   }
   return sqrt(x*x+y*y+z*z)*scale^(-i);
}

float Sierpinski4(vec4 z)
{
	float r;
	
	int n = 0;
	while (n < Iterations) {

		// This is the hyper-tetraedral folding
		if(z.x+z.y<0.0) z.xy = -z.yx;
		if(z.x+z.z<0.0) z.xz = -z.zx;
		if(z.y+z.z<0.0) z.zy = -z.yz;
		if(z.x+z.w<0.0) z.xw = -z.wx;
		if(z.y+z.w<0.0) z.yw = -z.wy;
		if(z.z+z.w<0.0) z.zw = -z.wz;
		Rotate4D (z,Angles4D); // <- placed by me to make it a "true" KIFS
		
		z = z*Scale - Offset4*(Scale-1.0);		
		n++;
	}
	
	return sqrt(x*x+y*y+z*z)*scale^(-i);
}

MixPinski4(x,y,z,w){
   r=x*x+y*y+z*z;
   for(i=0;i<MI && r<bailout;i++){

      if(z.x+z.y<0.0) z.xy = -z.yx;
      if(z.x+z.z<0.0) z.xz = -z.zx;
      if(z.y+z.z<0.0) z.zy = -z.yz;
      if(z.x+z.w<0.0) z.xw = -z.wx;
      if(z.y+z.w<0.0) z.yw = -z.wy;
      if(z.z+z.w<0.0) z.zw = -z.wz;

      rotate4D(x,y,z,w);

      x=scale*x-CX*(scale-1);
      y=scale*y-CY*(scale-1);
      w=scale*w-CW*(scale-1);
      z-=0.5*CZ*(scale-1)/scale;
      z=-abs(-z);
      z+=0.5*CZ*(scale-1)/scale;
      z=scale*z;
      
      r=x*x+y*y+z*z;
   }
   return sqrt(x*x+y*y+z*z)*scale^(-i);
}

float Octahedron4(vec4 z)
{
	// ... See Sierpinski4 until folding then

		// This is the hyper-octaedral folding
     		x=abs(x);y=abs(y);z=abs(z);w=abs(w);
      		if(x-y<0){x1=y;y=x;x=x1;}
      		if(x-z<0){x1=z;z=x;x=x1;}
      		if(y-z<0){y1=z;z=y;y=y1;}
        // ... fold w like in Menger4 ... and finally
	// ... See Sierpinski4
}

x = X_add - abs(x)
y = Y_add - abs(y)
z = Z_add - abs(z)
rr = x*x + y*y + z*z
if rr < sqr(Min_R) then m = Scale/sqr(Min_R) else
if rr < 1 then m = Scale/rr else m = Scale
x = x * m + Cx
y = y * m + Cy
z = z * m + Cz

Scale = Scale + Scale_vary*(abs(Scale)-1)
x = Fold-abs(abs(x+FoldXM)-Fold)-abs(FoldXM)
y = Fold-abs(abs(y+FoldYM)-Fold)-abs(FoldYM)
z = Fold-abs(abs(z+FoldZM)-Fold)-abs(FoldZM)
// rr = pow(x*x + y*y + z*z + w*w, R_power) <- removed to speedup
if rr < sqr(Min_R) then m = Scale/sqr(Min_R) else
if rr < 1 then m = Scale/rr else m = Scale
x = x * m + Cy
y = y * m + Cx
z = z * m + Cz

switch (fractal->formula)
		{
			case mandelbulb:
			{
				bulbAux[sequence].r = r;
				MandelbulbIteration(z, fractal, bulbAux[sequence]);
				break;
			}
                }
//addition of constant
		switch(fractal->formula)
		{
			case menger_sponge:
			case kaleidoscopicIFS:
			case aexion:
			{
				break;
			}
			default:
			{
				if(in.common.juliaMode)
				{
					z += in.common.juliaC;
				}
				else
				{
					z += c * in.common.constantMultiplier;
				}
				break;
			}
		}