Welcome to Fractal Forums

I read most of the ~40 pages from different threads about the perturbation of the mandelbrot. And i looked into three of the existing programs, but can't see the forest for the trees. There seems to be so much code for speed optimization  and  different formulas etc. that I don't see the essence of what is needed at least for a working program. If someone were kind enough to express in pseudocode the main routines necessary, I'd appreciate it a lot. I even tried to do the maths mentioned in the sft.pdf but reached different results for the approx. series.
I have an arbitrary calculation library at hand and the graphics routines. How would the simplest way to calculate the pixels values look like?

I found this Program without series approximation but was wondering if the radius has to have arbitrary precision as well. As is the radius would be zero when zooming in and reaching doubles precision limit, or not?

i have not implemented pertubation theory myself, i think the best resource is the original poster of this thread:
http://www.fractalforums.com/announcements-and-news/superfractalthing-arbitrary-precision-mandelbrot-set-rendering-in-java/

he provides a minimal java pertubation implementation, this should be your main reference, all  other implement various fallbacks and error correction, but yout main goal should be to implement original posters java implementation as reference!

Hi,

https://en.wikibooks.org/wiki/Fractals/Iterations_in_the_complex_plane/Mandelbrot_set#Perturbation_theory
 http://code.mathr.co.uk/mandelbrot-perturbator/
http://mathr.co.uk/blog/2014-03-31_perturbation_glitches.html

HTH

Adam

Thank you for your replies. I must say I read most of the 17 pages from the first link and the minimal solution doesn't look minimal  at all to me an looks really cryptic as well. Talking about variable names and commentary and the all the overhead for antialiasing and what else in there that's not necessary for the basic algorithm.
It's just too much code for understanding the basics. And as i found out the first paper indeed has some mistakes in them as written here: http://math.stackexchange.com/questions/939270/perturbation-of-mandelbrot-set-fractal
in  the midst of the 17 page thread was also someone asking for an explanation for someone that hadn't been around since the time this idea came up.
It's not my intention to whine or criticize, I just appreciated it to learn about this awesome  method without flooding my head with information that I cannot use yet. I do my own share of experimenting with quality and speed etc. when the basic thing works.

you are right it is not easy; there are lots of aspects both to the algorithms and their implementation, and it all has to be perfect or it will blow up and not work right.  furthermore not all aspects to it necessarily even have the best possible solution worked out yet, nor have current techniques necessarily been set in stone or fully agreed upon even now, primarily regarding how to deal with precision loss (both in the perturbed iterations and in the computation of the series approximation) and also regarding how to approach implementing a stop condition for the iteration of the series coefficients.

i think a concise yet comprehensive writeup designed to actually teach and convey real understanding of the whole thing from the ground up (particularly for those who are not already a seasoned math/fractal/programming expert) is yet to appear, and any requests for such a thing will likely fall on deaf ears and disappear into the vacuum of exclusivity.  "i trudged through the 50000 pages of extraneous and poorly organized forum posts, and spent a bunch of time figuring a bunch of stuff out the hard way, i'll be damned if i see it made easy for you" is the general sentiment you are most likely to encounter.  of course that is just humans generally, not necessarily specific to mandelbrot perturbation  :-*

honestly what i did when i first started out was to trudge through the endless wasteland of forum posts in an attempt to sift for gold and copy-paste what looked to be the most relevant bits of actual information into a word processor and then use that to study from and refer to whilst attempting to understand it and implement it  88)  i dont think im the only one with such a tale to tell either, though i am one of those not-an-expert-in-any-of-the-things people... maybe everyone here but me is an expert.

I understand. This process is not yet ready to be made into a recipe.
With the mandelbulb and the other 3d stuff I did exactly that, searching the forum and writing code fragments bit by bit. With some questions and great help from the pros i built myself a working raytracer. Somehow it was easier to put the pieces together in that matter.
I have the very basic perturbation part working for now without series approx and without deep zooming.
It's really fast and already a success until 10^-16. I'm not sure how to calculate the whole image without arbitrary precision yet. When I zoom in all points have to be precise to differ from each other. So what to do there? Upscale them?
I'll try to write that pseudocode here myself once I'm sure how to do it right.

well, it is simply an area of ongoing research.  from time to time people are still coming up with interesting ideas for better ways to do things, like knighty's application of interval arithmetic to create a proper stop condition for the iteration of the series coefficients, and claude's novel approach to glitch handling.  one could certainly write up a nice article/tutorial/book/whatever if they were so inclined, it is just a matter of doing it.


as i said, up to 10¹⁶ or so people are doing the standard mandelbrot iterations with hardware floating point, as there is nothing to gain from series approximation or perturbation at those shallow depths.  in fact, the overhead is likely to be slower in comparison.  the perturbation stuff is what is employed to break the 10¹⁶ or so barrier.  with regard to your implementation, you indeed need to use arbitrary precision for the location and for the reference iteration, as this is limited by the precision of the mantissa as opposed to the exponent.

@Imagyx I hope you will write up some basic preturbation psuedo code. I have been watching these threads from the sideline because I am only interested in the basic concept and how it could be used elsewhere (3d, whatever) but haven't seen a stripped down version to get started with. Good luck!

Here is some C++ code that tries to be simple without lots of extra optimisations (but the trouble is the whole thing is quite complicated, so I guess it's still pretty hard to get to grips with):

https://code.mathr.co.uk/fractal-bits/blob/HEAD:/mandelbrot-series-approximation/m.cpp

It could do with lots more comments, to be sure.