MathLib::PiecewiseLinearMonotonicCurve Class Reference

Detailed Description

Class for strong monotonic curves.

Definition at line 20 of file PiecewiseLinearMonotonicCurve.h.

#include <PiecewiseLinearMonotonicCurve.h>

Inheritance diagram for MathLib::PiecewiseLinearMonotonicCurve:

Collaboration diagram for MathLib::PiecewiseLinearMonotonicCurve:

Public Member Functions
	PiecewiseLinearMonotonicCurve (std::vector< double > x, std::vector< double > y)
	~PiecewiseLinearMonotonicCurve ()=default
double	getInverseVariable (const double y) const
Public Member Functions inherited from MathLib::PiecewiseLinearInterpolation
	PiecewiseLinearInterpolation (std::vector< double > supporting_points, std::vector< double > 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

Private Member Functions
bool	isStrongMonotonic () const

Additional Inherited Members
Protected Attributes inherited from MathLib::PiecewiseLinearInterpolation
std::vector< double >	supp_pnts_
std::vector< double >	values_at_supp_pnts_

Constructor & Destructor Documentation

PiecewiseLinearMonotonicCurve()

MathLib::PiecewiseLinearMonotonicCurve::PiecewiseLinearMonotonicCurve	(	std::vector< double >	x,
		std::vector< double >	y )

@ x x coordinates of curve points @ y y coordinates of curve points

Definition at line 23 of file PiecewiseLinearMonotonicCurve.cpp.

    : PiecewiseLinearInterpolation(std::move(x), std::move(y), false)
{
    if (!isStrongMonotonic())
    {
        OGS_FATAL("The given curve is not strong monotonic.");
    }
}

References isStrongMonotonic(), and OGS_FATAL.

~PiecewiseLinearMonotonicCurve()

MathLib::PiecewiseLinearMonotonicCurve::~PiecewiseLinearMonotonicCurve ( )

default

Member Function Documentation

getInverseVariable()

double MathLib::PiecewiseLinearMonotonicCurve::getInverseVariable

(

const double

y

)

const

Get variable, x, or abscissa, by a given value y, the ordinate. If this curve is not monotonic, this function gives a fatal error.

Definition at line 47 of file PiecewiseLinearMonotonicCurve.cpp.

{
    std::size_t interval_idx = 0;
    if (values_at_supp_pnts_.front() < values_at_supp_pnts_.back())
    {
        if (y <= values_at_supp_pnts_.front())
        {
            return supp_pnts_[0];
        }
        if (y >= values_at_supp_pnts_.back())
        {
            return supp_pnts_[supp_pnts_.size() - 1];
        }
 
        // search interval that has the point inside
        auto const& it(std::lower_bound(values_at_supp_pnts_.begin(),
                                        values_at_supp_pnts_.end(), y));
        interval_idx = std::distance(values_at_supp_pnts_.begin(), it) - 1;
    }
    else
    {
        if (y >= values_at_supp_pnts_.front())
        {
            return supp_pnts_[0];
        }
        if (y <= values_at_supp_pnts_.back())
        {
            return supp_pnts_[supp_pnts_.size() - 1];
        }
 
        // search interval in the reverse direction for the point inside
        auto const& it(std::lower_bound(values_at_supp_pnts_.rbegin(),
                                        values_at_supp_pnts_.rend(), y));
        interval_idx = values_at_supp_pnts_.size() -
                       (std::distance(values_at_supp_pnts_.rbegin(), it)) - 1;
    }
 
    const double xi_1 = supp_pnts_[interval_idx + 1];
    const double xi = supp_pnts_[interval_idx];
    const double yi_1 = values_at_supp_pnts_[interval_idx + 1];
    const double yi = values_at_supp_pnts_[interval_idx];
 
    // compute gradient: m = (x_{i+1} - x_i) / (y_{i+1} - y_i)
    const double m = (xi_1 - xi) / (yi_1 - yi);
 
    // compute the variable by linear interpolation:  x = m * (y - y_i) + x_i,
    // and then return the result.
    return m * (y - yi) + xi;
}

References MathLib::PiecewiseLinearInterpolation::supp_pnts_, and MathLib::PiecewiseLinearInterpolation::values_at_supp_pnts_.

isStrongMonotonic()

bool MathLib::PiecewiseLinearMonotonicCurve::isStrongMonotonic ( ) const

private

Check monotonicity of this curve such as for any \(i\), \(y(x_{i+1})>y(x_{i})\) if \(x_{i+1}>x_{i}\) or for any \(i\) \(y(x_{i+1})<y(x_{i})\) if \(x_{i+1}>x_{i}\)

Returns

True if the curve exhibits strong monotonic.

Definition at line 33 of file PiecewiseLinearMonotonicCurve.cpp.

{
    const double gradient0 = getDerivative(supp_pnts_[0]);
 
    if (std::abs(gradient0) < std::numeric_limits<double>::min())
    {
        return false;
    }
 
    return std::none_of(supp_pnts_.begin(), supp_pnts_.end(),
                        [&](const double p)
                        { return this->getDerivative(p) * gradient0 <= 0.; });
}

References MathLib::PiecewiseLinearInterpolation::getDerivative(), MathLib::p, and MathLib::PiecewiseLinearInterpolation::supp_pnts_.

Referenced by PiecewiseLinearMonotonicCurve().

---

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

• MathLib/Curve/PiecewiseLinearMonotonicCurve.h
• MathLib/Curve/PiecewiseLinearMonotonicCurve.cpp