AndersenPykhtinSokolEnsemble.java

  1. package org.drip.exposure.regressiontrade;

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

  78. /**
  79.  * <i>AndersenPykhtinSokolEnsemble</i> adjusts the Variation Margin, computes Path-wise Local Volatility, and
  80.  * eventually estimates the Path-wise Unadjusted Variation Margin across the Suite of Simulated Paths. The
  81.  * References are:
  82.  *  
  83.  * <br><br>
  84.  *      <ul>
  85.  *          <li>
  86.  *              Andersen, L. B. G., M. Pykhtin, and A. Sokol (2017): Re-thinking Margin Period of Risk
  87.  *                  https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2902737 <b>eSSRN</b>
  88.  *          </li>
  89.  *          <li>
  90.  *              Andersen, L. B. G., M. Pykhtin, and A. Sokol (2017): Credit Exposure in the Presence of
  91.  *                  Initial Margin https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2806156 <b>eSSRN</b>
  92.  *          </li>
  93.  *          <li>
  94.  *              Albanese, C., and L. Andersen (2014): Accounting for OTC Derivatives: Funding Adjustments and
  95.  *                  the Re-Hypothecation Option https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2482955
  96.  *                  <b>eSSRN</b>
  97.  *          </li>
  98.  *          <li>
  99.  *              Burgard, C., and M. Kjaer (2017): Derivatives Funding, Netting, and Accounting
  100.  *                  https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2534011 <b>eSSRN</b>
  101.  *          </li>
  102.  *          <li>
  103.  *              Pykhtin, M. (2009): Modeling Counter-party Credit Exposure in the Presence of Margin
  104.  *                  Agreements http://www.risk-europe.com/protected/michael-pykhtin.pdf
  105.  *          </li>
  106.  *      </ul>
  107.  *
  108.  *  <br><br>
  109.  *  <ul>
  110.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/PortfolioCore.md">Portfolio Core Module</a></li>
  111.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ExposureAnalyticsLibrary.md">Exposure Analytics</a></li>
  112.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/exposure/README.md">Exposure Group Level Collateralized/Uncollateralized Exposure</a></li>
  113.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/exposure/regressiontrade/README.md">Exposure Regression under Margin and Trade Payments</a></li>
  114.  *  </ul>
  115.  * 
  116.  * @author Lakshmi Krishnamurthy
  117.  */

  119. public class AndersenPykhtinSokolEnsemble
  120. {
  121.     private int[] _sparseExposureDateArray = null;
  122.     private org.drip.exposure.universe.MarketPath[] _marketPathArray = null;
  123.     private org.drip.exposure.mpor.VariationMarginTradePaymentVertex _marginTradePaymentGenerator = null;

  125.     /**
  126.      * AndersenPykhtinSokolEnsemble Constructor
  127.      * 
  128.      * @param marginTradePaymentGenerator The Variation Margin Estimate and the Trade Payment Generator
  129.      * @param marketPathArray Array of Market Paths
  130.      * @param sparseExposureDateArray Array of Sparse Exposure Dates
  131.      * 
  132.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  133.      */

  135.     public AndersenPykhtinSokolEnsemble (
  136.         final org.drip.exposure.mpor.VariationMarginTradePaymentVertex marginTradePaymentGenerator,
  137.         final org.drip.exposure.universe.MarketPath[] marketPathArray,
  138.         final int[] sparseExposureDateArray)
  139.         throws java.lang.Exception
  140.     {
  141.         if (null == (_marginTradePaymentGenerator = marginTradePaymentGenerator) ||
  142.             null == (_marketPathArray = marketPathArray) ||
  143.             null == (_sparseExposureDateArray = sparseExposureDateArray))
  144.         {
  145.             throw new java.lang.Exception ("AndersenPykhtinSokolEnsemble => Invalid Inputs");
  146.         }

  148.         int pathCount = _marketPathArray.length;
  149.         int sparseExposureDateCount = _sparseExposureDateArray.length;

  151.         if (0 == pathCount || 0 == sparseExposureDateCount)
  152.         {
  153.             throw new java.lang.Exception ("AndersenPykhtinSokolEnsemble => Invalid Inputs");
  154.         }

  156.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  157.         {
  158.             if (null == _marketPathArray[pathIndex])
  159.             {
  160.                 throw new java.lang.Exception ("AndersenPykhtinSokolEnsemble => Invalid Inputs");
  161.             }
  162.         }
  163.     }

  165.     /**
  166.      * Retrieve the Path-wise Variation Margin/Trade Payment Generator
  167.      * 
  168.      * @return The Path-wise Variation Margin/Trade Payment Generator
  169.      */

  171.     public org.drip.exposure.mpor.VariationMarginTradePaymentVertex marginTradePaymentGenerator()
  172.     {
  173.         return _marginTradePaymentGenerator;
  174.     }

  176.     /**
  177.      * Retrieve the Array of Market Paths
  178.      * 
  179.      * @return The Array of Market Paths
  180.      */

  182.     public org.drip.exposure.universe.MarketPath[] marketPathArray()
  183.     {
  184.         return _marketPathArray;
  185.     }

  187.     /**
  188.      * Retrieve the Array of Sparse Exposure Dates
  189.      * 
  190.      * @return The Array of Sparse Exposure Dates
  191.      */

  193.     public int[] sparseExposureDateArray()
  194.     {
  195.         return _sparseExposureDateArray;
  196.     }

  198.     /**
  199.      * Retrieve the Number of Simulation Paths
  200.      * 
  201.      * @return The Number of Simulation Paths
  202.      */

  204.     public int pathCount()
  205.     {
  206.         return _marketPathArray.length;
  207.     }

  209.     /**
  210.      * Retrieve the Number of Sparse Exposure Dates
  211.      * 
  212.      * @return The Number of Sparse Exposure Dates
  213.      */

  215.     public int sparseExposureDateCount()
  216.     {
  217.         return _sparseExposureDateArray.length;
  218.     }

  220.     /**
  221.      * Generate the Path-wise Adjusted Variation Margin Estimator
  222.      * 
  223.      * @return The Path-wise Adjusted Variation Margin Estimator
  224.      */

  226.     public org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimator[]
  227.         pathAdjustedVariationMarginEstimator()
  228.     {
  229.         int pathCount = _marketPathArray.length;
  230.         org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimator[]
  231.             adjustedVariationMarginEstimatorArray = new
  232.                 org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimator[pathCount];

  234.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  235.         {
  236.             try
  237.             {
  238.                 adjustedVariationMarginEstimatorArray[pathIndex] = new
  239.                     org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimator (
  240.                         _marginTradePaymentGenerator,
  241.                         _marketPathArray[pathIndex]
  242.                     );
  243.             }
  244.             catch (java.lang.Exception e)
  245.             {
  246.                 e.printStackTrace();

  248.                 return null;
  249.             }
  250.         }

  252.         return adjustedVariationMarginEstimatorArray;
  253.     }

  255.     /**
  256.      * Generate the Path-wise Adjusted Variation Margin Estimate
  257.      * 
  258.      * @return The Path-wise Adjusted Variation Margin Estimate
  259.      */

  261.     public org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimate[]
  262.         pathAdjustedVariationMarginEstimate()
  263.     {
  264.         int pathCount = _marketPathArray.length;
  265.         org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimate[]
  266.             adjustedVariationMarginEstimateArray = new
  267.                 org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimate[pathCount];

  269.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  270.         {
  271.             try
  272.             {
  273.                 adjustedVariationMarginEstimateArray[pathIndex] = new
  274.                     org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimator (
  275.                         _marginTradePaymentGenerator,
  276.                         _marketPathArray[pathIndex]
  277.                     ).adjustedVariationMarginEstimate (_sparseExposureDateArray);
  278.             }
  279.             catch (java.lang.Exception e)
  280.             {
  281.                 e.printStackTrace();

  283.                 return null;
  284.             }
  285.         }

  287.         return adjustedVariationMarginEstimateArray;
  288.     }

  290.     /**
  291.      * Generate the Ensemble Adjusted Variation Margin Dynamics
  292.      * 
  293.      * @return The Ensemble Adjusted Variation Margin Dynamics
  294.      */

  296.     public org.drip.exposure.regressiontrade.AdjustedVariationMarginDynamics
  297.         ensembleAdjustedVariationMarginDynamics()
  298.     {
  299.         int pathCount = _marketPathArray.length;
  300.         org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimate[]
  301.             adjustedVariationMarginEstimateArray = new
  302.                 org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimate[pathCount];

  304.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  305.         {
  306.             try
  307.             {
  308.                 adjustedVariationMarginEstimateArray[pathIndex] = new
  309.                     org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimator (
  310.                         _marginTradePaymentGenerator,
  311.                         _marketPathArray[pathIndex]
  312.                     ).adjustedVariationMarginEstimate (_sparseExposureDateArray);
  313.             }
  314.             catch (java.lang.Exception e)
  315.             {
  316.                 e.printStackTrace();

  318.                 return null;
  319.             }
  320.         }

  322.         try
  323.         {
  324.             return new org.drip.exposure.regressiontrade.AdjustedVariationMarginDynamics
  325.                 (adjustedVariationMarginEstimateArray);
  326.         }
  327.         catch (java.lang.Exception e)
  328.         {
  329.             e.printStackTrace();
  330.         }

  332.         return null;
  333.     }

  335.     /**
  336.      * Generate the Ensemble Pillar Dynamics Array
  337.      * 
  338.      * @return The Ensemble Pillar Dynamics Array
  339.      */

  341.     public org.drip.exposure.regression.PykhtinPillarDynamics[] ensemblePillarDynamics()
  342.     {
  343.         org.drip.exposure.regressiontrade.AdjustedVariationMarginDynamics adjustedVariationMarginDynamics =
  344.             ensembleAdjustedVariationMarginDynamics();

  346.         return null == adjustedVariationMarginDynamics ? null :
  347.             adjustedVariationMarginDynamics.pillarDynamics();
  348.     }

  350.     /**
  351.      * Generate the Path-wise Dense Variation Margin Array
  352.      * 
  353.      * @param localVolatilityGenerationControl Local Volatility Generation Control
  354.      * @param wanderEnsemble The Wander Ensemble
  355.      * 
  356.      * @return The Path-wise Dense Variation Margin Array
  357.      */

  359.     public double[][] denseVariationMargin (
  360.         final org.drip.exposure.regression.LocalVolatilityGenerationControl localVolatilityGenerationControl,
  361.         final double[][] wanderEnsemble)
  362.     {
  363.         if (null == wanderEnsemble)
  364.         {
  365.             return null;
  366.         }

  368.         int pathCount = _marketPathArray.length;
  369.         double[][] denseVariationMargin = new double[pathCount][];
  370.         int sparseExposureDateCount = _sparseExposureDateArray.length;
  371.         org.drip.function.definition.R1ToR1[] sparseLocalVolatilityArray = new
  372.             org.drip.function.definition.R1ToR1[sparseExposureDateCount];

  374.         if (pathCount != wanderEnsemble.length)
  375.         {
  376.             return null;
  377.         }

  379.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  380.         {
  381.             if (null == wanderEnsemble[pathIndex] || 0 == wanderEnsemble[pathIndex].length ||
  382.                 !org.drip.numerical.common.NumberUtil.IsValid (wanderEnsemble[pathIndex]))
  383.             {
  384.                 return null;
  385.             }
  386.         }

  388.         org.drip.exposure.regressiontrade.AdjustedVariationMarginDynamics adjustedVariationMarginDynamics =
  389.             ensembleAdjustedVariationMarginDynamics();

  391.         org.drip.exposure.regression.PykhtinPillarDynamics[] pillarDynamicsArray =
  392.             adjustedVariationMarginDynamics.pillarDynamics();

  394.         for (int sparseExposureDateIndex = 0;
  395.             sparseExposureDateIndex < sparseExposureDateCount;
  396.             ++sparseExposureDateIndex)
  397.         {
  398.             sparseLocalVolatilityArray[sparseExposureDateIndex] =
  399.                 pillarDynamicsArray[sparseExposureDateIndex].localVolatilityR1ToR1
  400.                     (localVolatilityGenerationControl);
  401.         }

  403.         org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimate[]
  404.             pathAdjustedVariationMarginEstimateArray =
  405.                 adjustedVariationMarginDynamics.adjustedVariationMarginEstimateArray();

  407.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  408.         {
  409.             try
  410.             {
  411.                 denseVariationMargin[pathIndex] = new
  412.                     org.drip.exposure.regression.AndersenPykhtinSokolStretch (
  413.                         _sparseExposureDateArray,
  414.                         pathAdjustedVariationMarginEstimateArray[pathIndex].adjustedVariationMarginEstimateArray(),
  415.                         sparseLocalVolatilityArray,
  416.                         pathAdjustedVariationMarginEstimateArray[pathIndex].denseTradePaymentArray()
  417.                     ).denseExposure (wanderEnsemble[pathIndex]);
  418.             }
  419.             catch (java.lang.Exception e)
  420.             {
  421.                 e.printStackTrace();
  422.             }
  423.         }

  425.         return denseVariationMargin;
  426.     }

  428.     /**
  429.      * Generate the Dense Variation Margin Trajectory
  430.      * 
  431.      * @param localVolatilityGenerationControl Local Volatility Generation Control
  432.      * @param wanderEnsemble The Wander Ensemble
  433.      * 
  434.      * @return The Dense Variation Margin Trajectory
  435.      */

  437.     public org.drip.exposure.regressiontrade.AndersenPykhtinSokolTrajectory[] denseTrajectory (
  438.         final org.drip.exposure.regression.LocalVolatilityGenerationControl localVolatilityGenerationControl,
  439.         final double[][] wanderEnsemble)
  440.     {
  441.         if (null == wanderEnsemble)
  442.         {
  443.             return null;
  444.         }

  446.         int pathCount = _marketPathArray.length;
  447.         int denseExposureStartDate = _sparseExposureDateArray[0];
  448.         int sparseExposureDateCount = _sparseExposureDateArray.length;
  449.         int denseExposureEndDate = _sparseExposureDateArray[sparseExposureDateCount - 1];
  450.         org.drip.function.definition.R1ToR1[] sparseLocalVolatilityArray = new
  451.             org.drip.function.definition.R1ToR1[sparseExposureDateCount];
  452.         org.drip.exposure.regressiontrade.AndersenPykhtinSokolTrajectory[]
  453.             andersenPykhtinSokolTrajectoryArray = new
  454.                 org.drip.exposure.regressiontrade.AndersenPykhtinSokolTrajectory[pathCount];

  456.         if (pathCount != wanderEnsemble.length)
  457.         {
  458.             return null;
  459.         }

  461.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  462.         {
  463.             if (null == wanderEnsemble[pathIndex] || 0 == wanderEnsemble[pathIndex].length ||
  464.                 !org.drip.numerical.common.NumberUtil.IsValid (wanderEnsemble[pathIndex]))
  465.             {
  466.                 return null;
  467.             }
  468.         }

  470.         org.drip.exposure.regressiontrade.AdjustedVariationMarginDynamics adjustedVariationMarginDynamics =
  471.             ensembleAdjustedVariationMarginDynamics();

  473.         org.drip.exposure.regression.PykhtinPillarDynamics[] pillarDynamicsArray =
  474.             adjustedVariationMarginDynamics.pillarDynamics();

  476.         for (int sparseExposureDateIndex = 0;
  477.             sparseExposureDateIndex < sparseExposureDateCount;
  478.             ++sparseExposureDateIndex)
  479.         {
  480.             sparseLocalVolatilityArray[sparseExposureDateIndex] =
  481.                 pillarDynamicsArray[sparseExposureDateIndex].localVolatilityR1ToR1
  482.                     (localVolatilityGenerationControl);
  483.         }

  485.         org.drip.exposure.regressiontrade.AdjustedVariationMarginEstimate[]
  486.             pathAdjustedVariationMarginEstimateArray =
  487.                 adjustedVariationMarginDynamics.adjustedVariationMarginEstimateArray();

  489.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  490.         {
  491.             java.util.Map<java.lang.Integer, java.lang.Double> variationMarginEstimateTrajectory = new
  492.                 java.util.HashMap<java.lang.Integer, java.lang.Double>();

  494.             try
  495.             {
  496.                 org.drip.exposure.mpor.TradePayment[] tradePaymentTrajectory =
  497.                     pathAdjustedVariationMarginEstimateArray[pathIndex].denseTradePaymentArray();

  499.                 double[] denseExposureArray = new org.drip.exposure.regression.AndersenPykhtinSokolStretch (
  500.                     _sparseExposureDateArray,
  501.                     pathAdjustedVariationMarginEstimateArray[pathIndex].adjustedVariationMarginEstimateArray(),
  502.                     sparseLocalVolatilityArray,
  503.                     tradePaymentTrajectory
  504.                 ).denseExposure (wanderEnsemble[pathIndex]);

  506.                 for (int denseExposureDate = denseExposureStartDate;
  507.                     denseExposureDate <= denseExposureEndDate;
  508.                     ++denseExposureDate)
  509.                 {
  510.                     variationMarginEstimateTrajectory.put (
  511.                         denseExposureDate,
  512.                         denseExposureArray[denseExposureDate - denseExposureStartDate]
  513.                     );
  514.                 }

  516.                 andersenPykhtinSokolTrajectoryArray[pathIndex] = new
  517.                     org.drip.exposure.regressiontrade.AndersenPykhtinSokolTrajectory (
  518.                     variationMarginEstimateTrajectory,
  519.                     tradePaymentTrajectory
  520.                 );
  521.             }
  522.             catch (java.lang.Exception e)
  523.             {
  524.                 e.printStackTrace();
  525.             }
  526.         }

  528.         return andersenPykhtinSokolTrajectoryArray;
  529.     }
  530. }
Created with JaCoCo 0.7.9.201702052155