smash::InterpolateDataLinear< T > Class Template Reference

#include <interpolation.h>

template<typename T>
class smash::InterpolateDataLinear< T >

Represent a piecewise linear interpolation.

Parameters

T	Type of interpolated values.

Definition at line 67 of file interpolation.h.

Collaboration diagram for smash::InterpolateDataLinear< T >:

Public Member Functions
	InterpolateDataLinear (const std::vector< T > &x, const std::vector< T > &y, ExtrapolationType extrapolation_type=ExtrapolationType::None)
	Interpolate function f given discrete samples f(x_i) = y_i. More...
T	operator() (T x) const
	Calculate linear interpolation at x. More...

Private Attributes
std::vector< T >	x_ {}
	x_i More...
std::vector< InterpolateLinear< T > >	f_ {}
	Piecewise linear interpolation using f(x_i) More...
ExtrapolationType	extrapolation_type_ = ExtrapolationType::None
	Extrapolation type. More...

Constructor & Destructor Documentation

InterpolateDataLinear()

template<typename T >

smash::InterpolateDataLinear< T >::InterpolateDataLinear	(	const std::vector< T > &	x,
		const std::vector< T > &	y,
		ExtrapolationType	extrapolation_type = ExtrapolationType::None
	)

Interpolate function f given discrete samples f(x_i) = y_i.

Piecewise linear interpolation is used.

Parameters

x	x-values.
y	y-values.
extrapolation_type	Type of extrapolation for requested x_i values that are out of bounds. Extrapolation is by default disabled. Possible types are None, Zero, Constant, and Linear.

Returns

The interpolation function.

Exceptions

std::invalid_argument	if vectors x and y have different length.
std::out_of_range	if values outside of the boundaries of the underlying data are tried to be accessed and extrapolation is disabled.
std::invalid_argument	if unsupported extrapolation type is requested.

Definition at line 186 of file interpolation.h.

    : extrapolation_type_{extrapolation_type} {
  switch (extrapolation_type_) {
    case ExtrapolationType::None:
    case ExtrapolationType::Zero:
    case ExtrapolationType::Constant:
    case ExtrapolationType::Linear:
      break;
    default:
      throw std::invalid_argument(
          "The provided extrapolation type is not supported. Valid types are "
          "'None', 'Zero', 'Constant', and 'Linear'.");
  }
  if (x.size() != y.size()) {
    throw std::invalid_argument(
        "The interpolation requires two vectors of equal length.");
  }
  const size_t n = x.size();
  const auto p = generate_sort_permutation(
      x, [&](T const& a, T const& b) { return a < b; });
  x_ = apply_permutation(x, p);
  check_duplicates(x_, "InterpolateDataLinear");
  std::vector<T> y_sorted = apply_permutation(y, p);
  f_.reserve(n - 1);
  for (size_t i = 0; i < n - 1; i++) {
    f_.emplace_back(
        InterpolateLinear<T>(x_[i], y_sorted[i], x_[i + 1], y_sorted[i + 1]));
  }
}

Here is the call graph for this function:

Member Function Documentation

operator()()

template<typename T >

T smash::InterpolateDataLinear< T >::operator()

(

T

x

)

const

Calculate linear interpolation at x.

Parameters

x	Interpolation argument.

Returns

Interpolated value.

Exceptions

std::out_of_range

if values outside of the boundaries of the underlying data are tried to be accessed and extrapolation is disabled.

Definition at line 247 of file interpolation.h.

                                                 {
  const double first_x = x_.front();
  const double last_x = x_.back();
  if (x0 < first_x || x0 > last_x) {
    if (extrapolation_type_ == ExtrapolationType::None) {
      std::ostringstream error_msg{
          "InterpolateDataLinear only accepts x values within the range of the "
          "underlying data\nwhen an extrapolation type is not specified. ",
          std::ios::ate};
      error_msg << "x value " << x0 << " is out of bounds.";
      throw std::out_of_range(error_msg.str());
    } else if (extrapolation_type_ == ExtrapolationType::Zero) {
      return 0.;
    } else if (extrapolation_type_ == ExtrapolationType::Constant) {
      return (x0 < first_x) ? f_.front()(first_x) : f_.back()(last_x);
    } else if (extrapolation_type_ == ExtrapolationType::Linear) {
      return (x0 < first_x) ? f_.front()(x0) : f_.back()(x0);
    }
  }
  // Find the piecewise linear interpolation corresponding to x0.
  const size_t i = find_index(x_, x0);
  return f_[i](x0);
}

Here is the call graph for this function:

Member Data Documentation

x_

template<typename T >

std::vector<T> smash::InterpolateDataLinear< T >::x_ {}

private

x_i

Definition at line 107 of file interpolation.h.

f_

template<typename T >

std::vector<InterpolateLinear<T> > smash::InterpolateDataLinear< T >::f_ {}

private

Piecewise linear interpolation using f(x_i)

Definition at line 109 of file interpolation.h.

extrapolation_type_

template<typename T >

ExtrapolationType smash::InterpolateDataLinear< T >::extrapolation_type_ = ExtrapolationType::None

private

Extrapolation type.

Definition at line 111 of file interpolation.h.

---

The documentation for this class was generated from the following file:

• src/include/smash/interpolation.h