Detailed Description

This class implements a one dimensional piecewise linear interpolation algorithm.

Definition at line 25 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 27 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_.

◆ 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 53 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 108 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 MaterialPropertyLib::Curve::dValue(), and MathLib::PiecewiseLinearMonotonicCurve::isStrongMonotonic().

◆ getSupportMax()

double MathLib::PiecewiseLinearInterpolation::getSupportMax ( ) const

Definition at line 151 of file PiecewiseLinearInterpolation.cpp.

152{

153 assert(!supp_pnts_.empty());

154 return supp_pnts_.back();

155}

References supp_pnts_.

Referenced by ProcessLib::DeactivatedSubdomainDirichlet::getEssentialBCValues(), and ProcessLib::DeactivatedSubdomain::isInTimeSupportInterval().

◆ getSupportMin()

double MathLib::PiecewiseLinearInterpolation::getSupportMin ( ) const

Definition at line 156 of file PiecewiseLinearInterpolation.cpp.

157{

158 assert(!supp_pnts_.empty());

159 return supp_pnts_.front();

160}

References supp_pnts_.

Referenced by ProcessLib::DeactivatedSubdomainDirichlet::getEssentialBCValues(), and ProcessLib::DeactivatedSubdomain::isInTimeSupportInterval().

◆ 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 78 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);
}