Reduce the number of multiplications

Author: jurihock

src/Robocode/Channel.cpp

@@ -17,7 +17,13 @@ Channel::Channel(const size_t index, const size_t dftsize, const double samplera
   config.samplerate = samplerate;
   config.concertpitch = concertpitch;
 
-  config.phase.resize(dftsize);
+  config.chnfreqs.resize(dftsize);
+  config.chnphase.resize(dftsize);
+
+  for (size_t i = 0; i < dftsize; ++i)
+  {
+    config.chnfreqs[i] = hz * i;
+  }
 }
 
 Channel::Channel(const Channel& other) :
@@ -52,20 +58,20 @@ double Channel::synthesize(const std::span<std::complex<double>> dft,
 {
   assert_true(dft.size() == config.dftsize, "Invalid DFT size!");
 
-  const double tophase = (2 * std::numbers::pi) / config.samplerate;
+  const double freq2phase = (2 * std::numbers::pi) / config.samplerate;
 
-  const double freq = config.freq;
   const double gain = config.gain;
 
-  auto& phase = config.phase;
+  const auto& chnfreqs = config.chnfreqs;
+  auto& chnphase = config.chnphase;
 
   for (size_t i = 1; i < dft.size() - 1; ++i)
   {
-    const double chnfreq = freq * i;
-    const double pvcfreq = pvcfreqs[i] / dftfreqs[i];
+    const double chnfreq = chnfreqs[i];
+    const double pvcfreq = pvcfreqs[i];
     const double newfreq = chnfreq * pvcfreq;
 
-    phase[i] += newfreq * tophase;
+    chnphase[i] += newfreq * freq2phase;
 
     if (newfreq <= dftfreqs.front())
     {
@@ -77,7 +83,7 @@ double Channel::synthesize(const std::span<std::complex<double>> dft,
       continue;
     }
 
-    dft[i] += std::polar(gain, phase[i]);
+    dft[i] += std::polar(gain, chnphase[i]);
   }
 
   return gain;

src/Robocode/Channel.h

@@ -33,7 +33,8 @@ class Channel final
     double samplerate;
     double concertpitch;
 
-    std::vector<double> phase;
+    std::vector<double> chnfreqs;
+    std::vector<double> chnphase;
   }
   config;
 

src/Robocode/Vocoder.cpp

@@ -12,25 +12,30 @@ inline double angle(const std::complex<double>& z)
 }
 
 Vocoder::Vocoder(const double samplerate, const std::vector<double>& frequencies) :
-  samplerate(samplerate),
   dftsize(frequencies.size())
 {
   cache.resize(dftsize);
+  slope.resize(dftsize);
   freqs.resize(dftsize);
+
+  const double phase2freq = samplerate / (2 * std::numbers::pi);
+
+  for (size_t i = 0; i < dftsize; ++i)
+  {
+    slope[i] = phase2freq / frequencies[i];
+  }
 }
 
 void Vocoder::analyze(const std::span<const std::complex<double>> dft,
                       const std::function<void(const std::span<const double> pvcfreqs)> callback)
 {
   assert_true(dft.size() == dftsize, "Invalid DFT size!");
 
-  const double tofreq = samplerate / (2 * std::numbers::pi);
-
   for (size_t i = 0; i < dft.size(); ++i)
   {
-    const double phase = angle(dft[i] / cache[i]); // TODO: approx, wrap
+    const double phase = angle(dft[i] / cache[i]); // TODO: wrap
 
-    freqs[i] = phase * tofreq;
+    freqs[i] = phase * slope[i];
     cache[i] = dft[i];
   }
 

src/Robocode/Vocoder.h

@@ -14,10 +14,10 @@ class Vocoder final
 
 private:
 
-  const double samplerate;
   const size_t dftsize;
 
   std::vector<std::complex<double>> cache;
+  std::vector<double> slope;
   std::vector<double> freqs;
 
 };