Kalles Fraktaler 2.9.5

[Kalles Fraktaler]

I just uploaded a new version of Kalles Fraktaler to http://www.chillheimer.de/kallesfraktaler/
A bunch of new fractals added, among them 4th and 5th power Burning Ship, Buffalo, Celtic, Mandelbar, and many more!
Thanks to stardust4ever for the easily accessible formulas, your nomenclature is the standard names of these fractals now!

[stardust4ever]

Whoo-Hoo!


My desktop is currently burning fractal right now. Maybe when it finishes, I take these new formula for a test drive!!!
 

[simon.snake]

I downloaded KF today (to 'install' on my new laptop) and noticed all the new formulae.

Nice job, and will keep us all entertained for many months to come, no doubt.

I was wondering if the following formula is a candidate for conversion into KF.  I have no interesting name for it, other than the name I called the formula when it was created in FractInt.  There are a whole bunch of these created as a plugin in Fractal eXtreme, with the base name simon100 to simon104.  simon100 was basic power of 2, simon101 was power 3, 102 was power 3, and so on.

The only thing different to the Mandelbrot is that at the start of each iteration I multiply the value of z by the value of abs(z) before squaring z and adding the constant.  I originally created the base version, and panzerboy added burning ship, celtic and buffalo varieties by performing an abs on real, imaginary or both parts of the equations.

I hope this makes it simple to figure out, and I would love to see this variant implemented.  For more info, here's the normal power 2 code taken from the Visual C source.:

Code:

		case FT_Simon100A_plain:
			for (/**/; count < MaxIters && zrsqr + zisqr < OverFlowPoint; count++)
			{
				zrabs = abs(zr);
				ziabs = abs(zi);
				tempzi = zi*zrabs+zr*ziabs;
				tempzr = zr*zrabs-zi*ziabs;
				zi=tempzi;
				zr=tempzr;

				zrsqr = zr * zr;
				zisqr = zi * zi;
				zi = zr * zi * 2.0 + JuliaI;
				zr = zrsqr - zisqr + JuliaR;

				zisqr = zi * zi;
				zrsqr = zr * zr;
			}
			break;

And attached is the initial picture of the fractal normal power 2.

Simon

[stardust4ever]

Hi Simon. I remember you from trying to get Panzerboy to incorporate your formulas back in the FX days. I am all in support of new formula, but it appears only some of them provide immense detail at arbitrary zoom depths. If you have access to a program which allows custom formula, even if it only renders to float precision, try zooming in a bit to see if it has infinite fractal detail. If the fractal breaks down into cantor dust or black blobs at a few zooms of depth, it generally tends to be a poor candidate for deep zooming. Ultra Fractal is a wonderful tool for trying out your own formula, even if "snail slow" once you hit arbitrary precision library.

I've kind of unintentionally become curator of fractal formulas for different orders. One thing I have done was to stick to modifications of existing integer power Mandelbrot formula. All Mandelbrots have infinite detail which increases the deeper you zoom. I have merely developed a systematic process for inserting abs() commands into fractal formula. The abs() acts as a mirror reflecting portions of the fractal across an imaginary or real axis. Zooming in deeper causes a kaleidoscope-like effect creating strikingly beautiful patterns totally unlike the standard Mandelbrots but with dendrites and minis and self-similarity but not self-congruency, with ever increasing complexity not unlike the standard Mandelbrot.

From a close inspection of the resultant render you provided, it appears the fractal is "blobby" without much evidence of dendrites. This of course may change if one zooms in. I likewise once experimented with Panzerboy's Snake plugins on Fractal Extreme, but had difficulty finding the kinds of detail present in the other standardized abs() fractals. Maybe I wasn't looking hard enough?

Judging by your sample code, it appears you are actually defining a forth order equation. Streamlining your code a bit yields

Code:

				tempzi = zi*abs(zr)+zr*abs(zi)
				tempzr = zr*abs(zr)-zi*abs(ai)
				zi=tempzi;
				zr=tempzr;

				zrsqr = zr * zr;
				zisqr = zi * zi;
				zi = zr * zi * 2.0 + JuliaI;
				zr = zrsqr - zisqr + JuliaR;

I have eliminated the second pair of zrsqr and zisqr defines, because zrsqr and zisqr are not used in the top half of the equation.

Compare the above rewritten definition to my "nested" forth order Mandelbrot and you'll notice some similarities.

Code:

				zrsqr = zr * zr;
				zisqr = zi * zi;
				zi = zr * zi * 2.0;
				zr = zrsqr - zisqr;

				zrsqr = zr * zr;
				zisqr = zi * zi;
				zi = zr * zi * 2.0 + JuliaI;
				zr = zrsqr - zisqr + JuliaR;

The above code expresses a 4th order Mandelbrot as Z1 = (Z0^2)^2) +C,
slightly reducing the complexity and increasing code efficiency by removing the polynomial element.

Removing the abs() commands from your equation yeilds:

Code:

				tempzi = zi*zr*2
				tempzr = zrsqr - zisqr
				zi=tempzi;
				zr=tempzr;

				zrsqr = zr * zr;
				zisqr = zi * zi;
				zi = zr * zi * 2.0 + JuliaI;
				zr = zrsqr - zisqr + JuliaR;

which is equivalent to Z= (z^2)^2 + C

But your fractal looks nothing like a fourth order fractal. Interesting nonetheless. I have found through experimentation that expanding the polynomial and adding an abs() commands to individual terms within it, creates whispy cobweb like structures, at least with the third order, although I'll admit I've not tried splitting a zrsqr or zisqr into zr*abs(zr) or zi*zbs(zi). I'm trying to figure a way to express this in the FX sampleplugin so I can play with it a bit, without declaring new variables. I may recycle and repurpose zrsqr and zisqr in the first half of the formula.

[stardust4ever]

Playing around with it now attempting to duplicate yours. I did not achieve the same result, but I thought I'd share this.

Code:

Radiant Burning Ship:
		zrsqr = zr * zr;
		zisqr = zi * zi;
		zi = zr * zi * 2.0;
		zr = zrsqr - zisqr;
		
		zrsqr = zr * abs(zr);
		zisqr = zi * abs(zi);
		zi = zr * zi * 2.0 + JuliaI;
		zr = zrsqr - zisqr + JuliaR;

The higher the bailout, the longer the "rays". Current bailout in the preview is set to 1024.

EDIT: This should probably be split off into separate topic.

[simon.snake]

EDIT: This should probably be split off into separate topic.

Yes, I agree.  I have the plugin available to use in 64 bit Fractal Extreme (it's one of the few that don't crash FX) that I can upload (hopefully as an attachment here).

There are lots of interesting structures in the fractal, but also some dust depending on where you look.  For the most part there is a huge variety of styles when zooming deeper.

Simon

[stardust4ever]

For some odd reason, rearranging the code eliminates the artifacts. I attempted to apply the "rays" effect to the standard mandelbrot by manipulating the code. I just got a standard Mandelbrot, no "rays."

My previous "radiant" BS: Defining zrsqr and zisqr at the end of the formula rather than the beginning creates the same fractal without the rays. So not knowing the cause of this artifact, it may not be possible to reproduce in other software.

Code:

Non-radiant BS:
		zi = zr * zi * 2.0;
		zr = zrsqr - zisqr;
		zrsqr = zr * abs(zr);
		zisqr = zi * abs(zi);

		zi = zr * zi * 2.0 + JuliaI;
		zr = zrsqr - zisqr + JuliaR;
		zrsqr = zr * zr;
		zisqr = zi * zi;

[simon.snake]

^^Is this dll for the 32-bit or 64-bit Fractal Extreme?

The dll is for 64-bit.

I can also show you the FractInt formula code, and some sample zooms.

Code:

simon0100-A {
  if (ismand)  // This section allows you to hit space in FractInt and view the corresponding julia
    z = c = pixel
  else
    z = pixel
    c = p1
  endif: // The colon separates any pre-initialisation from the iterated code
  z = z * abs(z)  // z times abs(z)
  z = z * z + c    // then as normal mandelbrot
  |z| < 4         // bailout when the condition is false
}

Saved GIFs to follow.

[stardust4ever]

Neato. The minis in your snake100 have iteration bands resembling wifi icons. 

[simon.snake]

Neato. The minis in your snake100 have iteration bands resembling wifi icons. 

Thought you'd find it interesting.

[stardust4ever]

Thought you'd find it interesting.

Nice plugin. Just an FYI, FX crashes when I double click the .fx file but not when I load the file from within the software. Glad you got arbitrary precision working and 64 bits.

New video should be live in about 20 minutes. I'm going to bed.
<a href="http://www.youtube.com/v/x5aAbEoQuM8&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/x5aAbEoQuM8&rel=1&fs=1&hd=1</a>

[TheRedshiftRider]

I just uploaded a new version of Kalles Fraktaler to http://www.chillheimer.de/kallesfraktaler/
A bunch of new fractals added, among them 4th and 5th power Burning Ship, Buffalo, Celtic, Mandelbar, and many more!
Thanks to stardust4ever for the easily accessible formulas, your nomenclature is the standard names of these fractals now!

Thanks for adding the formula's it is great to see them in this detail.

Thought you'd find it interesting.

That is a very interesting formula.

[simon.snake]

Nice plugin. Just an FYI, FX crashes when I double click the .fx file but not when I load the file from within the software. Glad you got arbitrary precision working and 64 bits.

I have always been plagued with crashing in my plugins.  The reason is complicated, but maybe easier to resolve now.  Not being a student or blessed with loads of money, I downloaded the free Visual Studio 2010 Express and installed it.  This didn't come with 64-bit support.  Reading about it online, there was someone who had managed to incorporate 64-bit support into that version of VS by installing the Windows Driver Development Kit and tweaking a few things here and there within VS.  I followed his instructions to the letter, and it did provide 64-bit support, but most of my plugins crash.  It's probably a small tweak that needs to be made, but I've never spent time investigating or solving the issue.  In the meantime, I've been helped by panzerboy who would take my source files and recompile them for me in his environment, which appears to solve the crashing issues, but I've stopped creating plugins for a while.  Maybe now I'm migrating all my old stuff to my new laptop I'll start going once more.

I've been waiting for Microsoft to release a new version of VS with 64-bit support included for free, and then I'll try again.

It's time to start looking for that, since the release of Windows 10 I feel they'll be encouraging programmers to jump aboard.

[stardust4ever]

Well I do have Visual Studio 2010 Pro that MS sent me for free just for having an EDU email, but am pretty hardcore newb about using it and don't have much real experience programming anything beyond graphing calculator TI-Basic, which is a child's toy by comparison. If you've got your plugins 100% finalized, I might be able to compile them. Maybe you could zip the projects and send them over...

[Kalles Fraktaler]

I can do any formula in perturbation as long as each term only contains one abs value.
abs(a)*abs(a) is equal to abs(a*a)
However for example "4th Celtic Real Quasi Heart" contains
zi = 4 * abs(zr) * zi * abs(zrsqr - zisqr) + JuliaI;
This is not the same as 4 * zi * abs(zr*zrsqr - zr*zisqr) + JuliaI so I don't know how to handle that.

So, what do we call the new formula from Simon Snake, is "FT_Simon100A_plain" a good name?
Expanding this function, also to be used for calculating the high precision reference, gives:
xn = y*y*abs(y*y)-4*y*abs(x*y)*x-x*x*abs(y*y)-y*y*abs(x*x)+x*x*abs(x*x) + x0;
yn = - 2*x*y*abs(y*y)-2*y*y*abs(x*y)+2*x*x*abs(x*y)+2*x*y*abs(x*x) + y0;
Adding perturbation, (reference+delta)-reference, gives:
xn = (y+b)*(y+b)*abs((y+b)*(y+b))-4*(y+b)*abs((x+a)*(y+b))*(x+a)-(x+a)*(x+a)*abs((y+b)*(y+b))-(y+b)*(y+b)*abs((x+a)*(x+a))+(x+a)*(x+a)*abs((x+a)*(x+a))
   - y*y*abs(y*y)+4*y*abs(x*y)*x+x*x*abs(y*y)+y*y*abs(x*x)-x*x*abs(x*x) + x0;
yn = - 2*(x+a)*(y+b)*abs((y+b)*(y+b))-2*(y+b)*(y+b)*abs((x+a)*(y+b))+2*(x+a)*(x+a)*abs((x+a)*(y+b))+2*(x+a)*(y+b)*abs((x+a)*(x+a))
   + 2*x*y*abs(y*y)+2*y*y*abs(x*y)-2*x*x*abs(x*y)-2*x*y*abs(x*x) + y0;
Analyzing the first term, we have (reference+delta)=(y+b)*(y+b)*abs((y+b)*(y+b)) and reference=y*y*abs(y*y)
Expand gives (y*y+2*b*y+b*b)*abs(y*y+2*b*y+b*b) - y*y*abs(y*y)
Rearranging so that we can identify what's in laser-blaster's abs-method and what's the rest:
y*y*abs(y*y+2*b*y+b*b) - y*y*abs(y*y) + (2*b*y+b*b)*abs(y*y+2*b*y+b*b)
y*y is the ref for laser-blaster's abs-method and 2*b*y+b*b is the delta:
y*y*lb_abs_db(y*y,2*b*y+b*b) + (2*b*y+b*b)*abs(y*y+2*b*y+b*b)
Repeat for the next 8 terms, and you get:
xn = y*y*lb_abs_db(y*y,2*b*y+b*b)-4*y*x*lb_abs_db(x*y,x*b+a*y+a*b)-x*x*lb_abs_db(y*y,2*b*y+b*b)-y*y*lb_abs_db(x*x,2*x*a+a*a)+x*x*lb_abs_db(x*x,2*x*a+a*a)
   + (2*b*y+b*b)*abs(y*y+2*b*y+b*b)-4*(y*a+b*x+b*a)*abs(x*y+x*b+a*y+a*b)-(2*x*a+a*a)*abs(y*y+2*b*y+b*b)-(2*b*y+b*b)*abs(x*x+2*x*a+a*a)+(2*x*a+a*a)*abs(x*x+2*x*a+a*a) + a0;
yn = 2*x*x*lb_abs_db(x*y,x*b+a*y+a*b)+2*x*y*lb_abs_db(x*x,2*x*a+a*a)-2*x*y*lb_abs_db(y*y,2*b*y+b*b)-2*y*y*lb_abs_db(x*y,x*b+a*y+a*b)
   + 2*(2*x*a+a*a)*abs(x*y+x*b+a*y+a*b) +2*(x*b+a*y+a*b)*abs(x*x+2*x*a+a*a)-2*(x*b+a*y+a*b)*abs(y*y+2*b*y+b*b)-2*(2*b*y+b*b)*abs(x*y+x*b+a*y+a*b)  + b0;
And the result is stunning:
<a href="http://www.youtube.com/v/ENS4r4fdyKE&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/ENS4r4fdyKE&rel=1&fs=1&hd=1</a>