Size of this preview: 600 × 600 pixels. Other resolutions: 240 × 240 pixels | 480 × 480 pixels | 1,000 × 1,000 pixels.

Original file ‎(1,000 × 1,000 pixels, file size: 161 KB, MIME type: image/jpeg)

This is a file from the Wikimedia Commons. The description on its description page there is shown below.
Commons is a freely licensed media file repository. You can help.

DescriptionJulia0bb.jpg	Fatou sets for $f_{0}(z)=z*z\,$ .
Date	24 November 2008
Source	self-made using C console program.
Author	Adam majewski
Permission (Reusing this file)	This file is licensed under the Creative Commons Attribution 3.0 Unported license. You are free: to share – to copy, distribute and transmit the work to remix – to adapt the work Under the following conditions: attribution – You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use. CC BY 3.0 Creative Commons Attribution 3.0 truetrue
Other versions	logical pattern Dynamical plane for c=0.35 Image Julia IIM 6 circle.png - binary decomposition

This math image could be re-created using vector graphics as an SVG file. This has several advantages; see Commons:Media for cleanup for more information. If an SVG form of this image is available, please upload it and afterwards replace this template with {{vector version available|new image name}}.

It is recommended to name the SVG file “Julia0bb.svg”—then the template Vector version available (or Vva) does not need the new image name parameter.

This math image was uploaded in the JPEG format even though it consists of non-photographic data. This information could be stored more efficiently or accurately in the PNG or SVG format. If possible, please upload a PNG or SVG version of this image without compression artifacts, derived from a non-JPEG source (or with existing artifacts removed). After doing so, please tag the JPEG version with {{Superseded|NewImage.ext}} and remove this tag. This tag should not be applied to photographs or scans. If this image is a diagram or other image suitable for vectorisation, please tag this image with {{Convert to SVG}} instead of {{BadJPEG}}. If not suitable for vectorisation, use {{Convert to PNG}}. For more information, see {{BadJPEG}}.

Compare with

Binary fractal images by Mark Dow ^[1]

Comment

This image shows part of dynamical plane ( z-plane ) under iteration of points using function $f_{c}(z)=z*z+c\,$ . Here z-plane consists of 2 sets:

Julia set ( circle of radius =1 and center = 0 ) which contain repeling fixed point ( red)
Fatou set, which consist of 2 subsets:
- A(infinity)=basin of attration of infinity ( infinity is allways superattracting fixed point for polynomials )
- A(0) = basin of attraction of finite attractor ( here is z=0 which is also here superattracting finite fixed point ).

Made with binary decomposition of basins of both ( finite and infinite) attractors :

Finite is $z=\alpha _{0}=0\,$
infinite attractor is point at infinity.

Fixed points :

Green point is a superattracting fixed point $z=\alpha _{0}=0\,$ ,
red point is repelling fixed point $z=\beta _{0}=1\,$ .

Compare it with Fig.31 on page 42 of Peitgen, Richter "The beauty of fractals".

C source code

It is a console C program ( one file) It can be compiled under :

windows ( gcc thru Dev-C++ )
linux and mac using gcc :

gcc main.c -lm

it creates a.out file. Then run it :

./a.out

It creates ppm file in program directory. Conversion to jpg is made with convert from ImageMagic

 /* 
 c program:
  1. draws Fatou set for Fc(z)=z*z 
  using  binary decomposition
 -------------------------------         
 2. technic of creating ppm file is  based on the code of Claudio Rocchini
 http://en.wikipedia.org/wiki/Image:Color_complex_plot.jpg
 create 24 bit color graphic file ,  portable pixmap file = PPM 
 see http://en.wikipedia.org/wiki/Portable_pixmap
 to see the file use external application ( graphic viewer)
 ---------------------------------
 */
 #include <stdio.h>
 #include <stdlib.h> /* for ISO C Random Number Functions */
 #include <math.h>
 /*  gives sign of number */
 double sign(double d)
 {
       if (d<0)
       {return -1.0;}
       else {return 1.0;};
 };
 /* ----------------------*/
 int main()
 {   
    const double Cx=0.0,Cy=0.0;
     /* screen coordinate = coordinate of pixels */      
    int iX, iY, 
        iXmin=0, iXmax=2000,
        iYmin=0, iYmax=2000,
        iWidth=iXmax-iXmin+1,
        iHeight=iYmax-iYmin+1,
        /* 3D data : X , Y, color */
        /* number of bytes = number of pixels of image * number of bytes of color */
        iLength=iWidth*iHeight*3,/* 3 bytes of color  */
        index; /* of array */
    int iXinc, iYinc,iIncMax=6;     
    /* world ( double) coordinate = parameter plane*/
    const double ZxMin=-2.5;
    const double ZxMax=2.5;
    const double ZyMin=-2.5;
    const double ZyMax=2.5;
    /* */
    double PixelWidth=(ZxMax-ZxMin)/iWidth;
    double PixelHeight=(ZyMax-ZyMin)/iHeight;
    double Zx, Zy,    /* Z=Zx+Zy*i   */
           Z0x, Z0y,  /* Z0 = Z0x + Z0y*i */
           Zx2, Zy2, /* Zx2=Zx*Zx;  Zy2=Zy*Zy  */
           NewZx, NewZy,
           DeltaX, DeltaY,
           SqrtDeltaX, SqrtDeltaY,
           AlphaX, AlphaY,
           BetaX,BetaY, /* repelling fixed point Beta */
           AbsLambdaA,AbsLambdaB;
          /*  */
        int Iteration,
            IterationMax=100,
            iTemp;
     /* bail-out value , radius of circle ;  */
    const int EscapeRadius=400;
    int ER2=EscapeRadius*EscapeRadius;
    double AR=PixelWidth, /* minimal distance from attractor = Attractor Radius */
           AR2=AR*AR,
           d,dX,dY; /*  distance from attractor : d=sqrt(dx*dx+dy*dy) */
        /* PPM file */
    FILE * fp;
    char *filename="julia00bb_.ppm";
    char *comment="# this is julia set for c= ";/* comment should start with # */
    const int MaxColorComponentValue=255;/* color component ( R or G or B) is coded from 0 to 255 */
    /* dynamic 1D array for 24-bit color values */    
    unsigned char *array;
    /*  ---------  find repelling fixed point ---------------------------------*/
   /* Delta=1-4*c */
   DeltaX=1-4*Cx;
   DeltaY=-4*Cy;
   /* SqrtDelta = sqrt(Delta) */
   /* sqrt of complex number algorithm from Peitgen, Jurgens, Saupe: Fractals for the classroom */
   if (DeltaX>0)
   {
    SqrtDeltaX=sqrt((DeltaX+sqrt(DeltaX*DeltaX+DeltaY*DeltaY))/2);
    SqrtDeltaY=DeltaY/(2*SqrtDeltaX);        
    }
    else /* DeltaX <= 0 */
    {
         if (DeltaX<0)
         {
          SqrtDeltaY=sign(DeltaY)*sqrt((-DeltaX+sqrt(DeltaX*DeltaX+DeltaY*DeltaY))/2);
          SqrtDeltaX=DeltaY/(2*SqrtDeltaY);        
          }
          else /* DeltaX=0 */
          {
           SqrtDeltaX=sqrt(fabs(DeltaY)/2);
           if (SqrtDeltaX>0) SqrtDeltaY=DeltaY/(2*SqrtDeltaX);
                        else SqrtDeltaY=0;    
                   }
    };
   /* Beta=(1-sqrt(delta))/2 */
   BetaX=0.5+SqrtDeltaX/2;
   BetaY=SqrtDeltaY/2;
   /* Alpha=(1+sqrt(delta))/2 */
   AlphaX=0.5-SqrtDeltaX/2;
   AlphaY=-SqrtDeltaY/2;
   AbsLambdaA=2*sqrt(AlphaX*AlphaX+AlphaY*AlphaY);
   AbsLambdaB=2*sqrt(BetaX*BetaX+BetaY*BetaY);
   printf(" Cx= %f\n",Cx);
   printf(" Cy= %f\n",Cy); 
   printf(" Beta= %f , %f\n",BetaX,BetaY);
   //printf(" BetaY= %f\n",BetaY);
   printf(" Alpha= %f, %f\n",AlphaX,AlphaY);
   //printf(" AlphaY= %f\n",AlphaY);
   printf(" abs(Lambda (Alpha))= %f\n",AbsLambdaA);
   printf(" abs(lambda(Beta))= %f\n",AbsLambdaB);
   /* initial value of orbit Z=Z0 is repelling fixed point */
   Zy=BetaY; /*  */
   Zx=BetaX; 
   /*-------------------------------------------------------------------*/
    array = malloc( iLength * sizeof(unsigned char) );
    if (array == NULL)
    {
      fprintf(stderr,"Could not allocate memory");
      getchar();
      return 1;
    }
    else 
    {         
      /* fill the data array with white points */       
      for(index=0;index<iLength-1;++index) array[index]=255;
      /* ---------------------------------------------------------------*/
      for(iY=0;iY<iYmax;++iY)
      {
          Z0y=ZyMin + iY*PixelHeight; /* reverse Y  axis */
             if (fabs(Z0y)<PixelHeight/2) Z0y=0.0; /*  */    
         for(iX=0;iX<iXmax;++iX)
         {    /* initial value of orbit Z0 */
             
              Z0x=ZxMin + iX*PixelWidth;
              /* Z = Z0 */
              Zx=Z0x;
              Zy=Z0y;
              Zx2=Zx*Zx;
              Zy2=Zy*Zy;
             /* */
             for (Iteration=0;Iteration<IterationMax && ((Zx2+Zy2)<ER2);Iteration++)
                    {
                        Zy=2*Zx*Zy + Cy;
                        Zx=Zx2-Zy2 +Cx;
                        Zx2=Zx*Zx;
                        Zy2=Zy*Zy;
                    };
           iTemp=((iYmax-iY-1)*iXmax+iX)*3;        
           /* compute  pixel color (24 bit = 3 bajts) */
           if (Iteration==IterationMax)
                    { /*  interior of Filled-in Julia set  =  */
                          /* Z = Z0 */
                          Zx=Z0x;
                          Zy=Z0y;
                          Zx2=Zx*Zx;
                          Zy2=Zy*Zy;
                          dX=Zx-AlphaX;
                            dY=Zy-AlphaY;
                            d=dX*dX+dY*dY;
                         for (Iteration=0;Iteration<IterationMax && (d>AR2);Iteration++)
                        {
                            Zy=2*Zx*Zy + Cy;
                            Zx=Zx2-Zy2 +Cx;
                            Zx2=Zx*Zx;
                            Zy2=Zy*Zy;
                            dX=Zx-AlphaX;
                            dY=Zy-AlphaY;
                            d=dX*dX+dY*dY;
                        };
                         /* */
                           if (Zy>AlphaY) 
                           { 
                             array[iTemp]=0; /* Red*/
                             array[iTemp+1]=0;  /* Green */ 
                             array[iTemp+2]=0;/* Blue */
                           }
                           else 
                           {
                             array[iTemp]=255; /* Red*/
                             array[iTemp+1]=255;  /* Green */ 
                             array[iTemp+2]=255;/* Blue */    
                           };                      
                        }
               else 
                 /* exterior of Filled-in Julia set  */
              /*  */
                       if (Zy>0) 
                       { 
                         array[iTemp]=0; /* Red*/
                         array[iTemp+1]=0;  /* Green */ 
                         array[iTemp+2]=0;/* Blue */
                       }
                       else 
                       {
                         array[iTemp]=255; /* Red*/
                         array[iTemp+1]=255;  /* Green */ 
                         array[iTemp+2]=255;/* Blue */    
                       };                      
   /* check the orientation of Z-plane */
               /* mark first quadrant of cartesian plane*/     
             //  if (Z0x>0 && Z0y>0) array[((iYmax-iY-1)*iXmax+iX)*3]=255-array[((iYmax-iY-1)*iXmax+iX)*3];  
     }
    } 
 /* draw fixed points ----------------------------------------------------*/             
 /* translate from world to screen coordinate */
  iX=(AlphaX-ZxMin)/PixelWidth;
  iY=(AlphaY-ZxMin)/PixelHeight; /*  */
  /* plot  big green pixel = 6 pixel wide */
  for(iYinc=-iIncMax;iYinc<iIncMax;++iYinc){
    for(iXinc=-iIncMax;iXinc<iIncMax;++iXinc)
    { 
    iTemp=((iYmax-iY-1+iYinc)*iXmax+iX+iXinc)*3;                                          
    array[iTemp]=0;
    array[iTemp+1]=255;
    array[iTemp+2]=0;  
    }
 }
  /* translate from world to screen coordinate */
  iX=(BetaX-ZxMin)/PixelWidth;
  iY=(BetaY-ZyMin)/PixelHeight; /*  */
  /* plot  big green pixel = 6 pixel wide */
  for(iYinc=-iIncMax;iYinc<iIncMax;++iYinc){
    for(iXinc=-iIncMax;iXinc<iIncMax;++iXinc)
    {  
    iTemp=((iYmax-iY-1+iYinc)*iXmax+iX+iXinc)*3;
    array[iTemp]=255;
    array[iTemp+1]=0;
    array[iTemp+2]=0;  
    }
    }          
 /* write the whole data array to ppm file in one step ----------------------- */      
      /*create new file,give it a name and open it in binary mode  */
      fp= fopen(filename,"wb"); /* b -  binary mode */
      if (fp == NULL){ fprintf(stderr,"file error"); }
            else
            {
            /*write ASCII header to the file*/
            fprintf(fp,"P6\n %s\n %d\n %d\n %d\n",comment,iXmax,iYmax,MaxColorComponentValue);
            /*write image data bytes to the file*/
            fwrite(array,iLength ,1,fp);
            fclose(fp);
            fprintf(stderr,"file saved");
            getchar();
            }
    free(array);
    return 0;
    } /* if (array ..  else ... */
 }

References

↑ Binary fractal images by Mark Dow

File history

Click on a date/time to view the file as it appeared at that time.

	Date/Time	Thumbnail	Dimensions	User	Comment
current	09:26, 11 June 2011		1,000 × 1,000 (161 KB)	Soul windsurfer	I have made 10 000 x 10 000 ppm image and resized with Image Magic : convert b1.ppm -resize 1000x1000 b.jpg
	15:39, 24 January 2008		2,000 × 2,000 (618 KB)	Soul windsurfer	{{Information \|Description= Fatou set for F(z)=z*z. Made with binary decomposition of basins of both ( finite and infinite) attractors. Finite is z=Alpha=0, infinite attractor is point at infinity. \|Source=self-made using C console program. \|Date=24.11.2

File usage

The following 2 pages use this file:

Global file usage

The following other wikis use this file:

Metadata

This file contains additional information, probably added from the digital camera or scanner used to create or digitize it.

If the file has been modified from its original state, some details may not fully reflect the modified file.

_error	0

[1] Binary fractal images by Mark Dow

[1]

File:Julia0bb.jpg

Contents

Compare with

Comment

C source code

References

Captions

Items portrayed in this file

depicts

creator

some value

copyright status

copyrighted

copyright license

Creative Commons Attribution 3.0 Unported

inception

24 November 2008

File history

File usage

Global file usage

Metadata