CapitalSegmentPnLAttribution.java

  1. package org.drip.capital.explain;

  3. /*
  4.  * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  5.  */

  7. /*!
  8.  * Copyright (C) 2020 Lakshmi Krishnamurthy
  9.  * Copyright (C) 2019 Lakshmi Krishnamurthy
  10.  * 
  11.  *  This file is part of DROP, an open-source library targeting analytics/risk, transaction cost analytics,
  12.  *      asset liability management analytics, capital, exposure, and margin analytics, valuation adjustment
  13.  *      analytics, and portfolio construction analytics within and across fixed income, credit, commodity,
  14.  *      equity, FX, and structured products. It also includes auxiliary libraries for algorithm support,
  15.  *      numerical analysis, numerical optimization, spline builder, model validation, statistical learning,
  16.  *      and computational support.
  17.  *  
  18.  *      https://lakshmidrip.github.io/DROP/
  19.  *  
  20.  *  DROP is composed of three modules:
  21.  *  
  22.  *  - DROP Product Core - https://lakshmidrip.github.io/DROP-Product-Core/
  23.  *  - DROP Portfolio Core - https://lakshmidrip.github.io/DROP-Portfolio-Core/
  24.  *  - DROP Computational Core - https://lakshmidrip.github.io/DROP-Computational-Core/
  25.  * 
  26.  *  DROP Product Core implements libraries for the following:
  27.  *  - Fixed Income Analytics
  28.  *  - Loan Analytics
  29.  *  - Transaction Cost Analytics
  30.  * 
  31.  *  DROP Portfolio Core implements libraries for the following:
  32.  *  - Asset Allocation Analytics
  33.  *  - Asset Liability Management Analytics
  34.  *  - Capital Estimation Analytics
  35.  *  - Exposure Analytics
  36.  *  - Margin Analytics
  37.  *  - XVA Analytics
  38.  * 
  39.  *  DROP Computational Core implements libraries for the following:
  40.  *  - Algorithm Support
  41.  *  - Computation Support
  42.  *  - Function Analysis
  43.  *  - Model Validation
  44.  *  - Numerical Analysis
  45.  *  - Numerical Optimizer
  46.  *  - Spline Builder
  47.  *  - Statistical Learning
  48.  * 
  49.  *  Documentation for DROP is Spread Over:
  50.  * 
  51.  *  - Main                     => https://lakshmidrip.github.io/DROP/
  52.  *  - Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
  53.  *  - GitHub                   => https://github.com/lakshmiDRIP/DROP
  54.  *  - Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
  55.  *  - Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
  56.  *  - Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
  57.  *  - Release Versions         => https://lakshmidrip.github.io/DROP/version.html
  58.  *  - Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
  59.  *  - Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
  60.  *  - JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
  61.  *  - Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html
  62.  * 
  63.  *  Licensed under the Apache License, Version 2.0 (the "License");
  64.  *      you may not use this file except in compliance with the License.
  65.  *   
  66.  *  You may obtain a copy of the License at
  67.  *      http://www.apache.org/licenses/LICENSE-2.0
  68.  *  
  69.  *  Unless required by applicable law or agreed to in writing, software
  70.  *      distributed under the License is distributed on an "AS IS" BASIS,
  71.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  72.  *  
  73.  *  See the License for the specific language governing permissions and
  74.  *      limitations under the License.
  75.  */

  77. /**
  78.  * <i>CapitalSegmentPnLAttribution</i> holds the Scenario-Level Cumulative Capital Attributions from the
  79.  *  Contributing Paths of the Stand-alone Capital Units corresponding to a Capital Segment. The References
  80.  *  are:
  81.  * 
  82.  * <br><br>
  83.  *  <ul>
  84.  *      <li>
  85.  *          Bank for International Supervision (2005): Stress Testing at Major Financial Institutions: Survey
  86.  *              Results and Practice https://www.bis.org/publ/cgfs24.htm
  87.  *      </li>
  88.  *      <li>
  89.  *          Glasserman, P. (2004): <i>Monte Carlo Methods in Financial Engineering</i> <b>Springer</b>
  90.  *      </li>
  91.  *      <li>
  92.  *          Kupiec, P. H. (2000): Stress Tests and Risk Capital <i>Risk</i> <b>2 (4)</b> 27-39
  93.  *      </li>
  94.  *  </ul>
  95.  *
  96.  *  <br><br>
  97.  *  <ul>
  98.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/PortfolioCore.md">Portfolio Core Module</a></li>
  99.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/CapitalAnalyticsLibrary.md">Capital Analytics</a></li>
  100.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/capital/README.md">Basel Market Risk and Operational Capital</a></li>
  101.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/capital/explain/README.md">Economic Risk Capital Attribution Explain</a></li>
  102.  *  </ul>
  103.  * 
  104.  * @author Lakshmi Krishnamurthy
  105.  */

  107. public class CapitalSegmentPnLAttribution
  108.     extends org.drip.capital.explain.PnLAttribution
  109. {
  110.     private int _pathCount = -1;
  111.     private java.util.List<java.lang.Integer> _pathIndexList = null;

  113.     private boolean updateFSDecompositionExplainMap (
  114.         final java.util.Map<java.lang.String, java.lang.Double> unitFSPnLDecompositionExplainMap)
  115.     {
  116.         if (null == unitFSPnLDecompositionExplainMap)
  117.         {
  118.             return true;
  119.         }

  121.         if (null == _fsPnLDecompositionExplainMap)
  122.         {
  123.             _fsPnLDecompositionExplainMap = new
  124.                 org.drip.analytics.support.CaseInsensitiveHashMap<java.lang.Double>();
  125.         }

  127.         for (java.util.Map.Entry<java.lang.String, java.lang.Double> fsPnLDecompositionExplainEntry :
  128.             unitFSPnLDecompositionExplainMap.entrySet())
  129.         {
  130.             java.lang.String fsType = fsPnLDecompositionExplainEntry.getKey();

  132.             if (_fsPnLDecompositionExplainMap.containsKey (
  133.                 fsType
  134.             ))
  135.             {
  136.                 _fsPnLDecompositionExplainMap.put (
  137.                     fsType,
  138.                     _fsPnLDecompositionExplainMap.get (
  139.                         fsType
  140.                     ) + fsPnLDecompositionExplainEntry.getValue()
  141.                 );
  142.             }
  143.             else
  144.             {
  145.                 _fsPnLDecompositionExplainMap.put (
  146.                     fsType,
  147.                     fsPnLDecompositionExplainEntry.getValue()
  148.                 );
  149.             }
  150.         }

  152.         return true;
  153.     }

  155.     private boolean updateSystemicEventNamePnLExplainMap (
  156.         final java.util.Map<java.lang.String, java.lang.Double> unitSystemicPnLExplainMap)
  157.     {
  158.         if (null == unitSystemicPnLExplainMap)
  159.         {
  160.             return true;
  161.         }

  163.         if (null == _systemicPnLExplainMap)
  164.         {
  165.             _systemicPnLExplainMap = new
  166.                 org.drip.analytics.support.CaseInsensitiveHashMap<java.lang.Double>();
  167.         }

  169.         for (java.util.Map.Entry<java.lang.String, java.lang.Double> systemicExplainEntry :
  170.             unitSystemicPnLExplainMap.entrySet())
  171.         {
  172.             java.lang.String systemicEventName = systemicExplainEntry.getKey();

  174.             if (_systemicPnLExplainMap.containsKey (
  175.                 systemicEventName
  176.             ))
  177.             {
  178.                 _systemicPnLExplainMap.put (
  179.                     systemicEventName,
  180.                     _systemicPnLExplainMap.get (
  181.                         systemicEventName
  182.                     ) + systemicExplainEntry.getValue()
  183.                 );
  184.             }
  185.             else
  186.             {
  187.                 _systemicPnLExplainMap.put (
  188.                     systemicEventName,
  189.                     systemicExplainEntry.getValue()
  190.                 );
  191.             }
  192.         }

  194.         return true;
  195.     }

  197.     private boolean updateSystemicGrossPnLExplainMap (
  198.         final java.util.Map<java.lang.String, java.lang.Double> unitSystemicGrossPnLExplainMap)
  199.     {
  200.         if (null == unitSystemicGrossPnLExplainMap)
  201.         {
  202.             return true;
  203.         }

  205.         if (null == _systemicGrossPnLExplainMap)
  206.         {
  207.             _systemicGrossPnLExplainMap = new
  208.                 org.drip.analytics.support.CaseInsensitiveHashMap<java.lang.Double>();
  209.         }

  211.         for (java.util.Map.Entry<java.lang.String, java.lang.Double> systemicGrossExplainEntry :
  212.             unitSystemicGrossPnLExplainMap.entrySet())
  213.         {
  214.             java.lang.String systemicEventName = systemicGrossExplainEntry.getKey();

  216.             if (_systemicGrossPnLExplainMap.containsKey (
  217.                 systemicEventName
  218.             ))
  219.             {
  220.                 _systemicGrossPnLExplainMap.put (
  221.                     systemicEventName,
  222.                     _systemicGrossPnLExplainMap.get (
  223.                         systemicEventName
  224.                     ) + systemicGrossExplainEntry.getValue()
  225.                 );
  226.             }
  227.             else
  228.             {
  229.                 _systemicGrossPnLExplainMap.put (
  230.                     systemicEventName,
  231.                     systemicGrossExplainEntry.getValue()
  232.                 );
  233.             }
  234.         }

  236.         return true;
  237.     }

  239.     private boolean updateSystemicInstanceCountMap (
  240.         final java.util.Map<java.lang.String, java.lang.Integer> unitSystemicInstanceCountMap)
  241.     {
  242.         if (null == unitSystemicInstanceCountMap)
  243.         {
  244.             return true;
  245.         }

  247.         if (null == _systemicInstanceCountMap)
  248.         {
  249.             _systemicInstanceCountMap = new
  250.                 org.drip.analytics.support.CaseInsensitiveHashMap<java.lang.Integer>();
  251.         }

  253.         for (java.util.Map.Entry<java.lang.String, java.lang.Integer> systemicInstanceCountEntry :
  254.             unitSystemicInstanceCountMap.entrySet())
  255.         {
  256.             java.lang.String systemicEventName = systemicInstanceCountEntry.getKey();

  258.             if (_systemicInstanceCountMap.containsKey (
  259.                 systemicEventName
  260.             ))
  261.             {
  262.                 _systemicInstanceCountMap.put (
  263.                     systemicEventName,
  264.                     _systemicInstanceCountMap.get (
  265.                         systemicEventName
  266.                     ) + systemicInstanceCountEntry.getValue()
  267.                 );
  268.             }
  269.             else
  270.             {
  271.                 _systemicInstanceCountMap.put (
  272.                     systemicEventName,
  273.                     systemicInstanceCountEntry.getValue()
  274.                 );
  275.             }
  276.         }

  278.         return true;
  279.     }

  281.     private boolean updateCorrelatedPnLExplainMap (
  282.         final java.util.Map<java.lang.String, java.lang.Double> unitCorrelatedPnLExplainMap)
  283.     {
  284.         if (null == unitCorrelatedPnLExplainMap)
  285.         {
  286.             return true;
  287.         }

  289.         if (null == _correlatedPnLExplainMap)
  290.         {
  291.             _correlatedPnLExplainMap = new
  292.                 org.drip.analytics.support.CaseInsensitiveHashMap<java.lang.Double>();
  293.         }

  295.         for (java.util.Map.Entry<java.lang.String, java.lang.Double> correlatedExplainEntry :
  296.             unitCorrelatedPnLExplainMap.entrySet())
  297.         {
  298.             java.lang.String correlatedEventName = correlatedExplainEntry.getKey();

  300.             if (_correlatedPnLExplainMap.containsKey (
  301.                 correlatedEventName
  302.             ))
  303.             {
  304.                 _correlatedPnLExplainMap.put (
  305.                     correlatedEventName,
  306.                     _correlatedPnLExplainMap.get (
  307.                         correlatedEventName
  308.                     ) + correlatedExplainEntry.getValue()
  309.                 );
  310.             }
  311.             else
  312.             {
  313.                 _correlatedPnLExplainMap.put (
  314.                     correlatedEventName,
  315.                     correlatedExplainEntry.getValue()
  316.                 );
  317.             }
  318.         }

  320.         return true;
  321.     }

  323.     private boolean updateCorrelatedInstanceCountMap (
  324.         final java.util.Map<java.lang.String, java.lang.Integer> unitCorrelatedInstanceCountMap)
  325.     {
  326.         if (null == unitCorrelatedInstanceCountMap)
  327.         {
  328.             return true;
  329.         }

  331.         if (null == _correlatedInstanceCountMap)
  332.         {
  333.             _correlatedInstanceCountMap = new
  334.                 org.drip.analytics.support.CaseInsensitiveHashMap<java.lang.Integer>();
  335.         }

  337.         for (java.util.Map.Entry<java.lang.String, java.lang.Integer> correlatedInstanceCountEntry :
  338.             unitCorrelatedInstanceCountMap.entrySet())
  339.         {
  340.             java.lang.String correlatedEventName = correlatedInstanceCountEntry.getKey();

  342.             if (_correlatedInstanceCountMap.containsKey (
  343.                 correlatedEventName
  344.             ))
  345.             {
  346.                 _correlatedInstanceCountMap.put (
  347.                     correlatedEventName,
  348.                     _correlatedInstanceCountMap.get (
  349.                         correlatedEventName
  350.                     ) + correlatedInstanceCountEntry.getValue()
  351.                 );
  352.             }
  353.             else
  354.             {
  355.                 _correlatedInstanceCountMap.put (
  356.                     correlatedEventName,
  357.                     correlatedInstanceCountEntry.getValue()
  358.                 );
  359.             }
  360.         }

  362.         return true;
  363.     }

  365.     private boolean updateIdiosyncraticPnLExplainMap (
  366.         final java.util.Map<java.lang.String, java.lang.Double> unitIdiosyncraticPnLExplainMap)
  367.     {
  368.         if (null == unitIdiosyncraticPnLExplainMap)
  369.         {
  370.             return true;
  371.         }

  373.         if (null == _idiosyncraticPnLExplainMap)
  374.         {
  375.             _idiosyncraticPnLExplainMap = new
  376.                 org.drip.analytics.support.CaseInsensitiveHashMap<java.lang.Double>();
  377.         }

  379.         for (java.util.Map.Entry<java.lang.String, java.lang.Double> idiosyncraticExplainEntry :
  380.             unitIdiosyncraticPnLExplainMap.entrySet())
  381.         {
  382.             java.lang.String idiosyncraticEventName = idiosyncraticExplainEntry.getKey();

  384.             if (_idiosyncraticPnLExplainMap.containsKey (
  385.                 idiosyncraticEventName
  386.             ))
  387.             {
  388.                 _idiosyncraticPnLExplainMap.put (
  389.                     idiosyncraticEventName,
  390.                     _idiosyncraticPnLExplainMap.get (
  391.                         idiosyncraticEventName
  392.                     ) + idiosyncraticExplainEntry.getValue()
  393.                 );
  394.             }
  395.             else
  396.             {
  397.                 _idiosyncraticPnLExplainMap.put (
  398.                     idiosyncraticEventName,
  399.                     idiosyncraticExplainEntry.getValue()
  400.                 );
  401.             }
  402.         }

  404.         return true;
  405.     }

  407.     private boolean updateIdiosyncraticInstanceCountMap (
  408.         final java.util.Map<java.lang.String, java.lang.Integer> unitIdiosyncraticInstanceCountMap)
  409.     {
  410.         if (null == unitIdiosyncraticInstanceCountMap)
  411.         {
  412.             return true;
  413.         }

  415.         if (null == _idiosyncraticInstanceCountMap)
  416.         {
  417.             _idiosyncraticInstanceCountMap = new
  418.                 org.drip.analytics.support.CaseInsensitiveHashMap<java.lang.Integer>();
  419.         }

  421.         for (java.util.Map.Entry<java.lang.String, java.lang.Integer> idiosyncraticInstanceCountEntry :
  422.             unitIdiosyncraticInstanceCountMap.entrySet())
  423.         {
  424.             java.lang.String idiosyncraticEventName = idiosyncraticInstanceCountEntry.getKey();

  426.             if (_idiosyncraticInstanceCountMap.containsKey (
  427.                 idiosyncraticEventName
  428.             ))
  429.             {
  430.                 _idiosyncraticInstanceCountMap.put (
  431.                     idiosyncraticEventName,
  432.                     _idiosyncraticInstanceCountMap.get (
  433.                         idiosyncraticEventName
  434.                     ) + idiosyncraticInstanceCountEntry.getValue()
  435.                 );
  436.             }
  437.             else
  438.             {
  439.                 _idiosyncraticInstanceCountMap.put (
  440.                     idiosyncraticEventName,
  441.                     idiosyncraticInstanceCountEntry.getValue()
  442.                 );
  443.             }
  444.         }

  446.         return true;
  447.     }

  449.     private boolean accumulateUnitAttribution (
  450.         final org.drip.capital.explain.PnLAttribution pnlAttribution)
  451.     {
  452.         if (!updateFSDecompositionExplainMap (
  453.             pnlAttribution.fsPnLDecompositionExplainMap()
  454.         ))
  455.         {
  456.             return false;
  457.         }

  459.         if (!updateSystemicEventNamePnLExplainMap (
  460.             pnlAttribution.systemicPnLExplainMap()
  461.         ))
  462.         {
  463.             return false;
  464.         }

  466.         if (!updateSystemicGrossPnLExplainMap (
  467.             pnlAttribution.systemicGrossPnLExplainMap()
  468.         ))
  469.         {
  470.             return false;
  471.         }

  473.         if (!updateSystemicInstanceCountMap (
  474.             pnlAttribution.systemicInstanceCountMap()
  475.         ))
  476.         {
  477.             return false;
  478.         }

  480.         if (!updateCorrelatedPnLExplainMap (
  481.             pnlAttribution.correlatedPnLExplainMap()
  482.         ))
  483.         {
  484.             return false;
  485.         }

  487.         if (!updateCorrelatedInstanceCountMap (
  488.             pnlAttribution.correlatedInstanceCountMap()
  489.         ))
  490.         {
  491.             return false;
  492.         }

  494.         if (!updateIdiosyncraticPnLExplainMap (
  495.             pnlAttribution.idiosyncraticPnLExplainMap()
  496.         ))
  497.         {
  498.             return false;
  499.         }

  501.         if (!updateIdiosyncraticInstanceCountMap (
  502.             pnlAttribution.idiosyncraticInstanceCountMap()
  503.         ))
  504.         {
  505.             return false;
  506.         }

  508.         return true;
  509.     }

  511.     /**
  512.      * CapitalSegmentPnLAttribution Constructor
  513.      * 
  514.      * @param pnlAttributionArray Array of PnL Attributions
  515.      * 
  516.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  517.      */

  519.     public CapitalSegmentPnLAttribution (
  520.         final org.drip.capital.explain.PnLAttribution[] pnlAttributionArray)
  521.         throws java.lang.Exception
  522.     {
  523.         if (null == pnlAttributionArray)
  524.         {
  525.             throw new java.lang.Exception (
  526.                 "CapitalSegmentPnLAttribution Constructor => Invalid Inputs"
  527.             );
  528.         }

  530.         int capitalUnitCount = pnlAttributionArray.length;

  532.         if (0 >= capitalUnitCount)
  533.         {
  534.             throw new java.lang.Exception (
  535.                 "CapitalSegmentPnLAttribution Constructor => Invalid Inputs"
  536.             );
  537.         }

  539.         _var = 0.;
  540.         _expectedShortfall = 0.;

  542.         _pathCount = pnlAttributionArray[0].pathCount();

  544.         for (int capitalUnitIndex = 0; capitalUnitIndex < capitalUnitCount; ++capitalUnitIndex)
  545.         {
  546.             if (null == pnlAttributionArray[capitalUnitIndex])
  547.             {
  548.                 throw new java.lang.Exception (
  549.                     "CapitalSegmentPnLAttribution Constructor => Invalid Inputs"
  550.                 );
  551.             }

  553.             _var = _var + pnlAttributionArray[capitalUnitIndex].var();

  555.             _expectedShortfall = _expectedShortfall +
  556.                 pnlAttributionArray[capitalUnitIndex].expectedShortfall();

  558.             if (!accumulateUnitAttribution (
  559.                 pnlAttributionArray[capitalUnitIndex]
  560.             ))
  561.             {
  562.                 throw new java.lang.Exception (
  563.                     "CapitalSegmentPnLAttribution Constructor => Invalid Inputs"
  564.                 );
  565.             }
  566.         }

  568.         _pathIndexList = pnlAttributionArray[0].pathIndexList();
  569.     }

  571.     @Override public java.util.List<java.lang.Integer> pathIndexList()
  572.     {
  573.         return _pathIndexList;
  574.     }

  576.     @Override public int pathCount()
  577.     {
  578.         return _pathCount;
  579.     }
  580. }
Created with JaCoCo 0.7.9.201702052155