Merge pull request #98 from antisvin/feature/quadrature

Quadrature oscillator and complex signals

Author: pingdynasty

LibSource/ComplexFloatArray.cpp

@@ -312,3 +312,16 @@ ComplexFloatArray ComplexFloatArray::create(size_t size){
 void ComplexFloatArray::destroy(ComplexFloatArray array){
   delete[] array.data;
 }
+
+void ComplexFloatArray::copyFrom(FloatArray real, FloatArray imag) {
+  for (size_t i = 0; i < getSize(); i++) {
+    data[i] = ComplexFloat(real[i], imag[i]);
+  }
+}
+
+void ComplexFloatArray::copyTo(FloatArray real, FloatArray imag) {
+  for (size_t i = 0; i < getSize(); i++) {
+    real[i] = data[i].re;
+    imag[i] = data[i].im;
+  }
+}

LibSource/ComplexFloatArray.h

@@ -3,10 +3,15 @@
 
 #include "FloatArray.h"
 #include "basicmaths.h"
+
 /**
 * A structure defining a floating point complex number as two members of type float.
 */
 struct ComplexFloat {
+  constexpr ComplexFloat() : re(0), im(0) {}
+  constexpr ComplexFloat(float x) : re(x), im(0) {}
+  constexpr ComplexFloat(float re, float im) : re(re), im(im) {}
+
   /**
    * The real part of the complex number.
    */
@@ -75,6 +80,20 @@ struct ComplexFloat {
     im = magnitude*sinf(phase);
   }
 
+  /**
+   * Returns complex conjugate - a copy of current number with imaginary part inverted
+   */
+  ComplexFloat getComplexConjugate() const {
+    return ComplexFloat {re, -im};
+  }
+
+  /**
+   * Returns dot product with another complex float value
+   */
+  ComplexFloat getDotProduct(ComplexFloat other) const {
+    return ComplexFloat {re * other.re - im  * other.im, re * other.im + im * other.re};
+  }
+
   bool operator<(const ComplexFloat& other) const {
     return getMagnitudeSquared() < other.getMagnitudeSquared();
   }
@@ -99,6 +118,88 @@ struct ComplexFloat {
     return re != other.re || im != other.im;
   }
 
+  friend const ComplexFloat operator+(const ComplexFloat&lhs, const ComplexFloat& rhs) {
+    ComplexFloat result = lhs;
+    result += rhs;
+    return result;
+  }
+
+  friend const ComplexFloat operator+(const ComplexFloat&lhs, float rhs) {
+    ComplexFloat result = lhs;
+    result += rhs;
+    return result;
+  }
+
+  ComplexFloat& operator+=(float other) {
+    re += other;
+    return *this;
+  }
+
+  ComplexFloat& operator+=(const ComplexFloat& other) {
+    re += other.re;
+    im += other.im;
+    return *this;
+  }
+
+  friend const ComplexFloat operator-(const ComplexFloat&lhs, const ComplexFloat& rhs) {
+    ComplexFloat result = lhs;
+    result -= rhs;
+    return result;
+  }
+
+  friend const ComplexFloat operator-(const ComplexFloat&lhs, float rhs) {
+    ComplexFloat result = lhs;
+    result -= rhs;
+    return result;
+  }
+
+  ComplexFloat& operator-=(float other) {
+    re -= other;
+    return *this;
+  }
+
+  ComplexFloat& operator-=(const ComplexFloat& other) {
+    re -= other.re;
+    im -= other.im;
+    return *this;
+  }
+
+  friend const ComplexFloat operator*(const ComplexFloat&lhs, const ComplexFloat& rhs) {
+    ComplexFloat result = lhs;
+    result *= rhs;
+    return result;
+  }
+
+  friend const ComplexFloat operator*(const ComplexFloat&lhs, float rhs) {
+    ComplexFloat result = lhs;
+    result *= rhs;
+    return result;
+  }
+
+  ComplexFloat& operator*=(float other) {
+    re *= other;
+    im *= other;
+    return *this;
+  }
+
+  ComplexFloat& operator*=(const ComplexFloat& other) {
+    re = re * other.re - im * other.im;
+    im = re * other.im + im * other.re;
+    return *this;
+  }
+
+  friend const ComplexFloat operator/(const ComplexFloat&lhs, float rhs) {
+    ComplexFloat result = lhs;
+    result /= rhs;
+    return result;
+  }
+
+  ComplexFloat& operator/=(float other) {
+    re /= other;
+    im /= other;
+    return *this;
+  }
+
 };
 
 class ComplexFloatArray : public SimpleArray<ComplexFloat> {
@@ -396,6 +497,24 @@ class ComplexFloatArray : public SimpleArray<ComplexFloat> {
    * @param[out] destination The destination array.
   */
   void setMagnitude(FloatArray magnitude, int offset, size_t count, ComplexFloatArray destination);
+
+  using SimpleArray<ComplexFloat>::copyFrom;
+  using SimpleArray<ComplexFloat>::copyTo;
+  /**
+   * Merge two channels of audio containing real and imaginary axis data into this array
+   * 
+   * @param[in] real Real axis data
+   * @param[in] imag Imaginary axis data
+  */
+  void copyFrom(FloatArray real, FloatArray imag);
+
+  /**
+   * Split complex data into two channels of audio containing real and imaginary axis data
+   * 
+   * @param[in] real Real axis data
+   * @param[in] imag Imaginary axis data
+  */
+  void copyTo(FloatArray real, FloatArray imag);
 };
 
 #endif // __ComplexFloatArray_h__

LibSource/ComplexOscillator.h

@@ -0,0 +1,61 @@
+#ifndef __COMPLEX_OSCILLATOR_H__
+#define __COMPLEX_OSCILLATOR_H__
+
+#include "SignalGenerator.h"
+#include "Oscillator.h"
+
+/**
+ * A complex oscillator is a MultiSignalGenerator with 2 channels that
+ * operates at a given frequency and that can be frequency modulated.
+ *
+ * A single sample is represented as a ComplexFloat value, while blocks
+ * of audio are stored in an AudioBuffer with 2 channels.
+ */
+class ComplexOscillator : public ComplexSignalGenerator {
+public:
+  ComplexOscillator() = default;
+  virtual ~ComplexOscillator() = default;
+  using ComplexSignalGenerator::generate;
+  /**
+   * Set oscillator sample rate
+   */
+  virtual void setSampleRate(float value){}
+  /**
+   * Set oscillator frequency in Hertz
+   */
+  virtual void setFrequency(float value) = 0;
+  /**
+   * Get oscillator frequency in Hertz
+   */
+  virtual float getFrequency() = 0;
+  /**
+   * Set current oscillator phase in radians
+   * @param phase a value between 0 and 2*pi
+   */
+  virtual void setPhase(float phase) = 0;
+  /**
+   * Get current oscillator phase in radians
+   * @return a value between 0 and 2*pi
+   */
+  virtual float getPhase() = 0;
+  /**
+   * Reset oscillator (typically resets phase)
+   */
+  virtual void reset() = 0;
+  /**
+   * Produce a sample with frequency modulation.
+   */
+  virtual ComplexFloat generate(float fm) = 0;
+  /**
+   * Produce a block of samples with frequency modulation.
+   */
+  virtual void generate(ComplexFloatArray output, FloatArray fm){
+    for(size_t i=0; i<output.getSize(); ++i)
+      output[i] = generate(fm[i]);
+  }
+
+};
+
+template<typename OscillatorClass>
+using ComplexOscillatorTemplate = OscillatorTemplate<OscillatorClass, ComplexOscillator, ComplexFloat>;
+#endif