AnalyticOutperformanceOptionEngine Class Reference

Pricing engine for European outperformance options using analytical formulae. More...

#include <qle/pricingengines/analyticoutperformanceoptionengine.hpp>

Inheritance diagram for AnalyticOutperformanceOptionEngine:

Collaboration diagram for AnalyticOutperformanceOptionEngine:

Public Member Functions
	AnalyticOutperformanceOptionEngine (const ext::shared_ptr< GeneralizedBlackScholesProcess > &process1, const ext::shared_ptr< GeneralizedBlackScholesProcess > &process2, const Handle< CorrelationTermStructure > &correlation, QuantLib::Size integrationPoints)
void	calculate () const override

Private Member Functions
Real	correlation (Time t, Real strike=1) const
Real	rho (Time t) const
Real	integrand (const Real x, Real phi, Real k, Real m1, Real m2, Real v1, Real v2, Real s1, Real s2, Real i1, Real i2, Real fixingTime) const
Real	getTodaysFxConversionRate (const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &fxIndex) const

Private Attributes
ext::shared_ptr< GeneralizedBlackScholesProcess >	process1_
ext::shared_ptr< GeneralizedBlackScholesProcess >	process2_
Handle< CorrelationTermStructure >	correlationCurve_
QuantLib::Size	integrationPoints_

Friends
class	integrand_f

Detailed Description

Pricing engine for European outperformance options using analytical formulae.

Definition at line 35 of file analyticoutperformanceoptionengine.hpp.

Constructor & Destructor Documentation

AnalyticOutperformanceOptionEngine()

AnalyticOutperformanceOptionEngine	(	const ext::shared_ptr< GeneralizedBlackScholesProcess > &	process1,
		const ext::shared_ptr< GeneralizedBlackScholesProcess > &	process2,
		const Handle< CorrelationTermStructure > &	correlation,
		QuantLib::Size	integrationPoints
	)

Definition at line 47 of file analyticoutperformanceoptionengine.cpp.

    : process1_(process1), process2_(process2), correlationCurve_(correlation), integrationPoints_(integrationPoints) {
    registerWith(process1_);
    registerWith(process2_);
}

Member Function Documentation

calculate()

void calculate ( ) const

override

Definition at line 114 of file analyticoutperformanceoptionengine.cpp.

                                                         {
 
    QL_REQUIRE(arguments_.exercise->type() == Exercise::European, "not an European option");
        
    Option::Type optionType = arguments_.optionType;
    Real phi = optionType == Option::Call ? 1.0 : -1.0;
 
    Real strike = arguments_.strikeReturn;
    QL_REQUIRE(strike >= 0, "non-negative strike expected");
    
    Time fixingTime = process1_->time(arguments_.exercise->lastDate());
 
    Real fx1 = arguments_.fxIndex1 ? getTodaysFxConversionRate(arguments_.fxIndex1) : 1.0;
    Real fx2 = arguments_.fxIndex2 ? getTodaysFxConversionRate(arguments_.fxIndex2) : 1.0;
 
    Real s1 = process1_->stateVariable()->value(); 
    Real s2 = process2_->stateVariable()->value();
    Real i1 = arguments_.initialValue1 * fx1;
    Real i2 = arguments_.initialValue2 * fx2;
 
    Real v1 = process1_->blackVolatility()->blackVol(
                                            arguments_.exercise->lastDate(), s1);
    Real v2 = process2_->blackVolatility()->blackVol(
                                            arguments_.exercise->lastDate(), s2);
 
    Real riskFreeRate1 = process1_->riskFreeRate()->zeroRate(
                arguments_.exercise->lastDate(),
                process1_->riskFreeRate()->dayCounter(),
                Continuous, NoFrequency);
    Real riskFreeRate2 = process2_->riskFreeRate()->zeroRate(
                arguments_.exercise->lastDate(),
                process2_->riskFreeRate()->dayCounter(),
                Continuous, NoFrequency);
    Real dividendYield1 = process1_->dividendYield()->zeroRate(
                arguments_.exercise->lastDate(),
                process1_->dividendYield()->dayCounter(),
                Continuous, NoFrequency);
    Real dividendYield2 = process2_->dividendYield()->zeroRate(
                arguments_.exercise->lastDate(),
                process2_->dividendYield()->dayCounter(),
                Continuous, NoFrequency);
 
    Real m1 = riskFreeRate1 - dividendYield1;
    Real m2 = riskFreeRate2 - dividendYield2;
 
    Real k = strike;
 
    Real res = 0.0;
    
    bool hasBarrier = (arguments_.knockInPrice != Null<Real>()) || (arguments_.knockOutPrice != Null<Real>());
    Real integral = 0;
    if (hasBarrier) {
        Real my = (m2 - 0.5 * v2 * v2) * fixingTime; 
        Real vy = v2 * std::sqrt(fixingTime);
        
        Real precision = 1.0e-6;
        
        Real upperBound = Null<Real>();
        Real lowerBound = Null<Real>();
        if (arguments_.knockOutPrice != Null<Real>()) {
            Real koPrice = fx2 * arguments_.knockOutPrice;
            // for the integration variable y : upperBound = log( knockOutPrice / initialPrice2)
            // in Brigo the variable change v = (y - my) / vy is made
            // we make a further variable change  x = v / sqrt(2)
            upperBound = (std::log(koPrice / s2) - my) / ( vy * M_SQRT2);
 
            if (arguments_.knockInPrice == Null<Real>()) {
                // we estimate the infinite boundary
                lowerBound = -2 * std::fabs(upperBound);
                while(integrand(lowerBound, phi, k, m1, m2, v1, v2, s1, s2, i1, i2, fixingTime) > precision)
                    lowerBound *=2.0;
            }
        }
        
        if (arguments_.knockInPrice != Null<Real>()) {
            Real kiPrice = fx2 * arguments_.knockInPrice;
            // for the integration variable y : lowerBound = log( knockInPrice / initialPrice2)
            // in Brigo the variable change v = (y - my) / vy is made
            // we make a further variable change  x = v / sqrt(2)
            lowerBound = (std::log(kiPrice / s2) - my) / ( vy * M_SQRT2);
 
            if (arguments_.knockOutPrice == Null<Real>()) {
                // we estimate the infinite boundary
                upperBound = 2 * std::fabs(lowerBound);
                while(integrand(upperBound, phi, k, m1, m2, v1, v2, s1, s2, i1, i2, fixingTime) > precision)
                    upperBound *=2.0;
            }
        }
 
        QuantLib::ext::shared_ptr<Integrator> integratorBounded = QuantLib::ext::make_shared<GaussKronrodNonAdaptive>(precision, 1000000, 1.0);
        
        QL_REQUIRE(upperBound != Null<Real>(), "AnalyticOutperformanceOptionEngine: expected valid upper bound.");
        QL_REQUIRE(lowerBound != Null<Real>(), "AnalyticOutperformanceOptionEngine: expected valid lower bound.");
        QL_REQUIRE(upperBound > lowerBound, "incorrect knock in levels provided");
        integral +=  (*integratorBounded)(integrand_f(this, phi, k, m1, m2, v1, v2, s1, s2, i1, i2, fixingTime), lowerBound, upperBound);
 
    } else {
        QuantLib::ext::shared_ptr<GaussianQuadrature> integrator = QuantLib::ext::make_shared<GaussHermiteIntegration>(integrationPoints_);
        integral +=
            (*integrator)(integrand_f(this, phi, k, m1, m2, v1, v2, s1, s2, i1, i2, fixingTime));
    }
 
    res += (integral / M_SQRTPI);
    DiscountFactor riskFreeDiscount =
        process1_->riskFreeRate()->discount(arguments_.exercise->lastDate());
 
    results_.value = res * riskFreeDiscount * arguments_.notional;
 
    Real variance1 = process1_->blackVolatility()->blackVariance(
                                            arguments_.exercise->lastDate(), s1);
    Real variance2 = process2_->blackVolatility()->blackVariance(
                                            arguments_.exercise->lastDate(), s2);
    Real variance = variance1 + variance2 - 2 * rho(fixingTime) * std::sqrt(variance1)*std::sqrt(variance2);
    Real stdDev = std::sqrt(variance);
    results_.standardDeviation = stdDev;
 
    results_.additionalResults["spot1"] = s1;
    results_.additionalResults["spot2"] = s2;
    results_.additionalResults["fx1"] = fx1;
    results_.additionalResults["fx2"] = fx2;
    results_.additionalResults["blackVol1"] = v1;
    results_.additionalResults["blackVol2"] = v2;
    results_.additionalResults["correlation"] = rho(fixingTime);
    results_.additionalResults["strike"] = strike;
    results_.additionalResults["residualTime"] = fixingTime;
    results_.additionalResults["riskFreeRate1"] = riskFreeRate1;
    results_.additionalResults["riskFreeRate2"] = riskFreeRate2;
    results_.additionalResults["dividendYield1"] = dividendYield1;
    results_.additionalResults["dividendYield2"] = dividendYield2;
    
} // calculate

Here is the call graph for this function:

correlation()

Real correlation ( Time  t, Real  strike = 1  ) const

private

Definition at line 43 of file analyticoutperformanceoptionengine.hpp.

{ return correlationCurve_->correlation(t, strike); }

Here is the caller graph for this function:

rho()

Real rho ( Time  t ) const

private

Definition at line 44 of file analyticoutperformanceoptionengine.hpp.

{ return std::max(std::min(correlation(t), 0.9999), -0.9999); }

Here is the call graph for this function:

Here is the caller graph for this function:

integrand()

Real integrand ( const Real  x, Real  phi, Real  k, Real  m1, Real  m2, Real  v1, Real  v2, Real  s1, Real  s2, Real  i1, Real  i2, Real  fixingTime  ) const

private

Definition at line 80 of file analyticoutperformanceoptionengine.cpp.

                                                                                                                                                                                {
 
    // this is Brigo, 13.16.2 with x = v / sqrt(2)
    Real v = M_SQRT2 * x;
    
    //a positive real number 'a', a negative real number 'b'
    Real a = 1 / i1;
    Real b = -1 / i2;
 
    CumulativeNormalDistribution cnd;
    
    Real h =
        k - b * s2 * std::exp((m2 - 0.5 * v2 * v2) * fixingTime +
                                 v2 * std::sqrt(fixingTime) * v);
    Real phi1, phi2;
    phi1 = cnd(
        phi * (std::log(a * s1 / h) +
                (m1 + (0.5 - rho(fixingTime) * rho(fixingTime)) * v1 * v1) * fixingTime +
                rho(fixingTime) * v1 * std::sqrt(fixingTime) * v) /
        (v1 * std::sqrt(fixingTime * (1.0 - rho(fixingTime) * rho(fixingTime)))));
    phi2 = cnd(
        phi * (std::log(a * s1 / h) +
                (m1 - 0.5 * v1 * v1) * fixingTime +
                rho(fixingTime) * v1 * std::sqrt(fixingTime) * v) /
        (v1 * std::sqrt(fixingTime * (1.0 - rho(fixingTime) * rho(fixingTime)))));
    Real f = a * phi * s1 *
                 std::exp(m1 * fixingTime -
                          0.5 * rho(fixingTime) * rho(fixingTime) * v1 * v1 * fixingTime +
                          rho(fixingTime) * v1 * std::sqrt(fixingTime) * v) *
                 phi1 -
             phi * h * phi2;
    return std::exp(-x * x) * f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getTodaysFxConversionRate()

Real getTodaysFxConversionRate ( const QuantLib::ext::shared_ptr< QuantExt::FxIndex > &  fxIndex ) const

private

Definition at line 31 of file analyticoutperformanceoptionengine.cpp.

                                                                                                                              {
    // The fx conversion rate as of today should always be taken from the market data, i.e. we should not use a
    // historical fixing, even if it exists, because we should generate sensitivities to market fx spot rate changes.
    // Furthermore, we can get the fx spot rate from the market data even if today is not a valid fixing date for the
    // fx index, that is why we should not use Index::fixing(today, true).
    Real tmp;
    if (fxIndex->useQuote()) {
        tmp = fxIndex->fxQuote()->value();
    } else {
        tmp = ExchangeRateManager::instance()
                  .lookup(fxIndex->sourceCurrency(), fxIndex->targetCurrency())
                  .rate();
    }
    return tmp;
}

Here is the caller graph for this function:

Friends And Related Function Documentation

integrand_f

friend class integrand_f

friend

Definition at line 49 of file analyticoutperformanceoptionengine.hpp.

Member Data Documentation

process1_

ext::shared_ptr<GeneralizedBlackScholesProcess> process1_

private

Definition at line 51 of file analyticoutperformanceoptionengine.hpp.

process2_

ext::shared_ptr<GeneralizedBlackScholesProcess> process2_

private

Definition at line 52 of file analyticoutperformanceoptionengine.hpp.

correlationCurve_

Handle<CorrelationTermStructure> correlationCurve_

private

Definition at line 54 of file analyticoutperformanceoptionengine.hpp.

integrationPoints_

QuantLib::Size integrationPoints_

private

Definition at line 55 of file analyticoutperformanceoptionengine.hpp.