FundingGroupPath.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>FundingGroupPath</i> holds up the Strategy Abstract Realizations of the Sequence in a Single Path
  81.  * Projection Run over Multiple Collateral Groups onto a Single Funding Group - the Purpose being to
  82.  * calculate Funding 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 FundingGroupPath
  121. {
  122.     private org.drip.exposure.universe.MarketPath _marketPath = null;
  123.     private org.drip.xva.netting.CreditDebtGroupPath[] _creditDebtGroupPathArray = null;

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

  137.     /**
  138.      * Retrieve the Array of CreditDebtGroupPath
  139.      * 
  140.      * @return The Array of CreditDebtGroupPath
  141.      */

  143.     public org.drip.xva.netting.CreditDebtGroupPath[] creditDebtGroupPathArray()
  144.     {
  145.         return _creditDebtGroupPathArray;
  146.     }

  148.     /**
  149.      * Retrieve the Market Path
  150.      * 
  151.      * @return The Market Path
  152.      */

  154.     public org.drip.exposure.universe.MarketPath marketPath()
  155.     {
  156.         return _marketPath;
  157.     }

  159.     /**
  160.      * Retrieve the Array of the Vertex Anchor Dates
  161.      * 
  162.      * @return The Array of the Vertex Anchor Dates
  163.      */

  165.     public org.drip.analytics.date.JulianDate[] vertexDates()
  166.     {
  167.         return _creditDebtGroupPathArray[0].vertexDates();
  168.     }

  170.     /**
  171.      * Compute Path Symmetric Funding Value Spread 01
  172.      * 
  173.      * @return The Path Symmetric Funding Value Spread 01
  174.      */

  176.     public double symmetricFundingValueSpread01()
  177.     {
  178.         double symmetricFundingSpread01 = 0.;
  179.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  181.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  182.             ++creditDebtGroupIndex)
  183.         {
  184.             symmetricFundingSpread01 +=
  185.                 _creditDebtGroupPathArray[creditDebtGroupIndex].symmetricFundingValueSpread01();
  186.         }

  188.         return symmetricFundingSpread01;
  189.     }

  191.     /**
  192.      * Compute Path Unilateral Funding Value Spread 01
  193.      * 
  194.      * @return The Path Unilateral Funding Value Spread 01
  195.      */

  197.     public double unilateralFundingValueSpread01()
  198.     {
  199.         double unilateralFundingValueSpread01 = 0.;
  200.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  202.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  203.             ++creditDebtGroupIndex)
  204.         {
  205.             unilateralFundingValueSpread01 +=
  206.                 _creditDebtGroupPathArray[creditDebtGroupIndex].unilateralFundingValueSpread01();
  207.         }

  209.         return 0. > unilateralFundingValueSpread01 ? 0. : unilateralFundingValueSpread01;
  210.     }

  212.     /**
  213.      * Compute Path Bilateral Funding Value Spread 01
  214.      * 
  215.      * @return The Path Bilateral Funding Value Spread 01
  216.      */

  218.     public double bilateralFundingValueSpread01()
  219.     {
  220.         double bilateralFundingValueSpread01 = 0.;
  221.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  223.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  224.             ++creditDebtGroupIndex)
  225.         {
  226.             bilateralFundingValueSpread01 +=
  227.                 _creditDebtGroupPathArray[creditDebtGroupIndex].bilateralFundingValueSpread01();
  228.         }

  230.         return 0. > bilateralFundingValueSpread01 ? 0. : bilateralFundingValueSpread01;
  231.     }

  233.     /**
  234.      * Compute Period Symmetric Funding Value Spread 01
  235.      * 
  236.      * @return The Period Symmetric Funding Value Spread 01
  237.      */

  239.     public double[] periodSymmetricFundingValueSpread01()
  240.     {
  241.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  243.         int periodCount = marketVertexArray.length - 1;
  244.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  245.         double[] periodSymmetricFundingValueSpread01 = new double[periodCount];

  247.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  248.         {
  249.             periodSymmetricFundingValueSpread01[periodIndex] = 0.;
  250.         }

  252.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  253.             ++creditDebtGroupIndex)
  254.         {
  255.             double[] periodCreditDebtGroupSymmetricFundingValueSpread01 =
  256.                 _creditDebtGroupPathArray[creditDebtGroupIndex].periodSymmetricFundingValueSpread01();

  258.             for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  259.             {
  260.                 periodSymmetricFundingValueSpread01[periodIndex] +=
  261.                     periodCreditDebtGroupSymmetricFundingValueSpread01[periodIndex];
  262.             }
  263.         }

  265.         return periodSymmetricFundingValueSpread01;
  266.     }

  268.     /**
  269.      * Compute Period Unilateral Funding Value Spread 01
  270.      * 
  271.      * @return The Period Unilateral Funding Value Spread 01
  272.      */

  274.     public double[] periodUnilateralFundingValueSpread01()
  275.     {
  276.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  278.         int periodCount = marketVertexArray.length - 1;
  279.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  280.         double[] periodUnilateralFundingValueSpread01 = new double[periodCount];

  282.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  283.         {
  284.             periodUnilateralFundingValueSpread01[periodIndex] = 0.;
  285.         }

  287.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  288.             ++creditDebtGroupIndex)
  289.         {
  290.             double[] periodCreditDebtGroupUnilateralFundingValueSpread01 =
  291.                 _creditDebtGroupPathArray[creditDebtGroupIndex].periodUnilateralFundingValueSpread01();

  293.             for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  294.             {
  295.                 periodUnilateralFundingValueSpread01[periodIndex] +=
  296.                     periodCreditDebtGroupUnilateralFundingValueSpread01[periodIndex];
  297.             }
  298.         }

  300.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  301.         {
  302.             if (0. > periodUnilateralFundingValueSpread01[periodIndex])
  303.             {
  304.                 periodUnilateralFundingValueSpread01[periodIndex] = 0.;
  305.             }
  306.         }

  308.         return periodUnilateralFundingValueSpread01;
  309.     }

  311.     /**
  312.      * Compute Period Bilateral Funding Value Spread 01
  313.      * 
  314.      * @return The Period Bilateral Funding Value Spread 01
  315.      */

  317.     public double[] periodBilateralFundingValueSpread01()
  318.     {
  319.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  321.         int periodCount = marketVertexArray.length - 1;
  322.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  323.         double[] periodBilateralFundingValueSpread01 = new double[periodCount];

  325.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  326.         {
  327.             periodBilateralFundingValueSpread01[periodIndex] = 0.;
  328.         }

  330.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  331.             ++creditDebtGroupIndex)
  332.         {
  333.             double[] periodCreditDebtGroupBilateralFundingValueSpread01 =
  334.                 _creditDebtGroupPathArray[creditDebtGroupIndex].periodBilateralFundingValueSpread01();

  336.             for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  337.             {
  338.                 periodBilateralFundingValueSpread01[periodIndex] +=
  339.                     periodCreditDebtGroupBilateralFundingValueSpread01[periodIndex];
  340.             }
  341.         }

  343.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  344.         {
  345.             if (0. > periodBilateralFundingValueSpread01[periodIndex])
  346.             {
  347.                 periodBilateralFundingValueSpread01[periodIndex] = 0.;
  348.             }
  349.         }

  351.         return periodBilateralFundingValueSpread01;
  352.     }

  354.     /**
  355.      * Compute Path Symmetric Funding Value Adjustment
  356.      * 
  357.      * @return The Path Symmetric Funding Value Adjustment
  358.      */

  360.     public double symmetricFundingValueAdjustment()
  361.     {
  362.         double[] periodSymmetricFundingValueSpread01 = periodSymmetricFundingValueSpread01();

  364.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  366.         int periodCount = periodSymmetricFundingValueSpread01.length;
  367.         double symmetricFundingValueAdjustment = 0.;

  369.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  370.         {
  371.             symmetricFundingValueAdjustment +=
  372.                 0.5 * periodSymmetricFundingValueSpread01[periodIndex] * (
  373.                     marketVertexArray[periodIndex].dealer().seniorFundingSpread() +
  374.                     marketVertexArray[periodIndex + 1].dealer().seniorFundingSpread()
  375.                 );
  376.         }

  378.         return symmetricFundingValueAdjustment;
  379.     }

  381.     /**
  382.      * Compute Path Unilateral Funding Value Adjustment
  383.      * 
  384.      * @return The Path Unilateral Funding Value Adjustment
  385.      */

  387.     public double unilateralFundingValueAdjustment()
  388.     {
  389.         double[] periodUnilateralFundingValueSpread01 = periodUnilateralFundingValueSpread01();

  391.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  393.         int periodCount = periodUnilateralFundingValueSpread01.length;
  394.         double unilateralFundingValueAdjustment = 0.;

  396.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  397.         {
  398.             unilateralFundingValueAdjustment -=
  399.                 0.5 * periodUnilateralFundingValueSpread01[periodIndex] * (
  400.                     marketVertexArray[periodIndex].dealer().seniorFundingSpread() +
  401.                     marketVertexArray[periodIndex + 1].dealer().seniorFundingSpread()
  402.                 );
  403.         }

  405.         return unilateralFundingValueAdjustment;
  406.     }

  408.     /**
  409.      * Compute Path Bilateral Funding Value Adjustment
  410.      * 
  411.      * @return The Path Bilateral Funding Value Adjustment
  412.      */

  414.     public double bilateralFundingValueAdjustment()
  415.     {
  416.         double[] periodBilateralFundingValueSpread01 = periodBilateralFundingValueSpread01();

  418.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  420.         int periodCount = periodBilateralFundingValueSpread01.length;
  421.         double bilateralFundingValueAdjustment = 0.;

  423.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  424.         {
  425.             bilateralFundingValueAdjustment -=
  426.                 0.5 * periodBilateralFundingValueSpread01[periodIndex] * (
  427.                     marketVertexArray[periodIndex].dealer().seniorFundingSpread() +
  428.                     marketVertexArray[periodIndex + 1].dealer().seniorFundingSpread()
  429.                 );
  430.         }

  432.         return bilateralFundingValueAdjustment;
  433.     }

  435.     /**
  436.      * Compute Path Unilateral Funding Debt Adjustment
  437.      * 
  438.      * @return The Path Unilateral Funding Debt Adjustment
  439.      */

  441.     public double unilateralFundingDebtAdjustment()
  442.     {
  443.         double[] periodUnilateralFundingDebtAdjustment = periodUnilateralFundingDebtAdjustment();

  445.         int periodCount = periodUnilateralFundingDebtAdjustment.length;
  446.         double unilateralFundingDebtAdjustment = 0.;

  448.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  449.         {
  450.             unilateralFundingDebtAdjustment += periodUnilateralFundingDebtAdjustment[periodIndex];
  451.         }

  453.         return unilateralFundingDebtAdjustment;
  454.     }

  456.     /**
  457.      * Compute Path Bilateral Funding Debt Adjustment
  458.      * 
  459.      * @return The Path Bilateral Funding Debt Adjustment
  460.      */

  462.     public double bilateralFundingDebtAdjustment()
  463.     {
  464.         double[] periodBilateralFundingDebtAdjustment = periodBilateralFundingDebtAdjustment();

  466.         int periodCount = periodBilateralFundingDebtAdjustment.length;
  467.         double bilateralFundingDebtAdjustment = 0.;

  469.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  470.         {
  471.             bilateralFundingDebtAdjustment += periodBilateralFundingDebtAdjustment[periodIndex];
  472.         }

  474.         return bilateralFundingDebtAdjustment;
  475.     }

  477.     /**
  478.      * Compute Vertex Path Collateralized Exposure
  479.      * 
  480.      * @return The Vertex Path Collateralized Exposure
  481.      */

  483.     public double[] vertexCollateralizedExposure()
  484.     {
  485.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  487.         int vertexCount = marketVertexArray.length;
  488.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  489.         double[] vertexCollateralizedExposure = new double[vertexCount];

  491.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  492.         {
  493.             vertexCollateralizedExposure[vertexIndex] = 0.;
  494.         }

  496.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  497.             ++creditDebtGroupIndex)
  498.         {
  499.             double[] creditDebtGroupVertexCollateralizedExposure =
  500.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexCollateralizedExposure();

  502.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  503.             {
  504.                 vertexCollateralizedExposure[vertexIndex] +=
  505.                     creditDebtGroupVertexCollateralizedExposure[vertexIndex];
  506.             }
  507.         }

  509.         return vertexCollateralizedExposure;
  510.     }

  512.     /**
  513.      * Compute Vertex Path Collateralized Exposure PV
  514.      * 
  515.      * @return The Vertex Path Collateralized Exposure PV
  516.      */

  518.     public double[] vertexCollateralizedExposurePV()
  519.     {
  520.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  522.         int vertexCount = marketVertexArray.length;
  523.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  524.         double[] vertexCollateralizedExposurePV = new double[vertexCount];

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

  531.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  532.             ++creditDebtGroupIndex)
  533.         {
  534.             double[] creditDebtGroupVertexCollateralizedExposurePV =
  535.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexCollateralizedExposurePV();

  537.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  538.             {
  539.                 vertexCollateralizedExposurePV[vertexIndex] +=
  540.                     creditDebtGroupVertexCollateralizedExposurePV[vertexIndex];
  541.             }
  542.         }

  544.         return vertexCollateralizedExposurePV;
  545.     }

  547.     /**
  548.      * Compute Vertex Path Collateralized Positive Exposure
  549.      * 
  550.      * @return The Vertex Path Collateralized Positive Exposure
  551.      */

  553.     public double[] vertexCollateralizedPositiveExposure()
  554.     {
  555.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  557.         int vertexCount = marketVertexArray.length;
  558.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  559.         double[] vertexCollateralizedPositiveExposure = new double[vertexCount];

  561.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  562.         {
  563.             vertexCollateralizedPositiveExposure[vertexIndex] = 0.;
  564.         }

  566.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  567.             ++creditDebtGroupIndex)
  568.         {
  569.             double[] creditDebtGroupVertexCollateralizedPositiveExposure =
  570.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexCollateralizedPositiveExposure();

  572.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  573.             {
  574.                 vertexCollateralizedPositiveExposure[vertexIndex] +=
  575.                     creditDebtGroupVertexCollateralizedPositiveExposure[vertexIndex];
  576.             }
  577.         }

  579.         return vertexCollateralizedPositiveExposure;
  580.     }

  582.     /**
  583.      * Compute Vertex Path Collateralized Positive Exposure PV
  584.      * 
  585.      * @return The Vertex Path Collateralized Positive Exposure PV
  586.      */

  588.     public double[] vertexCollateralizedPositiveExposurePV()
  589.     {
  590.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  592.         int vertexCount = marketVertexArray.length;
  593.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  594.         double[] vertexCollateralizedPositiveExposurePV = new double[vertexCount];

  596.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  597.         {
  598.             vertexCollateralizedPositiveExposurePV[vertexIndex] = 0.;
  599.         }

  601.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  602.             ++creditDebtGroupIndex)
  603.         {
  604.             double[] creditDebtGroupVertexCollateralizedPositiveExposurePV =
  605.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexCollateralizedPositiveExposurePV();

  607.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  608.             {
  609.                 vertexCollateralizedPositiveExposurePV[vertexIndex] +=
  610.                     creditDebtGroupVertexCollateralizedPositiveExposurePV[vertexIndex];
  611.             }
  612.         }

  614.         return vertexCollateralizedPositiveExposurePV;
  615.     }

  617.     /**
  618.      * Compute Vertex Path Collateralized Negative Exposure
  619.      * 
  620.      * @return The Vertex Path Collateralized Negative Exposure
  621.      */

  623.     public double[] vertexCollateralizedNegativeExposure()
  624.     {
  625.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  627.         int vertexCount = marketVertexArray.length;
  628.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  629.         double[] vertexCollateralizedNegativeExposure = new double[vertexCount];

  631.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  632.         {
  633.             vertexCollateralizedNegativeExposure[vertexIndex] = 0.;
  634.         }

  636.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  637.             ++creditDebtGroupIndex)
  638.         {
  639.             double[] creditDebtGroupVertexCollateralizedNegativeExposure =
  640.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexCollateralizedNegativeExposure();

  642.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  643.             {
  644.                 vertexCollateralizedNegativeExposure[vertexIndex] +=
  645.                     creditDebtGroupVertexCollateralizedNegativeExposure[vertexIndex];
  646.             }
  647.         }

  649.         return vertexCollateralizedNegativeExposure;
  650.     }

  652.     /**
  653.      * Compute Vertex Path Collateralized Negative Exposure PV
  654.      * 
  655.      * @return The Vertex Path Collateralized Negative Exposure PV
  656.      */

  658.     public double[] vertexCollateralizedNegativeExposurePV()
  659.     {
  660.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  662.         int vertexCount = marketVertexArray.length;
  663.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  664.         double[] vertexCollateralizedNegativeExposurePV = new double[vertexCount];

  666.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  667.         {
  668.             vertexCollateralizedNegativeExposurePV[vertexIndex] = 0.;
  669.         }

  671.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  672.             ++creditDebtGroupIndex)
  673.         {
  674.             double[] creditDebtGroupVertexCollateralizedNegativeExposurePV =
  675.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexCollateralizedNegativeExposurePV();

  677.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  678.             {
  679.                 vertexCollateralizedNegativeExposurePV[vertexIndex] +=
  680.                     creditDebtGroupVertexCollateralizedNegativeExposurePV[vertexIndex];
  681.             }
  682.         }

  684.         return vertexCollateralizedNegativeExposurePV;
  685.     }

  687.     /**
  688.      * Compute Vertex Path Uncollateralized Exposure
  689.      * 
  690.      * @return The Vertex Path Uncollateralized Exposure
  691.      */

  693.     public double[] vertexUncollateralizedExposure()
  694.     {
  695.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  697.         int vertexCount = marketVertexArray.length;
  698.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  699.         double[] vertexUncollateralizedExposure = new double[vertexCount];

  701.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  702.         {
  703.             vertexUncollateralizedExposure[vertexIndex] = 0.;
  704.         }

  706.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  707.             ++creditDebtGroupIndex)
  708.         {
  709.             double[] creditDebtGroupVertexCollateralizedExposure =
  710.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexUncollateralizedExposure();

  712.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  713.             {
  714.                 vertexUncollateralizedExposure[vertexIndex] +=
  715.                     creditDebtGroupVertexCollateralizedExposure[vertexIndex];
  716.             }
  717.         }

  719.         return vertexUncollateralizedExposure;
  720.     }

  722.     /**
  723.      * Compute Vertex Path Uncollateralized Exposure PV
  724.      * 
  725.      * @return The Vertex Path Uncollateralized Exposure PV
  726.      */

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

  732.         int vertexCount = marketVertexArray.length;
  733.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  734.         double[] vertexUncollateralizedExposurePV = new double[vertexCount];

  736.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  737.         {
  738.             vertexUncollateralizedExposurePV[vertexIndex] = 0.;
  739.         }

  741.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  742.             ++creditDebtGroupIndex)
  743.         {
  744.             double[] creditDebtGroupVertexCollateralizedExposurePV =
  745.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexUncollateralizedExposurePV();

  747.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  748.             {
  749.                 vertexUncollateralizedExposurePV[vertexIndex] +=
  750.                     creditDebtGroupVertexCollateralizedExposurePV[vertexIndex];
  751.             }
  752.         }

  754.         return vertexUncollateralizedExposurePV;
  755.     }

  757.     /**
  758.      * Compute Vertex Path Uncollateralized Positive Exposure
  759.      * 
  760.      * @return The Vertex Path Uncollateralized Positive Exposure
  761.      */

  763.     public double[] vertexUncollateralizedPositiveExposure()
  764.     {
  765.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  767.         int vertexCount = marketVertexArray.length;
  768.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  769.         double[] vertexUncollateralizedPositiveExposure = new double[vertexCount];

  771.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  772.         {
  773.             vertexUncollateralizedPositiveExposure[vertexIndex] = 0.;
  774.         }

  776.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  777.             ++creditDebtGroupIndex)
  778.         {
  779.             double[] creditDebtGroupVertexUncollateralizedPositiveExposure =
  780.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexUncollateralizedPositiveExposure();

  782.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  783.             {
  784.                 vertexUncollateralizedPositiveExposure[vertexIndex] +=
  785.                     creditDebtGroupVertexUncollateralizedPositiveExposure[vertexIndex];
  786.             }
  787.         }

  789.         return vertexUncollateralizedPositiveExposure;
  790.     }

  792.     /**
  793.      * Compute Vertex Path Uncollateralized Positive Exposure PV
  794.      * 
  795.      * @return The Vertex Path Uncollateralized Positive Exposure PV
  796.      */

  798.     public double[] vertexUncollateralizedPositiveExposurePV()
  799.     {
  800.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  802.         int vertexCount = marketVertexArray.length;
  803.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  804.         double[] vertexUncollateralizedPositiveExposurePV = new double[vertexCount];

  806.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  807.         {
  808.             vertexUncollateralizedPositiveExposurePV[vertexIndex] = 0.;
  809.         }

  811.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  812.             ++creditDebtGroupIndex)
  813.         {
  814.             double[] creditDebtGroupVertexUncollateralizedPositiveExposurePV =
  815.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexUncollateralizedPositiveExposurePV();

  817.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  818.             {
  819.                 vertexUncollateralizedPositiveExposurePV[vertexIndex] +=
  820.                     creditDebtGroupVertexUncollateralizedPositiveExposurePV[vertexIndex];
  821.             }
  822.         }

  824.         return vertexUncollateralizedPositiveExposurePV;
  825.     }

  827.     /**
  828.      * Compute Vertex Path Uncollateralized Negative Exposure
  829.      * 
  830.      * @return The Vertex Path Uncollateralized Negative Exposure
  831.      */

  833.     public double[] vertexUncollateralizedNegativeExposure()
  834.     {
  835.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  837.         int vertexCount = marketVertexArray.length;
  838.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  839.         double[] vertexUncollateralizedNegativeExposure = new double[vertexCount];

  841.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  842.         {
  843.             vertexUncollateralizedNegativeExposure[vertexIndex] = 0.;
  844.         }

  846.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  847.             ++creditDebtGroupIndex)
  848.         {
  849.             double[] creditDebtGroupVertexUncollateralizedNegativeExposure =
  850.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexUncollateralizedNegativeExposure();

  852.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  853.             {
  854.                 vertexUncollateralizedNegativeExposure[vertexIndex] +=
  855.                     creditDebtGroupVertexUncollateralizedNegativeExposure[vertexIndex];
  856.             }
  857.         }

  859.         return vertexUncollateralizedNegativeExposure;
  860.     }

  862.     /**
  863.      * Compute Vertex Path Uncollateralized Negative Exposure PV
  864.      * 
  865.      * @return The Vertex Path Uncollateralized Negative Exposure PV
  866.      */

  868.     public double[] vertexUncollateralizedNegativeExposurePV()
  869.     {
  870.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  872.         int vertexCount = marketVertexArray.length;
  873.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  874.         double[] vertexUncollateralizedNegativeExposurePV = new double[vertexCount];

  876.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  877.         {
  878.             vertexUncollateralizedNegativeExposurePV[vertexIndex] = 0.;
  879.         }

  881.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  882.             ++creditDebtGroupIndex)
  883.         {
  884.             double[] creditDebtGroupVertexUncollateralizedNegativeExposurePV =
  885.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexUncollateralizedNegativeExposurePV();

  887.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  888.             {
  889.                 vertexUncollateralizedNegativeExposurePV[vertexIndex] +=
  890.                     creditDebtGroupVertexUncollateralizedNegativeExposurePV[vertexIndex];
  891.             }
  892.         }

  894.         return vertexUncollateralizedNegativeExposurePV;
  895.     }

  897.     /**
  898.      * Compute Vertex Path Funding Exposure
  899.      * 
  900.      * @return The Vertex Path Funding Exposure
  901.      */

  903.     public double[] vertexFundingExposure()
  904.     {
  905.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  907.         int vertexCount = marketVertexArray.length;
  908.         double[] vertexFundingExposure = new double[vertexCount];
  909.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  911.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  912.         {
  913.             vertexFundingExposure[vertexIndex] = 0.;
  914.         }

  916.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  917.             ++creditDebtGroupIndex)
  918.         {
  919.             double[] creditDebtGroupVertexFundingExposure =
  920.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexFundingExposure();

  922.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  923.             {
  924.                 vertexFundingExposure[vertexIndex] += creditDebtGroupVertexFundingExposure[vertexIndex];
  925.             }
  926.         }

  928.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  929.         {
  930.             if (0. > vertexFundingExposure[vertexIndex])
  931.             {
  932.                 vertexFundingExposure[vertexIndex] = 0.;
  933.             }
  934.         }

  936.         return vertexFundingExposure;
  937.     }

  939.     /**
  940.      * Compute Vertex Path Funding Exposure PV
  941.      * 
  942.      * @return The Vertex Path Funding Exposure PV
  943.      */

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

  949.         int vertexCount = marketVertexArray.length;
  950.         double[] vertexFundingExposurePV = new double[vertexCount];
  951.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  953.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  954.         {
  955.             vertexFundingExposurePV[vertexIndex] = 0.;
  956.         }

  958.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  959.             ++creditDebtGroupIndex)
  960.         {
  961.             double[] creditDebtGroupVertexFundingExposurePV =
  962.                 _creditDebtGroupPathArray[creditDebtGroupIndex].vertexFundingExposurePV();

  964.             for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  965.             {
  966.                 vertexFundingExposurePV[vertexIndex] += creditDebtGroupVertexFundingExposurePV[vertexIndex];
  967.             }
  968.         }

  970.         for (int vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
  971.         {
  972.             if (0. > vertexFundingExposurePV[vertexIndex])
  973.             {
  974.                 vertexFundingExposurePV[vertexIndex] = 0.;
  975.             }
  976.         }

  978.         return vertexFundingExposurePV;
  979.     }

  981.     /**
  982.      * Compute Period-wise Path Symmetric Funding Value Adjustment
  983.      * 
  984.      * @return The Period-wise Path Symmetric Funding Value Adjustment
  985.      */

  987.     public double[] periodSymmetricFundingValueAdjustment()
  988.     {
  989.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  991.         double[] periodSymmetricFundingValueSpread01 = periodSymmetricFundingValueSpread01();

  993.         int periodCount = periodSymmetricFundingValueSpread01.length;
  994.         double[] periodSymmetricFundingValueAdjustment = new double[periodCount];

  996.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  997.         {
  998.             periodSymmetricFundingValueAdjustment[periodIndex] =
  999.                 0.5 * periodSymmetricFundingValueSpread01[periodIndex] * (
  1000.                     marketVertexArray[periodIndex].dealer().seniorFundingSpread() +
  1001.                     marketVertexArray[periodIndex + 1].dealer().seniorFundingSpread()
  1002.                 );
  1003.         }

  1005.         return periodSymmetricFundingValueAdjustment;
  1006.     }

  1008.     /**
  1009.      * Compute Period-wise Unilateral Path Funding Value Adjustment
  1010.      * 
  1011.      * @return The Period-wise Unilateral Path Funding Value Adjustment
  1012.      */

  1014.     public double[] periodUnilateralFundingValueAdjustment()
  1015.     {
  1016.         double[] periodUnilateralFundingValueSpread01 = periodUnilateralFundingValueSpread01();

  1018.         int periodCount = periodUnilateralFundingValueSpread01.length;
  1019.         double[] periodUnilateralFundingValueAdjustment = new double[periodCount];

  1021.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1023.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1024.         {
  1025.             periodUnilateralFundingValueAdjustment[periodIndex] =
  1026.                 0.5 * periodUnilateralFundingValueSpread01[periodIndex] * (
  1027.                     marketVertexArray[periodIndex].dealer().seniorFundingSpread() +
  1028.                     marketVertexArray[periodIndex + 1].dealer().seniorFundingSpread()
  1029.                 );
  1030.         }

  1032.         return periodUnilateralFundingValueAdjustment;
  1033.     }

  1035.     /**
  1036.      * Compute Period-wise Bilateral Path Funding Value Adjustment
  1037.      * 
  1038.      * @return The Period-wise Bilateral Path Funding Value Adjustment
  1039.      */

  1041.     public double[] periodBilateralFundingValueAdjustment()
  1042.     {
  1043.         double[] periodBilateralFundingValueSpread01 = periodBilateralFundingValueSpread01();

  1045.         int periodCount = periodBilateralFundingValueSpread01.length;
  1046.         double[] periodBilateralFundingValueAdjustment = new double[periodCount];

  1048.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1050.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1051.         {
  1052.             periodBilateralFundingValueAdjustment[periodIndex] =
  1053.                 0.5 * periodBilateralFundingValueSpread01[periodIndex] * (
  1054.                     marketVertexArray[periodIndex].dealer().seniorFundingSpread() +
  1055.                     marketVertexArray[periodIndex + 1].dealer().seniorFundingSpread()
  1056.                 );
  1057.         }

  1059.         return periodBilateralFundingValueAdjustment;
  1060.     }

  1062.     /**
  1063.      * Compute Period-wise Path Unilateral Funding Debt Adjustment
  1064.      * 
  1065.      * @return The Period-wise Path Unilateral Funding Debt Adjustment
  1066.      */

  1068.     public double[] periodUnilateralFundingDebtAdjustment()
  1069.     {
  1070.         org.drip.exposure.universe.MarketVertex[] marketVertexArray = _marketPath.marketVertexArray();

  1072.         int periodCount = marketVertexArray.length - 1;
  1073.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  1074.         double[] periodUnilateralFundingDebtAdjustment = new double[periodCount];

  1076.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1077.         {
  1078.             periodUnilateralFundingDebtAdjustment[periodIndex] = 0.;
  1079.         }

  1081.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  1082.             ++creditDebtGroupIndex)
  1083.         {
  1084.             double[] periodUnilateralFundingDebtAdjustmentCreditDebtGroup =
  1085.                 _creditDebtGroupPathArray[creditDebtGroupIndex].periodUnilateralFundingDebtAdjustment();

  1087.             for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1088.             {
  1089.                 periodUnilateralFundingDebtAdjustment[periodIndex] +=
  1090.                     periodUnilateralFundingDebtAdjustmentCreditDebtGroup[periodIndex];
  1091.             }
  1092.         }

  1094.         return periodUnilateralFundingDebtAdjustment;
  1095.     }

  1097.     /**
  1098.      * Compute Period-wise Path Bilateral Funding Debt Adjustment
  1099.      * 
  1100.      * @return The Period-wise Path Bilateral Funding Debt Adjustment
  1101.      */

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

  1107.         int periodCount = marketVertexArray.length - 1;
  1108.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;
  1109.         double[] periodBilateralFundingDebtAdjustment = new double[periodCount];

  1111.         for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1112.         {
  1113.             periodBilateralFundingDebtAdjustment[periodIndex] = 0.;
  1114.         }

  1116.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  1117.             ++creditDebtGroupIndex)
  1118.         {
  1119.             double[] periodBilateralFundingDebtAdjustmentCreditDebtGroup =
  1120.                 _creditDebtGroupPathArray[creditDebtGroupIndex].periodBilateralFundingDebtAdjustment();

  1122.             for (int periodIndex = 0; periodIndex < periodCount; ++periodIndex)
  1123.             {
  1124.                 periodBilateralFundingDebtAdjustment[periodIndex] +=
  1125.                     periodBilateralFundingDebtAdjustmentCreditDebtGroup[periodIndex];
  1126.             }
  1127.         }

  1129.         return periodBilateralFundingDebtAdjustment;
  1130.     }

  1132.     /**
  1133.      * Compute Path Unilateral Credit Value Adjustment
  1134.      * 
  1135.      * @return The Path Unilateral Credit Value Adjustment
  1136.      */

  1138.     public double unilateralCreditAdjustment()
  1139.     {
  1140.         double unilateralCreditAdjustment = 0.;
  1141.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  1143.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  1144.             ++creditDebtGroupIndex)
  1145.         {
  1146.             unilateralCreditAdjustment +=
  1147.                 _creditDebtGroupPathArray[creditDebtGroupIndex].unilateralCreditAdjustment();
  1148.         }

  1150.         return unilateralCreditAdjustment;
  1151.     }

  1153.     /**
  1154.      * Compute Path Bilateral Credit Value Adjustment
  1155.      * 
  1156.      * @return The Path Bilateral Credit Value Adjustment
  1157.      */

  1159.     public double bilateralCreditAdjustment()
  1160.     {
  1161.         double bilateralCreditAdjustment = 0.;
  1162.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  1164.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  1165.             ++creditDebtGroupIndex)
  1166.         {
  1167.             bilateralCreditAdjustment +=
  1168.                 _creditDebtGroupPathArray[creditDebtGroupIndex].bilateralCreditAdjustment();
  1169.         }

  1171.         return bilateralCreditAdjustment;
  1172.     }

  1174.     /**
  1175.      * Compute Path Contra-Liability Credit Adjustment
  1176.      * 
  1177.      * @return The Path Contra-Liability Credit Adjustment
  1178.      */

  1180.     public double contraLiabilityCreditAdjustment()
  1181.     {
  1182.         double contraLiabilityCreditAdjustment = 0.;
  1183.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  1185.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  1186.             ++creditDebtGroupIndex)
  1187.         {
  1188.             contraLiabilityCreditAdjustment +=
  1189.                 _creditDebtGroupPathArray[creditDebtGroupIndex].contraLiabilityCreditAdjustment();
  1190.         }

  1192.         return contraLiabilityCreditAdjustment;
  1193.     }

  1195.     /**
  1196.      * Compute Path Unilateral Debt Value Adjustment
  1197.      * 
  1198.      * @return The Path Unilateral Debt Value Adjustment
  1199.      */

  1201.     public double unilateralDebtAdjustment()
  1202.     {
  1203.         double unilateralDebtAdjustment = 0.;
  1204.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  1206.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  1207.             ++creditDebtGroupIndex)
  1208.         {
  1209.             unilateralDebtAdjustment +=
  1210.                 _creditDebtGroupPathArray[creditDebtGroupIndex].unilateralDebtAdjustment();
  1211.         }

  1213.         return unilateralDebtAdjustment;
  1214.     }

  1216.     /**
  1217.      * Compute Path Bilateral Debt Value Adjustment
  1218.      * 
  1219.      * @return The Path Bilateral Credit Value Adjustment
  1220.      */

  1222.     public double bilateralDebtAdjustment()
  1223.     {
  1224.         double bilateralDebtAdjustment = 0.;
  1225.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  1227.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  1228.             ++creditDebtGroupIndex)
  1229.         {
  1230.             bilateralDebtAdjustment +=
  1231.                 _creditDebtGroupPathArray[creditDebtGroupIndex].bilateralDebtAdjustment();
  1232.         }

  1234.         return bilateralDebtAdjustment;
  1235.     }

  1237.     /**
  1238.      * Compute Path Contra-Asset Debt Adjustment
  1239.      * 
  1240.      * @return The Path Contra-Asset Debt Adjustment
  1241.      */

  1243.     public double contraAssetDebtAdjustment()
  1244.     {
  1245.         double contraAssetDebtAdjustment = 0.;
  1246.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  1248.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  1249.             ++creditDebtGroupIndex)
  1250.         {
  1251.             contraAssetDebtAdjustment +=
  1252.                 _creditDebtGroupPathArray[creditDebtGroupIndex].contraAssetDebtAdjustment();
  1253.         }

  1255.         return contraAssetDebtAdjustment;
  1256.     }

  1258.     /**
  1259.      * Compute Path Unilateral Collateral Value Adjustment
  1260.      * 
  1261.      * @return The Path Unilateral Collateral Value Adjustment
  1262.      */

  1264.     public double unilateralCollateralAdjustment()
  1265.     {
  1266.         double unilateralCollateralAdjustment = 0.;
  1267.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  1269.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  1270.             ++creditDebtGroupIndex)
  1271.         {
  1272.             unilateralCollateralAdjustment +=
  1273.                 _creditDebtGroupPathArray[creditDebtGroupIndex].unilateralCollateralAdjustment();
  1274.         }

  1276.         return unilateralCollateralAdjustment;
  1277.     }

  1279.     /**
  1280.      * Compute Path Bilateral Collateral Value Adjustment
  1281.      * 
  1282.      * @return The Path Bilateral Collateral Value Adjustment
  1283.      */

  1285.     public double bilateralCollateralAdjustment()
  1286.     {
  1287.         double bilateralCollateralAdjustment = 0.;
  1288.         int creditDebtGroupCount = _creditDebtGroupPathArray.length;

  1290.         for (int creditDebtGroupIndex = 0; creditDebtGroupIndex < creditDebtGroupCount;
  1291.             ++creditDebtGroupIndex)
  1292.         {
  1293.             bilateralCollateralAdjustment +=
  1294.                 _creditDebtGroupPathArray[creditDebtGroupIndex].bilateralCollateralAdjustment();
  1295.         }

  1297.         return bilateralCollateralAdjustment;
  1298.     }

  1300.     /**
  1301.      * Compute Path Funding Value Adjustment
  1302.      * 
  1303.      * @return The Path Funding Value Adjustment
  1304.      */

  1306.     public abstract double fundingValueAdjustment();

  1308.     /**
  1309.      * Compute Path Funding Debt Adjustment
  1310.      * 
  1311.      * @return The Path Funding Debt Adjustment
  1312.      */

  1314.     public abstract double fundingDebtAdjustment();

  1316.     /**
  1317.      * Compute Path Funding Cost Adjustment
  1318.      * 
  1319.      * @return The Path Funding Cost Adjustment
  1320.      */

  1322.     public abstract double fundingCostAdjustment();

  1324.     /**
  1325.      * Compute Path Funding Benefit Adjustment
  1326.      * 
  1327.      * @return The Path Funding Benefit Adjustment
  1328.      */

  1330.     public abstract double fundingBenefitAdjustment();

  1332.     /**
  1333.      * Compute Period-wise Path Funding Value Adjustment
  1334.      * 
  1335.      * @return The Period-wise Path Funding Value Adjustment
  1336.      */

  1338.     public abstract double[] periodFundingValueAdjustment();

  1340.     /**
  1341.      * Compute Period-wise Path Funding Debt Adjustment
  1342.      * 
  1343.      * @return The Period-wise Path Funding Debt Adjustment
  1344.      */

  1346.     public abstract double[] periodFundingDebtAdjustment();

  1348.     /**
  1349.      * Compute Period-wise Path Funding Cost Adjustment
  1350.      * 
  1351.      * @return The Period-wise Path Funding Cost Adjustment
  1352.      */

  1354.     public abstract double[] periodFundingCostAdjustment();

  1356.     /**
  1357.      * Compute Period-wise Path Funding Benefit Adjustment
  1358.      * 
  1359.      * @return The Period-wise Path Funding Benefit Adjustment
  1360.      */

  1362.     public abstract double[] periodFundingBenefitAdjustment();
  1363. }
Created with JaCoCo 0.7.9.201702052155