# Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world.

## Modified Akima interpolation

#### Synopsis

#include <boost/math/interpolators/makima.hpp>

namespace boost::math::interpolators {

template <class RandomAccessContainer>
class makima
{
public:

using Real = RandomAccessContainer::value_type;

makima(RandomAccessContainer&& abscissas, RandomAccessContainer&& ordinates,
Real left_endpoint_derivative = std::numeric_limits<Real>::quiet_NaN(),
Real right_endpoint_derivative = std::numeric_limits<Real>::quiet_NaN());

Real operator()(Real x) const;

Real prime(Real x) const;

void push_back(Real x, Real y);

friend std::ostream& operator<<(std::ostream & os, const makima & m);
};

} // namespaces

#### Modified Akima Interpolation

The modified Akima interpolant takes non-equispaced data and interpolates between them via cubic Hermite polynomials whose slopes are chosen by a modification of a geometric construction proposed by Akima. The modification is given by Cosmin Ionita and agrees with Matlab's version. The interpolant is C1 and evaluation has 𝑶(log(N)) complexity. This is faster than barycentric rational interpolation, but also less smooth. An example usage is as follows:

std::vector<double> x{1, 5, 9 , 12};
std::vector<double> y{8,17, 4, -3};
using boost::math::interpolators::makima;
auto spline = makima(std::move(x), std::move(y));
// evaluate at a point:
double z = spline(3.4);
// evaluate derivative at a point:
double zprime = spline.prime(3.4);

Periodically, it is helpful to see what data the interpolator has, and the slopes it has chosen. This can be achieved via

std::cout << spline << "\n";

Note that the interpolator is pimpl'd, so that copying the class is cheap, and hence it can be shared between threads. (The call operator and .prime() are threadsafe.)

One unique aspect of this interpolator is that it can be updated in constant time. Hence we can use boost::circular_buffer to do real-time interpolation:

#include <boost/circular_buffer.hpp>
...
boost::circular_buffer<double> initial_x{1,2,3,4};
boost::circular_buffer<double> initial_y{4,5,6,7};
auto circular_akima = makima(std::move(initial_x), std::move(initial_y));
// interpolate via call operation:
double y = circular_akima(3.5);