added fftfreq and rfftfreq

Author: dpilger26

docs/markdown/ReleaseNotes.md

@@ -8,17 +8,13 @@
   * `fft::fftfreq` <https://numpy.org/doc/stable/reference/generated/numpy.fft.fftfreq.html>
   * `fft::fftshift` <https://numpy.org/doc/stable/reference/generated/numpy.fft.fftshfit.html>
   * `fft::ifftshift` <https://numpy.org/doc/stable/reference/generated/numpy.fft.ifftshfit.html>
-  * `fft::fftresample`: Resample a series to m points via Fourier interpolation
   * `fft::fft2` <https://numpy.org/doc/stable/reference/generated/numpy.fft.fft2.html#numpy.fft.fft2>
   * `fft::ifft2` <https://numpy.org/doc/stable/reference/generated/numpy.fft.ifft2.html#numpy.fft.ifft2>
-  * `fft::fft2resample`: Resample a series to m x n points via Fourier interpolation
   * `fft::rfft` <https://numpy.org/doc/stable/reference/generated/numpy.fft.rfft.html#numpy.fft.rfft>
   * `fft::irfft` <https://numpy.org/doc/stable/reference/generated/numpy.fft.irfft.html#numpy.fft.irfft>
   * `fft::rfftfreq` <https://numpy.org/doc/stable/reference/generated/numpy.fft.rfftfreq.html>
-  * `fft::rfftresample`: Resample a series to m points via Fourier interpolation
   * `fft::rfft2` <https://numpy.org/doc/stable/reference/generated/numpy.fft.rfft2.html#numpy.fft.rfft2>
   * `fft::irfft2` <https://numpy.org/doc/stable/reference/generated/numpy.fft.irfft2.html#numpy.fft.irfft2>
-  * `fft::rfft2resample`: Resample a series to m x n points via Fourier interpolation
 * added `divmod` <https://numpy.org/doc/stable/reference/generated/numpy.divmod.html#numpy-divmod>
 * added `find_duplicates` <https://numpy.org/doc/stable//reference/generated/numpy.rec.find_duplicate.html>
 * added `mode` <https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.mode.html>

include/NumCpp/FFT.hpp

@@ -29,16 +29,13 @@
 
 #include "NumCpp/FFT/fft.hpp"
 #include "NumCpp/FFT/fft2.hpp"
-#include "NumCpp/FFT/fft2resample.hpp"
 #include "NumCpp/FFT/fftfreq.hpp"
-#include "NumCpp/FFT/fftresample.hpp"
 #include "NumCpp/FFT/fftshift.hpp"
 #include "NumCpp/FFT/ifft.hpp"
 #include "NumCpp/FFT/ifft2.hpp"
 #include "NumCpp/FFT/ifftshift.hpp"
 #include "NumCpp/FFT/irfft.hpp"
+#include "NumCpp/FFT/irfft2.hpp"
 #include "NumCpp/FFT/rfft.hpp"
 #include "NumCpp/FFT/rfft2.hpp"
-#include "NumCpp/FFT/rfft2resample.hpp"
 #include "NumCpp/FFT/rfftfreq.hpp"
-#include "NumCpp/FFT/rfftresample.hpp"

include/NumCpp/FFT/fft2resample.hpp

@@ -41,12 +41,42 @@ namespace nc::fft
     /// NumPy Reference: <https://numpy.org/doc/stable/reference/generated/numpy.fft.fftfreq.html#>
     ///
     /// @param inN Window Length
-    /// @param inD (Optional) Sample spacing (inverse of the sampling rate). Defaults to 1.
+    /// @param inD (Optional) Sample spacing (inverse of the sampling rate). Must be positive non-zero. Defaults to 1.
     ///
     /// @return NdArray
     ///
     inline NdArray<double> fftfreq(uint32 inN, double inD = 1.)
     {
-        return {};
+        if (inN == 0)
+        {
+            return {};
+        }
+        else if (inN == 1)
+        {
+            return { 0 };
+        }
+
+        if (inD <= 0.)
+        {
+            return {};
+        }
+
+        const auto nTimesD = static_cast<double>(inN) * inD;
+
+        auto result = NdArray<double>(1, inN);
+        result[0]   = 0.;
+
+        for (auto i = 1u; i < (inN + 1) / 2; ++i)
+        {
+            result[i]       = static_cast<double>(i) / nTimesD;
+            result[inN - i] = -static_cast<double>(i) / nTimesD;
+        }
+
+        if (inN % 2 == 0)
+        {
+            result[inN / 2] = -static_cast<double>(inN / 2) / nTimesD;
+        }
+
+        return result;
     }
 } // namespace nc::fft

include/NumCpp/FFT/fftfreq.hpp

@@ -47,6 +47,29 @@ namespace nc::fft
     ///
     inline NdArray<double> rfftfreq(uint32 inN, double inD = 1.)
     {
-        return {};
+        if (inN == 0)
+        {
+            return {};
+        }
+        else if (inN == 1)
+        {
+            return { 0 };
+        }
+
+        if (inD <= 0.)
+        {
+            return {};
+        }
+
+        const auto halfN   = (inN / 2) + 1;
+        const auto nTimesD = static_cast<double>(inN) * inD;
+
+        auto result = NdArray<double>(1, halfN);
+        for (auto i = 0u; i < halfN; ++i)
+        {
+            result[i] = static_cast<double>(i) / nTimesD;
+        }
+
+        return result;
     }
 } // namespace nc::fft