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;
}