Welcome to Fractal Forums

rad2=0.5;
norm = x*x+y*y+z*z;
 while (iter<imax) {

   (*nfunc)++;

   r2 = x*x + y*y + z*z;

   if (r2 < rad2*rad2) {

    maxnorm = ((double) (abs(i+j) % 12))/11.0;
    iter=imax+1;

   }  else {

    x = x*1.7;
    y = y*1.7;
    z = z*1.7;
    r1 = x*x + (y-1.0)*(y-1.0) + z*z;

    x1 = 3.0 * x / r1;
    y1 = 3.0 * (y-1.0) / r1+1.9;
    z1 = 3.0 * z / r1;

    i = (int)round(x1);
    j = (int)round(z1);

      x = x1 - round(x1);
      y = y1;
      z = z1 - round(z1);

   }

   norm = x*x+y*y+z*z;

   iter++;
 }

 if (iter == imax) {iter = imax - 1;}

 *minnorm = maxnorm;
 return(iter);
}

//RiemannSphereMsltoe     Variation2---------------------------------- 
  //http://www.fractalforums.com/new-theories-and-research/another-way-to-make-my-riemann-sphere-'bulb'-using-a-conformal-transformation/
void RiemannSphereMsltoeV2Iteration(CVector3 &z, const cFractal *fractal)
{
  double rad2 = fractal->transformCommon.minR05; // radius variable, default = 0.5
  double r2 = z.x * z.x + z.y * z.y + z.z * z.z + 1e-061;
  if (r2 < rad2 * rad2)
  {
    if (fractal->transformCommon.functionEnabled)
      z *=  rad2 * ((r2 * 0.1) + 0.4) * 1.18 /r2; // smooth inside
  } // if internal smooth function is not enabled → z = z;
  else
  {
    z *= fractal->transformCommon.constantMultiplier222; //1.7; 1.7, 1.7 //1st scale variable, default vect3 (1.7, 1.7, 1.7)
    double r1 = z.x * z.x + (z.y-1.0)*(z.y-1.0) + z.z * z.z;// used to normalise about (0, -1, 0)
    CVector3 newZ = z;
    newZ.x = z.x / r1; //normalise
    newZ.y = (z.y - 1.0) / r1;
    newZ.z = z.z / r1;
    newZ *= fractal->transformCommon.scale3;// 2nd scale variable , default = double (3.0)
    z.x = newZ.x - round(newZ.x);
    z.y = newZ.y + fractal->transformCommon.offset105;// y offset variable, default = double (1.9);
    z.z = newZ.z - round(newZ.z);
  }
}
// Bailout setting range 1.0 to 2.4,

//RiemannSphereMsltoe     Variation2----------------------------------
  //http://www.fractalforums.com/new-theories-and-research/another-way-to-make-my-riemann-sphere-'bulb'-using-a-conformal-transformation/
void RiemannSphereMsltoeV2Iteration(CVector3 &z, const cFractal *fractal)
{
  double rad2; // radius default = 0.5
  double r2 = z.x * z.x + z.y * z.y + z.z * z.z;// r2 or point radius squared
  if (r2 < rad2 * rad2)
  {
    if (fractal->transformCommon.functionEnabled)// smooth inside
      z *=  rad2 * ((r2 * 0.1 * thickness factor) + 0.4 * thickness factor) * 1.18 * fudge factor /r2; // defaults = 1.0
  } // if internal smooth function is not enabled → z = z;
  else
  {
    double shift; //first offset default = 1.0
    z *= first scale; //1st scale variable, default vect3 (1.7, 1.7, 1.7),
    double r1 = z.x * z.x + (z.y-shift)*(z.y-shift) + z.z * z.z  + 1e-061;// r1 = length^2,
    CVector3 newZ = z;
    newZ.x = z.x / r1; //inversions by length^2
    newZ.y = (z.y - shift) / r1;
    newZ.z = z.z / r1;
    newZ *= second scale;// 2nd scale variable , default = double (3.0)
    z.x = newZ.x - round(newZ.x); // form of tiling,
    z.y = newZ.y + second shift ;// y offset variable, default = double (1.9);
    z.z = newZ.z - round(newZ.z);
  }
}

//RiemannBulbMsltoe Mod2----------------------------------
  //http://www.fractalforums.com/new-theories-and-research/another-way-to-make-my-riemann-sphere-'bulb'-using-a-conformal-transformation/
void RiemannBulbMsltoeMod2Iteration(CVector3 &z, int i, const cFractal *fractal)
{
  double rad2 = fractal->transformCommon.minR05; // radius default = 0.5
  double r2 = z.x * z.x + z.y * z.y + z.z * z.z;// r2 or point radius squared
  if (r2 < rad2 * rad2)
  {
    if (fractal->transformCommon.functionEnabled)
      z *= rad2 * ((r2 * 0.1) + 0.4) * 1.18 * fractal->transformCommon.scaleA1 /r2; // smooth inside
    else
    {
      z *= fractal->transformCommon.constantMultiplier111;
    }
  } // if internal smooth function is not enabled → z = z * scale, default vect3(1,1,1)
  else
  {
    z *= fractal->transformCommon.constantMultiplier222; //1st scale variable, default vect3 (1.7, 1.7, 1.7),

    double shift = fractal->transformCommon.offset1;
    double r1 = z.x * z.x + (z.y-shift)*(z.y-shift) + z.z * z.z  + 1e-061;// r1 = length^2,

    z.x = z.x / r1; // inversions by length^2
    z.y = (z.y - shift) / r1;
    z.z = z.z / r1;

    z *= fractal->transformCommon.scale3;// 2nd scale variable , default = double (3.0)
    z.y = z.y + fractal->transformCommon.offset105;// y offset variable, default = double (1.9);

    if (fractal->transformCommon.functionEnabledx)
    {
      z.x = z.x - round(z.x); // periodic cubic tiling,
      z.z = z.z - round(z.z);
    }
    if (fractal->transformCommon.functionEnabledxFalse)
    {
      z.x = fabs(sin(M_PI * z.x * fractal->transformCommon.scale1));
      z.z = fabs(sin(M_PI * z.z * fractal->transformCommon.scale1));
    }
  }
}

// original tiling
  x := x_tmp - Round(x_tmp);
  z := z_tmp - Round(z_tmp);

-->

// changed tiling
 else if Type_Tiling = 2 then
   begin
     x_diff := sin(x_tmp);
     z_diff := cos(z_tmp);
   end
		   
   .....
		   
 else if Type_PostCalc = 6 then
   begin
     tmp1 := x_diff*x_diff;
     SinCos(z_diff, stmp2, ctmp2);
     x := tmp1 + (1-ctmp2)/2;
     z := tmp1 + (1+stmp2)/2;
   end