Ducky fractals with conjugate only

[thomas314]

Hi element90,
your picture combining Mandel and Ducky is fantastic
Two questions:
How did you combine Mandel and Ducky and
how is your algorithm for "circle fold out" and "circle fold in"?

Inspired from you i tried myself "circle fold in" with surprising results:

Code:

;Circle fold in
if (|z|>1)        ;if (|z|<1) kalis version of circle fold out condition
  z=z/|z|
endif

z=z*m+offset

z=z^2+c

Mandelbrot with m=(1.0,0.0) offset=(0.0,0.0)

2 Julias:

[element90]

thomas314

Those pictures look familiar.

All the fractals pictures I produce are generated using my own software, Saturn & Titan, Saturn is used for exploring fractals and Titan is used to expand fractals saved from Saturn to much larger dimensions I usual expand 750x500 images up to 12000x8000, the maximum size is around 700 megapixels. Saturn & Titan were preceded by Mars and Phobos with each fractal type implemented in C++, as I came across the work of Kali I found that many of the formula were variations on a theme, at that point I came up with the idea of adding transforms to the formulae, the work involved such a major rework of Mars and Phobos that created new projects called Saturn and Titan.

Virtually all the fractal types defined in Saturn start with a transform line, e.g.

z = transform(z)
z = z^2 + c

The transform function is different to the type of function parameter found in UF. A number of transforms can be assigned to a transform set, there are two transform sets A & B and the transform sets can be applied depending on the transform sequence which is a string of As and Bs, for example "AAB" would apply the first transform set to A the first iteration and the second iteration, set B to the third and the sequence then repeats from the fourth iteration. If no transforms are defined then the formula acts as normal, in this the example it would be just a normal Mandelbrot. In addition a transform set can be defined for the complex plane.

In the version 1.x & 2.x branches of Saturn and Titan the available transforms are compound and for calculation are turned into potentially more than one "simple" transform (for version 3.0 a transform set will be a set of simple transforms which will be merged with complex functions). Taking the example "circle fold in" with the circle centred at 0.7 + 0i and diameter 2, three simple transforms are used: translation, circle fold in & translation, the first translation subtracts the position of the centre of the circle from the value to be transformed which of course moves the circle to the origin where the circle fold in operation can be applied, finally the result is moved by adding the position of the circle so the complex plane is back where we started.

The simple circle fold in transform is defined in C++ as follows:

Code:

LongComplex Transform::circlefold_in(const LongComplex &z)
{
    long double normz = std::norm(z);
    return (normz > m_p1 ? LongComplex((m_p0*m_p0*real(z))/normz, (m_p0*m_p0*imag(z))/normz) : z);
}

where m_p0 & m_p1 are set before the circlefold_in is called, m_p0 is the radius of the circle and m_p1 is the radius of the circle squared the meaning values held in m_p0 and m_p1 varies with the type of transform. The inclusion of radius in the calculation allows the size of the circle to be varied.

The related "inverse fold in" transform is defined as:

Code:

LongComplex Transform::inverse_fold_in(const LongComplex &z)
{
    return (normz > m_p1 ? (m_p0*m_p0)/z : z);
}

I said most of the escape time fractal's formulae are preceded by the transform function, in some formulae the transform function is "in formula" for example:

z = log(transform(z^alpha + beta))

which I've called Ltczcpac Julia, the following example uses a single "inverse fold in" transform with a diameter other than 2.



Fractal summary:

Parameters

Formula: Ltzcpac Julia

z = log(transform(z^alpha) + beta)

alpha = 1.8 + 0i
beta = 0.25 + 0i

Programs: saturn and titan
Number of A transforms: 1
Transform 0: inverse fold in, diameter 1.975 centred at 0 + 0i
Number of B transforms: 0
Transform sequence: A
Number of Complex Plane transforms: 0
Initial values of z: transformed c
Image centre: 5.43466666666666667 + 0i
Image width: 3
Rotation about image centre: 90 degrees
Maximum iterations: 75
Bailout: No Bailout
Colour selection: all points are inner
Outer colouring: iteration
Inner colouring: absolute log of average magnitude

Because I defined all escape time formula with either a pre-formula transform or an in formula transform I can apply transforms in any combination I like to all of them for example here's a Nova with a transform applied:



I said earlier that that transforms can be applied to the complex plane, here's a Mandelbrot with "inverse fold out" centred at -0.4 + 0i, diameter 1.



If instead of using a circle inversion the value is simply inverted i.e. for a unit circle at the origin, roughly UF syntax:

Code:

if (|z| > 1)
    z = 1/z
endif

You get this on the Mandelbrot needle:



The above picture was my first attempt at circle folding before I found that inverting a complex number doesn't result in a value on the same line.

Finally here is a picture of Saturn transform settings:

 

The transform settings the for complex plane are the same as transform set A which results in:



I've only shown examples with relatively simple transforms, I haven't covered the effect of multiple transforms in a set or indeed the effect of using two different transform sets. A transform set can of course be empty so it is possible to apply a single transform set periodically. For version 3.0 in addition to increasing the number of available transforms the number of transform sets will be increased, the number is limited to a maximum of 26 transform sets as they can be easily identified using the letters A to Z. 

[thomas314]

Thanks element90
for your very helpful and interesting explanations. After converting
your code of Circle-Fold-in (-out) to UF i understood that this formula
is exactly the same as Kalis  Circle Fold.
One question: What is a circle reflect transform? Sounds interesting

But first have a look at following example:

Iterationloop:
   z=inverse_fold_in(z)
   z=conjugate_fold(z) ;rotate angle=0
   z=conjugate_fold(z) ;rotate angle=120
   z=conjugate_fold(z) ;rotate angle=240
   z=z^2+c
endloop (Bailout = 1e12)

Some Julias:

[element90]

Thomas314,

Circle reflect is reflection of points relative to the circumference of the circle, it is circle fold in (or circle fold out) with out the condition. I haven't got any examples to hand. From what I can remember it is not that interesting on its own, several transforms are relatively boring on their own but have value when used in combination. Now you what it I'm sure that you can experiment.

I think Kali and I developed circle folding at roughly the same time, I saw that if you could fold in one direction you can fold in the other or indeed both directions at the same time, hence the distinction between circle fold in, out and reflect.

For these internal coloured space filling patterns there is no point including a bailout condition, in Saturn for all escape fractals I've included the option of 14 different types of bailout condition (including no bailout).

No, pictures today. Your last two pictures are impressive, especially the "triangular" one.

[element90]

Further to my previous post. I've checked circle reflect applied to the standard Mandelbrot formula with a circle of radius 1 centred at the origin.




200 iterations, no bailout, exponential smoothing.

This looks a lot more interesting than I remembered. Interesting images with the Julia aren't so easy to find.