QUICK Octal and Hex Fractals

[David Makin]

So, if we talk about speed, how long did your images take? (My generator: (root Mandelbrot, 800x600, 100 iterations, exponent = 500): 28 seconds.)

Do you mean for a quaternion in 3D, or the standard 2D Mandelbrot ?

I don't have a formula of my own that does 2D quaternions - though I think there are a couple in the Ultrafractal formula collection.

Benchmarking 3D in different software is fairly impossible since the viewpoint/angles/perspective/detail level etc. would all have to be the same.

For the standard 2D complex z^500+c in Ultrafractal with periodicity checking off and maxiter=100 for an exponent of 500 at 800*600 I get a time of under 5 seconds on my 3GHz P4 and I'm sure Ultrafractal uses the log method (as evidenced by the fact that I get roughly the same time for an exponent of 500.01).
You can obviously test this in Ultrafractal yourself on the same machine you did your timing on.

Out of interest I tried the default Quaternionic z^500+c * in 3D * at 800*600 on my 3GHz system using my older (very un-optimised 3D formula) and got a time of 2m 8s when the 500 is treated as fully quaternionic (i.e. as if the 3 imaginary components of the exponent are significant) and 1m 52s when it's treated as a real (i.e. assuming the 3 imaginary components are zero). It should be noted that these two times are 5* as slow as they should be due to 5 rays being cast per screen pixel to get the lighting normals (because I implimented the formula in UF so you could see the fractal as it is drawn and so there wouldn't be an issue with producing very large renders).
The current 3D formulas I'm working on are the aforementioned 5* faster due to only casting one ray per pixel plus around another 2* to 3* faster (for the same detail) due to using proper distance estimation in the ray tracing.

[Nahee_Enterprises]

So, if we talk about speed, how long did your images take?
(My generator: (root Mandelbrot, 800x600, 100 iterations, exponent = 500): 28 seconds.)

two points to make here:

• experience tells that you should really not mention speed in this thread
  (even if it's about assembly language and integers)
• to give a benchmark without so much as a machine spec is wholly useless

Yes, the "speed" is definitely relative.

[dentaku2]

Well, this thread is about speed, right? And I find it pretty useless talking about performance/speed if noone posts examples of their algorithms on their hardware/software configuration. Just to give an idea about what improvement can be achieved using this algorithm in favour of the other.

[David Makin]

Well, this thread is about speed, right? And I find it pretty useless talking about performance/speed if noone posts examples of their algorithms on their hardware/software configuration. Just to give an idea about what improvement can be achieved using this algorithm in favour of the other.

I think there are really just 2 algorithms being discussed - one can be either CPU arithmetic or FPU, the other only FPU.

The CPU/FPU version is where say z^16 is optimised as ((z^2)^2)^2 etc.
The FPU version is z^p optimised as exp(p*log(z)) for cases where the first method doesn't apply (e.g. p complex or fractional) and when p is a larger integer - the point at which the second method is optimum in the latter case depends on the compiler and the CPU/FPU combination that the code is run on so it's best to impliment both methods yourself and test which is best - in the case of Java code this test should be done at run-time.
When I wrote MMFrac I didn't bother with powers beyond 10 so even though using FPU code I didn't bother with the exp/log method.
I believe Ultrafractal chooses the optimum method depending on the value of the power but always calculates using FPU code - though I'm not altogether sure that the extended precision mode is FPU (or solely FPU).

[David Makin]

Oops - should have said that I think Ultrafractal decides on the method to use at compile time (which in UF is when you choose a formula or change a user parameter).
Also I said that Java needs to choose at runtime (prior to executing the main code) as the optimum method will vary depending on the host CPU/FPU.