benchmark/fourier/parallel/pi/xeonphi/openmp/fourier-parallel-pi-xeonphi-openmp.c
void butterfly_right(data_t* out, data_t* in, uint32_t size, uint32_t N){
  uint32_t bit;
      
  // For each bit in the segment (note we are offsetting out by size/2!
  for(out += size/2, bit = 0; bit < size/2; bit++){
    out[bit] =                              //  set the current (new) bit to
      mul(                                  //   the multiplication of
        sub(                                //    the sum of the
          in[bit],                          //     the (size/2)-prev bit, and
          in[bit+size/2]),                  //     the next one
        omega(N,                            //    times the Nth root of unity,
              bit*(N/size)));               //     to the power of 0,1,2 first,
  }                                         //     0,2,4 second, etc.

  return;
}
// This function computes the right half of an n-point butterfly. Note it only
// writes to the _second_ half of the output.
//
//   out,in:                 output and input arrays
//   size:                   size of the butterfly
//   N:                      input size of the broader FFT
//
This function computes the right half of an n-point butterfly. Note it only
writes to the _second_ half of the output.

out,in:                 output and input arrays
size:                   size of the butterfly
N:                      input size of the broader FFT
This function computes the right half of an n - point butterfly . Note it only writes to the _second_ half of the output . out in : output and input arrays size : size of the butterfly N : input size of the broader FFT
void butterfly_right(data_t* out, data_t* in, uint32_t size, uint32_t N){
  uint32_t bit;
  for(out += size/2, bit = 0; bit < size/2; bit++){
    out[bit] =                              
      mul(                                  
        sub(                                
          in[bit],                          
          in[bit+size/2]),                  
        omega(N,                            
              bit*(N/size)));               
  }                                         
  return;
}
void butterfly_right ( data_t * out , data_t * in , uint32_t size , uint32_t N ) { uint32_t bit ; for ( out += size / 2 , bit = 0 ; bit < size / 2 ; bit ++ ) { out [ bit ] = mul ( sub ( in [ bit ] , in [ bit + size / 2 ] ) , omega ( N , bit * ( N / size ) ) ) ; } return ; }
This function computes the right half of an n-point butterfly.
This function computes the right half of an n - point butterfly .
// For each bit in the segment (note we are offsetting out by size/2! //  set the current (new) bit to //   the multiplication of //    the sum of the //     the (size/2)-prev bit, and //     the next one //    times the Nth root of unity, //     to the power of 0,1,2 first, //     0,2,4 second, etc.