ifft2.hpp

Go to the documentation of this file.

#pragma once
 
#include <complex>
 
#include "NumCpp/Core/Internal/StaticAsserts.hpp"
#include "NumCpp/Core/Types.hpp"
#include "NumCpp/NdArray.hpp"
 
namespace nc::fft
{
    namespace detail
    {
        //===========================================================================
        // Method Description:
        inline NdArray<std::complex<double>> ifft2_internal(const NdArray<std::complex<double>>& x, const Shape& shape)
        {
            if (shape.rows == 0 || shape.cols == 0)
            {
                return {};
            }
 
            auto result = NdArray<std::complex<double>>(shape.rows, shape.cols);
 
            stl_algorithms::for_each(result.begin(),
                                     result.end(),
                                     [&](auto& resultElement)
                                     {
                                         const auto i  = &resultElement - result.data();
                                         const auto m  = static_cast<double>(i / shape.cols);
                                         const auto n  = static_cast<double>(i % shape.cols);
                                         resultElement = std::complex<double>{ 0., 0. };
                                         for (auto k = 0u; k < std::min(shape.rows, x.numRows()); ++k)
                                         {
                                             for (auto l = 0u; l < std::min(shape.cols, x.numCols()); ++l)
                                             {
                                                 const auto angle =
                                                     constants::twoPi *
                                                     (((static_cast<double>(k) * m) / static_cast<double>(shape.rows)) +
                                                      ((static_cast<double>(l) * n) / static_cast<double>(shape.cols)));
                                                 resultElement += (x(k, l) * std::polar(1., angle));
                                             }
                                         }
                                         resultElement /= shape.size();
                                     });
 
            return result;
        }
    } // namespace detail
 
    //===========================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<double>> ifft2(const NdArray<dtype>& inArray, const Shape& inShape)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto data = nc::complex<dtype, double>(inArray);
        return detail::ifft2_internal(data, inShape);
    }
 
    //===========================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<double>> ifft2(const NdArray<dtype>& inArray)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        return ifft2(inArray, inArray.shape());
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<double>> ifft2(const NdArray<std::complex<dtype>>& inArray, const Shape& inShape)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto data = nc::complex<dtype, double>(inArray);
        return detail::ifft2_internal(data, inShape);
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<double>> ifft2(const NdArray<std::complex<dtype>>& inArray)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        return ifft2(inArray, inArray.shape());
    }
} // namespace nc::fft