Refactoring

Author: jurihock

src/Robocode/Arctangent.h

@@ -3,6 +3,7 @@
 #include <cmath>
 #include <complex>
 #include <concepts>
+#include <numbers>
 
 /**
  * Arctangent approximation according to [1].
@@ -43,7 +44,7 @@ namespace Arctangent
     const T phi = q + std::copysign(e, s);
 
     // translate the result from [0, 4) to [0, 2pi)
-    return phi * T(1.57079632679489661923);
+    return phi * T(std::numbers::pi / 2);
   }
 
   template<std::floating_point T>

src/Robocode/Assert.h

@@ -30,7 +30,7 @@
   while(0)                          //
 
 template<typename... Args>
-static void assert_throw_if(
+inline void assert_throw_if(
   const bool condition,
   const char* expression,
   const char* file,
@@ -51,7 +51,7 @@ static void assert_throw_if(
     va_start(args, format);
 
     va_copy(temp, args);
-    auto size = std::vsnprintf(nullptr, 0, format, temp);
+    int size = std::vsnprintf(nullptr, 0, format, temp);
     va_end(temp);
 
     std::string buffer(size + 1, '\0');

src/Robocode/Channel.cpp

@@ -4,12 +4,9 @@ Channel::Channel(const size_t index, const double samplerate, const std::span<co
 {
   const size_t dftsize = frequencies.size();
 
-  // https://newt.phys.unsw.edu.au/jw/notes.html
-  const double hz = std::pow(2, (double(index) - 69) / 12) * concertpitch;
-
   config.dftsize = dftsize;
 
-  config.freq = hz;
+  config.freq = midi_to_hertz(index, concertpitch);
   config.gain = 0;
 
   config.samplerate = samplerate;
@@ -21,7 +18,7 @@ Channel::Channel(const size_t index, const double samplerate, const std::span<co
 
   for (size_t i = 0; i < dftsize; ++i)
   {
-    config.chnfreqs[i] = hz * frequencies[i];
+    config.chnfreqs[i] = config.freq * frequencies[i];
   }
 }
 
@@ -57,7 +54,7 @@ double Channel::synthesize(const std::span<std::complex<double>> dft,
 {
   assert_true(dft.size() == config.dftsize, "Invalid DFT size!");
 
-  const double freq2phase = (2 * std::numbers::pi) / config.samplerate;
+  const double hz2rad = hertz_to_radian(config.samplerate);
 
   const double gain = config.gain;
   const auto& chnfreqs = config.chnfreqs;
@@ -70,7 +67,7 @@ double Channel::synthesize(const std::span<std::complex<double>> dft,
     {
       const double newfreq = chnfreqs[i];
 
-      phase[i] += newfreq * freq2phase;
+      phase[i] += newfreq * hz2rad;
 
       if (newfreq <= dftfreqs.front())
       {
@@ -94,7 +91,7 @@ double Channel::synthesize(const std::span<std::complex<double>> dft,
     {
       const double newfreq = chnfreqs[i] * pvcfreqs[i];
 
-      phase[i] += newfreq * freq2phase;
+      phase[i] += newfreq * hz2rad;
 
       if (newfreq <= dftfreqs.front())
       {

src/Robocode/Header.h

@@ -17,3 +17,4 @@
 #include <vector>
 
 #include <Robocode/Assert.h>
+#include <Robocode/Math.h>

src/Robocode/Math.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <Robocode/Arctangent.h>
+
+inline double angle(const std::complex<double>& z)
+{
+  #if defined(ENABLE_ARCTANGENT_APPROXIMATION)
+    return Arctangent::atan2(z);
+  #else
+    return std::arg(z);
+  #endif
+}
+
+inline double wrap(const double angle)
+{
+  const double pi = 2 * std::numbers::pi;
+
+  return angle - pi * std::floor(angle / pi + 0.5);
+}
+
+// (2 * pi) / sr
+inline double hertz_to_radian(const double samplerate)
+{
+  return (2 * std::numbers::pi) / samplerate;
+}
+
+// sr / (2 * pi)
+inline double radian_to_hertz(const double samplerate)
+{
+  return samplerate / (2 * std::numbers::pi);
+}
+
+// https://newt.phys.unsw.edu.au/jw/notes.html
+inline double midi_to_hertz(const double midi, const double concertpitch)
+{
+  return std::pow(2, (midi - 69) / 12) * concertpitch;
+}

src/Robocode/Vocoder.cpp

@@ -1,32 +1,21 @@
 #include <Robocode/Vocoder.h>
 
-#include <Robocode/Arctangent.h>
-
-inline double angle(const std::complex<double>& z)
-{
-  #if defined(ENABLE_ARCTANGENT_APPROXIMATION)
-    return Arctangent::atan2(z);
-  #else
-    return std::arg(z);
-  #endif
-}
-
 Vocoder::Vocoder(const double samplerate, const std::span<const double> frequencies) :
   dftsize(frequencies.size())
 {
   cache.resize(dftsize);
   slope.resize(dftsize);
   freqs.resize(dftsize);
 
-  const double phase2freq = samplerate / (2 * std::numbers::pi);
+  const double rad2hz = radian_to_hertz(samplerate);
 
   std::transform(
     frequencies.begin(),
     frequencies.end(),
     slope.begin(),
     [&](const double freq)
     {
-      return (freq > 0) ? phase2freq / freq : 0;
+      return (freq > 0) ? rad2hz / freq : 0;
     });
 }