BaroneAdesiWhaleyApproximationEngine Class Reference

#include <qle/pricingengines/baroneadesiwhaleyengine.hpp>

Inheritance diagram for BaroneAdesiWhaleyApproximationEngine:

Collaboration diagram for BaroneAdesiWhaleyApproximationEngine:

Public Member Functions
	BaroneAdesiWhaleyApproximationEngine (const QuantLib::ext::shared_ptr< QuantLib::GeneralizedBlackScholesProcess > &)
void	calculate () const override

Static Public Member Functions
static QuantLib::Real	criticalPrice (const QuantLib::ext::shared_ptr< QuantLib::StrikedTypePayoff > &payoff, QuantLib::DiscountFactor riskFreeDiscount, QuantLib::DiscountFactor dividendDiscount, QuantLib::Real variance, QuantLib::Real tolerance=1e-6)

Private Attributes
QuantLib::ext::shared_ptr< QuantLib::GeneralizedBlackScholesProcess >	process_

Detailed Description

Barone-Adesi and Whaley pricing engine for American options (1987) This QuantExt class is a copy of the class with the same name in QuantLib v1.14 with the following change

• Added handling for put option where early exercise is never optimal

  Tests:

  the correctness of the returned value is tested by reproducing results available in literature.

Definition at line 58 of file baroneadesiwhaleyengine.hpp.

Constructor & Destructor Documentation

BaroneAdesiWhaleyApproximationEngine()

BaroneAdesiWhaleyApproximationEngine

(

const QuantLib::ext::shared_ptr< QuantLib::GeneralizedBlackScholesProcess > &

)

Definition at line 47 of file baroneadesiwhaleyengine.cpp.

    : process_(process) {
    registerWith(process_);
}

Member Function Documentation

criticalPrice()

Real criticalPrice ( const QuantLib::ext::shared_ptr< QuantLib::StrikedTypePayoff > &  payoff, QuantLib::DiscountFactor  riskFreeDiscount, QuantLib::DiscountFactor  dividendDiscount, QuantLib::Real  variance, QuantLib::Real  tolerance = 1e-6  )

static

Definition at line 54 of file baroneadesiwhaleyengine.cpp.

                                                                         {
 
    // Calculation of seed value, Si
    Real n = 2.0 * std::log(dividendDiscount / riskFreeDiscount) / (variance);
    Real m = -2.0 * std::log(riskFreeDiscount) / (variance);
    Real bT = std::log(dividendDiscount / riskFreeDiscount);
 
    Real qu, Su, h, Si;
    switch (payoff->optionType()) {
    case Option::Call:
        qu = (-(n - 1.0) + std::sqrt(((n - 1.0) * (n - 1.0)) + 4.0 * m)) / 2.0;
        Su = payoff->strike() / (1.0 - 1.0 / qu);
        h = -(bT + 2.0 * std::sqrt(variance)) * payoff->strike() / (Su - payoff->strike());
        Si = payoff->strike() + (Su - payoff->strike()) * (1.0 - std::exp(h));
        break;
    case Option::Put:
        qu = (-(n - 1.0) - std::sqrt(((n - 1.0) * (n - 1.0)) + 4.0 * m)) / 2.0;
        Su = payoff->strike() / (1.0 - 1.0 / qu);
        h = (bT - 2.0 * std::sqrt(variance)) * payoff->strike() / (payoff->strike() - Su);
        Si = Su + (payoff->strike() - Su) * std::exp(h);
        break;
    default:
        QL_FAIL("unknown option type");
    }
 
    Real maxIterations = 100;
    // Newton Raphson algorithm for finding critical price Si
    Real Q, LHS, RHS, bi;
    Real forwardSi = Si * dividendDiscount / riskFreeDiscount;
    Real d1 = (std::log(forwardSi / payoff->strike()) + 0.5 * variance) / std::sqrt(variance);
    CumulativeNormalDistribution cumNormalDist;
    Real K = (!close(riskFreeDiscount, 1.0, 1000))
                 ? -2.0 * std::log(riskFreeDiscount) / (variance * (1.0 - riskFreeDiscount))
                 : 2.0 / variance;
    Real temp = blackFormula(payoff->optionType(), payoff->strike(), forwardSi, std::sqrt(variance)) * riskFreeDiscount;
    Real i;
    switch (payoff->optionType()) {
    case Option::Call:
        Q = (-(n - 1.0) + std::sqrt(((n - 1.0) * (n - 1.0)) + 4 * K)) / 2;
        LHS = Si - payoff->strike();
        RHS = temp + (1 - dividendDiscount * cumNormalDist(d1)) * Si / Q;
        bi = dividendDiscount * cumNormalDist(d1) * (1 - 1 / Q) +
             (1 - dividendDiscount * cumNormalDist.derivative(d1) / std::sqrt(variance)) / Q;
        i = 0;
        while ((std::fabs(LHS - RHS) / payoff->strike()) > tolerance) {
            if (i > maxIterations)
                QL_FAIL("Failed to find critical price after " << maxIterations << "iterations.");
            Si = (payoff->strike() + RHS - bi * Si) / (1 - bi);
            forwardSi = Si * dividendDiscount / riskFreeDiscount;
            d1 = (std::log(forwardSi / payoff->strike()) + 0.5 * variance) / std::sqrt(variance);
            LHS = Si - payoff->strike();
            Real temp2 =
                blackFormula(payoff->optionType(), payoff->strike(), forwardSi, std::sqrt(variance)) * riskFreeDiscount;
            RHS = temp2 + (1 - dividendDiscount * cumNormalDist(d1)) * Si / Q;
            bi = dividendDiscount * cumNormalDist(d1) * (1 - 1 / Q) +
                 (1 - dividendDiscount * cumNormalDist.derivative(d1) / std::sqrt(variance)) / Q;
            i++;
        }
        break;
    case Option::Put:
        Q = (-(n - 1.0) - std::sqrt(((n - 1.0) * (n - 1.0)) + 4 * K)) / 2;
        LHS = payoff->strike() - Si;
        RHS = temp - (1 - dividendDiscount * cumNormalDist(-d1)) * Si / Q;
        bi = -dividendDiscount * cumNormalDist(-d1) * (1 - 1 / Q) -
             (1 + dividendDiscount * cumNormalDist.derivative(-d1) / std::sqrt(variance)) / Q;
        i = 0;
        while ((std::fabs(LHS - RHS) / payoff->strike()) > tolerance) {
            if (i > maxIterations)
                QL_FAIL("Failed to find critical price after " << maxIterations << "iterations.");
            Si = (payoff->strike() - RHS + bi * Si) / (1 + bi);
            forwardSi = Si * dividendDiscount / riskFreeDiscount;
            d1 = (std::log(forwardSi / payoff->strike()) + 0.5 * variance) / std::sqrt(variance);
            LHS = payoff->strike() - Si;
            Real temp2 =
                blackFormula(payoff->optionType(), payoff->strike(), forwardSi, std::sqrt(variance)) * riskFreeDiscount;
            RHS = temp2 - (1 - dividendDiscount * cumNormalDist(-d1)) * Si / Q;
            bi = -dividendDiscount * cumNormalDist(-d1) * (1 - 1 / Q) -
                 (1 + dividendDiscount * cumNormalDist.derivative(-d1) / std::sqrt(variance)) / Q;
            i++;
        }
        break;
    default:
        QL_FAIL("unknown option type");
    }
 
    return Si;
}

Here is the call graph for this function:

Here is the caller graph for this function:

calculate()

void calculate ( ) const

override

Definition at line 145 of file baroneadesiwhaleyengine.cpp.

                                                           {
 
    QL_REQUIRE(arguments_.exercise->type() == Exercise::American, "not an American Option");
 
    ext::shared_ptr<AmericanExercise> ex = ext::dynamic_pointer_cast<AmericanExercise>(arguments_.exercise);
    QL_REQUIRE(ex, "non-American exercise given");
    QL_REQUIRE(!ex->payoffAtExpiry(), "payoff at expiry not handled");
 
    ext::shared_ptr<StrikedTypePayoff> payoff = ext::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff);
    QL_REQUIRE(payoff, "non-striked payoff given");
 
    Real variance = process_->blackVolatility()->blackVariance(ex->lastDate(), payoff->strike());
    DiscountFactor dividendDiscount = process_->dividendYield()->discount(ex->lastDate());
    DiscountFactor riskFreeDiscount = process_->riskFreeRate()->discount(ex->lastDate());
    Real spot = process_->stateVariable()->value();
    QL_REQUIRE(spot > 0.0, "negative or null underlying given");
    Real forwardPrice = spot * dividendDiscount / riskFreeDiscount;
    BlackCalculator black(payoff, forwardPrice, std::sqrt(variance), riskFreeDiscount);
    bool useEuropeanPrice = (payoff->optionType() == Option::Call &&
                             ((dividendDiscount >= 1.0 && riskFreeDiscount < 1.0) ||
                              (riskFreeDiscount >= 1.0 && (dividendDiscount / riskFreeDiscount) >= 1.0))) ||
                            (dividendDiscount < 1.0 && riskFreeDiscount >= 1.0 && payoff->optionType() == Option::Put);
 
    Real tolerance = 1e-6;
    Real Sk = 0.0;
    // try to determine the critical price for the american option
    // in some case, for example r < 0, q < 0 it is never optimal to exercise early
    // and we cannot solve for critical price, the newton raphson solver diverges
    // with Si turning negative
    try {
        Sk = criticalPrice(payoff, riskFreeDiscount, dividendDiscount, variance, tolerance);
    } catch (...) {
        // failed to calculate the critical price
        useEuropeanPrice = true;
    }
 
    if (useEuropeanPrice) {
        // early exercise never optimal
        results_.value = black.value();
        results_.delta = black.delta(spot);
        results_.deltaForward = black.deltaForward();
        results_.elasticity = black.elasticity(spot);
        results_.gamma = black.gamma(spot);
 
        DayCounter rfdc = process_->riskFreeRate()->dayCounter();
        DayCounter divdc = process_->dividendYield()->dayCounter();
        DayCounter voldc = process_->blackVolatility()->dayCounter();
        Time t = rfdc.yearFraction(process_->riskFreeRate()->referenceDate(), arguments_.exercise->lastDate());
        results_.rho = black.rho(t);
 
        t = divdc.yearFraction(process_->dividendYield()->referenceDate(), arguments_.exercise->lastDate());
        results_.dividendRho = black.dividendRho(t);
 
        t = voldc.yearFraction(process_->blackVolatility()->referenceDate(), arguments_.exercise->lastDate());
        results_.vega = black.vega(t);
        results_.theta = black.theta(spot, t);
        results_.thetaPerDay = black.thetaPerDay(spot, t);
 
        results_.strikeSensitivity = black.strikeSensitivity();
        results_.itmCashProbability = black.itmCashProbability();
    } else {
        // early exercise can be optimal
        CumulativeNormalDistribution cumNormalDist;
        Real forwardSk = Sk * dividendDiscount / riskFreeDiscount;
        Real d1 = (std::log(forwardSk / payoff->strike()) + 0.5 * variance) / std::sqrt(variance);
        Real n = 2.0 * std::log(dividendDiscount / riskFreeDiscount) / variance;
        Real K = (!close(riskFreeDiscount, 1.0, 1000))
                     ? -2.0 * std::log(riskFreeDiscount) / (variance * (1.0 - riskFreeDiscount))
                     : 2.0 / variance;
        Real Q, a;
        switch (payoff->optionType()) {
        case Option::Call:
            Q = (-(n - 1.0) + std::sqrt(((n - 1.0) * (n - 1.0)) + 4.0 * K)) / 2.0;
            a = (Sk / Q) * (1.0 - dividendDiscount * cumNormalDist(d1));
            if (spot < Sk) {
                results_.value = black.value() + a * std::pow((spot / Sk), Q);
            } else {
                results_.value = spot - payoff->strike();
            }
            break;
        case Option::Put:
            Q = (-(n - 1.0) - std::sqrt(((n - 1.0) * (n - 1.0)) + 4.0 * K)) / 2.0;
            a = -(Sk / Q) * (1.0 - dividendDiscount * cumNormalDist(-d1));
            if (spot > Sk) {
                results_.value = black.value() + a * std::pow((spot / Sk), Q);
            } else {
                results_.value = payoff->strike() - spot;
            }
            break;
        default:
            QL_FAIL("unknown option type");
        }
    } // end of "early exercise can be optimal"
}

Here is the call graph for this function:

Member Data Documentation

process_

QuantLib::ext::shared_ptr<QuantLib::GeneralizedBlackScholesProcess> process_

private

Definition at line 68 of file baroneadesiwhaleyengine.hpp.