Is there anything novel left to do in M-like escape-time fractals in 2d?

[simon.snake]

I have for some time been playing (mostly unsuccessfully) with simple M-like formulae in Fractint, and if I get anything mildly interesting, most of the time they have disconnected julia like areas.

Today, however, I created the following very simple alteration of the mandelbrot in the formula parser:

Code:

simon0086-F {
  if (ismand)
    z = pixel
    c = pixel
  else
    z = pixel
    c = p1
  endif:
  z = z * z * c
  z = z * z + c
  |z| < 4
}

Now, for anyone who doesn't know the formula parser, anything before the : is performed for each pixel once, then from that to the last but one line is iterated for every pixel, then the test is the line at the bottom.  I have tried a few different combinations of the "z = z * z ..." lines and this one creates the following image which is finally connected:



Zooming in to the valley on the right at 0 axis, produces the following zooms:























I very quickly reached the number precision limit of the version of FractInt I am using. The next image was very blocky so not included.

So far quite interesting for me, and I now need to ask kindly of members of the forum who have Fractal eXtreme (64-bit) and the necessary know how to write me a plugin with this formula included... (I hate grovelling but, when needs must...)

[fracmonk]

Hey Simon!

The limit for the fractint formula parser is 16 digits, giving you about 12 accurate with large pix.  I cry and whine, but no one listens...

So that's an M4 Multibrot, yes?

Later!

[simon.snake]

If I was feeling really manic I'd pop into a dosbox session and run the true dos version, which I believe supports arbitrary precision, but it just takes far too long to generate images for my liking.

The windows version that was created is a lot faster but has its own issues.

I have sent a pm to the only person I know with the suitable skills to create the plugins, however the author of Fractal eXtreme, Bruce Dawson is also a member of the forum I seem to recall, so maybe I should ask him.

[panzerboy]

I have for some time been playing (mostly unsuccessfully) with simple M-like formulae in Fractint, and if I get anything mildly interesting, most of the time they have disconnected julia like areas.

Today, however, I created the following very simple alteration of the mandelbrot in the formula parser:

Code:

simon0086-F {
  if (ismand)
    z = pixel
    c = pixel
  else
    z = pixel
    c = p1
  endif:
  z = z * z * c
  z = z * z + c
  |z| < 4
}

...
So far quite interesting for me, and I now need to ask kindly of members of the forum who have Fractal eXtreme (64-bit) and the necessary know how to write me a plugin with this formula included... (I hate grovelling but, when needs must...)

Hi Simon,

I've tried your formula but it looks nothing like you example.
My actual code (for floating point) looks like this...

Code:

	zizrt2=zr*zi*2;
	zrsqrmzisqr=zisqr-zrsqr;
	zr=zrsqrmzisqr*JuliaR - zizrt2*JuliaI;
	zi=zizrt2*JuliaR + zrsqrmzisqr*JuliaI;
	zr=zr*zr - zi*zi + JuliaR;
	zi=2*zi*zr+ JuliaI;
	zisqr = zi * zi;
	zrsqr = zr * zr;

I have a spreadsheet that helps me expand the complex multiplications into individual real and imaginary equations.
So for Z=Z*Z*C
expands to
zr=(zr*zr - zi*zi)*cr - (zi*zr + zr*zi)i*ci
zi=(zi*zr + zr*zi)i*cr + (zr*zr - zi*zi)*ci

And I've just spotted a mistake on line 6 "zi=2*zi*zr+ JuliaI;" but I've already clobbered the zr variable in the previous line.
Doh!
Back soon (Hopefully)

Jeremy Thomson.

[simon.snake]

That image looks kind of interesting, too. Might be worth a look at that in Fractal eXtreme also!

[fracmonk]

Simon,

   Sorry!  I misidentified your object as M4, but it's M4 on an M6 body, and I only realized that when I took a second look at the first pic.  I think arbitrary precision only works with Mandel type in FractInt.  In formula, I wouldn't care if each 10x mag. took twice as long as the last, as long as I could go beyond 16 digits when I wanted.  I dream...

Also, I'm not familiar with what ismand does, and haven't used conditionals for years now, as it turns out.  When I did, I might have knocked out the largest circles of lambda, for instance, to save time in calculation when machines were that slow...but I'm obsessed with utmost simplicity in formulae leading to utmost complication in outcome, these days.

Later.

[simon.snake]

If you include the ismand check then FractInt gives you a prompt at the time you select the formula where you can set whether you run in mandelbrot or julia mode, and while you view the fractal if you press space it will then give you a crosshair which you move to your desired point then press space to show a julia of that spot.

I hope that helps.

Simon

[simon.snake]

So, tell me if I'm rambling but based on what FractInt does with complex numbers, and trying to convert this into code for Fractal eXtreme, I have been trying to get my head around the way these things are done.

Here's my take on converting the complex maths into non-complex code:

Code:

The two iterated calculations in my formula:

1) z = z * z * c
2) z = z * z + c

Broken down, line 1 is:

[the z * z]
zr1 = (zr*zr - zi*zi)  // I use zr to mean the real value, zi to mean the imaginary value
zi1 = (2 * zr*zi)      // and I've used zr1 and zi1 as we need to use a temporary variable

[the (z*z) * c]
zr2 = zr1*cr - zi1*ci  // also zr2 and zi2 so I don't change original value of z
zi2 = zi1*cr + zr1*ci  // am I right to split the two multiplications?

[expanded]

zr2 = ((zr*zr-zi*zi)*cr)-((2*zr*zi)*ci)  // replacing the zr1 in the lines above gives these two
zi2 = ((2*zr*zi)*cr)+(zr*zr-zi*zi)*ci    // lines, but they may be able to be simplified somewhat

Broken down, line 2 is:

[the z * z + c]
zr1 = (zr2*zr2 - zi2*zi2)+cr  // this is a lot simpler, but I don't know if it can
zi1 = (2 * zr2*zi2)+ci        // be combined with above as needs new value of z

I don't know if I'm on the right track with this, as it's all a bit over my head, but I was good at maths at school so shouldn't have too much trouble with it if I put my mind to it.

Happy coding...

[fracmonk]

Simon,

To be honest, I've lately been overreliant on the auto complex calc that FractInt does, and it has been pretty reliable because of the straightforwardness of the formulae I use lately.  The last time I resorted to "manual" was when trying out a 4d scheme that required it, and it was a disaster, not so much math-wise but results-wise.  I'll read your code if it will print (it's in a rolling box here) and see if I can interpret it right, O.K.?

Later.

[simon.snake]

Please do, but I do feel we're slightly hijacking this thread so can we create one in the Fractal eXtreme plugins forum instead.

Simon

[fracmonk]

Simon,

No problem, but make plain how you got that shape, O. K.?

Later.

[laser blaster]

I need help implementing one of the formulas in this thread...

It's on page 2. Fracmonk describes the formula as: The oddity of M4 shapes in an M2 general structure (1st pic below) is obtained with the formula f(z)->((z^4)c)+1. And the results he gets are:


I tried to implement it myself in glsl, but the results are:


Clearly, my result is not the same. Here's my code (all the important bits, at least):

Code:

dvec2 complexSquare(dvec2 myVec) {
        return dvec2(myVec.x*myVec.x-myVec.y*myVec.y, 2.0*myVec.x*myVec.y);
} 
dvec2 complexMult(dvec2 aVec, dvec2 bVec) {
        return dvec2(aVec.x*bVec.x-aVec.y*bVec.y, aVec.x*bVec.y+aVec.y*bVec.x);
}
      
void main() { 
      
    dvec2 initPosition = gl_TexCoord[0].st;
        
    dvec2 newPoint =  initPosition;
        
    vec4 color = vec4(vec3(0.0),1.0); // interior color
        
    int i=0;
    for(i=0;i<iterations;i++) { 

           newPoint = complexMult( initPosition, complexSquare(complexSquare(newPoint))) + dvec2(1.0,0.0);
             
           if (length(vec2(newPoint)) > 256.0) {
               //(do exterior coloring here)
               break;
           }
    }
    gl_FragColor = color;
 }

Pay special attention to this line:
newPoint = complexMult( initPosition, complexSquare(complexSquare(newPoint))) + dvec2(1.0,0.0);

If someone could help me find where I went wrong, that would be awesome.

[tit_toinou]

You maybe need to begin with the Complex 0 (or 1 it is the same after one iteration). Here you begin with c just like if you would do with the regular Mandelbrot because c=f(0) (in order to simplify one iteration) !

[laser blaster]

You are correct. Thank you very much sir!

[simon.snake]

I've made a slight change to the standard Mandelbrot formula and came up with another new M-like fractal which I feel has some interesting features:

Here's the formula in FractInt:

Code:

simon0100-A {
  if (ismand)
    z = c = pixel
  else
    z = pixel
    c = p1
  endif:
  z = z * abs(z)
  z = z * z + c
  |z| < 4
}

The important bit is between the endif: and |z| which are the two assignments to z.  All I do is first multiply z by abs(z).

Here's the initial image...


...and some zooms...










































...and some julias...








What do you think?

Looks like another candidate for conversion to a Fractal eXtreme plugin.

I've tried power 3, 4, etc. and they look quite good too.