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

this sounds like a fundamental performance thing i was mostly unaware of     whenever i square something i just do x*x ... but there is a magic square function that implements some kind of math hax to make it faster?  how about for hardware floating point, is there a magic function for that also or is that just x*x ?

it looks like the c++ wrapper im using for mpfr calls mpfr_sqr for its sqr function.  you mention mpc_sqr in your article.  is it the same thing?

another thing i was wondering about was multiplying by 2.  i was noticing my code doing x+x and thinking to myself, hmm, there ought to be a mpfr function for multiplying by 2 by just adjusting the exponent or something?

for hardware floating point I use x*x too, but for arbitrary precision a special squaring function can be a fair bit faster than a regular multiply.  arbitrary precision libraries use a vector of limbs, each small enough that hardware operations can be used for them.  here's a multiplication with 3 limbs (considered as polynomial in the base):



now for squaring, so the right hand side can be simplified:


here are typically 64bit words (sometimes 32bit, it depends), and this doesn't take into account the carrying/normalization that needs doing to get it all to fit together properly but you can already see that this multiply takes 6 word-multiplies and 3 word-adds while the squaring takes only 4 word-multiplies, 1 word-add and 2 shifts

in actualilty this grade-school algorithm probably isn't used by MPFR and other high-quality arbitrary precision libraries except at low precisions, there are asymptotically faster ones like Karatsuba and Toom-Cook and even FFT-based methods for when you need to multiply huge numbers.

MPC is a C-wrapper for complex numbers around MPFR for real numbers.  mpc_sqr squares a complex number, mpfr_sqr squares a real number.  mpfr_mul_2si multiplies by a power of two very cheaply

Yes I used MPFR for all arbitrary precision calculation in the benchmark.  MPFR has lots of optimisations built in, like the ones you mention.  My benchmark only compares some different usages of MPFR to do complex squaring (MPFR is only for real numbers).  I could have been clearer in my post, the reason I counted squares and multiplications separately is because of the MPFR-provided optimized functions (where square(x) is cheaper than multiply(x,x)).  My reply to quaz0r was about real numbers, you explained it much more concisely, thanks!

None of this is Mandelbrot-specific, MPFR provides mpfr_sqr and mpfr_mul, and the MPC library for complex numbers over MPFR provides mpc_sqr (which uses (x+y)(x-y) for the real part) and mpc_mul too.

something to try I guess, try it and report back (I'm guessing grabbing a and b to double precision then calculating a^2+b^2 should work fine for glitch detection).

the naive way might be faster because the compiler could use SIMD to do vec3(x, y, x) * vec3(x, y, y) = vec3(x^2, y^2, xy) in one instruction.  but this is just a guess, disassembling a small snippet would tell for sure.

I don't know about mpr but I do know that other arbitrary precision libraries do not implement the Mandelbrot optimization.
If you want to make a 100% correct multiplication of say 10 digits, you must do all the 100 operations and produce 20 digits, because the least significant digit can theoretically turn all 9s into 10s and change the most significant digit. So in those libraries, even if you specify 10 digits as precision, it will internally use 20 for a correct multiplication. But when calculating Mandelbrot such small values can be ignored, and that even in apparently non-approximation programs like fractal extreme.
But the gain is 50%, and for squaring, 75%!
Just saying...