complex not so complex

[puntopunto]

PART 1A
(Somehow I am unable to upload larger files, so, sorry, I try it this way)

Already  a year ago I wrote in a post somewhere on this forum:
"You arrived at your formula, taking a complicated route, but it is a very simple and logic formula. No need for complex function theory. This is one example. If I have some time I will show some more."
Now is the time.
This is a simple formula:

        P is the point with coordinates (x,y) and
   f(x,y)=|x|/(x^2+y^2),y/( x^2+y^2) with
   |x|=Abs(x)=
   x if x>=0 and -x if x<0
f maps the left half plane on the right half  and divides both coordinates by the square of the distance from point (x,y) to (0,0). Or saying otherwise it invert the point in the unit circle. So f is a  fold to the right with folding line  the y-axes, followed by the circle inversion in the unit circle.
This is the M-set:



Doesn't look very promising. But look to some results from Julia sets:





The inner square is inside. Augmenting the maximum iterations from 100 to 500 gives this:



The inside of the Julia sets from this and the formulas that follows are very sensitive for the number of iterations. You can find interesting structures by incrementing, but often also by decrementing the max. iterations.
Here is a third one:



This picture is made using the inside "smooth" colouring algorithm. With the standard colouring algorithm you see nothing. With the often used exponential colouring you see just chaos. So choosing colouring algorithms is essential. Other colouring algorithms could give also nice results. For instance:



There are more patterns of this kind to find in this Julia set. They very strongly look like variations of   generalizations of the Koch curve.
By now you might  be curious about other possibilities of this formula. In my member gallery, in the UF part there are about 35 pictures (more to come). All made with this formula or with some logical extensions of it.
I discovered this formula, together with some of the formulas that I will show later,  about 15 years ago, using Fractint.  Here is an translation in Ultra Fractal. Even if you are not interested in the formula, please, read the comments in the formula. They are fundamental for this post.

Code:

fold right {
;by JosHendriks. First in Fractint about 1998. Translated  in Ultrafractal 2012
;
; The formulas act on points, complex number terminology is not used. Although
; complex number and point are completely inter exchangeable, there are advantages
; using points: First fractal creating is essentially geometrically. Second it is
; demystifying, certainly for people without knowledge of complex function theory.
; Thirdly: as soon as you use complex functions you are tempted to do everything
; with z, z^2, exp(z) etc. And not defining maps that acts on the real and imaginary
; parts of the numbers. Moreover the few predefined functions has names that hide
; there geometrical meaning. Flip and complex conjugation are just reflections.
; The cabs function consist of two folds.
;
; The following fractal formula consist of one fold, followed by the
; circle inversion in the unit circle.
; "Folds" maps half the plane on the other half. They are defined by one line.
; That line could be horizontally, vertically or skew. In this formula there is one parameter for the ;position of a vertical line.
;The circle inversion maps
; points inside the circle outside and points outside the circle inside the circle.
; It divides the x- and y-coordinate of a point by the square of the distance of
; that point to the point (0,0).

global:
import "jhe.ulb"

init:
point mandelstart= new point(real(#pixel),imag(#pixel))
; This should be the only line of code, where complex number terminology is visible.
; Necessary because of the default type complex in ultra fractal. We use this point
; for the final addition (translation) in the loop.
;
point p= new point(mandelstart.x,mandelstart.y)
; The point p is a copy of the point mandelstart. It is used in the loop. Results of
; functions (methods) are stored in p. So the final result of each loop is point p.

loop:
 point.fold_r(p,@vertical_line)
: The real  parameter "vertical_line" defines the position of the vertical fold line. Default is 0 ( the line x=0).
 point.circle_inversion(p)
 point.add(p,mandelstart)
; adds the point p to  mandelstart. You can also say translate p over the vector mandelstart.
; The functions fold_r, circle_inversion and add (UF terminology "methods")are
; defined in the class "point"
; You can find them in de file jhe.ulb.
; They acts on the point p. They don't return a value. They change the value of
; the x- and y-coordinate of p (in de formulas represented by p.x and p.y)

 z=p.x+1i*p.y
; This line of code you need for the coloring functions. They expect a complex number
; with the name z. Later I will adept the coloring algoritms. Then this line is no
; longer needed

 bailout:		
point.squarenorm(p)<16
; squarenorm is also defined in the file jhe.ulb. It returns the square of the distance of p to the origin (0,0).

switch:       		
  type = "julia_fold_right"
  seed=#pixel
       		
default:
  title="fold right"
  float param vertical_line
  caption="vertical line x="
  default=0.0
  endparam
}

Thinking geometrically (points, lines, circles, reflections, rotations etc. ) a first extension of the folding along x=0 is to change the position of the fold line. Thus this first formula already has  one parameter. It defines a horizontal fold line x=a.
Here is a comparison of one Julia set which comes from several folding lines:




Top left is a Julia for the fold along x=0. The others are folds along x=a with a between 0 and  -2. All have the same seed.
As you see, it "adds" possibilities.
If you can fold to the right, then you can also fold to the left.  And up and down. But as expected, the collection of the Julia sets are the same. They only are rotated. Finally we can fold skew left and skew right. 
Combining two or more of these folds gives a fascinating scala of possibilities. So I wrote a fairly general formula. Here it is:

Code:

folding_general_1 {
; By Jos Hendriks. First in Fractint about 1998. Translated and extended in Ultrafractal 2012/2013
: See also for comments the formula "right_fold".

global:
import "jhe.ulb"
 ;In this file are the several kinds of folds: left, right, up, down, skew left, skew right, defined.
; For more information see the formula right_fold

init:
point mandelstart= new point(real(#pixel),imag(#pixel))
; the point mandelstart is used for the final translation in the loop
point p= new point(real(#pixel),imag(#pixel))
;p is a copy of mandelstart. It is used in the loop. The final result of the loop is also stored in point p.
if @flag5==1
float phi_r=@angle_r*#pi/180
point q_r=new point(@q1_r,@q2_r)
;there are six parameters named flag. They define if a fold is used or not. 1 means used.
;flag 5 and 6 are for skew folds. They are defined by the parameter phi_r and phi_l, which gives an angle with the positive x-axes and point q_r and q_l on the folding lines
endif
if @flag6==1
float phi_l=@angle_l*#pi/180
point q_l=new point(@q1_l,@q2_l)
endif
loop:
 if    @flag1==1
       point.fold_r(p,@f1)
       endif
       if @flag2==1
       point.fold_l(p,@f2)
       endif
       if @flag3==1
       point.fold_u(p,@f3)
       endif
       if @flag4==1
       point.fold_d(p,@f4)
       endif
;parameters f1,....f4 defines the position of the folding lines.
        if @flag5==1
       point.fold_skew_r(p,q_r,phi_r)
       endif
       if @flag6==1
       point.fold_skew_l(p,q_l,phi_l)
       endif
        point.circle_inversion(p)
;Finally the point p is inverted in the unit circle.
 point.translate(p,mandelstart)
  z=p.x+1i*p.y
; This line of code is necessary for using colouring algorithms.
 
bailout:		
point.squarenorm(p)<16
       		
switch:
                type = "julia_folding_general_1"
                seed=#pixel
                flag2=flag2
                flag1=flag1
                flag3=flag3
                flag4=flag4
                flag5=flag5
                flag6=flag6
                f1=f1
                f2=f2
                f1=f1
                f2=f2
                f3=f3
                f4=f4
                angle_r=angle_r
                q1_r=q1_r
                q2_r=q2_r
                angle_l=angle_l
                q1_l=q1_l
                q2_l=q2_l

default:
  title = "folding_general_1"

  heading
  text="1 for including the specified fold"
  endheading

   int param flag1
    caption = "right fold"
    default=1
    hint="1 for including a fold\
    to the right"
  endparam

   int param flag2
    caption = "left fold"
    default=0
  endparam
  
    int param flag3
    caption = "fold up"
    default=0
  endparam
  
      int param flag4
    caption = "fold down"
    default=0
  endparam
  
      int param flag5
    caption = "fold skew r"
    default=0
  endparam
  
      int param flag6
    caption = "fold skew l"
    default=0
  endparam
 heading
 text="lines for horizontal and vertical folds"
 endheading
  float param f1
    caption = "foldline right "
    default=0
    endparam

  float param f2
    caption = "foldline left "
    default=0
  endparam

  float param f3
    caption = "foldline up "
    default=0
    endparam

  float param f4
    caption = "foldline down "
    default=0
  endparam
 heading
 text="fold skew right"
 endheading
  float param angle_r
caption="angle line r"
default=45.0
endparam
float param q1_r
caption="x point"
default=1.0
endparam
float param q2_r
caption="y point"
default=1.0
endparam
heading
 text="fold skew left"
 endheading
  float param angle_l
caption="angle line r"
default=45.0
endparam
float param q1_l
caption="x point"
default=1.0
endparam
float param q2_l
caption="y point"
default=1.0
endparam
}

The Julia code is as usual.

[puntopunto]

POST 1B

Here some typical results. You can see many more in my gallery Ultra Fractal II

Combining left/right fold with an up fold can give Julia's , partly consisting of straight, parallel lines:





Filled and unfilled polygons:






Bifurcations are central:



As many patterns as you wish:







These kind of patterns can change completely just by augmenting the number of iterations by 1.

[puntopunto]

PART 1C

You can spend a lifetime finding "tree" variations:






In this complete Julia set you can see ground and figure, both having some meaning. Like in the art of Escher.

All sort of fractals related to the Pascal triangle fractals, the Koch, Minkofski, Sierpinski and other IFS fractals:









You can go wild:



Or create valentine cards:



Below the code of the jhe.ulb file.
There I define a class "point" and several functions acting on those points. My programming experience is not very much. So there might be improvements possible. I would like to have functions that actually returns points. So if somebody has a straightforward solution I would be happy. Anyway, every comment that can improve the code is welcome.
As soon as I am satisfied with the code I will upload the files to the Ultra Fractal  database.
In my next post I will introduce a second large class of fractals with folding.

P.s: the first formula in the thread "a very simple formula", consist of the left fold with folding line x=0 and one "fold up" with folding line y=0, followed by the unit circle inversion. It is not the simplest possibility. Only making one fold, to the right, gives about the same possibilities.  And there is still another simplification possible. About that later.

Code:

 class point {
public:

     func point(float aX, float aY)
     x = aX
     y = aY
     endfunc
     
     static float func norm(point p)
     return sqrt(p.x*p.x+p.y*p.y)
     endfunc


     static float func squarenorm(point p)
     return p.x*p.x+p.y*p.y
     endfunc
     
     static float func distance(point p, point q)
     return sqr((p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y))
     endfunc
     
     static float func squaredistance(point p, point q)
     return (p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y)
     endfunc
     
     static func translate(point p, point q)
     p.x=p.x+q.x
     p.y=p.y+q.y
     endfunc
     
     static func add(point p, point q)
     p.x=p.x+q.x
     p.y=p.y+q.y
     endfunc
     
     static func substract(point p, point q)
     p.x=p.x-q.x
     p.y=p.y-q.y
     endfunc
     
     static func square(point p)
     point newp=new point(p.x*p.x-p.y*p.y,2*p.x*p.y)
     p.x=newp.x
     p.y=newp.y
     endfunc
     
     static func multiply(point p, point q)
     point newp=new point(p.x*q.x-p.y*q.y,p.x*q.y+p.y*q.x)
     p.x=newp.x
     p.y=newp.y
     endfunc
     
     static func stretch_circ(point p, float r)
     p.x=r*p.x
     p.y=r*p.y
     endfunc
     
     static func stretch_h(point p, float r)
     p.x=abs(r)*p.x
     endfunc
     
     static func stretch_v(point p, float r)
     p.y=abs(r)*p.y
     endfunc
     
     
     
     static func expo(point p)
     point newp=new point(exp(p.x)*cos(p.x),exp(p.x)*sin(p.y) )
     p.x=newp.x
     p.y=newp.y
     endfunc
     
     static func copy(point p,point q)
     p.x=q.x
     p.y=q.y
     endfunc
     
     
     static func fold_r(point p,float r)
     If p.x<r
     p.x=p.x+2*(r-p.x)
     endif
     endfunc
     
     static func fold_l(point p,float r)
     If p.x>r
     p.x=p.x-2*(p.x-r)
     endif
     endfunc
     
     static func fold_u(point p,float r)
     If p.y<r
     p.y=p.y+2*(r-p.y)
     endif
     endfunc
     
     static func fold_d(point p,float r)
     If p.y>r
     p.y=p.y-2*(p.y-r)
     endif
     endfunc
     
     static func fold_skew_r (point p, const point q, const float phi)
     point.substract(p,q)
     point newp= new point(p.x*cos(2*phi)+p.y*sin(2*phi),p.x*sin(2*phi)-p.y*cos(2*phi))
     If newp.x<p.x
     point.add(p,q)
     else
     point.copy(p,newp)
     point.add(p,q)
     endif
     endfunc
     
     static func fold_skew_l (point p, const point q, const float phi)
     point.substract(p,q)
     point newp= new point(p.x*cos(2*phi)+p.y*sin(2*phi),p.x*sin(2*phi)-p.y*cos(2*phi))
     If newp.x>p.x
     point.add(p,q)
     else
     point.copy(p,newp)
     point.add(p,q)
     endif
     endfunc
     
     static func rotate(point p,const float phi)
     point q=new point(0,0)
     q.x=p.x*cos(phi)-p.y*sin(phi)
     q.y=(p.x)*sin(phi)+p.y*cos(phi)
     copy(p,q)
     endfunc
     
     static func reflect(point p,const float phi)
     point q=new point(0,0)
     q.x=p.x*cos(2*phi)+p.y*sin(2*phi)
     q.y=p.x*sin(2*phi)-(p.y)*cos(2*phi)
     copy(p,q)
     endfunc
       			

          	
     static float func arg(point p)
     if p.x > 0
     float phi = atan(p.y / p.x)
     elseif p.x == 0
            if p.y > 0
            phi = 0.5 * #pi
            else
            phi = -0.5 * #pi
            endif
     else
         if p.y > 0
         phi = #pi + atan(p.y / p.x)
         else
         phi = -#pi + atan(p.y/ p.x)
         endif
     endif
     return phi
     endfunc
		
 	
     
     static func circle_inversion(point p)
     float norm=p.x^2+p.y^2
     p.x=p.x/norm
     p.y=p.y/norm
     endfunc
     
     static func fold_in(point p)
     float norm=p.x^2+p.y^2
     if norm<1
     p.x=p.x/norm
     p.y=p.y/norm
     endif
     endfunc
     
     static func fold_out(point p)
     float norm=p.x^2+p.y^2
     if norm>1
     p.x=p.x/norm
     p.y=p.y/norm
     endif
     endfunc
     
     static func circle_inversion_gen(point p,point mp,float r)
     float norm=(p.x-mp.x)^2+(p.y-mp.y)^2
     p.x=mp.x+(r*r/norm)*(p.x-mp.x)
     p.y=mp.y+(r*r/norm)*(p.y-mp.y)
     endfunc
     
     float x
     float y
}

[kram1032]

those are some really nice patterns! Great work!

[puntopunto]

PART 2A
Here is a second general formula, involving folds. This formula is the same as the formula folding_general_1, except the circle inversion is replaced by squaring.
Squaring a point P(x,y) is defined by f, acting on the coordinates of P and  f(x,y)=(x^2-y^2,2xy).
Geometrically  the point P is rotated by the angle of the line through P and (0,0)  with the X-axes, followed by squaring the distance of the new point by its distance to (0,0).

Code:

folding_general_2 {
;by Jos Hendriks 1998-2013
;for comments see folding_general_1

global:

import "jhe.ulb"

init:

point mandelstart= new point(real(#pixel),imag(#pixel))
point p= new point(real(#pixel),imag(#pixel))
if @flag5==1
float phi_r=@angle_r*#pi/180
point q_r=new point(@q1_r,@q2_r)
endif
if @flag6==1
float phi_l=@angle_l*#pi/180
point q_l=new point(@q1_l,@q2_l)
endif

loop:

 if    @flag1==1
       point.fold_r(p,@f1)
       endif
       if @flag2==1
       point.fold_l(p,@f2)
       endif



       if @flag3==1
       point.fold_u(p,@f3)
       endif
       if @flag4==1
       point.fold_d(p,@f4)
       endif
        if @flag5==1
       point.fold_skew_r(p,q_r,phi_r)
       endif
       if @flag6==1
       point.fold_skew_l(p,q_l,phi_l)
       endif
        point.square(p)
 point.translate(p,mandelstart)
 z=p.x+1i*p.y

  bailout:		
       		point.squarenorm(p)<16
       		
   switch:
                type = "julia_folding_general_2"
                seed=#pixel
                flag2=flag2
                flag1=flag1
                flag3=flag3
                flag4=flag4
                flag5=flag5
                flag6=flag6
                f1=f1
                f2=f2
                f1=f1
                f2=f2
                f3=f3
                f4=f4
                angle_r=angle_r
                q1_r=q1_r
                q2_r=q2_r
                angle_l=angle_l
                q1_l=q1_l
                q2_l=q2_l

default:
  title = "folding_general_2"

  heading
  text="1 for including the specified fold"
  endheading

   int param flag1
    caption = "right fold"
    default=1
    hint="1 for including a fold\
    to the right"
  endparam

   int param flag2
    caption = "left fold"
    default=0
  endparam

    int param flag3
    caption = "fold up"
    default=0
  endparam

      int param flag4
    caption = "fold down"
    default=0
  endparam

      int param flag5
    caption = "fold skew r"
    default=0
  endparam

      int param flag6
    caption = "fold skew l"
    default=0
  endparam
 heading
 text="lines for horizontal and vertical folds"
 endheading
  float param f1
    caption = "foldline right "
    default=0
    endparam

  float param f2
    caption = "foldline left "
    default=0
  endparam

  float param f3
    caption = "foldline up "
    default=0
    endparam

  float param f4
    caption = "foldline down "
    default=0
  endparam
 heading
 text="fold skew right"
 endheading
  float param angle_r
caption="angle line r"
default=45.0
endparam
float param q1_r
caption="x point"
default=1.0
endparam
float param q2_r
caption="y point"
default=1.0
endparam
heading
 text="fold skew left"
 endheading
  float param angle_l
caption="angle line r"
default=45.0
endparam
float param q1_l
caption="x point"
default=1.0
endparam
float param q2_l
caption="y point"
default=1.0
endparam
}

julia_folding_general_2 {
;By Jos Hendriks 1998-2013

global:

import "jhe.ulb"

init:

point juliaseed=new point (real(@seed),imag(@seed))
point p= new point(real(#pixel),imag(#pixel))
if @flag5==1
float phi_r=@angle_r*#pi/180
point q_r=new point(@q1_r,@q2_r)
endif
if @flag6==1
float phi_l=@angle_l*#pi/180
point q_l=new point(@q1_l,@q2_l)
endif

loop:

 if    @flag1==1
       point.fold_r(p,@f1)
       endif
       if @flag2==1
       point.fold_l(p,@f2)
       endif



       if @flag3==1
       point.fold_u(p,@f3)
       endif
       if @flag4==1
       point.fold_d(p,@f4)
       endif
        if @flag5==1
       point.fold_skew_r(p,q_r,phi_r)
       endif
       if @flag6==1
       point.fold_skew_l(p,q_l,phi_l)
       endif
        point.square(p)
 point.translate(p,juliaseed)
z=p.x+1i*p.y


  bailout:		
       		point.squarenorm(p)<16
       		
   switch:
                type = "folding_general_2"
                seed=#pixel
                 flag1=flag1
                flag2=flag2

                flag3=flag3
                flag4=flag4
                flag5=flag5
                flag6=flag6
                f1=f1
                f2=f2
                f1=f1
                f2=f2
                f3=f3
                f4=f4
                angle_r=angle_r
                q1_r=q1_r
                q2_r=q2_r
                angle_l=angle_l
                q1_l=q1_l
                q2_l=q2_l

default:
  title = "julia_folding_general_2"
   complex param seed
   endparam
  heading
  text="1 for including the specified fold"
  endheading

   int param flag1
    caption = "right fold"
    default=1
    hint="1 for including a fold\
    to the right"
  endparam

   int param flag2
    caption = "left fold"
    default=0
  endparam

    int param flag3
    caption = "fold up"
    default=0
  endparam

      int param flag4
    caption = "fold down"
    default=0
  endparam

      int param flag5
    caption = "fold skew r"
    default=0
  endparam

      int param flag6
    caption = "fold skew l"
    default=0
  endparam
 heading
 text="lines for horizontal and vertical folds"
 endheading
  float param f1
    caption = "foldline right "
    default=0
    endparam

  float param f2
    caption = "foldline left "
    default=0
  endparam

  float param f3
    caption = "foldline up "
    default=0
    endparam

  float param f4
    caption = "foldline down "
    default=0
  endparam
 heading
 text="fold skew right"
 endheading
  float param angle_r
caption="angle line r"
default=45.0
endparam
float param q1_r
caption="x point"
default=1.0
endparam
float param q2_r
caption="y point"
default=1.0
endparam
heading
 text="fold skew left"
 endheading
  float param angle_l
caption="angle line r"
default=45.0
endparam
float param q1_l
caption="x point"
default=1.0
endparam
float param q2_l
caption="y point"
default=1.0
endparam
}

Here are the Mandelbrot pictures for  several possible folds:




The first two are right and left fold along the line x=0. The following two are up and down fold along the line y=0
The last two are folds along lines of 45 and -45 degrees through (0.0). All these fractals are good starting points for interesting pictures.
For now I focus on the first, a right fold.  Here some pictures, if you change the position of the folding line:
folding line x=.5:

folding line x=1:


folding line x=2:

 

folding line x=3:

 
 

Changing the folding line introduce the tricorn and brings in the Mandelbrot set for z^2 . If the line is far enough to the right there is just that fractal alone.
All the fractals from above seem to have interesting zoom possibilities. I started a category Ultra Fractal II in mygallery. Please have a look there to see some of the possibilities
Also interesting is the presence of mini tricorns together with minibrots in several of these fractals:



While zooming it is often a surprise if you are ending with a (deformed) minibrot or ending with a (deformed) minitricorn.
Anyway I would be glad if one of the zooming experts would give some of the above fractals a try. I am really curious about possible results.

[puntopunto]

PART 2B
Here an interesting comparison  of Julia's with the same seed for the fractals with a left fold and different folding line:




Above left, is the Juliaset for z^2. To the right for the same seed the Juliaset for a  left fold along x=.5. The following pictures are the  sets for folds x=1, x=2, x=3. The Julia sets changes and splits into two equal parts that seems to be copies of the Juliaset for z^2. The last picture is made from a fold with x=0.


Below a picture of a part of the Juliaset with the fold x=.5 and the exponential coloring algorithm:




This clearly shows that a fold is involved.

Then combining two  folds. Below a few of the many possibilities:





Below are several Julias from the same, randomly taken, seed, but with more then one fold involved:



The first is the Julia set derived from the standard Mandelbrot set. The second has all fold along the two axes, and one skew 45 degree fold. The other six has 2 or 3 or 4 folds out of the set of the second one. There are more possibilities. And with changing the position of fold lines infinitely many.
They can resemble Julia's from the standard Mandelbrot set, but there also many very different ones.  Moreover sometimes other coloring algorithms then the standard one can reveal interesting structures.

Here is, I think, an amazing one:



The border reminds me of an old tree trunk. The inside a Escher like filing with trees.

[puntopunto]

POST 2C
And here a small collection of other Julia's:








And this look like  a funny representation of the Mandelbrot set. But it actually is inside a Julia set:


It is made with the smooth coloring algorithm. You only have to change the maximum iterations by one to get another one:



Enough for now. I have more to say and to show. That I will do in some shorter posts. There is a final aim: To show that the fundamental transformations for fractal creation are fold and stretch. If correct, I believe that is revolutionary.
If you are going to use my formulas, please don't upload them to the database of Fractint. I will do that as soon as I am satisfied with the formulation and the comments. Any idea will be welcomed.

[Levi]

Wow! Nice stuff. Some of those Julias are just gorgeous.

Was surprised to see folded Mandelbrots that looked like rotated slices of the Mandelbulb...

And the appearance of shapes similar to the 'mobiusbrot': http://www.fractalforums.com/mandelbrot-and-julia-set/m-set-on-a-partialtotal-mobius-cylinder-looks-neat/
Although the idea behind mobiusbrot is almost identical to this, so I guess that shouldn't be surprising.

Good work puntopunto!!

[Kali]

It's nice that you found all this by yourself. Now you would like to take a look at this thread:

http://www.fractalforums.com/new-theories-and-research/very-simple-formula-for-fractal-patterns/

And also it's nice how you found the same fractal I made some time ago:


http://www.fractalforums.com/index.php?action=gallery;sa=view;id=7153

Good work

[M Benesi]

  @Kali - hehe, I thought of you when I saw the first tree in the thread.


  Very nice images. 

[puntopunto]

It's nice that you found all this by yourself. Now you would like to take a look at this thread:

http://www.fractalforums.com/new-theories-and-research/very-simple-formula-for-fractal-patterns/

And also it's nice how you found the same fractal I made some time ago:

Did you actually read my post?

P.s: the first formula in the thread "a very simple formula", consist of the left fold with folding line x=0 and one "fold up" with folding line y=0, followed by the unit circle inversion. It is not the simplest possibility. Only making one fold, to the right, gives about the same possibilities.  And there is still another simplification possible. About that later.

That fractal I know already for a long time. I made it with Fractint about 15 years ago.

Also some other formulas mentioned in the topic "very simple formula..." are part of my formula general_fold_1, but that formula is far more general, by changing the positions of the folding lines and introducing skew folds.
My posts are really about a new geometric foundation of fractal generation. Although still working on it I think I can show that a very, very large class of fractals can be made using only folds and stretches. For instance, as I will show later, you can create the Mandelbrot set in that way.
 
I avoid also complex notations with "i" and "z". I don't use complex function theory. There are very good reasons doing so:

1. Fractal creating is essentially geometrically. Thinking in "folds" you will get faster the idea of changing the folding line then thinking abs(z).

2 .Second it is demystifying, certainly for people without knowledge of complex function theory. By the way, many books introducing complex numbers and all the videos, I saw on youtube doing so, don't do that correctly.

3. As soon as you use complex functions you are tempted to do everything
with z, z^2, exp(z) etc. And not defining maps that acts on the real and imaginary
parts of the numbers. Moreover the few predefined functions has names that hide
there geometrical meaning. Flip and complex conjugation are just reflections.

[Kali]

Did you actually read my post?

Actually, no. I only read it entirely now, yesterday I took a quick look at the images and formulas cause I didn't have the time to read all at that moment. But I saw that most of the patterns and formulas are related to the ones I discovered myself, based on works by Tom Lowe (mandelbox formula) and Sam Monnier (ducks formula), including the patterns on folded mandelbrot (also when I discovered the patterns inside the "burning ship", I searched exhaustively in the web to see if somebody knew about this and I found nothing.). Just wanted to let you know that I've found similar stuff, and...

That fractal I know already for a long time. I made it with Fractint about 15 years ago.

...that's ok, congrats, I just didn't know of it, did you publish anything before?

P.s: the first formula in the thread "a very simple formula", consist of the left fold with folding line x=0 and one "fold up" with folding line y=0, followed by the unit circle inversion. It is not the simplest possibility. Only making one fold, to the right, gives about the same possibilities.  And there is still another simplification possible. About that later.
Also some other formulas mentioned in the topic "very simple formula..." are part of my formula general_fold_1, but that formula is far more general, by changing the positions of the folding lines and introducing skew folds.

Yes, I know there is also a 1 fold version, as you can see in my entangled tree image similar to yours. Also I've been exploring a lot of combinations of foldings, symmetries, rotations, hybrids, including the 3D version of this kind of fractals, and I've been posting some of my findings in other topics here in FF.

My posts are really about a new geometric foundation of fractal generation. Although still working on it I think I can show that a very, very large class of fractals can be made using only folds and stretches. For instance, as I will show later, you can create the Mandelbrot set in that way.
I avoid also complex notations with "i" and "z". I don't use complex function theory.

I'm pretty sure you can't create the Mandelbrot set using ONLY folds and stretches (no rotations, no complex multiplications), but now I'm curious because if you really can do it, then it's extendable to 3D...

So maybe you have found the holy grail 15 years ago and you don't know it

[M Benesi]

I'm pretty sure you can't create the Mandelbrot set using ONLY folds and stretches (no rotations, no complex multiplications), but now I'm curious because if you really can do it, then it's extendable to 3D...

 I'm wondering what you'd get if you folded over the angle between the original and double angle....

   z^2 Mandelbrot = r^2 [ cos(2*theta) + sin (2*theta) ]

2* theta = doubled angle
1.5 theta= angle of line to fold over
theta = original angle ====  atan2(y,x)

  though the easiest way to do this is to

a)  rotate x and y -1.5 * theta so that they fold over the x axis
b) fold them over the x axis
.... x=x
.... y=-y
c) rotate them (x,y)  1.5 * theta  (back to original)
d) you probably need to go ahead and multiply them by their magnitude

which technically involves a rotation......

[kram1032]

I thought, fold and stretch are well known as being fundamental parts of fractal imagery?
More generally, you need some form of deform (which might be fold) and rescale (which might be stretch) to give rise to a fractal pattern. Any transformation that does any of this will give rise to fractal patterns for at least a fraction of the involved parameter sets.

Either way, those are really gorgeous works!
It's amazing how the very same basic patterns (like, say, that tree structure) can appear like that over and over and yet produce so very different images. The ultimate puzzle generator.

[Dinkydau]

Great work