#include <qle/math/quadraticinterpolation.hpp>

Inheritance diagram for QuadraticInterpolationImpl< I1, I2 >:

Collaboration diagram for QuadraticInterpolationImpl< I1, I2 >:

Public Member Functions
	QuadraticInterpolationImpl (const I1 &xBegin, const I1 &xEnd, const I2 &yBegin, Real x_mul=1, Real x_offset=0, Real y_mul=1, Real y_offset=0)

std::vector< Real >	lambdas () const

void	update () override

Real	value (Real x) const override

Real	primitive (Real x) const override

Real	derivative (Real x) const override

Real	secondDerivative (Real x) const override

Private Attributes
const Size	n_

Real	p_

Real	x_mul_

Real	x_offset_

Real	y_mul_

Real	y_offset_

std::vector< Real >	x_

std::vector< Real >	y_

std::vector< Real >	lambdas_

Detailed Description

template<class I1, class I2>
class QuantExt::detail::QuadraticInterpolationImpl< I1, I2 >

Definition at line 103 of file quadraticinterpolation.hpp.

Constructor & Destructor Documentation

◆ QuadraticInterpolationImpl()

QuadraticInterpolationImpl	(	const I1 &	xBegin,
		const I1 &	xEnd,
		const I2 &	yBegin,
		Real	x_mul = `1`,
		Real	x_offset = `0`,
		Real	y_mul = `1`,
		Real	y_offset = `0`
	)

Definition at line 106 of file quadraticinterpolation.hpp.

             : Interpolation::templateImpl<I1,I2>(xBegin, xEnd, yBegin,
                                                  Quadratic::requiredPoints),
               n_(static_cast<int>(xEnd-xBegin)),
               x_mul_(x_mul), x_offset_(x_offset),
               y_mul_(y_mul), y_offset_(y_offset),
               x_(std::vector<Real>(n_)),
               y_(std::vector<Real>(n_+1)),
               lambdas_(std::vector<Real>(n_)) {}

Member Function Documentation

◆ lambdas()

std::vector< Real > lambdas ( ) const

Definition at line 120 of file quadraticinterpolation.hpp.

                                             {
                 return lambdas_;
             }

◆ update()

void update ( )

override

Definition at line 123 of file quadraticinterpolation.hpp.

                                    {
 
                 for(Size i=0; i < n_; ++i) {
                     x_[i] = this->xBegin_[i] * x_mul_ + x_offset_;
                     y_[i] = this->yBegin_[i] * y_mul_ + y_offset_;
                 }
                 y_[n_] = 0;
 
                 // Return if x <= 0 or y = 0
                 // Error will be thrown when calling value or
                 // derivative functions
                 for(Size i=0; i < n_; ++i) {
                     if(x_[i] <= 0 || QuantLib::close_enough(y_[i], 0.0)) {
                         p_ = Null<Real>();
                         return;
                     }
                 }
 
                 Matrix q(n_+1, n_+1, 0.0);
                 for(Size i=0; i<n_; ++i) {
                     q[i][0] = q[n_][i+1] = x_[i];
 
                     for(Size j=0; j<i; ++j) {
                         q[i][j+1] += std::pow(x_[i] - x_[j], 3) / 6.0;
                     }
                     Time t = -std::pow(x_[i], 3) / 6.0;
                     for(Size j=1; j<n_+1; ++j) {
                         q[i][j] += t;
                     }
                 }
                 Matrix q_inv = QuantLib::inverse(q);
                 Array l(y_.begin(), y_.end());
 
                 Array lambdaArray = q_inv * l;
                 lambdas_ = std::vector<Real>(lambdaArray.begin(),
                                              lambdaArray.end());
 
                 p_ = 0;
                 for(Size i=1; i < n_+1; ++i) {
                     p_ += lambdaArray[i];
                 }
             }

◆ value()

Real value ( Real x ) const

override

Definition at line 165 of file quadraticinterpolation.hpp.

                                               {
                 QL_REQUIRE(p_ != Null<Real>(), "failed to calibrate lambda");
                 x = x * x_mul_ + x_offset_;
                 Real l = lambdas_[0] * x;
                 Real b = 0;
                 for (Size i=0; i<n_ && x_[i]<x; ++i) {
                     b += lambdas_[i+1] * std::pow(x - x_[i], 3);
                 }
                 l += (b - p_ * std::pow(x, 3)) / 6.0;
                 return (l - y_offset_) / y_mul_;
             }

◆ primitive()

Real primitive ( Real x ) const

override

Definition at line 176 of file quadraticinterpolation.hpp.

                                                   {
                 QL_FAIL("QuadraticInterpolation primitive is not implemented");
             }

◆ derivative()

Real derivative ( Real x ) const

override

Definition at line 179 of file quadraticinterpolation.hpp.

                                                    {
                 QL_REQUIRE(p_ != 0.0, "failed to calibrate lambda");
                 x = x * x_mul_ + x_offset_;
                 Real l = lambdas_[0];
                 Real b = 0;
                 for (Size i=0; i<n_ && x_[i]<x; ++i) {
                     b += lambdas_[i+1] * std::pow(x - x_[i], 2);
                 }
                 l += (b - p_ * std::pow(x, 2)) / 2.0;
                 return l / y_mul_;
             }

◆ secondDerivative()

Real secondDerivative ( Real x ) const

override

Definition at line 190 of file quadraticinterpolation.hpp.

                                                          {
                 QL_REQUIRE(p_ != 0.0, "failed to calibrate lambda");
                 x = x * x_mul_ + x_offset_;
                 Real l = 0;
                 Real b = 0;
                 for (Size i=0; i<n_ && x_[i]<x; ++i) {
                     b += lambdas_[i+1] * (x - x_[i]);
                 }
                 l += (b - p_* x);
                 return l / y_mul_;;
             }