title: How to get the real and imaginary parts of a complex matrix separately in CUDA?
body: <p>I'm trying to get the fft of a 2D array. The input is a <code>NxM</code> real matrix, therefore the output matrix is also a <code>NxM</code> matrix (<code>2xNxM</code> output matrix which is complex is saved in a NxM matrix using the property Hermitian symmetry). </p>
  
  <p>So i want to know whether there is method to extract in cuda to extract real and complex matrices separately ? In opencv split function does the duty. So I'm looking for a similar function in cuda, but I couldn't find it yet. </p>
  
  <p>Given below is my complete code</p>
  
  <pre><code>#define NRANK 2
  #define BATCH 10
  
  #include "cuda_runtime.h"
  #include "device_launch_parameters.h"
  #include &lt;cufft.h&gt;
  #include &lt;stdio.h&gt; 
  
  #include &lt;iostream&gt;
  #include &lt;vector&gt;
  
  using namespace std;
  
  int main()
      { 
  
      const size_t NX = 4;
      const size_t NY = 5;
  
      // Input array - host side
       float b[NX][NY] ={ 
          {0.7943 ,   0.6020 ,   0.7482  ,  0.9133  ,  0.9961},
          {0.3112 ,   0.2630 ,   0.4505  ,  0.1524  ,  0.0782},
          {0.5285 ,   0.6541 ,   0.0838  ,  0.8258  ,  0.4427},
          {0.1656 ,   0.6892 ,   0.2290  ,  0.5383  ,  0.1067}
      };
  
  
      // Output array - host side
      float c[NX][NY] = { 0 };
  
      cufftHandle plan;
      cufftComplex *data; // Holds both the input and the output - device side
      int n[NRANK] = {NX, NY};
  
      // Allocated memory and copy from host to device
      cudaMalloc((void**)&amp;data, sizeof(cufftComplex)*NX*(NY/2+1));
      for(int i=0; i&lt;NX; ++i){
          // Uses this because my actual array is a dynamically allocated. 
          // but here I've replaced it with a static 2D array to make it simple.
          cudaMemcpy(reinterpret_cast&lt;float*&gt;(data) + i*NY, b[i], sizeof(float)*NY, cudaMemcpyHostToDevice);
       }
  
      // Performe the fft
      cufftPlanMany(&amp;plan, NRANK, n,NULL, 1, 0,NULL, 1, 0,CUFFT_R2C,BATCH);
      cufftSetCompatibilityMode(plan, CUFFT_COMPATIBILITY_NATIVE);
      cufftExecR2C(plan, (cufftReal*)data, data);
      cudaThreadSynchronize();
      cudaMemcpy(c, data, sizeof(float)*NX*NY, cudaMemcpyDeviceToHost);
  
  
      // Here c is a NxM matrix. I want to split it to 2 seperate NxM matrices with each   
      // having the complex and real component of the output
  
      // Here c is in 
      cufftDestroy(plan);
      cudaFree(data);
  
      return 0;
      }
  </code></pre>
  
  <hr>
  
  <h2>EDIT</h2>
  
  <p>As suggested by  JackOLanter, I modified the code as below. But still the problem is not solved.</p>
  
  <pre><code> float  real_vec[NX][NY] = {0};       // host vector, real part
   float  imag_vec[NX][NY] = {0};       // host vector, imaginary part
  cudaError  cudaStat1 = cudaMemcpy2D (real_vec, sizeof(real_vec[0]), data,  sizeof(data[0]),NY*sizeof(float2), NX, cudaMemcpyDeviceToHost);
  cudaError  cudaStat2 = cudaMemcpy2D (imag_vec, sizeof(imag_vec[0]),data + 1,  sizeof(data[0]),NY*sizeof(float2), NX, cudaMemcpyDeviceToHost);
  </code></pre>
  
  <p>The error i get is 'invalid pitch argument error'. But i can't understand why. For the destination I use a pitch size of 'float' while for the source i use size of 'float2'</p>