File:Preimages of the circle under map f(z) = z*z+0.25.svg

From Wikimedia Commons, the free media repository
Jump to navigation Jump to search

Original file(SVG file, nominally 1,000 × 2,000 pixels, file size: 188 KB)



Add a one-line explanation of what this file represents


English: Preimages of the green circle under map . Preimages of the green circle from the interior gives level curves of the attracting time ( boundaries of the level sets). Green circle here is an attracting petal of the Leau–Fatou flower. Fixed point is on the circle and on the boundary of the Fatou set. Standard view is not readible so click on the image to see animation !! Reload ( refresh ) to see it again.
Date 16 March 2018
Source Own work
Author Adam majewski
Other versions
SVG development
W3C grn.svg The SVG code is valid.Gnuplot val.svg This plot was created with Gnuplot.


I, the copyright holder of this work, hereby publish it under the following license:
w:en:Creative Commons

attribution share alike

This file is licensed under the Creative Commons Attribution-Share Alike 4.0 International 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.
  • share alike – If you remix, transform, or build upon the material, you must distribute your contributions under the same or compatible license as the original.


  • start with the function : complex quadratic polynomial
  • compute fixed point
  • compute critical orbit ( orbit of the critical point ) which tend to the fixed point
  • take 2 points
    • fixed point
  • draw a circle
    • thru 2 points:
      • fixed point
      • last point of the critical orbit
    • with center in the midpoint of above points
  • draw preimages of critical point under our function
  • compute/draw preimaes of the circle under our function

Note :

  • there are 2 preimages

Green circle[edit]

  • Radius of the circle is equal to half of the distance between parabolic fixed point ( big blue dot) and last point of critical orbit ( black dots )
  • Center of the green circle is a midpoint between above 2 points

Gray curves[edit]

  • gray curves are preimages of green circle
  • preimages
  • go to the left ( from fixed point to the critical point = along critical orbit in the reverse direction) until meet the critical point
  • then closed curve is splitted to the curve which join red points ( preimage of critical point and it's symmetric point)
  • all preimages tend to the fixed point from the right

Maxima CAS src code[edit]


Batch file for Maxima CAS
save as a o.mac
run maxima : 
and then : 


/* ---------- functions ---------------------- */

/*  */

/* Forward iteration */


/* find fixed point alfa of function f(z,c)   */
GiveFixed(c):= float(rectform((1-sqrt(1-4*c))/2))$

converts complex number z = x*y*%i 
to the list in a draw format:  
d(z):=[float(realpart(z)), float(imagpart(z))]$

/* give Draw List from one point*/

/* gives an orbit of z0 under fc where iMax is the length of the orbit */
 GiveForwardOrbit(z0,c, iMax):= block
  [i,z, orbit],
   orbit :[d(z)],
   while ( i<iMax ) 
      orbit : endcons(d(z), orbit),

/* gives an orbit of z0 under fc where iMax is the length of the orbit */
 GiveBackwardOrbit(z0,c, iMax):= block
  [i,z,  orbit],
   orbit :[],
   z : z0,
   while ( i<iMax ) 
      orbit : cons(d( z), orbit),
      orbit : cons(d(conjugate(z)), orbit),

 point of the unit circle D={w:abs(w)=1 } where w=l(t) 
 t is angle in turns 
 1 turn = 360 degree = 2*Pi radians 
l(t):= float(rectform(%e^(%i*t*2*%pi)));

/* circle point */
cl(center, radius_, t) := float(rectform(center + radius_*l(t)));

/* here t is a real number */
GiveCircleArc(center, _radius, tmin, tmax, n):=block(
  [t, dt, list],
  dt : (tmax - tmin)/n,
  /* add first turn */
  t : tmin,
  z: cl(center,  _radius, t),
  list : [z],
  /* add arc turns */
  while t < tmax do 
    ( t: t + dt,
      z: cl(center,  _radius, t),
      list : endcons(z, list)),

/* slimming the list 

only between iMin and  iMax
iMin : angle =1/4
iMax : angle = 3/4

SlimList(MyList, n):=block(
	[NewList, iMax, iMin, l], 
	l : length(MyList),
	iMin: l*0.2,
	iMax: l*0.8,
	for i:1 thru l step 1 do 
		(if (i>iMin and i<iMax) 
			then (if (mod(i,n)=0) then  NewList:endcons(MyList[i],NewList))
			else NewList:endcons(MyList[i],NewList)
	NewList : endcons(last(MyList), NewList),





/* variables */

zcr : 0; 


/* computations */

zf : GiveFixed(c) $

critical_orbit : GiveForwardOrbit(zcr, c, 100)$
precritical : GiveBackwardOrbit(zcr, c, 100)$

/* compute attracting petals */ 

last ( here)  attracting petal is a circle  with:
*  center on the x axis 
* radius = distance between last point of critical orbit and fixed point 
 = ( cabs(zf) + cabs(z))/2 where z is the last point of critical orbit
so in other words circle whic passes thru zl and zf

Method by Scott Sutherland:[31]

choose the connected component containing the critical point
find an analytic curve which lies entirely in the Fatou set, has the right tangency property at the fixed point, and is mapped into its interior by the correct power of the map

z_l : last(critical_orbit)[1];
radius_l : (zf - z_l)/2;
center_l : z_l+ radius_l;


smallest attracting petal is a circle
under inverse iteration circle ( closed curve ): 
"Circles are split because of the branch cut along the imaginary axis"

start from 1/2 !!! not zero
this is the point where circle is splitted


p0 :  GiveCircleArc( center_l, radius_l,   1/2, 3/2, jMax)$

p60 : p0$
for i: 1  thru 60  step 1 do p60 : map(b, p60)$

p70 : p60$
for i: 1  thru 10  step 1 do p70 : map(b, p70)$

p80 : p70$
for i: 1  thru 10  step 1 do p80 : map(b, p80)$
p81 : map (b, p80)$
p82 : map (b, p81)$
p83 : map (b, p82)$
p84 : map (b, p83)$
p85 : map (b, p84)$
p86 : map (b, p85)$
p87 : map (b, p86)$
p88 : map (b, p87)$
p89 : map (b, p88)$
p90 : map (b, p89)$

p91 : map(b, p90)$
p92 : map(b, p91)$
p93 : map(b, p92)$

p94 : map(b, p93)$

p95 : map(b, p94)$

p96 : map(b,p95)$

p97 : map(b,p96)$

p98 : map(b,p97)$
p99 : map(b,p98)$

trick : 
change first point of the list 
from origin to slightly below 
now it is different from last !!!
= split closed curve 
p99[1]: -4.424164545328475E-7*%i$

p100 : map (b, p99)$
p101 : map (b, p100)$
p102 : map (b, p101)$
p103 : map (b, p102)$
p104 : map (b, p103)$
p105 : map (b, p104)$
p106 : map (b, p105)$
p107 : map (b, p106)$
p108 : map (b, p107)$
p109 : map (b, p108)$
p110 : map (b, p109)$
p111 : map (b, p110)$
p112 : map (b, p111)$
p113 : map (b, p112)$
p114 : map (b, p113)$
p115 : map (b, p114)$

/* make lists smaller */

p0: SlimList(p0, 500)$
p80: SlimList(p80,500)$
p81: SlimList(p81,500)$
p82: SlimList(p82,500)$
p83: SlimList(p83,500)$
p84: SlimList(p84,500)$
p85: SlimList(p85,500)$
p86: SlimList(p86,500)$
p87: SlimList(p87,500)$
p88: SlimList(p88,500)$
p89: SlimList(p89,500)$
p90: SlimList(p90,500)$
p91: SlimList(p91,500)$
p92: SlimList(p92,500)$
p93: SlimList(p93,500)$
p94: SlimList(p94,500)$
p95: SlimList(p95,500)$
p96: SlimList(p96,500)$
p97: SlimList(p97,500)$
p98: SlimList(p98,100)$
p99: SlimList(p99,100)$
p100: SlimList(p100,100)$
p101: SlimList(p101,100)$
p102: SlimList(p102,500)$
p103: SlimList(p103,500)$
p104: SlimList(p104,500)$
p105: SlimList(p105,500)$
p106: SlimList(p106,500)$
p107: SlimList(p107,500)$
p108: SlimList(p108,500)$
p109: SlimList(p109,500)$
p110: SlimList(p110,500)$
p111: SlimList(p111,500)$
p112: SlimList(p112,500)$
p113: SlimList(p113,500)$
p114: SlimList(p114,500)$
p115: SlimList(p115,500)$

/* to draw format */

p0 : map(d, p0)$
p60: map (d, p60)$
p70: map (d, p70)$
p80: map (d, p80)$
p81: map (d, p81)$
p82: map (d, p82)$
p83: map (d, p83)$
p84: map (d, p84)$
p85: map (d, p85)$
p86: map (d, p86)$
p87: map (d, p87)$
p88: map (d, p88)$
p89: map (d, p89)$
p90: map (d, p90)$
p91 : map(d, p91)$
p92 : map(d, p92)$
p93 : map(d, p93)$
p94 : map(d, p94)$
p95 : map(d, p95)$
p96 : map(d, p96)$
p97 : map(d, p97)$
p98 : map(d, p98)$
p99 : map(d, p99)$
p100 : map(d, p100)$
p101 : map(d, p101)$
p102 : map(d, p102)$
p103 : map(d, p103)$
p104 : map(d, p104)$
p105 : map(d, p105)$
p106 : map(d, p106)$
p107 : map(d, p107)$
p108 : map(d, p108)$
p109 : map(d, p109)$
p110 : map(d, p110)$
p111 : map(d, p111)$
p112 : map(d, p112)$
p113 : map(d, p113)$
p114 : map(d, p114)$
p115 : map(d, p115)$

/* ---------------- draw ------------------------------- */

path:"~/maxima/batch/julia/parabolic/1over1/circle_preimages/c4/small/s2/"$ /*  if empty then file is in a home dir , path should end with "/" */

/* draw it using draw package by */

/* if graphic  file is empty (= 0 bytes) then run draw2d command again */

  user_preamble="set key top right; unset mouse",
  terminal  = 'svg,
  file_name = sconcat(path,"s", string(jMax)),
  title= "Preimages of the circle  for f(z) = z^2 +1/4",
  dimensions = [1000, 2000],
  yrange = [-0.75, 0.75],
  xrange = [0, 0.75],
    xlabel     = "zx ",
  ylabel     = "zy",
  point_type = filled_circle,
  points_joined =true,
  point_size    =  0.1,

  color         = green,
  key="green circle",
  color         = gray,
  key = "",
  here not drawn because of  dense image 
  /* points(p80),
  key = "preimages of the green circle",
  point_size    =  0.5,
  points_joined =false,
  key = "images of critical point",
  color         = black,

  key = "preimages of critical point",
  color         = red,
  /*  big points */ 
  point_size    =  1.1,
  key= "fixed point",
  color = blue,
  key= "critical point",
  color = black,


The size of svg image is to big.

"I simply opened the file in a text editor to see what's wrong with it and edited it down to the current version with regex substitutions. Of course regexes can be a bit tricky and the older version of the file is so slow to render that I didn't check for deviations as thoroughly as I should have." TilmannR

"The text editor I used was Notepad++[1], but that's not particularly relevant.

I don't remember each individual pattern I used, but the main culprit definitely were lines like <use xlink:href='#gpPt6' transform='translate(600.3,998.2) scale(0.45)' color='rgb(190, 190, 190)'/>. There are 12141 of those, each about 100 characters long, so approximately 1.2 MB in total. A short regex for that is e.g. <use[^>]*190, 190, 190\)'/>, but the real solution to superfluous elements is to not generate them at all. Apparently it's possible to avoid generating points by setting their point_type to -1. If I was more familiar with Maxima, I'd fix the script, but I'm not, so I won't.: TilmannR (talk) 21:03, 19 May 2018 (UTC)

File history

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

current06:27, 19 May 2018Thumbnail for version as of 06:27, 19 May 20181,000 × 2,000 (188 KB)TilmannR (talk | contribs)Fixed the fixed point color, Increased circle radii by .5
12:42, 16 May 2018Thumbnail for version as of 12:42, 16 May 20181,000 × 2,000 (187 KB)TilmannR (talk | contribs)reduced file size
08:46, 14 April 2018Thumbnail for version as of 08:46, 14 April 20181,000 × 2,000 (1.44 MB)Adam majewski (talk | contribs)smaller size
20:16, 8 April 2018Thumbnail for version as of 20:16, 8 April 20181,000 × 2,000 (3.09 MB)JoKalliauer (talk | contribs)reduced file size
12:46, 17 March 2018Thumbnail for version as of 12:46, 17 March 20181,000 × 2,000 (4.02 MB)Adam majewski (talk | contribs)<80 not drawn, dense
17:14, 16 March 2018Thumbnail for version as of 17:14, 16 March 20181,000 × 2,000 (3.27 MB)Adam majewski (talk | contribs)User created page with UploadWizard

File usage on other wikis

The following other wikis use this file: