Pricing engine for cash settled European vanilla options using analytical formulae. More...

#include <qle/pricingengines/analyticcashsettledeuropeanengine.hpp>

Inheritance diagram for AnalyticCashSettledEuropeanEngine:

Collaboration diagram for AnalyticCashSettledEuropeanEngine:

Public Member Functions
	AnalyticCashSettledEuropeanEngine (const QuantLib::ext::shared_ptr< QuantLib::GeneralizedBlackScholesProcess > &bsp)

	AnalyticCashSettledEuropeanEngine (const QuantLib::ext::shared_ptr< QuantLib::GeneralizedBlackScholesProcess > &bsp, const QuantLib::Handle< QuantLib::YieldTermStructure > &discountCurve)

PricingEngine interface
QuantExt::AnalyticEuropeanForwardEngine	underlyingEngine_
	Underlying engine that does the work. More...

QuantLib::ext::shared_ptr< QuantLib::GeneralizedBlackScholesProcess >	bsp_
	Underlying process. More...

QuantLib::Handle< QuantLib::YieldTermStructure >	discountCurve_
	Curve for discounting cashflows. More...

void	calculate () const override

Detailed Description

Pricing engine for cash settled European vanilla options using analytical formulae.

Definition at line 36 of file analyticcashsettledeuropeanengine.hpp.

Constructor & Destructor Documentation

◆ AnalyticCashSettledEuropeanEngine() [1/2]

AnalyticCashSettledEuropeanEngine ( const QuantLib::ext::shared_ptr< QuantLib::GeneralizedBlackScholesProcess > & bsp )

The risk-free rate in the given process bsp is used for both forecasting and discounting.

◆ AnalyticCashSettledEuropeanEngine() [2/2]

AnalyticCashSettledEuropeanEngine	(	const QuantLib::ext::shared_ptr< QuantLib::GeneralizedBlackScholesProcess > &	bsp,
		const QuantLib::Handle< QuantLib::YieldTermStructure > &	discountCurve
	)

As usual, the risk-free rate from the given process bsp is used for forecasting the forward price. The discountCurve is used for discounting.

Member Function Documentation

◆ calculate()

void calculate ( ) const

override

Definition at line 54 of file analyticcashsettledeuropeanengine.cpp.

                                                        {
 
    // Same logic as underlying engine for discount curve.
    QuantLib::ext::shared_ptr<YieldTermStructure> dts =
        discountCurve_.empty() ? bsp_->riskFreeRate().currentLink() : discountCurve_.currentLink();
 
    // Option expiry date.
    Date expiryDate = arguments_.exercise->lastDate();
 
    Date today = Settings::instance().evaluationDate();
    if (expiryDate <= today) {
        // If expiry has occurred, we attempt to establish the payoff amount, if any, and discount it.
        Real payoffAmount = 0.0;
        Real priceAtExercise = 0.0;
        bool deterministicPayoff = true;
        if (arguments_.automaticExercise) {
            // If we have automatic exercise, we base the payoff on the value of the index on the expiry date.
            QL_REQUIRE(arguments_.underlying, "Expect a valid underlying index when exercise is automatic.");
            priceAtExercise = arguments_.underlying->fixing(expiryDate);
            payoffAmount = (*arguments_.payoff)(priceAtExercise);
        } else if (arguments_.exercised) {
            // If we have manually exercised, we base the payoff on the value at exercise.
            QL_REQUIRE(arguments_.priceAtExercise != Null<Real>(), "Expect a valid price at exercise when option "
                                                                       << "has been manually exercised.");
            priceAtExercise = arguments_.priceAtExercise;
            payoffAmount = (*arguments_.payoff)(priceAtExercise);
        } else if (expiryDate == today) {
            // Expiry date is today, not automatic exercise and hasn't been manually exercised - use spot.
            priceAtExercise = bsp_->x0();
            payoffAmount = (*arguments_.payoff)(priceAtExercise);
            deterministicPayoff = false;
        }
 
        if(deterministicPayoff) {
            results_.delta = 0.0;
            results_.deltaForward = 0.0;
            results_.elasticity = 0.0;
            results_.gamma = 0.0;
            results_.dividendRho = 0.0;
            results_.vega = 0.0;
        }
 
        // Discount factor to payment date.
        DiscountFactor df_tp = dts->discount(arguments_.paymentDate);
        Time delta_tp = dts->timeFromReference(arguments_.paymentDate);
 
        // Only value, rho and theta are meaningful now.
        results_.value = df_tp * payoffAmount;
        results_.rho = -delta_tp * results_.value;
        results_.theta = 0.0;
        if (delta_tp > 0.0 && !close(delta_tp, 0.0)) {
            results_.theta = -std::log(df_tp) / delta_tp * results_.value;
        }
        results_.thetaPerDay = results_.theta / 365.0;
 
        // Populate some additional results.
        results_.additionalResults["spot"] = bsp_->x0();
        auto payoff = QuantLib::ext::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff);
        if (payoff)
            results_.additionalResults["strike"] = payoff->strike();
        results_.additionalResults["priceAtExercise"] = priceAtExercise;
        results_.additionalResults["payoffAmount"] = payoffAmount;
        results_.additionalResults["discountFactor"] = df_tp;
        results_.additionalResults["timeToExpiry"] = delta_tp;
 
    } else {
 
        // If expiry has not occurred, we use the underlying engine and amend the results to account
        // for the deferred cash payment.
 
        // Prepare the underlying engine for the valuation.
        underlyingEngine_.reset();
        VanillaForwardOption::arguments* underlyingArgs =
            dynamic_cast<VanillaForwardOption::arguments*>(underlyingEngine_.getArguments());
        QL_REQUIRE(underlyingArgs, "Underlying engine expected to have vanilla option arguments.");
        underlyingArgs->exercise = arguments_.exercise;
        underlyingArgs->payoff = arguments_.payoff;
 
        // If we have a commodity future index, set the forward date to its expiry to get the right future price 
        // in the Black formula. If not, just use the expiry date => same result as standard QL engine.
        if (auto cfi = QuantLib::ext::dynamic_pointer_cast<CommodityFuturesIndex>(arguments_.underlying)) {
            underlyingArgs->forwardDate = cfi->expiryDate();
        } else {
            underlyingArgs->forwardDate = expiryDate;
        }
        underlyingEngine_.calculate();
 
        // Discount factor from payment date back to expiry date i.e. P(t_e, t_p) when rates are deterministic.
        DiscountFactor df_te_tp = dts->discount(arguments_.paymentDate) / dts->discount(expiryDate);
        Time delta_te_tp = dts->timeFromReference(arguments_.paymentDate) - dts->timeFromReference(expiryDate);
 
        // Populate this engine's results using the results from the underlying engine.
        const CashSettledEuropeanOption::results* underlyingResults =
            dynamic_cast<const CashSettledEuropeanOption::results*>(underlyingEngine_.getResults());
        QL_REQUIRE(underlyingResults, "Underlying engine expected to have compatible results.");
 
        results_.value = df_te_tp * underlyingResults->value;
        results_.delta = df_te_tp * underlyingResults->delta;
        results_.deltaForward = df_te_tp * underlyingResults->deltaForward;
        results_.elasticity = underlyingResults->elasticity;
        results_.gamma = df_te_tp * underlyingResults->gamma;
        results_.rho = df_te_tp * (underlyingResults->rho - delta_te_tp * underlyingResults->value);
        results_.dividendRho = df_te_tp * underlyingResults->dividendRho;
        results_.vega = df_te_tp * underlyingResults->vega;
        if (underlyingResults->theta != Null<Real>())
            results_.theta = df_te_tp * underlyingResults->theta;
        if (underlyingResults->thetaPerDay != Null<Real>())
            results_.thetaPerDay = df_te_tp * underlyingResults->thetaPerDay;
        results_.strikeSensitivity = df_te_tp * underlyingResults->strikeSensitivity;
        results_.itmCashProbability = underlyingResults->itmCashProbability;
 
        // Take the additional results from the underlying engine and add more.
        results_.additionalResults = underlyingResults->additionalResults;
        results_.additionalResults["discountFactorTeTp"] = df_te_tp;
    }
 
}

Member Data Documentation

◆ underlyingEngine_

QuantExt::AnalyticEuropeanForwardEngine underlyingEngine_

mutableprivate

Underlying engine that does the work.

Definition at line 55 of file analyticcashsettledeuropeanengine.hpp.

◆ bsp_

QuantLib::ext::shared_ptr<QuantLib::GeneralizedBlackScholesProcess> bsp_

private

Underlying process.

Definition at line 57 of file analyticcashsettledeuropeanengine.hpp.

◆ discountCurve_

QuantLib::Handle<QuantLib::YieldTermStructure> discountCurve_