Serializable Asian Option. More...

#include <ored/portfolio/asianoption.hpp>

Inheritance diagram for AsianOption:

Collaboration diagram for AsianOption:

Public Member Functions
	AsianOption (const string &tradeType)

	AsianOption (const Envelope &env, const string &tradeType, const double quantity, const TradeStrike &strike, const OptionData &option, const ScheduleData &observationDates, const QuantLib::ext::shared_ptr< Underlying > &underlying, const Date &settlementDate, const std::string &currency)

void	build (const QuantLib::ext::shared_ptr< EngineFactory > &) override
	Build QuantLib/QuantExt instrument, link pricing engine. More...

QuantLib::Real	notional () const override
	Trade interface. More...

string	notionalCurrency () const override

Serialisation
virtual void	fromXML (XMLNode *node) override

virtual XMLNode *	toXML (XMLDocument &doc) const override

Public Member Functions inherited from Trade
	Trade ()
	Default constructor. More...

	Trade (const string &tradeType, const Envelope &env=Envelope(), const TradeActions &ta=TradeActions())
	Base class constructor. More...

virtual	~Trade ()
	Default destructor. More...

virtual void	build (const QuantLib::ext::shared_ptr< EngineFactory > &)=0

virtual std::map< std::string, RequiredFixings::FixingDates >	fixings (const QuantLib::Date &settlementDate=QuantLib::Date()) const

const RequiredFixings &	requiredFixings () const

virtual std::map< AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager=nullptr) const

void	reset ()
	Reset trade, clear all base class data. This does not reset accumulated timings for this trade. More...

void	resetPricingStats (const std::size_t numberOfPricings=0, const boost::timer::nanosecond_type cumulativePricingTime=0)
	Reset accumulated timings to given values. More...

string &	id ()
	Set the trade id. More...

void	setEnvelope (const Envelope &envelope)
	Set the envelope with counterparty and portfolio info. More...

void	setAdditionalData (const std::map< std::string, boost::any > &additionalData)

TradeActions &	tradeActions ()
	Set the trade actions. More...

const string &	id () const

const string &	tradeType () const

const Envelope &	envelope () const

const set< string > &	portfolioIds () const

const TradeActions &	tradeActions () const

const QuantLib::ext::shared_ptr< InstrumentWrapper > &	instrument () const

const std::vector< QuantLib::Leg > &	legs () const

const std::vector< string > &	legCurrencies () const

const std::vector< bool > &	legPayers () const

const string &	npvCurrency () const

const Date &	maturity () const

virtual bool	isExpired (const Date &d)

const string &	issuer () const

template<typename T >
T	additionalDatum (const std::string &tag) const
	returns any additional datum. More...

virtual const std::map< std::string, boost::any > &	additionalData () const
	returns all additional data returned by the trade once built More...

const std::string &	sensitivityTemplate () const

void	validate () const
	Utility to validate that everything that needs to be set in this base class is actually set. More...

virtual bool	hasCashflows () const

boost::timer::nanosecond_type	getCumulativePricingTime () const
	Get cumulative timing spent on pricing. More...

std::size_t	getNumberOfPricings () const
	Get number of pricings. More...

Public Member Functions inherited from XMLSerializable
virtual	~XMLSerializable ()

virtual void	fromXML (XMLNode *node)=0

virtual XMLNode *	toXML (XMLDocument &doc) const =0

void	fromFile (const std::string &filename)

void	toFile (const std::string &filename) const

void	fromXMLString (const std::string &xml)
	Parse from XML string. More...

std::string	toXMLString () const
	Parse from XML string. More...

Inspectors
double	quantity_ = 0.0

TradeStrike	tradeStrike_

OptionData	option_

ScheduleData	observationDates_

QuantLib::ext::shared_ptr< Underlying >	underlying_

Date	settlementDate_

string	currency_

string	assetName_

QuantLib::ext::shared_ptr< Trade >	delegatingBuilderTrade_

string	indexName_

const string &	asset () const

const TradeStrike &	strike () const

double	quantity () const

const OptionData &	option () const

const ScheduleData &	observationDates () const

const Date &	settlementDate () const

const string &	payCurrency () const

const string &	indexName () const

const QuantLib::ext::shared_ptr< Underlying > &	underlying () const

std::map< AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager=nullptr) const override

void	populateIndexName () const

Additional Inherited Members
Protected Member Functions inherited from Trade
Date	addPremiums (std::vector< QuantLib::ext::shared_ptr< Instrument > > &instruments, std::vector< Real > &multipliers, const Real tradeMultiplier, const PremiumData &premiumData, const Real premiumMultiplier, const Currency &tradeCurrency, const QuantLib::ext::shared_ptr< EngineFactory > &factory, const string &configuration)

void	setLegBasedAdditionalData (const Size legNo, Size resultLegId=Null< Size >()) const

void	setSensitivityTemplate (const EngineBuilder &builder)

void	setSensitivityTemplate (const std::string &id)

Protected Attributes inherited from Trade
string	tradeType_

QuantLib::ext::shared_ptr< InstrumentWrapper >	instrument_

std::vector< QuantLib::Leg >	legs_

std::vector< string >	legCurrencies_

std::vector< bool >	legPayers_

string	npvCurrency_

QuantLib::Real	notional_

string	notionalCurrency_

Date	maturity_

string	issuer_

string	sensitivityTemplate_

bool	sensitivityTemplateSet_ = false

std::size_t	savedNumberOfPricings_ = 0

boost::timer::nanosecond_type	savedCumulativePricingTime_ = 0

RequiredFixings	requiredFixings_

std::map< std::string, boost::any >	additionalData_

Detailed Description

Serializable Asian Option.

Definition at line 40 of file asianoption.hpp.

Constructor & Destructor Documentation

◆ AsianOption() [1/2]

AsianOption ( const string & tradeType )

explicit

Definition at line 42 of file asianoption.hpp.

42: Trade(tradeType) {}

ore::data::Trade::Trade

Trade()

Default constructor.

Definition: trade.hpp:59

ore::data::Trade::tradeType

const string & tradeType() const

Definition: trade.hpp:133

◆ AsianOption() [2/2]

AsianOption	(	const Envelope &	env,
		const string &	tradeType,
		const double	quantity,
		const TradeStrike &	strike,
		const OptionData &	option,
		const ScheduleData &	observationDates,
		const QuantLib::ext::shared_ptr< Underlying > &	underlying,
		const Date &	settlementDate,
		const std::string &	currency
	)

Definition at line 43 of file asianoption.hpp.

        : Trade(tradeType, env), quantity_(quantity), tradeStrike_(strike), option_(option),
          observationDates_(observationDates), underlying_(underlying), settlementDate_(settlementDate),
          currency_(currency) {}

Member Function Documentation

◆ build()

void build ( const QuantLib::ext::shared_ptr< EngineFactory > & engineFactory )

overridevirtual

Build QuantLib/QuantExt instrument, link pricing engine.

Implements Trade.

Definition at line 35 of file asianoption.cpp.

                                                                                 {
 
    // ISDA taxonomy
    if (underlying_->type() == "Equity") {
        additionalData_["isdaAssetClass"] = string("Equity");
        additionalData_["isdaBaseProduct"] = string("Option");
        additionalData_["isdaSubProduct"] = string("Price Return Basic Performance");  
    } else if (underlying_->type() == "FX") {
        additionalData_["isdaAssetClass"] = string("Foreign Exchange");
        additionalData_["isdaBaseProduct"] = string("Vanilla Option");
        additionalData_["isdaSubProduct"] = string("");
    } else if (underlying_->type() == "Commodity") {
        // guessing that Commodities are treated like Equity
        additionalData_["isdaAssetClass"] = string("Commodity");
        additionalData_["isdaBaseProduct"] = string("Option");
        additionalData_["isdaSubProduct"] = string("Price Return Basic Performance");  
    }
    else {
        WLOG("ISDA taxonomy not set for trade " << id());
    }
    additionalData_["isdaTransaction"] = string("");  
 
    Currency payCcy = parseCurrency(currency_);
 
    QL_REQUIRE(tradeActions().empty(), "TradeActions not supported for AsianOption");
 
    Option::Type type = parseOptionType(option_.callPut());
    QL_REQUIRE(option_.exerciseDates().size() == 1, "Expected exactly one exercise date");
    Date expiryDate = parseDate(option_.exerciseDates().front());
 
    string tradeTypeBuilder = tradeType_;
 
    // Add Arithmetic/Geometric
 
    if (option_.payoffType2() == "Arithmetic" || option_.payoffType2().empty())
        tradeTypeBuilder += "Arithmetic";
    else if (option_.payoffType2() == "Geometric")
        tradeTypeBuilder += "Geometric";
    else {
        QL_FAIL("payoff type 2 must be 'Arithmetic' or 'Geometric'");
    }
 
    // Add Price/Strike
 
    if (option_.payoffType() == "Asian")
        tradeTypeBuilder += "Price";
    else if (option_.payoffType() == "AverageStrike")
        tradeTypeBuilder += "Strike";
    else {
        QL_FAIL("payoff type must be 'Asian' or 'AverageStrike'");
    }
 
    QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder(tradeTypeBuilder);
    QL_REQUIRE(builder, "No builder found for " << tradeTypeBuilder);
 
    // check for delegating engine builder
 
    if (auto db = QuantLib::ext::dynamic_pointer_cast<DelegatingEngineBuilder>(builder)) {
 
        // let the delegating builder build the trade and link the results to this trade
 
        delegatingBuilderTrade_ = db->build(this, engineFactory);
 
        instrument_ = delegatingBuilderTrade_->instrument();
        maturity_ = delegatingBuilderTrade_->maturity();
        npvCurrency_ = delegatingBuilderTrade_->npvCurrency();
        additionalData_ = delegatingBuilderTrade_->additionalData();
    requiredFixings_ = delegatingBuilderTrade_->requiredFixings();
        setSensitivityTemplate(delegatingBuilderTrade_->sensitivityTemplate());
 
        // notional and notional currency are defined in overriden methods!
 
        return;
    }
 
    // we do not have a delegating engine builder
 
    QuantLib::ext::shared_ptr<AsianOptionEngineBuilder> asianOptionBuilder =
        QuantLib::ext::dynamic_pointer_cast<AsianOptionEngineBuilder>(builder);
 
    QL_REQUIRE(asianOptionBuilder, "engine builder is not an AsianOption engine builder" << tradeTypeBuilder);
 
    std::string processType = asianOptionBuilder->processType();
    QL_REQUIRE(!processType.empty(), "ProcessType must be configured, this is unexpected");
 
    QuantLib::ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, tradeStrike_.value()));
 
    auto index = parseIndex(indexName());
 
    if (auto fxIndex = QuantLib::ext::dynamic_pointer_cast<QuantExt::FxIndex>(index)) {
        QL_REQUIRE(fxIndex->targetCurrency() == payCcy,
                   "FX domestic ccy " << fxIndex->targetCurrency() << " must match pay ccy " << payCcy);
        assetName_ = fxIndex->sourceCurrency().code();
    } else if (auto eqIndex = QuantLib::ext::dynamic_pointer_cast<QuantExt::EquityIndex2>(index)) {
        // FIXME for EQ and COMM indices check whether EQ, COMM ccy = payCcy (in the engine builders probably)
        assetName_ = eqIndex->name();
    } else if (auto commIndex = QuantLib::ext::dynamic_pointer_cast<QuantExt::CommodityIndex>(index)) {
        assetName_ = commIndex->underlyingName();
    }
 
    // FIXME the engine should handle the historical part of the averaging as well!
    QuantLib::ext::shared_ptr<QuantLib::Instrument> asian;
    auto exercise = QuantLib::ext::make_shared<QuantLib::EuropeanExercise>(expiryDate);
    if (processType == "Discrete") {
        QuantLib::Date today = engineFactory->market()->asofDate();
        Real runningAccumulator = option_.payoffType2() == "Geometric" ? 1.0 : 0.0;
        Size pastFixings = 0;
        Schedule observationSchedule = makeSchedule(observationDates_);
        std::vector<QuantLib::Date> observationDates = observationSchedule.dates();
 
        // Sort for the engine's sake. Not needed - instrument also sorts...?
        std::sort(observationDates.begin(), observationDates.end());
 
        for (QuantLib::Date observationDate : observationDates) {
            // TODO: Verify. Should today be read too? a enforcesTodaysHistoricFixings() be used?
            if (observationDate < today ||
                (observationDate == today && Settings::instance().enforcesTodaysHistoricFixings())) {
                // FIXME all observation dates lead to a required fixing
                requiredFixings_.addFixingDate(observationDate, indexName());
                Real fixingValue = index->fixing(observationDate);
                if (option_.payoffType2() == "Geometric") {
                    runningAccumulator *= fixingValue;
                } else if (option_.payoffType2() == "Arithmetic") {
                    runningAccumulator += fixingValue;
                }
                ++pastFixings;
            }
        }
        asian = QuantLib::ext::make_shared<QuantLib::DiscreteAveragingAsianOption>(
            option_.payoffType2() == "Geometric" ? QuantLib::Average::Type::Geometric
                                                 : QuantLib::Average::Type::Arithmetic,
            runningAccumulator, pastFixings, observationDates, payoff, exercise);
    } else if (processType == "Continuous") {
        // FIXME how is the accumulated average handled in this case?
        asian = QuantLib::ext::make_shared<QuantLib::ContinuousAveragingAsianOption>(option_.payoffType2() == "Geometric"
                                                                                 ? QuantLib::Average::Type::Geometric
                                                                                 : QuantLib::Average::Type::Arithmetic,
                                                                             payoff, exercise);
    } else {
        QL_FAIL("unexpected ProcessType, valid options are Discrete/Continuous");
    }
 
    // Only try to set an engine on the option instrument if it is not expired. This avoids errors in
    // engine builders that rely on the expiry date being in the future.
    string configuration = asianOptionBuilder->configuration(MarketContext::pricing);
    if (!asian->isExpired()) {
        asian->setPricingEngine(asianOptionBuilder->engine(assetName_, payCcy, expiryDate));
        setSensitivityTemplate(*asianOptionBuilder);
    } else {
        DLOG("No engine attached for option on trade " << id() << " with expiry date " << io::iso_date(expiryDate)
                                                       << " because it is expired.");
    }
 
    Position::Type positionType = parsePositionType(option_.longShort());
    Real bsInd = (positionType == QuantLib::Position::Long ? 1.0 : -1.0);
    Real mult = quantity_ * bsInd;
 
    std::vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    std::vector<Real> additionalMultipliers;
    maturity_ = expiryDate;
    maturity_ =
        std::max(maturity_, addPremiums(additionalInstruments, additionalMultipliers, mult, option_.premiumData(),
                                        positionType == QuantLib::Position::Long ? -1.0 : 1.0, payCcy, engineFactory,
                                        configuration));
 
    instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(asian, mult, additionalInstruments, additionalMultipliers);
 
    npvCurrency_ = currency_;
    notional_ = tradeStrike_.value() * quantity_;
    notionalCurrency_ = currency_;
}

Here is the call graph for this function:

◆ notional()

QuantLib::Real notional ( ) const

overridevirtual

Trade interface.

Reimplemented from Trade.

Definition at line 306 of file asianoption.cpp.

                                         {
    return delegatingBuilderTrade_ != nullptr ? delegatingBuilderTrade_->notional() : Trade::notional();
}

Here is the call graph for this function:

◆ notionalCurrency()

string notionalCurrency ( ) const

overridevirtual

Reimplemented from Trade.

Definition at line 310 of file asianoption.cpp.

                                           {
    return delegatingBuilderTrade_ != nullptr ? delegatingBuilderTrade_->notionalCurrency() : Trade::notionalCurrency();
}

Here is the call graph for this function:

◆ fromXML()

void fromXML ( XMLNode * node )

overridevirtual

Reimplemented from Trade.

Definition at line 207 of file asianoption.cpp.

                                       {
    Trade::fromXML(node);
    XMLNode* n = XMLUtils::getChildNode(node, tradeType() + "Data");
    QL_REQUIRE(n, "No " + tradeType_ + "Data node found.");
 
    quantity_ = XMLUtils::getChildValueAsDouble(n, "Quantity", true);
 
    tradeStrike_.fromXML(n);
 
    currency_ = XMLUtils::getChildValue(n, "Currency", false);
 
    XMLNode* tmp = XMLUtils::getChildNode(n, "Underlying");
    if (!tmp)
        tmp = XMLUtils::getChildNode(n, "Name");
    UnderlyingBuilder underlyingBuilder;
    underlyingBuilder.fromXML(tmp);
    underlying_ = underlyingBuilder.underlying();
 
    option_.fromXML(XMLUtils::getChildNode(n, "OptionData"));
 
    settlementDate_ = parseDate(XMLUtils::getChildValue(n, "Settlement", false));
 
    observationDates_.fromXML(XMLUtils::getChildNode(n, "ObservationDates"));
}

Here is the call graph for this function:

◆ toXML()

XMLNode * toXML ( XMLDocument & doc ) const

overridevirtual

Reimplemented from Trade.

Definition at line 232 of file asianoption.cpp.

                                                  {
    XMLNode* node = Trade::toXML(doc);
    XMLNode* n = doc.allocNode(tradeType() + "Data");
    XMLUtils::appendNode(node, n);
    XMLUtils::addChild(doc, n, "Quantity", quantity_);
    XMLUtils::appendNode(n, tradeStrike_.toXML(doc));
    XMLUtils::addChild(doc, n, "Currency", currency_);
    XMLUtils::appendNode(n, underlying_->toXML(doc));
    XMLUtils::appendNode(n, option_.toXML(doc));
    if (settlementDate_ != Null<Date>())
        XMLUtils::addChild(doc, n, "Settlement", ore::data::to_string(settlementDate_));
    auto tmp = observationDates_.toXML(doc);
    XMLUtils::setNodeName(doc, tmp, "ObservationDates");
    XMLUtils::appendNode(n, tmp);
    return node;
}

Here is the call graph for this function:

◆ asset()

const string & asset ( ) const

Definition at line 66 of file asianoption.hpp.

66{ return assetName_; } // only available after build()

◆ strike()

const TradeStrike & strike ( ) const

Definition at line 67 of file asianoption.hpp.

67{ return tradeStrike_; }

◆ quantity()

double quantity ( ) const

Definition at line 68 of file asianoption.hpp.

68{ return quantity_; }

◆ option()

const OptionData & option ( ) const

Definition at line 69 of file asianoption.hpp.

69{ return option_; }

◆ observationDates()

const ScheduleData & observationDates ( ) const

Definition at line 70 of file asianoption.hpp.

70{ return observationDates_; }

Here is the caller graph for this function:

◆ settlementDate()

const Date & settlementDate ( ) const

Definition at line 71 of file asianoption.hpp.

71{ return settlementDate_; }

◆ payCurrency()

const string & payCurrency ( ) const

Definition at line 72 of file asianoption.hpp.

72{ return currency_; }

◆ indexName()

const string & indexName ( ) const

Definition at line 73 of file asianoption.hpp.

                                    {
        populateIndexName();
        return indexName_;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ underlying()

const QuantLib::ext::shared_ptr< Underlying > & underlying ( ) const

Definition at line 77 of file asianoption.hpp.

77{ return underlying_; }

◆ underlyingIndices()

std::map< AssetClass, std::set< std::string > > underlyingIndices ( const QuantLib::ext::shared_ptr< ReferenceDataManager > & referenceDataManager = nullptr ) const

overridevirtual

Reimplemented from Trade.

Definition at line 250 of file asianoption.cpp.

                                                                                                            {
    std::map<AssetClass, std::set<std::string>> result;
    if (isEquityIndex(indexName())) {
        result[AssetClass::EQ].insert(indexName());
    } else if (isFxIndex(indexName_)) {
        result[AssetClass::FX].insert(indexName());
    } else if (isCommodityIndex(indexName_)) {
        result[AssetClass::COM].insert(indexName());
    }
    return result;
}

Here is the call graph for this function:

◆ populateIndexName()

void populateIndexName ( ) const

protected

Definition at line 262 of file asianoption.cpp.

                                          {
    if (!indexName_.empty())
        return;
    if (underlying_->type() == "Equity") {
        indexName_ = "EQ-" + underlying_->name();
    } else if (underlying_->type() == "FX") {
        indexName_ = "FX-" + underlying_->name();
    } else if (underlying_->type() == "Commodity") {
        QuantLib::ext::shared_ptr<CommodityUnderlying> comUnderlying =
            QuantLib::ext::dynamic_pointer_cast<CommodityUnderlying>(underlying_);
        std::string tmp = "COMM-" + comUnderlying->name();
        if (comUnderlying->priceType().empty() || comUnderlying->priceType() == "Spot") {
            indexName_ = tmp;
        } else if (comUnderlying->priceType() == "FutureSettlement") {
            auto conventions = InstrumentConventions::instance().conventions();
            QL_REQUIRE(conventions->has(comUnderlying->name()),
                       "future settlement requires conventions for commodity '" << comUnderlying->name() << "'");
            auto convention =
                QuantLib::ext::dynamic_pointer_cast<CommodityFutureConvention>(conventions->get(comUnderlying->name()));
            Size futureMonthsOffset =
                comUnderlying->futureMonthOffset() == Null<Size>() ? 0 : comUnderlying->futureMonthOffset();
            Size deliveryRollDays =
                comUnderlying->deliveryRollDays() == Null<Size>() ? 0 : comUnderlying->deliveryRollDays();
            Calendar cal = parseCalendar(comUnderlying->deliveryRollCalendar());
            ConventionsBasedFutureExpiry expiryCalculator(*convention);
            QL_REQUIRE(option_.exerciseDates().size() == 1, "expected exactly one exercise date");
            Date expiryDate = parseDate(option_.exerciseDates().front());
            Date adjustedObsDate =
                deliveryRollDays != 0 ? cal.advance(expiryDate, deliveryRollDays * Days) : expiryDate;
            auto tmp = parseCommodityIndex(comUnderlying->name(), false, Handle<QuantExt::PriceTermStructure>(),
                                           convention->calendar(), true);
            tmp = tmp->clone(expiryCalculator.nextExpiry(true, adjustedObsDate, futureMonthsOffset));
            indexName_ = tmp->name();
        } else {
            QL_FAIL("underlying price type '" << comUnderlying->priceType() << "' for commodity underlying '"
                                              << comUnderlying->name() << "' not handled.");
        }
    } else if (underlying_->type() == "Basic") {
        indexName_ = underlying_->name();
    } else {
        QL_FAIL("invalid underlying type: " << underlying_->type());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ quantity_

double quantity_ = 0.0

protected

Definition at line 87 of file asianoption.hpp.

◆ tradeStrike_

TradeStrike tradeStrike_

protected

Definition at line 88 of file asianoption.hpp.

◆ option_

OptionData option_

protected

Definition at line 89 of file asianoption.hpp.

◆ observationDates_

ScheduleData observationDates_

protected

Definition at line 90 of file asianoption.hpp.

◆ underlying_

QuantLib::ext::shared_ptr<Underlying> underlying_

protected

Definition at line 91 of file asianoption.hpp.

◆ settlementDate_

Date settlementDate_

protected

Definition at line 92 of file asianoption.hpp.

◆ currency_

string currency_

protected

Definition at line 94 of file asianoption.hpp.

◆ assetName_

string assetName_

protected

Definition at line 95 of file asianoption.hpp.

◆ delegatingBuilderTrade_

QuantLib::ext::shared_ptr<Trade> delegatingBuilderTrade_

protected

Definition at line 97 of file asianoption.hpp.

◆ indexName_

string indexName_

mutableprotected

Definition at line 99 of file asianoption.hpp.

Public Member Functions

Inspectors

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ AsianOption() [1/2]

◆ AsianOption() [2/2]

Member Function Documentation

◆ build()

◆ notional()

◆ notionalCurrency()

◆ fromXML()

◆ toXML()

◆ asset()

◆ strike()

◆ quantity()

◆ option()

◆ observationDates()

◆ settlementDate()

◆ payCurrency()

◆ indexName()

◆ underlying()

◆ underlyingIndices()

◆ populateIndexName()

Member Data Documentation

◆ quantity_

◆ tradeStrike_

◆ option_

◆ observationDates_

◆ underlying_

◆ settlementDate_

◆ currency_

◆ assetName_

◆ delegatingBuilderTrade_

◆ indexName_