weightFunc.hpp

/*
 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
 
template <class DataPoint, class WeightKernel>
typename DistWeightFunc<DataPoint, WeightKernel>::WeightReturnType DistWeightFunc<DataPoint, WeightKernel>::operator()(
    const DataPoint& _q) const
{
    const auto lq = NeighborhoodFrame::convertToLocalBasis(_q.pos());
    Scalar d      = lq.norm();
    if (isCompact) // compile-time branching
        return {(d <= m_t) ? m_wk.f(d / m_t) : Scalar(0.), lq};
    else
        return {m_wk.f(d / m_t), lq};
}
 
template <class DataPoint, class WeightKernel>
typename DistWeightFunc<DataPoint, WeightKernel>::VectorType DistWeightFunc<DataPoint, WeightKernel>::spacedw(
    const VectorType& _q, const DataPoint&) const
{
    static_assert(WeightKernel::isDValid, "First order derivatives are required");
    VectorType result = VectorType::Zero();
    const auto q      = NeighborhoodFrame::convertToLocalBasis(_q);
    Scalar d          = q.norm();
    // isCompact is tested at compile-time
    if ((!isCompact) || (d <= m_t && d != Scalar(0.)))
        result = (q / (d * m_t)) * m_wk.df(d / m_t);
    return result;
}
 
template <class DataPoint, class WeightKernel>
typename DistWeightFunc<DataPoint, WeightKernel>::MatrixType DistWeightFunc<DataPoint, WeightKernel>::spaced2w(
    const VectorType& _q, const DataPoint&) const
{
    static_assert(WeightKernel::isDDValid, "Second order derivatives are required");
    MatrixType result = MatrixType::Zero();
    const auto q      = NeighborhoodFrame::convertToLocalBasis(_q);
    Scalar d          = q.norm();
    if ((!isCompact) || (d <= m_t && d != Scalar(0.)))
    {
        Scalar der = m_wk.df(d / m_t);
        result     = q * q.transpose() / d * (m_wk.ddf(d / m_t) / m_t - der / d);
        result.diagonal().array() += der;
        result *= Scalar(1.) / (m_t * d);
    }
    return result;
}
 
template <class DataPoint, class WeightKernel>
typename DistWeightFunc<DataPoint, WeightKernel>::Scalar DistWeightFunc<DataPoint, WeightKernel>::scaledw(
    const VectorType& _q, const DataPoint&) const
{
    static_assert(WeightKernel::isDValid, "First order derivatives are required");
    Scalar d = NeighborhoodFrame::convertToLocalBasis(_q).norm();
    return ((!isCompact) || (d <= m_t)) ? Scalar(-d * m_wk.df(d / m_t) / (m_t * m_t)) : Scalar(0.);
}
 
template <class DataPoint, class WeightKernel>
typename DistWeightFunc<DataPoint, WeightKernel>::Scalar DistWeightFunc<DataPoint, WeightKernel>::scaled2w(
    const VectorType& _q, const DataPoint&) const
{
    static_assert(WeightKernel::isDDValid, "Second order derivatives are required");
    Scalar d = NeighborhoodFrame::convertToLocalBasis(_q).norm();
    return ((!isCompact) || (d <= m_t)) ? Scalar(Scalar(2.) * d / (m_t * m_t * m_t) * m_wk.df(d / m_t) +
                                                 d * d / (m_t * m_t * m_t * m_t) * m_wk.ddf(d / m_t))
                                        : Scalar(0.);
}
 
template <class DataPoint, class WeightKernel>
typename DistWeightFunc<DataPoint, WeightKernel>::VectorType DistWeightFunc<DataPoint, WeightKernel>::scaleSpaced2w(
    const VectorType& _q, const DataPoint&) const
{
    static_assert(WeightKernel::isDDValid, "Second order derivatives are required");
    VectorType result = VectorType::Zero();
    const auto q      = NeighborhoodFrame::convertToLocalBasis(_q);
    Scalar d          = q.norm();
    if ((!isCompact) || (d <= m_t && d != Scalar(0.)))
        result = -q / (m_t * m_t) * (m_wk.df(d / m_t) / d + m_wk.ddf(d / m_t) / m_t);
    return result;
}