Re: multiplication of complex times a float
On 10 Sep., 10:46, foice wrote:
I am dealing with a rather long mathematical expression generated by a
CAS and this contains products of real numbers and complex numbers.
Of course the real numbers can be thought as complex and
multiplication between complex numbers would not be a problem.
Unfortunately the CAS gives output where a real is put in real form
and apparently a multiplication between a float and complex like this
amp = 2. * complex<float> (1.,1.);
cannot be digested by the compiler.
Mathematically the operation makes perfectly sense ... why is not
defined the multiplication of reals and complex?
The problem here is that template argument deduction fails. The C++
standard states that by including the <complex> header you get the
following function template among others:
template<class T>
complex<T> operator*(const T&, const complex<T>&);
We have two contexts where T can be deduced. Since you use a double
integral in combination with a complex<float> you'll have T=double for
the first parameter and T=float for the second parameter which is a
contradiction. This is a deduction failure and the function template
is ignored.
If you use 2.f instead of 2. it'll work.
There are a couple of tricks one could use if you have the chance to
write your own complex class. For example, you can define operator* in
class as a friend. This way, it's not a template so T doesn't have to
be deduced:
template<class T>
class mycomplex
{
T real_, imag_;
public:
mycomplex(T r=0, T i=0) : real_(r), imag_(i) {}
...
friend mycomplex operator*(T s, mycomplex const& c)
{
return mycomplex(s*c.real,s*c.imag);
}
...
};
Another way of handling the template parameter deduction problem is to
disable deduction for one parameter:
template<class T>
struct identity {typedef T type;};
template<class T>
complex<T> operator*(const typename identity<T>::type&,
const complex<T>&);
Here, identity<T>::type is not a deducible context with respect to the
template parameter T. So, given your example, T will be deduced to be
float and the double value would be converted to float.
But as soon as you make mycomplex<U> convertible to mycomplex<T> with
this
template<class U>
mycomplex(mycomplex<U> const& c)
: real(c.real()), imag(c.imag())
{}
you will probably get ambiguities in a situation like yours:
2.0 * mycomplex<float>(1,0)
operator*(double,mycomplex<double>) or
operator*(float, mycomplex<float>) ??
To emulate "the usual arithmetic conversions" one probably has to use
two template parameters:
template<class T, class U>
mycomplex<Z> operator*(T s, mycomplex<U> const&);
where picking Z is not that easy if you can't use the decltype
operator of C++0x. The BOOST_TYPEOF macro could help here.
Cheers!
SG