Numerically stabilised general linear least squares. More...

#include <qle/math/stabilisedglls.hpp>

Collaboration diagram for StabilisedGLLS:

Public Types
enum	Method { None , MaxAbs , MeanStdDev }

Public Member Functions
template<class xContainer , class yContainer , class vContainer >
	StabilisedGLLS (const xContainer &x, const yContainer &y, const vContainer &v, const Method method=MeanStdDev)

const Array &	transformedCoefficients () const

const Array &	transformedResiduals () const

const Array &	transformedStandardErrors () const

const Array &	transformedError () const

const Array &	xMultiplier () const
	Transformation parameters (u => (u + shift) * multiplier for u = x, y) More...

const Array &	xShift () const

const Real	yMultiplier () const

const Real	yShift () const

Size	size () const

Size	dim () const

template<class xType , class vContainer >
Real	eval (xType x, vContainer &v, typename boost::enable_if< typename boost::is_arithmetic< xType >::type >::type *=0)
	evaluate regression function in terms of original x, y More...

template<class xType , class vContainer >
Real	eval (xType x, vContainer &v, typename boost::disable_if< typename boost::is_arithmetic< xType >::type >::type *=0)
	evaluate regression function in terms of original x, y More...

Protected Member Functions
template<class xContainer , class yContainer , class vContainer >
void	calculate (xContainer x, yContainer y, vContainer v, typename boost::enable_if< typename boost::is_arithmetic< typename xContainer::value_type >::type >::type *=0)

template<class xContainer , class yContainer , class vContainer >
void	calculate (xContainer x, yContainer y, vContainer v, typename boost::disable_if< typename boost::is_arithmetic< typename xContainer::value_type >::type >::type *=0)

Protected Attributes
Array	a_

Array	err_

Array	residuals_

Array	standardErrors_

Array	xMultiplier_

Array	xShift_

Real	yMultiplier_

Real	yShift_

Method	method_

QuantLib::ext::shared_ptr< GeneralLinearLeastSquares >	glls_

Detailed Description

Numerically stabilised general linear least squares.

The input data is linearly transformed before performing the linear least squares fit. The linear least squares fit on the transformed data is done using the GeneralLinearLeastSquares class.

Definition at line 51 of file stabilisedglls.hpp.

Member Enumeration Documentation

◆ Method

enum Method

Enumerator
None
MaxAbs
MeanStdDev

Definition at line 53 of file stabilisedglls.hpp.

                {
        None,      // No stabilisation
        MaxAbs,    // Divide x and y values by max of abs of values (per x coordinate, y)
        MeanStdDev // Subtract mean and divide by std dev (per x coordinate, y)
    };

Constructor & Destructor Documentation

◆ StabilisedGLLS()

StabilisedGLLS	(	const xContainer &	x,
		const yContainer &	y,
		const vContainer &	v,
		const Method	method = `MeanStdDev`
	)

Definition at line 102 of file stabilisedglls.hpp.

    : a_(v.end() - v.begin(), 0.0), err_(v.end() - v.begin(), 0.0), residuals_(y.end() - y.begin()),
      standardErrors_(v.end() - v.begin()), method_(method) {
    calculate(x, y, v);
}

Here is the call graph for this function:

Member Function Documentation

◆ transformedCoefficients()

const Array & transformedCoefficients ( ) const

Definition at line 61 of file stabilisedglls.hpp.

61{ return glls_->coefficients(); }

QuantExt::StabilisedGLLS::glls_

QuantLib::ext::shared_ptr< GeneralLinearLeastSquares > glls_

Definition: stabilisedglls.hpp:88

Here is the caller graph for this function:

◆ transformedResiduals()

const Array & transformedResiduals ( ) const

Definition at line 62 of file stabilisedglls.hpp.

62{ return glls_->residuals(); }

◆ transformedStandardErrors()

const Array & transformedStandardErrors ( ) const

Definition at line 63 of file stabilisedglls.hpp.

63{ return glls_->standardErrors(); }

◆ transformedError()

const Array & transformedError ( ) const

Definition at line 64 of file stabilisedglls.hpp.

64{ return glls_->error(); }

◆ xMultiplier()

const Array & xMultiplier ( ) const

Transformation parameters (u => (u + shift) * multiplier for u = x, y)

Definition at line 67 of file stabilisedglls.hpp.

67{ return xMultiplier_; }

QuantExt::StabilisedGLLS::xMultiplier_

Array xMultiplier_

Definition: stabilisedglls.hpp:85

Here is the caller graph for this function:

◆ xShift()

const Array & xShift ( ) const

Definition at line 68 of file stabilisedglls.hpp.

68{ return xShift_; }

QuantExt::StabilisedGLLS::xShift_

Array xShift_

Definition: stabilisedglls.hpp:85

◆ yMultiplier()

const Real yMultiplier ( ) const

Definition at line 69 of file stabilisedglls.hpp.

69{ return yMultiplier_; }

QuantExt::StabilisedGLLS::yMultiplier_

Real yMultiplier_

Definition: stabilisedglls.hpp:86

Here is the caller graph for this function:

◆ yShift()

const Real yShift ( ) const

Definition at line 70 of file stabilisedglls.hpp.

70{ return yShift_; }

QuantExt::StabilisedGLLS::yShift_

Real yShift_

Definition: stabilisedglls.hpp:86

◆ size()

Size size ( ) const

Definition at line 72 of file stabilisedglls.hpp.

72{ return glls_->residuals().size(); }

◆ dim()

Size dim ( ) const

Definition at line 73 of file stabilisedglls.hpp.

73{ return glls_->coefficients().size(); }

◆ eval() [1/2]

Real eval	(	xType	x,
		vContainer &	v,
		typename boost::enable_if< typename boost::is_arithmetic< xType >::type >::type *	= `0`
	)

evaluate regression function in terms of original x, y

Definition at line 248 of file stabilisedglls.hpp.

                                                                                                {
    QL_REQUIRE(v.size() == glls_->dim(),
               "StabilisedGLLS::eval(): v size (" << v.size() << ") must be equal to dim (" << glls_->dim());
    Real tmp = 0.0;
    for (Size i = 0; i < v.size(); ++i) {
        tmp += glls_->coefficients()[i] * v[i]((x + xShift_[0]) * xMultiplier_[0]);
    }
    return tmp / yMultiplier_ - yShift_;
}

Here is the caller graph for this function:

◆ eval() [2/2]

Real eval	(	xType	x,
		vContainer &	v,
		typename boost::disable_if< typename boost::is_arithmetic< xType >::type >::type *	= `0`
	)

evaluate regression function in terms of original x, y

Definition at line 260 of file stabilisedglls.hpp.

                                                                                                 {
    QL_REQUIRE(v.size() == glls_->dim(),
               "StabilisedGLLS::eval(): v size (" << v.size() << ") must be equal to dim (" << glls_->dim());
    Real tmp = 0.0;
    for (Size i = 0; i < v.size(); ++i) {
        xType xNew(x.end() - x.begin());
        for (Size j = 0; j < static_cast<Size>(x.end() - x.begin()); ++j) {
            xNew[j] = (x[j] + xShift_[j]) * xMultiplier_[j];
        }
        tmp += glls_->coefficients()[i] * v[i](xNew);
    }
    return tmp / yMultiplier_ - yShift_;
}

◆ calculate() [1/2]

void calculate	(	xContainer	x,
		yContainer	y,
		vContainer	v,
		typename boost::enable_if< typename boost::is_arithmetic< typename xContainer::value_type >::type >::type *	= `0`
	)

protected

Definition at line 110 of file stabilisedglls.hpp.

                                                                                                  {
 
    std::vector<Real> xData(x.end() - x.begin(), 0.0), yData(y.end() - y.begin(), 0.0);
    xMultiplier_ = Array(1, 1.0);
    xShift_ = Array(1, 0.0);
    yMultiplier_ = 1.0;
    yShift_ = 0.0;
 
    switch (method_) {
    case None:
        break;
    case MaxAbs: {
        Real mx = 0.0, my = 0.0;
        for (Size i = 0; i < static_cast<Size>(x.end() - x.begin()); ++i) {
            mx = std::max(std::abs(x[i]), mx);
        }
        if (!QuantLib::close_enough(mx, 0.0))
            xMultiplier_[0] = 1.0 / mx;
        for (Size i = 0; i < static_cast<Size>(y.end() - y.begin()); ++i) {
            my = std::max(std::abs(y[i]), my);
        }
        if (!QuantLib::close_enough(my, 0.0))
            yMultiplier_ = 1.0 / my;
        break;
    }
    case MeanStdDev: {
        accumulator_set<Real, stats<boost::accumulators::tag::mean, boost::accumulators::tag::variance> > acc;
        for (Size i = 0; i < static_cast<Size>(x.end() - x.begin()); ++i) {
            acc(x[i]);
        }
        xShift_[0] = -mean(acc);
        Real tmp = boost::accumulators::variance(acc);
        if (!QuantLib::close_enough(tmp, 0.0))
            xMultiplier_[0] = 1.0 / std::sqrt(tmp);
        accumulator_set<Real, stats<boost::accumulators::tag::mean, boost::accumulators::tag::variance> > acc2;
        for (Size i = 0; i < static_cast<Size>(y.end() - y.begin()); ++i) {
            acc2(y[i]);
        }
        yShift_ = -mean(acc2);
        Real tmp2 = boost::accumulators::variance(acc2);
        if (!QuantLib::close_enough(tmp2, 0.0))
            yMultiplier_ = 1.0 / std::sqrt(tmp2);
        break;
    }
    default:
        QL_FAIL("unknown stabilisation method");
    }
 
    for (Size i = 0; i < static_cast<Size>(x.end() - x.begin()); ++i) {
        xData[i] = (x[i] + xShift_[0]) * xMultiplier_[0];
    }
    for (Size i = 0; i < static_cast<Size>(y.end() - y.begin()); ++i) {
        yData[i] = (y[i] + yShift_) * yMultiplier_;
    }
 
    glls_ = QuantLib::ext::make_shared<GeneralLinearLeastSquares>(xData, yData, v);
}

Here is the caller graph for this function:

◆ calculate() [2/2]

void calculate	(	xContainer	x,
		yContainer	y,
		vContainer	v,
		typename boost::disable_if< typename boost::is_arithmetic< typename xContainer::value_type >::type >::type *	= `0`
	)

protected

Definition at line 171 of file stabilisedglls.hpp.

                                                                                                   {
 
    QL_REQUIRE(x.end() - x.begin() > 0, "StabilisedGLLS::calculate(): x container is empty");
    QL_REQUIRE(x[0].end() - x[0].begin() > 0, "StabilisedGLLS:calculate(): x contains empty point(s)");
 
    std::vector<Array> xData(x.end() - x.begin(), Array(x[0].end() - x[0].begin(), 0.0));
    std::vector<Real> yData(y.end() - y.begin(), 0.0);
    xMultiplier_ = Array(x[0].end() - x[0].begin(), 1.0);
    xShift_ = Array(x[0].end() - x[0].begin(), 0.0);
    yMultiplier_ = 1.0;
    yShift_ = 0.0;
 
    switch (method_) {
    case None:
        break;
    case MaxAbs: {
        Array m(x[0].end() - x[0].begin(), 0.0);
        Real my = 0.0;
        for (Size i = 0; i < static_cast<Size>(x.end() - x.begin()); ++i) {
            for (Size j = 0; j < m.size(); ++j) {
                m[j] = std::max(std::abs(x[i][j]), m[j]);
            }
        }
        for (Size j = 0; j < m.size(); ++j) {
            if (!QuantLib::close_enough(m[j], 0.0))
                xMultiplier_[j] = 1.0 / m[j];
        }
        for (Size i = 0; i < static_cast<Size>(y.end() - y.begin()); ++i) {
            my = std::max(std::abs(y[i]), my);
        }
        if (!QuantLib::close_enough(my, 0.0))
            yMultiplier_ = 1.0 / my;
        break;
    }
    case MeanStdDev: {
        std::vector<accumulator_set<Real, stats<boost::accumulators::tag::mean, boost::accumulators::tag::variance> > > acc(x[0].end() - x[0].begin());
        for (Size i = 0; i < static_cast<Size>(x.end() - x.begin()); ++i) {
            for (Size j = 0; j < acc.size(); ++j) {
                acc[j](x[i][j]);
            }
        }
        for (Size j = 0; j < acc.size(); ++j) {
            xShift_[j] = -mean(acc[j]);
            Real tmp = boost::accumulators::variance(acc[j]);
            if (!QuantLib::close_enough(tmp, 0.0))
                xMultiplier_[j] = 1.0 / std::sqrt(tmp);
        }
        accumulator_set<Real, stats<boost::accumulators::tag::mean, boost::accumulators::tag::variance> > acc2;
        for (Size i = 0; i < static_cast<Size>(y.end() - y.begin()); ++i) {
            acc2(y[i]);
        }
        yShift_ = -mean(acc2);
        Real tmp2 = boost::accumulators::variance(acc2);
        if (!QuantLib::close_enough(tmp2, 0.0))
            yMultiplier_ = 1.0 / std::sqrt(tmp2);
        break;
    }
    default:
        QL_FAIL("unknown stabilisation method");
        break;
    }
 
    for (Size i = 0; i < static_cast<Size>(x.end() - x.begin()); ++i) {
        for (Size j = 0; j < xMultiplier_.size(); ++j) {
            xData[i][j] = (x[i][j] + xShift_[j]) * xMultiplier_[j];
        }
    }
    for (Size i = 0; i < static_cast<Size>(y.end() - y.begin()); ++i) {
        yData[i] = (y[i] + yShift_) * yMultiplier_;
    }
 
    glls_ = QuantLib::ext::make_shared<GeneralLinearLeastSquares>(xData, yData, v);
}

Member Data Documentation

◆ a_

Array a_

protected

Definition at line 85 of file stabilisedglls.hpp.

◆ err_

Array err_

protected

Definition at line 85 of file stabilisedglls.hpp.

◆ residuals_

Array residuals_

protected

Definition at line 85 of file stabilisedglls.hpp.

◆ standardErrors_

Array standardErrors_

protected

Definition at line 85 of file stabilisedglls.hpp.

◆ xMultiplier_

Array xMultiplier_

protected

Definition at line 85 of file stabilisedglls.hpp.

◆ xShift_

Array xShift_

protected

Definition at line 85 of file stabilisedglls.hpp.

◆ yMultiplier_

Real yMultiplier_

protected

Definition at line 86 of file stabilisedglls.hpp.

◆ yShift_

Real yShift_

protected

Definition at line 86 of file stabilisedglls.hpp.

◆ method_

Method method_

protected

Definition at line 87 of file stabilisedglls.hpp.

◆ glls_

QuantLib::ext::shared_ptr<GeneralLinearLeastSquares> glls_

protected

Definition at line 88 of file stabilisedglls.hpp.

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ Method

Constructor & Destructor Documentation

◆ StabilisedGLLS()

Member Function Documentation

◆ transformedCoefficients()

◆ transformedResiduals()

◆ transformedStandardErrors()

◆ transformedError()

◆ xMultiplier()

◆ xShift()

◆ yMultiplier()

◆ yShift()

◆ size()

◆ dim()

◆ eval() [1/2]

◆ eval() [2/2]

◆ calculate() [1/2]

◆ calculate() [2/2]

Member Data Documentation

◆ a_

◆ err_

◆ residuals_

◆ standardErrors_

◆ xMultiplier_

◆ xShift_

◆ yMultiplier_

◆ yShift_

◆ method_

◆ glls_