Welcome to Fractal Forums

Happy eastern everybody :)
I've found a way to create those lovely ducky patterns, but without any abs function.

It's quite easy (UF-Code):

Bailoutvalue is
Outsidecoloring is none
Insidecoloring for the examples are Statistics and Exponential Smoothing with Iteration skipping

Some examples:

Mandel1 p=0.5/0.5i  center=-1.65/0i  magnification=1
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/ConjugatetM1.jpg)
Julia1    seed=-1.05/0.415i
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/ConjugatetM1J1.jpg)

Mandel2 p=0.75/0.5i  center=0/0i  magnifcation=1
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/ConjugatetM2.jpg)
Julia2    seed=-1.85163/1.07058i
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/ConjugatetM2J1.jpg)

Mandel3 p=-1/1i  center=0/0i magnification=1
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/ConjugatetM3.jpg)
Julia3    seed=0.42/-1.165i
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/ConjugatetM3J1.jpg)

I've had much fun exploring duckies or talis-pattern created with abs... And that lead me to the question: Are there other ways(i found one) to fold a
fractal to get ducky like patterns? I suspect that symmetrie and equal coverage are important for this purpose.
What do you think?

   

You are just replacing abs with his definition.
abs(x) is if x<0 x = -x
conj (m,n) = m - i*n
so now you can find out how it works :)

Nice images

You can try also the "rotated circle inversion", no abs function at all

The simpler form could be:


where m is a complex number, and it works with Julias (picking a constant for c)

A quick example, with values  m=(0.00,0.90) & c=(0.25,0.50)

It normally requires more iterations than other "ducky" formulas, and also a bit of patience in finding the right values that leads to interesting results...

Hi,

To get ducky patterns, you only need to combine a mirror symmetry with some conformal transformation. Your conditional use of the conj function is exactly a mirror. Kali's circle inversion is a mirror operation about a circle, and can be conformally mapped to a standard mirror symmetry. Using the function "abs" is a bit less general, as it creates two perpendicular mirror symmetries (as it takes the absolute value of both the real and the imaginary part of the complex number).

You can also generalize the mirror symmetry to higher order symmetries (technically, to higher order dihedral groups). Here is a picture using an algorithm with four intersecting mirrors.
http://algorithmic-worlds.net/expo/work.php?work=20110526-kd8
You can see that the squarish figure in the center admits four approximate axes of symmetry (approximate because the symmetry is broken if you go far enough from the center).

Sam

Hi Sam. Nobody's could explained better than the creator/discoverer of Ducks formula  :)

BTW, I was wondering how to achieve a mandelbrot set of this kind of patterns without any stretching. Or maybe not strictly a Mandelbrot set, mathematically speaking, but a set of continuous different varying patterns along the plane, so you could explore the fractal and find the unstretched patterns just by looking around and zooming, without picking julias or changing any parameters... Any clues?

We could maybe call this the Ducky Grial of fractals ;D

Edit: I forgot to mention that the method I described above (rotated circle inversion julia), can produce a certain amount of variation on the type of patterns along the plane, but I'm still not satisfied... also, just in cause I didn't explain myself well, I'm talking about variations on the kind of patterns it shows... off course any julia of a ducky formula shows a huge amount of different arrangements of the patterns but keeping the similarity of the specific kind of pattern the parameters produces.

Hi,
thank you all for your kind and very interesting answers :)

DarkBeam

This make me thinking of:

Kali
I'm curious what your rotated circle inversion formual can create :)
That would be cool to have an infinite plane filled with dense unstretched patterns as Mandelbrot  :o
But i would missing the switching feature in UF  ;D (Maybe the julias will then be stretched?)

s31415
Indeed, that is the rule (or axiom or recipe?)  i was looking for. Now i know the right direction to looking forward :)

Hi Kali,

I don't know about the conditions that should be put on the variation of a parameter so that the resulting pattern is not deformed. I'm starting to read seriously about complex dynamics, so maybe I'll get some clues... If I do I'll share it here for sure.

Best,

Sam

Nice result. Throught flip of real value should be the same as real value *1i.  Maybe should test, what is faster;)

z/|z|  is http://en.wikipedia.org/wiki/Unit_vector (http://en.wikipedia.org/wiki/Unit_vector) in complex number plane.

I think, infinite pattern set should hardly be posible without repeating functions like sinus. Simplest possible abs formula, the burning ship fractal, generates patterns only in quadrants where there are some negative C values, imaginary or real. Probably positive from abs + negative from pixel reveals fractal nature of numbers. When it gets too far from 0, differences between positive and negative values, escaping to infinity fastly and slowly increases in both side, hence streching.


p.s.
Try exponent smoothing were negative exponents are calculated not of cabs (z) but of cabs (z + complex parameter). Adding 1, -1, i, -i , maximum 2,  helps to reveal much more patterns.

Experimenting with equation I got a pretty strange but interesting formula.
z=abs(z)/ (z+1+C) +C

It have nice paterns in m-brot mode, but without some z based colour function it shows absolutelly nothing  (it don't have any iteration differences, nor diverges nor converges). Julias looks strange, but they have patterns inside. Maybe just a bitt streched.

Direct coloured:
(http://fc00.deviantart.net/fs70/i/2012/115/4/3/kaliset_variation_2_by_edo555-d4xj3wr.jpg)

Palette coloured:
(http://fc04.deviantart.net/fs70/i/2012/115/a/2/kaliset_version_1_by_edo555-d4xj3qu.jpg)

Here is corrected version of circlefold. This calculates modulus of z only once, and don't have division by zero problem. Something similar like of mandelbox fold.

With this I got nice formula:
in single line
z= scale* circlefold ( z+D )*c +c

With "if |z|<1 then z=z/|z|" formula fails to initialise when D=0 and z=0, so my circlefold are preferable. Maybe this formula could have additional name, Sefir (space filling rotation), as it is rotated.  Alsou very similar:
z= scale* circlefold ( z+D )/c +c

With formulas i posted (z=scale*circlefold(z+D)*c+c and z=scale*circlefold(z+D)/c+c) I got this

Here is the result.
(http://fc07.deviantart.net/fs70/i/2012/124/7/d/croco_skin_by_edo555-d4yi25h.jpg)

(http://fc09.deviantart.net/fs71/i/2012/124/d/e/storm_by_edo555-d4yi0yb.jpg)
kaliset_sefer4_storm {
::8xGe7jn2NSVTztNIUw7eG/fgR3jNCBC52hDtT7l+1l07eIIkNJIQBQx2dyP+C6Ln2OpT8NYf
vd33+QuxxFBu+drXBABVQLZZPw1KvMs3LbkO8efw6azAnU1hjsSMEcUqOcMwwVQgmfR68s8U
3CnsWF8ssP4r5tvnstYLCmjyWvaoqBFE8ugyaYZfkLe4gz2bqzA2OuQFuwyhw1ra5ddKzhxq
lmg0xuBuhURJbhbogW+BDLfDqgmnXgXvqJ6teNfo8W+ZVqeMB0JdijSxDMbTDoRplGebcykt
b6bizSkX3FW2XHHUpf/tyGlTpyS00tX+YPf0m4bADQg27nwujr02+AjSpw3yvYLRJCX6ksv0
rV8RW8nUBxxZgvzN1S9dObICdfqq0MTLGm5dxRPe9nGD5m9N9Gx+OrPwU1x5IRmgHXb5bTa9
kUMQ5PsGZ6YTc7aHiQ02Y6qM+YXDpVsZfK1JbIggjb8xlNz/oL8X5lQvkX/8ky8NebnfKLiu
wIPwgbgRfmUvW1Ooe2nP3dDQLfSql1gn/1zTN0yDH9tWb8hU2tJpmKJLilWdm+WGikeGEj4F
nu4OtyI5u3i/+HzNq/r7v/n5G79P93BHvWFldwgTdZsAVcRemBBCrOm6wpz5TnzLJ0dVFlzX
XN8IfEiQrqQl4JI0MFoSUJpamI6815FlV4dYcigRodkrMtDWgW0ehKCCjqWoKHTeh6RjVSxV
zYX1pkUWipoZbhJX9VOGDvqfB6F9QJU48oUs4M4yN7mvJuoH/4/Vyx5/aARiu93AKE0c9D==
}



(http://fc07.deviantart.net/fs71/i/2012/124/e/a/tentacles_in_sky_by_edo555-d4yi1b4.jpg)
Kaliset_Sefer4_tentacles {
::kG6S8jn2NP1yyuJMM09Zm8P4h9hYIQIt3xLuda30Xb6HAjiRQcixmabSu0v+KDJZufC3lW6I
dO6I5WHIDg+zrXxYBVQjikfAalHD1/BbRXRdANBQqRfC7mqJcSsvgzOhquTBRxBOTDTozLyi
dQ6wGVwLSe13A9vUud32ceWey6VzomZRCDBl1IS+CIv05sjmmEmdAkqwkIjzXvqHGGUmuF0E
7oTshnWulz6hOTkpWrrfUDzI6h3URIlc2A6knQ5Fhttl1q0oB6pBC7THb7TYUrcTPnP0HnQl
TpSitZoG/7IsosiNs5Us+zJUijgSbHDiqqKOnYpmqOMNgivPqVwSx+bqg80jE/CMNo+ozGoU
njoiTwnqoZItoqkC+1FDrtud0IrHs+gQ1QCM2KJQrhstRmuiy5G+brBjPbptld2Oy3SOly4p
qmtBqYf0BzTPwCOw4plnwrMvzHa6PnOK1PNC69mfOBDjG717eAVp8yVwpgjxTBw0pRmtl9vo
PYwOyguGjf0b1jBkdF0jYM3g9GxXeKfpPPsssvlPbY9WLd5YsrXRRfq5n6UrMI4+oJ1OH0oI
BMr17xnQPTRL33Ecm0qpdRWWRZVJdXsEOb3u7JKL5lHqquHPf/+57571kXUcYXJZHLH+vnCj
9JDP+WkXSQ/PXO4M/A==
}

(http://fc03.deviantart.net/fs70/i/2012/124/3/b/rotated_triangles_by_edo555-d4yi1jd.jpg)
Kaliset_sefer3_rotated_triangles {
::1Gvx3hn2NSVTPuJMQ07RK/Hs4+m4vAMtyH22eqVtX6PAkXwk4sGbqxs7m/9dggJrq0KVu53M
zbm3bspLoaiK7n2vDhimoVLz+hyaG1x6RdnOwqD+oKqbrjBjydyqHzQvaajnlFcM6s2c6cUy
F4ZCsqr6wokgaC6WTcUm94Yrq/z5HZHpYCNb/ulUW6WjaIa8OZ2XUNPfK4nctZI/gqxEvKJY
gwe1wgxd6W2aXUHkPgPkfEj6VncSy+dd+Q/kVtkRv6NzcKcGaQHaOrbeW676QdGr2p6Bhp7P
M11nhAqCX30pes+36OTwYympZoW/nJ1tJj9AaJEq/yasnUGrfKKLLLx/vf3qE6U86gW+9JrR
Nf+VTs5cC9nKXr2+E41QoLzpMLVwyA1eQAYfbWuIUXd3krpewPGlmWQIzM1og1GByuknXdcu
ucBpauqX0NL0/LvTfbMepD23+FjkeEGNjbE4526PocjwKXaNOtK8Ojrt/yhpG7mzBnf4rqgd
07eMqcz7VwU+Ii2v7UQ1agaXiO279wtHnHZAN/mEja8WYiwrnJrnzBPWwTgpsK4lF8ZaWxFJ
caJhuCC3AuBK4YReCNnviSJ8KOr4OJFlrR45YBsXXhFJYClVKIsiUPJLri1YFMcFVsN8sUvJ
EBFjLTdnwTTKBzFliC87FRSzwcVywiEeFNhXUVx34iSKvPAAVcOfLS1/4mUR1mKSYscx96p8
7wpUpsCBYzJ8S8mzREVb+DTwfnPgFsiNLiVloSAW38PHWfY/B3ASP7p55739X0EHjFI=
}

Now that the discussion has mentioned circle fold, I thought I'd share a picture combining a Mandelbrot and "ducky" type patterns.

(http://fc09.deviantart.net/fs71/i/2011/227/5/5/scaly_bundles_and_mandelbrot_by_element90-d467d8t.jpg)

This is produced with a circle fold but instead of folding in it folds out, i.e. any point inside the circle is reflected outside the circle otherwise it is left alone. If the centre of the circle is left at the origin when used with the standard Mandelbrot formula you don't get ducky patterns in fact you don't get much at all, so the centre of the circle has to be moved. Here is a summary of the parameters for this picture.

Formula: Mandelbrot

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

Transform: circle fold out, diameter 2 centred at -1.3 + 0i
Complex plane transform: none
Initial values of z: c
Image centre: -0.189938 - 0.718423i
Long side: 0.022725
Rotation about image centre: 300 degrees
Bailout condition: norm(z) > 16
Maximum iterations: 100
Colour selection: outer for bailout otherwise inner
Outer colouring: iteration
Inner colouring: absolute log of average magnitude

Saturn and Titan has circle fold in, circle fold out and circle reflect transforms. Initially I implemented these as simple inversions but it turns out that when inverting a complex number the result is not on the same vector as the original value, it is often in an entirely different sector. Saturn has in addition inverse fold in, inverse fold out and inverse reflect.

The circle fold in, circle fold out, inverse fold in and inverse fold out all produce ducky patterns, good ducky patterns are produced with low iteration counts, if the iteration count is increased the ducky patterns become just texture but Mandelbrot islands and Tricorns appear with circle folds and only Mandelbrots appear with inverse folds (I have no proof that this always the case).

Here are some Mandelbrots and Tricorns, in this case c has also be transformed by a "unit circle inversion" centred at 0.0 + 0.7i. When I produced these pictures Titan hadn't been updated to produce the parameter summaries so the descriptions are not in the same format and terminology tended to vary. The transform "unit circle inversion" is circle reflect.

(http://fc07.deviantart.net/fs71/i/2011/224/2/4/tricorn_invasion_by_element90-d467f4n.jpg)

Formula: Mandelbrot

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

Transform: apply Transform 1
Transform 1: circle fold in, diameter 2 centred at 0 + 0i
Complex plane transform: unit circle inversion centred at 0 + 0.7i
Initial values of z: transformed c
Image centre: -2.670267 + 0.855936i
Long side: 3.203797
Rotation about image centre: 0 degrees
Bailout condition: norm(z) > 16
Maximum iterations: 250
Colour selection: outer for bailout otherwise inner
Outer colouring: not applicable, all points are inner
Inner colouring: absolute log of magnitude, fractal dimension

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:


Mandelbrot with m=(1.0,0.0) offset=(0.0,0.0)
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/KOutCircleM1.jpg)
2 Julias:
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/KOutCircleJ1.jpg)
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/KOutCircleJ2.jpg)

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:


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:


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.

(http://fc01.deviantart.net/fs70/i/2011/315/5/7/lanterns_2_by_element90-d4fr5vz.jpg)

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:

(http://fc00.deviantart.net/fs70/i/2011/320/3/d/nova_tricorn_by_element90-d4gcg4i.jpg)

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.

(http://fc06.deviantart.net/fs70/i/2011/348/0/5/hollowed_out_mandelbrot_by_element90-d4j2rwu.jpg)

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


You get this on the Mandelbrot needle:

(http://fc06.deviantart.net/fs70/i/2011/174/9/1/experiment_in_folding_by_element90-d3jrhnl.jpg)

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:

 (http://ubuntuone.com/0zhaZGov9fUryQLRY7XaGI)

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

(http://fc02.deviantart.net/fs70/i/2011/283/b/5/mandelbrot_disc_by_element90-d4c7rtn.jpg)

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. 

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:
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/InvFoldInConjFold3J1.jpg)
(http://i1255.photobucket.com/albums/hh621/thomasmichels/fractalforum/ducky_fractals_with_conjugate/InvFoldInConjFold3J2.jpg)

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.

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.

(http://ubuntuone.com/0n9tjDh8eWq1N6MBnqDAfs)
(http://ubuntuone.com/1QzGPxsg0m3KboL4cUAOZ5)

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.