Boost logo

Boost :

Subject: Re: [boost] Review request: extended complex number library
From: Matthieu Schaller (matthieu.schaller_at_[hidden])
Date: 2012-03-07 05:42:43

Dear all,

Thanks for your comments.

    How about having a boost::real<T> (or whatever you want to name it),
    that references a complex number with an imaginary part set to 0?

This could in principle be done but I don't think that it is a good
thing to do. boost::real<> would be a wrapper around the double type
say. Now, this would require to rewrite all the mathematical functions
for this type. Furthermore, people doing numerical sciences will
probably not be keen to drop the use of native POD variable for simple
It is true that some functions could be modified to return complex
values instead of NaNs but this would come at a performance cost when
performing real only computations.

    Seems quite interesting. One issue I have though, as a user of gcc/libstdc++, I
    see that the versions of many std::complex operations seem to be optimized in
    terms of gcc builtins. For example:

       inline float
       __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }

       inline double
       __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }

    So if I switched to boost::complex, I'd loose these optimizations.
    Is it useful to have an imaginary library that complements std::complex, rather
    than replaces it?

I am actually using the std::complex<> versions for all non-trivial
operations. This means that built-in functions can be used by the compiler.
Now, you found one example (abs()) where this is not done. Measurements
showed that this was not necessary for this particular operation but for
consistency, I could do this for all operations.

    I'm not sure implicit conversion are desirable, but what about explicit
    conversions to/from std::complex? and a make_complex function?

I don't think that implicit conversions to/from std::complex should be
used. But you are right, I should provide an explicit conversion
constructor and a make_complex function. I could then write

inline boost::complex<float> cos(const boost::complex<float>& x)
     return boost::complex<float>(std::cos(make_std_complex<float>(x));



Matthieu Schaller

Boost list run by bdawes at, gregod at, cpdaniel at, john at