FM / interpolators

/usr/include/boost/math/interpolators

Name	Size	Mode	Actions
detail/	-	0755	rm
barycentric_rational.hpp	3805	0644	edit dl rm
cardinal_cubic_b_spline.hpp	3715	0644	edit dl rm
cardinal_quadratic_b_spline.hpp	2347	0644	edit dl rm
cardinal_quintic_b_spline.hpp	2675	0644	edit dl rm
cardinal_trigonometric.hpp	1443	0644	edit dl rm
catmull_rom.hpp	8767	0644	edit dl rm
cubic_b_spline.hpp	3665	0644	edit dl rm
cubic_hermite.hpp	3470	0644	edit dl rm
makima.hpp	5978	0644	edit dl rm
pchip.hpp	3720	0644	edit dl rm
quintic_hermite.hpp	3639	0644	edit dl rm
septic_hermite.hpp	3697	0644	edit dl rm
vector_barycentric_rational.hpp	2866	0644	edit dl rm
whittaker_shannon.hpp	1291	0644	edit dl rm

Edit: /usr/include/boost/math/interpolators/vector_barycentric_rational.hpp (2866B)

/*
 *  Copyright Nick Thompson, 2019
 *  Use, modification and distribution are subject to the
 *  Boost Software License, Version 1.0. (See accompanying file
 *  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 *
 *  Exactly the same as barycentric_rational.hpp, but delivers values in $\mathbb{R}^n$.
 *  In some sense this is trivial, since each component of the vector is computed in exactly the same
 *  as would be computed by barycentric_rational.hpp. But this is a bit more efficient and convenient.
 */

#ifndef BOOST_MATH_INTERPOLATORS_VECTOR_BARYCENTRIC_RATIONAL_HPP
#define BOOST_MATH_INTERPOLATORS_VECTOR_BARYCENTRIC_RATIONAL_HPP

#include <memory>
#include <boost/math/interpolators/detail/vector_barycentric_rational_detail.hpp>

namespace boost{ namespace math{

template<class TimeContainer, class SpaceContainer>
class vector_barycentric_rational
{
public:
    using Real = typename TimeContainer::value_type;
    using Point = typename SpaceContainer::value_type;
    vector_barycentric_rational(TimeContainer&& times, SpaceContainer&& points, size_t approximation_order = 3);

void operator()(Point& x, Real t) const;

// I have validated using google benchmark that returning a value is no more expensive populating it,
    // at least for Eigen vectors with known size at compile-time.
    // This is kinda a weird thing to discover since it goes against the advice of basically every high-performance computing book.
    Point operator()(Real t) const {
        Point p;
        this->operator()(p, t);
        return p;
    }

void prime(Point& dxdt, Real t) const {
        Point x;
        m_imp->eval_with_prime(x, dxdt, t);
    }

Point prime(Real t) const {
        Point p;
        this->prime(p, t);
        return p;
    }

void eval_with_prime(Point& x, Point& dxdt, Real t) const {
        m_imp->eval_with_prime(x, dxdt, t);
        return;
    }

std::pair<Point, Point> eval_with_prime(Real t) const {
        Point x;
        Point dxdt;
        m_imp->eval_with_prime(x, dxdt, t);
        return {x, dxdt};
    }

private:
    std::shared_ptr<detail::vector_barycentric_rational_imp<TimeContainer, SpaceContainer>> m_imp;
};

template <class TimeContainer, class SpaceContainer>
vector_barycentric_rational<TimeContainer, SpaceContainer>::vector_barycentric_rational(TimeContainer&& times, SpaceContainer&& points, size_t approximation_order):
 m_imp(std::make_shared<detail::vector_barycentric_rational_imp<TimeContainer, SpaceContainer>>(std::move(times), std::move(points), approximation_order))
{
    return;
}

template <class TimeContainer, class SpaceContainer>
void vector_barycentric_rational<TimeContainer, SpaceContainer>::operator()(typename SpaceContainer::value_type& p, typename TimeContainer::value_type t) const
{
    m_imp->operator()(p, t);
    return;
}

}}
#endif

cmd: