cosine_evaluator.hpp

#pragma once
#include <cmath>
 
#include <ddc/ddc.hpp>
 
#include <sll/math_tools.hpp>
 
#include "ddc_aliases.hpp"
 
struct CosineEvaluator
{
    template <class Grid1D>
    class Evaluator
    {
    public:
        using Dim = Grid1D;
 
    private:
        static inline constexpr double s_2_pi = 2. * M_PI;
 
    private:
        double m_c0;
 
        double m_c1;
 
    public:
        template <class IdxRange>
        Evaluator(IdxRange idx_range) : m_c0(1.0)
                                      , m_c1(0.0)
        {
        }
 
        Evaluator(double c0, double c1) : m_c0(c0), m_c1(c1) {}
 
        double operator()(double const x) const noexcept
        {
            return eval(x, 0);
        }
 
        void operator()(ddc::ChunkSpan<double, ddc::DiscreteDomain<Grid1D>> chunk) const
        {
            auto const& idx_range = chunk.idx_range();
 
            for (ddc::DiscreteElement<Grid1D> const i : idx_range) {
                chunk(i) = eval(ddc::coordinate(i), 0);
            }
        }
 
        double deriv(double const x, int const derivative) const noexcept
        {
            return eval(x, derivative);
        }
 
        void deriv(ddc::ChunkSpan<double, ddc::DiscreteDomain<Grid1D>> chunk, int const derivative)
                const
        {
            auto const& idx_range = chunk.idx_range();
 
            for (ddc::DiscreteElement<Grid1D> const i : idx_range) {
                chunk(i) = eval(ddc::coordinate(i), derivative);
            }
        }
 
        double max_norm(int diff = 0) const
        {
            return ipow(s_2_pi * m_c0, diff);
        }
 
    private:
        double eval(double const x, int const derivative) const noexcept
        {
            return ipow(s_2_pi * m_c0, derivative)
                   * std::cos(M_PI_2 * derivative + s_2_pi * (m_c0 * x + m_c1));
        }
    };
};