naming scheme for abs() variant fractals?

  • 10 Replies
  • 597 Views

0 Members and 1 Guest are viewing this topic.

Offline claude

  • *
  • 3f
  • ******
  • Posts: 1232
    • mathr.co.uk
« on: February 08, 2018, 05:40:05 PM »
I have seen stardust4ever's images which name various formulas for various powers: 2 3 4 5

But I've not managed to reverse-engineer the corresponding system of naming, to be able to know what a "celtic quasi heart power 7" might mean, for example.

Moreover some standard formulas differ from stardust4ever's charts, for example Burning Ship is generally considered to be (|x|+i|y|)^p+c afaict.  Mandelbar is definitely (x-iy)^p+c too, and Mandelbrot z^p+c of course.

I tried to systemize some naming like this:

Mandelbrot : (x + i y)^p + c
Mandelbar : (x - i y)^p + c
Burning Ship : (|x| + i |y|)^p + c
(these are all standard)

Heart Mandelbrot : (|x| + i y)^p + c
Perpendicular Mandelbrot : (|x| - i y)^p + c
Perpendicular Burning Ship : (x - i |y|)^p + c
(not sure on those three)

Celtic X : do X (without the + c), take the absolute value of the real part (leaving imaginary part untouched), then do the + c.
Buffalo X:  do X (without the + c), take the absolute value of the real part and the imaginary part, then do the + c.
Buffalo Partial Imag X:  do X (without the + c), take the absolute value of the imaginary part (leaving real part untouched), then do the + c.
(seem to be common patterns, but not 100% sure on thes)

The Quasi modifier seems more complicated still, haven't figured that out at all...

Any ideas?

Offline greentexas

  • *
  • Fractal Phenom
  • ****
  • Posts: 52
« Reply #1 on: February 10, 2018, 02:44:52 AM »
Most of my fractal time is spent doing EXACTLY what you're talking about! My fractal-themed dreams have come true :wow:

The 7th Celtic Quasi Heart can be derived as follows:

Take the 7th Quasi BS (Bs/Buffalo Hybrid).
Mirroring that gives a Quasi Heart.

The Celtic Quasi Heart fractals are Celtic versions of that. From looking at the 4th Celtic Quasi Heart, and seeing that it's a mirrored Buffalo (as all Quasi Hearts), it's simply a mirrored version of the 7th Buffalo.

An explicit formula is:

        ozx = zx;
        ozxsqr = ozx*ozx;
        zysqr = zy*zy;
        zx = abs(ozxsqr*ozxsqr*ozxsqr - 21*ozxsqr*ozxsqr*zysqr + 35*ozxsqr*zysqr*zysqr - 7*zysqr*zysqr*zysqr)*abs(zx) + cx;
        zy = abs(7*ozxsqr*ozxsqr*ozxsqr - 35*ozxsqr*ozxsqr*zysqr + 21*ozxsqr*zysqr*zysqr - zysqr*zysqr*zysqr)*(zy) + cy;

I've also noticed that the False Quasi Perpendicular fractals can be obtained by raising a certain power of Perpendicular Mandelbrot to a certain power, but it really grinds at my gears that the standard patterns don't work for all powers of the Quasi Perpendicular, Heart, or Imag Quasi Perpendicular / Heart fractals or their variants. You can simulate the Quasi Heart by mirroring a quasi BS or a Buffalo to get its Celtic.

Offline greentexas

  • *
  • Fractal Phenom
  • ****
  • Posts: 52
« Reply #2 on: February 10, 2018, 02:58:31 AM »
I have a hint on what you could do. I just came up with the idea now, I might test it if I get spare time tomorrow.

To do an even order, instead of doing something like

zrsqr*zrsqr + zisqr*zisqr - 6*zrsqr*zisqr + JuliaR
4*zr*zi - (zrsqr*zisqr) + JuliaI (I start with the reals)

I do

zr*zr - zi*zi
2*zr*zi
zr*zr - zi*zi + JuliaR
2*zr*zi + JuliaI

I do as many 2nd order parts without the JuliaR and JuliaI as the exponent of the highest power of 2 that divides the order of the fractal. Here's a ridiculous example: A 400th order variation would have four 2nd order pieces with no JuliaR or JuliaI, followed by a 25th order fractal which can be simplified into two large polynomials multiplied by a monomial. (2 x 2 x 2 x 2 x 25 = 400.)

Even orders that are divisible by a high power of 2 are particularly annoying. I'm a little baffled only figuring out order 8.



Offline claude

  • *
  • 3f
  • ******
  • Posts: 1232
    • mathr.co.uk
« Reply #3 on: February 12, 2018, 06:32:30 PM »
The 7th Celtic Quasi Heart can be derived as follows:

I got lost in your derivation pretty quickly - can you break it down explaining every step / terminology as if I don't know anything about it?  Suppose I know what complex numbers are, and multiplication / addition / subtraction, and abs() for real numbers, but that's about it.

Offline claude

  • *
  • 3f
  • ******
  • Posts: 1232
    • mathr.co.uk
« Reply #4 on: February 12, 2018, 06:37:07 PM »
Even orders that are divisible by a high power of 2 are particularly annoying. I'm a little baffled only figuring out order 8.

The Haskell standard library has a function for raising to a positive integer power, which works by repeated squaring and multiplication:
https://hackage.haskell.org/package/base-4.10.1.0/docs/src/GHC.Real.html#^
Code: [Select]
(^) :: (Num a, Integral b) => a -> b -> a
x0 ^ y0 | y0 < 0    = errorWithoutStackTrace "Negative exponent"
        | y0 == 0   = 1
        | otherwise = f x0 y0
    where -- f : x0 ^ y0 = x ^ y
          f x y | even y    = f (x * x) (y `quot` 2)
                | y == 1    = x
                | otherwise = g (x * x) ((y - 1) `quot` 2) x
          -- g : x0 ^ y0 = (x ^ y) * z
          g x y z | even y = g (x * x) (y `quot` 2) z
                  | y == 1 = x * z
                  | otherwise = g (x * x) ((y - 1) `quot` 2) (x * z)

Offline greentexas

  • *
  • Fractal Phenom
  • ****
  • Posts: 52
« Reply #5 on: April 11, 2018, 04:30:00 AM »
I found this out:

The Perpendicular Buffalo is always z = real(abs(z^n) + c) + imag(abs(z^n + c))*sqrt(-1), (Buffalo/BS).
The Celtic Heart is z = real(abs(z^n) + c) + imag((real(z) + imag(z)*sqrt(-1))^n + c)*sqrt(-1).
The Perpendicular Celtic is z = real(abs(z^n) + c) - imag((real(z) + imag(z)*sqrt(-1))^n + c)*sqrt(-1).

If these functions could be defined as f(z,p) where p is the power, then z = f(z,p)q has power pq, and with the right choices, you could get the Quasi Heart & Perpendicular, as well as the Celtic types, false types, and false Celtic types.

E.g.

z = ((real(abs(z)) + imag(z)*sqrt(-1))^2 + c)^2 gives the 4th False Quasi Heart.

Offline greentexas

  • *
  • Fractal Phenom
  • ****
  • Posts: 52
« Reply #6 on: May 12, 2018, 01:46:23 PM »
I found all of the formulas for all 26 of his ABS variations. I have wanted to do this for over three years. It took tons of trial and error, but here are the formulas. (They are built for the newest version of ChaosPro.) Don't be surprised if the formulas look ambiguous and sloppy to you. These formulas can generate any real order of the fractal while not looking like the fractal came in two parts.

Mandelbrot:
z=z^power + pixel;

Mandelbar Vertical:
z=conj(z^power + pixel);

Mandelbar Horizontal:
z=-conj(z^power + pixel);

Burning Ship:
z=abs(z^power + pixel);

Buffalo:
z=abs(z^power) + pixel;

BS Partial Imaginary:
z=real(z^power + pixel) + imag(abs(z^power + pixel))*flip(1);

BS Partial Real:
z=real(abs(z^power + pixel)) + imag(z^power + pixel)*flip(1);

BS Partial Real Mandelbar:
z=real(abs(z^power + pixel)) - imag(z^power + pixel)*flip(1);

Celtic:
z=real(abs(z^power) + pixel) + flip(1)*imag(z^power + pixel);

Celtic Mandelbar:
z=real(abs(z^power) + pixel) - flip(1)*imag(z^power + pixel);

Buffalo Partial Imaginary:
z=real(z^power + pixel) + flip(1)*imag(abs(z^power) + pixel);

Quasi Burning Ship:
z = real(abs(z^power + pixel)) + imag(abs(z^power) + pixel)*flip(1);

Celtic BS:
z = (abs(z)^power);
z = z - real(z) + abs(real(z)) + pixel;

Celtic BS Partial Imaginary:
z=(((real(z)) + abs(imag(z))*flip(1))^(power/2))^2;
z = z - real(z) + abs(real(z)) + pixel;

Celtic BS Partial Real:
z=(((real(abs(z))) + imag(z)*flip(1))^(power/2))^2;
z = z - real(z) + abs(real(z)) + pixel;

Celtic BS Partial Real Mandelbar:
z=(((real(abs(z))) + imag(z)*flip(1))^(power/2))^2;
z = z - real(z) + abs(real(z)) + pixel;
z = conj(z);

False Quasi Heart:
z=((real(abs(z)) + imag(z)*flip(1))^(power/2) + pixel)^2;

False Quasi Perpendicular:
z=((real(abs(z)) - imag(z)*flip(1))^(power/2) + pixel)^2;

Quasi Heart:
if (imag(z) > 0) {
z=abs(abs(z)^(power/2))^2 + pixel;
} else {
z=(abs(abs(z)^(power/-2))^-2 + pixel);
   
}

Quasi Perpendicular:
if (imag(z) < 0) {
z=abs(abs(z)^(power/2))^2 + pixel;
} else {
z=(abs(abs(z)^(power/-2))^-2 + pixel);
}

Imag Quasi Perpendicular / Heart:
if (imag(z) > 0) {      
z=abs(abs(z)^(power/2))^2 + pixel;      
} else {
z=(abs(abs(z)^(power/-2))^-2 + pixel);
}
z = flip(z);

Celtic False Quasi Heart:
z=((real(abs(z)) + imag(z)*flip(1))^(power/2));
z = (z - real(z) + abs(real(z)) + pixel)^2;

Celtic False Quasi Perpendicular:
z=((real(abs(z)) - imag(z)*flip(1))^(power/2));
z = (z - real(z) + abs(real(z)) + pixel)^2;

Celtic Quasi Heart:
if (imag(z) < 0) {
z=(conj(abs(abs(z)^(power))) + pixel);
} else {
z=((abs(abs(z)^(power))) + pixel);
}

Celtic Quasi Perpendicular:
if (imag(z) < 0) {
z=(conj(abs(abs(z)^(power))) + pixel);
} else {
z=((abs(abs(z)^(power))) + pixel);
}
z = conj(z);

Celtic Imaginary Quasi Perpendicular / Heart:
if (imag(z) < 0) {
z=(conj(abs(abs(z)^(power))) + pixel);
} else {
z=((abs(abs(z)^(power))) + pixel);
}
z = flip(z);

Enjoy!

Offline beer

  • *
  • Fractal Freshman
  • *
  • Posts: 5
« Reply #7 on: May 22, 2018, 01:49:28 AM »
Hi,
I had exactly the same problem:
I was interested in the different fractals which can be generated by modifying the Mandelbrot formula and after some research discovered the image by stardust4ever.  It left me a bit confused, because it only contains 12 variants and the naming is not clear.  Some things are also different than the definition in Wikipedia, for example the Burning Ship is conjugated in the image, but in Wikipedia it is not.

So after some research I figured out there are 16 possible variations of the Mandelbrot formula:
- using the abs function for zr and/or zi : creates 4 variants
- using abs for |zr²-zi²| : 2 variants
- complex conjugating the term : 2 variants

I wrote a program (attached) which generates the 16 possible images as pgm files and adds the name according to stardust4ever.

Some interesting observations:
- The symmetrical fractals have only one variant.  Conjugating them yields a completely different shape.
- The asymmetrical fractals have two variants of each other, one being mirrored by conjugation.  The mirrored variants are missing in the stardust overview.
- "perpendicular" seems to refer to |zr| (abs function on real z), for example for "buffalo"
- "celtic" seems to have something to do with using abs on the squares |zr²-zi²|, but not for "buffalo"
- a "mandelbar" is a conjugated "mandelbrot", so a "celtic mandelbar" is a conjugated "celtic mandelbrot"

Problems:
- a "perpendicular celtic" is not generated by setting zr to the absolute, but by complex conjugating "celtic heart".
  It should be called "celticbar" or something ...

Because of this, we should work out a new naming scheme.
- Mandelbrot and Tricorn should keep the name, Wikipedia already uses these names.
- "Perpendicular" could indicate that the abs function is used on the real part zr
- "celtic" could indicate that abs is used on the squares: |zr² - zi²|

Alternatively, it is possible to just invent some names for the variants.

The table with the "old" names for reference:
//           conjug  abs_zr abs_zi abs_square
   { gen_func<false, false, false, false>, "mandelbrot" },               // 0
   { gen_func<true , false, false, false>, "mandelbar_tricorn" },         // 1
   { gen_func<false, true , false, false>,   "heart mandelbrot" },         // 2
   { gen_func<true , true , false, false>,   "perpendicular mandelbrot" },   // 3
   { gen_func<false, false, true , false>,   "perpendicular burning ship 1" },      // 4
   { gen_func<true , false, true , false>,   "perpendicular burning ship 2" },      // 5
   { gen_func<false, true , true , false>,   "burning ship 1" },      // 6
   { gen_func<true , true , true , false>,   "burning ship 2" },      // 7
   { gen_func<false, false, false, true >,   "celtic mandelbrot" },      // 8
   { gen_func<true , false, false, true >,   "celtic mandelbar" },      // 9
   { gen_func<false, true , false, true >,   "celtic heart" },      // 10
   { gen_func<true , true , false, true >,   "perpendicular celtic" },      // 11
   { gen_func<false, false, true , true >,   "perpendicular buffalo 1" },      // 12
   { gen_func<true , false, true , true >,   "perpendicular buffalo 2" },      // 13
   { gen_func<false, true , true , true >,   "buffalo 1" },      // 14
   { gen_func<true , true , true , true >,   "buffalo 2" }      // 15

Looking forward to your thoughts.


Offline claude

  • *
  • 3f
  • ******
  • Posts: 1232
    • mathr.co.uk
« Reply #8 on: May 22, 2018, 04:20:13 AM »
So after some research I figured out there are 16 possible variations of the Mandelbrot formula:
- using the abs function for zr and/or zi : creates 4 variants
- using abs for |zr²-zi²| : 2 variants
- complex conjugating the term : 2 variants

I think there are more variations.  Here are the most basic things you could do, some of which will lead to duplicate formulae (depending on power):
- zr, -zr, |zr|, -|zr| before power
- zi, -zi, |zi|, -|zi| before power
- swap zr, zi before power
- zr, -zr, |zr|, -|zr| after power
- zi, -zi, |zi|, -|zi| after power
- swap zr, zi after power

-zi before power is tricorn/mandelbar
|zr| after power seems to be celtic

the "quasi" stuff in the higher power variations is totally confusing to me though...

but I'm leaning toward the idea of just using the formula as a name, instead of trying to come up with words.  The formula is usually short and unambiguous...

Offline beer

  • *
  • Fractal Freshman
  • *
  • Posts: 5
« Reply #9 on: May 24, 2018, 04:02:42 AM »
I tried to generate more variations, but I think it is not possible (at least for power two) - you can generate more formulas, but I think you can not generate more distinct appearances.
As far as I understand, using -zr will just conjugate the result (which I already did).
Swapping zi and zr before/after raising to the power will just rotate or mirror the result or have the same effect as conjugation.
I will look deeper into the higher powers, but I have the feeling these will be just minor variations of the patterns already emerging from power two.
For now, it almost looks like there are 12 different fundamental things the numbers allow you to do, the rest just being morphs between these basic operations, like the superposition of 12 fundamental orthogonal tones.   Looking at the renderings of these basic fractals using a modified Buddhabrot method makes the fundamentals even more visible and recognizable.

Offline greentexas

  • *
  • Fractal Phenom
  • ****
  • Posts: 52
« Reply #10 on: June 01, 2018, 05:51:01 PM »
You can generate an infinite number of variations by taking the fractals and raising them to a series of powers along the way that gives the result.

For example:
z=((abs(real(z)) + imag(z)*flip(1))^N + pixel)^(2/N);
z = z^(3/2);

gives various shapes for N from 2 to 6.


clip
Mandelbrot-Variant Orbit Traps

Started by ixm.ibrahim on Fractal Mathematics And New Theories

1 Replies
258 Views
Last post March 03, 2018, 05:45:57 PM
by claude
xx
Printing big fractals

Started by drcoolson on Discuss Fractalforums

15 Replies
1796 Views
Last post May 27, 2019, 01:17:18 AM
by 3DickUlus
clip
Paper fractals

Started by julofi on Other Artforms

3 Replies
488 Views
Last post May 02, 2018, 10:56:31 AM
by julofi
clip
Classic fractals

Started by utak3r on Synthclipse

4 Replies
379 Views
Last post March 06, 2018, 11:15:34 PM
by utak3r
clip
Julofi's fractals

Started by julofi on Image Threads

57 Replies
2386 Views
Last post October 01, 2019, 05:01:51 PM
by julofi