As part of the project to produce a Boost TR1 implementation I've implemented the additional algorithms in <complex> that are part of the TR: fabs asin asinh acos acosh atan atanh It occurs to me that maybe these should really be spun out as a separate library rather than "slipped in" as part of another submission (comments welcome on that). In the mean time these algorithms can be downloaded as part of the TR1 library here: http://boost-sandbox.sourceforge.net/vault/index.php?&direction=0&order=&directory=tr1 All the inverse trig functions are defined for the full complex plain, and do the right thing even for exceptional input (no overflow or underflow during the computation if the result is actually representable). They also do the right thing for infinities and nan's, as specified by C99. The asin/asinh/acos/acosh algorithms have a theoretical max error bound of 9.5e (experimental bounds are much lower, about 4e), there is no theoretical work on atan/atanh that I know of, but experimentally the error bound seems lower than for asin/acos. This is some of the most heavily commented code I've written, so refer to the header for more information on the literature sources used etc. During the implementation I found that I needed a few other things that might make useful Boost components (part implemented, part wish list as noted below): log1p: ~~~~ This algorithm is part of C99, but by no means all compilers support it yet, I used a Taylor series expansion for small x: I'm aware that there are much more efficient methods, but optimizing compilers completely trash the logic of these (Intel C++ proved to be particularly bad). Series Summation (Kahan Method): ~~~~~~~~~~~~~~~~~~~~~~~~ I wrote a small routine to apply the Kahan summation method to a nullary-functor that generates successive terms in a series. Summation stops when the next term is below a particular threshold. I've found the Kahan method to be significantly more accurate for certain series, but again some highly optimizing compilers can cause small errors to creep in (I believe that the issue is double-rounding of intermediate terms on machines with extended-double registers). Probably my current interface to this one needs some more thought before it could be anything other than a detail, and if we're talking about wish lists, infinite product, and continued fraction evaluation would be useful additions too.... Floating point testing: ~~~~~~~~~~~~~~ Currently just a version of C99's isnan, and only works for quiet nan's with IEEE-conforming compilers. More of a wish list really, I could really use all the C99 fp-testing macros (as C++ functions obviously). Numeric constants: ~~~~~~~~~~~~~ Currently I've embedded the numeric constants used inside the implementation, a numeric constants library really would have simplified things... just a pity we could never agree on an interface last time this came up. Whew, I think that's all, thanks for reading this far! Regards, John.