Boost logo

Boost :

Subject: Re: [boost] Determining interest: Pure imaginary number library
From: Matthieu Schaller (matthieu.schaller_at_[hidden])
Date: 2011-11-19 06:21:42

Thank you for your interest and your input.

I have corrected the mistakes spotted by Francis Smit and added casts
from/to std::complex as suggested by Vicente Botet.

Some comments about your proposals.

Comparing imaginary and reals seems confusing to me
> ///Returns true if x equals y
> template<typename T>
> inline bool operator==(const Imaginary<T>& x, const T& y);
> template<typename T>
> inline bool operator==(const T& x, const Imaginary<T>& y);

The SL offers comparison between std::complex<T> and T which only compare
the real part of the complex number and verifies that its imaginary part is
zero. I do the same here: I compare the imaginary part of both arguments
and verify that the real part of the complex is zero.

> The following divide assign operator is missing:
> Imaginary<T>& operator/=(const Imaginary<T>& rhs)

I don't think so. If you divide an imaginary number by another imaginary
number you obtain a real number which cannot be represented by this class.
Hence, the absence of this operator. The same is true for *=.

> Many years ago I proposed
> Maybe it can be of interest.

This looks like what I'm presenting here. Your proposal goes further in the
sense that it also modifies std::complex<T> to add the relevant
constructors and operators to the SL complex class but I can't do that here
even if it would be more "symmetric" vis-a-vis the real numbers. The
complex class could be modified to interact in a better way with pure
imaginary numbers but this cannot really be done.

I will replace

T& imag();
> const T& imag() const;
> by
> T imag() const;

I have modified the code as you suggested as it seems that the norm imposes
the latter form for std::complex. Even though I don't really see why. A
non-const access could simplify the notation in some cases and I don't see
any smarter implementation than just
T m_real;
T m_imag;
but I will conform to the norm and only provide const access.

While I like the trick, it could break a lot of code. Could the addition of
> a user literal allow to use it as
> complex_t z = 4.2 + 3.0i;

I haven't had a look at this until now but this may allow to simplify the
notation even more. I see a slight drawback: it uses a C++11 feature which
prevents its use with older compilers and these are often the compilers
used by scientists on computing platforms. It is quite rare to have access
to the last compiler versions in numerical computing.

Thanks again for your input. I will "boostify" the code to make it follow
more closely the code guiding rules, add a boost-like documentation and
prepare more examples.



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