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

I'm interested in supporting fractional escape counts for coloring the exteriors of Mandelbrot and Julia sets. Typically this is done using the log log of the magnitude of the escape value for a point:

mu = N + 1 - log (log  |Z(N)|) / log 2

Where N is the integer escape count, Z(N) is the complex value of the last iteration of the function when it reaches the escape threshold, |Z(N)| is the magnitude of the escape value { Z(N) = a+bi;  |Z(N)| = sqrt(a^2 + b^) }

What is the range of the values you get from this function, and how much precision do you need in order to create smoothly shaded plots with lots of color gradiation? (Right now I use integer escape values to color my plots, and assign a unique color value to every escape value, up to 65535 unique colors)

I was thinking of using 32 bit fixed point values for the fractional escape value (+- 2^15 + (2^16 - 1) / 16). That would let me represent numbers as large as 32767 and as small as about 1.53E-5. Alternately, I have available a "Fract" data type that is a 32 bit quantity with a 2 bit signed integer component and 30 bit fraction, which would let me handle numbers in the range of about +-4 to roughly 9.3E-10.


Duncan C

The fractional (or smooth) iteration count is given by the equation

mu = N + 1 + log( log(M) / log|z(N)| ) / log(p),

where
N is the iteration count
M is the bailout value
p is the power in the iterated equation z(n+1) = z(n)^p + c

The decimal part 1+log( log(M) / log|z(N)| ) / log(p) is in the range [0,1].

The smooth iteration count has discontinuities at the iteration boundaries. However, the discontinuity is very small for, say, M = 5, and decreases for larger bailouts. About the preferrable number presentation, I propose that you try the usual float or double and see if you encounter any problems with accuracy.

You can find a rather difficult to follow discussion of the smooth iteration count here:
http://linas.org/art-gallery/escape/escape.html
A more thorough discussion will be included in my soon-to-be-finished master's thesis on fractal coloring functions.

ok i skipped over the derivation of my formula last time, but since people seem to still be really attached to their sqrt computations, here it is in full:

log(log(x^1/2)) =
log(log(x)/2) =
log(log(x)) - log(2)

and since we have in the original expression log(log(x^1/2)) / log2 we get by substitution (log(log(x)) - log2) / log2 = log(log(x))/log2 - 1, and that - 1 cancels with the + 1, making the whole formula seem a lot more natural too. 1/log2 can and should be precomputed, since it is a constant (divides are two orders of magnitude slower!).

in most forums i'm on, simplifications and speedups are welcomed with open arms...

btw david, thanks for your insightful post!

always happy to make a contribution! those opportunities are few and far between for me

about fractals and maths: i recently had a chat with a good friend of mine (who is one hell of a fractalist) about this. he could also would benefit from a stronger mathematical grounding, however that's hardly hindered him! it turns out that when working with fractals, quite often you can pretty much do what you like and still get awesome looking results (an obvious corollary is that researchers tend to have boring images *dodges a thousand hurled chalkboard dusters*.) such a truth is completely unavoidable, so the only defense i could make for poor old mathematics at that stage is "knowing which rules you're breaking can give you more perspective and therefore power". however, it occurs to me now (returning to the matter at hand) that it has a further use, namely simplifying expressions*.

i referred him to this great website i found some years ago, S.O.S math (lol): http://www.sosmath.com/algebra/algebra.html

feel like you dozed too much during high school maths classes? get in line! the above site is really nice and concise, highly recommended. it goes deeper than just algebra and i still find some use for it now and then (it's great to finally master things i floundered with earlier).


* things like sqrt(x) < const, and the simplification given earlier are two such examples.