#include <ored/scripting/engines/cliquetoptionmcscriptengine.hpp>

Inheritance diagram for CliquetOptionMcScriptEngine:

Collaboration diagram for CliquetOptionMcScriptEngine:

Public Member Functions
	CliquetOptionMcScriptEngine (const std::string &underlying, const std::string &baseCcy, const std::string &underlyingCcy, const QuantLib::ext::shared_ptr< GeneralizedBlackScholesProcess > &p, const std::set< std::string > &tradeTypes, const Size samples, const Size regressionOrder, bool interactive, bool scriptedLibraryOverride)

void	calculate () const override

Private Attributes
const std::string	underlying_

const std::string	baseCcy_

const std::string	underlyingCcy_

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

const Size	samples_

const Size	regressionOrder_

bool	interactive_

ASTNodePtr	ast_

Detailed Description

Definition at line 31 of file cliquetoptionmcscriptengine.hpp.

Constructor & Destructor Documentation

◆ CliquetOptionMcScriptEngine()

CliquetOptionMcScriptEngine	(	const std::string &	underlying,
		const std::string &	baseCcy,
		const std::string &	underlyingCcy,
		const QuantLib::ext::shared_ptr< GeneralizedBlackScholesProcess > &	p,
		const std::set< std::string > &	tradeTypes,
		const Size	samples,
		const Size	regressionOrder,
		bool	interactive,
		bool	scriptedLibraryOverride
	)

Definition at line 33 of file cliquetoptionmcscriptengine.cpp.

    : underlying_(underlying), baseCcy_(baseCcy), underlyingCcy_(underlyingCcy), p_(p), samples_(samples),
      regressionOrder_(regressionOrder), interactive_(interactive) {
 
    string scriptStr;
 
    if (scriptedLibraryOverride) {
        QL_REQUIRE(tradeTypes.size() == 1, "");
        string scriptName = *tradeTypes.begin();
 
        QL_REQUIRE(ScriptLibraryStorage::instance().get().has(scriptName, ""),
                   "script '" << scriptName << "' not found in library");
        ScriptedTradeScriptData script = ScriptLibraryStorage::instance().get().get(scriptName, "").second;
        scriptStr = script.code();
    } else {
        scriptStr = "NUMBER Payoff, d, premiumPayment;\n"
                    "Payoff = 0;\n"
                    "premiumPayment = 0;\n"
                    "IF PremiumPaymentDate >= TODAY THEN"
                    "    premiumPayment = PAY(LongShort * Notional * Premium, PremiumPaymentDate, PremiumPaymentDate, "
                    "PremiumCurrency);"
                    "END;\n"
                    "FOR d IN (2, SIZE(ValuationDates), 1) DO"
                    "   Payoff = Payoff + min( max( Type * ( (Underlying(ValuationDates[d]) / "
                    "Underlying(ValuationDates[d-1])) - Moneyness ), LocalFloor ), LocalCap );"
                    "END;\n"
                    "Option = premiumPayment + PAY( LongShort * Notional * min( max( Payoff, GlobalFloor ), GlobalCap "
                    "), Expiry, PayDate, PayCcy );\n";
    }
 
    ScriptParser parser(scriptStr);
    QL_REQUIRE(parser.success(), "could not initialise AST for McScriptEuropeanEngine: " << parser.error());
    ast_ = parser.ast();
    registerWith(p_);
}

Here is the call graph for this function:

Member Function Documentation

◆ calculate()

void calculate ( ) const

override

Definition at line 74 of file cliquetoptionmcscriptengine.cpp.

                                                  {
 
    // some checks (copied from QuantLib::AnalyticEuropeanEngine)
 
    QL_REQUIRE(arguments_.exercise->type() == Exercise::European, "not an European option");
    QuantLib::ext::shared_ptr<StrikedTypePayoff> payoff = QuantLib::ext::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff);
    QL_REQUIRE(payoff, "non-striked payoff given");
 
    // set up the script engine model
 
    // cas use time steps = 0 for black scholes
    auto builder = QuantLib::ext::make_shared<BlackScholesModelBuilder>(p_->riskFreeRate(), p_, arguments_.valuationDates,
                                                                std::set<Date>(), 0);
    // the black scholes model wrapper won't notify the model of changes in curves and vols, so we register manually
    builder->model()->registerWith(p_);
    Model::McParams mcParams;
    mcParams.regressionOrder = regressionOrder_;
    auto model = QuantLib::ext::make_shared<BlackScholes>(samples_, baseCcy_, p_->riskFreeRate(), underlying_, underlyingCcy_,
                                                  builder->model(), mcParams, arguments_.valuationDates);
 
    // populate context
 
    auto context = QuantLib::ext::make_shared<Context>();
    context->scalars["TODAY"] = EventVec{samples_, Settings::instance().evaluationDate()};
    context->scalars["Underlying"] = IndexVec{samples_, underlying_};
    std::vector<ValueType> tmp;
    for (auto const& d : arguments_.valuationDates)
        tmp.push_back(EventVec{samples_, d});
    context->arrays["ValuationDates"] = tmp;
    context->scalars["Expiry"] = EventVec{samples_, arguments_.exercise->lastDate()};
    context->scalars["PayCcy"] = CurrencyVec{samples_, baseCcy_};
    context->scalars["PayDate"] = EventVec{samples_, arguments_.paymentDate};
    context->scalars["Moneyness"] = RandomVariable{samples_, arguments_.moneyness};
    context->scalars["Type"] = RandomVariable{samples_, arguments_.type == Option::Type::Call ? 1.0 : -1.0};
    context->scalars["LongShort"] =
        RandomVariable{samples_, arguments_.longShort == QuantLib::Position::Type::Long ? 1.0 : -1.0};
    context->scalars["LocalCap"] =
        RandomVariable{samples_, arguments_.localCap == Null<Real>() ? QL_MAX_REAL : arguments_.localCap};
    context->scalars["LocalFloor"] =
        RandomVariable{samples_, arguments_.localFloor == Null<Real>() ? -QL_MAX_REAL : arguments_.localFloor};
    context->scalars["GlobalCap"] =
        RandomVariable{samples_, arguments_.globalCap == Null<Real>() ? QL_MAX_REAL : arguments_.globalCap};
    context->scalars["GlobalFloor"] =
        RandomVariable{samples_, arguments_.globalFloor == Null<Real>() ? -QL_MAX_REAL : arguments_.globalFloor};
    context->scalars["Notional"] = RandomVariable{samples_, arguments_.notional};
    context->scalars["Premium"] =
        RandomVariable{samples_, arguments_.premium == Null<Real>() ? 0.0 : arguments_.premium};
    context->scalars["PremiumPaymentDate"] = EventVec{samples_, arguments_.premiumPayDate};
    context->scalars["PremiumCurrency"] = CurrencyVec{samples_, arguments_.premiumCurrency};
    context->scalars["Option"] = RandomVariable(samples_, 0.0); // result
 
    // run the script engine and set the result
 
    ScriptEngine engine(ast_, context, model);
    engine.run("", interactive_);
    results_.value = expectation(QuantLib::ext::get<RandomVariable>(context->scalars.at("Option"))).at(0);
}