### QuantLib Swaption Pricing Setup and Execution

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/test_2mclgmswaptionengine_8cpp_source

This snippet demonstrates the setup and execution of swaption pricing using multiple QuantLib models and engines. It includes data preparation, model instantiation (Gsr, LGM), engine configuration, NPV calculation, and performance timing.

```C++
std::vector<Date> stepDates = std::vector<Date>(exerciseDates.begin(), exerciseDates.end() - 1);

Array stepTimes(stepDates.size());
for (Size i = 0; i < stepDates.size(); ++i) {
    stepTimes[i] = yts->timeFromReference(stepDates[i]);
}

std::vector<Real> sigmas(stepDates.size() + 1);
for (Size i = 0; i < sigmas.size(); ++i) {
    sigmas[i] = 0.0050 + (0.0080 - 0.0050) * std::exp(-0.2 * static_cast<double>(i));
}

Real reversion = 0.03;
QuantLib::ext::shared_ptr<Gsr> gsr = QuantLib::ext::make_shared<Gsr>(yts, stepDates, sigmas, reversion, 50.0);

QuantLib::ext::shared_ptr<IrLgm1fPiecewiseConstantHullWhiteAdaptor> lgmParam = QuantLib::ext::make_shared<IrLgm1fPiecewiseConstantHullWhiteAdaptor>(
    EURCurrency(), yts, stepTimes, Array(sigmas.begin(), sigmas.end()), stepTimes, Array(sigmas.size(), reversion));

QuantLib::ext::shared_ptr<LinearGaussMarkovModel> lgm = QuantLib::ext::make_shared<LinearGaussMarkovModel>(lgmParam);
QuantLib::ext::shared_ptr<Gaussian1dModel> lgmGaussian1d = QuantLib::ext::make_shared<Gaussian1dCrossAssetAdaptor>(lgm);

QuantLib::ext::shared_ptr<PricingEngine> swaptionEngineGsr =
    QuantLib::ext::make_shared<Gaussian1dSwaptionEngine>(gsr, 64, 7.0, true, false);

QuantLib::ext::shared_ptr<PricingEngine> swaptionEngineLgm =
    QuantLib::ext::make_shared<Gaussian1dSwaptionEngine>(lgmGaussian1d, 64, 7.0, true, false);

QuantLib::ext::shared_ptr<PricingEngine> swaptionEngineLgm2 =
    QuantLib::ext::make_shared<NumericLgmSwaptionEngine>(lgm, 7.0, 16, 7.0, 32);

Size polynomOrder = 4;
LsmBasisSystem::PolynomialType polynomType = LsmBasisSystem::Monomial;
Size tSamples = 10000;
Size pSamples = 10000;
QuantLib::ext::shared_ptr<StochasticProcess> stateProcess = lgm->stateProcess();

QuantLib::ext::shared_ptr<PricingEngine> swaptionEngineLgmMC = QuantLib::ext::shared_ptr<McLgmSwaptionEngine>(
    new McLgmSwaptionEngine(lgm, MersenneTwisterAntithetic, SobolBrownianBridge, tSamples, pSamples, 42, 43,
    polynomOrder, polynomType));

// Calculate the T0 price of the bermudan swaption using different engines
swaption->setPricingEngine(swaptionEngineGsr);
Real npvGsr = swaption->NPV();

swaption->setPricingEngine(swaptionEngineLgm);
Real npvLgm = swaption->NPV();

swaption->setPricingEngine(swaptionEngineLgm2);
Real npvLgm2 = swaption->NPV();

boost::timer::cpu_timer timer;
swaption->setPricingEngine(swaptionEngineLgmMC);
Real npvLgmMc = swaption->NPV();
Real undNpvMc = swaption->result<Real>("underlyingNpv");
BOOST_TEST_MESSAGE("Underlying value mc = " << undNpvMc);
BOOST_TEST_MESSAGE("npvGsr: " << npvGsr << ", npvLgm: " << npvLgm << ", npvLgm2: " << npvLgm
 << ", npvLgmMc: " << npvLgmMc);
timer.stop();
BOOST_TEST_MESSAGE("timing mc engine: " << timer.elapsed().wall * 1e-6 << " ms");

Real tol = 2E-4; // basis point tolerance
BOOST_CHECK_SMALL(std::fabs(undNpvMc - undlSwap->NPV()), tol);
BOOST_CHECK_SMALL(std::fabs(npvGsr - npvLgm), tol);
BOOST_CHECK_SMALL(std::fabs(npvGsr - npvLgm2), tol);
BOOST_CHECK_SMALL(std::fabs(npvGsr - npvLgmMc), tol);
```

--------------------------------

### Swaption Engine Test Setup

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/test_2blackswaptionenginedeltagamma_8cpp_source

This snippet demonstrates the setup for a Boost Test Suite case that tests the BlackSwaptionEngine. It initializes test data and creates pricing engines for swaptions with different volatility inputs.

```C++
BOOST_FIXTURE_TEST_SUITE(QuantExtTestSuite, [qle::test::TopLevelFixture](classqle_1_1test_1_1_top_level_fixture.html))

BOOST_AUTO_TEST_SUITE(BlackSwaptionEngineDeltaGammaTest)

[342](test_2blackswaptionenginedeltagamma_8cpp.html#a9d9f2a926c8024f2eff1e6e873fdeb2c)[BOOST_AUTO_TEST_CASE](test_2blackswaptionenginedeltagamma_8cpp.html#a9d9f2a926c8024f2eff1e6e873fdeb2c)(testNpvDeltasGammaVegas) {
  TestData d;
  
  QuantLib::ext::shared_ptr<PricingEngine> engineLn0 =
    QuantLib::ext::make_shared<BlackSwaptionEngine>(d.discountCurve, Handle<Quote>(d.lnVol));
  QuantLib::ext::shared_ptr<PricingEngine> engineSln0 =
    QuantLib::ext::make_shared<BlackSwaptionEngine>(d.discountCurve, Handle<Quote>(d.slnVol), Actual365Fixed(), d.slnShift);
```

--------------------------------

### C++: Setup Financial Environment for Pricing

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/test_2analyticeuropeanenginedeltagamma_8cpp_source

Initializes QuantLib and QuantExt financial structures including yield term structures, volatility, and the GeneralizedBlackScholesProcess. This setup is crucial for pricing engine calculations within the ORE framework. Dependencies include QuantLib and QuantExt libraries.

```C++
namespace {
struct TestData {
TestData() : refDate(Date(22, Aug, 2016)) {
Settings::instance().evaluationDate() = refDate;
rateDiscount = Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(
0, NullCalendar(), Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.02)), Actual365Fixed()));
divDiscount = Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(
0, NullCalendar(), Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.03)), Actual365Fixed()));
pillarDates.push_back(refDate + 1 * Years);
pillarDates.push_back(refDate + 2 * Years);
pillarDates.push_back(refDate + 3 * Years);
pillarDates.push_back(refDate + 4 * Years);
pillarDates.push_back(refDate + 5 * Years);
pillarDates.push_back(refDate + 7 * Years);
pillarDates.push_back(refDate + 10 * Years);
pillarDates.push_back(refDate + 15 * Years);
pillarDates.push_back(refDate + 20 * Years);
std::vector<Handle<Quote>> tmpRateSpr, tmpDivSpr;
for (Size i = 0; i < pillarDates.size(); ++i) {
QuantLib::ext::shared_ptr<SimpleQuote> qr = QuantLib::ext::make_shared<SimpleQuote>(0.0);
QuantLib::ext::shared_ptr<SimpleQuote> qd = QuantLib::ext::make_shared<SimpleQuote>(0.0);
rateSpreads.push_back(qr);
divSpreads.push_back(qd);
tmpRateSpr.push_back(Handle<Quote>(qr));
tmpDivSpr.push_back(Handle<Quote>(qd));
pillarTimes.push_back(rateDiscount->timeFromReference(pillarDates[i]));
}
rateCurve =
Handle<YieldTermStructure>(QuantLib::ext::make_shared<InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>>(
rateDiscount, tmpRateSpr, pillarDates));
divCurve =
Handle<YieldTermStructure>(QuantLib::ext::make_shared<InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>>(
divDiscount, tmpDivSpr, pillarDates));
rateCurve->enableExtrapolation();
divCurve->enableExtrapolation();
vol = QuantLib::ext::make_shared<SimpleQuote>(0.20);
volTs = Handle<BlackVolTermStructure>(
QuantLib::ext::make_shared<BlackConstantVol>(0, NullCalendar(), Handle<Quote>(vol), Actual365Fixed()));
spot = QuantLib::ext::make_shared<SimpleQuote>(100.0);
process = QuantLib::ext::make_shared<GeneralizedBlackScholesProcess>(Handle<Quote>(spot), divCurve, rateCurve, volTs);
}
Date refDate;
Handle<YieldTermStructure> rateDiscount, divDiscount, rateCurve, divCurve;
std::vector<Date> pillarDates;
std::vector<QuantLib::ext::shared_ptr<SimpleQuote>> rateSpreads, divSpreads;
std::vector<Real> pillarTimes;
QuantLib::ext::shared_ptr<SimpleQuote> vol, spot;
Handle<BlackVolTermStructure> volTs;
QuantLib::ext::shared_ptr<GeneralizedBlackScholesProcess> process;
};
} // namespace
```

--------------------------------

### C++ Currency Swap Engine Delta/Gamma Test Setup

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/test_2discountingcurrencyswapenginedeltagamma_8cpp_source

This C++ code snippet demonstrates the setup of test data for currency swap engine delta and gamma calculations. It initializes reference dates, yield term structures (discount and forward curves), and market quotes using QuantLib and QuantExt libraries, preparing the environment for financial instrument pricing tests.

```C++
#include "toplevelfixture.hpp"
#include <boost/test/unit_test.hpp>

#include <qle/pricingengines/discountingcurrencyswapengine.hpp>
#include <qle/pricingengines/discountingcurrencyswapenginedeltagamma.hpp>

#include <ql/cashflows/iborcoupon.hpp>
#include <ql/indexes/ibor/euribor.hpp>
#include <ql/indexes/ibor/usdlibor.hpp>
#include <ql/math/matrix.hpp>
#include <ql/quotes/simplequote.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/termstructures/yield/piecewisezerospreadedtermstructure.hpp>
#include <ql/time/calendars/target.hpp>
#include <ql/time/calendars/unitedstates.hpp>

#include <boost/make_shared.hpp>

using namespace QuantLib;
using namespace QuantExt;

using namespace boost::unit_test_framework;
using std::vector;

namespace {
struct TestData {
    TestData() : refDate(Date(22, Aug, 2016)) {
        Settings::instance().evaluationDate() = refDate;
        baseDiscount = Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(
            refDate, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.02)), Actual365Fixed()));
        baseForward = Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(
            refDate, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.03)), Actual365Fixed()));
        baseDiscountFor = Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(
            refDate, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.04)), Actual365Fixed()));
        baseForwardFor = Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(
            refDate, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.05)), Actual365Fixed()));
        fxQuote = QuantLib::ext::make_shared<SimpleQuote>(0.90);
        pillarDates.push_back(refDate + 1 * Years);
        pillarDates.push_back(refDate + 2 * Years);
        pillarDates.push_back(refDate + 3 * Years);
        pillarDates.push_back(refDate + 4 * Years);
        pillarDates.push_back(refDate + 5 * Years);
        pillarDates.push_back(refDate + 7 * Years);
        pillarDates.push_back(refDate + 10 * Years);
        std::vector<Handle<Quote>> tmpDiscSpr, tmpFwdSpr, tmpDiscSprFor, tmpFwdSprFor;
        for (Size i = 0; i < pillarDates.size(); ++i) {
            QuantLib::ext::shared_ptr<SimpleQuote> qd = QuantLib::ext::make_shared<SimpleQuote>(0.0);
            QuantLib::ext::shared_ptr<SimpleQuote> qf = QuantLib::ext::make_shared<SimpleQuote>(0.0);
            QuantLib::ext::shared_ptr<SimpleQuote> qdf = QuantLib::ext::make_shared<SimpleQuote>(0.0);
            QuantLib::ext::shared_ptr<SimpleQuote> qff = QuantLib::ext::make_shared<SimpleQuote>(0.0);
            discountSpreads.push_back(qd);
            forwardSpreads.push_back(qf);
            discountSpreadsFor.push_back(qdf);
            forwardSpreadsFor.push_back(qff);
            tmpDiscSpr.push_back(Handle<Quote>(qd));
            tmpFwdSpr.push_back(Handle<Quote>(qf));
            tmpDiscSprFor.push_back(Handle<Quote>(qdf));
            tmpFwdSprFor.push_back(Handle<Quote>(qff));
            pillarTimes.push_back(baseDiscount->timeFromReference(pillarDates[i]));
        }
        discountCurve = 
            Handle<YieldTermStructure>(QuantLib::ext::make_shared<InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>>(
                baseDiscount, tmpDiscSpr, pillarDates));
        forwardCurve = 
            Handle<YieldTermStructure>(QuantLib::ext::make_shared<InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>>(
                baseForward, tmpFwdSpr, pillarDates));
        discountCurveFor = 
            Handle<YieldTermStructure>(QuantLib::ext::make_shared<InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>>(
                baseDiscountFor, tmpDiscSprFor, pillarDates));
        forwardCurveFor = 
            Handle<YieldTermStructure>(QuantLib::ext::make_shared<InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>>(
                baseForwardFor, tmpFwdSprFor, pillarDates));
    }
    Date refDate;
    Handle<YieldTermStructure> baseDiscount, baseForward, baseDiscountFor, baseForwardFor;
    std::vector<QuantLib::ext::shared_ptr<SimpleQuote>> discountSpreads, forwardSpreads, discountSpreadsFor, forwardSpreadsFor;
    std::vector<Date> pillarDates;
    std::vector<Time> pillarTimes;
    QuantLib::ext::shared_ptr<SimpleQuote> fxQuote;
};
}

BOOST_AUTO_TEST_SUITE(OREAnnotatedSourceDiscountingCurrencySwapEngineDeltaGammaSuite)

BOOST_AUTO_TEST_CASE(DiscountingCurrencySwapEngineDeltaGammaTest) {
    TestData data;

    // Setup for EUR/USD currency swap
    Calendar calendar = TARGET();
    Date startDate = calendar.advance(data.refDate, 1 * Days);
    Date endDate = calendar.advance(startDate, 5 * Years);
    BusinessDayConvention convention = ModifiedFollowing;
    Frequency frequency = Annual;
    
    // EURibor index
    QuantLib::ext::shared_ptr<IborIndex> euribor = QuantLib::ext::make_shared<Euribor>(6 * Months, data.baseForward);
    
    // USD Libor index
    QuantLib::ext::shared_ptr<IborIndex> usdlibor = QuantLib::ext::make_shared<USDLibor>(6 * Months, data.baseForwardFor);

    // Pricing engine for EUR/USD swap
    QuantLib::ext::shared_ptr<PricingEngine> engine = QuantLib::ext::make_shared<DiscountingCurrencySwapEngine>(
        data.baseDiscount, data.baseForward, data.fxQuote, euribor, usdlibor);

    // Pricing engine for EUR/USD swap with delta/gamma calculation
    QuantLib::ext::shared_ptr<PricingEngine> engineDeltaGamma = QuantLib::ext::make_shared<DiscountingCurrencySwapEngineDeltaGamma>(
        data.baseDiscount, data.baseForward, data.fxQuote, euribor, usdlibor);

    // Further test logic would go here, e.g., creating a swap and calculating Greeks.
    // For brevity, only the setup is shown.
    BOOST_CHECK(true); // Placeholder for actual test assertions
}

BOOST_AUTO_TEST_SUITE_END()

```

--------------------------------

### Setup Arguments

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/riskparticipationagreement_8hpp_source

Internal method to set up the arguments for pricing. This is an override from a base class and is marked as const.

```cpp
void setupArguments(QuantLib::PricingEngine::arguments*) const override;
```

--------------------------------

### Setup and Test Forward Bond Pricing Engine

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/test_2forwardbond_8cpp

Demonstrates initializing a DiscountingForwardBondEngine for a forward bond using QuantLib and QuantExt. It sets the pricing engine, logs the bond's NPV, and asserts its value against an expected result using Boost testing macros.

```C++
QuantLib::ext::shared_ptr<PricingEngine> fwdBondEngine(new QuantExt::DiscountingForwardBondEngine(discountTS, incomeTS, yts, bondSpecificSpread, dpts, recovery, 2 * Months));
fwdBond->setPricingEngine(fwdBondEngine);

BOOST_TEST_MESSAGE("Forward Bond price short = " << fwdBond->NPV());

BOOST_CHECK_CLOSE(fwdBondNPV, (-1.0) * fwdBond->NPV(), 0.000001);
```

--------------------------------

### Get Protection Start Date

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/riskparticipationagreement_8hpp_source

Retrieves the start date of the protection period. This method provides read-only access to the protection start date.

```cpp
const Date& protectionStart() const { return protectionStart_; }
```

--------------------------------

### EquityForward Construction and Setup

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/equityforward_8cpp_source

Demonstrates the construction of an EquityForward instrument using QuantLib's shared pointers and factory pattern. It includes setting up trade details, currency checks against market data, and configuring the pricing engine. Dependencies include QuantLib core, QuantExt, and market data access.

```C++
QuantLib::ext::shared_ptr<Instrument> inst = 
    QuantLib::ext::make_shared<QuantExt::EquityForward>(name, ccy, longShort, quantity_, maturity, strike);

// set up other Trade details
instrument_ = QuantLib::ext::shared_ptr<InstrumentWrapper>(new VanillaInstrument(inst));
npvCurrency_ = ccy.code();
maturity_ = maturity;
// Notional - we really need todays spot to get the correct notional.
// But rather than having it move around we use strike * quantity
notional_ = strike * quantity_;
notionalCurrency_ = ccy.code();

// We check the ccys here at the end of the build to ensure that the rest of the build above
// (which does not require the market) runs first

// get the equity currency from the market
Currency equityCcy = engineFactory->market()->equityCurve(eqName())->currency();

// ensure forward currency matches the equity currency
QL_REQUIRE(!equityCcy.empty(), "No equity currency in equityCurve for equity " << eqName());
QL_REQUIRE(ccy == equityCcy, "EquityForward currency " << ccy << " does not match equity currency " << equityCcy << " for trade " << id());

if (!strikeCurrency_.empty()) {
    Currency strikeCcy = parseCurrencyWithMinors(strikeCurrency_);
    QL_REQUIRE(strikeCcy == equityCcy, "Strike currency " << ccy << " does not match equity currency " << equityCcy << " for trade " << id());
}

// Pricing engine
QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder(tradeType_);
QL_REQUIRE(builder, "No builder found for " << tradeType_);
QuantLib::ext::shared_ptr<EquityForwardEngineBuilder> eqFwdBuilder = 
    QuantLib::ext::dynamic_pointer_cast<EquityForwardEngineBuilder>(builder);
inst->setPricingEngine(eqFwdBuilder->engine(name, ccy));
setSensitivityTemplate(*eqFwdBuilder);
```

--------------------------------

### Get Start Date

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/commodityapo_8hpp_source

Returns the start date for the commodity average price option. This getter provides read-only access to the start date as a std::string.

```cpp
const std::string& startDate() const { return startDate_; }
```

--------------------------------

### Get Start Date

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/classore_1_1data_1_1_default_curve_config_1_1_config

Returns the start date. This method retrieves the QuantLib::Date object representing the start date for the configuration.

```cpp
const QuantLib::Date & startDate() const {
  return startDate_;
}
```

--------------------------------

### EquityForward::setupArguments Method (C++)

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/equityforward_8cpp_source

Populates the pricing engine's arguments with the EquityForward's specific data. It casts the generic arguments to EquityForward::arguments and assigns member variables.

```cpp
void EquityForward::setupArguments(PricingEngine::arguments* args) const {
    EquityForward::arguments* arguments = dynamic_cast<EquityForward::arguments*>(args);
    QL_REQUIRE(arguments != 0, "wrong argument type in equityforward");
    arguments->name = name_;
    arguments->currency = currency_;
    arguments->longShort = longShort_;
    arguments->quantity = quantity_;
    arguments->maturityDate = maturityDate_;
    arguments->strike = strike_;
}
```

--------------------------------

### Get Start Date - CPI Leg Data

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/legdata_8hpp_source

Retrieves the start date for the CPI leg. This inspector returns a constant reference to the string representing the start date.

```cpp
const string& startDate() const { return startDate_; }
```

--------------------------------

### EquityForward Trade Initialization and Setup

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/classore_1_1data_1_1_equity_forward

This snippet demonstrates the initialization and setup of an EquityForward trade. It involves creating an InstrumentWrapper, setting NPV currency, maturity, notional, and notional currency. It also includes crucial checks for currency consistency between the equity and strike currencies, and sets up the pricing engine using an EquityForwardEngineBuilder.

```C++
QuantLib::ext::shared_ptr<InstrumentWrapper> instrument_ = QuantLib::ext::shared_ptr<InstrumentWrapper>(new VanillaInstrument(inst));

npvCurrency_ = ccy.code();
maturity_ = maturity;

// Notional - we really need todays spot to get the correct notional.
// But rather than having it move around we use strike * quantity
notional_ = strike * quantity_;
notionalCurrency_ = ccy.code();

// We check the ccys here at the end of the build to ensure that the rest of the build above
// (which does not require the market) runs first

// get the equity currency from the market
Currency equityCcy = engineFactory->market()->equityCurve(eqName())->currency();

// ensure forward currency matches the equity currency
QL_REQUIRE(!equityCcy.empty(), "No equity currency in equityCurve for equity " << eqName());
QL_REQUIRE(ccy == equityCcy, "EquityForward currency " << ccy << " does not match equity currency " << equityCcy << " for trade " << id());

if (!strikeCurrency_.empty()) {
    Currency strikeCcy = parseCurrencyWithMinors(strikeCurrency_);
    QL_REQUIRE(strikeCcy == equityCcy, "Strike currency " << ccy << " does not match equity currency " << equityCcy << " for trade " << id());
}

// Pricing engine
QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder(tradeType_);
QL_REQUIRE(builder, "No builder found for " << tradeType_);
QuantLib::ext::shared_ptr<EquityForwardEngineBuilder> eqFwdBuilder =
    QuantLib::ext::dynamic_pointer_cast<EquityForwardEngineBuilder>(builder);
inst->setPricingEngine(eqFwdBuilder->engine(name(), ccy));
setSensitivityTemplate(*eqFwdBuilder);
```

--------------------------------

### C++: DiscountingSwapEngineDeltaGamma Test Setup

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/test_2discountingswapenginedeltagamma_8cpp_source

This snippet demonstrates the setup for testing the DiscountingSwapEngineDeltaGamma pricing engine. It includes the definition of a TestData struct for initializing QuantLib yield term structures, dates, and indices, along with utility functions for floating-point comparisons and timing.

```cpp
#include <boost/test/unit_test.hpp>
#include <qle/pricingengines/discountingswapenginedeltagamma.hpp>
#include <ql/indexes/ibor/euribor.hpp>
#include <ql/instruments/makevanillaswap.hpp>
#include <ql/pricingengines/swap/discountingswapengine.hpp>
#include <ql/quotes/simplequote.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/termstructures/yield/piecewisezerospreadedtermstructure.hpp>
#include <boost/make_shared.hpp>
#include <boost/timer/timer.hpp>

using namespace QuantLib;
using namespace QuantExt;

using namespace boost::unit_test_framework;
using std::vector;

namespace {
struct TestData {
    TestData() : refDate(Date(22, Aug, 2016)) {
        Settings::instance().evaluationDate() = refDate;
        baseDiscount = Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(
            refDate, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.02)), Actual365Fixed()));
        baseForward = Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(
            refDate, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.03)), Actual365Fixed()));
        pillarDates.push_back(refDate + 1 * Years);
        pillarDates.push_back(refDate + 2 * Years);
        pillarDates.push_back(refDate + 3 * Years);
        pillarDates.push_back(refDate + 4 * Years);
        pillarDates.push_back(refDate + 5 * Years);
        pillarDates.push_back(refDate + 7 * Years);
        pillarDates.push_back(refDate + 10 * Years);
        std::vector<Handle<Quote>> tmpDiscSpr, tmpFwdSpr;
        for (Size i = 0; i < pillarDates.size(); ++i) {
            QuantLib::ext::shared_ptr<SimpleQuote> qd = QuantLib::ext::make_shared<SimpleQuote>(0.0);
            QuantLib::ext::shared_ptr<SimpleQuote> qf = QuantLib::ext::make_shared<SimpleQuote>(0.0);
            discountSpreads.push_back(qd);
            forwardSpreads.push_back(qf);
            tmpDiscSpr.push_back(Handle<Quote>(qd));
            tmpFwdSpr.push_back(Handle<Quote>(qf));
            pillarTimes.push_back(baseDiscount->timeFromReference(pillarDates[i]));
        }
        discountCurve = 
            Handle<YieldTermStructure>(QuantLib::ext::make_shared<InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>>(
                baseDiscount, tmpDiscSpr, pillarDates));
        forwardCurve = 
            Handle<YieldTermStructure>(QuantLib::ext::make_shared<InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>>(
                baseForward, tmpFwdSpr, pillarDates));
        discountCurve->enableExtrapolation();
        forwardCurve->enableExtrapolation();
        forwardIndex = QuantLib::ext::make_shared<Euribor>(6 * Months, forwardCurve);
    }
    Date refDate;
    Handle<YieldTermStructure> baseDiscount, baseForward, discountCurve, forwardCurve;
    QuantLib::ext::shared_ptr<IborIndex> forwardIndex;
    std::vector<Date> pillarDates;
    std::vector<QuantLib::ext::shared_ptr<SimpleQuote>> discountSpreads, forwardSpreads;
    std::vector<Real> pillarTimes;
};

bool check(const Real reference, const Real value) {
    if (std::fabs(reference) >= 1E-4) {
        return std::fabs((reference - value) / reference) < 1E-3;
    } else {
        return std::fabs(reference - value) < 5E-5;
    }
}

class Timer {
    boost::timer::cpu_timer timer_;
    double elapsed_;

public:
    void start() { timer_ = boost::timer::cpu_timer(); }
    void stop() { elapsed_ = timer_.elapsed().wall * 1e-9; }
    double elapsed() const { return elapsed_; }
};

void performTest(const TestData& d, const QuantLib::ext::shared_ptr<PricingEngine>& engine0,
                 const QuantLib::ext::shared_ptr<PricingEngine>& engine, const bool receiveFixed, const Real spread,

```

--------------------------------

### Synthetic CDO Index Start Date Hint

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/cdo_8hpp_source

Manages a hint for the index start date, used when the actual start date is not set correctly in the trade setup.

```cpp
void setIndexStartDateHint(const QuantLib::Date& d) const { indexStartDateHint_ = d;
}

const QuantLib::Date& indexStartDateHint() const { return indexStartDateHint_;
}
```

--------------------------------

### QuantExt::BondOption::setupArguments

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/qle_2instruments_2bondoption_8cpp_source

Sets up arguments for the Pricing Engine. This method is part of the BondOption class and is an override.

```APIDOC
QuantExt::BondOption::setupArguments
  void setupArguments(PricingEngine::arguments *) const override
  Definition: bondoption.cpp:25
```

--------------------------------

### Get Protection Start Date (C++)

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/class_quant_ext_1_1_risk_participation_agreement_t_lock

Retrieves the start date for the protection period. This const member function provides read-only access to the protection start date.

```C++
const Date & protectionStart() const { return protectionStart_; }
```

--------------------------------

### IndexCdsOption::setupArguments - C++

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/indexcdsoption_8hpp_source

Sets up the arguments for the pricing engine for the IndexCdsOption. This is an override from the base class.

```C++
void setupArguments(QuantLib::PricingEngine::arguments *args) const override
```

--------------------------------

### Get Rate Computation Start Date

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/class_quant_ext_1_1_average_o_n_indexed_coupon

Retrieves the start date for rate computation. This method returns a constant reference to the Date object representing the start date.

```cpp
const Date & rateComputationStartDate() const {
  return rateComputationStartDate_;
}
```

--------------------------------

### FxForward setupArguments Method

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/fxforward_8cpp_source

Prepares the arguments for a pricing engine. This method is intended to be overridden by derived classes to populate specific pricing engine arguments.

```C++
void FxForward::setupArguments(PricingEngine::arguments* args) const {
  
}
```

--------------------------------

### Get Start Date (C++)

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/classore_1_1data_1_1_equity_touch_option

Retrieves the start date of the equity touch option. This const member function returns a constant reference to the start date string.

```C++
const string & startDate() const
{
  return startDate_;
}
```

--------------------------------

### C++: Setup Swaption Test Case for Dual Curve Model

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/test_2analyticlgmswaptionengine_8cpp_source

This C++ code defines a test case for evaluating swaption pricing engines in a dual-curve interest rate environment. It initializes discounting and forward yield term structures using FlatForward, creates EuriborSwapIsdaFixA indices with these curves, and constructs Swaption objects. This setup is preparatory for testing the analytic LGM swaption engine.

```C++
BOOST_AUTO_TEST_CASE(testDualCurve) {

    BOOST_TEST_MESSAGE("Testing analytic LGM swaption engine coupon "
                       "adjustments in dual curve setup...");

    // discounting curve
    Handle<YieldTermStructure> discCurve(QuantLib::ext::make_shared<FlatForward>(0, NullCalendar(), 0.02, Actual365Fixed()));
    // forward (+10bp)
    Handle<YieldTermStructure> forwardCurve1(
        QuantLib::ext::make_shared<FlatForward>(0, NullCalendar(), 0.0210, Actual365Fixed()));
    // forward (-10bp)
    Handle<YieldTermStructure> forwardCurve2(
        QuantLib::ext::make_shared<FlatForward>(0, NullCalendar(), 0.0190, Actual365Fixed()));

    const QuantLib::ext::shared_ptr<IrLgm1fConstantParametrization> irlgm1f = 
        QuantLib::ext::make_shared<IrLgm1fConstantParametrization>(EURCurrency(), discCurve, 0.01, 0.01);

    // forward curve attached
    QuantLib::ext::shared_ptr<SwapIndex> index1 = QuantLib::ext::make_shared<EuriborSwapIsdaFixA>(10 * Years, forwardCurve1);
    QuantLib::ext::shared_ptr<SwapIndex> index2 = QuantLib::ext::make_shared<EuriborSwapIsdaFixA>(10 * Years, forwardCurve2);

    Swaption swaption1 = MakeSwaption(index1, 10 * Years, 0.02);
    Swaption swaption2 = MakeSwaption(index2, 10 * Years, 0.02);

    QuantLib::ext::shared_ptr<PricingEngine> engine_a = 

```

--------------------------------

### Setup Cross-Asset Model and Swaption Engine

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/test_2crossassetmodel_8cpp

Initializes `IrLgm1fParametrization` for EUR and USD, an `FxBsParametrization`, and combines them into a `CrossAssetModel`. A `AnalyticLgmSwaptionEngine` is then created and applied to a basket of options.

```C++
QuantLib::ext::shared_ptr<IrLgm1fParametrization> lgm_p21 = QuantLib::ext::make_shared<IrLgm1fPiecewiseConstantHullWhiteAdaptor>(
    USCurrency(), yts, stepTimes_a, lgmInitialSigmas2_a, stepTimes_a, kappas_a);

QuantLib::ext::shared_ptr<IrLgm1fParametrization> lgm_p22 = QuantLib::ext::make_shared<IrLgm1fPiecewiseConstantHullWhiteAdaptor>(
    EURCurrency(), yts, stepTimes_a, lgmInitialSigmas2_a, stepTimes_a, kappas_a);

// ... and a fx parametrization ...
Array notimes_a(0);
Array sigma_a(1, 0.10);
QuantLib::ext::shared_ptr<FxBsParametrization> fx_p = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(
    EURCurrency(), Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(1.00)), notimes_a, sigma_a);

// ... and set up an crossasset model with USD as domestic currency ...
std::vector<QuantLib::ext::shared_ptr<Parametrization> > parametrizations;
parametrizations.push_back(lgm_p21);
parametrizations.push_back(lgm_p22);
parametrizations.push_back(fx_p);
Matrix rho(3, 3, 0.0);
rho[0][0] = rho[1][1] = rho[2][2] = 1.0;
QuantLib::ext::shared_ptr<CrossAssetModel> xmodel = 
    QuantLib::ext::make_shared<CrossAssetModel>(parametrizations, rho, SalvagingAlgorithm::None);

QuantLib::ext::shared_ptr<PricingEngine> swaptionEngineLgm2 = QuantLib::ext::make_shared<AnalyticLgmSwaptionEngine>(xmodel, 1);

for (Size i = 0; i < basket.size(); ++i) {
    basket[i]->setPricingEngine(swaptionEngineLgm2);
}
```

--------------------------------

### ScenarioStatisticsAnalytic Setup Configurations

Source: https://rkapl123.github.io/OREAnnotatedSource/Examples.Example_15.Output.log_var.txt

Logs the call to the setUpConfigurations method for the ScenarioStatisticsAnalytic component. This signifies the start of configuration setup for statistics-related analytics.

```cpp
NOTICE [2024-Jan-31 23:28:00.178102] [OREAnalytics/orea/app/analytics/scenariostatisticsanalytic.cpp:42](https://rkapl123.github.io/OREAnnotatedSource/orea/scenariostatisticsanalytic_8cpp_source.html#l00042) : ScenarioStatisticsAnalytic::setUpConfigurations() called
```

--------------------------------

### Get Start Date - ScheduleRules C++

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/schedule_8hpp_source

Retrieves the start date of the schedule. This is a mandatory field for a valid schedule.

```cpp
const string& startDate() const { return startDate_; }
```

--------------------------------

### AnalyticLgmSwaptionEngine Setup and NPV Calculation

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/test_2analyticlgmswaptionengine_8cpp_source

Demonstrates the creation of an AnalyticLGMSwaptionEngine with different configurations (nextCoupon, proRata) and setting it for a swaption object. It then proceeds to calculate the Net Present Value (NPV) of the swaption.

```C++
QuantLib::ext::shared_ptr<PricingEngine> engine_a =
    QuantLib::ext::make_shared<AnalyticLgmSwaptionEngine>(irlgm1f, discCurve, QuantLib::AnalyticLgmSwaptionEngine::nextCoupon);

swaption1.setPricingEngine(engine_a);
swaption1.NPV();

QuantLib::ext::shared_ptr<PricingEngine> engine_b =
    QuantLib::ext::make_shared<AnalyticLgmSwaptionEngine>(irlgm1f, discCurve, QuantLib::AnalyticLgmSwaptionEngine::proRata);

swaption2.setPricingEngine(engine_b);
swaption2.NPV();
```

--------------------------------

### Get Start Date - FxDigitalBarrierOption C++

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/classore_1_1data_1_1_fx_digital_barrier_option

Retrieves the start date as a constant string reference for the FxDigitalBarrierOption. This method returns the start date string, indicating when the option becomes active.

```C++
const string & startDate() const {
  return startDate_;
}
```

--------------------------------

### Test Equity Coupon Setup and Instantiation

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/cashflow_8cpp_source

Sets up QuantLib objects like EquityIndex2, YieldTermStructures, and FXIndex to test various EquityCoupon configurations. Demonstrates instantiation for Price Return, Total Return, and Total Return with fixing lag.

```C++
// Test today = 5 Jan 2016
Settings::instance().evaluationDate() = Date(5, Jan, 2016);
Date today = Settings::instance().evaluationDate();

Date cfDate1(4, Dec, 2015);
Date cfDate2(5, Apr, 2016); // future
Date fixingDate1(31, Dec, 2015);
Date fixingDate2(1, Apr, 2016);

Real nominal = 1000000; // 1M - in USD
string eqName = "SP5";
QuantLib::ext::shared_ptr<SimpleQuote> sq = QuantLib::ext::make_shared<SimpleQuote>(2100);
Handle<Quote> spot(sq);
DayCounter dc = ActualActual(ActualActual::ISDA);
Calendar cal = TARGET();
Currency ccy = USDCurrency();
Natural fixingLag = 2;
Real divFactor = 1.0;
Handle<YieldTermStructure> dividend(
QuantLib::ext::shared_ptr<YieldTermStructure>(new FlatForward(0, cal, 0.01, dc))); // Dividend Curve
Handle<YieldTermStructure> equityforecast(
QuantLib::ext::shared_ptr<YieldTermStructure>(new FlatForward(0, cal, 0.02, dc))); // Equity Forecast Curve

QuantLib::ext::shared_ptr<EquityIndex2> eqIndex =
QuantLib::ext::make_shared<EquityIndex2>(eqName, cal, ccy, spot, equityforecast, dividend);

eqIndex->addFixing(cfDate1, 2000);
eqIndex->addFixing(fixingDate1, 1980);

// Price Return coupon
EquityCoupon eq1(cfDate2, nominal, today, cfDate2, 0, eqIndex, dc, EquityReturnType::Price);
// Total Return Coupon
EquityCoupon eq2(cfDate2, nominal, today, cfDate2, 0, eqIndex, dc, EquityReturnType::Total, divFactor);
// historical starting coupon
EquityCoupon eq3(cfDate2, nominal, cfDate1, cfDate2, 0, eqIndex, dc, EquityReturnType::Price);
// Total Return Coupon with fixing lag
EquityCoupon eq4(cfDate2, nominal, today, cfDate2, fixingLag, eqIndex, dc, EquityReturnType::Total);

// Fx Index, coupon and underlying have different currency
Handle<YieldTermStructure> domYTS(QuantLib::ext::shared_ptr<YieldTermStructure>(new FlatForward(0, cal, 0.01, dc))); // EUR
Handle<YieldTermStructure> forYTS(QuantLib::ext::shared_ptr<YieldTermStructure>(new FlatForward(0, cal, 0.02, dc))); // USD
Handle<Quote> fxSpot(QuantLib::ext::make_shared<SimpleQuote>(1.1));
QuantLib::ext::shared_ptr<FxIndex> fxIndex =
QuantLib::ext::make_shared<FxIndex>("FX::EURUSD", 2, EURCurrency(), USDCurrency(), TARGET(), fxSpot, domYTS, forYTS);
// Add historical and todays fixing
fxIndex->addFixing(cfDate1, 1.09);

// Total return coupon with underlying in different ccy - Base ccy EUR, and underlying SP5 in USD
EquityCoupon eq5(cfDate2, nominal, today, cfDate2, 0, eqIndex, dc, EquityReturnType::Total, 1.0, false,
Null<Real>(), Null<Real>(), Date(), Date(), Date(), Date(), Date(), fxIndex);
```

--------------------------------

### Get Deposit Start Date in C++

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/class_quant_ext_1_1_deposit

Returns the start date of the deposit. This marks the beginning of the deposit period.

```C++
Date QuantExt::Deposit::startDate() const {
  return startDate_;
}
```

--------------------------------

### ConvertibleBond2 setupArguments Method (C++)

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/convertiblebond2_8cpp_source

Sets up the arguments for a pricing engine for the ConvertibleBond2 class. This method populates the specific arguments object for ConvertibleBond2 with data from the instrument, such as start date, notionals, and various configuration data structures. It ensures the correct argument type is used.

```C++
void ConvertibleBond2::setupArguments(PricingEngine::arguments* args) const {
    Bond::setupArguments(args);
    ConvertibleBond2::arguments* arguments = dynamic_cast<ConvertibleBond2::arguments*>(args);
    QL_REQUIRE(arguments != nullptr, "ConvertibleBond2::setupArguments(): wrong argument type");
    arguments->startDate = startDate();
    arguments->notionals = notionals();
    arguments->exchangeableData = exchangeableData_;
    arguments->callData = callData_;
    arguments->makeWholeData = makeWholeData_;
}
```

--------------------------------

### QuantExt::Ascot::arguments::setupArguments Method

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/ascot_8hpp_source

Sets up the arguments for the pricing engine. Takes a pointer to PricingEngine::arguments.

```cpp
void setupArguments(PricingEngine::arguments *) const;
```

--------------------------------

### Get FEP Start Date

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/indexcreditdefaultswapoption_8cpp_source

Retrieves the First Effective Period (FEP) start date for the IndexCreditDefaultSwapOption. This is a const member function.

```C++
const Date& IndexCreditDefaultSwapOption::fepStartDate() const {
  return fepStartDate_;
}
```

--------------------------------

### QuantExt::BondRepo::setupArguments Method

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/bondrepo_8hpp_source

Sets up the arguments for the pricing engine. This const override method takes a pointer to QuantLib::PricingEngine::arguments and is defined in the cpp file.

```APIDOC
QuantExt::BondRepo::setupArguments
  void setupArguments(QuantLib::PricingEngine::arguments *) const override
  Definition: bondrepo.cpp:48
```

--------------------------------

### Get Protection Start Date - CreditDefaultSwapData

Source: https://rkapl123.github.io/OREAnnotatedSource/ored/creditdefaultswapdata_8hpp_source

Retrieves the start date for protection under the Credit Default Swap. This is a QuantLib::Date object.

```cpp
const Date& protectionStart() const { return protectionStart_; }
```

--------------------------------

### Get Protection Start Date

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/class_quant_ext_1_1_risk_participation_agreement

Returns a constant reference to the Date object representing the start of protection. This is a const member function.

```C++
const Date & protectionStart() const {
  return protectionStart_;
}
```

--------------------------------

### VanillaForwardOption Class

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/group__instruments

Documentation for the VanillaForwardOption class, modeling a standard forward option on a single asset. Includes a link for more details.

```APIDOC
Class: VanillaForwardOption
Description: Represents a standard (vanilla) forward option on a single underlying asset.
Details: Provides functionality for pricing and managing vanilla forward options.
```

--------------------------------

### Get Cap Floor Start Date (CPVolatilitySurface)

Source: https://rkapl123.github.io/OREAnnotatedSource/qle/class_quant_ext_1_1_c_p_i_price_volatility_surface

Retrieves the start date for the cap or floor instrument associated with this volatility surface.

```C++
QuantLib::Date capFloorStartDate() const
  // Returns the start date for cap/floor instruments.
```