ExposureAdjustmentAggregator.java

  1. package org.drip.xva.gross;

  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>ExposureAdjustmentAggregator</i> aggregates across Multiple Exposure/Adjustment Paths belonging to the
  81.  * Counter Party. The References are:
  82.  *
  83.  *  <br><br>
  84.  *  <ul>
  85.  *      <li>
  86.  *          Burgard, C., and M. Kjaer (2014): PDE Representations of Derivatives with Bilateral Counter-party
  87.  *              Risk and Funding Costs <i>Journal of Credit Risk</i> <b>7 (3)</b> 1-19
  88.  *      </li>
  89.  *      <li>
  90.  *          Burgard, C., and M. Kjaer (2014): In the Balance <i>Risk</i> <b>24 (11)</b> 72-75
  91.  *      </li>
  92.  *      <li>
  93.  *          Gregory, J. (2009): Being Two-faced over Counter-party Credit Risk <i>Risk</i> <b>20 (2)</b>
  94.  *              86-90
  95.  *      </li>
  96.  *      <li>
  97.  *          Li, B., and Y. Tang (2007): <i>Quantitative Analysis, Derivatives Modeling, and Trading
  98.  *              Strategies in the Presence of Counter-party Credit Risk for the Fixed Income Market</i>
  99.  *              <b>World Scientific Publishing</b> Singapore
  100.  *      </li>
  101.  *      <li>
  102.  *          Piterbarg, V. (2010): Funding Beyond Discounting: Collateral Agreements and Derivatives Pricing
  103.  *              <i>Risk</i> <b>21 (2)</b> 97-102
  104.  *      </li>
  105.  *  </ul>
  106.  *
  107.  *  <br><br>
  108.  *  <ul>
  109.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/PortfolioCore.md">Portfolio Core Module</a></li>
  110.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/XVAAnalyticsLibrary.md">XVA Analytics Library</a></li>
  111.  *      <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>
  112.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/xva/gross/README.md">XVA Gross Adiabat Exposure Aggregation</a></li>
  113.  *  </ul>
  114.  * <br><br>
  115.  * 
  116.  * @author Lakshmi Krishnamurthy
  117.  */

  119. public class ExposureAdjustmentAggregator
  120. {
  121.     private org.drip.xva.gross.PathExposureAdjustment[] _pathExposureAdjustmentArray = null;

  123.     /**
  124.      * ExposureAdjustmentAggregator Constructor
  125.      * 
  126.      * @param pathExposureAdjustmentArray Array of the Counter Party Group Paths
  127.      * 
  128.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  129.      */

  131.     public ExposureAdjustmentAggregator (
  132.         final org.drip.xva.gross.PathExposureAdjustment[] pathExposureAdjustmentArray)
  133.         throws java.lang.Exception
  134.     {
  135.         if (null == (_pathExposureAdjustmentArray = pathExposureAdjustmentArray) ||
  136.             0 == _pathExposureAdjustmentArray.length)
  137.         {
  138.             throw new java.lang.Exception ("ExposureAdjustmentAggregator Constructor => Invalid Inputs");
  139.         }
  140.     }

  142.     /**
  143.      * Retrieve the Array of Group Path Exposure Adjustments
  144.      * 
  145.      * @return Array of Group Path Exposure Adjustments
  146.      */

  148.     public org.drip.xva.gross.PathExposureAdjustment[] pathExposureAdjustmentArray()
  149.     {
  150.         return _pathExposureAdjustmentArray;
  151.     }

  153.     /**
  154.      * Retrieve the Array of the Vertex Anchor Dates
  155.      * 
  156.      * @return The Array of the Vertex Anchor Dates
  157.      */

  159.     public org.drip.analytics.date.JulianDate[] vertexDates()
  160.     {
  161.         return _pathExposureAdjustmentArray[0].vertexDates();
  162.     }

  164.     /**
  165.      * Retrieve the Array of Collateralized Exposures
  166.      * 
  167.      * @return The Array of Collateralized Exposures
  168.      */

  170.     public double[] collateralizedExposure()
  171.     {
  172.         int vertexCount = vertexDates().length;

  174.         int pathCount = _pathExposureAdjustmentArray.length;
  175.         double[] collateralizedExposure = new double[vertexCount];

  177.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  178.         {
  179.             collateralizedExposure[vertexIndex] = 0.;
  180.         }

  182.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  183.         {
  184.             double[] pathCollateralizedExposure =
  185.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedExposure();

  187.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  188.             {
  189.                 collateralizedExposure[vertexIndex] += pathCollateralizedExposure[vertexIndex];
  190.             }
  191.         }

  193.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  194.         {
  195.             collateralizedExposure[vertexIndex] /= pathCount;
  196.         }

  198.         return collateralizedExposure;
  199.     }

  201.     /**
  202.      * Retrieve the Array of Collateralized Exposure PV's
  203.      * 
  204.      * @return The Array of Collateralized Exposure PV's
  205.      */

  207.     public double[] collateralizedExposurePV()
  208.     {
  209.         int vertexCount = vertexDates().length;

  211.         int pathCount = _pathExposureAdjustmentArray.length;
  212.         double[] collateralizedExposurePV = new double[vertexCount];

  214.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  215.         {
  216.             collateralizedExposurePV[vertexIndex] = 0.;
  217.         }

  219.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  220.         {
  221.             double[] pathCollateralizedExposurePV =
  222.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedExposurePV();

  224.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  225.             {
  226.                 collateralizedExposurePV[vertexIndex] += pathCollateralizedExposurePV[vertexIndex];
  227.             }
  228.         }

  230.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  231.         {
  232.             collateralizedExposurePV[vertexIndex] /= pathCount;
  233.         }

  235.         return collateralizedExposurePV;
  236.     }

  238.     /**
  239.      * Retrieve the Array of Uncollateralized Exposures
  240.      * 
  241.      * @return The Array of Uncollateralized Exposures
  242.      */

  244.     public double[] uncollateralizedExposure()
  245.     {
  246.         int vertexCount = vertexDates().length;

  248.         int pathCount = _pathExposureAdjustmentArray.length;
  249.         double[] uncollateralizedExposure = new double[vertexCount];

  251.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  252.         {
  253.             uncollateralizedExposure[vertexIndex] = 0.;
  254.         }

  256.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  257.         {
  258.             double[] pathUncollateralizedExposure =
  259.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedExposure();

  261.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  262.             {
  263.                 uncollateralizedExposure[vertexIndex] += pathUncollateralizedExposure[vertexIndex];
  264.             }
  265.         }

  267.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  268.             uncollateralizedExposure[vertexIndex] /= pathCount;

  270.         return uncollateralizedExposure;
  271.     }

  273.     /**
  274.      * Retrieve the Array of Uncollateralized Exposure PV's
  275.      * 
  276.      * @return The Array of Uncollateralized Exposure PV's
  277.      */

  279.     public double[] uncollateralizedExposurePV()
  280.     {
  281.         int vertexCount = vertexDates().length;

  283.         int pathCount = _pathExposureAdjustmentArray.length;
  284.         double[] uncollateralizedExposurePV = new double[vertexCount];

  286.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  287.         {
  288.             uncollateralizedExposurePV[vertexIndex] = 0.;
  289.         }

  291.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  292.         {
  293.             double[] pathUncollateralizedExposurePV =
  294.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedExposurePV();

  296.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  297.             {
  298.                 uncollateralizedExposurePV[vertexIndex] +=
  299.                     pathUncollateralizedExposurePV[vertexIndex];
  300.             }
  301.         }

  303.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  304.         {
  305.             uncollateralizedExposurePV[vertexIndex] /= pathCount;
  306.         }

  308.         return uncollateralizedExposurePV;
  309.     }

  311.     /**
  312.      * Retrieve the Array of Collateralized Positive Exposures
  313.      * 
  314.      * @return The Array of Collateralized Positive Exposures
  315.      */

  317.     public double[] collateralizedPositiveExposure()
  318.     {
  319.         int vertexCount = vertexDates().length;

  321.         int pathCount = _pathExposureAdjustmentArray.length;
  322.         double[] collateralizedPositiveExposure = new double[vertexCount];

  324.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  325.         {
  326.             collateralizedPositiveExposure[vertexIndex] = 0.;
  327.         }

  329.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  330.         {
  331.             double[] pathCollateralizedPositiveExposure =
  332.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedPositiveExposure();

  334.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  335.             {
  336.                 collateralizedPositiveExposure[vertexIndex] +=
  337.                     pathCollateralizedPositiveExposure[vertexIndex];
  338.             }
  339.         }

  341.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  342.         {
  343.             collateralizedPositiveExposure[vertexIndex] /= pathCount;
  344.         }

  346.         return collateralizedPositiveExposure;
  347.     }

  349.     /**
  350.      * Retrieve the Array of Collateralized Positive Exposure PV
  351.      * 
  352.      * @return The Array of Collateralized Positive Exposure PV
  353.      */

  355.     public double[] collateralizedPositiveExposurePV()
  356.     {
  357.         int vertexCount = vertexDates().length;

  359.         int pathCount = _pathExposureAdjustmentArray.length;
  360.         double[] collateralizedPositiveExposurePV = new double[vertexCount];

  362.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  363.         {
  364.             collateralizedPositiveExposurePV[vertexIndex] = 0.;
  365.         }

  367.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  368.         {
  369.             double[] pathCollateralizedPositiveExposurePV =
  370.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedPositiveExposurePV();

  372.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  373.             {
  374.                 collateralizedPositiveExposurePV[vertexIndex] +=
  375.                     pathCollateralizedPositiveExposurePV[vertexIndex];
  376.             }
  377.         }

  379.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  380.         {
  381.             collateralizedPositiveExposurePV[vertexIndex] /= pathCount;
  382.         }

  384.         return collateralizedPositiveExposurePV;
  385.     }

  387.     /**
  388.      * Retrieve the Array of Uncollateralized Positive Exposures
  389.      * 
  390.      * @return The Array of Uncollateralized Positive Exposures
  391.      */

  393.     public double[] uncollateralizedPositiveExposure()
  394.     {
  395.         int vertexCount = vertexDates().length;

  397.         int pathCount = _pathExposureAdjustmentArray.length;
  398.         double[] uncollateralizedPositiveExposure = new double[vertexCount];

  400.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  401.         {
  402.             uncollateralizedPositiveExposure[vertexIndex] = 0.;
  403.         }

  405.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  406.         {
  407.             double[] pathUncollateralizedPositiveExposure =
  408.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedPositiveExposure();

  410.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  411.             {
  412.                 uncollateralizedPositiveExposure[vertexIndex] +=
  413.                     pathUncollateralizedPositiveExposure[vertexIndex];
  414.             }
  415.         }

  417.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  418.         {
  419.             uncollateralizedPositiveExposure[vertexIndex] /= pathCount;
  420.         }

  422.         return uncollateralizedPositiveExposure;
  423.     }

  425.     /**
  426.      * Retrieve the Array of Uncollateralized Positive Exposure PV
  427.      * 
  428.      * @return The Array of Uncollateralized Positive Exposure PV
  429.      */

  431.     public double[] uncollateralizedPositiveExposurePV()
  432.     {
  433.         int vertexCount = vertexDates().length;

  435.         int pathCount = _pathExposureAdjustmentArray.length;
  436.         double[] uncollateralizedPositiveExposurePV = new double[vertexCount];

  438.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  439.         {
  440.             uncollateralizedPositiveExposurePV[vertexIndex] = 0.;
  441.         }

  443.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  444.         {
  445.             double[] pathUncollateralizedPositiveExposurePV =
  446.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedPositiveExposurePV();

  448.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  449.             {
  450.                 uncollateralizedPositiveExposurePV[vertexIndex] +=
  451.                     pathUncollateralizedPositiveExposurePV[vertexIndex];
  452.             }
  453.         }

  455.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  456.         {
  457.             uncollateralizedPositiveExposurePV[vertexIndex] /= pathCount;
  458.         }

  460.         return uncollateralizedPositiveExposurePV;
  461.     }

  463.     /**
  464.      * Retrieve the Array of Collateralized Negative Exposures
  465.      * 
  466.      * @return The Array of Collateralized Negative Exposures
  467.      */

  469.     public double[] collateralizedNegativeExposure()
  470.     {
  471.         int vertexCount = vertexDates().length;

  473.         int pathCount = _pathExposureAdjustmentArray.length;
  474.         double[] collateralizedNegativeExposure = new double[vertexCount];

  476.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  477.         {
  478.             collateralizedNegativeExposure[vertexIndex] = 0.;
  479.         }

  481.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  482.         {
  483.             double[] pathCollateralizedNegativeExposure =
  484.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedNegativeExposure();

  486.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  487.             {
  488.                 collateralizedNegativeExposure[vertexIndex] +=
  489.                     pathCollateralizedNegativeExposure[vertexIndex];
  490.             }
  491.         }

  493.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  494.         {
  495.             collateralizedNegativeExposure[vertexIndex] /= pathCount;
  496.         }

  498.         return collateralizedNegativeExposure;
  499.     }

  501.     /**
  502.      * Retrieve the Array of Collateralized Negative Exposure PV
  503.      * 
  504.      * @return The Array of Collateralized Negative Exposure PV
  505.      */

  507.     public double[] collateralizedNegativeExposurePV()
  508.     {
  509.         int vertexCount = vertexDates().length;

  511.         int pathCount = _pathExposureAdjustmentArray.length;
  512.         double[] collateralizedNegativeExposurePV = new double[vertexCount];

  514.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  515.         {
  516.             collateralizedNegativeExposurePV[vertexIndex] = 0.;
  517.         }

  519.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  520.         {
  521.             double[] pathCollateralizedNegativeExposurePV =
  522.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedNegativeExposurePV();

  524.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  525.             {
  526.                 collateralizedNegativeExposurePV[vertexIndex] +=
  527.                     pathCollateralizedNegativeExposurePV[vertexIndex];
  528.             }
  529.         }

  531.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  532.         {
  533.             collateralizedNegativeExposurePV[vertexIndex] /= pathCount;
  534.         }

  536.         return collateralizedNegativeExposurePV;
  537.     }

  539.     /**
  540.      * Retrieve the Array of Uncollateralized Negative Exposures
  541.      * 
  542.      * @return The Array of Uncollateralized Negative Exposures
  543.      */

  545.     public double[] uncollateralizedNegativeExposure()
  546.     {
  547.         int vertexCount = vertexDates().length;

  549.         int pathCount = _pathExposureAdjustmentArray.length;
  550.         double[] uncollateralizedNegativeExposure = new double[vertexCount];

  552.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  553.         {
  554.             uncollateralizedNegativeExposure[vertexIndex] = 0.;
  555.         }

  557.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  558.         {
  559.             double[] pathUncollateralizedNegativeExposure =
  560.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedNegativeExposure();

  562.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  563.             {
  564.                 uncollateralizedNegativeExposure[vertexIndex] +=
  565.                     pathUncollateralizedNegativeExposure[vertexIndex];
  566.             }
  567.         }

  569.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  570.         {
  571.             uncollateralizedNegativeExposure[vertexIndex] /= pathCount;
  572.         }

  574.         return uncollateralizedNegativeExposure;
  575.     }

  577.     /**
  578.      * Retrieve the Array of Uncollateralized Negative Exposure PV
  579.      * 
  580.      * @return The Array of Uncollateralized Negative Exposure PV
  581.      */

  583.     public double[] uncollateralizedNegativeExposurePV()
  584.     {
  585.         int vertexCount = vertexDates().length;

  587.         int pathCount = _pathExposureAdjustmentArray.length;
  588.         double[] uncollateralizedNegativeExposurePV = new double[vertexCount];

  590.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  591.         {
  592.             uncollateralizedNegativeExposurePV[vertexIndex] = 0.;
  593.         }

  595.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  596.         {
  597.             double[] pathUncollateralizedNegativeExposurePV =
  598.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedNegativeExposurePV();

  600.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  601.             {
  602.                 uncollateralizedNegativeExposurePV[vertexIndex] +=
  603.                     pathUncollateralizedNegativeExposurePV[vertexIndex];
  604.             }
  605.         }

  607.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  608.         {
  609.             uncollateralizedNegativeExposurePV[vertexIndex] /= pathCount;
  610.         }

  612.         return uncollateralizedNegativeExposurePV;
  613.     }

  615.     /**
  616.      * Retrieve the Array of Funding Exposures
  617.      * 
  618.      * @return The Array of Funding Exposures
  619.      */

  621.     public double[] fundingExposure()
  622.     {
  623.         int vertexCount = vertexDates().length;

  625.         double[] fundingExposure = new double[vertexCount];
  626.         int pathCount = _pathExposureAdjustmentArray.length;

  628.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  629.         {
  630.             fundingExposure[vertexIndex] = 0.;
  631.         }

  633.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  634.         {
  635.             double[] pathFundingExposure = _pathExposureAdjustmentArray[pathIndex].vertexFundingExposure();

  637.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  638.             {
  639.                 fundingExposure[vertexIndex] += pathFundingExposure[vertexIndex];
  640.             }
  641.         }

  643.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  644.         {
  645.             fundingExposure[vertexIndex] /= pathCount;
  646.         }

  648.         return fundingExposure;
  649.     }

  651.     /**
  652.      * Retrieve the Array of Funding Exposure PV
  653.      * 
  654.      * @return The Array of Funding Exposure PV
  655.      */

  657.     public double[] fundingExposurePV()
  658.     {
  659.         int vertexCount = vertexDates().length;

  661.         int pathCount = _pathExposureAdjustmentArray.length;
  662.         double[] fundingExposurePV = new double[vertexCount];

  664.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  665.         {
  666.             fundingExposurePV[vertexIndex] = 0.;
  667.         }

  669.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  670.         {
  671.             double[] pathFundingExposurePV =
  672.                 _pathExposureAdjustmentArray[pathIndex].vertexFundingExposurePV();

  674.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  675.             {
  676.                 fundingExposurePV[vertexIndex] += pathFundingExposurePV[vertexIndex];
  677.             }
  678.         }

  680.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  681.         {
  682.             fundingExposurePV[vertexIndex] /= pathCount;
  683.         }

  685.         return fundingExposurePV;
  686.     }

  688.     /**
  689.      * Retrieve the Expected Bilateral Collateral VA
  690.      * 
  691.      * @return The Expected Bilateral Collateral VA
  692.      */

  694.     public org.drip.xva.basel.ValueAdjustment ftdcolva()
  695.     {
  696.         double ftdcolva = 0.;
  697.         int pathCount = _pathExposureAdjustmentArray.length;

  699.         try
  700.         {
  701.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  702.             {
  703.                 ftdcolva += _pathExposureAdjustmentArray[pathIndex].bilateralCollateralAdjustment();
  704.             }
  705.         }
  706.         catch (java.lang.Exception e)
  707.         {
  708.             e.printStackTrace();

  710.             return null;
  711.         }

  713.         return org.drip.xva.basel.ValueAdjustment.COLVA (ftdcolva / pathCount);
  714.     }

  716.     /**
  717.      * Retrieve the Expected Collateral VA
  718.      * 
  719.      * @return The Expected Collateral VA
  720.      */

  722.     public org.drip.xva.basel.ValueAdjustment colva()
  723.     {
  724.         double colva = 0.;
  725.         int pathCount = _pathExposureAdjustmentArray.length;

  727.         try
  728.         {
  729.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  730.             {
  731.                 colva += _pathExposureAdjustmentArray[pathIndex].bilateralCollateralAdjustment();
  732.             }
  733.         }
  734.         catch (java.lang.Exception e)
  735.         {
  736.             e.printStackTrace();

  738.             return null;
  739.         }

  741.         return org.drip.xva.basel.ValueAdjustment.COLVA (colva / pathCount);
  742.     }

  744.     /**
  745.      * Retrieve the Expected Unilateral CVA
  746.      * 
  747.      * @return The Expected Unilateral CVA
  748.      */

  750.     public org.drip.xva.basel.ValueAdjustment ucva()
  751.     {
  752.         double ucva = 0.;
  753.         int pathCount = _pathExposureAdjustmentArray.length;

  755.         try
  756.         {
  757.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  758.             {
  759.                 ucva += _pathExposureAdjustmentArray[pathIndex].unilateralCreditAdjustment();
  760.             }
  761.         }
  762.         catch (java.lang.Exception e)
  763.         {
  764.             e.printStackTrace();

  766.             return null;
  767.         }

  769.         return org.drip.xva.basel.ValueAdjustment.UCVA (ucva / pathCount);
  770.     }

  772.     /**
  773.      * Retrieve the Expected Bilateral/FTD CVA
  774.      * 
  775.      * @return The Expected Bilateral/FTD CVA
  776.      */

  778.     public org.drip.xva.basel.ValueAdjustment ftdcva()
  779.     {
  780.         double ftdcva = 0.;
  781.         int pathCount = _pathExposureAdjustmentArray.length;

  783.         try
  784.         {
  785.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  786.             {
  787.                 ftdcva += _pathExposureAdjustmentArray[pathIndex].bilateralCreditAdjustment();
  788.             }
  789.         }
  790.         catch (java.lang.Exception e)
  791.         {
  792.             e.printStackTrace();

  794.             return null;
  795.         }

  797.         return org.drip.xva.basel.ValueAdjustment.FTDCVA (ftdcva / pathCount);
  798.     }

  800.     /**
  801.      * Retrieve the Expected CVA
  802.      * 
  803.      * @return The Expected CVA
  804.      */

  806.     public org.drip.xva.basel.ValueAdjustment cva()
  807.     {
  808.         return ftdcva();
  809.     }

  811.     /**
  812.      * Retrieve the Expected CVA Contra-Liability
  813.      * 
  814.      * @return The Expected CVA Contra-Liability
  815.      */

  817.     public org.drip.xva.basel.ValueAdjustment cvacl()
  818.     {
  819.         double cvacl = 0.;
  820.         int pathCount = _pathExposureAdjustmentArray.length;

  822.         try
  823.         {
  824.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  825.             {
  826.                 cvacl += _pathExposureAdjustmentArray[pathIndex].contraLiabilityCreditAdjustment();
  827.             }
  828.         }
  829.         catch (java.lang.Exception e)
  830.         {
  831.             e.printStackTrace();

  833.             return null;
  834.         }

  836.         return org.drip.xva.basel.ValueAdjustment.CVACL (cvacl / pathCount);
  837.     }

  839.     /**
  840.      * Retrieve the Expected Unilateral DVA
  841.      * 
  842.      * @return The Expected Unilateral DVA
  843.      */

  845.     public org.drip.xva.basel.ValueAdjustment udva()
  846.     {
  847.         double udva = 0.;
  848.         int pathCount = _pathExposureAdjustmentArray.length;

  850.         try {
  851.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  852.             {
  853.                 udva += _pathExposureAdjustmentArray[pathIndex].unilateralDebtAdjustment();
  854.             }
  855.         }
  856.         catch (java.lang.Exception e)
  857.         {
  858.             e.printStackTrace();

  860.             return null;
  861.         }

  863.         return org.drip.xva.basel.ValueAdjustment.DVA (udva / pathCount);
  864.     }

  866.     /**
  867.      * Retrieve the Expected Bilateral DVA
  868.      * 
  869.      * @return The Expected Bilateral DVA
  870.      */

  872.     public org.drip.xva.basel.ValueAdjustment ftddva()
  873.     {
  874.         double ftddva = 0.;
  875.         int pathCount = _pathExposureAdjustmentArray.length;

  877.         try {
  878.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  879.             {
  880.                 ftddva += _pathExposureAdjustmentArray[pathIndex].bilateralDebtAdjustment();
  881.             }
  882.         }
  883.         catch (java.lang.Exception e)
  884.         {
  885.             e.printStackTrace();

  887.             return null;
  888.         }

  890.         return org.drip.xva.basel.ValueAdjustment.DVA (ftddva / pathCount);
  891.     }

  893.     /**
  894.      * Retrieve the Expected DVA
  895.      * 
  896.      * @return The Expected DVA
  897.      */

  899.     public org.drip.xva.basel.ValueAdjustment dva()
  900.     {
  901.         double dva = 0.;
  902.         int pathCount = _pathExposureAdjustmentArray.length;

  904.         try {
  905.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  906.             {
  907.                 dva += _pathExposureAdjustmentArray[pathIndex].debtAdjustment();
  908.             }
  909.         }
  910.         catch (java.lang.Exception e)
  911.         {
  912.             e.printStackTrace();

  914.             return null;
  915.         }

  917.         return org.drip.xva.basel.ValueAdjustment.DVA (dva / pathCount);
  918.     }

  920.     /**
  921.      * Retrieve the Expected FVA
  922.      * 
  923.      * @return The Expected FVA
  924.      */

  926.     public org.drip.xva.basel.ValueAdjustment fva()
  927.     {
  928.         double fva = 0.;
  929.         int pathCount = _pathExposureAdjustmentArray.length;

  931.         try
  932.         {
  933.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  934.             {
  935.                 fva += _pathExposureAdjustmentArray[pathIndex].fundingValueAdjustment();
  936.             }
  937.         }
  938.         catch (java.lang.Exception e)
  939.         {
  940.             e.printStackTrace();

  942.             return null;
  943.         }

  945.         return org.drip.xva.basel.ValueAdjustment.FVA (fva / pathCount);
  946.     }

  948.     /**
  949.      * Retrieve the Expected FDA
  950.      * 
  951.      * @return The Expected FDA
  952.      */

  954.     public org.drip.xva.basel.ValueAdjustment fda()
  955.     {
  956.         double fda = 0.;
  957.         int pathCount = _pathExposureAdjustmentArray.length;

  959.         try
  960.         {
  961.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  962.             {
  963.                 fda += _pathExposureAdjustmentArray[pathIndex].fundingDebtAdjustment();
  964.             }
  965.         }
  966.         catch (java.lang.Exception e)
  967.         {
  968.             e.printStackTrace();

  970.             return null;
  971.         }

  973.         return org.drip.xva.basel.ValueAdjustment.FDA (fda / pathCount);
  974.     }

  976.     /**
  977.      * Retrieve the Expected DVA2
  978.      * 
  979.      * @return The Expected DVA2
  980.      */

  982.     public org.drip.xva.basel.ValueAdjustment dva2()
  983.     {
  984.         return fda();
  985.     }

  987.     /**
  988.      * Retrieve the Expected FCA
  989.      * 
  990.      * @return The Expected FCA
  991.      */

  993.     public org.drip.xva.basel.ValueAdjustment fca()
  994.     {
  995.         double fca = 0.;
  996.         int pathCount = _pathExposureAdjustmentArray.length;

  998.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  999.         {
  1000.             fca += _pathExposureAdjustmentArray[pathIndex].fundingCostAdjustment();
  1001.         }

  1003.         return org.drip.xva.basel.ValueAdjustment.HYBRID (fca / pathCount);
  1004.     }

  1006.     /**
  1007.      * Retrieve the Expected FBA
  1008.      * 
  1009.      * @return The Expected FBA
  1010.      */

  1012.     public org.drip.xva.basel.ValueAdjustment fba()
  1013.     {
  1014.         double fba = 0.;
  1015.         int pathCount = _pathExposureAdjustmentArray.length;

  1017.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  1018.         {
  1019.             fba += _pathExposureAdjustmentArray[pathIndex].fundingBenefitAdjustment();
  1020.         }

  1022.         return org.drip.xva.basel.ValueAdjustment.HYBRID (fba / pathCount);
  1023.     }

  1025.     /**
  1026.      * Retrieve the Expected SFVA
  1027.      * 
  1028.      * @return The Expected SFVA
  1029.      */

  1031.     public org.drip.xva.basel.ValueAdjustment sfva()
  1032.     {
  1033.         double sfva = 0.;
  1034.         int pathCount = _pathExposureAdjustmentArray.length;

  1036.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  1037.         {
  1038.             sfva += _pathExposureAdjustmentArray[pathIndex].symmetricFundingValueAdjustment();
  1039.         }

  1041.         return org.drip.xva.basel.ValueAdjustment.HYBRID (sfva / pathCount);
  1042.     }

  1044.     /**
  1045.      * Retrieve the Total VA
  1046.      * 
  1047.      * @return The Total VA
  1048.      */

  1050.     public double total()
  1051.     {
  1052.         return cva().amount() + dva().amount() + fva().amount() + colva().amount();
  1053.     }

  1055.     /**
  1056.      * Generate the "Digest" containing the "Thin" Path Statistics
  1057.      * 
  1058.      * @return The "Digest" containing the "Thin" Path Statistics
  1059.      */

  1061.     public org.drip.xva.gross.ExposureAdjustmentDigest digest()
  1062.     {
  1063.         int vertexCount = vertexDates().length;

  1065.         int pathCount = _pathExposureAdjustmentArray.length;
  1066.         double[] pathCVA = new double[pathCount];
  1067.         double[] pathDVA = new double[pathCount];
  1068.         double[] pathFBA = new double[pathCount];
  1069.         double[] pathFCA = new double[pathCount];
  1070.         double[] pathFDA = new double[pathCount];
  1071.         double[] pathFVA = new double[pathCount];
  1072.         double[] pathUCVA = new double[pathCount];
  1073.         double[] pathSFVA = new double[pathCount];
  1074.         double[] pathCVACL = new double[pathCount];
  1075.         double[] pathFTDCVA = new double[pathCount];
  1076.         double[] pathCOLVA = new double[pathCount];
  1077.         double[] pathTotalVA = new double[pathCount];
  1078.         double[] pathFTDCOLVA = new double[pathCount];
  1079.         double[][] fundingExposure = new double[vertexCount][pathCount];
  1080.         double[][] fundingExposurePV = new double[vertexCount][pathCount];
  1081.         double[][] collateralizedExposure = new double[vertexCount][pathCount];
  1082.         double[][] uncollateralizedExposure = new double[vertexCount][pathCount];
  1083.         double[][] collateralizedExposurePV = new double[vertexCount][pathCount];
  1084.         double[][] uncollateralizedExposurePV = new double[vertexCount][pathCount];
  1085.         double[][] collateralizedPositiveExposure = new double[vertexCount][pathCount];
  1086.         double[][] collateralizedNegativeExposure = new double[vertexCount][pathCount];
  1087.         double[][] uncollateralizedPositiveExposure = new double[vertexCount][pathCount];
  1088.         double[][] uncollateralizedNegativeExposure = new double[vertexCount][pathCount];
  1089.         double[][] collateralizedPositiveExposurePV = new double[vertexCount][pathCount];
  1090.         double[][] collateralizedNegativeExposurePV = new double[vertexCount][pathCount];
  1091.         double[][] uncollateralizedPositiveExposurePV = new double[vertexCount][pathCount];
  1092.         double[][] uncollateralizedNegativeExposurePV = new double[vertexCount][pathCount];

  1094.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  1095.         {
  1096.             for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  1097.             {
  1098.                 collateralizedExposure[vertexIndex][pathIndex] = 0.;
  1099.                 uncollateralizedExposure[vertexIndex][pathIndex] = 0.;
  1100.                 collateralizedExposurePV[vertexIndex][pathIndex] = 0.;
  1101.                 uncollateralizedExposurePV[vertexIndex][pathIndex] = 0.;
  1102.                 collateralizedPositiveExposure[vertexIndex][pathIndex] = 0.;
  1103.                 collateralizedNegativeExposure[vertexIndex][pathIndex] = 0.;
  1104.                 uncollateralizedPositiveExposure[vertexIndex][pathIndex] = 0.;
  1105.                 uncollateralizedNegativeExposure[vertexIndex][pathIndex] = 0.;
  1106.                 collateralizedPositiveExposurePV[vertexIndex][pathIndex] = 0.;
  1107.                 collateralizedNegativeExposurePV[vertexIndex][pathIndex] = 0.;
  1108.                 uncollateralizedPositiveExposurePV[vertexIndex][pathIndex] = 0.;
  1109.                 uncollateralizedNegativeExposurePV[vertexIndex][pathIndex] = 0.;
  1110.             }
  1111.         }

  1113.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  1114.         {
  1115.             double[] pathCollateralizedExposure =
  1116.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedExposure();

  1118.             double[] pathCollateralizedExposurePV =
  1119.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedExposurePV();

  1121.             double[] pathCollateralizedPositiveExposure =
  1122.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedPositiveExposure();

  1124.             double[] pathCollateralizedPositiveExposurePV =
  1125.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedPositiveExposurePV();

  1127.             double[] pathCollateralizedNegativeExposure =
  1128.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedNegativeExposure();

  1130.             double[] pathCollateralizedNegativeExposurePV =
  1131.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedNegativeExposurePV();

  1133.             double[] pathUncollateralizedExposure =
  1134.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedExposure();

  1136.             double[] pathUncollateralizedExposurePV =
  1137.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedExposurePV();

  1139.             double[] pathUncollateralizedPositiveExposure =
  1140.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedPositiveExposure();

  1142.             double[] pathUncollateralizedPositiveExposurePV =
  1143.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedPositiveExposurePV();

  1145.             double[] pathUncollateralizedNegativeExposure =
  1146.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedNegativeExposure();

  1148.             double[] pathUncollateralizedNegativeExposurePV =
  1149.                 _pathExposureAdjustmentArray[pathIndex].vertexUncollateralizedNegativeExposurePV();

  1151.             double[] pathFundingExposure = _pathExposureAdjustmentArray[pathIndex].vertexFundingExposure();

  1153.             double[] pathFundingExposurePV =
  1154.                 _pathExposureAdjustmentArray[pathIndex].vertexFundingExposurePV();

  1156.             try
  1157.             {
  1158.                 pathCVA[pathIndex] = _pathExposureAdjustmentArray[pathIndex].creditAdjustment();

  1160.                 pathDVA[pathIndex] = _pathExposureAdjustmentArray[pathIndex].debtAdjustment();

  1162.                 pathFCA[pathIndex] = _pathExposureAdjustmentArray[pathIndex].fundingCostAdjustment();

  1164.                 pathFDA[pathIndex] = _pathExposureAdjustmentArray[pathIndex].fundingDebtAdjustment();

  1166.                 pathFVA[pathIndex] = _pathExposureAdjustmentArray[pathIndex].fundingValueAdjustment();

  1168.                 pathFBA[pathIndex] = _pathExposureAdjustmentArray[pathIndex].fundingBenefitAdjustment();

  1170.                 pathUCVA[pathIndex] = _pathExposureAdjustmentArray[pathIndex].unilateralCreditAdjustment();

  1172.                 pathSFVA[pathIndex] =
  1173.                     _pathExposureAdjustmentArray[pathIndex].symmetricFundingValueAdjustment();

  1175.                 pathCVACL[pathIndex] =
  1176.                     _pathExposureAdjustmentArray[pathIndex].contraLiabilityCreditAdjustment();

  1178.                 pathFTDCVA[pathIndex] = _pathExposureAdjustmentArray[pathIndex].bilateralCreditAdjustment();

  1180.                 pathCOLVA[pathIndex] =
  1181.                     _pathExposureAdjustmentArray[pathIndex].bilateralCollateralAdjustment();

  1183.                 pathFTDCOLVA[pathIndex] =
  1184.                     _pathExposureAdjustmentArray[pathIndex].bilateralCollateralAdjustment();

  1186.                 pathTotalVA[pathIndex] = _pathExposureAdjustmentArray[pathIndex].totalAdjustment();
  1187.             }
  1188.             catch (java.lang.Exception e)
  1189.             {
  1190.                 e.printStackTrace();

  1192.                 return null;
  1193.             }

  1195.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  1196.             {
  1197.                 collateralizedExposure[vertexIndex][pathIndex] =
  1198.                     pathCollateralizedExposure[vertexIndex];
  1199.                 collateralizedExposurePV[vertexIndex][pathIndex] =
  1200.                     pathCollateralizedExposurePV[vertexIndex];
  1201.                 collateralizedPositiveExposure[vertexIndex][pathIndex] =
  1202.                     pathCollateralizedPositiveExposure[vertexIndex];
  1203.                 collateralizedPositiveExposurePV[vertexIndex][pathIndex] =
  1204.                     pathCollateralizedPositiveExposurePV[vertexIndex];
  1205.                 collateralizedNegativeExposure[vertexIndex][pathIndex] =
  1206.                     pathCollateralizedNegativeExposure[vertexIndex];
  1207.                 collateralizedNegativeExposurePV[vertexIndex][pathIndex] =
  1208.                     pathCollateralizedNegativeExposurePV[vertexIndex];
  1209.                 uncollateralizedExposure[vertexIndex][pathIndex] =
  1210.                     pathUncollateralizedExposure[vertexIndex];
  1211.                 uncollateralizedExposurePV[vertexIndex][pathIndex] =
  1212.                     pathUncollateralizedExposurePV[vertexIndex];
  1213.                 uncollateralizedPositiveExposure[vertexIndex][pathIndex] =
  1214.                     pathUncollateralizedPositiveExposure[vertexIndex];
  1215.                 uncollateralizedPositiveExposurePV[vertexIndex][pathIndex] =
  1216.                     pathUncollateralizedPositiveExposurePV[vertexIndex];
  1217.                 uncollateralizedNegativeExposure[vertexIndex][pathIndex] =
  1218.                     pathUncollateralizedNegativeExposure[vertexIndex];
  1219.                 uncollateralizedNegativeExposurePV[vertexIndex][pathIndex] =
  1220.                     pathUncollateralizedNegativeExposurePV[vertexIndex];
  1221.                 fundingExposure[vertexIndex][pathIndex] = pathFundingExposure[vertexIndex];
  1222.                 fundingExposurePV[vertexIndex][pathIndex] = pathFundingExposurePV[vertexIndex];
  1223.             }
  1224.         }

  1226.         try
  1227.         {
  1228.             return new org.drip.xva.gross.ExposureAdjustmentDigest (
  1229.                 pathCOLVA,
  1230.                 pathFTDCOLVA,
  1231.                 pathUCVA,
  1232.                 pathFTDCVA,
  1233.                 pathCVA,
  1234.                 pathCVACL,
  1235.                 pathDVA,
  1236.                 pathFVA,
  1237.                 pathFDA,
  1238.                 pathFCA,
  1239.                 pathFBA,
  1240.                 pathSFVA,
  1241.                 pathTotalVA,
  1242.                 collateralizedExposure,
  1243.                 collateralizedExposurePV,
  1244.                 collateralizedPositiveExposure,
  1245.                 collateralizedPositiveExposurePV,
  1246.                 collateralizedNegativeExposure,
  1247.                 collateralizedNegativeExposurePV,
  1248.                 uncollateralizedExposure,
  1249.                 uncollateralizedExposurePV,
  1250.                 uncollateralizedPositiveExposure,
  1251.                 uncollateralizedPositiveExposurePV,
  1252.                 uncollateralizedNegativeExposure,
  1253.                 uncollateralizedNegativeExposurePV,
  1254.                 fundingExposure,
  1255.                 fundingExposurePV
  1256.             );
  1257.         }
  1258.         catch (java.lang.Exception e)
  1259.         {
  1260.             e.printStackTrace();
  1261.         }

  1263.         return null;
  1264.     }

  1266.     /**
  1267.      * Generate the Basel Exposure Digest
  1268.      * 
  1269.      * @param standardizedExposureGeneratorScheme The Standardized Basel Exposure Generation Scheme
  1270.      * 
  1271.      * @return The Basel Exposure Digest
  1272.      */

  1274.     public org.drip.xva.gross.BaselExposureDigest baselExposureDigest (
  1275.         final org.drip.xva.settings.StandardizedExposureGeneratorScheme standardizedExposureGeneratorScheme)
  1276.     {
  1277.         if (null == standardizedExposureGeneratorScheme)
  1278.         {
  1279.             return null;
  1280.         }

  1282.         org.drip.analytics.date.JulianDate[] vertexJulianDateArray = vertexDates();

  1284.         int vertexCount = vertexJulianDateArray.length;
  1285.         int[] vertexDateArray = new int[vertexCount];
  1286.         int pathCount = _pathExposureAdjustmentArray.length;
  1287.         double[] collateralizedPositiveExposure = new double[vertexCount];
  1288.         double[] effectiveCollateralizedPositiveExposure = new double[vertexCount];
  1289.         org.drip.spline.params.SegmentCustomBuilderControl[] collateralizedExposureSegmentBuilderControlArray
  1290.             = new org.drip.spline.params.SegmentCustomBuilderControl[vertexCount - 1];
  1291.         org.drip.spline.params.SegmentCustomBuilderControl[]
  1292.             collateralizedPositiveExposureSegmentBuilderControlArray = new
  1293.                 org.drip.spline.params.SegmentCustomBuilderControl[vertexCount - 1];

  1295.         org.drip.spline.params.SegmentCustomBuilderControl collateralizedExposureSegmentBuilderControl =
  1296.             standardizedExposureGeneratorScheme.collateralizedExposureSegmentBuilderControl();

  1298.         org.drip.spline.params.SegmentCustomBuilderControl
  1299.             collateralizedPositiveExposureSegmentBuilderControl =
  1300.                 standardizedExposureGeneratorScheme.collateralizedPositiveExposureSegmentBuilderControl();

  1302.         for (int i = 0; i < vertexCount - 1; ++i)
  1303.         {
  1304.             collateralizedExposureSegmentBuilderControlArray[i] =
  1305.                 collateralizedExposureSegmentBuilderControl;
  1306.             collateralizedPositiveExposureSegmentBuilderControlArray[i] =
  1307.                 collateralizedPositiveExposureSegmentBuilderControl;
  1308.         }

  1310.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  1311.         {
  1312.             collateralizedPositiveExposure[vertexIndex] = 0.;

  1314.             vertexDateArray[vertexIndex] = vertexJulianDateArray[vertexIndex].julian();
  1315.         }

  1317.         for (int pathIndex = 0; pathIndex < pathCount; ++pathIndex)
  1318.         {
  1319.             double[] pathCollateralizedPositiveExposure =
  1320.                 _pathExposureAdjustmentArray[pathIndex].vertexCollateralizedPositiveExposure();

  1322.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  1323.             {
  1324.                 collateralizedPositiveExposure[vertexIndex] +=
  1325.                     pathCollateralizedPositiveExposure[vertexIndex];
  1326.             }
  1327.         }

  1329.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  1330.         {
  1331.             collateralizedPositiveExposure[vertexIndex] /= pathCount;

  1333.             if (0 == vertexIndex)
  1334.             {
  1335.                 effectiveCollateralizedPositiveExposure[0] = collateralizedPositiveExposure[0];
  1336.             }
  1337.             else
  1338.             {
  1339.                 effectiveCollateralizedPositiveExposure[vertexIndex] =
  1340.                     collateralizedPositiveExposure[vertexIndex] >
  1341.                     effectiveCollateralizedPositiveExposure[vertexIndex - 1] ?
  1342.                     collateralizedPositiveExposure[vertexIndex] :
  1343.                     effectiveCollateralizedPositiveExposure[vertexIndex - 1];
  1344.             }
  1345.         }

  1347.         try
  1348.         {
  1349.             org.drip.spline.stretch.MultiSegmentSequence multiSegmentSequenceCollateralizedPositiveExposure =
  1350.                 org.drip.spline.stretch.MultiSegmentSequenceBuilder.CreateCalibratedStretchEstimator (
  1351.                     "CollateralizedPositiveExposure",
  1352.                     vertexDateArray,
  1353.                     collateralizedPositiveExposure,
  1354.                     collateralizedExposureSegmentBuilderControlArray,
  1355.                     null,
  1356.                     org.drip.spline.stretch.BoundarySettings.NaturalStandard(),
  1357.                     org.drip.spline.stretch.MultiSegmentSequence.CALIBRATE
  1358.                 );

  1360.             org.drip.spline.stretch.MultiSegmentSequence
  1361.                 multiSegmentSequenceEffectiveCollateralizedPositiveExposure =
  1362.                     org.drip.spline.stretch.MultiSegmentSequenceBuilder.CreateCalibratedStretchEstimator (
  1363.                         "EffectiveCollateralizedPositiveExposure",
  1364.                         vertexDateArray,
  1365.                         effectiveCollateralizedPositiveExposure,
  1366.                         collateralizedPositiveExposureSegmentBuilderControlArray,
  1367.                         null,
  1368.                         org.drip.spline.stretch.BoundarySettings.NaturalStandard(),
  1369.                         org.drip.spline.stretch.MultiSegmentSequence.CALIBRATE
  1370.                     );

  1372.             if (null == multiSegmentSequenceCollateralizedPositiveExposure ||
  1373.                 null == multiSegmentSequenceEffectiveCollateralizedPositiveExposure)
  1374.             {
  1375.                 return null;
  1376.             }

  1378.             int exposureGeneratorTimeIntegrand = standardizedExposureGeneratorScheme.timeIntegrand();

  1380.             int integrandFinishDate = vertexDateArray[0] + exposureGeneratorTimeIntegrand;

  1382.             double effectiveExpectedPositiveExposure =
  1383.                 multiSegmentSequenceEffectiveCollateralizedPositiveExposure.toAU().integrate (
  1384.                     vertexDateArray[0],
  1385.                     integrandFinishDate
  1386.                 ) / exposureGeneratorTimeIntegrand;

  1388.             return new BaselExposureDigest (
  1389.                 collateralizedPositiveExposure[0],
  1390.                 multiSegmentSequenceCollateralizedPositiveExposure.toAU().integrate (
  1391.                     vertexDateArray[0],
  1392.                     integrandFinishDate
  1393.                 ) / exposureGeneratorTimeIntegrand,
  1394.                 effectiveCollateralizedPositiveExposure[vertexCount - 1],
  1395.                 effectiveExpectedPositiveExposure,
  1396.                 effectiveExpectedPositiveExposure * standardizedExposureGeneratorScheme.eadMultiplier()
  1397.             );
  1398.         }
  1399.         catch (java.lang.Exception e)
  1400.         {
  1401.             e.printStackTrace();
  1402.         }

  1404.         return null;
  1405.     }
  1406. }
Created with JaCoCo 0.7.9.201702052155