lsst::afw::math::InterpolateConstant Class Reference

Inheritance diagram for lsst::afw::math::InterpolateConstant:

Public Types
enum	Style {   UNKNOWN = -1 , CONSTANT = 0 , LINEAR = 1 , NATURAL_SPLINE = 2 ,   CUBIC_SPLINE = 3 , CUBIC_SPLINE_PERIODIC = 4 , AKIMA_SPLINE = 5 , AKIMA_SPLINE_PERIODIC = 6 ,   NUM_STYLES }

Public Member Functions
	~InterpolateConstant () override=default
double	interpolate (double const x) const override
std::vector< double >	interpolate (std::vector< double > const &x) const
ndarray::Array< double, 1 >	interpolate (ndarray::Array< double const, 1 > const &x) const

Protected Attributes
std::vector< double > const	_x
std::vector< double > const	_y
Interpolate::Style const	_style

Friends
std::shared_ptr< Interpolate >	makeInterpolate (std::vector< double > const &x, std::vector< double > const &y, Interpolate::Style const style)
	A factory function to make Interpolate objects. More...

Detailed Description

Definition at line 75 of file Interpolate.cc.

Member Enumeration Documentation

Style

enum lsst::afw::math::Interpolate::Style

inherited

Enumerator
UNKNOWN
CONSTANT
LINEAR
NATURAL_SPLINE
CUBIC_SPLINE
CUBIC_SPLINE_PERIODIC
AKIMA_SPLINE
AKIMA_SPLINE_PERIODIC
NUM_STYLES

Definition at line 38 of file Interpolate.h.

               {
        UNKNOWN = -1,
        CONSTANT = 0,
        LINEAR = 1,
        NATURAL_SPLINE = 2,
        CUBIC_SPLINE = 3,
        CUBIC_SPLINE_PERIODIC = 4,
        AKIMA_SPLINE = 5,
        AKIMA_SPLINE_PERIODIC = 6,
        NUM_STYLES
    };

Constructor & Destructor Documentation

~InterpolateConstant()

lsst::afw::math::InterpolateConstant::~InterpolateConstant ( )

overridedefault

Member Function Documentation

interpolate() [1/3]

double lsst::afw::math::InterpolateConstant::interpolate ( double const  x ) const

overridevirtual

Implements lsst::afw::math::Interpolate.

Definition at line 94 of file Interpolate.cc.

                                                {
    //
    // Look for the interval wherein lies xInterp.  We could naively use std::upper_bound, but that requires a
    // logarithmic time lookup so we'll cache the previous answer in _old -- this is a good idea if people
    // usually call this routine repeatedly for a range of x
    //
    // We start by searching up from _old
    //
    if (xInterp < *_old) {         // We're to the left of the cache
        if (_old == _x.begin()) {  // ... actually off the array
            return _y[0];
        }
        _old = _x.begin();  // reset the cached point to the start of the array
    } else {                // see if we're still in the same interval
        if (_old < _x.end() - 1 and xInterp < *(_old + 1)) {  // we are, so we're done
            return _y[_old - _x.begin()];
        }
    }
    // We're to the right of the cached point and not in the same inverval, so search up from _old
    std::vector<double>::const_iterator low = std::upper_bound(_old, _x.end(), xInterp);
    //
    // Did that work?
    if (low == _old && _old != _x.begin()) {
        // No.  Sigh.  Search the entire range.
        low = std::upper_bound(_x.begin(), low + 1, xInterp);
    }
    //
    // OK, we've found the right interval.  Return the desired value, being careful at the ends
    //
    if (low == _x.end()) {
        return _y[_y.size() - 1];
    } else if (low == _x.begin()) {
        return _y[0];
    } else {
        --low;
        _old = low;
        return _y[low - _x.begin()];
    }
}

interpolate() [2/3]

ndarray::Array< double, 1 > lsst::afw::math::Interpolate::interpolate ( ndarray::Array< double const, 1 > const &  x ) const

inherited

Definition at line 303 of file Interpolate.cc.

                                                                                             {
    int const num = x.getShape()[0];
    ndarray::Array<double, 1> out = ndarray::allocate(ndarray::makeVector(num));
    for (int i = 0; i < num; ++i) {
        std::cout << "Interpolating " << x[i] << std::endl;
        out[i] = interpolate(x[i]);
    }
    return out;
}

interpolate() [3/3]

std::vector< double > lsst::afw::math::Interpolate::interpolate ( std::vector< double > const &  x ) const

inherited

Definition at line 294 of file Interpolate.cc.

                                                                           {
    size_t const num = x.size();
    std::vector<double> out(num);
    for (size_t i = 0; i < num; ++i) {
        out[i] = interpolate(x[i]);
    }
    return out;
}

Friends And Related Function Documentation

makeInterpolate

std::shared_ptr<Interpolate> makeInterpolate ( std::vector< double > const &  x, std::vector< double > const &  y, Interpolate::Style const  style = Interpolate::AKIMA_SPLINE  )

friend

A factory function to make Interpolate objects.

Parameters

x	the x-values of points
y	the values at x[]
style	desired interpolator

Definition at line 342 of file Interpolate.cc.

                                                                           {
    switch (style) {
        case Interpolate::CONSTANT:
            return std::shared_ptr<Interpolate>(new InterpolateConstant(x, y, style));
        default:  // use GSL
            return std::shared_ptr<Interpolate>(new InterpolateGsl(x, y, style));
    }
}

Member Data Documentation

_style

Interpolate::Style const lsst::afw::math::Interpolate::_style

protectedinherited

Definition at line 85 of file Interpolate.h.

_x

std::vector<double> const lsst::afw::math::Interpolate::_x

protectedinherited

Definition at line 83 of file Interpolate.h.

_y

std::vector<double> const lsst::afw::math::Interpolate::_y

protectedinherited

Definition at line 84 of file Interpolate.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-32-g5ddfab5d3+60ce4897b0/src/math/Interpolate.cc