Some more docs and quadrature oscillator with complex feedback

Author: antisvin

LibSource/ComplexOscillator.h

@@ -45,15 +45,15 @@ class ComplexOscillator : public ComplexSignalGenerator {
   /**
    * Produce a sample with frequency modulation.
    */
-  virtual ComplexFloat generate() {
-    return generate(0.f);
-  }
   virtual ComplexFloat generate(float fm) = 0;
-  virtual void generate(ComplexFloatArray output) {
-    for(size_t i=0; i<output.getSize(); ++i) {
-      output[i]= generate();
-    }
+  /**
+   * 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>

LibSource/QuadratureSineOscillator.h

@@ -3,6 +3,11 @@
 
 #include "ComplexOscillator.h"
 
+/**
+ * Oscillator outputs complex numbers on unit cycle. This means that axis are
+ * 90 degrees out of phase at any point of time and oscillator's magnitude is
+ * always equal to 1.0
+ **/
 class QuadratureSineOscillator : public ComplexOscillatorTemplate<QuadratureSineOscillator> {
 public:
     static constexpr float begin_phase = 0;
@@ -19,7 +24,7 @@ class QuadratureSineOscillator : public ComplexOscillatorTemplate<QuadratureSine
         }
         phase = fmodf(phase, end_phase);
     }
-    void generate(ComplexFloatArray output, FloatArray fm) {
+    void generate(ComplexFloatArray output, FloatArray fm) override {
         size_t len = output.getSize();
         for (size_t i = 0; i < len; ++i) {
             output[i].re = cosf(phase);
@@ -32,13 +37,21 @@ class QuadratureSineOscillator : public ComplexOscillatorTemplate<QuadratureSine
     using ComplexOscillatorTemplate<QuadratureSineOscillator>::generate;
 };
 
+/**
+ * An oscillator similar to QuadratureSineOscillator class that also includes
+ * feedback control. Feedback value is a scalar value, meaning that both real and
+ * imaginary axis get the same amount of feeback
+ **/
 class FeedbackQuadratureSineOscillator : public ComplexOscillatorTemplate<FeedbackQuadratureSineOscillator> {
 public:
     static constexpr float begin_phase = 0;
     static constexpr float end_phase = 2 * M_PI;
     void setFeedback(float feedback) {
         this->feedback = feedback;
     }
+    float getFeedback() const {
+        return feedback;
+    }
     ComplexFloat getSample() {
         last_sample = ComplexFloat(
             cosf(phase + last_sample.re * feedback), sinf(phase + last_sample.im * feedback));
@@ -54,7 +67,7 @@ class FeedbackQuadratureSineOscillator : public ComplexOscillatorTemplate<Feedba
         }
         phase = fmodf(phase, end_phase);
     }
-    void generate(ComplexFloatArray output, FloatArray fm) {
+    void generate(ComplexFloatArray output, FloatArray fm) override {
         size_t len = output.getSize();
         for (size_t i = 0; i < len; ++i) {
             output[i].re = cosf(phase + last_sample.re * feedback);
@@ -71,4 +84,52 @@ class FeedbackQuadratureSineOscillator : public ComplexOscillatorTemplate<Feedba
     ComplexFloat last_sample = 0;
 };
 
+
+/**
+ * An oscillator similar to QuadratureSineOscillator class that also includes
+ * feedback control. Feedback value is a complex number, this allows controlling
+ * feedback direction.
+ **/
+class ComplexFeedbackQuadratureSineOscillator : public ComplexOscillatorTemplate<ComplexFeedbackQuadratureSineOscillator> {
+public:
+    static constexpr float begin_phase = 0;
+    static constexpr float end_phase = 2 * M_PI;
+    void setFeedback(ComplexFloat feedback) {
+        this->feedback = feedback;
+    }
+    ComplexFloat getFeedback() const {
+        return feedback;
+    }
+    ComplexFloat getSample() {
+        last_sample = ComplexFloat(
+            cosf(phase + last_sample.re * feedback.re), sinf(phase + last_sample.im * feedback.im));
+        return last_sample;
+    }
+    void generate(ComplexFloatArray output) override {
+        size_t len = output.getSize();
+        for (size_t i = 0; i < len; ++i) {
+            output[i].re = cosf(phase + last_sample.re * feedback.re);
+            output[i].im = sinf(phase + last_sample.im * feedback.im);
+            last_sample = output[i];
+            phase += incr; // allow phase to overrun
+        }
+        phase = fmodf(phase, end_phase);
+    }
+    void generate(ComplexFloatArray output, FloatArray fm) override {
+        size_t len = output.getSize();
+        for (size_t i = 0; i < len; ++i) {
+            output[i].re = cosf(phase + last_sample.re * feedback.re);
+            output[i].im = sinf(phase + last_sample.im * feedback.im);
+            last_sample = output[i];
+            phase += incr * (1 + fm[i]);
+            // allow phase to overrun
+        }
+        phase = fmodf(phase, end_phase);
+    }
+    using ComplexOscillatorTemplate<ComplexFeedbackQuadratureSineOscillator>::generate;
+protected:
+    ComplexFloat feedback = 0;
+    ComplexFloat last_sample = 0;
+};
+
 #endif /* QUADRATURE_SINE_OSCILLATOR_H */

LibSource/SignalGenerator.h

@@ -36,9 +36,8 @@ class MultiSignalGenerator {
 
 /**
  * Base class for stereo signal generators such as Oscillators.
- * A ComplexSignalGenerator produces complex numbers with parts
- * in [-1..1] range unless
- * otherwise stated.
+ * A ComplexSignalGenerator produces complex numbers with each channel
+ * containing samples in [-1..1] range unless otherwise stated.
  */
 class ComplexSignalGenerator {
 public: