dsp.h

Go to the documentation of this file.

#ifndef CPPAPE_DSP_H
#define CPPAPE_DSP_H
 
#include <cmath>
#include <cstddef>
#include "misc.h"
#include <vector>
#include <complex>
#include <algorithm>
 
namespace ape
{
 
#if 0
 
    constexpr inline long double operator ""dB(long double arg)
    {
        return std::pow(10, arg / 20);
    }
 
    constexpr inline long double operator ""_dB(long double arg)
    {
        return std::pow(10, arg / 20);
    }
 
#endif
 
    class dB
    {
    public:
        template<typename T>
        static inline T from(T arg)
        {
            return std::pow(10, arg / 20);
        }
 
        template<typename T>
        static inline T to(T arg)
        {
            return 20 * std::log10(arg);
        }
    };
 
    template<typename T>
    T lanczos(T x, int size)
    {
        constexpr T pi = static_cast<T>(M_PI);
        return x ? (size * std::sin(pi * x) * std::sin(pi * x / size)) / (pi * pi * x * x) : 1;
    }
 
    template<typename T>
    T sinc(T x)
    {
        constexpr T pi = static_cast<T>(M_PI);
        return x ? (std::sin(pi * x)) / (pi * x) : 1;
    }
 
    template<typename T, typename Container>
    auto to_complex(const Container& c) -> decltype(std::begin(c), std::end(c), std::vector<std::complex<T>>())
    {
        return to_complex(c, std::distance(std::begin(c), std::end(c)));
    }
 
    template<typename T, typename Container>
    auto to_complex(const Container& c, std::size_t size) -> decltype(std::begin(c), std::end(c), std::vector<std::complex<T>>())
    {
        std::vector<std::complex<T>> ret;
        ret.reserve(size);
 
        std::size_t count = 0;
 
        for (auto it = std::begin(c); count < size && it != std::end(c); it++, count++)
        {
            ret.emplace_back(static_cast<T>(*it));
        }
 
        for (; count < size; ++count)
            ret.emplace_back(T());
 
        return std::move(ret);
    }
 
    template<typename T, typename Container>
    auto normalize(Container& c, T scale, double threshold = 1e-8f) -> decltype(std::begin(c), std::end(c), void())
    {
        if (scale < threshold)
            return;
 
        const T normalization = T(1) / std::sqrt(scale);
 
        for (auto it = std::begin(c); it != std::end(c); it++)
            *it *= normalization;
    }
 
    template<typename Container>
    auto accumulate_norm(const Container& c) -> decltype(std::begin(c), std::end(c), std::norm(c[0]))
    {
        using namespace std;
 
        using T = decltype(norm(c[0]));
 
        T acc{};
 
        for (auto it = begin(c); it != end(c); it++)
        {
            acc += norm(*it);
        }
 
        return acc;
    }
 
    template<typename T, typename Container>
    auto multiply(Container& c, T scale) -> decltype(std::begin(c), std::end(c), void())
    {
        for (auto it = std::begin(c); it != std::end(c); it++)
            *it *= scale;
    }
}
 
#endif