Detailed Description

This class implements a one dimensional piecewise linear interpolation algorithm.

Definition at line 14 of file PiecewiseLinearInterpolation.h.

#include <PiecewiseLinearInterpolation.h>

Inheritance diagram for MathLib::PiecewiseLinearInterpolation:

Public Member Functions
	PiecewiseLinearInterpolation (std::vector< double > supporting_points, std::vector< double > values_at_supp_pnts, bool supp_pnts_sorted=false)
	PiecewiseLinearInterpolation (std::vector< int > const &supporting_points, std::vector< double > const &values_at_supp_pnts, bool supp_pnts_sorted=false)
double	getValue (double pnt_to_interpolate) const
	Calculates the interpolation value.
double	getDerivative (double const pnt_to_interpolate) const
	Calculates derivative using quadratic interpolation and central difference quotient.
double	getSupportMax () const
double	getSupportMin () const

Protected Attributes
std::vector< double >	supp_pnts_
std::vector< double >	values_at_supp_pnts_

Constructor & Destructor Documentation

◆ PiecewiseLinearInterpolation() [1/2]

MathLib::PiecewiseLinearInterpolation::PiecewiseLinearInterpolation	(	std::vector< double >	supporting_points,
		std::vector< double >	values_at_supp_pnts,
		bool	supp_pnts_sorted = false )

The constructor copies the entries of the vector of supporting points \((x_0, x_1, \dots, x_n)\) and the entries of the vector of values at the supporting points \((y_0, y_1, \dots, y_n)\) where \(n\) is the number of entries of the vector. The number of supporting points must be the same like the number of values at the supporting points. It is assumed that \(x_j\) corresponds to \(y_j\) for all \(j \in [0, n]\).

It is not assumed that the supporting points are sorted, i.e. \(x_0 < x_1 < \dots < x_n\). It is assumed, that the supporting points are pairwise different. The user can set the flag supp_pnts_sorted to true, if the supporting points are sorted. This will save some setup time.

Parameters

supporting_points	vector of supporting points
values_at_supp_pnts	vector of values at the supporting points
supp_pnts_sorted	false (default), if it is sure the supporting points are sorted one can set the switch to true

Definition at line 17 of file PiecewiseLinearInterpolation.cpp.

    : supp_pnts_(std::move(supporting_points)),
      values_at_supp_pnts_(std::move(values_at_supp_pnts))
{
    if (!supp_pnts_sorted)
    {
        BaseLib::quicksort<double, double>(
            supp_pnts_, static_cast<std::size_t>(0), supp_pnts_.size(),
            values_at_supp_pnts_);
    }
 
    const auto it = std::adjacent_find(supp_pnts_.begin(), supp_pnts_.end());
    if (it != supp_pnts_.end())
    {
        const std::size_t i = std::distance(supp_pnts_.begin(), it);
        OGS_FATAL(
            "Variable {:d} and variable {:d} are the same. Piecewise linear "
            "interpolation is not possible\n",
            i, i + 1);
    }
}

References OGS_FATAL, BaseLib::quicksort(), supp_pnts_, and values_at_supp_pnts_.

Referenced by MathLib::PiecewiseLinearMonotonicCurve::PiecewiseLinearMonotonicCurve().

◆ PiecewiseLinearInterpolation() [2/2]

MathLib::PiecewiseLinearInterpolation::PiecewiseLinearInterpolation	(	std::vector< int > const &	supporting_points,
		std::vector< double > const &	values_at_supp_pnts,
		bool	supp_pnts_sorted = false )

Definition at line 43 of file PiecewiseLinearInterpolation.cpp.

    : supp_pnts_(supporting_points | ranges::to<std::vector<double>>()),
      values_at_supp_pnts_(values_at_supp_pnts)
{
    if (!supp_pnts_sorted)
    {
        BaseLib::quicksort<double, double>(
            supp_pnts_, static_cast<std::size_t>(0), supp_pnts_.size(),
            values_at_supp_pnts_);
    }
 
    const auto it = std::adjacent_find(supp_pnts_.begin(), supp_pnts_.end());
    if (it != supp_pnts_.end())
    {
        const std::size_t i = std::distance(supp_pnts_.begin(), it);
        OGS_FATAL(
            "Variable {:d} and variable {:d} are the same. Piecewise linear "
            "interpolation is not possible\n",
            i, i + 1);
    }
}

References OGS_FATAL, BaseLib::quicksort(), supp_pnts_, and values_at_supp_pnts_.

Member Function Documentation

◆ getDerivative()

double MathLib::PiecewiseLinearInterpolation::getDerivative ( double const pnt_to_interpolate ) const

Calculates derivative using quadratic interpolation and central difference quotient.

Parameters

pnt_to_interpolate The point should be located within the range \([x_{\min}, x_{\max}]\), where \(x_{\min} = \min_{1 \le j \le n} x_j\) and \(x_{\max} = \max_{1 \le j \le n} x_j\). when points are located outside of this interval, the derivative is set to 0.

Attention: if a point is located between the first and second points (or last and second to last point), the derivative is calculated using linear interpolation.

Definition at line 98 of file PiecewiseLinearInterpolation.cpp.

{
    if (pnt_to_interpolate < supp_pnts_.front() ||
        supp_pnts_.back() < pnt_to_interpolate)
    {
        return 0;
    }
 
    auto const& it(std::lower_bound(supp_pnts_.begin(), supp_pnts_.end(),
                                    pnt_to_interpolate));
    std::size_t interval_idx = std::distance(supp_pnts_.begin(), it);
 
    if (pnt_to_interpolate == supp_pnts_.front())
    {
        interval_idx = 1;
    }
 
    if (interval_idx > 1 && interval_idx < supp_pnts_.size() - 2)
    {
        // left and right support points.
        double const x_ll = supp_pnts_[interval_idx - 2];
        double const x_l = supp_pnts_[interval_idx - 1];
        double const x = supp_pnts_[interval_idx];
        double const x_r = supp_pnts_[interval_idx + 1];
 
        // left and right values.
        double const f_ll = values_at_supp_pnts_[interval_idx - 2];
        double const f_l = values_at_supp_pnts_[interval_idx - 1];
        double const f = values_at_supp_pnts_[interval_idx];
        double const f_r = values_at_supp_pnts_[interval_idx + 1];
 
        double const tangent_right = (f_l - f_r) / (x_l - x_r);
        double const tangent_left = (f_ll - f) / (x_ll - x);
        double const w = (pnt_to_interpolate - x) / (x_l - x);
        return (1. - w) * tangent_right + w * tangent_left;
    }
 
    return (values_at_supp_pnts_[interval_idx] -
            values_at_supp_pnts_[interval_idx - 1]) /
           (supp_pnts_[interval_idx] - supp_pnts_[interval_idx - 1]);
}

References supp_pnts_, and values_at_supp_pnts_.

Referenced by MathLib::PiecewiseLinearMonotonicCurve::isStrongMonotonic().

◆ getSupportMax()

double MathLib::PiecewiseLinearInterpolation::getSupportMax ( ) const

Definition at line 141 of file PiecewiseLinearInterpolation.cpp.

{
    assert(!supp_pnts_.empty());
    return supp_pnts_.back();
}

References supp_pnts_.

◆ getSupportMin()

double MathLib::PiecewiseLinearInterpolation::getSupportMin ( ) const

Definition at line 146 of file PiecewiseLinearInterpolation.cpp.

{
    assert(!supp_pnts_.empty());
    return supp_pnts_.front();
}

References supp_pnts_.

◆ getValue()

double MathLib::PiecewiseLinearInterpolation::getValue ( double pnt_to_interpolate ) const

Calculates the interpolation value.

Parameters

pnt_to_interpolate The point should be located within the range \([x_{\min}, x_{\max}]\), where \(x_{\min} = \min_{1 \le j \le n} x_j\) and \(x_{\max} = \max_{1 \le j \le n} x_j\). Points outside of this interval are set to \(x_{\min}\) or \(x_{\max}\).

Returns: The interpolated value.

Definition at line 68 of file PiecewiseLinearInterpolation.cpp.

{
    // search interval that has the point inside
    if (pnt_to_interpolate <= supp_pnts_.front())
    {
        return values_at_supp_pnts_[0];
    }
 
    if (supp_pnts_.back() <= pnt_to_interpolate)
    {
        return values_at_supp_pnts_[supp_pnts_.size() - 1];
    }
 
    auto const& it(std::lower_bound(supp_pnts_.begin(), supp_pnts_.end(),
                                    pnt_to_interpolate));
    std::size_t const interval_idx = std::distance(supp_pnts_.begin(), it) - 1;
 
    // support points.
    double const x = supp_pnts_[interval_idx];
    double const x_r = supp_pnts_[interval_idx + 1];
 
    // values.
    double const f = values_at_supp_pnts_[interval_idx];
    double const f_r = values_at_supp_pnts_[interval_idx + 1];
 
    // compute linear interpolation polynom: y = m * (x - support[i]) + value[i]
    const double t = (pnt_to_interpolate - x) / (x_r - x);
    return std::lerp(f, f_r, t);
}