Compute Mutliplication of complex numbers - c++

Question

What I am trying to do ultimately is multiplying two complex numbers like this:
z1 = R1 + I1*j
z2 = R2 + I2*j
z3 = z1 * z2 = (R1*R2 - I1*I2) (R1*I2 + R2*I1)*j;
But what I have are two separate vectors for the real and complex part of both those complex numbers. So something like this:
v1 = [R1, R2, R3, R4 ... Rn] of z1
v2 = [I1, I2, I3, I4 ... In] of z1
v1 = [R1, R2, R3, R4 ... Rn] of z2
v2 = [I1, I2, I3, I4 ... In] of z2
So when I am trying to calculate z3 now, I do this:
foo (std::vector<double> real1, std::vector<double> imag1,
std::vector<double> real2, std::vector<double> imag2)
{
std::vector<double> realResult;
std::vector<double> imagResult;
for (size_t i = 0; i < real1.size(); i++)
{
realResult.push_back(real1[i]*real2[i] - imag1[i]*imag2[i]);
imagResult.push_back(real1[i]*imag2[i] + real2[i]*imag1[i]);
}
//And so on
}
Now, this function is eating a lot of time. There sure is another way of doing that can you think of something that I can use?

Answer 1

You might be able to make use of std::complex. This probably implements operations you require at least close to as well as they can be implemented.
EDIT (In reply to comment):
I would do this:
size_t num_items = real1.size();
std::vector<double> realResult;
realResult.reserve(num_items);
std::vector<double> imagResult;
imagResult.reserve(num_items);
for (size_t i = 0; i < num_items; ++i) {
// lalala not re-sizeing any vectors yey!
realResult.push_back(real1[i] * real2[i] - imag1[i] * imag2[i]);
imagResult.push_back(real1[i] * imag2[i] + real2[i] * imag1[i]);
}
Otherwise if you have a large input array and you are doing a lot of multiplication on doubles I'm afraid that might just be slow. Best you can do is mess around with getting things contiguous in memory for bonus cache points. Impossible to really say without profiling the code exactly what might work best.

Answer 2

Pass in parameter as const std::vector<double>& to avoid unnecessary copy
You may also consider computing each multiplication in parallel, if N is big enough, the overhead of parallel computing is worthwhile

Answer 3

Use std::valarray of std::complex. It is simple and optimized for arithmetic operations
foo(std::valarray<std::complex<double>> & z1,
std::valarray<std::complex<double>> & z2)
{
auto z3 = z1 * z2; // applies to each element of two valarrays, or a valarray and a value
// . . .
}
EDIT: Convert vectors to valarray
std::valarray<std::complex<double>> z1(real1.size());
for (size_t i = 0; i < z1.size(); ++i)
z1[i] = std::complex<double>(real1[i], imag1[i]);