MarketVertexGenerator.java

  1. package org.drip.exposure.universe;

  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>MarketVertexGenerator</i> generates the Market Realizations at a Trajectory Vertex needed for computing
  81.  * the Valuation Adjustment. The References are:
  82.  *  
  83.  * <br><br>
  84.  *      <ul>
  85.  *          <li>
  86.  *              Burgard, C., and M. Kjaer (2013): Funding Costs, Funding Strategies <i>Risk</i> <b>23
  87.  *                  (12)</b> 82-87
  88.  *          </li>
  89.  *          <li>
  90.  *              Burgard, C., and M. Kjaer (2014): In the Balance <i>Risk</i> <b>24 (11)</b> 72-75
  91.  *          </li>
  92.  *          <li>
  93.  *              Burgard, C., and M. Kjaer (2014): PDE Representations of Derivatives with Bilateral Counter-
  94.  *                  party Risk and Funding Costs <i>Journal of Credit Risk</i> <b>7 (3)</b> 1-19
  95.  *          </li>
  96.  *          <li>
  97.  *              Gregory, J. (2009): Being Two-faced over Counter-party Credit Risk <i>Risk</i> <b>20 (2)</b>
  98.  *                  86-90
  99.  *          </li>
  100.  *          <li>
  101.  *              Piterbarg, V. (2010): Funding Beyond Discounting: Collateral Agreements and Derivatives
  102.  *                  Pricing <i>Risk</i> <b>21 (2)</b> 97-102
  103.  *          </li>
  104.  *          <li>
  105.  *      </ul>
  106.  *
  107.  *  <br><br>
  108.  *  <ul>
  109.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/PortfolioCore.md">Portfolio Core Module</a></li>
  110.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ExposureAnalyticsLibrary.md">Exposure Analytics</a></li>
  111.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/exposure/README.md">Exposure Group Level Collateralized/Uncollateralized Exposure</a></li>
  112.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/exposure/universe/README.md">Exposure Generation - Market States Simulation</a></li>
  113.  *  </ul>
  114.  * 
  115.  * @author Lakshmi Krishnamurthy
  116.  */

  118. public class MarketVertexGenerator
  119. {
  120.     private int _spotDate = -1;
  121.     private double[] _ycfWidth = null;
  122.     private int[] _eventDateArray = null;
  123.     private org.drip.exposure.evolver.EntityDynamicsContainer _entityDynamicsContainer = null;
  124.     private org.drip.exposure.evolver.LatentStateDynamicsContainer _latentStateDynamicsContainer = null;
  125.     private org.drip.exposure.evolver.PrimarySecurityDynamicsContainer _primarySecurityDynamicsContainer =
  126.         null;

  128.     private org.drip.measure.process.DiffusionEvolver evolver (
  129.         final org.drip.state.identifier.LatentStateLabel latentStateLabel)
  130.     {
  131.         org.drip.exposure.evolver.TerminalLatentState terminalLatentState =
  132.             _latentStateDynamicsContainer.terminal (latentStateLabel);

  134.         if (null == terminalLatentState)
  135.         {
  136.             terminalLatentState = _latentStateDynamicsContainer.terminal (latentStateLabel);
  137.         }

  139.         return null == terminalLatentState ? null : terminalLatentState.evolver();
  140.     }

  142.     private java.util.List<org.drip.measure.realization.JumpDiffusionVertex[]> latentStateVertexArrayList (
  143.         final java.util.List<org.drip.state.identifier.LatentStateLabel> latentStateLabelList,
  144.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  145.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  146.         final int terminalDate)
  147.     {
  148.         if (null == latentStateLabelList)
  149.         {
  150.             return null;
  151.         }

  153.         java.util.List<org.drip.measure.realization.JumpDiffusionVertex[]> latentStateVertexArrayList = new
  154.             java.util.ArrayList<org.drip.measure.realization.JumpDiffusionVertex[]>();

  156.         for (org.drip.state.identifier.LatentStateLabel latentStateLabel : latentStateLabelList)
  157.         {
  158.             org.drip.measure.process.DiffusionEvolver latentStateDiffusionEvolver = evolver
  159.                 (latentStateLabel);

  161.             if (null == latentStateDiffusionEvolver)
  162.             {
  163.                 continue;
  164.             }

  166.             try
  167.             {
  168.                 latentStateVertexArrayList.add (
  169.                     latentStateDiffusionEvolver.vertexSequence (
  170.                         new org.drip.measure.realization.JumpDiffusionVertex (
  171.                             terminalDate,
  172.                             initialMarketVertex.latentStateValue (latentStateLabel),
  173.                             0.,
  174.                             false
  175.                         ),
  176.                         org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  177.                             _ycfWidth,
  178.                             latentStateWeiner.incrementArray (latentStateLabel)
  179.                         ),
  180.                         _ycfWidth
  181.                     )
  182.                 );
  183.             }
  184.             catch (java.lang.Exception e)
  185.             {
  186.                 e.printStackTrace();
  187.             }
  188.         }

  190.         return latentStateVertexArrayList;
  191.     }

  193.     private org.drip.measure.realization.JumpDiffusionVertex[] overnightReplicatorVertexArray (
  194.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  195.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  196.         final int terminalDate)
  197.     {
  198.         org.drip.exposure.evolver.PrimarySecurity overnightReplicator =
  199.             _primarySecurityDynamicsContainer.overnight();

  201.         try
  202.         {
  203.             return overnightReplicator.evolver().vertexSequenceReverse (
  204.                 new org.drip.measure.realization.JumpDiffusionVertex (
  205.                     terminalDate,
  206.                     initialMarketVertex.overnightReplicator(),
  207.                     0.,
  208.                     false
  209.                 ),
  210.                 org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  211.                     _ycfWidth,
  212.                     latentStateWeiner.incrementArray (overnightReplicator.label())
  213.                 ),
  214.                 _ycfWidth
  215.             );
  216.         }
  217.         catch (java.lang.Exception e)
  218.         {
  219.             e.printStackTrace();
  220.         }

  222.         return null;
  223.     }

  225.     private org.drip.measure.realization.JumpDiffusionVertex[] csaReplicatorVertexArray (
  226.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  227.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  228.         final int terminalDate)
  229.     {
  230.         org.drip.exposure.evolver.PrimarySecurity csaReplicator = _primarySecurityDynamicsContainer.csa();

  232.         try
  233.         {
  234.             return csaReplicator.evolver().vertexSequenceReverse (
  235.                 new org.drip.measure.realization.JumpDiffusionVertex (
  236.                     terminalDate,
  237.                     initialMarketVertex.csaReplicator(),
  238.                     0.,
  239.                     false
  240.                 ),
  241.                 org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  242.                     _ycfWidth,
  243.                     latentStateWeiner.incrementArray (csaReplicator.label())
  244.                 ),
  245.                 _ycfWidth
  246.             );
  247.         }
  248.         catch (java.lang.Exception e)
  249.         {
  250.             e.printStackTrace();
  251.         }

  253.         return null;
  254.     }

  256.     private org.drip.measure.realization.JumpDiffusionVertex[] dealerSeniorFundingReplicatorVertexArray (
  257.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  258.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  259.         final int terminalDate)
  260.     {
  261.         org.drip.exposure.evolver.PrimarySecurity dealerSeniorFundingReplicator =
  262.             _primarySecurityDynamicsContainer.dealerSeniorFunding();

  264.         try
  265.         {
  266.             return dealerSeniorFundingReplicator.evolver().vertexSequenceReverse (
  267.                 new org.drip.measure.realization.JumpDiffusionVertex (
  268.                     terminalDate,
  269.                     initialMarketVertex.dealer().seniorFundingReplicator(),
  270.                     0.,
  271.                     false
  272.                 ),
  273.                 org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  274.                     _ycfWidth,
  275.                     latentStateWeiner.incrementArray (dealerSeniorFundingReplicator.label())
  276.                 ),
  277.                 _ycfWidth
  278.             );
  279.         }
  280.         catch (java.lang.Exception e)
  281.         {
  282.             e.printStackTrace();
  283.         }

  285.         return null;
  286.     }

  288.     private org.drip.measure.realization.JumpDiffusionVertex[]
  289.         dealerSubordinateFundingReplicatorVertexArray (
  290.             final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  291.             final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  292.             final int terminalDate)
  293.     {
  294.         org.drip.exposure.evolver.PrimarySecurity dealerSubordinateFundingReplicator =
  295.             _primarySecurityDynamicsContainer.dealerSubordinateFunding();

  297.         double initialDealerSubordinateFundingReplicator =
  298.             initialMarketVertex.dealer().subordinateFundingReplicator();

  300.         if (null == dealerSubordinateFundingReplicator ||
  301.             !org.drip.numerical.common.NumberUtil.IsValid (initialDealerSubordinateFundingReplicator))
  302.         {
  303.             return null;
  304.         }

  306.         try
  307.         {
  308.             return dealerSubordinateFundingReplicator.evolver().vertexSequenceReverse (
  309.                 new org.drip.measure.realization.JumpDiffusionVertex (
  310.                     terminalDate,
  311.                     initialDealerSubordinateFundingReplicator,
  312.                     0.,
  313.                     false
  314.                 ),
  315.                 org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  316.                     _ycfWidth,
  317.                     latentStateWeiner.incrementArray (dealerSubordinateFundingReplicator.label())
  318.                 ),
  319.                 _ycfWidth
  320.             );
  321.         }
  322.         catch (java.lang.Exception e)
  323.         {
  324.             e.printStackTrace();
  325.         }

  327.         return null;
  328.     }

  330.     private org.drip.measure.realization.JumpDiffusionVertex[] clientFundingReplicatorVertexArray (
  331.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  332.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  333.         final int terminalDate)
  334.     {
  335.         org.drip.exposure.evolver.PrimarySecurity clientFundingReplicator =
  336.             _primarySecurityDynamicsContainer.clientFunding();

  338.         try
  339.         {
  340.             return clientFundingReplicator.evolver().vertexSequenceReverse (
  341.                 new org.drip.measure.realization.JumpDiffusionVertex (
  342.                     terminalDate,
  343.                     initialMarketVertex.client().seniorFundingReplicator(),
  344.                     0.,
  345.                     false
  346.                 ),
  347.                 org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  348.                     _ycfWidth,
  349.                     latentStateWeiner.incrementArray (clientFundingReplicator.label())
  350.                 ),
  351.                 _ycfWidth
  352.             );
  353.         }
  354.         catch (java.lang.Exception e)
  355.         {
  356.             e.printStackTrace();
  357.         }

  359.         return null;
  360.     }

  362.     private org.drip.measure.realization.JumpDiffusionVertex[] dealerHazardVertexArray (
  363.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  364.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  365.         final int terminalDate)
  366.     {
  367.         try
  368.         {
  369.             return _entityDynamicsContainer.dealerHazardRateEvolver().vertexSequence (
  370.                 new org.drip.measure.realization.JumpDiffusionVertex (
  371.                     terminalDate,
  372.                     initialMarketVertex.dealer().hazardRate(),
  373.                     0.,
  374.                     false
  375.                 ),
  376.                 org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  377.                     _ycfWidth,
  378.                     latentStateWeiner.incrementArray (_entityDynamicsContainer.dealerHazardLabel())
  379.                 ),
  380.                 _ycfWidth
  381.             );
  382.         }
  383.         catch (java.lang.Exception e)
  384.         {
  385.             e.printStackTrace();
  386.         }

  388.         return null;
  389.     }

  391.     private org.drip.measure.realization.JumpDiffusionVertex[] clientHazardVertexArray (
  392.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  393.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  394.         final int terminalDate)
  395.     {
  396.         try
  397.         {
  398.             return _entityDynamicsContainer.clientHazardRateEvolver().vertexSequence (
  399.                 new org.drip.measure.realization.JumpDiffusionVertex (
  400.                     terminalDate,
  401.                     initialMarketVertex.client().hazardRate(),
  402.                     0.,
  403.                     false
  404.                 ),
  405.                 org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  406.                     _ycfWidth,
  407.                     latentStateWeiner.incrementArray (_entityDynamicsContainer.clientHazardLabel())
  408.                 ),
  409.                 _ycfWidth
  410.             );
  411.         }
  412.         catch (java.lang.Exception e)
  413.         {
  414.             e.printStackTrace();
  415.         }

  417.         return null;
  418.     }

  420.     private org.drip.measure.realization.JumpDiffusionVertex[] dealerSeniorRecoveryVertexArray (
  421.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  422.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  423.         final int terminalDate)
  424.     {
  425.         try
  426.         {
  427.             return _entityDynamicsContainer.dealerSeniorRecoveryRateEvolver().vertexSequence (
  428.                 new org.drip.measure.realization.JumpDiffusionVertex (
  429.                     terminalDate,
  430.                     initialMarketVertex.dealer().seniorRecoveryRate(),
  431.                     0.,
  432.                     false
  433.                 ),
  434.                 org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  435.                     _ycfWidth,
  436.                     latentStateWeiner.incrementArray (_entityDynamicsContainer.dealerSeniorRecoveryLabel())
  437.                 ),
  438.                 _ycfWidth
  439.             );
  440.         }
  441.         catch (java.lang.Exception e)
  442.         {
  443.             e.printStackTrace();
  444.         }

  446.         return null;
  447.     }

  449.     private org.drip.measure.realization.JumpDiffusionVertex[] dealerSubordinateRecoveryVertexArray (
  450.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  451.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  452.         final int terminalDate)
  453.     {
  454.         org.drip.measure.process.DiffusionEvolver dealerSubordinateRecoveryRateEvolver =
  455.             _entityDynamicsContainer.dealerSubordinateRecoveryRateEvolver();

  457.         if (null == dealerSubordinateRecoveryRateEvolver)
  458.         {
  459.             return null;
  460.         }

  462.         try
  463.         {
  464.             return dealerSubordinateRecoveryRateEvolver.vertexSequence (
  465.                 new org.drip.measure.realization.JumpDiffusionVertex (
  466.                     terminalDate,
  467.                     initialMarketVertex.dealer().subordinateRecoveryRate(),
  468.                     0.,
  469.                     false
  470.                 ),
  471.                 org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  472.                     _ycfWidth,
  473.                     latentStateWeiner.incrementArray
  474.                         (_entityDynamicsContainer.dealerSubordinateRecoveryLabel())
  475.                 ),
  476.                 _ycfWidth
  477.             );
  478.         }
  479.         catch (java.lang.Exception e)
  480.         {
  481.             e.printStackTrace();
  482.         }

  484.         return null;
  485.     }

  487.     private org.drip.measure.realization.JumpDiffusionVertex[] clientRecoveryVertexArray (
  488.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  489.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner,
  490.         final int terminalDate)
  491.     {
  492.         try
  493.         {
  494.             return _entityDynamicsContainer.clientRecoveryRateEvolver().vertexSequence (
  495.                 new org.drip.measure.realization.JumpDiffusionVertex (
  496.                     terminalDate,
  497.                     initialMarketVertex.client().seniorRecoveryRate(),
  498.                     0.,
  499.                     false
  500.                 ),
  501.                 org.drip.measure.realization.JumpDiffusionEdgeUnit.Diffusion (
  502.                     _ycfWidth,
  503.                     latentStateWeiner.incrementArray (_entityDynamicsContainer.clientRecoveryLabel())
  504.                 ),
  505.                 _ycfWidth
  506.             );
  507.         }
  508.         catch (java.lang.Exception e)
  509.         {
  510.             e.printStackTrace();
  511.         }

  513.         return null;
  514.     }

  516.     /**
  517.      * MarketVertexGenerator Constructor
  518.      * 
  519.      * @param spotDate The Spot Date
  520.      * @param eventDateArray Array of the Event Dates
  521.      * @param entityDynamicsContainer The Dealer/Client Entity Latent State Dynamics Container
  522.      * @param primarySecurityDynamicsContainer The Primary Security Dynamics Container
  523.      * @param latentStateDynamicsContainer The Latent State Dynamics Container
  524.      * 
  525.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  526.      */

  528.     public MarketVertexGenerator (
  529.         final int spotDate,
  530.         final int[] eventDateArray,
  531.         final org.drip.exposure.evolver.EntityDynamicsContainer entityDynamicsContainer,
  532.         final org.drip.exposure.evolver.PrimarySecurityDynamicsContainer primarySecurityDynamicsContainer,
  533.         final org.drip.exposure.evolver.LatentStateDynamicsContainer latentStateDynamicsContainer)
  534.         throws java.lang.Exception
  535.     {
  536.         if (0 >= (_spotDate = spotDate) ||
  537.             null == (_eventDateArray = eventDateArray) ||
  538.             null == (_entityDynamicsContainer = entityDynamicsContainer))
  539.         {
  540.             throw new java.lang.Exception ("MarketVertexGenerator Constructor => Invalid Inputs");
  541.         }

  543.         int eventVertexCount = _eventDateArray.length;
  544.         _latentStateDynamicsContainer = latentStateDynamicsContainer;
  545.         _primarySecurityDynamicsContainer = primarySecurityDynamicsContainer;
  546.         _ycfWidth = 0 == eventVertexCount ? null : new double[eventVertexCount];

  548.         if (0 == eventVertexCount ||
  549.             0. >= (_ycfWidth[0] = ((double) (_eventDateArray[0] - _spotDate)) / 365.25))
  550.         {
  551.             throw new java.lang.Exception ("MarketVertexGenerator Constructor => Invalid Inputs");
  552.         }

  554.         for (int eventVertexIndex = 1; eventVertexIndex < eventVertexCount; ++eventVertexIndex)
  555.         {
  556.             if (0. >= (_ycfWidth[eventVertexIndex] = ((double) (_eventDateArray[eventVertexIndex] -
  557.                 _eventDateArray[eventVertexIndex - 1])) / 365.25))
  558.             {
  559.                 throw new java.lang.Exception ("MarketVertexGenerator Constructor => Invalid Inputs");
  560.             }
  561.         }
  562.     }

  564.     /**
  565.      * Retrieve the Spot Date
  566.      * 
  567.      * @return The Spot Date
  568.      */

  570.     public int spotDate()
  571.     {
  572.         return _spotDate;
  573.     }

  575.     /**
  576.      * Retrieve the Time Width Array
  577.      * 
  578.      * @return The Time Width Array
  579.      */

  581.     public double[] timeWidth()
  582.     {
  583.         return _ycfWidth;
  584.     }

  586.     /**
  587.      * Retrieve the Entity Dynamics Container
  588.      * 
  589.      * @return The Entity Dynamics Container
  590.      */

  592.     public org.drip.exposure.evolver.EntityDynamicsContainer entityDynamicsContainer()
  593.     {
  594.         return _entityDynamicsContainer;
  595.     }

  597.     /**
  598.      * Retrieve the Primary Security Dynamics Container
  599.      * 
  600.      * @return The Primary Security Dynamics Container
  601.      */

  603.     public org.drip.exposure.evolver.PrimarySecurityDynamicsContainer primarySecurityDynamicsContainer()
  604.     {
  605.         return _primarySecurityDynamicsContainer;
  606.     }

  608.     /**
  609.      * Retrieve the Latent State Dynamics Container
  610.      * 
  611.      * @return The Latent State Dynamics Container
  612.      */

  614.     public org.drip.exposure.evolver.LatentStateDynamicsContainer latentStateDynamicsContainer()
  615.     {
  616.         return _latentStateDynamicsContainer;
  617.     }

  619.     /**
  620.      * Retrieve the Vertex Date Array
  621.      * 
  622.      * @return The Vertex Date Array
  623.      */

  625.     public int[] vertexDates()
  626.     {
  627.         int eventDateCount = _eventDateArray.length;
  628.         int[] vertexDateArray = new int[eventDateCount + 1];
  629.         vertexDateArray[0] = _spotDate;

  631.         for (int i = 0; i < eventDateCount; ++i)
  632.             vertexDateArray[i + 1] = _eventDateArray[i];

  634.         return vertexDateArray;
  635.     }

  637.     /**
  638.      * Generate the Trajectory of the Simulated Market Vertexes
  639.      * 
  640.      * @param initialMarketVertex The Initial Market Vertex
  641.      * @param latentStateWeiner The Latent State Weiner Instance
  642.      * 
  643.      * @return The Trajectory of the Simulated Market Vertexes
  644.      */

  646.     public java.util.Map<java.lang.Integer, org.drip.exposure.universe.MarketVertex> marketVertex (
  647.         final org.drip.exposure.universe.MarketVertex initialMarketVertex,
  648.         final org.drip.exposure.universe.LatentStateWeiner latentStateWeiner)
  649.     {
  650.         if (null == initialMarketVertex ||
  651.             null == latentStateWeiner)
  652.         {
  653.             return null;
  654.         }

  656.         int latentStateCount = latentStateWeiner.stateCount();

  658.         if (7 > latentStateCount)
  659.         {
  660.             return null;
  661.         }

  663.         org.drip.exposure.evolver.LatentStateVertexContainer latentStateVertexContainerInitial =
  664.             initialMarketVertex.latentStateVertexContainer();

  666.         java.util.List<org.drip.state.identifier.LatentStateLabel> latentStateLabelList = null ==
  667.             latentStateVertexContainerInitial ? null : latentStateVertexContainerInitial.labelList();

  669.         double clientSurvivalProbabilityExponent = 0.;
  670.         double dealerSurvivalProbabilityExponent = 0.;
  671.         int eventVertexCount = _eventDateArray.length;
  672.         int terminalDate = _eventDateArray[eventVertexCount - 1];

  674.         int latentStateLabelCount = null == latentStateLabelList ? 0 : latentStateLabelList.size();

  676.         org.drip.measure.realization.JumpDiffusionVertex[] overnightReplicatorVertexArray =
  677.             overnightReplicatorVertexArray (
  678.                 initialMarketVertex,
  679.                 latentStateWeiner,
  680.                 terminalDate
  681.             );

  683.         org.drip.measure.realization.JumpDiffusionVertex[] csaReplicatorVertexArray =
  684.             csaReplicatorVertexArray (
  685.                 initialMarketVertex,
  686.                 latentStateWeiner,
  687.                 terminalDate
  688.             );

  690.         org.drip.measure.realization.JumpDiffusionVertex[] dealerSeniorFundingReplicatorVertexArray =
  691.             dealerSeniorFundingReplicatorVertexArray (
  692.                 initialMarketVertex,
  693.                 latentStateWeiner,
  694.                 terminalDate
  695.             );

  697.         org.drip.measure.realization.JumpDiffusionVertex[] dealerSubordinateFundingReplicatorVertexArray =
  698.             dealerSubordinateFundingReplicatorVertexArray (
  699.                 initialMarketVertex,
  700.                 latentStateWeiner,
  701.                 terminalDate
  702.             );

  704.         org.drip.measure.realization.JumpDiffusionVertex[] clientFundingReplicatorVertexArray =
  705.             clientFundingReplicatorVertexArray (
  706.                 initialMarketVertex,
  707.                 latentStateWeiner,
  708.                 terminalDate
  709.             );

  711.         org.drip.measure.realization.JumpDiffusionVertex[] dealerHazardVertexArray =
  712.             dealerHazardVertexArray (
  713.                 initialMarketVertex,
  714.                 latentStateWeiner,
  715.                 terminalDate
  716.             );

  718.         org.drip.measure.realization.JumpDiffusionVertex[] clientHazardVertexArray =
  719.             clientHazardVertexArray (
  720.                 initialMarketVertex,
  721.                 latentStateWeiner,
  722.                 terminalDate
  723.             );

  725.         org.drip.measure.realization.JumpDiffusionVertex[] dealerSeniorRecoveryVertexArray =
  726.             dealerSeniorRecoveryVertexArray (
  727.                 initialMarketVertex,
  728.                 latentStateWeiner,
  729.                 terminalDate
  730.             );

  732.         org.drip.measure.realization.JumpDiffusionVertex[] dealerSubordinateRecoveryVertexArray =
  733.             dealerSubordinateRecoveryVertexArray (
  734.                 initialMarketVertex,
  735.                 latentStateWeiner,
  736.                 terminalDate
  737.             );

  739.         org.drip.measure.realization.JumpDiffusionVertex[] clientRecoveryVertexArray =
  740.             clientRecoveryVertexArray (
  741.                 initialMarketVertex,
  742.                 latentStateWeiner,
  743.                 terminalDate
  744.             );

  746.         java.util.List<org.drip.measure.realization.JumpDiffusionVertex[]> latentStateVertexArrayList =
  747.             latentStateVertexArrayList (
  748.                 latentStateLabelList,
  749.                 initialMarketVertex,
  750.                 latentStateWeiner,
  751.                 terminalDate
  752.             );

  754.         if (null == overnightReplicatorVertexArray ||
  755.             null == csaReplicatorVertexArray ||
  756.             null == dealerSeniorFundingReplicatorVertexArray ||
  757.             null == clientFundingReplicatorVertexArray ||
  758.             null == dealerHazardVertexArray ||
  759.             null == clientHazardVertexArray ||
  760.             null == dealerSeniorRecoveryVertexArray ||
  761.             null == clientRecoveryVertexArray)
  762.         {
  763.             return null;
  764.         }

  766.         double initialCSAReplicator = csaReplicatorVertexArray[0].value();

  768.         double initialOvernightReplicator = overnightReplicatorVertexArray[0].value();

  770.         double initialDealerSeniorFundingReplicator = dealerSeniorFundingReplicatorVertexArray[0].value();

  772.         double initialDealerSubordinateFundingReplicator =
  773.             null == dealerSubordinateFundingReplicatorVertexArray ||
  774.             null == dealerSubordinateFundingReplicatorVertexArray[0] ?
  775.             java.lang.Double.NaN : dealerSubordinateFundingReplicatorVertexArray[0].value();

  777.         double initialClientFundingReplicator = clientFundingReplicatorVertexArray[0].value();

  779.         java.util.Map<java.lang.Integer, org.drip.exposure.universe.MarketVertex> marketVertexTrajectory =
  780.             new java.util.TreeMap<java.lang.Integer, org.drip.exposure.universe.MarketVertex>();

  782.         for (int eventVertexIndex = 1; eventVertexIndex <= eventVertexCount; ++eventVertexIndex)
  783.         {
  784.             double clientHazardRate = clientHazardVertexArray[eventVertexIndex].value();

  786.             double dealerHazardRate = dealerHazardVertexArray[eventVertexIndex].value();

  788.             double csaReplicatorFinish =  csaReplicatorVertexArray[eventVertexIndex].value();

  790.             double overnightReplicatorFinish = overnightReplicatorVertexArray[eventVertexIndex].value();

  792.             double clientFundingReplicatorFinish =
  793.                 clientFundingReplicatorVertexArray[eventVertexIndex].value();

  795.             double dealerSeniorFundingReplicatorFinish =
  796.                 dealerSeniorFundingReplicatorVertexArray[eventVertexIndex].value();

  798.             double timeWidth = _ycfWidth[eventVertexIndex - 1];
  799.             double timeWidthReciprocal = 1. / timeWidth;
  800.             clientSurvivalProbabilityExponent += clientHazardRate * timeWidth;
  801.             dealerSurvivalProbabilityExponent += dealerHazardRate * timeWidth;

  803.             double overnightRate = timeWidthReciprocal * java.lang.Math.log (overnightReplicatorFinish /
  804.                 initialOvernightReplicator);

  806.             double dealerSubordinateFundingReplicatorFinish =
  807.                 null == dealerSubordinateFundingReplicatorVertexArray ||
  808.                 null == dealerSubordinateFundingReplicatorVertexArray[eventVertexIndex] ?
  809.                 java.lang.Double.NaN :
  810.                 dealerSubordinateFundingReplicatorVertexArray[eventVertexIndex].value();

  812.             try
  813.             {
  814.                 org.drip.exposure.universe.MarketVertexEntity dealerMarketVertex =
  815.                     new org.drip.exposure.universe.MarketVertexEntity (
  816.                         java.lang.Math.exp (-1. * dealerSurvivalProbabilityExponent),
  817.                         dealerHazardRate,
  818.                         dealerSeniorRecoveryVertexArray[eventVertexIndex].value(),
  819.                         timeWidthReciprocal * java.lang.Math.log (dealerSeniorFundingReplicatorFinish /
  820.                             initialDealerSeniorFundingReplicator) - overnightRate,
  821.                         dealerSeniorFundingReplicatorFinish,
  822.                         null == dealerSubordinateFundingReplicatorVertexArray ||
  823.                         null == dealerSubordinateRecoveryVertexArray[eventVertexIndex] ? java.lang.Double.NaN
  824.                             : dealerSubordinateRecoveryVertexArray[eventVertexIndex].value(),
  825.                         null == dealerSubordinateFundingReplicatorVertexArray ? java.lang.Double.NaN :
  826.                             timeWidthReciprocal *
  827.                             java.lang.Math.log (dealerSubordinateFundingReplicatorFinish /
  828.                                 initialDealerSubordinateFundingReplicator) - overnightRate,
  829.                         dealerSubordinateFundingReplicatorFinish
  830.                     );

  832.                 org.drip.exposure.universe.MarketVertexEntity clientMarketVertex =
  833.                     new org.drip.exposure.universe.MarketVertexEntity (
  834.                         java.lang.Math.exp (-1. * clientSurvivalProbabilityExponent),
  835.                         clientHazardRate,
  836.                         clientRecoveryVertexArray[eventVertexIndex].value(),
  837.                         timeWidthReciprocal * java.lang.Math.log (clientFundingReplicatorFinish /
  838.                             initialClientFundingReplicator) - overnightRate,
  839.                         clientFundingReplicatorFinish,
  840.                         java.lang.Double.NaN,
  841.                         java.lang.Double.NaN,
  842.                         java.lang.Double.NaN
  843.                     );

  845.                 org.drip.exposure.evolver.LatentStateVertexContainer latentStateVertexContainer = new
  846.                     org.drip.exposure.evolver.LatentStateVertexContainer();

  848.                 if (null != latentStateVertexArrayList && null != latentStateLabelList)
  849.                 {
  850.                     for (int latentStateLabelIndex = 0; latentStateLabelIndex < latentStateLabelCount;
  851.                         ++latentStateLabelIndex)
  852.                     {
  853.                         org.drip.state.identifier.LatentStateLabel latentStateLabel =
  854.                             latentStateLabelList.get (latentStateLabelIndex);

  856.                         if (null != latentStateLabel)
  857.                         {
  858.                             latentStateVertexContainer.addLatentStateValue (
  859.                                 latentStateLabel,
  860.                                 latentStateVertexArrayList.get
  861.                                     (latentStateLabelIndex)[eventVertexIndex].value()
  862.                             );
  863.                         }
  864.                     }
  865.                 }

  867.                 org.drip.exposure.universe.MarketVertex marketVertex =
  868.                     new org.drip.exposure.universe.MarketVertex (
  869.                         new org.drip.analytics.date.JulianDate (_eventDateArray[eventVertexIndex - 1]),
  870.                         overnightRate,
  871.                         overnightReplicatorFinish,
  872.                         timeWidthReciprocal * java.lang.Math.log (csaReplicatorFinish / initialCSAReplicator)
  873.                             - overnightRate,
  874.                         csaReplicatorFinish,
  875.                         dealerMarketVertex,
  876.                         clientMarketVertex,
  877.                         latentStateVertexContainer
  878.                     );

  880.                 marketVertexTrajectory.put (
  881.                     _eventDateArray[eventVertexIndex - 1],
  882.                     marketVertex
  883.                 );
  884.             }
  885.             catch (java.lang.Exception e)
  886.             {
  887.                 e.printStackTrace();

  889.                 return null;
  890.             }

  892.             initialCSAReplicator = csaReplicatorFinish;
  893.             initialOvernightReplicator = overnightReplicatorFinish;
  894.             initialClientFundingReplicator = clientFundingReplicatorFinish;
  895.             initialDealerSeniorFundingReplicator = dealerSeniorFundingReplicatorFinish;
  896.             initialDealerSubordinateFundingReplicator = dealerSubordinateFundingReplicatorFinish;
  897.         }

  899.         try
  900.         {
  901.             double clientHazardVertexEpochal = clientHazardVertexArray[0].value();

  903.             double dealerHazardVertexEpochal = dealerHazardVertexArray[0].value();

  905.             marketVertexTrajectory.put (
  906.                 initialMarketVertex.anchorDate().julian(),
  907.                 new org.drip.exposure.universe.MarketVertex (
  908.                     new org.drip.analytics.date.JulianDate (_spotDate),
  909.                     0.,
  910.                     overnightReplicatorVertexArray[0].value(),
  911.                     0.,
  912.                     csaReplicatorVertexArray[0].value(),
  913.                     new org.drip.exposure.universe.MarketVertexEntity (
  914.                         java.lang.Math.exp (-1. * _ycfWidth[0] * dealerHazardVertexEpochal),
  915.                         dealerHazardVertexEpochal,
  916.                         dealerSeniorRecoveryVertexArray[0].value(),
  917.                         initialMarketVertex.dealer().seniorFundingSpread(),
  918.                         dealerSeniorFundingReplicatorVertexArray[0].value(),
  919.                         null == dealerSubordinateFundingReplicatorVertexArray ||
  920.                         null == dealerSubordinateRecoveryVertexArray[0] ? java.lang.Double.NaN :
  921.                             dealerSubordinateRecoveryVertexArray[0].value(),
  922.                         null == dealerSubordinateFundingReplicatorVertexArray ? java.lang.Double.NaN :
  923.                             initialMarketVertex.dealer().subordinateFundingSpread(),
  924.                         null == dealerSubordinateFundingReplicatorVertexArray ||
  925.                             null == dealerSubordinateFundingReplicatorVertexArray[0] ?
  926.                             java.lang.Double.NaN :
  927.                             dealerSubordinateFundingReplicatorVertexArray[0].value()
  928.                     ),
  929.                     new org.drip.exposure.universe.MarketVertexEntity (
  930.                         java.lang.Math.exp (-1. * _ycfWidth[0] * clientHazardVertexEpochal),
  931.                         clientHazardVertexEpochal,
  932.                         clientRecoveryVertexArray[0].value(),
  933.                         initialMarketVertex.client().seniorFundingSpread(),
  934.                         clientFundingReplicatorVertexArray[0].value(),
  935.                         java.lang.Double.NaN,
  936.                         java.lang.Double.NaN,
  937.                         java.lang.Double.NaN
  938.                     ),
  939.                     initialMarketVertex.latentStateVertexContainer()
  940.                 )
  941.             );
  942.         }
  943.         catch (java.lang.Exception e)
  944.         {
  945.             e.printStackTrace();

  947.             return null;
  948.         }

  950.         return marketVertexTrajectory;
  951.     }
  952. }
Created with JaCoCo 0.7.9.201702052155