interp::InterpSetData Class Reference

Class for managing a set of data and performing interpolation. More...

#include "interpolation_set.h"

Public Member Functions
template<RealConcept T>
void	insertSample (T x, T y) noexcept
	Inserts a sample point into the interpolation set.
template<RealConcept T>
std::optional< T >	value (T x) const noexcept
	Retrieves the interpolated value at a given point.
double	max () const noexcept
	Retrieves the maximum absolute value in the interpolation set.
template<RealConcept T>
void	divide (T a)
	Divides all y-values in the dataset by a given number.

Detailed Description

Class for managing a set of data and performing interpolation.

Definition at line 30 of file interpolation_set.h.

Member Function Documentation

divide()

template<RealConcept T>

template void interp::InterpSetData::divide< float >

(

T

a

)

Divides all y-values in the dataset by a given number.

Template Parameters

T	The type of the divisor (must be an arithmetic type).

Parameters

a	The divisor to divide all y-values by.

Exceptions

std::invalid_argument

Thrown if the divisor is zero.

Definition at line 75 of file interpolation_set.cpp.

    {
        if (a == 0)
        {
            throw std::invalid_argument("Division by zero is not allowed.");
        }
 
        std::ranges::for_each(_data | std::views::values, [a](auto& value) { value /= static_cast<double>(a); });
    }

References value().

Here is the call graph for this function:

insertSample()

template<RealConcept T>

void interp::InterpSetData::insertSample ( T  x, T  y  )

noexcept

Inserts a sample point into the interpolation set.

Template Parameters

T	The type of the x and y coordinates (must be an arithmetic type).

Parameters

x	The x-coordinate of the sample point.
y	The y-coordinate of the sample point.

Definition at line 41 of file interpolation_set.h.

        {
            _data.insert({x, y});
        }

max()

double interp::InterpSetData::max ( ) const

noexcept

Retrieves the maximum absolute value in the interpolation set.

Returns

The maximum absolute y-value in the dataset, or 0.0 if the set is empty.

Definition at line 64 of file interpolation_set.cpp.

    {
        auto values = _data | std::views::values;
 
        const auto max_element =
            std::ranges::max_element(values, [](const double a, const double b) { return std::abs(a) < std::abs(b); });
 
        return max_element != values.end() ? std::abs(*max_element) : 0.0;
    }

value()

template<RealConcept T>

template std::optional< float > interp::InterpSetData::value< float > ( T  x ) const

noexcept

Retrieves the interpolated value at a given point.

Template Parameters

T	The type of the x-coordinate (must be an arithmetic type).

Parameters

x	The x-coordinate at which to interpolate the value.

Returns

The interpolated value at the given x-coordinate, or std::nullopt if the dataset is empty.

Definition at line 25 of file interpolation_set.cpp.

    {
        if (_data.empty())
        {
            return std::nullopt;
        }
 
        // TODO: RealConcept is broader than the implementation really supports?
        // std::is_arithmetic_v<T> admits integral types
        // That may be intended, but for value(T x) it means interpolation with
        // integer queries returns std::optional<int>, and the final interpolated
        // double gets truncated by:
        // return static_cast<T>(...)
        // If the class is conceptually for real-valued interpolation,
        // std::floating_point<T> would be a better constraint
        const RealType x_value = static_cast<RealType>(x);
        const auto iter = _data.lower_bound(x_value);
 
        if (iter == _data.begin())
        {
            return static_cast<T>(iter->second);
        }
        if (iter == _data.end())
        {
            const auto prev = std::prev(iter);
            return static_cast<T>(prev->second);
        }
        if (iter->first == x_value)
        {
            return static_cast<T>(iter->second);
        }
 
        auto prev = std::prev(iter);
        const auto [x1, y1] = *prev;
        const auto [x2, y2] = *iter;
 
        return static_cast<T>(y2 * (x_value - x1) / (x2 - x1) + y1 * (x2 - x_value) / (x2 - x1));
    }

Referenced by divide().

Here is the caller graph for this function:

---

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

• packages/libfers/src/interpolation/interpolation_set.h
• packages/libfers/src/interpolation/interpolation_set.cpp