Element wise multiplication of two arrays in C/C++
<p>I would like to perform Element wise multiplication of two arrays, both are of type complex but I am getting the following error message:</p>

<pre>serge@ubuntu:~/Downloads/OpenCV/opencv-2.4.9/build$ g++ -o myfft  myfft.cpp -std=c++14
In file included from myfft.cpp:14:0:
cs_delay.cpp: In function ‘void cs_delay(CArray&, int, int, int)’:
cs_delay.cpp:35:28: error: no match for ‘operator*’ (operand types are ‘void’ and ‘Complex {aka std::complex}’)
         x[j] = ifft(fft(x) * rot[j]);
                            ^
cs_delay.cpp:35:28: note: candidates are:
In file included from myfft.cpp:1:0:
/usr/include/c++/4.9/complex:381:5: note: template std::complex std::operator*(const std::complex&, const std::complex&)
     operator*(const complex& __x, const complex& __y)
     ^
/usr/include/c++/4.9/complex:381:5: note:   template argument deduction/substitution failed:
In file included from myfft.cpp:14:0:
cs_delay.cpp:35:35: note:   mismatched types ‘const std::complex’ and ‘void’
         x[j] = ifft(fft(x) * rot[j]);
                                   ^
In file included from myfft.cpp:1:0:
/usr/include/c++/4.9/complex:390:5: note: template std::complex std::operator*(const std::complex&, const _Tp&)
     operator*(const complex& __x, const _Tp& __y)
     ^
/usr/include/c++/4.9/complex:390:5: note:   template argument deduction/substitution failed:
In file included from myfft.cpp:14:0:
cs_delay.cpp:35:35: note:   mismatched types ‘const std::complex’ and ‘void’
         x[j] = ifft(fft(x) * rot[j]);
                                   ^
In file included from myfft.cpp:1:0:
/usr/include/c++/4.9/complex:399:5: note: template std::complex std::operator*(const _Tp&, const std::complex&)
     operator*(const _Tp& __x, const complex& __y)
     ^
/usr/include/c++/4.9/complex:399:5: note:   template argument deduction/substitution failed:
In file included from myfft.cpp:14:0:
cs_delay.cpp:35:35: note:   deduced conflicting types for parameter ‘_Tp’ (‘void’ and ‘double’)
         x[j] = ifft(fft(x) * rot[j]);
                                   ^
In file included from /usr/include/c++/4.9/valarray:587:0,
                 from myfft.cpp:3:
/usr/include/c++/4.9/bits/valarray_after.h:404:5: note: template std::_Expr, typename std::__fun::result_type> std::operator*(const std::_Expr&, const std::_Expr&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/4.9/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
In file included from myfft.cpp:14:0:
cs_delay.cpp:35:35: note:   mismatched types ‘const std::_Expr’ and ‘void’
         x[j] = ifft(fft(x) * rot[j]);
                                   ^
In file included from /usr/include/c++/4.9/valarray:587:0,
                 from myfft.cpp:3:
/usr/include/c++/4.9/bits/valarray_after.h:404:5: note: template std::_Expr, typename std::__fun::result_type> std:</pre>

<p>Function which returns error :</p>

<pre><code>//cs_delay.cpp
using namespace std;

typedef std::complex&lt;double&gt; Complex;
typedef std::valarray&lt;Complex&gt; CArray;


void cs_delay(CArray&amp; x, int rate_hz, int delay_s, int n)
{

const size_t N = x.size();
    if (N &lt;= 1) return;

int j;
double cycLen_s;
double nCyc;
double* f = new double[n];
double* phase = new double[n];
Complex* rot = new Complex[n];
cycLen_s = n/rate_hz;
nCyc = delay_s / cycLen_s;
/*************************************************************/
for ( j = 0 ; j &lt; n ; j++ ){

        f[j] =j+floor(n/2);
        f[j] =fmod(f[j], n);
        f[j] =f[j]-floor(n/2);
        phase[j] = -2 * PI * f[j] * nCyc;
        rot[j] = exp(1i*phase[j]);
        std::cout &lt;&lt; "rot["&lt;&lt;j&lt;&lt;"] ="&lt;&lt;rot[j] &lt;&lt;std::endl;
        fft(x);
        x *= rot[j];
        ifft(x);
        }
/*************************************************************/
        delete [] f;
        delete [] phase;
        delete [] rot;
}
</code></pre>

<p>fft and ifft are here:</p>

<pre><code>//fft.cpp
using namespace std;
const double PI = 3.141592653589793238460;


//functions declarations

typedef std::complex&lt;double&gt; Complex;
typedef std::valarray&lt;Complex&gt; CArray;
// Cooley–Tukey FFT (in-place, divide-and-conquer)
// Higher memory requirements and redundancy although more intuitive
void fft(CArray&amp; x)
{
    const size_t N = x.size();
    if (N &lt;= 1) return;

    // divide
    CArray even = x[std::slice(0, N/2, 2)];
    CArray  odd = x[std::slice(1, N/2, 2)];

    // conquer
    fft(even);
    fft(odd);

    // combine
    for (size_t k = 0; k &lt; N/2; ++k)
    {
        Complex t = std::polar(1.0, -2 * PI * k / N) * odd[k];
        x[k    ] = even[k] + t;
        x[k+N/2] = even[k] - t;
    }
}
// inverse fft (in-place)
void ifft(CArray&amp; x)

{
    // conjugate the complex numbers
    x = x.apply(std::conj);

    // forward fft
    fft( x );

    // conjugate the complex numbers again
    x = x.apply(std::conj);

    // scale the numbers
    x /= x.size();
}
</code></pre>

<p>here is my main function:</p>

<pre><code>#include &lt;complex&gt;
#include &lt;iostream&gt;
#include &lt;valarray&gt;
#include &lt;malloc.h&gt;
#include &lt;string&gt;
#include &lt;stdlib.h&gt;
#include &lt;fstream&gt;
#include &lt;cstdio&gt;
#include &lt;cstdlib&gt;
#include &lt;cmath&gt;
#include &lt;iomanip&gt;
#include &lt;cmath&gt;
#include "fft.cpp"
#include "cs_delay.cpp"
using namespace std;
//const double PI  = 3.141592653589793238460;
char filename[]  = "vidres6.txt";
char filename2[] = "vidres7.txt";

//typedef std::complex&lt;double&gt; Complex;
//typedef std::valarray &lt;Complex&gt; CArray;
/***********************************************************************************************
*                                 function declarations
************************** ******************************************************** ***********/
void fft(CArray&amp; x);
void ifft(CArray&amp; x);
void binFreq(int n);
void cs_delay(CArray&amp; x, int rate_hz, int delay_s, int n);

int main()

{
        int dTest_samples;
        int cTest;
        //cTest = -cTest;  
        int n=299;
        int i;
        int j;
        double x [n];

    /*****************************getting x*******************************/

        string line;
        double Result;
             ifstream myfile (filename);
             if (myfile.is_open())
               {
                 for ( i = 0 ; (i &lt; n) &amp;&amp; (myfile &gt;&gt; x[i]) ; ++i)

                        cout &lt;&lt; line &lt;&lt; '\n';
                         stringstream convert(line);

                         if ( !(convert &gt;&gt; Result) )
                        Result = 0;
                        x[i]=Result;


               }
                else cout &lt;&lt; "Unable to open file";
    /***********************************************************************/


    Complex test[n];

    for ( i = 0 ; i &lt; n ; ++i )
    test[i] = x[i];

    CArray data(test,n);

    // forward fft
    fft(data);

    std::cout &lt;&lt; "fft" &lt;&lt; std::endl;
    for (int i = 0; i &lt;n; ++i)
    {
        cout &lt;&lt; data[i] &lt;&lt; endl;
    }

    // inverse fft
    ifft(data);

    std::cout &lt;&lt; std::endl &lt;&lt; "ifft" &lt;&lt; std::endl;
    for (int i = 0; i &lt;n; ++i)
    {
        std::cout &lt;&lt; data[i] &lt;&lt; std::endl;
    }

    return 0;
}
</code></pre>