END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

That's essentialy what's being used

You should also note that because there is no "+1" involved in the derivative for Julia Sets of the form a*z^p+c then all you actually need is the running product of the magnitude i.e. you just do:

Dr = Dr*length(Zn)

where initial Dr is 1.0

Of course that optimisation won't adapt for exp(z)+c or z^p+z^p1+c etc.

Well I'm pretty sure I'm using a start for the running derivative of (1,0,0) in all cases and assuming you're starting with initial z as (0,0,0) then that's correct since on the first iteration for the Mandelbrot you get 0 + 1 for the running derivative anyway.

I think you're confusing my delta DE method and using a binary search when solid is hit ?

I created the delta DE method for formulas other than the Mandelbulb before Paul Nylander extended Daniel White's original formula to higher powers finding the Mandelbulb - the other formulas concerned, although simple, are not so easy to get the analytical derivatives for - in fact for the Mandelbrot version they really need the full Jacobian which is both complicated and slow to calculate.
I used the delta DE method for my earlier renders of the Mandelbulb because it worked and because I'm a little lazy when it comes to maths (rather than programming) and I waited for someone else to come up with an analytical DE for the Mandelbulb using the derivative (I'm not sure who came up with that first but Jos Leys described it to me).

As for the binary search - that's a separate subject, when you use DE (delta or derivative) but you set the solid threshold to a high value, i.e. for a low resolution render, then without using a binary search (by initially stepping backwards 1/2 the last step when solid is hit) you get "stepping" in the render.

I should add that for some renders of the Mandelbulb using the latest optimised version of my Ultra Fractal formula (not released yet) then in some cases using delta DE is actually faster than using derivative DE - but not when using the magnitude only method for the derivative.

I should add that the delta DE method will work with *any* formula that you can get accurate smooth iteration values for.

I think so, you need to use 2 points *on the ray* i.e. at vp + alpha*d (the current step position) and vp + (alpha+1e-10)*d because the method you're using (like mine) is directional unlike the analytical method which gives the minimum distance in any direction.

(vp = viewpoint (ray start), alpha = step, d = ray's unit direction vector)

As to the smooth iteration value, use:

smooth = final iter + 1 + (log(log(bailout))-log(log(final magnitude)))/log(power)

Or (for much more accurate results) instead of log(power) use log(log(|z|)/log(|zold|)) when final iter is >1 (where zold is the penultimate value of z i.e. z from the iteration prior to bailout).

Actually for delta DE purposes because the difference of the 2 smooth iteration values is actually used then when using /log(power) then both the +1 term and the log(log(bailout)) term can be omitted - if using the log(log(|z|)/log(|zold|)) method then the +1 can be omitted but not the bailout term. I don't omit anything in my code because the overhead is small anyway and often the full correct iteration value will be needed for colouring.
Note that the +1 term is only required anyway if bailout on the first iteration results in a final iter of zero rather than 1.

Binary search is for finding exact place where distance equals to DE threshold. Last DE step is always little too close (distance is less than DE threshold) and you have to cancel last step and go half step forward and check distance. When distance is to high you have to go forward or when distance is too small you have to go back again. In my programs I'm ending searching when distance is in range 90% - 100% of DE threshold. It is completely enough for all shading algorithms.

Yes, that would be the same as having a low threshold to begin with

Sometimes setting the DE large enough to avoid aliasing causes the stepping i.e. setting the DE threshold too small on a lower resolution image can cause aliasing but if you set it too high then you can get stepping.

Here's a gross example of the difference on a DE threshold animated quaternion (note that with my latest code the jagged artifacts on the version using the binary search have gone altogether):

http://makinmagic.deviantart.com/art/Plain-DE-animation-127361800

http://makinmagic.deviantart.com/art/Using-DE-Binary-Search-127362040

No, I didn't implemented it. But I think for it I have to change final condition if I implement it. Now I'm searching fractal boundary until I achieve proper distance. Maybe will it be better when I finish searching when I find required value of iteration count? Now when my program meets some place where there is wrong value of distance (for example iteration count in this place is very low) and this is unfortunately lees than distance threshold, it finishes searching. When DE values are accurate everything is very simple but for power 2 fractals unfortunately are very inaccurate, also analytical.
Tomorrow I will try also with smooth iteration value instead of last value of z.