weightKernel.h

/*
 This Source Code Form is subject to the terms of the Mozilla Public
 License, v. 2.0. If a copy of the MPL was not distributed with this
 file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#pragma once
 
#include "./defines.h"
#include PONCA_MULTIARCH_INCLUDE_CU_STD(cmath)
 
namespace Ponca
{
    template <typename _Scalar>
    class ConstantWeightKernel
    {
    public:
        using Scalar = _Scalar;
 
        static constexpr bool isCompact = true;
 
        // Init
        PONCA_MULTIARCH inline ConstantWeightKernel(const Scalar& _value = Scalar(1.)) : m_y(_value) {}
        PONCA_MULTIARCH inline void setValue(const Scalar& _value) { m_y = _value; }
 
        // Functor
        PONCA_MULTIARCH [[nodiscard]] inline Scalar f(const Scalar&) const { return m_y; }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar df(const Scalar&) const { return Scalar(0.); }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar ddf(const Scalar&) const { return Scalar(0.); }
 
        static constexpr bool isDValid = true;
        static constexpr bool isDDValid = true;
 
    private:
        Scalar m_y; 
    }; // class ConstantWeightKernel
 
    template <typename _Scalar>
    class SmoothWeightKernel
    {
    public:
        using Scalar = _Scalar;
 
        static constexpr bool isCompact = true;
 
        // Functor
        PONCA_MULTIARCH [[nodiscard]] inline Scalar f(const Scalar& _x) const
        {
            Scalar v = _x * _x - Scalar(1.);
            return v * v;
        }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar df(const Scalar& _x) const
        {
            return Scalar(4.) * _x * (_x * _x - Scalar(1.));
        }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar ddf(const Scalar& _x) const
        {
            return Scalar(12.) * _x * _x - Scalar(4.);
        }
        static constexpr bool isDValid = true;
        static constexpr bool isDDValid = true;
    }; // class SmoothWeightKernel
 
    template <typename _Scalar, int m, int n>
    class PolynomialSmoothWeightKernel
    {
    public:
        using Scalar = _Scalar;
 
        static constexpr bool isCompact = true;
 
        // Functor
        PONCA_MULTIARCH [[nodiscard]] inline Scalar f(const Scalar& _x) const
        {
            PONCA_MULTIARCH_STD_MATH(pow);
            return pow(pow(_x, Scalar(n)) - Scalar(1.), Scalar(m));
        }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar df(const Scalar& _x) const
        {
            PONCA_MULTIARCH_STD_MATH(pow);
            return pow(Scalar(m * n) * _x, Scalar(n - 1)) * pow(pow(_x, Scalar(n)) - 1, Scalar(m - 1));
        }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar ddf(const Scalar& _x) const
        {
            PONCA_MULTIARCH_STD_MATH(pow);
            return Scalar((m - 1) * m * n * n) * pow(_x, Scalar(2 * n - 2)) *
                       pow(pow(_x, Scalar(n)) - Scalar(1), Scalar(m - 2)) +
                   Scalar(m * (n - 1) * n) * pow(_x, Scalar(n - 2)) *
                       pow(pow(_x, Scalar(n)) - Scalar(1), Scalar(m - 1));
        }
        static constexpr bool isDValid = true;
        static constexpr bool isDDValid = true;
    }; // class PolynomialSmoothWeightKernel
 
    template <typename _Scalar>
    class WendlandWeightKernel
    {
    public:
        using Scalar = _Scalar;
 
        static constexpr bool isCompact = true;
 
        // Functor
        PONCA_MULTIARCH [[nodiscard]] inline Scalar f(const Scalar& _x) const
        {
            const Scalar v = Scalar(1.) - _x;
            return v * v * v * v * ((Scalar(4.) * _x) + Scalar(1.));
        }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar df(const Scalar& _x) const
        {
            const Scalar v = _x - Scalar(1.);
            return Scalar(20.) * _x * v * v * v;
        }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar ddf(const Scalar& _x) const
        {
            const Scalar v = _x - Scalar(1.);
            return v * v * (Scalar(80.) * _x - Scalar(20));
        }
        static constexpr bool isDValid = true;
        static constexpr bool isDDValid = true;
    }; // class WendlandWeightKernel
 
    template <typename _Scalar>
    class SingularWeightKernel
    {
    public:
        using Scalar = _Scalar;
 
        static constexpr bool isCompact = true;
 
        // Functor
        PONCA_MULTIARCH [[nodiscard]] inline Scalar f(const Scalar& _x) const { return Scalar(1.) / (_x * _x); }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar df(const Scalar& _x) const { return Scalar(-2.) / (_x * _x * _x); }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar ddf(const Scalar& _x) const
        {
            return Scalar(6.) / (_x * _x * _x * _x);
        }
        static constexpr bool isDValid = true;
        static constexpr bool isDDValid = true;
    }; // class SingularWeightKernel
 
    template <typename _Scalar>
    class CompactExpWeightKernel
    {
    public:
        using Scalar = _Scalar;
 
        static constexpr bool isCompact = true;
 
        // Functor
        PONCA_MULTIARCH [[nodiscard]] inline Scalar f(const Scalar& _x) const
        {
            PONCA_MULTIARCH_STD_MATH(exp);
            Scalar v = _x * _x;
            return exp(-v / (Scalar(1) - v));
        }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar df(const Scalar& _x) const
        {
            PONCA_MULTIARCH_STD_MATH(exp);
            Scalar v  = _x * _x;
            Scalar mv = v - Scalar(1);
            return -(Scalar(2) * exp(v / mv) * _x) / (mv * mv);
        }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar ddf(const Scalar& _x) const
        {
            PONCA_MULTIARCH_STD_MATH(exp);
            PONCA_MULTIARCH_STD_MATH(pow);
            Scalar v      = _x * _x;        // x^2
            Scalar mv     = v - Scalar(1);  // x^2-1
            Scalar mvpow  = Scalar(2) / mv; // 2/(x^2-1)
            Scalar cmvpow = pow(_x, mvpow); // x^{2/(x^2-1)}
            return Scalar(2) * exp(cmvpow) *
                   ((Scalar(4) * pow(_x, mvpow + Scalar(2)) * log(_x) -
                     mv * (-Scalar(3) * v + Scalar(2) * cmvpow - Scalar(1)))) /
                   (mv * mv * mv * mv);
        }
 
        static constexpr bool isDValid = true;
        static constexpr bool isDDValid = false;
    }; // class CompactExpWeightKernel
 
    template <typename _Scalar>
    class GaussianWeightKernel
    {
    public:
        using Scalar = _Scalar;
 
        static constexpr bool isCompact = false;
 
        PONCA_MULTIARCH [[nodiscard]] inline Scalar f(const Scalar& _x) const
        {
            PONCA_MULTIARCH_STD_MATH(exp);
            return exp((-_x * _x) / Scalar(2));
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline Scalar df(const Scalar& _x) const { return -f(_x) * _x; }
        PONCA_MULTIARCH [[nodiscard]] inline Scalar ddf(const Scalar& _x) const
        {
            return f(_x) * (_x * _x - Scalar(1));
        }
        static constexpr bool isDValid = true;
        static constexpr bool isDDValid = true;
    }; // class GaussianWeightKernel
 
} // namespace Ponca