CreditDebtGroupPath.java

  1. package org.drip.xva.netting;

  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>CreditDebtGroupPath</i> rolls up the Path Realizations of the Sequence in a Single Path Projection Run
  81.  * over Multiple Collateral Hypothecation Groups onto a Single Credit/Debt Netting Group - the Purpose being
  82.  * to calculate Credit Valuation Adjustments. The References are:
  83.  *
  84.  *  <br><br>
  85.  *  <ul>
  86.  *      <li>
  87.  *          Burgard, C., and M. Kjaer (2014): PDE Representations of Derivatives with Bilateral Counter-party
  88.  *              Risk and Funding Costs <i>Journal of Credit Risk</i> <b>7 (3)</b> 1-19
  89.  *      </li>
  90.  *      <li>
  91.  *          Burgard, C., and M. Kjaer (2014): In the Balance <i>Risk</i> <b>24 (11)</b> 72-75
  92.  *      </li>
  93.  *      <li>
  94.  *          Gregory, J. (2009): Being Two-faced over Counter-party Credit Risk <i>Risk</i> <b>20 (2)</b>
  95.  *              86-90
  96.  *      </li>
  97.  *      <li>
  98.  *          Li, B., and Y. Tang (2007): <i>Quantitative Analysis, Derivatives Modeling, and Trading
  99.  *              Strategies in the Presence of Counter-party Credit Risk for the Fixed Income Market</i>
  100.  *              <b>World Scientific Publishing</b> Singapore
  101.  *      </li>
  102.  *      <li>
  103.  *          Piterbarg, V. (2010): Funding Beyond Discounting: Collateral Agreements and Derivatives Pricing
  104.  *              <i>Risk</i> <b>21 (2)</b> 97-102
  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/XVAAnalyticsLibrary.md">XVA Analytics Library</a></li>
  112.  *      <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>
  113.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/xva/netting/README.md">Credit/Debt/Funding Netting Groups</a></li>
  114.  *  </ul>
  115.  * <br><br>
  116.  * 
  117.  * @author Lakshmi Krishnamurthy
  118.  */

  120. public abstract class CreditDebtGroupPath
  121. {
  122.     private org.drip.exposure.universe.MarketPath _marketPath = null;
  123.     private org.drip.xva.netting.CollateralGroupPath[] _collateralGroupPathArray = null;

  125.     protected CreditDebtGroupPath (
  126.         final org.drip.xva.netting.CollateralGroupPath[] collateralGroupPathArray,
  127.         final org.drip.exposure.universe.MarketPath marketPath)
  128.         throws java.lang.Exception
  129.     {
  130.         if (null == (_collateralGroupPathArray = collateralGroupPathArray) ||
  131.             null == (_marketPath = marketPath))
  132.         {
  133.             throw new java.lang.Exception ("CreditDebtGroupPath Constructor => Invalid Inputs");
  134.         }

  136.         int collateralGroupCount = _collateralGroupPathArray.length;

  138.         if (0 == collateralGroupCount)
  139.         {
  140.             throw new java.lang.Exception ("CreditDebtGroupPath Constructor => Invalid Inputs");
  141.         }

  143.         for (int collateralGroupIndex = 0; collateralGroupIndex < collateralGroupCount;
  144.             ++collateralGroupIndex)
  145.         {
  146.             if (null == _collateralGroupPathArray[collateralGroupIndex])
  147.             {
  148.                 throw new java.lang.Exception ("CreditDebtGroupPath Constructor => Invalid Inputs");
  149.             }
  150.         }
  151.     }

  153.     /**
  154.      * Retrieve the Array of the Position Hypothecation Group Trajectory Paths
  155.      * 
  156.      * @return Array of the Position Hypothecation Group Trajectory Paths
  157.      */

  159.     public org.drip.xva.netting.CollateralGroupPath[] collateralGroupPaths()
  160.     {
  161.         return _collateralGroupPathArray;
  162.     }

  164.     /**
  165.      * Retrieve the Market Path
  166.      * 
  167.      * @return The Market Path
  168.      */

  170.     public org.drip.exposure.universe.MarketPath marketPath()
  171.     {
  172.         return _marketPath;
  173.     }

  175.     /**
  176.      * Retrieve the Array of the Vertex Anchor Dates
  177.      * 
  178.      * @return The Array of the Vertex Anchor Dates
  179.      */

  181.     public org.drip.analytics.date.JulianDate[] vertexDates()
  182.     {
  183.         return _collateralGroupPathArray[0].vertexDates();
  184.     }

  186.     /**
  187.      * Retrieve the Array of Vertex Collateralized Exposures
  188.      * 
  189.      * @return The Array of Vertex Collateralized Exposures
  190.      */

  192.     public double[] vertexCollateralizedExposure()
  193.     {
  194.         int vertexCount = vertexDates().length;

  196.         int collateralGroupCount = _collateralGroupPathArray.length;
  197.         double[] vertexCollateralizedExposure = new double[vertexCount];

  199.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  200.         {
  201.             vertexCollateralizedExposure[vertexIndex] = 0.;
  202.         }

  204.         for (int collateralGroupIndex = 0; collateralGroupIndex < collateralGroupCount;
  205.             ++collateralGroupIndex)
  206.         {
  207.             double[] collateralGroupVertexCollateralizedExposure =
  208.                 _collateralGroupPathArray[collateralGroupIndex].vertexCollateralizedExposure();

  210.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  211.             {
  212.                 vertexCollateralizedExposure[vertexIndex] +=
  213.                     collateralGroupVertexCollateralizedExposure[vertexIndex];
  214.             }
  215.         }

  217.         return vertexCollateralizedExposure;
  218.     }

  220.     /**
  221.      * Retrieve the Array of Vertex Collateralized Exposure PV
  222.      * 
  223.      * @return The Array of Vertex Collateralized Exposure PV
  224.      */

  226.     public double[] vertexCollateralizedExposurePV()
  227.     {
  228.         int vertexCount = vertexDates().length;

  230.         double[] vertexCollateralizedExposurePV = new double[vertexCount];
  231.         int collateralGroupCount = _collateralGroupPathArray.length;

  233.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  234.         {
  235.             vertexCollateralizedExposurePV[vertexIndex] = 0.;
  236.         }

  238.         for (int collateralGroupIndex = 0; collateralGroupIndex < collateralGroupCount;
  239.             ++collateralGroupIndex)
  240.         {
  241.             double[] collateralGroupVertexCollateralizedExposurePV =
  242.                 _collateralGroupPathArray[collateralGroupIndex].vertexCollateralizedExposurePV();

  244.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  245.             {
  246.                 vertexCollateralizedExposurePV[vertexIndex] +=
  247.                     collateralGroupVertexCollateralizedExposurePV[vertexIndex];
  248.             }
  249.         }

  251.         return vertexCollateralizedExposurePV;
  252.     }

  254.     /**
  255.      * Retrieve the Array of Vertex Collateralized Positive Exposures
  256.      * 
  257.      * @return The Array of Vertex Collateralized Positive Exposures
  258.      */

  260.     public double[] vertexCollateralizedPositiveExposure()
  261.     {
  262.         double[] vertexCollateralizedPositiveExposure = vertexCollateralizedExposure();

  264.         int vertexCount = vertexCollateralizedPositiveExposure.length;

  266.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  267.         {
  268.             if (0. > vertexCollateralizedPositiveExposure[vertexIndex])
  269.                 vertexCollateralizedPositiveExposure[vertexIndex] = 0.;
  270.         }

  272.         return vertexCollateralizedPositiveExposure;
  273.     }

  275.     /**
  276.      * Retrieve the Array of Vertex Collateralized Positive Exposure PV
  277.      * 
  278.      * @return The Array of Vertex Collateralized Positive Exposures PV
  279.      */

  281.     public double[] vertexCollateralizedPositiveExposurePV()
  282.     {
  283.         double[] vertexCollateralizedPositiveExposurePV = vertexCollateralizedExposurePV();

  285.         int vertexCount = vertexCollateralizedPositiveExposurePV.length;

  287.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  288.         {
  289.             if (0. > vertexCollateralizedPositiveExposurePV[vertexIndex])
  290.                 vertexCollateralizedPositiveExposurePV[vertexIndex] = 0.;
  291.         }

  293.         return vertexCollateralizedPositiveExposurePV;
  294.     }

  296.     /**
  297.      * Retrieve the Array of Vertex Collateralized Negative Exposures
  298.      * 
  299.      * @return The Array of Vertex Collateralized Negative Exposures
  300.      */

  302.     public double[] vertexCollateralizedNegativeExposure()
  303.     {
  304.         double[] vertexCollateralizedNegativeExposure = vertexCollateralizedExposure();

  306.         int vertexCount = vertexCollateralizedNegativeExposure.length;

  308.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  309.         {
  310.             if (0. < vertexCollateralizedNegativeExposure[vertexIndex])
  311.                 vertexCollateralizedNegativeExposure[vertexIndex] = 0.;
  312.         }

  314.         return vertexCollateralizedNegativeExposure;
  315.     }

  317.     /**
  318.      * Retrieve the Array of Vertex Collateralized Negative Exposure PV
  319.      * 
  320.      * @return The Array of Vertex Collateralized Negative Exposure PV
  321.      */

  323.     public double[] vertexCollateralizedNegativeExposurePV()
  324.     {
  325.         double[] vertexCollateralizedNegativeExposurePV = vertexCollateralizedExposurePV();

  327.         int vertexCount = vertexCollateralizedNegativeExposurePV.length;

  329.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  330.         {
  331.             if (0. < vertexCollateralizedNegativeExposurePV[vertexIndex])
  332.                 vertexCollateralizedNegativeExposurePV[vertexIndex] = 0.;
  333.         }

  335.         return vertexCollateralizedNegativeExposurePV;
  336.     }

  338.     /**
  339.      * Retrieve the Array of Vertex Uncollateralized Exposures
  340.      * 
  341.      * @return The Array of Vertex Uncollateralized Exposures
  342.      */

  344.     public double[] vertexUncollateralizedExposure()
  345.     {
  346.         int vertexCount = vertexDates().length;

  348.         int collateralGroupCount = _collateralGroupPathArray.length;
  349.         double[] vertexUncollateralizedExposure = new double[vertexCount];

  351.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  352.         {
  353.             vertexUncollateralizedExposure[vertexIndex] = 0.;
  354.         }

  356.         for (int collateralGroupIndex = 0; collateralGroupIndex < collateralGroupCount;
  357.             ++collateralGroupIndex)
  358.         {
  359.             double[] collateralGroupVertexUncollateralizedExposure =
  360.                 _collateralGroupPathArray[collateralGroupIndex].vertexUncollateralizedExposure();

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

  369.         return vertexUncollateralizedExposure;
  370.     }

  372.     /**
  373.      * Retrieve the Array of Vertex Uncollateralized Exposure PV
  374.      * 
  375.      * @return The Array of Vertex Uncollateralized Exposure PV
  376.      */

  378.     public double[] vertexUncollateralizedExposurePV()
  379.     {
  380.         int vertexCount = vertexDates().length;

  382.         int collateralGroupCount = _collateralGroupPathArray.length;
  383.         double[] vertexUncollateralizedExposurePV = new double[vertexCount];

  385.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  386.         {
  387.             vertexUncollateralizedExposurePV[vertexIndex] = 0.;
  388.         }

  390.         for (int collateralGroupIndex = 0; collateralGroupIndex < collateralGroupCount;
  391.             ++collateralGroupIndex)
  392.         {
  393.             double[] collateralGroupVertexUncollateralizedExposurePV =
  394.                 _collateralGroupPathArray[collateralGroupIndex].vertexUncollateralizedExposurePV();

  396.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  397.             {
  398.                 vertexUncollateralizedExposurePV[vertexIndex] +=
  399.                     collateralGroupVertexUncollateralizedExposurePV[vertexIndex];
  400.             }
  401.         }

  403.         return vertexUncollateralizedExposurePV;
  404.     }

  406.     /**
  407.      * Retrieve the Array of Vertex Uncollateralized Positive Exposures
  408.      * 
  409.      * @return The Array of Vertex Uncollateralized Positive Exposures
  410.      */

  412.     public double[] vertexUncollateralizedPositiveExposure()
  413.     {
  414.         double[] vertexUncollateralizedPositiveExposure = vertexUncollateralizedExposure();

  416.         int vertexCount = vertexUncollateralizedPositiveExposure.length;

  418.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  419.         {
  420.             if (0. > vertexUncollateralizedPositiveExposure[vertexIndex])
  421.                 vertexUncollateralizedPositiveExposure[vertexIndex] = 0.;
  422.         }

  424.         return vertexUncollateralizedPositiveExposure;
  425.     }

  427.     /**
  428.      * Retrieve the Array of Vertex Uncollateralized Positive Exposure PV
  429.      * 
  430.      * @return The Array of Vertex Uncollateralized Positive Exposure PV
  431.      */

  433.     public double[] vertexUncollateralizedPositiveExposurePV()
  434.     {
  435.         double[] vertexUncollateralizedPositiveExposurePV = vertexUncollateralizedExposurePV();

  437.         int vertexCount = vertexUncollateralizedPositiveExposurePV.length;

  439.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  440.         {
  441.             if (0. > vertexUncollateralizedPositiveExposurePV[vertexIndex])
  442.                 vertexUncollateralizedPositiveExposurePV[vertexIndex] = 0.;
  443.         }

  445.         return vertexUncollateralizedPositiveExposurePV;
  446.     }

  448.     /**
  449.      * Retrieve the Array of Vertex Uncollateralized Negative Exposures
  450.      * 
  451.      * @return The Array of Vertex Uncollateralized Negative Exposures
  452.      */

  454.     public double[] vertexUncollateralizedNegativeExposure()
  455.     {
  456.         double[] vertexUncollateralizedNegativeExposure = vertexUncollateralizedExposure();

  458.         int vertexCount = vertexUncollateralizedNegativeExposure.length;

  460.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  461.         {
  462.             if (0. < vertexUncollateralizedNegativeExposure[vertexIndex])
  463.                 vertexUncollateralizedNegativeExposure[vertexIndex] = 0.;
  464.         }

  466.         return vertexUncollateralizedNegativeExposure;
  467.     }

  469.     /**
  470.      * Retrieve the Array of Vertex Uncollateralized Negative Exposure PV
  471.      * 
  472.      * @return The Array of Vertex Uncollateralized Negative Exposure PV
  473.      */

  475.     public double[] vertexUncollateralizedNegativeExposurePV()
  476.     {
  477.         double[] vertexUncollateralizedNegativeExposurePV = vertexUncollateralizedExposurePV();

  479.         int vertexCount = vertexUncollateralizedNegativeExposurePV.length;

  481.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  482.         {
  483.             if (0. < vertexUncollateralizedNegativeExposurePV[vertexIndex])
  484.                 vertexUncollateralizedNegativeExposurePV[vertexIndex] = 0.;
  485.         }

  487.         return vertexUncollateralizedNegativeExposurePV;
  488.     }

  490.     /**
  491.      * Retrieve the Array of Vertex Credit Exposure
  492.      * 
  493.      * @return The Array of Vertex Credit Exposure
  494.      */

  496.     public double[] vertexCreditExposure()
  497.     {
  498.         return vertexCollateralizedPositiveExposure();
  499.     }

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

  507.     public double[] vertexCreditExposurePV()
  508.     {
  509.         return vertexCollateralizedPositiveExposurePV();
  510.     }

  512.     /**
  513.      * Retrieve the Array of Vertex Debt Exposure
  514.      * 
  515.      * @return The Array of Vertex Debt Exposure
  516.      */

  518.     public double[] vertexDebtExposure()
  519.     {
  520.         return vertexCollateralizedNegativeExposure();
  521.     }

  523.     /**
  524.      * Retrieve the Array of Vertex Debt Exposure PV
  525.      * 
  526.      * @return The Array of Vertex Debt Exposure PV
  527.      */

  529.     public double[] vertexDebtExposurePV()
  530.     {
  531.         return vertexCollateralizedNegativeExposurePV();
  532.     }

  534.     /**
  535.      * Retrieve the Array of Vertex Funding Exposure
  536.      * 
  537.      * @return The Array of Vertex Funding Exposure
  538.      */

  540.     public double[] vertexFundingExposure()
  541.     {
  542.         return vertexCollateralizedExposure();
  543.     }

  545.     /**
  546.      * Retrieve the Array of Vertex Funding Exposure PV
  547.      * 
  548.      * @return The Array of Vertex Funding Exposure PV
  549.      */

  551.     public double[] vertexFundingExposurePV()
  552.     {
  553.         return vertexCollateralizedExposurePV();
  554.     }

  556.     /**
  557.      * Retrieve the Array of Vertex Collateral Balances
  558.      * 
  559.      * @return The Array of Vertex Collateral Balances
  560.      */

  562.     public double[] vertexCollateralBalance()
  563.     {
  564.         int vertexCount = vertexDates().length;

  566.         int collateralGroupCount = _collateralGroupPathArray.length;
  567.         double[] vertexCollateralBalance = new double[vertexCount];

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

  574.         for (int collateralGroupIndex = 0; collateralGroupIndex < collateralGroupCount;
  575.             ++collateralGroupIndex)
  576.         {
  577.             double[] collateralVertexGroupCollateralBalance =
  578.                 _collateralGroupPathArray[collateralGroupIndex].vertexCollateralBalance();

  580.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  581.             {
  582.                 vertexCollateralBalance[vertexIndex] += collateralVertexGroupCollateralBalance[vertexIndex];
  583.             }
  584.         }

  586.         return vertexCollateralBalance;
  587.     }

  589.     /**
  590.      * Retrieve the Array of Vertex Collateral Balances PV
  591.      * 
  592.      * @return The Array of Vertex Collateral Balances PV
  593.      */

  595.     public double[] vertexCollateralBalancePV()
  596.     {
  597.         int vertexCount = vertexDates().length;

  599.         int collateralGroupCount = _collateralGroupPathArray.length;
  600.         double[] vertexCollateralBalancePV = new double[vertexCount];

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

  607.         for (int collateralGroupIndex = 0; collateralGroupIndex < collateralGroupCount;
  608.             ++collateralGroupIndex)
  609.         {
  610.             double[] collateralVertexGroupCollateralBalancePV =
  611.                 _collateralGroupPathArray[collateralGroupIndex].vertexCollateralBalancePV();

  613.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  614.             {
  615.                 vertexCollateralBalancePV[vertexIndex] +=
  616.                     collateralVertexGroupCollateralBalancePV[vertexIndex];
  617.             }
  618.         }

  620.         return vertexCollateralBalancePV;
  621.     }

  623.     /**
  624.      * Compute Period-wise Path Collateral Spread 01
  625.      * 
  626.      * @return The Period-wise Path Collateral Spread 01
  627.      */

  629.     public double[] periodCollateralSpread01()
  630.     {
  631.         int vertexCount = vertexDates().length;

  633.         int periodCount = vertexCount - 1;
  634.         int collateralGroupCount = _collateralGroupPathArray.length;
  635.         double[] periodCollateralSpread01 = new double[periodCount];

  637.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  638.         {
  639.             periodCollateralSpread01[periodIndex] = 0.;
  640.         }

  642.         for (int collateralGroupIndex = 0; collateralGroupIndex < collateralGroupCount;
  643.             ++collateralGroupIndex)
  644.         {
  645.             double[] collateralPeriodCollateralSpread01 =
  646.                 _collateralGroupPathArray[collateralGroupIndex].periodCollateralSpread01();

  648.             for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  649.             {
  650.                 periodCollateralSpread01[periodIndex] += collateralPeriodCollateralSpread01[periodIndex];
  651.             }
  652.         }

  654.         return periodCollateralSpread01;
  655.     }

  657.     /**
  658.      * Compute Period-wise Path Collateral Value Adjustment
  659.      * 
  660.      * @return The Period-wise Path Collateral Value Adjustment
  661.      */

  663.     public double[] periodCollateralValueAdjustment()
  664.     {
  665.         int vertexCount = vertexDates().length;

  667.         int periodCount = vertexCount - 1;
  668.         int collateralGroupCount = _collateralGroupPathArray.length;
  669.         double[] periodCollateralValueAdjustment = new double[periodCount];

  671.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  672.         {
  673.             periodCollateralValueAdjustment[periodIndex] = 0.;
  674.         }

  676.         for (int collateralGroupIndex = 0; collateralGroupIndex < collateralGroupCount;
  677.             ++collateralGroupIndex)
  678.         {
  679.             double[] collateralPeriodCollateralValueAdjustment =
  680.                 _collateralGroupPathArray[collateralGroupIndex].periodCollateralValueAdjustment();

  682.             for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  683.             {
  684.                 periodCollateralValueAdjustment[periodIndex] +=
  685.                     collateralPeriodCollateralValueAdjustment[periodIndex];
  686.             }
  687.         }

  689.         return periodCollateralValueAdjustment;
  690.     }

  692.     /**
  693.      * Compute Path Unilateral Credit Adjustment
  694.      * 
  695.      * @return The Path Unilateral Credit Adjustment
  696.      */

  698.     public double unilateralCreditAdjustment()
  699.     {
  700.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  702.         double[] vertexCreditExposurePV = vertexCreditExposurePV();

  704.         int vertexCount = vertexCreditExposurePV.length;
  705.         double unilateralCreditAdjustment = 0.;

  707.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  708.         {
  709.             double periodIntegrandStart = vertexCreditExposurePV[vertexIndex - 1] * (1. -
  710.                 marketVertexArray[vertexIndex - 1].client().seniorRecoveryRate());

  712.             double periodIntegrandEnd = vertexCreditExposurePV[vertexIndex] * (1. -
  713.                 marketVertexArray[vertexIndex].client().seniorRecoveryRate());

  715.             unilateralCreditAdjustment -= 0.5 * (periodIntegrandStart + periodIntegrandEnd) *
  716.                 (marketVertexArray[vertexIndex - 1].client().survivalProbability() -
  717.                     marketVertexArray[vertexIndex].client().survivalProbability());
  718.         }

  720.         return unilateralCreditAdjustment;
  721.     }

  723.     /**
  724.      * Compute Path Bilateral Credit Adjustment
  725.      * 
  726.      * @return The Path Bilateral Credit Adjustment
  727.      */

  729.     public double bilateralCreditAdjustment()
  730.     {
  731.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  733.         double[] vertexCreditExposurePV = vertexCreditExposurePV();

  735.         int vertexCount = vertexCreditExposurePV.length;
  736.         double bilateralCreditAdjustment = 0.;

  738.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  739.         {
  740.             double periodIntegrandStart = vertexCreditExposurePV[vertexIndex - 1] * (1. -
  741.                 marketVertexArray[vertexIndex - 1].client().seniorRecoveryRate()) *
  742.                 marketVertexArray[vertexIndex - 1].dealer().survivalProbability();

  744.             double periodIntegrandEnd = vertexCreditExposurePV[vertexIndex] * (1. -
  745.                 marketVertexArray[vertexIndex].client().seniorRecoveryRate()) *
  746.                 marketVertexArray[vertexIndex].dealer().survivalProbability();

  748.             bilateralCreditAdjustment -= 0.5 * (periodIntegrandStart + periodIntegrandEnd) *
  749.                 (marketVertexArray[vertexIndex - 1].client().survivalProbability() -
  750.                     marketVertexArray[vertexIndex].client().survivalProbability());
  751.         }

  753.         return bilateralCreditAdjustment;
  754.     }

  756.     /**
  757.      * Compute Path Contra-Liability Credit Adjustment
  758.      * 
  759.      * @return The Path Contra-Liability Credit Adjustment
  760.      */

  762.     public double contraLiabilityCreditAdjustment()
  763.     {
  764.         return bilateralCreditAdjustment() - unilateralCreditAdjustment();
  765.     }

  767.     /**
  768.      * Compute Path Unilateral Debt Adjustment
  769.      * 
  770.      * @return The Path Unilateral Debt Adjustment
  771.      */

  773.     public double unilateralDebtAdjustment()
  774.     {
  775.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  777.         double[] vertexDebtExposurePV = vertexDebtExposurePV();

  779.         int vertexCount = vertexDebtExposurePV.length;
  780.         double unilateralDebtAdjustment = 0.;

  782.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  783.         {
  784.             double periodIntegrandStart = vertexDebtExposurePV[vertexIndex - 1] * (1. -
  785.                 marketVertexArray[vertexIndex - 1].dealer().seniorRecoveryRate());

  787.             double periodIntegrandEnd = vertexDebtExposurePV[vertexIndex] * (1. -
  788.                 marketVertexArray[vertexIndex].dealer().seniorRecoveryRate());

  790.             unilateralDebtAdjustment -= 0.5 * (periodIntegrandStart + periodIntegrandEnd) *
  791.                 (marketVertexArray[vertexIndex - 1].dealer().survivalProbability() -
  792.                     marketVertexArray[vertexIndex].dealer().survivalProbability());
  793.         }

  795.         return unilateralDebtAdjustment;
  796.     }

  798.     /**
  799.      * Compute Path Bilateral Debt Adjustment
  800.      * 
  801.      * @return The Path Bilateral Debt Adjustment
  802.      */

  804.     public double bilateralDebtAdjustment()
  805.     {
  806.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  808.         double[] vertexDebtExposurePV = vertexDebtExposurePV();

  810.         int vertexCount = vertexDebtExposurePV.length;
  811.         double bilateralDebtAdjustment = 0.;

  813.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  814.         {
  815.             double periodIntegrandStart = vertexDebtExposurePV[vertexIndex - 1] * (1. -
  816.                 marketVertexArray[vertexIndex - 1].dealer().seniorRecoveryRate()) *
  817.                 marketVertexArray[vertexIndex - 1].client().survivalProbability();

  819.             double periodIntegrandEnd = vertexDebtExposurePV[vertexIndex] * (1. -
  820.                 marketVertexArray[vertexIndex].dealer().seniorRecoveryRate()) *
  821.                 marketVertexArray[vertexIndex].client().survivalProbability();

  823.             bilateralDebtAdjustment -= 0.5 * (periodIntegrandStart + periodIntegrandEnd) *
  824.                 (marketVertexArray[vertexIndex - 1].dealer().survivalProbability() -
  825.                     marketVertexArray[vertexIndex].dealer().survivalProbability());
  826.         }

  828.         return bilateralDebtAdjustment;
  829.     }

  831.     /**
  832.      * Compute Path Contra-Asset Debt Adjustment
  833.      * 
  834.      * @return The Path Contra-Asset Debt Adjustment
  835.      */

  837.     public double contraAssetDebtAdjustment()
  838.     {
  839.         return bilateralDebtAdjustment() - unilateralDebtAdjustment();
  840.     }

  842.     /**
  843.      * Compute Path Symmetric Funding Value Spread 01
  844.      * 
  845.      * @return The Path Symmetric Funding Value Spread 01
  846.      */

  848.     public double symmetricFundingValueSpread01()
  849.     {
  850.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  852.         double[] vertexCollateralizedExposurePV = vertexCollateralizedExposurePV();

  854.         int vertexCount = vertexCollateralizedExposurePV.length;
  855.         double symmetricFundingValueSpread01 = 0.;

  857.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  858.         {
  859.             symmetricFundingValueSpread01 = 0.5 * (
  860.                 vertexCollateralizedExposurePV[vertexIndex - 1] *
  861.                 marketVertexArray[vertexIndex - 1].dealer().survivalProbability() +
  862.                 vertexCollateralizedExposurePV[vertexIndex] *
  863.                 marketVertexArray[vertexIndex].dealer().survivalProbability()
  864.             ) * (
  865.                 marketVertexArray[vertexIndex].anchorDate().julian() -
  866.                 marketVertexArray[vertexIndex - 1].anchorDate().julian()
  867.             ) / 365.25;
  868.         }

  870.         return symmetricFundingValueSpread01;
  871.     }

  873.     /**
  874.      * Compute Path Unilateral Funding Value Spread 01
  875.      * 
  876.      * @return The Path Unilateral Funding Value Spread 01
  877.      */

  879.     public double unilateralFundingValueSpread01()
  880.     {
  881.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  883.         double[] vertexFundingExposurePV = vertexFundingExposurePV();

  885.         int vertexCount = vertexFundingExposurePV.length;
  886.         double unilateralFundingValueSpread01 = 0.;

  888.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  889.         {
  890.             double periodIntegrandStart = vertexFundingExposurePV[vertexIndex - 1] *
  891.                 marketVertexArray[vertexIndex - 1].client().survivalProbability();

  893.             double periodIntegrandEnd = vertexFundingExposurePV[vertexIndex] *
  894.                 marketVertexArray[vertexIndex].client().survivalProbability();

  896.             unilateralFundingValueSpread01 = 0.5 * (periodIntegrandStart + periodIntegrandEnd) * (
  897.                 marketVertexArray[vertexIndex].anchorDate().julian() -
  898.                 marketVertexArray[vertexIndex - 1].anchorDate().julian()
  899.             ) / 365.25;
  900.         }

  902.         return unilateralFundingValueSpread01;
  903.     }

  905.     /**
  906.      * Compute Path Bilateral Funding Value Spread 01
  907.      * 
  908.      * @return The Path Bilateral Funding Value Spread 01
  909.      */

  911.     public double bilateralFundingValueSpread01()
  912.     {
  913.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  915.         double[] vertexFundingExposurePV = vertexFundingExposurePV();

  917.         int vertexCount = vertexFundingExposurePV.length;
  918.         double bilateralFundingValueSpread01 = 0.;

  920.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  921.         {
  922.             double periodIntegrandStart = vertexFundingExposurePV[vertexIndex - 1] *
  923.                 marketVertexArray[vertexIndex - 1].client().survivalProbability() *
  924.                 marketVertexArray[vertexIndex - 1].dealer().survivalProbability();

  926.             double periodIntegrandEnd = vertexFundingExposurePV[vertexIndex] *
  927.                 marketVertexArray[vertexIndex].client().survivalProbability() *
  928.                 marketVertexArray[vertexIndex].dealer().survivalProbability();

  930.             bilateralFundingValueSpread01 = 0.5 * (periodIntegrandStart + periodIntegrandEnd) * (
  931.                 marketVertexArray[vertexIndex].anchorDate().julian() -
  932.                 marketVertexArray[vertexIndex - 1].anchorDate().julian()
  933.             ) / 365.25;
  934.         }

  936.         return bilateralFundingValueSpread01;
  937.     }

  939.     /**
  940.      * Compute Path Unilateral Funding Debt Adjustment
  941.      * 
  942.      * @return The Path Unilateral Funding Debt Adjustment
  943.      */

  945.     public double unilateralFundingDebtAdjustment()
  946.     {
  947.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  949.         double[] vertexDebtExposurePV = vertexDebtExposurePV();

  951.         int vertexCount = vertexDebtExposurePV.length;
  952.         double unilateralFundingDebtAdjustment = 0.;

  954.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  955.         {
  956.             double periodIntegrandStart = vertexDebtExposurePV[vertexIndex - 1] * (1. -
  957.                 marketVertexArray[vertexIndex - 1].dealer().seniorRecoveryRate());

  959.             double periodIntegrandEnd = vertexDebtExposurePV[vertexIndex] * (1. -
  960.                 marketVertexArray[vertexIndex].dealer().seniorRecoveryRate());

  962.             unilateralFundingDebtAdjustment -= 0.5 * (periodIntegrandStart + periodIntegrandEnd) *
  963.                 (marketVertexArray[vertexIndex - 1].dealer().survivalProbability() -
  964.                     marketVertexArray[vertexIndex].dealer().survivalProbability());
  965.         }

  967.         return unilateralFundingDebtAdjustment;
  968.     }

  970.     /**
  971.      * Compute Path Bilateral Funding Debt Adjustment
  972.      * 
  973.      * @return The Path Bilateral Funding Debt Adjustment
  974.      */

  976.     public double bilateralFundingDebtAdjustment()
  977.     {
  978.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  980.         double[] vertexDebtExposurePV = vertexDebtExposurePV();

  982.         int vertexCount = vertexDebtExposurePV.length;
  983.         double bilateralFundingDebtAdjustment = 0.;

  985.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  986.         {
  987.             double periodIntegrandStart = vertexDebtExposurePV[vertexIndex - 1] *
  988.                 marketVertexArray[vertexIndex - 1].client().survivalProbability() * (1. -
  989.                 marketVertexArray[vertexIndex - 1].dealer().seniorRecoveryRate());

  991.             double periodIntegrandEnd = vertexDebtExposurePV[vertexIndex] *
  992.                 marketVertexArray[vertexIndex].client().survivalProbability() * (1. -
  993.                 marketVertexArray[vertexIndex].dealer().seniorRecoveryRate());

  995.             bilateralFundingDebtAdjustment += 0.5 * (periodIntegrandStart + periodIntegrandEnd) *
  996.                 (marketVertexArray[vertexIndex - 1].dealer().survivalProbability() -
  997.                     marketVertexArray[vertexIndex].dealer().survivalProbability());
  998.         }

  1000.         return bilateralFundingDebtAdjustment;
  1001.     }

  1003.     /**
  1004.      * Compute Path Unilateral Collateral Value Adjustment
  1005.      * 
  1006.      * @return The Path Unilateral Collateral Value Adjustment
  1007.      */

  1009.     public double unilateralCollateralAdjustment()
  1010.     {
  1011.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1013.         double[] periodCollateralValueAdjustment = periodCollateralValueAdjustment();

  1015.         double unilateralCollateralValueAdjustment = 0.;
  1016.         int periodCount = periodCollateralValueAdjustment.length;

  1018.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1019.         {
  1020.             unilateralCollateralValueAdjustment += 0.5 * periodCollateralValueAdjustment[periodIndex] * (
  1021.                 marketVertexArray[periodIndex].client().survivalProbability() +
  1022.                 marketVertexArray[periodIndex + 1].client().survivalProbability()
  1023.             );
  1024.         }

  1026.         return unilateralCollateralValueAdjustment;
  1027.     }

  1029.     /**
  1030.      * Compute Path Bilateral Collateral Value Adjustment
  1031.      * 
  1032.      * @return The Path Bilateral Collateral Value Adjustment
  1033.      */

  1035.     public double bilateralCollateralAdjustment()
  1036.     {
  1037.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1039.         double[] periodCollateralValueAdjustment = periodCollateralValueAdjustment();

  1041.         double bilateralCollateralValueAdjustment = 0.;
  1042.         int periodCount = periodCollateralValueAdjustment.length;

  1044.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1045.         {
  1046.             bilateralCollateralValueAdjustment += 0.5 * periodCollateralValueAdjustment[periodIndex] * (
  1047.                 marketVertexArray[periodIndex].dealer().survivalProbability() *
  1048.                 marketVertexArray[periodIndex].client().survivalProbability() +
  1049.                 marketVertexArray[periodIndex + 1].dealer().survivalProbability() *
  1050.                 marketVertexArray[periodIndex + 1].client().survivalProbability()
  1051.             );
  1052.         }

  1054.         return bilateralCollateralValueAdjustment;
  1055.     }

  1057.     /**
  1058.      * Compute Path Collateral Value Adjustment
  1059.      * 
  1060.      * @return The Path Collateral Value Adjustment
  1061.      */

  1063.     public double collateralValueAdjustment()
  1064.     {
  1065.         return unilateralCollateralAdjustment();
  1066.     }

  1068.     /**
  1069.      * Compute Period-wise Symmetric Funding Value Spread 01
  1070.      * 
  1071.      * @return The Period-wise Symmetric Funding Value Spread 01
  1072.      */

  1074.     public double[] periodSymmetricFundingValueSpread01()
  1075.     {
  1076.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1078.         double[] vertexCollateralizedExposurePV = vertexCollateralizedExposurePV();

  1080.         int periodCount = vertexCollateralizedExposurePV.length - 1;
  1081.         double[] periodSymmetricFundingValueSpread01 = new double[periodCount];

  1083.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1084.         {
  1085.             periodSymmetricFundingValueSpread01[periodIndex] = -0.5 * (
  1086.                 vertexCollateralizedExposurePV[periodIndex] +
  1087.                 vertexCollateralizedExposurePV[periodIndex + 1]
  1088.             ) * (
  1089.                 marketVertexArray[periodIndex + 1].anchorDate().julian() -
  1090.                 marketVertexArray[periodIndex].anchorDate().julian()
  1091.             ) / 365.25;
  1092.         }

  1094.         return periodSymmetricFundingValueSpread01;
  1095.     }

  1097.     /**
  1098.      * Compute Period-wise Unilateral Credit Adjustment
  1099.      * 
  1100.      * @return The Period-wise Unilateral Credit Adjustment
  1101.      */

  1103.     public double[] periodUnilateralCreditAdjustment()
  1104.     {
  1105.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1107.         double[] vertexCreditExposurePV = vertexCreditExposurePV();

  1109.         int vertexCount = vertexCreditExposurePV.length;
  1110.         double[] periodUnilateralCreditAdjustment = new double[vertexCount - 1];

  1112.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  1113.         {
  1114.             double periodIntegrandStart = vertexCreditExposurePV[vertexIndex - 1] * (1. -
  1115.                 marketVertexArray[vertexIndex - 1].client().seniorRecoveryRate());

  1117.             double periodIntegrandEnd = vertexCreditExposurePV[vertexIndex] * (1. -
  1118.                 marketVertexArray[vertexIndex].client().seniorRecoveryRate());

  1120.             periodUnilateralCreditAdjustment[vertexIndex - 1] =
  1121.                 -0.5 * (periodIntegrandStart + periodIntegrandEnd) *
  1122.                 (marketVertexArray[vertexIndex - 1].client().survivalProbability() -
  1123.                 marketVertexArray[vertexIndex].client().survivalProbability());
  1124.         }

  1126.         return periodUnilateralCreditAdjustment;
  1127.     }

  1129.     /**
  1130.      * Compute Period-wise Bilateral Credit Adjustment
  1131.      * 
  1132.      * @return The Period-wise Bilateral Credit Adjustment
  1133.      */

  1135.     public double[] periodBilateralCreditAdjustment()
  1136.     {
  1137.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1139.         double[] vertexCreditExposurePV = vertexCreditExposurePV();

  1141.         int vertexCount = vertexCreditExposurePV.length;
  1142.         double[] periodBilateralCreditAdjustment = new double[vertexCount - 1];

  1144.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  1145.         {
  1146.             double periodIntegrandStart = vertexCreditExposurePV[vertexIndex - 1] * (1. -
  1147.                 marketVertexArray[vertexIndex - 1].client().seniorRecoveryRate()) *
  1148.                 marketVertexArray[vertexIndex - 1].dealer().survivalProbability();

  1150.             double periodIntegrandEnd = vertexCreditExposurePV[vertexIndex] * (1. -
  1151.                 marketVertexArray[vertexIndex].client().seniorRecoveryRate()) *
  1152.                 marketVertexArray[vertexIndex].dealer().survivalProbability();

  1154.             periodBilateralCreditAdjustment[vertexIndex - 1] =
  1155.                 -0.5 * (periodIntegrandStart + periodIntegrandEnd) *
  1156.                 (marketVertexArray[vertexIndex - 1].client().survivalProbability() -
  1157.                 marketVertexArray[vertexIndex].client().survivalProbability());
  1158.         }

  1160.         return periodBilateralCreditAdjustment;
  1161.     }

  1163.     /**
  1164.      * Compute Period-wise Contra-Liability Credit Adjustment
  1165.      * 
  1166.      * @return The Period-wise Contra-Liability Credit Adjustment
  1167.      */

  1169.     public double[] periodContraLiabilityCreditAdjustment()
  1170.     {
  1171.         double[] periodUnilateralCreditAdjustment = periodUnilateralCreditAdjustment();

  1173.         double[] periodBilateralCreditAdjustment = periodBilateralCreditAdjustment();

  1175.         int vertexCount = periodUnilateralCreditAdjustment.length;
  1176.         double[] periodContraLiabilityCreditAdjustment = new double[vertexCount];

  1178.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  1179.         {
  1180.             periodContraLiabilityCreditAdjustment[vertexIndex] =
  1181.                 periodUnilateralCreditAdjustment[vertexIndex] -
  1182.                 periodBilateralCreditAdjustment[vertexIndex];
  1183.         }

  1185.         return periodContraLiabilityCreditAdjustment;
  1186.     }

  1188.     /**
  1189.      * Compute Period-wise Unilateral Debt Adjustment
  1190.      * 
  1191.      * @return The Period-wise Unilateral Debt Adjustment
  1192.      */

  1194.     public double[] periodUnilateralDebtAdjustment()
  1195.     {
  1196.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1198.         double[] vertexDebtExposurePV = vertexDebtExposurePV();

  1200.         int vertexCount = vertexDebtExposurePV.length;
  1201.         double[] periodUnilateralDebtAdjustment = new double[vertexCount - 1];

  1203.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  1204.         {
  1205.             double periodIntegrandStart = vertexDebtExposurePV[vertexIndex - 1] * (1. -
  1206.                 marketVertexArray[vertexIndex - 1].dealer().seniorRecoveryRate());

  1208.             double periodIntegrandEnd = vertexDebtExposurePV[vertexIndex] * (1. -
  1209.                 marketVertexArray[vertexIndex].dealer().seniorRecoveryRate());

  1211.             periodUnilateralDebtAdjustment[vertexIndex - 1] =
  1212.                 -0.5 * (periodIntegrandStart + periodIntegrandEnd) *
  1213.                 (marketVertexArray[vertexIndex - 1].dealer().survivalProbability() -
  1214.                 marketVertexArray[vertexIndex].dealer().survivalProbability());
  1215.         }

  1217.         return periodUnilateralDebtAdjustment;
  1218.     }

  1220.     /**
  1221.      * Compute Period-wise Bilateral Debt Adjustment
  1222.      * 
  1223.      * @return The Period-wise Bilateral Debt Adjustment
  1224.      */

  1226.     public double[] periodBilateralDebtAdjustment()
  1227.     {
  1228.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1230.         double[] vertexDebtExposurePV = vertexDebtExposurePV();

  1232.         int vertexCount = vertexDebtExposurePV.length;
  1233.         double[] periodBilateralDebtAdjustment = new double[vertexCount - 1];

  1235.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  1236.         {
  1237.             double periodIntegrandStart = vertexDebtExposurePV[vertexIndex - 1] * (1. -
  1238.                 marketVertexArray[vertexIndex - 1].dealer().seniorRecoveryRate()) *
  1239.                 marketVertexArray[vertexIndex - 1].client().survivalProbability();

  1241.             double periodIntegrandEnd = vertexDebtExposurePV[vertexIndex] * (1. -
  1242.                 marketVertexArray[vertexIndex].dealer().seniorRecoveryRate()) *
  1243.                 marketVertexArray[vertexIndex].client().survivalProbability();

  1245.             periodBilateralDebtAdjustment[vertexIndex - 1] =
  1246.                 -0.5 * (periodIntegrandStart + periodIntegrandEnd) *
  1247.                 (marketVertexArray[vertexIndex - 1].dealer().survivalProbability() -
  1248.                 marketVertexArray[vertexIndex].dealer().survivalProbability());
  1249.         }

  1251.         return periodBilateralDebtAdjustment;
  1252.     }

  1254.     /**
  1255.      * Compute Period Unilateral Funding Value Spread 01
  1256.      * 
  1257.      * @return The Period Unilateral Funding Value Spread 01
  1258.      */

  1260.     public double[] periodUnilateralFundingValueSpread01()
  1261.     {
  1262.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1264.         double[] vertexFundingExposurePV = vertexFundingExposurePV();

  1266.         int periodCount = vertexFundingExposurePV.length - 1;
  1267.         double[] periodUnilateralFundingValueSpread01 = new double[periodCount];

  1269.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1270.         {
  1271.             double periodIntegrandStart = vertexFundingExposurePV[periodIndex] *
  1272.                 marketVertexArray[periodIndex].client().survivalProbability();

  1274.             double periodIntegrandEnd = vertexFundingExposurePV[periodIndex + 1] *
  1275.                 marketVertexArray[periodIndex + 1].client().survivalProbability();

  1277.             periodUnilateralFundingValueSpread01[periodIndex] =
  1278.                 0.5 * (periodIntegrandStart + periodIntegrandEnd) * (
  1279.                     marketVertexArray[periodIndex + 1].anchorDate().julian() -
  1280.                     marketVertexArray[periodIndex].anchorDate().julian()
  1281.                 ) / 365.25;
  1282.         }

  1284.         return periodUnilateralFundingValueSpread01;
  1285.     }

  1287.     /**
  1288.      * Compute Period Bilateral Funding Value Spread 01
  1289.      * 
  1290.      * @return The Period Bilateral Funding Value Spread 01
  1291.      */

  1293.     public double[] periodBilateralFundingValueSpread01()
  1294.     {
  1295.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1297.         double[] vertexFundingExposurePV = vertexFundingExposurePV();

  1299.         int periodCount = vertexFundingExposurePV.length - 1;
  1300.         double[] periodBilateralFundingValueSpread01 = new double[periodCount];

  1302.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1303.         {
  1304.             double periodIntegrandStart = vertexFundingExposurePV[periodIndex] *
  1305.                 marketVertexArray[periodIndex].client().survivalProbability() *
  1306.                 marketVertexArray[periodIndex].dealer().survivalProbability();

  1308.             double periodIntegrandEnd = vertexFundingExposurePV[periodIndex + 1] *
  1309.                 marketVertexArray[periodIndex + 1].client().survivalProbability() *
  1310.                 marketVertexArray[periodIndex + 1].dealer().survivalProbability();

  1312.             periodBilateralFundingValueSpread01[periodIndex] =
  1313.                 0.5 * (periodIntegrandStart + periodIntegrandEnd) * (
  1314.                     marketVertexArray[periodIndex + 1].anchorDate().julian() -
  1315.                     marketVertexArray[periodIndex].anchorDate().julian()
  1316.                 ) / 365.25;
  1317.         }

  1319.         return periodBilateralFundingValueSpread01;
  1320.     }

  1322.     /**
  1323.      * Compute Period Unilateral Funding Debt Adjustment
  1324.      * 
  1325.      * @return The Period Unilateral Funding Debt Adjustment
  1326.      */

  1328.     public double[] periodUnilateralFundingDebtAdjustment()
  1329.     {
  1330.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1332.         double[] vertexDebtExposurePV = vertexDebtExposurePV();

  1334.         int vertexCount = vertexDebtExposurePV.length;
  1335.         double[] periodUnilateralFundingDebtAdjustment = new double[vertexCount - 1];

  1337.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  1338.         {
  1339.             double periodIntegrandStart = vertexDebtExposurePV[vertexIndex - 1] * (1. -
  1340.                 marketVertexArray[vertexIndex - 1].dealer().seniorRecoveryRate());

  1342.             double periodIntegrandEnd = vertexDebtExposurePV[vertexIndex] * (1. -
  1343.                 marketVertexArray[vertexIndex].dealer().seniorRecoveryRate());

  1345.             periodUnilateralFundingDebtAdjustment[vertexIndex - 1] = -0.5 *
  1346.                 (periodIntegrandStart + periodIntegrandEnd) *
  1347.                 (marketVertexArray[vertexIndex - 1].dealer().survivalProbability() -
  1348.                 marketVertexArray[vertexIndex].dealer().survivalProbability());
  1349.         }

  1351.         return periodUnilateralFundingDebtAdjustment;
  1352.     }

  1354.     /**
  1355.      * Compute Period Bilateral Funding Debt Adjustment
  1356.      * 
  1357.      * @return The Period Bilateral Funding Debt Adjustment
  1358.      */

  1360.     public double[] periodBilateralFundingDebtAdjustment()
  1361.     {
  1362.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1364.         double[] vertexDebtExposurePV = vertexDebtExposurePV();

  1366.         int vertexCount = vertexDebtExposurePV.length;
  1367.         double[] periodBilateralFundingDebtAdjustment = new double[vertexCount - 1];

  1369.         for (int vertexIndex = 1; vertexIndex < vertexCount; ++vertexIndex)
  1370.         {
  1371.             double periodIntegrandStart = vertexDebtExposurePV[vertexIndex - 1] * (1. -
  1372.                 marketVertexArray[vertexIndex - 1].dealer().seniorRecoveryRate()) *
  1373.                 marketVertexArray[vertexIndex - 1].client().survivalProbability();

  1375.             double periodIntegrandEnd = vertexDebtExposurePV[vertexIndex] * (1. -
  1376.                 marketVertexArray[vertexIndex].dealer().seniorRecoveryRate()) *
  1377.                 marketVertexArray[vertexIndex].client().survivalProbability();

  1379.             periodBilateralFundingDebtAdjustment[vertexIndex - 1] = -0.5 *
  1380.                 (periodIntegrandStart + periodIntegrandEnd) *
  1381.                 (marketVertexArray[vertexIndex - 1].dealer().survivalProbability() -
  1382.                 marketVertexArray[vertexIndex].dealer().survivalProbability());
  1383.         }

  1385.         return periodBilateralFundingDebtAdjustment;
  1386.     }

  1388.     /**
  1389.      * Compute Path Credit Adjustment
  1390.      * 
  1391.      * @return The Path Credit Adjustment
  1392.      */

  1394.     public abstract double creditAdjustment();

  1396.     /**
  1397.      * Compute Path Debt Adjustment
  1398.      * 
  1399.      * @return The Path Debt Adjustment
  1400.      */

  1402.     public abstract double debtAdjustment();

  1404.     /**
  1405.      * Compute Period-wise Credit Adjustment
  1406.      * 
  1407.      * @return The Period-wise Credit Adjustment
  1408.      */

  1410.     public abstract double[] periodCreditAdjustment();

  1412.     /**
  1413.      * Compute Period-wise Debt Adjustment
  1414.      * 
  1415.      * @return The Period-wise Debt Adjustment
  1416.      */

  1418.     public abstract double[] periodDebtAdjustment();
  1419. }
Created with JaCoCo 0.7.9.201702052155