Minor clean up for cooley tukey in C++

- rename c64 to complex
- make pi a constant instead of function
- fix complilation warnings about comparing signed int with unsigned int

Author: mika314

chapters/algorithms/cooley_tukey/code/c++/fft.cpp

@@ -17,11 +17,8 @@ using std::swap;
 
 using std::size_t;
 
-using c64 = std::complex<double>;
-template <typename T>
-constexpr T pi() {
-  return 3.14159265358979323846264338327950288419716;
-}
+using complex = std::complex<double>;
+static const double pi = 3.14159265358979323846264338327950288419716;
 
 // `cooley_tukey` does the cooley-tukey algorithm, recursively
 template <typename Iter>
@@ -30,12 +27,12 @@ void cooley_tukey(Iter first, Iter last) {
   if (size >= 2) {
     // split the range, with even indices going in the first half,
     // and odd indices going in the last half.
-    auto temp = std::vector<c64>(size / 2);
-    for (size_t i = 0; i < size / 2; ++i) {
+    auto temp = std::vector<complex>(size / 2);
+    for (int i = 0; i < size / 2; ++i) {
       temp[i] = first[i * 2 + 1];
       first[i] = first[i * 2];
     }
-    for (size_t i = 0; i < size / 2; ++i) {
+    for (int i = 0; i < size / 2; ++i) {
       first[i + size / 2] = temp[i];
     }
 
@@ -45,8 +42,8 @@ void cooley_tukey(Iter first, Iter last) {
     cooley_tukey(split, last);
 
     // now combine each of those halves with the butterflies
-    for (size_t k = 0; k < size / 2; ++k) {
-      auto w = std::exp(c64(0, -2.0 * pi<double>() * k / size));
+    for (int k = 0; k < size / 2; ++k) {
+      auto w = std::exp(complex(0, -2.0 * pi * k / size));
 
       auto& bottom = first[k];
       auto& top = first[k + size / 2];
@@ -83,11 +80,11 @@ void iterative_cooley_tukey(Iter first, Iter last) {
 
   // perform the butterfly on the range
   auto size = last - first;
-  for (size_t stride = 2; stride <= size; stride *= 2) {
-    auto w = exp(c64(0, -2.0 * pi<double>() / stride));
-    for (size_t j = 0; j < size; j += stride) {
-      auto v = c64(1.0);
-      for (size_t k = 0; k < stride / 2; k++) {
+  for (int stride = 2; stride <= size; stride *= 2) {
+    auto w = exp(complex(0, -2.0 * pi / stride));
+    for (int j = 0; j < size; j += stride) {
+      auto v = complex(1.0);
+      for (int k = 0; k < stride / 2; k++) {
         first[k + j + stride / 2] =
             first[k + j] - v * first[k + j + stride / 2];
         first[k + j] -= (first[k + j + stride / 2] - first[k + j]);
@@ -103,7 +100,7 @@ int main() {
   std::mt19937 rng(random_device());
   std::uniform_real_distribution<double> distribution(0.0, 1.0);
 
-  std::array<c64, 64> initial;
+  std::array<complex, 64> initial;
   std::generate(
       begin(initial), end(initial), [&] { return distribution(rng); });
 
@@ -117,7 +114,7 @@ int main() {
   // Check if the arrays are approximately equivalent
   std::cout << std::right << std::setw(16) << "idx" << std::setw(16) << "rec"
             << std::setw(16) << "it" << std::setw(16) << "subtracted" << '\n';
-  for (int i = 0; i < initial.size(); ++i) {
+  for (size_t i = 0; i < initial.size(); ++i) {
     auto rec = recursive[i];
     auto it = iterative[i];
     std::cout << std::setw(16) << i << std::setw(16) << std::abs(rec)