git subrepo pull (merge) ore

subrepo:
  subdir:   "ore"
  merged:   "114603f2b4"
upstream:
  origin:   "git@gitlab.acadiasoft.net:qs/ore.git"
  branch:   "master"
  commit:   "868dbf458e"
git-subrepo:
  version:  "0.4.6"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "73a0129"

Author: jenkins

OREData/ored/configuration/equitycurveconfig.cpp

@@ -143,16 +143,5 @@ EquityCurveConfig::Type parseEquityCurveConfigType(const std::string& str) {
     QL_FAIL("Invalid EquityCurveConfig::Type " << str);
 }
 
-std::ostream& operator<<(std::ostream& out, Exercise::Type t) {
-    switch (t) {
-    case Exercise::American:
-        return out << "American";
-    case Exercise::European:
-        return out << "European";
-    default:
-        QL_FAIL("invalid Exercise::Type(" << int(t) << ")");
-    }
-}
-
 } // namespace data
 } // namespace ore

OREData/ored/configuration/equitycurveconfig.hpp

@@ -118,7 +118,6 @@ class EquityCurveConfig : public CurveConfig {
 };
 
 std::ostream& operator<<(std::ostream& out, EquityCurveConfig::Type t);
-std::ostream& operator<<(std::ostream& out, QuantLib::Exercise::Type t);
 
 EquityCurveConfig::Type parseEquityCurveConfigType(const std::string& str);
 

OREData/ored/configuration/volatilityconfig.cpp

@@ -46,7 +46,7 @@ void VolatilityConfig::fromXMLNode(XMLNode* node) {
 }
 
 void VolatilityConfig::toXMLNode(XMLDocument& doc, XMLNode* node) const {
-    XMLUtils::addAttribute(doc, node, "priority", to_string(priority_));
+    XMLUtils::addAttribute(doc, node, "priority", std::to_string(priority_));
     if (!calendarStr_.empty())
         XMLUtils::addChild(doc, node, "Calendar", calendarStr_);
 }
@@ -126,7 +126,7 @@ void QuoteBasedVolatilityConfig::toBaseNode(XMLDocument& doc, XMLNode* node) con
     // Check first for premium
     if (quoteType_ == MarketDatum::QuoteType::PRICE) {
         XMLUtils::addChild(doc, node, "QuoteType", "Premium");
-        XMLUtils::addChild(doc, node, "ExerciseType", to_string(exerciseType_));
+        XMLUtils::addChild(doc, node, "ExerciseType", ore::data::to_string(exerciseType_));
         return;
     }
 

OREData/ored/portfolio/barrieroption.cpp

@@ -73,6 +73,10 @@ void BarrierOption::build(const QuantLib::ext::shared_ptr<EngineFactory>& engine
     Real rebate = barrier_.rebate() / tradeMultiplier();
     QL_REQUIRE(rebate >= 0, "rebate must be non-negative");
 
+    
+    // set the maturity
+    maturity_ = std::max(option_.premiumData().latestPremiumDate(), payDate);
+
     // fx base
     // Payoff
     Option::Type type = parseOptionType(option_.callPut());
@@ -164,12 +168,8 @@ void BarrierOption::build(const QuantLib::ext::shared_ptr<EngineFactory>& engine
 
     // Add additional premium payments
     Real bsInd = (positionType == QuantLib::Position::Long ? 1.0 : -1.0);
-    Date lastPremiumDate =
-        addPremiums(additionalInstruments, additionalMultipliers, bsInd * tradeMultiplier(), option_.premiumData(),
-                    -bsInd, tradeCurrency(), engineFactory, engineFactory->configuration(MarketContext::pricing));
-
-    // set the maturity
-    maturity_ = std::max(lastPremiumDate, payDate);
+    addPremiums(additionalInstruments, additionalMultipliers, bsInd * tradeMultiplier(), option_.premiumData(), -bsInd,
+                tradeCurrency(), engineFactory, engineFactory->configuration(MarketContext::pricing));
 }
 
 
@@ -217,19 +217,22 @@ void FxOptionWithBarrier::build(const QuantLib::ext::shared_ptr<ore::data::Engin
     additionalData_["isdaSubProduct"] = string("Barrier");    
     additionalData_["isdaTransaction"] = string("");  
 
-    spotQuote_ = ef->market()->fxSpot(boughtCurrency_ + soldCurrency_);
-    fxIndex_ = ef->market()->fxIndex(indexFixingName(), ef->configuration(MarketContext::pricing)).currentLink();
+    additionalData_["boughAmount"] = boughtAmount_;
+    additionalData_["boughtCurrency"] = boughtCurrency_;
+    additionalData_["soldAmount"] = soldAmount_;
+    additionalData_["soldCurrency"] = soldCurrency_;
 
-    BarrierOption::build(ef); 
-    
     npvCurrency_ = soldCurrency_; // sold is the domestic
     notional_ = soldAmount_;
     notionalCurrency_ = soldCurrency_; // sold is the domestic
 
-    additionalData_["boughAmount"] = boughtAmount_;
-    additionalData_["boughtCurrency"] = boughtCurrency_;
-    additionalData_["soldAmount"] = soldAmount_;
-    additionalData_["soldCurrency"] = soldCurrency_;
+    QuantLib::Date expiryDate = parseDate(option().exerciseDates().front());
+    maturity_ = std::max(option().premiumData().latestPremiumDate(), expiryDate);
+
+    spotQuote_ = ef->market()->fxSpot(boughtCurrency_ + soldCurrency_);
+    fxIndex_ = ef->market()->fxIndex(indexFixingName(), ef->configuration(MarketContext::pricing)).currentLink();
+
+    BarrierOption::build(ef); 
 }
 
 void FxOptionWithBarrier::additionalFromXml(XMLNode* node) {
@@ -257,9 +260,12 @@ void EquityOptionWithBarrier::build(const QuantLib::ext::shared_ptr<ore::data::E
     additionalData_["isdaSubProduct"] = string("Price Return Basic Performance");  
     additionalData_["isdaTransaction"] = string("");  
 
-    eqIndex_ = ef->market()->equityCurve(equityName()).currentLink();
+    additionalData_["quantity"] = quantity_;
+    additionalData_["strike"] = tradeStrike_.value();
+    additionalData_["strikeCurrency"] = tradeStrike_.currency();
 
-    BarrierOption::build(ef);
+    QuantLib::Date expiryDate = parseDate(option().exerciseDates().front());
+    maturity_ = std::max(option().premiumData().latestPremiumDate(), expiryDate);
 
     if (tradeStrike_.currency().empty())
         tradeStrike_.setCurrency(currencyStr_);
@@ -271,9 +277,9 @@ void EquityOptionWithBarrier::build(const QuantLib::ext::shared_ptr<ore::data::E
     notional_ = tradeStrike_.value() * quantity_;
     notionalCurrency_ = parseCurrencyWithMinors(tradeStrike_.currency()).code();
 
-    additionalData_["quantity"] = quantity_;
-    additionalData_["strike"] = tradeStrike_.value();
-    additionalData_["strikeCurrency"] = tradeStrike_.currency();
+    eqIndex_ = ef->market()->equityCurve(equityName()).currentLink();
+
+    BarrierOption::build(ef);
 }
 
 void EquityOptionWithBarrier::additionalFromXml(XMLNode* node) {

OREData/ored/portfolio/bondoption.cpp

@@ -65,7 +65,17 @@ void BondOption::build(const QuantLib::ext::shared_ptr<EngineFactory>& engineFac
 
     // FIXME this won't work for zero bonds (but their implementation is incomplete anyhow, see bond.cpp)
     underlying_ = QuantLib::ext::make_shared<ore::data::Bond>(Envelope(), bondData_);
+
     underlying_->build(engineFactory);
+
+    legs_ = underlying_->legs();
+    legCurrencies_ = underlying_->legCurrencies();
+    legPayers_ = std::vector<bool>(legs_.size(), false); // always receive (long option view)
+    npvCurrency_ = underlying_->bondData().currency();
+    notional_ = underlying_->notional() * bondData_.bondNotional();
+    notionalCurrency_ = underlying_->bondData().currency();
+    maturity_ = std::max(optionData_.premiumData().latestPremiumDate(), underlying_->maturity());
+
     auto qlBondInstr = QuantLib::ext::dynamic_pointer_cast<QuantLib::Bond>(underlying_->instrument()->qlInstrument());
     QL_REQUIRE(qlBondInstr, "BondOption::build(): could not cast to QuantLib::Bond");
     for (auto const p : underlying_->legPayers()) {
@@ -126,20 +136,12 @@ void BondOption::build(const QuantLib::ext::shared_ptr<EngineFactory>& engineFac
 
     std::vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
     std::vector<Real> additionalMultipliers;
-    Date lastPremiumDate = addPremiums(additionalInstruments, additionalMultipliers, multiplier,
-                                       optionData_.premiumData(), multiplier > 0.0 ? -1.0 : 1.0, currency,
-                                       engineFactory, bondOptionBuilder->configuration(MarketContext::pricing));
+    addPremiums(additionalInstruments, additionalMultipliers, multiplier, optionData_.premiumData(),
+                multiplier > 0.0 ? -1.0 : 1.0, currency, engineFactory,
+                bondOptionBuilder->configuration(MarketContext::pricing));
 
     instrument_.reset(new VanillaInstrument(bondoption, multiplier, additionalInstruments, additionalMultipliers));
-
-    legs_ = underlying_->legs();
-    legCurrencies_ = underlying_->legCurrencies();
-    legPayers_ = std::vector<bool>(legs_.size(), false); // always receive (long option view)
-    npvCurrency_ = underlying_->bondData().currency();
-    maturity_ = std::max(lastPremiumDate, underlying_->maturity());
-    notional_ = underlying_->notional() * bondData_.bondNotional();
-    notionalCurrency_ = underlying_->bondData().currency();
-
+    
     // the required fixings are (at most) those of the underlying
     requiredFixings_ = underlying_->requiredFixings();
 }

OREData/ored/portfolio/bondtotalreturnswap.cpp

@@ -76,6 +76,9 @@ void BondTRS::build(const QuantLib::ext::shared_ptr<EngineFactory>& engineFactor
                "if funding leg ccy (" << fundingLegData_.currency() << ") != bond ccy (" << bondData_.currency()
                                       << "), a fx index must be given");
 
+    npvCurrency_ = fundingLegData_.currency();
+    notionalCurrency_ = bondData_.currency();
+
     // build return leg valuation and payment schedule
     DLOG("build valuation and payment dates vectors");
 
@@ -194,12 +197,9 @@ void BondTRS::build(const QuantLib::ext::shared_ptr<EngineFactory>& engineFactor
     bondTRS->setPricingEngine(trsBondBuilder->engine(fundingLegData_.currency()));
     setSensitivityTemplate(*trsBondBuilder);
     instrument_.reset(new VanillaInstrument(bondTRS));
-
-    npvCurrency_ = fundingLegData_.currency();
     // maturity_ = std::max(valuationDates.back(), paymentDates.back());
     maturity_ = bondIndex->bond()->maturityDate();
     notional_ = bondIndex->bond()->notional() * bondData_.bondNotional();
-    notionalCurrency_ = bondData_.currency();
 
     // cashflows will be generated as additional results in the pricing engine
 

OREData/ored/portfolio/cliquetoption.cpp

@@ -113,7 +113,6 @@ void CliquetOption::build(const QuantLib::ext::shared_ptr<EngineFactory>& engine
     }
 
     additionalData_["notional"] = cliquetNotional_;
-    additionalData_["currency"] = currency_;
 }
 
 void CliquetOption::fromXML(XMLNode* node) {

OREData/ored/portfolio/commodityapo.cpp

@@ -78,6 +78,14 @@ void CommodityAveragePriceOption::build(const QuantLib::ext::shared_ptr<EngineFa
     QL_REQUIRE(spread_ < strike_ || QuantLib::close_enough(spread_, strike_),
                "Spread (" << spread_ << ") should be less than strike (" << strike_ << ").");
 
+    additionalData_["quantity"] = quantity_;
+    additionalData_["strike"] = strike_;
+    additionalData_["strikeCurrency"] = currency_;
+
+    // Notional = effective_quantity * effective_strike = (G x Q) x ((K - s) / G) = Q x (K - s)
+    notional_ = quantity_ * (strike_ - spread_);
+    notionalCurrency_ = npvCurrency_ = currency_;
+
     // Allow exercise dates not to be specified for an APO. In this case, the exercise date is deduced below when
     // building the APO or a standard option.
     Date exDate;
@@ -95,12 +103,7 @@ void CommodityAveragePriceOption::build(const QuantLib::ext::shared_ptr<EngineFa
     // can then use a standard commodity option pricer below.
     Leg leg = buildLeg(engineFactory, configuration);
 
-    // Notional = effective_quantity * effective_strike = (G x Q) x ((K - s) / G) = Q x (K - s)
-    notional_ = quantity_ * (strike_ - spread_);
-    notionalCurrency_ = currency_;
-
     // Based on allAveraging_ flag, set up a standard or averaging commodity option
-    npvCurrency_ = currency_;
     if (allAveraging_) {
         buildStandardOption(engineFactory, leg, exDate);
     } else {
@@ -111,10 +114,6 @@ void CommodityAveragePriceOption::build(const QuantLib::ext::shared_ptr<EngineFa
     legs_.push_back(leg);
     legPayers_.push_back(false);
     legCurrencies_.push_back(currency_);
-
-    additionalData_["quantity"] = quantity_;
-    additionalData_["strike"] = strike_;
-    additionalData_["strikeCurrency"] = currency_;
 }
 
 std::map<AssetClass, std::set<std::string>> CommodityAveragePriceOption::underlyingIndices(
@@ -312,6 +311,10 @@ void CommodityAveragePriceOption::buildApo(const QuantLib::ext::shared_ptr<Engin
     QL_REQUIRE(leg.size() == 1, "Single flow expected but found " << leg.size());
     auto apoFlow = QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(leg[0]);
     QL_REQUIRE(apoFlow, "Expected a cashflow of type CommodityIndexedAverageCashFlow");
+
+    // Populate relevant Trade members
+    maturity_ = std::max(optionData_.premiumData().latestPremiumDate(), apoFlow->date());
+    
     Date lastApoFixingDate = apoFlow->indices().rbegin()->first;
 
     // If exercise date is given use it. If not given, take the cashflow's last pricing date.
@@ -399,15 +402,12 @@ void CommodityAveragePriceOption::buildApo(const QuantLib::ext::shared_ptr<Engin
     // Take care of fees
     vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
     vector<Real> additionalMultipliers;
-    Date lastPremiumDate = addPremiums(additionalInstruments, additionalMultipliers, multiplier,
-                                       optionData_.premiumData(), positionType == Position::Long ? -1.0 : 1.0, ccy,
-                                       engineFactory, engineBuilder->configuration(MarketContext::pricing));
+    addPremiums(additionalInstruments, additionalMultipliers, multiplier, optionData_.premiumData(),
+                positionType == Position::Long ? -1.0 : 1.0, ccy, engineFactory,
+                engineBuilder->configuration(MarketContext::pricing));
 
     // Populate instrument wrapper
     instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(apo, multiplier, additionalInstruments, additionalMultipliers);
-
-    // Populate relevant Trade members
-    maturity_ = std::max(lastPremiumDate, apoFlow->date());
 }
 
 } // namespace data

OREData/ored/portfolio/commodityforward.cpp

@@ -76,8 +76,24 @@ void CommodityForward::build(const QuantLib::ext::shared_ptr<EngineFactory>& eng
     // Create the underlying commodity index for the forward
     const QuantLib::ext::shared_ptr<Market>& market = engineFactory->market();
     QuantLib::ext::shared_ptr<QuantExt::FxIndex> fxIndex = nullptr;
-    auto index = *market->commodityIndex(commodityName_, engineFactory->configuration(MarketContext::pricing));
+
+    npvCurrency_ = fixingDate_ == Date() ? currency_ : payCcy_;
+
+    // notional_ = strike_ * quantity_;
+    notional_ = strike_ * quantity_;
+    notionalCurrency_ = currency_;
+
+    additionalData_["quantity"] = quantity_;
+    additionalData_["strike"] = strike_;
+    additionalData_["strikeCurrency"] = currency_;
+    if (fixingDate_ != Date()) {
+        additionalData_["settlementCurrency"] = payCcy_;
+        additionalData_["fixingDate"] = fixingDate_;
+        additionalData_["fxIndex"] = fxIndex;
+    }
+
     maturity_ = parseDate(maturityDate_);
+    auto index = *market->commodityIndex(commodityName_, engineFactory->configuration(MarketContext::pricing));
     bool isFutureAccordingToConventions = InstrumentConventions::instance().conventions()->has(commodityName_, Convention::Type::CommodityFuture);
 
     // adjust the maturity date if not a valid fixing date for the index
@@ -104,7 +120,7 @@ void CommodityForward::build(const QuantLib::ext::shared_ptr<EngineFactory>& eng
     Date paymentDate = paymentDate_;
     bool physicallySettled = true;
     if (physicallySettled_ && !(*physicallySettled_)) {
-        // If cash settled and given a payment date that is not greater than the maturity date, set it equal to the 
+        // If cash settled and given a payment date that is not greater than the maturity date, set it equal to the
         // maturity date and log a warning to continue processing.
         physicallySettled = false;
         if (paymentDate_ != Date() && paymentDate_ < maturity_) {
@@ -152,20 +168,6 @@ void CommodityForward::build(const QuantLib::ext::shared_ptr<EngineFactory>& eng
 
     // set up other Trade details
     instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(commodityForward);
-    npvCurrency_ = fixingDate_==Date() ? currency_ : payCcy_;
-
-    // notional_ = strike_ * quantity_;
-    notional_ = strike_ * quantity_;
-    notionalCurrency_ = currency_;
-
-    additionalData_["quantity"] = quantity_;
-    additionalData_["strike"] = strike_;
-    additionalData_["strikeCurrency"] = currency_;
-    if(fixingDate_ != Date()) {
-        additionalData_["settlementCurrency"] = payCcy_;
-        additionalData_["fixingDate"] = fixingDate_;
-        additionalData_["fxIndex"] = fxIndex;
-    }
 }
 
 Real CommodityForward::notional() const { return notional_; }

OREData/ored/portfolio/commodityoption.cpp

@@ -57,12 +57,20 @@ void CommodityOption::build(const QuantLib::ext::shared_ptr<EngineFactory>& engi
     // skip the transaction level mapping for now
     additionalData_["isdaTransaction"] = std::string("");
 
+    additionalData_["quantity"] = quantity_;
+    additionalData_["strike"] = strike_.value();
+    additionalData_["strikeCurrency"] = currency_;    
+
     // Checks
     QL_REQUIRE((strike_.value() > 0) || close_enough(strike_.value(),0.0), "Commodity option requires a non-negative strike");
     if (close_enough(strike_.value(), 0.0)) {
         strike_.setValue(0.0);
     }
 
+    // This is called in VanillaOptionTrade::build(), but we want to call it first here,
+    // in case the build fails before it reaches VanillaOptionTrade::build()
+    VanillaOptionTrade::setNotionalAndCurrencies();
+
     // Populate the index_ in case the option is automatic exercise.
     // Intentionally use null calendar because we will ask for index value on the expiry date without adjustment.
     const QuantLib::ext::shared_ptr<Market>& market = engineFactory->market();
@@ -105,10 +113,6 @@ void CommodityOption::build(const QuantLib::ext::shared_ptr<EngineFactory>& engi
                                 << " and strike " << strike_.value() << " is "
                                 << market->commodityVolatility(assetName_)->blackVol(expiryDate_, strike_.value()));
     }
-
-    additionalData_["quantity"] = quantity_;
-    additionalData_["strike"] = strike_.value();
-    additionalData_["strikeCurrency"] = currency_;    
 }
 
 std::map<AssetClass, std::set<std::string>>