QPR-11641 fix upDownFactor(), add crossFactor() method

upDownFactor() only worked for up factors so far (which was good enough for our use cases)

Author: pcaspers

OREAnalytics/orea/cube/sensitivitycube.cpp

@@ -26,9 +26,8 @@ using namespace std;
 
 using std::make_pair;
 
-// Ease the notation below
-using bm_type = boost::bimap<ore::analytics::RiskFactorKey, ore::analytics::SensitivityCube::FactorData>;
-typedef bm_type::left_map left_map_type;
+namespace ore {
+namespace analytics {
 
 namespace {
 
@@ -40,7 +39,9 @@ template <class KeyType, class ValueType> ValueType index(const KeyType& k, cons
     return it->second;
 }
 
-ore::analytics::SensitivityCube::FactorData index(const ore::analytics::RiskFactorKey& k, const left_map_type& m) {
+ore::analytics::SensitivityCube::FactorData
+index(const ore::analytics::RiskFactorKey& k,
+      const std::map<ore::analytics::RiskFactorKey, SensitivityCube::FactorData>& m) {
 
     auto it = m.find(k);
     QL_REQUIRE(it != m.end(), "Key, " << k << ", was not found in the sensitivity cube.");
@@ -49,11 +50,6 @@ ore::analytics::SensitivityCube::FactorData index(const ore::analytics::RiskFact
 
 } // namespace
 
-namespace ore {
-namespace analytics {
-
-typedef SensitivityCube::crossPair crossPair;
-
 std::ostream& operator<<(std::ostream& out, const SensitivityCube::crossPair& cp) {
     return out << cp.first << "-" << cp.second;
 }
@@ -103,24 +99,27 @@ void SensitivityCube::initialise() {
         // Populate factors_ = list of factors for which we can calculate a delta/gamma
         switch (des.type()) {
         case ShiftScenarioDescription::Type::Up:
-            QL_REQUIRE(upFactors_.left.count(des.key1()) == 0, "Cannot have multiple up factors with "
-                                                               "the same risk factor key["
-                                                                   << des.key1() << "]");
+            QL_REQUIRE(upFactors_.count(des.key1()) == 0, "Cannot have multiple up factors with "
+                                                          "the same risk factor key["
+                                                              << des.key1() << "]");
             factors_.insert(des.key1());
-            upFactors_.insert(bm_type::value_type(des.key1(), fd));
+            upFactors_[des.key1()] = fd;
+            upDownIndexToKey_[fd.index] = des.key1();
             break;
         case ShiftScenarioDescription::Type::Down:
             QL_REQUIRE(downFactors_.count(des.key1()) == 0, "Cannot have multiple down factors with "
                                                             "the same risk factor key ["
                                                                 << des.key1() << "]");
             downFactors_[des.key1()] = fd;
+            upDownIndexToKey_[fd.index] = des.key1();
             break;
         case ShiftScenarioDescription::Type::Cross:
             factorPair = make_pair(des.key1(), des.key2());
             QL_REQUIRE(crossFactors.count(factorPair) == 0, "Cannot have multiple cross factors with "
                                                             "the same risk factor key pair ["
                                                                 << des.key1() << ", " << des.key2() << "]");
             crossFactors[factorPair] = i;
+            crossIndexToKey_[i] = factorPair;
             break;
         default:
             // Do nothing
@@ -130,8 +129,8 @@ void SensitivityCube::initialise() {
 
     // Add each cross factor to crossFactors with index of the two contributing factors
     for (auto cf : crossFactors) {
-        FactorData id_1 = index(cf.first.first, upFactors_.left);
-        FactorData id_2 = index(cf.first.second, upFactors_.left);
+        FactorData id_1 = index(cf.first.first, upFactors_);
+        FactorData id_2 = index(cf.first.second, upFactors_);
         crossFactors_[cf.first] = make_tuple(id_1, id_2, cf.second);
     }
 
@@ -141,7 +140,7 @@ void SensitivityCube::initialise() {
                                            << "the number of shift sizes (" << shiftSizes_.size() << ") supplied");
     }
 
-    for (auto const& kv : upFactors_.left) {
+    for (auto const& kv : upFactors_) {
         auto it = shiftSizes_.find(kv.first);
         if (it == shiftSizes_.end()) {
             WLOG("No entry for risk factor " << kv.first << " in shift sizes.");
@@ -155,27 +154,33 @@ void SensitivityCube::initialise() {
 bool SensitivityCube::hasTrade(const string& tradeId) const { return tradeIdx_.count(tradeId) > 0; }
 
 RiskFactorKey SensitivityCube::upDownFactor(const Size upDownIndex) const {
-    FactorData fd;
-    fd.index = upDownIndex;
-    auto it = upFactors_.right.find(fd);
-    if (it == upFactors_.right.end())
+    if (auto k = upDownIndexToKey_.find(upDownIndex); k != upDownIndexToKey_.end()) {
+        return k->second;
+    } else {
         return RiskFactorKey();
-    else
-        return it->second;
+    }
+}
+
+SensitivityCube::crossPair SensitivityCube::crossFactor(const Size crossIndex) const {
+    if (auto k = crossIndexToKey_.find(crossIndex); k != crossIndexToKey_.end()) {
+        return k->second;
+    } else {
+        return std::make_pair(RiskFactorKey(), RiskFactorKey());
+    }
 }
 
 bool SensitivityCube::hasScenario(const ShiftScenarioDescription& scenarioDescription) const {
     return scenarioIdx_.count(scenarioDescription) > 0;
 }
 
 std::string SensitivityCube::factorDescription(const RiskFactorKey& riskFactorKey) const {
-    Size scenarioIdx = index(riskFactorKey, upFactors_.left).index;
+    Size scenarioIdx = index(riskFactorKey, upFactors_).index;
     return scenarioDescriptions_[scenarioIdx].factor1();
 }
 
 const set<RiskFactorKey>& SensitivityCube::factors() const { return factors_; }
 
-const std::map<crossPair, tuple<SensitivityCube::FactorData, SensitivityCube::FactorData, Size>>&
+const std::map<SensitivityCube::crossPair, tuple<SensitivityCube::FactorData, SensitivityCube::FactorData, Size>>&
 SensitivityCube::crossFactors() const {
     return crossFactors_;
 }
@@ -207,7 +212,7 @@ Real SensitivityCube::delta(Size id, Size upIdx, Size downIdx) const {
 }
 
 Real SensitivityCube::delta(const string& tradeId, const RiskFactorKey& riskFactorKey) const {
-    Size scenarioIdx = index(riskFactorKey, upFactors_.left).index;
+    Size scenarioIdx = index(riskFactorKey, upFactors_).index;
     Size tradeIdx = cube_->getTradeIndex(tradeId);
     if (!twoSidedDelta(riskFactorKey.keytype)) {
         return delta(tradeIdx, scenarioIdx);
@@ -227,7 +232,7 @@ Real SensitivityCube::gamma(Size id, Size upScenarioIdx, Size downScenarioIdx) c
 }
 
 Real SensitivityCube::gamma(const std::string& tradeId, const RiskFactorKey& riskFactorKey) const {
-    Size upIdx = index(riskFactorKey, upFactors_.left).index;
+    Size upIdx = index(riskFactorKey, upFactors_).index;
     Size downIdx = index(riskFactorKey, downFactors_).index;
     Size tradeIdx = cube_->getTradeIndex(tradeId);
 

OREAnalytics/orea/cube/sensitivitycube.hpp

@@ -80,6 +80,10 @@ class SensitivityCube {
       is not an up/down scenario (to be reviewed) */
     RiskFactorKey upDownFactor(const Size upDownIndex) const;
 
+    /*! Return factor for given cross scenario index or None if given index
+      is not a cross scenario (to be reviewed) */
+    crossPair crossFactor(const Size crossIndex) const;
+
     //! Check if the cube has scenario NPVs for scenario with description \p scenarioDescription
     bool hasScenario(const ShiftScenarioDescription& scenarioDescription) const;
 
@@ -90,10 +94,10 @@ class SensitivityCube {
     //! Returns the set of risk factor keys for which a delta and gamma can be calculated
     const std::set<RiskFactorKey>& factors() const;
 
-    //! Return the map of up risk factors to it's factor data
-    const boost::bimap<RiskFactorKey, SensitivityCube::FactorData>& upFactors() const { return upFactors_; };
+    //! Return the map of up risk factors to its factor data
+    const std::map<RiskFactorKey, SensitivityCube::FactorData>& upFactors() const { return upFactors_; };
 
-    //! Return the map of down risk factors to it's factor data
+    //! Return the map of down risk factors to its factor data
     const std::map<RiskFactorKey, SensitivityCube::FactorData>& downFactors() const { return downFactors_; };
 
     //! Returns the set of pairs of risk factor keys for which a cross gamma is available
@@ -161,23 +165,24 @@ class SensitivityCube {
     std::map<std::string, QuantLib::Size> tradeIdx_;
     std::map<ShiftScenarioDescription, QuantLib::Size> scenarioIdx_;
 
-    // Suppress warnings from Boost concept_check.hpp (VS 16.9.0, Boost 1.72.0).
-    // warning C4834: discarding return value of function with 'nodiscard' attribute
-#pragma warning( push )
-#pragma warning( disable : 4834 )
-    boost::bimap<RiskFactorKey, FactorData> upFactors_;
-#pragma warning( pop )
-
-    std::map<RiskFactorKey, FactorData> downFactors_;
+    std::map<RiskFactorKey, FactorData> upFactors_, downFactors_;
     // map of crossPair to tuple of (data of first \p RiskFactorKey, data of second \p RiskFactorKey, index of
     // crossFactor)
     std::map<crossPair, std::tuple<FactorData, FactorData, QuantLib::Size>> crossFactors_;
 
     // Set of risk factor key types where we want a two-sided delta calculation.
     std::set<RiskFactorKey::KeyType> twoSidedDeltas_;
+
+    // map of up / down factor index to risk factor key
+    std::map<QuantLib::Size, RiskFactorKey> upDownIndexToKey_;
+
+    // map of cross factor index to risk factor pair
+    std::map<QuantLib::Size, crossPair> crossIndexToKey_;
+
 };
 
 std::ostream& operator<<(std::ostream& out, const SensitivityCube::crossPair& cp);
 
 } // namespace analytics
 } // namespace ore
+#