Welcome to Fractal Forums

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! :)

Whoo-Hoo! ;D
:banana: :chilli: :banana: :chilli: :banana: :chilli: :banana: :chilli: :banana: :chilli:

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

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.:


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

Simon

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
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.

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:


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.

Playing around with it now attempting to duplicate yours. I did not achieve the same result, but I thought I'd share this.
The higher the bailout, the longer the "rays". Current bailout in the preview is set to 1024. O0

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

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

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." :tongue1:

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. :tongue1:

The dll is for 64-bit.

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


Saved GIFs to follow.

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

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.
https://youtu.be/x5aAbEoQuM8

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

That is a very interesting formula.

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.

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...

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:
https://youtu.be/ENS4r4fdyKE

We do need a new name for this formula.  Suggestions welcome.  I thought of WIFIbrot, but that's only really describing one small part of the image (there are different looking areas towards the bottom middle for example).

I'm not all that imaginative (hence my user name on here still containing the word Simon), so thinking caps at the ready...   Go!

I started trying to look at all those algebraic equations and couldn't begin to understand them, so I'm mightily glad there are those out there who do.
 
Thanks.

Simon

I'm still quite a newbie at this but I recall the reason there has to be two sets of the equations is to optimise slightly.

The bottom ones are calculated just before returning to the for loop so the bailout can be performed at the right time with correct values.

In my case and also in the standard Mandelbrot, the top ones are used to assist when squaring Z so as to avoid creating additional temporary variables.

I do feel my code for Fractal eXtreme could have been optimised further to avoid creating expensive temporaries (especially when the high precision code is being called), just not the way you suggest.

Indeed, it has seahorse valleys and and such!
Do you have more formulas?

It should be. I would like to add that per the laws of mathematics, in dealing with real numbers, abs(x) is always positive. X^2 is always positive regardless of whether X is positive or negative. I'm not going to write a rigorous proof, but suffice to say that X^2 = |X|^2 = |x^2| for all real numbers.

Also |X| * |Y| is always equal to |X * Y| for real numbers, again because both outputs will always be positive. I used two abs() commands in the quasi heart formula because it was easy to write.

Zrsqr and Zisqr will always be positive no matter what because they are the square of a real number, however this is not the case for Zrsqr - Zisqr which can be positive or negative depending on which coefficient is bigger. So abs(Zrsqr - Zisqr) will have a different effect on each equation.

4.0 * abs(Zr) * Zi * abs(Zrsqr - Zisqr)

should be identical to

4.0 * Zi * abs(Zr * (Zrsqr - Zisqr))

based on the distributive and associative properties of multiplication, and the identity

|x| * |y| = |x * y|

is always true because a rule states that the product of two positive real numbers is always positive.

Unless something weird is going on in your code, these expression should be identical. Forgive me for not rearranging the equation to include a single abs() operation because it was easier for me to visually check my equations for typos or logic errors when each formula has terms laid out in the same order. If you feel one of my formulas is in error please let me know so I can check it.

I never attempted these formulas but yes,
4.0 * abs(Zr) * Zi * abs(Zrsqr - Zisqr) should be identical to 4.0 * Zi * abs(Zr * (Zrsqr - Zisqr))
So you are right :)

Sometimes unexplained consequences happen in software code that cannot be explained. For instance my "radiant" BS in the previous page, alternate version the 4th Mandelbrot BS formula created by subbing Zsqr for Z * abs(Z) in a "nested" powers resulted in "rays" emanating from the main brot because I placed the the Zsqr definition at the beginning of the code instead of the end. Copying these two code from beginning to end resulted in the same fractal without the ray artifacts. I attempted to duplicate this effect with the standard Mandelbrot and Burning Ship fractals for 2nd, 3rd, and 4th order by moving these two lines from end to beginning of the formula, with absolutely no percieved difference. Assuming all variables are zeroed out prior to the start of iteration, the results of placing Zsqr = Z * Z at the beinning or the end shouldn't matter, but it did have a dramatic effect for the alternate formula I discovered in trying to implement my own Snake brot.

And Simon.Snake, the Snake brot you provided is indeed forth order even though it has twofold symmetry. In my quick two minute zoom movie I produced, I made my last fork in the path around 90 zooms and hit the minibrot at 120. A second order equation would have placed the mini around 180 zooms if my last fork was at 90. O0

Yes the snake-brot is 4th order. I see it clearly because to get smooth gradients with high-bailout, log(power) is used, and there bands are clearly visible for other values
(If you see any bands in my movie, it's because the codec...)

Lots, but whether any of them are suitable candidates for conversion to Perturbation is another matter.  I am happy to upload a FractInt formula database that I have been writing since time immemorial.  Some are good, a lot are rubbish, some require mathematical operations such as cos, abs, sqrt etc. and some behave in strange ways or contain conditional branching to achieve different things.

I play about, and don't often know the consequences of my trial and error approach.

I'll upload it in a new thread, as it will be easier to find in the future.

Anything involving irrational functions or long division probably would not be a good candidate. Long division in arbitrary precision is a pain or so I've heard. At least I know it's super annoying to do base ten longhand on paper.

Irrational functions such as square roots, fractional powers, and trig functions require iteration to compute even at float precision so these would be a royal pain in the ass to do in arbitrary. Each iteration of said function would require many sub-iterations.

I presume absolute value works nicely because it is possible to create separate cases in code if the operand is negative or positive, and adjust the formula acordingly.

Beat you to it by a few hours, LOL! :dink:

I finally read the full post. I was on a mobile device without flash capability when I made my first reply and missed the embedded video! Fractal forums needs to update their embed code to support HTML5... :tongue1:

But seriously, this is awesome! :dink:

Kalles, are you doing repetitious multiplies? Defining common terms such as x*x or y*y by creating variables like Xsqr and Ysqr so you only have to compute them once, and using the distributive property when possible as I did in my FX float codes would reduce render time by eliminating unnecessary calculations.
:siren:

https://www.visualstudio.com/en-us/products/free-developer-offers-vs.aspx (https://www.visualstudio.com/en-us/products/free-developer-offers-vs.aspx)
Visual Studio community is free and supports 64 bit. I haven't as yet tried to build a FX plugin with it so no promises.

I have uploaded a version 2.9.6 which includes simon.snake's wonderful formula :)

I downloaded and installed VS Community 2015 yesterday, and when I attempt to load one of the solution files it says that the solution is Incompatible, and that "The Application is not Installed".

I think I read somewhere that the Community 2015 will allow you to edit and build incompatible sources if you have the appropriate Visual Studio version installed, which means I am no further forward.  :sad1:

I'm happily zooming in to somewhere magical right now, and it's so quick it is unbelievable.

One thing I would like to ask is this:  For those who understand the mathematics involved in my formula, could you attempt to explain in reasonably simple terms what is going on with the values, and, with regard to the fractal's properties, why it generates images that it does?

I don't know why it looks the way it does, and can't fathom it out, but I'd love to learn something about it, however basic.

I think I found a similar formula:

f(z)=(absre(z)*absim(z))^2+c

(http://i.imgur.com/b8BrJT3.png)

Simon, have you tried doing an order 3 version of your snake brot? The "radioactive" minis with twofold radiation aureola would look gnarly if they were threefold. Like real radiation symbols!!!

Instead of

try this

BTW, I have no idea what the output might look like, but I imagined radioactive logos everywhere...
(http://www.meshmag.hu/wp-content/uploads/2014/10/NUKE.jpg)

Hey stardust, I guess you've mistaken me for Simon.

I've had a look at this formula using some other software which simple lets you imput functions, like I did in the previous post.

There does not seem to be a way to do that. f(z)=(absre(z)*absim(z))^3+c will simply change the main fractal but the stretched lines stay the same. I guess we would have to play around with abs values to change that.

Sorry I'm up way past my bedtime. It's already daylight here... :sleep:

You are probably right about the circular bars. The initial symmetries may be twofold, as are many third order abs() functions. But then again with many 3rd order abs() fractals you get beautiful hexagonal kaleidoscope patterns after the pattern triplicates itself... The third order abs() fractals are beautiful, but the Snake brot is technically fourth order despite having an appearance like a second order set, and the 3-fold variant would actually be sixth order.

Sure interesting, however I am sorry I cannot extract real and imaginary parts from such format.

The radioactive symbol is definitely very interesting!

Ok, I'll look whether I can simplify it.



Edit: stardust, shouldn't you go to bed?


Edit2: I tried but I can't do it. (was the code from stardust the code of the original formula or the one I found?)

:sleep:

Now that you are still awake. Was that code you posted from the original formula by simon or was it the one I found?


Edit: well...

Sorry, instead of folding the wifi-radion 3 times, there two of them becomes lines only.
But I am maybe looking in the wrong section of this fractal...

The result has the 6th power...

Nevertheless, still a rather cool fractal. There is always the possibility of radiation patterns deeper into the set. But starting around sixth order and beyond, you need to zoom deep just to get away from minis. In my 9th Power B.S. "Madi Gras Masks" zoom video (use the search function), the minis were still quite large around the point at 43 zoom levels when the float point code ended.

Yep, I crashed pretty hard, but I need to be up again for class at 9am so good nights and I mean it this time. You European people are on very different time zones! The alarm crows early at 7am to prepare for my MWF.

I seem to suffer from delayed sleep cycle / non-24 at times and generally gravitate towards staying up at nights, but skipping bedtime every other night and falling into a 48-hour cycle is bad for anyone. The one time I travelled abroad (Italy, 2005) I experienced zero jet lag effects because I'm so used to constantly resetting my own body clock. :snore:

Kalles, first off thank you for your formulas! I am already doing another zoom video into the Quasi B.S. 5th.

I noticed you incorporated my "false" quasi perpendicular but not the real variant. The real variant which can be rewritten with Zr and the brackets inside the abs() to only use one abs() per line, has the best fractal details IMO of the quasi groups. In my opinion the "real" version contains better fractal detail than the "false" variants. Which is why I denoted it "false" because it absolutes neither the standalone Zr or Zi components.

Again I appologize if my 4th order list was long. I am flattered you incorporated so many! :D

Thanks stardust. Can you give the full name of the formula you are missing? They are so many now...
If it is "4th Real Quasi Perpendicular" or "4th Imag Quasi Perpendicular / Heart" - they are included in recently uploaded versoin 2.9.7 :)

Fortunately this page exist
http://quickmath.com/webMathematica3/quickmath/algebra/expand/basic.jsp
This enables me to quickly expand the formulas and apply perturbation on them.

If there are any more requested, for example from simon.snake's big file, I can add them as well, however I am having a hard time converting these to real/imag pair formulas.
When we are done adding formulas, I will make a version 2.10 that also implement the formulas in long double and floatexp, so that they can be unlimited zoomed (ok, e100000 is max for this and the next decade ;) )

Ah, never mind. I very briefly looked over the formulas and did not notice an additional grouping of 4th order formula after the 5th order ones. (see attachment) They are all in there it appears. My apologies there were so many 4th order equations but the way the formula factored out gave more combinations to play with.

I'm currently doing a zoom into the 5th Quasi B.S. Not very deep (2e65) but has large bailout or 500000 at the final mini so is taking some time. The expanded formulas can get quite unwieldy with the polynomials. I hope you are taking advantage of distributive property and defining variables for repeated terms like Zrsqr and Zisqr as this will reduce the number of multiply operations. The higher order perturbation formulas yield some pretty complex strings of polynomials with dr and di in addition to Zr and Zi, though if my understanding is correct, some of the smaller terms with delta exponents are so infinitesimal they could be safely eliminated in some circumstances.

For instance at arbitrary depth, the delta between two pixels within the image are tiny numbers not far off the end of useful precision. Such a pixel delta value squared, cubed, or raised to higher exponent would result in a smaller number than even arbitrary precision allows. Say the entire image has a width of 2^-96 and you are using 128-bit maths to calculate the orbits. Take any two pixels in the image, and the delta value will be equal to or less than 2^-96.

So with 128-bit calculations, and |dx| <= 2^-96

|dx^2| <= 2^-192
|dx^3| <= 2^-288
|dx^4| <= 2^-384

and so on. If the reference orbit is only calculated to a precision of 128 bits, then terms with 2 or greater exponent for dx^n could be safely discarded from the equation. This effect will continue to hold true at deeper and deeper iteration depths that

dx^n where n => 2

will be smaller than the least significant bit of the reference orbit. That is if my understanding of perturbation theory is correct. I could be way off base however as the delta values will slowly increase each iteration until the orbit finally escapes.

yes, at least the squares are stored in temprary variables.
One can probably examine each formula and replace much more, example:
The compiler is having a hard time optimizing all of this in release mode, it takes some 15-30 minutes to make a release build...

Regarding "small add-ends", as Botond called them...
Yeah, I have been on that track. However I found it hard, and Mandel Machine do fail to render some locations correctly. So I simply skipped it all togheter...

Kalles, first off, thank you, thank you, thank you for implementing our formulas. What you are doing is an incredible service to all fractal explorers.

While I have not made any qualitative tests with regards to render speed and efficiency, it seems the higher order formula (4th and 5th) are taking significantly longer compared to lower orders (2nd and 3rd). I am currently doing a zoom to ~e65 in the 5th order Quasi (hybrid) B.S. and chose a zoom location with relatively high bailout (500,000 at the final mini but this drops rapidly to under 100k as you zoom out), but my desktop is still chugging along about 44 hours in and has progressed roughly ~e10 outwards from the minibrot. For th lower orders, I would expect this slower rate of initial progress further out, ie beyond e300 or so.

My floating point code samples obviously did not include the expanded polynomials present within the perturbation code, but due to the long-winded polynomials with many terms required by perturbation, laws of diminishing returns take effect when using higher powers. It may even be plausible, if perturbation equations are significantly more complex, that for higher orders, full arbitrary precision might be slightly faster at lighter zoom levels (ie 128-256 bits). It is unfortunate if as you claim that nested powers, ie (Z^N1)^N2 do not "work" as I feel there may be great potential for code optimization using the nested power technique with prime factors for formulas of 6th order and higher.

Deep zooms using higher order formula also tend to be not as deep due to the simple fact that one does not have to zoom as far to reach a minibrot. My 5th Quasi B.S. zoom location currently rendering is highly ornate and I can't wait to share it.

I also cannot wait to explore the "3rd" (technically 6th) order Snake brot. I may explore it on my laptop, which has mobile quad core AMD with roughly one third the effective speed of my large desktop. With summer temps fast approaching in humid Louisiana, the room containing my desktop PC is currently isolated from the house AC and getting uncomfortably warm. The exhaust fan is like a mini hair dryer... :tongue1:

I guessed wrong. At deeper zoom level, it appear to have double-sided radions similar to the "2nd" version. :whistle2:

I think I have another "trick" or two up my sleeve though... :evil1: