comparison bqvec/src/VectorOpsComplex.cpp @ 372:af71cbdab621 tip

Update bqvec code

     bqvec
 
     A small library for vector arithmetic and allocation in C++ using
     raw C pointer arrays.
 
-    Copyright 2007-2015 Particular Programs Ltd.
+    Copyright 2007-2016 Particular Programs Ltd.
 
     Permission is hereby granted, free of charge, to any person
     obtaining a copy of this software and associated documentation
     files (the "Software"), to deal in the Software without
     restriction, including without limitation the rights to use, copy,

     Particular Programs Ltd shall not be used in advertising or
     otherwise to promote the sale, use or other dealings in this
     Software without prior written authorization.
 */
 
-#include "bqvec/VectorOpsComplex.h"
+#include "VectorOpsComplex.h"
 
 #include <cassert>
-
-#ifdef __MSVC__
-#include <malloc.h>
-#define alloca _alloca
-#endif
 
 #if defined USE_POMMIER_MATHFUN
 #if defined __ARMEL__
 #include "pommier/neon_mathfun.h"
 #else
 #include "pommier/sse_mathfun.h"
 #endif
 #endif
 
-#ifdef __MSVC__
+#if defined(_MSC_VER) || defined(WIN32)
 #include <malloc.h>
+#ifndef alloca
 #define alloca _alloca
 #endif
+#else
+#include <alloca.h>
+#endif
+
+#include <iostream>
+
+using namespace std;
 
 namespace breakfastquay {
 
 #ifdef USE_APPROXIMATE_ATAN2
 float approximate_atan2f(float real, float imag)

         } else {
             atan = pi2 - z / (z * z + 0.28f);
             if (imag < 0.f) atan -= pi;
         }
     }
+
+    return atan;
 }
 #endif
 
 #if defined USE_POMMIER_MATHFUN
 

 
 #endif
 
 #ifndef NO_COMPLEX_TYPES
 
-#if defined HAVE_IPP
-
 void
 v_polar_to_cartesian(bq_complex_t *const BQ_R__ dst,
 		     const bq_complex_element_t *const BQ_R__ mag,
 		     const bq_complex_element_t *const BQ_R__ phase,
 		     const int count)
 {
     if (sizeof(bq_complex_element_t) == sizeof(float)) {
-	ippsPolarToCart_32fc((const float *)mag, (const float *)phase,
-                             (Ipp32fc *)dst, count);
+        v_polar_to_cartesian_interleaved((float *)dst,
+                                         (const float *)mag,
+                                         (const float *)phase,
+                                         count);
     } else {
-	ippsPolarToCart_64fc((const double *)mag, (const double *)phase,
-                             (Ipp64fc *)dst, count);
-    }
-}
-
-#elif defined HAVE_VDSP
-
-void
-v_polar_to_cartesian(bq_complex_t *const BQ_R__ dst,
-		     const bq_complex_element_t *const BQ_R__ mag,
-		     const bq_complex_element_t *const BQ_R__ phase,
-		     const int count)
-{
-    bq_complex_element_t *sc = (bq_complex_element_t *)
-	alloca(count * 2 * sizeof(bq_complex_element_t));
-
+        v_polar_to_cartesian_interleaved((double *)dst,
+                                         (const double *)mag,
+                                         (const double *)phase,
+                                         count);
+    }
+}
+
+void
+v_cartesian_to_polar(bq_complex_element_t *const BQ_R__ mag,
+                     bq_complex_element_t *const BQ_R__ phase,
+                     const bq_complex_t *const BQ_R__ src,
+                     const int count)
+{
     if (sizeof(bq_complex_element_t) == sizeof(float)) {
-        vvsincosf((float *)sc, (float *)(sc + count), (float *)phase, &count);
+        v_cartesian_interleaved_to_polar((float *)mag,
+                                         (float *)phase,
+                                         (const float *)src,
+                                         count);
     } else {
-        vvsincos((double *)sc, (double *)(sc + count), (double *)phase, &count);
-    }
-
-    int sini = 0;
-    int cosi = count;
-
-    for (int i = 0; i < count; ++i) {
-	dst[i].re = mag[i] * sc[cosi++];
-	dst[i].im = mag[i] * sc[sini++];
-    }
-}    
-
-#else
-
-void
-v_polar_to_cartesian(bq_complex_t *const BQ_R__ dst,
-		     const bq_complex_element_t *const BQ_R__ mag,
-		     const bq_complex_element_t *const BQ_R__ phase,
-		     const int count)
-{
-    for (int i = 0; i < count; ++i) {
-	dst[i] = c_phasor(phase[i]);
-    }
-    for (int i = 0; i < count; ++i) {
-        dst[i].re *= mag[i];
-        dst[i].im *= mag[i];
-    }
-}    
-
-#endif
+        v_cartesian_interleaved_to_polar((double *)mag,
+                                         (double *)phase,
+                                         (const double *)src,
+                                         count);
+    }
+}
+
+void
+v_cartesian_to_magnitudes(bq_complex_element_t *const BQ_R__ mag,
+                          const bq_complex_t *const BQ_R__ src,
+                          const int count)
+{
+    if (sizeof(bq_complex_element_t) == sizeof(float)) {
+        v_cartesian_interleaved_to_magnitudes((float *)mag,
+                                              (const float *)src,
+                                              count);
+    } else {
+        v_cartesian_interleaved_to_magnitudes((double *)mag,
+                                              (const double *)src,
+                                              count);
+    }
+}
 
 #if defined USE_POMMIER_MATHFUN
 
 //!!! further tests reqd.  This is only single precision but it seems
 //!!! to be much faster than normal math library sincos.  The comments

 
 void
 v_polar_interleaved_to_cartesian_inplace(bq_complex_element_t *const BQ_R__ srcdst,
                                          const int count)
 {
-    // Not ideal
     bq_complex_element_t mag, phase;
     int ii = 0, io = 0;
     for (int i = 0; i < count; ++i) {
         mag = srcdst[ii++];
         phase = srcdst[ii++];

         srcdst[io++] = mag * p.re;
         srcdst[io++] = mag * p.im;
     }
 }
 
-#endif
-
-}
+#endif // NO_COMPLEX_TYPES
+
+}