internal level sets

Color of point  :

• is proportional to the value of z is at final iteration.
• shows internal level sets of periodic attractors.

bof60

Image of bof60 in on page 60 in the book "the Beauty Of Fractals".Description of the method described on page 63 of bof. It is used only for interior points of the Mandelbrot set.

Color of point is proportional to :

• the smallest distance of its orbit from origin^[9][10]
• the smallest value z gets during iteration ^[11]
• illuminating the closest approach the iterates of the origin (critical point) make to the origin inside the set
• "Each pixel of each particular video frame represents a particular complex number c = a + ib. For each sequential frame n, the magnitude of z(c,n) := z(c, n-1)^2 + c is displayed as a grayscale intensity value at each of these points c: larger magnitude points are whiter, smaller magnitudes are darker. As n rises from 1 to 256, points outside the Mandelbrot Set quickly saturate to pure white, while points within the Mandelbrot Set oscillate through the darker intensities." Brian Gawalt ^[12]

Level sets of distance are sets of points with the same distance^[13]

if (Iteration==IterationMax)
 /* interior of Mandelbrot set = color is proportional to modulus of last iteration */
 else { /* exterior of Mandelbrot set = black */
  color[0]=0;
  color[1]=0;
  color[2]=0;                           
 }

• fragment of code : fractint.cfrm from Gnofract4d ^[14]

bof60 {
 init:
       float mag_of_closest_point = 1e100
 loop:
       float zmag = |z|
       if zmag < mag_of_closest_point
               mag_of_closest_point = zmag
       endif
 final:
       #index = sqrt(mag_of_closest_point) * 75.0/256.0
}

bof61 or atom domains

Full description

• 
  animation
• 
  3D view of bof61
• 
  2D view of BOF61

computing

For periods:^[20]

• 1 to 3 explicit equations can be used^[21]
• >3 it must be find using numerical methods

 c+(w/2)^2-w/2=0;

(%i1) eq1:c+(w/2)^2-w/2=0;
                                                                                                              2
                                                                                                             w    w
(%o1)                                                                                                        -- - - + c = 0
                                                                                                             4    2
(%i2) solve(eq1,w);
(%o2)                                                                                        [w = 1 - sqrt(1 - 4 c), w = sqrt(1 - 4 c) + 1]
(%i3) s:solve(eq1,w);
(%o3)                                                                                        [w = 1 - sqrt(1 - 4 c), w = sqrt(1 - 4 c) + 1]
(%i4) s:map(rhs,s);
(%o4)                                                                                            [1 - sqrt(1 - 4 c), sqrt(1 - 4 c) + 1]

 w = w(c) =  1.0 - csqrt(1.0-4.0*c)

 w = 4.0*c + 4;

 ${\displaystyle c^{3}+2c^{2}-(w/8-1)c+(w/8-1)^{2}=0}$

(%i1) e1:c^3 + 2*c^2 - (w/8-1)*c + (w/8-1)^2 = 0;

                      3      2        w       w     2
(%o1)                c  + 2 c  + (1 - -) c + (- - 1)  = 0
                                      8       8
(%i2) solve(e1,w);
(%o2) [w = (- 4 sqrt((- 4 c) - 7) c) + 4 c + 8, w = 4 sqrt((- 4 c) - 7) c + 4 c + 8]

complex double AproximateMultiplierMap(complex double c, int period, double eps2, double er2){
     
     complex double z;  // variable z 
     complex double zp ; // periodic point 
     complex double zcr = 0.0; // critical point
     complex double d = 1;
     
     int p;
     
     // first find periodic point
     zp =  GivePeriodic( c, zcr, period,  eps2, er2); // Find periodic point z0 such that Fp(z0,c)=z0 using Newton's method in one complex variable
     
     // Find w by evaluating first derivative with respect to z of Fp at z0 
     if ( cabs2(zp)<er2) {
     
     
     z = zp;
     for (p=0; p < period; p++){
        d = 2*z*d; /* first derivative with respect to z */
        z = z*z +c ; /* complex quadratic polynomial */
     
     }}
     else d= 10000; //

return d;
}

Internal angle

interior of Mandelbrots set coloured with radial angle

Method by Renato Fonseca :^[22] "a point c in the set is given a hue equal to argument

${\displaystyle arg(z_{n_{max}})=arctan{\frac {Im(z_{n_{max}})}{Re(z_{n_{max}})}}}$

(scaled appropriatly so that we end up with a number in the range 0 - 255). The number z_nmax is the last one calculated in the z's sequence. "

Internal rays

• 
  Internal and external rays
• 
  multiplier map and internal rays
• 
  internal and external rays

When ${\displaystyle radius\,}$ varies and ${\displaystyle angle\,}$ is constant then ${\displaystyle c\,}$ goes along internal ray ^[24]. It is used as a path inside Mandelbrot set

 
double complex Give_c(double t, double r, int p){
	/* 
	 input : 
	InternalRadius = r in [0,1] 
  	InternalAngleInTurns = t in range [0,1]
  	p = period
  	
  	output = c = complex point of 2D parameter plane  
  	*/
  	

	complex double w = 0.0;
	complex double c = 0.0;
	
	t = t*2*M_PI; // from turns to radians
  	// point of unit circle
  	w = r* cexp(I*t);
  		
	// map circle to component
	switch (p){
	
	case 1: c = (2.0*w - w*w)/4.0; break;
	case 2: c = (w -4.0)/ 4.0; break;
  
	}
	return c; 
}

/* find c in component of Mandelbrot set 
 uses complex type so #include <complex.h> and -lm 
 uses code by Wolf Jung from program Mandel
 see function mndlbrot::bifurcate from mandelbrot.cpp
 http://www.mndynamics.com/indexp.html

  */
double complex GiveC(double InternalAngleInTurns, double InternalRadius, unsigned int period)
{
  //0 <= InternalRay<= 1
  //0 <= InternalAngleInTurns <=1
  double t = InternalAngleInTurns *2*M_PI; // from turns to radians
  double R2 = InternalRadius * InternalRadius;
  double Cx, Cy; /* C = Cx+Cy*i */
  switch ( period ) {
    case 1: // main cardioid
      Cx = (cos(t)*InternalRadius)/2-(cos(2*t)*R2)/4; 
      Cy = (sin(t)*InternalRadius)/2-(sin(2*t)*R2)/4; 
      break;
   case 2: // only one component 
      Cx = InternalRadius * 0.25*cos(t) - 1.0;
      Cy = InternalRadius * 0.25*sin(t); 
      break;
  // for each period  there are 2^(period-1) roots. 
  default: // safe values
      Cx = 0.0;
      Cy = 0.0; 
    break; }

  return Cx+ Cy*I;
}

// draws points to memmory array data
int DrawInternalRay(double InternalAngleInTurns , unsigned int period, int iMax, unsigned char data[])
{

   complex double c;
   double InternalRadius;
   double RadiusStep; // between radius of points 
   int i; // number of point to draw
      
  RadiusStep = 1.0/iMax;
   
  for(i=0;i<=iMax;++i){ 
   InternalRadius = i * RadiusStep;
   c = GiveC(InternalAngleInTurns, InternalRadius, period);
   DrawPoint(c,data);
  }

return 0;
}

Example : internal ray of angle =1/6 of main cardioid.

Internal angle :

${\displaystyle angle=1/6\,}$

radius of ray :

${\displaystyle 0\leq radius\leq 1\,}$

Point of internal radius of unit circle :

${\displaystyle w=radius*e^{i*angle}\,}$

Map point ${\displaystyle w}$ to parameter plane :

${\displaystyle c={\frac {w}{2}}-{\frac {w^{2}}{4}}\,}$

For ${\displaystyle epsilon=0\,}$ this is equation for main cardioid.

Internal curve

When ${\displaystyle radius\,}$ is constant varies and ${\displaystyle angle\,}$ varies then ${\displaystyle c\,}$ goes along internal curve.

/* find c in component of Mandelbrot set 
 uses complex type so #include <complex.h> and -lm 
 uses code by Wolf Jung from program Mandel
 see function mndlbrot::bifurcate from mandelbrot.cpp
 http://www.mndynamics.com/indexp.html
*/
double complex GiveC(double InternalAngleInTurns, double InternalRadius, unsigned int period)
{
  //0 <= InternalRay<= 1
  //0 <= InternalAngleInTurns <=1
  double t = InternalAngleInTurns *2*M_PI; // from turns to radians
  double R2 = InternalRadius * InternalRadius;
  double Cx, Cy; /* C = Cx+Cy*i */
  switch ( period ) {
    case 1: // main cardioid
      Cx = (cos(t)*InternalRadius)/2-(cos(2*t)*R2)/4; 
      Cy = (sin(t)*InternalRadius)/2-(sin(2*t)*R2)/4; 
      break;
    case 2: // only one component 
      Cx = InternalRadius * 0.25*cos(t) - 1.0;
      Cy = InternalRadius * 0.25*sin(t); 
      break;
    // for each period  there are 2^(period-1) roots. 
    default: // safe values
      Cx = 0.0;
      Cy = 0.0; 
    break;
  }

  return Cx+ Cy*I;
}

// draws points to memory array data
int DrawInternalCurve(double InternalRadius , unsigned int period,  int iMax, unsigned char data[])
{
  complex double c;
  double InternalAngle; // in turns = from 0.0 to 1.0
  double AngleStep;
  int i;
  // int iMax =100;
   
  AngleStep = 1.0/iMax;
   
  for (i=0; i<=iMax; ++i) { 
    InternalAngle = i * AngleStep;
    c = GiveC(InternalAngle, InternalRadius, period);
    DrawPoint(c,data);
  }

  return 0;
}

Centers of components

• definition
• Methods of finding centers