#include <ored/portfolio/commoditydigitalapo.hpp>

Inheritance diagram for CommodityDigitalAveragePriceOption:

Collaboration diagram for CommodityDigitalAveragePriceOption:

Public Member Functions
	CommodityDigitalAveragePriceOption ()

	CommodityDigitalAveragePriceOption (const ore::data::Envelope &envelope, const ore::data::OptionData &optionData, QuantLib::Real strike, QuantLib::Real digitalCashPayoff, const std::string &currency, const std::string &name, CommodityPriceType priceType, const std::string &startDate, const std::string &endDate, const std::string &paymentCalendar, const std::string &paymentLag, const std::string &paymentConvention, const std::string &pricingCalendar, const std::string &paymentDate="", QuantLib::Real gearing=1.0, QuantLib::Spread spread=0.0, QuantExt::CommodityQuantityFrequency commodityQuantityFrequency=QuantExt::CommodityQuantityFrequency::PerCalculationPeriod, CommodityPayRelativeTo commodityPayRelativeTo=CommodityPayRelativeTo::CalculationPeriodEndDate, QuantLib::Natural futureMonthOffset=0, QuantLib::Natural deliveryRollDays=0, bool includePeriodEnd=true, const BarrierData &barrierData={}, const std::string &fxIndex="")

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

std::map< AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager=nullptr) const override
	Add underlying Commodity names. More...

Inspectors
const ore::data::OptionData &	optionData ()

const ore::data::BarrierData &	barrierData ()

QuantLib::Real	strike () const

QuantLib::Real	digitalCashPayoff () const

const std::string &	currency () const

const std::string &	name () const

CommodityPriceType	priceType () const

const std::string &	startDate () const

const std::string &	endDate () const

const std::string &	paymentCalendar () const

const std::string &	paymentLag () const

const std::string &	paymentConvention () const

const std::string &	pricingCalendar () const

const std::string &	paymentDate () const

QuantLib::Real	gearing () const

QuantLib::Spread	spread () const

QuantExt::CommodityQuantityFrequency	commodityQuantityFrequency () const

CommodityPayRelativeTo	commodityPayRelativeTo () const

QuantLib::Natural	futureMonthOffset () const

QuantLib::Natural	deliveryRollDays () const

bool	includePeriodEnd () const

const std::string &	fxIndex () const

Serialisation
virtual void	fromXML (ore::data::XMLNode *node) override

virtual ore::data::XMLNode *	toXML (ore::data::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

virtual QuantLib::Real	notional () const
	Return the current notional in npvCurrency. See individual sub-classes for the precise definition. More...

virtual string	notionalCurrency () 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...

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...

Trade
ore::data::OptionData	optionData_

ore::data::BarrierData	barrierData_

QuantLib::Real	strike_

QuantLib::Real	digitalCashPayoff_

std::string	currency_

std::string	name_

CommodityPriceType	priceType_

std::string	startDate_

std::string	endDate_

std::string	paymentCalendar_

std::string	paymentLag_

std::string	paymentConvention_

std::string	pricingCalendar_

std::string	paymentDate_

QuantLib::Real	gearing_

QuantLib::Spread	spread_

QuantExt::CommodityQuantityFrequency	commodityQuantityFrequency_

CommodityPayRelativeTo	commodityPayRelativeTo_

QuantLib::Natural	futureMonthOffset_

QuantLib::Natural	deliveryRollDays_

bool	includePeriodEnd_

std::string	fxIndex_

bool	hasCashflows () const override

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 Commodity Average Price Option

Definition at line 38 of file commoditydigitalapo.hpp.

Constructor & Destructor Documentation

◆ CommodityDigitalAveragePriceOption() [1/2]

CommodityDigitalAveragePriceOption ( )

Definition at line 40 of file commoditydigitalapo.hpp.

40: ore::data::Trade("CommodityDigitalAveragePriceOption") {}

ore::data::Trade

Trade base class.

Definition: trade.hpp:55

◆ CommodityDigitalAveragePriceOption() [2/2]

CommodityDigitalAveragePriceOption	(	const ore::data::Envelope &	envelope,
		const ore::data::OptionData &	optionData,
		QuantLib::Real	strike,
		QuantLib::Real	digitalCashPayoff,
		const std::string &	currency,
		const std::string &	name,
		CommodityPriceType	priceType,
		const std::string &	startDate,
		const std::string &	endDate,
		const std::string &	paymentCalendar,
		const std::string &	paymentLag,
		const std::string &	paymentConvention,
		const std::string &	pricingCalendar,
		const std::string &	paymentDate = `""`,
		QuantLib::Real	gearing = `1.0`,
		QuantLib::Spread	spread = `0.0`,
		QuantExt::CommodityQuantityFrequency	commodityQuantityFrequency = `QuantExt::CommodityQuantityFrequency::PerCalculationPeriod`,
		CommodityPayRelativeTo	commodityPayRelativeTo = `CommodityPayRelativeTo::CalculationPeriodEndDate`,
		QuantLib::Natural	futureMonthOffset = `0`,
		QuantLib::Natural	deliveryRollDays = `0`,
		bool	includePeriodEnd = `true`,
		const BarrierData &	barrierData = `{}`,
		const std::string &	fxIndex = `""`
	)

Member Function Documentation

◆ build()

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

override

Definition at line 54 of file commoditydigitalapo.cpp.

                                                                                                        {
 
    reset();
 
    DLOG("CommodityDigitalAveragePriceOption::build() called for trade " << id());
    
    // ISDA taxonomy, assuming Commodity follows the Equity template
    additionalData_["isdaAssetClass"] = std::string("Commodity");
    additionalData_["isdaBaseProduct"] = std::string("Option");
    additionalData_["isdaSubProduct"] = std::string("Price Return Basic Performance");
    // skip the transaction level mapping for now
    additionalData_["isdaTransaction"] = std::string("");
 
    QL_REQUIRE(optionData_.exerciseDates().size() == 1, "Invalid number of excercise dates");
    Date exDate = parseDate(optionData_.exerciseDates().front());
 
 
    Real strikeSpread = strike_ * 0.01; // FIXME, what is a usual spread here, and where should we put it?
    Real strike1 = strike_ - strikeSpread / 2;
    Real strike2 = strike_ + strikeSpread / 2;
    CommodityAveragePriceOption opt1(
        envelope(), optionData_, 1.0, strike1, currency_, name_, priceType_, startDate_, endDate_, paymentCalendar_,
        paymentLag_, paymentConvention_, pricingCalendar_, paymentDate_, gearing_, spread_, commodityQuantityFrequency_,
        commodityPayRelativeTo_, futureMonthOffset_, deliveryRollDays_, includePeriodEnd_, barrierData_, fxIndex_);
    
    CommodityAveragePriceOption opt2(envelope(), optionData_, 1.0, strike2, currency_, name_, priceType_,
                                     startDate_, endDate_, paymentCalendar_,
        paymentLag_, paymentConvention_, pricingCalendar_, paymentDate_, gearing_, spread_, commodityQuantityFrequency_,
        commodityPayRelativeTo_, futureMonthOffset_, deliveryRollDays_, includePeriodEnd_, barrierData_, fxIndex_);
 
    opt1.build(engineFactory);
    opt2.build(engineFactory);
 
    setSensitivityTemplate(opt1.sensitivityTemplate());
 
    QuantLib::ext::shared_ptr<Instrument> inst1 = opt1.instrument()->qlInstrument();
    QuantLib::ext::shared_ptr<Instrument> inst2 = opt2.instrument()->qlInstrument();
 
    QuantLib::ext::shared_ptr<CompositeInstrument> composite = QuantLib::ext::make_shared<CompositeInstrument>();
    // add and subtract such that the long call spread and long put spread have positive values
    if (optionData_.callPut() == "Call") {
        composite->add(inst1);
        composite->subtract(inst2);
    } else if (optionData_.callPut() == "Put") {
        composite->add(inst2);
        composite->subtract(inst1);
    } else {
        QL_FAIL("OptionType Call or Put required in CommodityDigitalOption " << id());
    }
 
    Position::Type positionType = parsePositionType(optionData_.longShort());
    Real bsIndicator = (positionType == QuantLib::Position::Long ? 1.0 : -1.0);
    Real multiplier = digitalCashPayoff_ * bsIndicator / strikeSpread;
    std::vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    std::vector<Real> additionalMultipliers;
    // FIXME: Do we need to retrieve the engine builder's configuration
    string configuration = Market::defaultConfiguration;
    Currency ccy = parseCurrencyWithMinors(currency_);
    
    maturity_ =
        std::max(exDate, addPremiums(additionalInstruments, additionalMultipliers, multiplier,
                                          optionData_.premiumData(), -bsIndicator, ccy, engineFactory, configuration));
 
    instrument_ = QuantLib::ext::shared_ptr<InstrumentWrapper>(
        new VanillaInstrument(composite, multiplier, additionalInstruments, additionalMultipliers));
 
    npvCurrency_ = currency_;
    notional_ = digitalCashPayoff_;
    notionalCurrency_ = currency_;
 
    // LOG the volatility if the trade expiry date is in the future.
    if (exDate > Settings::instance().evaluationDate()) {
        DLOG("Implied vol for " << tradeType_ << " on " << name_ << " with expiry " << exDate << " and strike "
                                << strike_ << " is "
                                << engineFactory->market()->commodityVolatility(name_)->blackVol(exDate, strike_));
    }
 
    additionalData_["payoff"] = digitalCashPayoff_;
    additionalData_["strike"] = strike_;
    additionalData_["optionType"] = optionData_.callPut();
    additionalData_["strikeCurrency"] = currency_;
}

Here is the call graph for this function:

◆ underlyingIndices()

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

overridevirtual

Add underlying Commodity names.

Reimplemented from Trade.

Definition at line 137 of file commoditydigitalapo.cpp.

                                                                                   {
    return {{AssetClass::COM, std::set<std::string>({name_})}};
}

◆ optionData()

const ore::data::OptionData & optionData ( )

Definition at line 63 of file commoditydigitalapo.hpp.

63{ return optionData_; }

◆ barrierData()

const ore::data::BarrierData & barrierData ( )

Definition at line 64 of file commoditydigitalapo.hpp.

64{ return barrierData_; }

◆ strike()

QuantLib::Real strike ( ) const

Definition at line 65 of file commoditydigitalapo.hpp.

65{ return strike_; }

◆ digitalCashPayoff()

QuantLib::Real digitalCashPayoff ( ) const

Definition at line 66 of file commoditydigitalapo.hpp.

66{ return digitalCashPayoff_; }

◆ currency()

const std::string & currency ( ) const

Definition at line 67 of file commoditydigitalapo.hpp.

67{ return currency_; }

◆ name()

const std::string & name ( ) const

Definition at line 68 of file commoditydigitalapo.hpp.

68{ return name_; }

◆ priceType()

CommodityPriceType priceType ( ) const

Definition at line 69 of file commoditydigitalapo.hpp.

69{ return priceType_; }

◆ startDate()

const std::string & startDate ( ) const

Definition at line 70 of file commoditydigitalapo.hpp.

70{ return startDate_; }

◆ endDate()

const std::string & endDate ( ) const

Definition at line 71 of file commoditydigitalapo.hpp.

71{ return endDate_; }

◆ paymentCalendar()

const std::string & paymentCalendar ( ) const

Definition at line 72 of file commoditydigitalapo.hpp.

72{ return paymentCalendar_; }

◆ paymentLag()

const std::string & paymentLag ( ) const

Definition at line 73 of file commoditydigitalapo.hpp.

73{ return paymentLag_; }

◆ paymentConvention()

const std::string & paymentConvention ( ) const

Definition at line 74 of file commoditydigitalapo.hpp.

74{ return paymentConvention_; }

◆ pricingCalendar()

const std::string & pricingCalendar ( ) const

Definition at line 75 of file commoditydigitalapo.hpp.

75{ return pricingCalendar_; }

◆ paymentDate()

const std::string & paymentDate ( ) const

Definition at line 76 of file commoditydigitalapo.hpp.

76{ return paymentDate_; }

◆ gearing()

QuantLib::Real gearing ( ) const

Definition at line 77 of file commoditydigitalapo.hpp.

77{ return gearing_; }

◆ spread()

QuantLib::Spread spread ( ) const

Definition at line 78 of file commoditydigitalapo.hpp.

78{ return spread_; }

◆ commodityQuantityFrequency()

QuantExt::CommodityQuantityFrequency commodityQuantityFrequency ( ) const

Definition at line 79 of file commoditydigitalapo.hpp.

79{ return commodityQuantityFrequency_; }

◆ commodityPayRelativeTo()

CommodityPayRelativeTo commodityPayRelativeTo ( ) const

Definition at line 80 of file commoditydigitalapo.hpp.

80{ return commodityPayRelativeTo_; }

◆ futureMonthOffset()

QuantLib::Natural futureMonthOffset ( ) const

Definition at line 81 of file commoditydigitalapo.hpp.

81{ return futureMonthOffset_; }

◆ deliveryRollDays()

QuantLib::Natural deliveryRollDays ( ) const

Definition at line 82 of file commoditydigitalapo.hpp.

82{ return deliveryRollDays_; }

◆ includePeriodEnd()

bool includePeriodEnd ( ) const

Definition at line 83 of file commoditydigitalapo.hpp.

83{ return includePeriodEnd_; }

◆ fxIndex()

const std::string & fxIndex ( ) const

Definition at line 84 of file commoditydigitalapo.hpp.

84{ return fxIndex_; }

◆ fromXML()

void fromXML ( ore::data::XMLNode * node )

overridevirtual

Reimplemented from Trade.

Definition at line 142 of file commoditydigitalapo.cpp.

                                                              {
 
    Trade::fromXML(node);
 
    XMLNode* apoNode = XMLUtils::getChildNode(node, "CommodityDigitalAveragePriceOptionData");
    QL_REQUIRE(apoNode, "No CommodityDigitalAveragePriceOptionData Node");
 
    optionData_.fromXML(XMLUtils::getChildNode(apoNode, "OptionData"));
    if(auto b = XMLUtils::getChildNode(apoNode, "BarrierData")) {
        barrierData_.fromXML(b);
    }
    name_ = XMLUtils::getChildValue(apoNode, "Name", true);
    currency_ = XMLUtils::getChildValue(apoNode, "Currency", true);
    strike_ = XMLUtils::getChildValueAsDouble(apoNode, "Strike", true);
    digitalCashPayoff_ = XMLUtils::getChildValueAsDouble(apoNode, "DigitalCashPayoff", true);
    priceType_ = parseCommodityPriceType(XMLUtils::getChildValue(apoNode, "PriceType", true));
    startDate_ = XMLUtils::getChildValue(apoNode, "StartDate", true);
    endDate_ = XMLUtils::getChildValue(apoNode, "EndDate", true);
    paymentCalendar_ = XMLUtils::getChildValue(apoNode, "PaymentCalendar", true);
    paymentLag_ = XMLUtils::getChildValue(apoNode, "PaymentLag", true);
    paymentConvention_ = XMLUtils::getChildValue(apoNode, "PaymentConvention", true);
    pricingCalendar_ = XMLUtils::getChildValue(apoNode, "PricingCalendar", true);
 
    paymentDate_ = XMLUtils::getChildValue(apoNode, "PaymentDate", false);
 
    gearing_ = 1.0;
    if (XMLNode* n = XMLUtils::getChildNode(apoNode, "Gearing")) {
        gearing_ = parseReal(XMLUtils::getNodeValue(n));
    }
 
    spread_ = XMLUtils::getChildValueAsDouble(apoNode, "Spread", false);
 
    commodityQuantityFrequency_ = CommodityQuantityFrequency::PerCalculationPeriod;
    if (XMLNode* n = XMLUtils::getChildNode(apoNode, "CommodityQuantityFrequency")) {
        commodityQuantityFrequency_ = parseCommodityQuantityFrequency(XMLUtils::getNodeValue(n));
    }
 
    commodityPayRelativeTo_ = CommodityPayRelativeTo::CalculationPeriodEndDate;
    if (XMLNode* n = XMLUtils::getChildNode(apoNode, "CommodityPayRelativeTo")) {
        commodityPayRelativeTo_ = parseCommodityPayRelativeTo(XMLUtils::getNodeValue(n));
    }
 
    futureMonthOffset_ = XMLUtils::getChildValueAsInt(apoNode, "FutureMonthOffset", false);
    deliveryRollDays_ = XMLUtils::getChildValueAsInt(apoNode, "DeliveryRollDays", false);
 
    includePeriodEnd_ = true;
    if (XMLNode* n = XMLUtils::getChildNode(apoNode, "IncludePeriodEnd")) {
        includePeriodEnd_ = parseBool(XMLUtils::getNodeValue(n));
    }
 
    if (XMLNode* n = XMLUtils::getChildNode(apoNode, "FXIndex")){
        fxIndex_ = XMLUtils::getNodeValue(n);
    }
}

Here is the call graph for this function:

◆ toXML()

XMLNode * toXML ( ore::data::XMLDocument & doc ) const

overridevirtual

Reimplemented from Trade.

Definition at line 197 of file commoditydigitalapo.cpp.

                                                                         {
 
    XMLNode* node = Trade::toXML(doc);
 
    XMLNode* apoNode = doc.allocNode("CommodityDigitalAveragePriceOptionData");
    XMLUtils::appendNode(node, apoNode);
 
    XMLUtils::appendNode(apoNode, optionData_.toXML(doc));
    if (barrierData_.initialized())
        XMLUtils::appendNode(apoNode, barrierData_.toXML(doc));
    XMLUtils::addChild(doc, apoNode, "Name", name_);
    XMLUtils::addChild(doc, apoNode, "Currency", currency_);
    XMLUtils::addChild(doc, apoNode, "Strike", strike_);
    XMLUtils::addChild(doc, apoNode, "DigitalCashPayoff", digitalCashPayoff_);
    XMLUtils::addChild(doc, apoNode, "PriceType", to_string(priceType_));
    XMLUtils::addChild(doc, apoNode, "StartDate", startDate_);
    XMLUtils::addChild(doc, apoNode, "EndDate", endDate_);
    XMLUtils::addChild(doc, apoNode, "PaymentCalendar", paymentCalendar_);
    XMLUtils::addChild(doc, apoNode, "PaymentLag", paymentLag_);
    XMLUtils::addChild(doc, apoNode, "PaymentConvention", paymentConvention_);
    XMLUtils::addChild(doc, apoNode, "PricingCalendar", pricingCalendar_);
    XMLUtils::addChild(doc, apoNode, "PaymentDate", paymentDate_);
    XMLUtils::addChild(doc, apoNode, "Gearing", gearing_);
    XMLUtils::addChild(doc, apoNode, "Spread", spread_);
    XMLUtils::addChild(doc, apoNode, "CommodityQuantityFrequency", to_string(commodityQuantityFrequency_));
    XMLUtils::addChild(doc, apoNode, "CommodityPayRelativeTo", to_string(commodityPayRelativeTo_));
    XMLUtils::addChild(doc, apoNode, "FutureMonthOffset", static_cast<int>(futureMonthOffset_));
    XMLUtils::addChild(doc, apoNode, "DeliveryRollDays", static_cast<int>(deliveryRollDays_));
    XMLUtils::addChild(doc, apoNode, "IncludePeriodEnd", includePeriodEnd_);
    if(!fxIndex_.empty()){
        XMLUtils::addChild(doc, apoNode, "FXIndex", fxIndex_);
    }
 
    return node;
}

Here is the call graph for this function:

◆ hasCashflows()

bool hasCashflows ( ) const

overridevirtual

Utility method indicating if the trade has cashflows for the cashflow report. The default implementation returns true so that a trade is automatically considered when cashflows are being written. To prevent a trade from being asked for its cashflows, the method can be overridden to return false.

Reimplemented from Trade.

Definition at line 95 of file commoditydigitalapo.hpp.

95{ return false; }

Member Data Documentation

◆ optionData_

ore::data::OptionData optionData_

private

Definition at line 99 of file commoditydigitalapo.hpp.

◆ barrierData_

ore::data::BarrierData barrierData_

private

Definition at line 100 of file commoditydigitalapo.hpp.

◆ strike_

QuantLib::Real strike_

private

Definition at line 101 of file commoditydigitalapo.hpp.

◆ digitalCashPayoff_

QuantLib::Real digitalCashPayoff_

private

Definition at line 102 of file commoditydigitalapo.hpp.

◆ currency_

std::string currency_

private

Definition at line 103 of file commoditydigitalapo.hpp.

◆ name_

std::string name_

private

Definition at line 104 of file commoditydigitalapo.hpp.

◆ priceType_

CommodityPriceType priceType_

private

Definition at line 105 of file commoditydigitalapo.hpp.

◆ startDate_

std::string startDate_

private

Definition at line 106 of file commoditydigitalapo.hpp.

◆ endDate_

std::string endDate_

private

Definition at line 107 of file commoditydigitalapo.hpp.

◆ paymentCalendar_

std::string paymentCalendar_

private

Definition at line 108 of file commoditydigitalapo.hpp.

◆ paymentLag_

std::string paymentLag_

private

Definition at line 109 of file commoditydigitalapo.hpp.

◆ paymentConvention_

std::string paymentConvention_

private

Definition at line 110 of file commoditydigitalapo.hpp.

◆ pricingCalendar_

std::string pricingCalendar_

private

Definition at line 111 of file commoditydigitalapo.hpp.

◆ paymentDate_

std::string paymentDate_

private

Definition at line 112 of file commoditydigitalapo.hpp.

◆ gearing_

QuantLib::Real gearing_

private

Definition at line 113 of file commoditydigitalapo.hpp.

◆ spread_

QuantLib::Spread spread_

private

Definition at line 114 of file commoditydigitalapo.hpp.

◆ commodityQuantityFrequency_

QuantExt::CommodityQuantityFrequency commodityQuantityFrequency_

private

Definition at line 115 of file commoditydigitalapo.hpp.

◆ commodityPayRelativeTo_

CommodityPayRelativeTo commodityPayRelativeTo_

private

Definition at line 116 of file commoditydigitalapo.hpp.

◆ futureMonthOffset_

QuantLib::Natural futureMonthOffset_

private

Definition at line 117 of file commoditydigitalapo.hpp.

◆ deliveryRollDays_

QuantLib::Natural deliveryRollDays_

private

Definition at line 118 of file commoditydigitalapo.hpp.

◆ includePeriodEnd_

bool includePeriodEnd_

private

Definition at line 119 of file commoditydigitalapo.hpp.

◆ fxIndex_

std::string fxIndex_

private

Definition at line 120 of file commoditydigitalapo.hpp.

Public Member Functions

Trade

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CommodityDigitalAveragePriceOption() [1/2]

◆ CommodityDigitalAveragePriceOption() [2/2]

Member Function Documentation

◆ build()

◆ underlyingIndices()

◆ optionData()

◆ barrierData()

◆ strike()

◆ digitalCashPayoff()

◆ currency()

◆ name()

◆ priceType()

◆ startDate()

◆ endDate()

◆ paymentCalendar()

◆ paymentLag()

◆ paymentConvention()

◆ pricingCalendar()

◆ paymentDate()

◆ gearing()

◆ spread()

◆ commodityQuantityFrequency()

◆ commodityPayRelativeTo()

◆ futureMonthOffset()

◆ deliveryRollDays()

◆ includePeriodEnd()

◆ fxIndex()

◆ fromXML()

◆ toXML()

◆ hasCashflows()

Member Data Documentation

◆ optionData_

◆ barrierData_

◆ strike_

◆ digitalCashPayoff_

◆ currency_

◆ name_

◆ priceType_

◆ startDate_

◆ endDate_

◆ paymentCalendar_

◆ paymentLag_

◆ paymentConvention_

◆ pricingCalendar_

◆ paymentDate_

◆ gearing_

◆ spread_

◆ commodityQuantityFrequency_

◆ commodityPayRelativeTo_

◆ futureMonthOffset_

◆ deliveryRollDays_

◆ includePeriodEnd_

◆ fxIndex_