PathSimulator.java

  1. package org.drip.xva.dynamics;

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

  79. /**
  80.  * <i>PathSimulator</i> drives the Simulation for various Latent States and Exposures. The References are:
  81.  *
  82.  *  <br><br>
  83.  *  <ul>
  84.  *      <li>
  85.  *          Albanese, C., and L. Andersen (2014): Accounting for OTC Derivatives: Funding Adjustments and the
  86.  *              Re-Hypothecation Option https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2482955
  87.  *              <b>eSSRN</b>
  88.  *      </li>
  89.  *      <li>
  90.  *          Burgard, C., and M. Kjaer (2014): PDE Representations of Derivatives with Bilateral Counter-party
  91.  *              Risk and Funding Costs <i>Journal of Credit Risk</i> <b>7 (3)</b> 1-19
  92.  *      </li>
  93.  *      <li>
  94.  *          Burgard, C., and M. Kjaer (2014): In the Balance <i>Risk</i> <b>24 (11)</b> 72-75
  95.  *      </li>
  96.  *      <li>
  97.  *          Burgard, C., and M. Kjaer (2017): Derivatives Funding, Netting, and Accounting
  98.  *              https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2534011 <b>eSSRN</b>
  99.  *      </li>
  100.  *      <li>
  101.  *          Piterbarg, V. (2010): Funding Beyond Discounting: Collateral Agreements and Derivatives Pricing
  102.  *              <i>Risk</i> <b>21 (2)</b> 97-102
  103.  *      </li>
  104.  *  </ul>
  105.  *
  106.  *  <br><br>
  107.  *  <ul>
  108.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/PortfolioCore.md">Portfolio Core Module</a></li>
  109.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/XVAAnalyticsLibrary.md">XVA Analytics Library</a></li>
  110.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/xva/README.md">Valuation Adjustments that account for Collateral, CC Credit/Debt and Funding Overhead</a></li>
  111.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/xva/dynamics/README.md">XVA Dynamics - Settings and Evolution</a></li>
  112.  *  </ul>
  113.  * <br><br>
  114.  * 
  115.  * @author Lakshmi Krishnamurthy
  116.  */

  118. public class PathSimulator
  119. {
  120.     private int _iCount = -1;
  121.     private int _adjustmentDigestScheme = -1;
  122.     private org.drip.exposure.universe.MarketVertexGenerator _marketVertexGenerator = null;
  123.     private org.drip.exposure.holdings.PositionGroupContainer _positionGroupContainer = null;

  125.     private double[][] positionGroupValueArray (
  126.         final org.drip.exposure.universe.MarketPath marketPath)
  127.     {
  128.         org.drip.exposure.holdings.PositionGroup[] positionGroupArray =
  129.             _positionGroupContainer.positionGroupArray();

  131.         org.drip.analytics.date.JulianDate[] vertexDateArray = marketPath.anchorDates();

  133.         int vertexCount = vertexDateArray.length;
  134.         int positionGroupCount = positionGroupArray.length;
  135.         double[][] positionGroupValueArray = new double[positionGroupCount][vertexCount];

  137.         for (int positionGroupIndex = 0; positionGroupIndex < positionGroupCount; ++positionGroupIndex)
  138.         {
  139.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  140.             {
  141.                 int forwardDate = vertexDateArray[vertexIndex].julian();

  143.                 try {
  144.                     positionGroupValueArray[positionGroupIndex][vertexIndex] =
  145.                         null == positionGroupArray[positionGroupIndex].positionGroupEstimator() ? 1. :
  146.                         positionGroupArray[positionGroupIndex].positionGroupEstimator().variationMarginEstimate (
  147.                             forwardDate,
  148.                             marketPath
  149.                         );
  150.                 }
  151.                 catch (java.lang.Exception e)
  152.                 {
  153.                     e.printStackTrace();

  155.                     return null;
  156.                 }
  157.             }
  158.         }

  160.         return positionGroupValueArray;
  161.     }

  163.     private boolean collateralGroupPathArray (
  164.         final org.drip.exposure.universe.MarketPath marketPath)
  165.     {
  166.         org.drip.xva.dynamics.PositionGroupTrajectory collateralGroup = null;

  168.         try
  169.         {
  170.             collateralGroup = new org.drip.xva.dynamics.PositionGroupTrajectory (
  171.                 _positionGroupContainer.positionGroupArray()[0].positionGroupSpecification().positionGroupSpecification(),
  172.                 marketPath,
  173.                 positionGroupValueArray (marketPath)
  174.             );
  175.         }
  176.         catch (java.lang.Exception e)
  177.         {
  178.             e.printStackTrace();

  180.             return false;
  181.         }

  183.         org.drip.xva.hypothecation.CollateralGroupVertex[][] collateralGroupVertexArray =
  184.             collateralGroup.positionGroupVertexArray();

  186.         if (null == collateralGroupVertexArray)
  187.         {
  188.             return false;
  189.         }

  191.         int positionGroupCount = collateralGroupVertexArray.length;

  193.         try
  194.         {
  195.             for (int positionGroupIndex = 0; positionGroupIndex < positionGroupCount; ++positionGroupIndex)
  196.             {
  197.                 if (!_positionGroupContainer.setCollateralGroupPath (
  198.                     positionGroupIndex,
  199.                     new org.drip.xva.netting.CollateralGroupPath (
  200.                         collateralGroupVertexArray[positionGroupIndex],
  201.                         marketPath
  202.                     )))
  203.                     return false;
  204.             }

  206.             return true;
  207.         }
  208.         catch (java.lang.Exception e)
  209.         {
  210.             e.printStackTrace();
  211.         }

  213.         return false;
  214.     }

  216.     /**
  217.      * Generate a PathSimulator Instance with the corresponding Position Group Value
  218.      * 
  219.      * @param iPathCount Path Count
  220.      * @param marketVertexGenerator Market Vertex Generator
  221.      * @param positionGroupContainer Container of Position Groups
  222.      * 
  223.      * @return The PathSimulator Instance
  224.      */

  226.     public static final PathSimulator UnitPositionGroupValue (
  227.         final int iPathCount,
  228.         final org.drip.exposure.universe.MarketVertexGenerator marketVertexGenerator,
  229.         final org.drip.exposure.holdings.PositionGroupContainer positionGroupContainer)
  230.     {
  231.         try
  232.         {
  233.             return new PathSimulator (
  234.                 iPathCount,
  235.                 marketVertexGenerator,
  236.                 org.drip.xva.settings.AdjustmentDigestScheme.ALBANESE_ANDERSEN_METRICS_POINTER,
  237.                 positionGroupContainer
  238.             );
  239.         }
  240.         catch (java.lang.Exception e)
  241.         {
  242.             e.printStackTrace();
  243.         }

  245.         return null;
  246.     }

  248.     /**
  249.      * PathSimulator Constructor
  250.      * 
  251.      * @param iCount Path Count
  252.      * @param marketVertexGenerator Market Vertex Generator
  253.      * @param adjustmentDigestScheme Adjustment Digest Scheme
  254.      * @param positionGroupContainer Container of Position Groups
  255.      * 
  256.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  257.      */

  259.     public PathSimulator (
  260.         final int iCount,
  261.         final org.drip.exposure.universe.MarketVertexGenerator marketVertexGenerator,
  262.         final int adjustmentDigestScheme,
  263.         final org.drip.exposure.holdings.PositionGroupContainer positionGroupContainer)
  264.         throws java.lang.Exception
  265.     {
  266.         if (0 >= (_iCount = iCount) ||
  267.             null == (_marketVertexGenerator = marketVertexGenerator) ||
  268.             null == (_positionGroupContainer = positionGroupContainer))
  269.         {
  270.             throw new java.lang.Exception ("PathSimulator Constructor => Invalid Inputs");
  271.         }

  273.         _adjustmentDigestScheme = adjustmentDigestScheme;
  274.     }

  276.     /**
  277.      * Retrieve the Path Count
  278.      * 
  279.      * @return The Path Count
  280.      */

  282.     public int count()
  283.     {
  284.         return _iCount;
  285.     }

  287.     /**
  288.      * Retrieve the Market Vertex Generator
  289.      * 
  290.      * @return The Market Vertex Generator
  291.      */

  293.     public org.drip.exposure.universe.MarketVertexGenerator marketVertexGenerator()
  294.     {
  295.         return _marketVertexGenerator;
  296.     }

  298.     /**
  299.      * Retrieve the Adjustment Digest Scheme
  300.      * 
  301.      * @return The Adjustment Digest Scheme
  302.      */

  304.     public int adjustmentDigestScheme()
  305.     {
  306.         return _adjustmentDigestScheme;
  307.     }

  309.     /**
  310.      * Retrieve the Position Group Container
  311.      * 
  312.      * @return Position Group Container
  313.      */

  315.     public org.drip.exposure.holdings.PositionGroupContainer positionGroupContainer()
  316.     {
  317.         return _positionGroupContainer;
  318.     }

  320.     /**
  321.      * Generate a Single Trajectory from the Specified Initial Market Vertex and the Evolver Sequence
  322.      * 
  323.      * @param initialMarketVertex The Initial Market Vertex
  324.      * @param latentStateWeiner The Latent State Weiner Instance
  325.      * 
  326.      * @return Single Trajectory Path Exposure Adjustment
  327.      */

  329.     public org.drip.xva.gross.PathExposureAdjustment singleTrajectory (
  330.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  331.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner)
  332.     {
  333.         try
  334.         {
  335.             org.drip.exposure.universe.MarketPath marketPath = new org.drip.exposure.universe.MarketPath (
  336.                 _marketVertexGenerator.marketVertex (
  337.                     initialMarketVertex,
  338.                     latentStateWeiner
  339.                 )
  340.             );

  342.             if (!collateralGroupPathArray (marketPath))
  343.             {
  344.                 return null;
  345.             }

  347.             org.drip.xva.netting.CollateralGroupPath[][] positionFundingGroupPath =
  348.                 _positionGroupContainer.fundingSegmentPaths();

  350.             org.drip.xva.netting.CollateralGroupPath[][] positionCreditDebtGroupPath =
  351.                 _positionGroupContainer.creditDebtSegmentPaths();

  353.             int positionFundingGroupCount = positionFundingGroupPath.length;
  354.             org.drip.xva.netting.FundingGroupPath[] fundingGroupPathArray = new
  355.                 org.drip.xva.strategy.AlbaneseAndersenFundingGroupPath[positionFundingGroupCount];

  357.             if (org.drip.xva.settings.AdjustmentDigestScheme.ALBANESE_ANDERSEN_METRICS_POINTER ==
  358.                 _adjustmentDigestScheme)
  359.             {
  360.                 int positionCreditDebtGroupCount = positionCreditDebtGroupPath.length;

  362.                 org.drip.xva.netting.CreditDebtGroupPath[] creditDebtGroupPathArray = new
  363.                     org.drip.xva.strategy.AlbaneseAndersenNettingGroupPath[positionCreditDebtGroupCount];

  365.                 for (int positionCreditDebtGroupIndex = 0; positionCreditDebtGroupIndex <
  366.                     positionCreditDebtGroupCount; ++positionCreditDebtGroupIndex)
  367.                 {
  368.                     creditDebtGroupPathArray[positionCreditDebtGroupIndex] =
  369.                         new org.drip.xva.strategy.AlbaneseAndersenNettingGroupPath (
  370.                             positionCreditDebtGroupPath[positionCreditDebtGroupIndex],
  371.                             marketPath
  372.                         );
  373.                 }

  375.                 for (int positionFundingGroupIndex = 0; positionFundingGroupIndex <
  376.                     positionFundingGroupCount; ++positionFundingGroupIndex)
  377.                 {
  378.                     fundingGroupPathArray[positionFundingGroupIndex] =
  379.                         new org.drip.xva.strategy.AlbaneseAndersenFundingGroupPath (
  380.                             creditDebtGroupPathArray,
  381.                             marketPath
  382.                         );
  383.                 }
  384.             }

  386.             return new org.drip.xva.gross.MonoPathExposureAdjustment (fundingGroupPathArray);
  387.         }
  388.         catch (java.lang.Exception e)
  389.         {
  390.             e.printStackTrace();
  391.         }

  393.         return null;
  394.     }

  396.     /**
  397.      * Simulate the Realized State/Entity Values and their Aggregates over the Paths
  398.      * 
  399.      * @param latentStateLabelList Latent State Label List
  400.      * @param initialMarketVertex The Initial Market Vertex
  401.      * @param correlatedPathVertexDimension Path Vertex Dimension Generator
  402.      * 
  403.      * @return The Exposure Adjustment Aggregator - Simulation Result
  404.      */

  406.     public org.drip.xva.gross.ExposureAdjustmentAggregator simulate (
  407.         final java.util.List<org.drip.state.identifier.LatentStateLabel> latentStateLabelList,
  408.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  409.         final org.drip.measure.discrete.CorrelatedPathVertexDimension correlatedPathVertexDimension)
  410.     {
  411.         if (null == correlatedPathVertexDimension)
  412.         {
  413.             return null;
  414.         }

  416.         org.drip.xva.gross.PathExposureAdjustment[] pathExposureAdjustmentArray = new
  417.             org.drip.xva.gross.PathExposureAdjustment[_iCount];

  419.         for (int pathIndex = 0; pathIndex < _iCount; ++pathIndex)
  420.         {
  421.             if (null == (pathExposureAdjustmentArray[pathIndex] = singleTrajectory (
  422.                 initialMarketVertex,
  423.                 org.drip.exposure.universe.LatentStateWeiner.FromUnitRandom (
  424.                     latentStateLabelList,
  425.                     org.drip.numerical.linearalgebra.Matrix.Transpose
  426.                         (org.drip.numerical.linearalgebra.Matrix.Transpose
  427.                         (correlatedPathVertexDimension.straightPathVertexRd().flatform()))))))
  428.             {
  429.                 return null;
  430.             }
  431.         }

  433.         try
  434.         {
  435.             return new org.drip.xva.gross.ExposureAdjustmentAggregator (pathExposureAdjustmentArray);
  436.         }
  437.         catch (java.lang.Exception e)
  438.         {
  439.             e.printStackTrace();
  440.         }

  442.         return null;
  443.     }
  444. }
Created with JaCoCo 0.7.9.201702052155