TrajectoryEvolutionScheme.java

  1. package org.drip.xva.pde;

  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>TrajectoryEvolutionScheme</i> holds the Evolution Edges of a Trajectory evolved in a Dynamically
  81.  * Adaptive Manner, as laid out in Burgard and Kjaer (2014). The References are:
  82.  *
  83.  *  <br><br>
  84.  *  <ul>
  85.  *      <li>
  86.  *          Burgard, C., and M. Kjaer (2014): PDE Representations of Derivatives with Bilateral Counter-party
  87.  *              Risk and Funding Costs <i>Journal of Credit Risk</i> <b>7 (3)</b> 1-19
  88.  *      </li>
  89.  *      <li>
  90.  *          Cesari, G., J. Aquilina, N. Charpillon, X. Filipovic, G. Lee, and L. Manda (2009): <i>Modeling,
  91.  *              Pricing, and Hedging Counter-party Credit Exposure - A Technical Guide</i> <b>Springer
  92.  *              Finance</b> New York
  93.  *      </li>
  94.  *      <li>
  95.  *          Gregory, J. (2009): Being Two-faced over Counter-party Credit Risk <i>Risk</i> <b>20 (2)</b>
  96.  *              86-90
  97.  *      </li>
  98.  *      <li>
  99.  *          Li, B., and Y. Tang (2007): <i>Quantitative Analysis, Derivatives Modeling, and Trading
  100.  *              Strategies in the Presence of Counter-party Credit Risk for the Fixed Income Market</i>
  101.  *              <b>World Scientific Publishing</b> Singapore
  102.  *      </li>
  103.  *      <li>
  104.  *          Piterbarg, V. (2010): Funding Beyond Discounting: Collateral Agreements and Derivatives Pricing
  105.  *              <i>Risk</i> <b>21 (2)</b> 97-102
  106.  *      </li>
  107.  *  </ul>
  108.  *
  109.  *  <br><br>
  110.  *  <ul>
  111.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/PortfolioCore.md">Portfolio Core Module</a></li>
  112.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/XVAAnalyticsLibrary.md">XVA Analytics Library</a></li>
  113.  *      <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>
  114.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/xva/pde/README.md">Burgard Kjaer PDE Evolution Scheme</a></li>
  115.  *  </ul>
  116.  * <br><br>
  117.  * 
  118.  * @author Lakshmi Krishnamurthy
  119.  */

  121. public class TrajectoryEvolutionScheme
  122. {
  123.     private org.drip.xva.definition.PDEEvolutionControl _pdeEvolutionControl = null;
  124.     private org.drip.exposure.evolver.PrimarySecurityDynamicsContainer _tradeablesContainer = null;

  126.     /**
  127.      * TrajectoryEvolutionScheme Constructor
  128.      * 
  129.      * @param tradeablesContainer The Universe of Tradeables
  130.      * @param pdeEvolutionControl The XVA PDE Control Settings
  131.      * 
  132.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  133.      */

  135.     public TrajectoryEvolutionScheme (
  136.         final org.drip.exposure.evolver.PrimarySecurityDynamicsContainer tradeablesContainer,
  137.         final org.drip.xva.definition.PDEEvolutionControl pdeEvolutionControl)
  138.         throws java.lang.Exception
  139.     {
  140.         if (null == (_tradeablesContainer = tradeablesContainer) ||
  141.             null == (_pdeEvolutionControl = pdeEvolutionControl))
  142.         {
  143.             throw new java.lang.Exception ("TrajectoryEvolutionScheme Constructor => Invalid Inputs");
  144.         }
  145.     }

  147.     /**
  148.      * Retrieve the Universe of Tradeables
  149.      * 
  150.      * @return The Universe of Tradeables
  151.      */

  153.     public org.drip.exposure.evolver.PrimarySecurityDynamicsContainer tradeablesContainer()
  154.     {
  155.         return _tradeablesContainer;
  156.     }

  158.     /**
  159.      * Retrieve the XVA PDE Control Settings
  160.      * 
  161.      * @return The XVA PDE Control Settings
  162.      */

  164.     public org.drip.xva.definition.PDEEvolutionControl pdeEvolutionControl()
  165.     {
  166.         return _pdeEvolutionControl;
  167.     }

  169.     /**
  170.      * Re-balance the Cash Account and generate the Derivative Value Update
  171.      * 
  172.      * @param initialTrajectoryVertex The Starting Evolution Trajectory Vertex
  173.      * @param marketEdge Market Edge Instance
  174.      * 
  175.      * @return The CashAccountRebalancer Instance
  176.      */

  178.     public org.drip.xva.derivative.CashAccountRebalancer rebalanceCash (
  179.         final org.drip.xva.derivative.EvolutionTrajectoryVertex initialTrajectoryVertex,
  180.         final org.drip.exposure.universe.MarketEdge marketEdge)
  181.     {
  182.         if (null == initialTrajectoryVertex ||
  183.             null == marketEdge)
  184.         {
  185.             return null;
  186.         }

  188.         org.drip.xva.derivative.ReplicationPortfolioVertex initialReplicationPortfolioVertex =
  189.             initialTrajectoryVertex.replicationPortfolioVertex();

  191.         double initialPortfolioHoldings = initialReplicationPortfolioVertex.positionHoldings();

  193.         double initialDealerSeniorNumeraireHoldings =
  194.             initialReplicationPortfolioVertex.dealerSeniorNumeraireHoldings();

  196.         double initialClientNumeraireHoldings = initialReplicationPortfolioVertex.clientNumeraireHoldings();

  198.         double initialDealerSubordinateNumeraireHoldings =
  199.             initialReplicationPortfolioVertex.dealerSubordinateNumeraireHoldings();

  201.         org.drip.exposure.universe.MarketVertex initialMarketVertex = marketEdge.start();

  203.         org.drip.exposure.universe.MarketVertex finalMarketVertex = marketEdge.finish();

  205.         org.drip.exposure.universe.MarketVertexEntity emvDealerStart = initialMarketVertex.dealer();

  207.         org.drip.exposure.universe.MarketVertexEntity dealerMarketVertex = finalMarketVertex.dealer();

  209.         org.drip.exposure.universe.MarketVertexEntity clientMarketVertex = finalMarketVertex.client();

  211.         double finalDealerSeniorFundingNumeraire = dealerMarketVertex.seniorFundingReplicator();

  213.         double finalClientNumeraire = clientMarketVertex.seniorFundingReplicator();

  215.         double initialDealerSubordinateFundingNumeraire = emvDealerStart.subordinateFundingReplicator();

  217.         double finalDealerSubordinateFundingNumeraire = dealerMarketVertex.subordinateFundingReplicator();

  219.         double timeIncrement = marketEdge.vertexIncrement() / 365.25;

  221.         org.drip.exposure.evolver.PrimarySecurity clientFundingTradeable = _tradeablesContainer.clientFunding();

  223.         double clientCashAccumulation = initialClientNumeraireHoldings *
  224.             clientFundingTradeable.cashAccumulationRate() * finalClientNumeraire * timeIncrement;

  226.         double clientHoldingsValueChange = initialClientNumeraireHoldings * (finalClientNumeraire -
  227.             initialMarketVertex.client().seniorFundingReplicator());

  229.         double cashAccountBalance = -1. * initialTrajectoryVertex.positionGreekVertex().derivativeXVAValue()
  230.             - initialDealerSeniorNumeraireHoldings * finalDealerSeniorFundingNumeraire;

  232.         if (org.drip.numerical.common.NumberUtil.IsValid (finalDealerSubordinateFundingNumeraire))
  233.         {
  234.             cashAccountBalance -= initialDealerSubordinateNumeraireHoldings *
  235.                 finalDealerSubordinateFundingNumeraire;
  236.         }

  238.         org.drip.exposure.evolver.PrimarySecurity csaTradeable = _tradeablesContainer.csa();

  240.         org.drip.exposure.evolver.PrimarySecurity dealerSeniorFundingTradeable =
  241.             _tradeablesContainer.dealerSeniorFunding();

  243.         double dealerCashAccumulation = cashAccountBalance * (cashAccountBalance > 0. ?
  244.             csaTradeable.cashAccumulationRate() : dealerSeniorFundingTradeable.cashAccumulationRate()) *
  245.                 timeIncrement;

  247.         try
  248.         {
  249.             double finalPortfolioValue = finalMarketVertex.latentStateValue
  250.                 (_tradeablesContainer.assetList().get (0).label());

  252.             double portfolioCashChange = initialPortfolioHoldings *
  253.                 _tradeablesContainer.assetList().get (0).cashAccumulationRate() * finalPortfolioValue *
  254.                     timeIncrement;

  256.             double derivativeXVAValueChange = -1. * (initialPortfolioHoldings * (finalPortfolioValue -
  257.                 initialMarketVertex.latentStateValue (_tradeablesContainer.assetList().get (0).label())) +
  258.                     initialDealerSeniorNumeraireHoldings * (finalDealerSeniorFundingNumeraire -
  259.                         emvDealerStart.seniorFundingReplicator()) + clientHoldingsValueChange +
  260.                             (portfolioCashChange + clientCashAccumulation + dealerCashAccumulation) *
  261.                                 timeIncrement);

  263.             if (org.drip.numerical.common.NumberUtil.IsValid (initialDealerSubordinateFundingNumeraire) &&
  264.                 org.drip.numerical.common.NumberUtil.IsValid (finalDealerSubordinateFundingNumeraire))
  265.             {
  266.                 derivativeXVAValueChange += initialDealerSubordinateNumeraireHoldings *
  267.                     (finalDealerSubordinateFundingNumeraire - initialDealerSubordinateFundingNumeraire);
  268.             }

  270.             return new org.drip.xva.derivative.CashAccountRebalancer (
  271.                 new org.drip.xva.derivative.CashAccountEdge (
  272.                     portfolioCashChange,
  273.                     dealerCashAccumulation * timeIncrement,
  274.                     clientCashAccumulation * timeIncrement
  275.                 ),
  276.                 derivativeXVAValueChange
  277.             );
  278.         }
  279.         catch (java.lang.Exception e)
  280.         {
  281.             e.printStackTrace();
  282.         }

  284.         return null;
  285.     }

  287.     /**
  288.      * Execute a Single Euler Time Step Walk
  289.      * 
  290.      * @param marketEdge Market Edge Instance
  291.      * @param burgardKjaerOperator The Burgard Kjaer Operator Instance
  292.      * @param initialTrajectoryVertex The Starting ETV Instance
  293.      * @param collateral The Applicable Collateral
  294.      * 
  295.      * @return The Evolution Trajectory Edge
  296.      */

  298.     public org.drip.xva.derivative.EvolutionTrajectoryEdge eulerWalk (
  299.         final org.drip.exposure.universe.MarketEdge marketEdge,
  300.         final org.drip.xva.pde.BurgardKjaerOperator burgardKjaerOperator,
  301.         final org.drip.xva.derivative.EvolutionTrajectoryVertex initialTrajectoryVertex,
  302.         final double collateral)
  303.     {
  304.         if (null == marketEdge ||
  305.             null == burgardKjaerOperator ||
  306.             null == initialTrajectoryVertex)
  307.         {
  308.             return null;
  309.         }

  311.         org.drip.xva.derivative.PositionGreekVertex initialPositionGreekVertex =
  312.             initialTrajectoryVertex.positionGreekVertex();

  314.         org.drip.xva.pde.BurgardKjaerEdgeRun burgardKjaerEdgeRun = burgardKjaerOperator.edgeRun (
  315.             marketEdge,
  316.             initialTrajectoryVertex,
  317.             collateral
  318.         );

  320.         double initialTime = initialTrajectoryVertex.time();

  322.         double timeIncrement = marketEdge.vertexIncrement() / 365.25;

  324.         if (null == burgardKjaerEdgeRun)
  325.         {
  326.             return null;
  327.         }

  329.         double theta = burgardKjaerEdgeRun.theta();

  331.         double positionValueBump = burgardKjaerEdgeRun.positionValueBump();

  333.         double thetaPositionValueUp = burgardKjaerEdgeRun.thetaPositionValueUp();

  335.         double thetaPositionValueDown = burgardKjaerEdgeRun.thetaPositionValueDown();

  337.         org.drip.exposure.universe.MarketVertex finalMarketVertex = marketEdge.finish();

  339.         org.drip.exposure.universe.MarketVertexEntity dealerMarketVertex = finalMarketVertex.dealer();

  341.         org.drip.exposure.universe.MarketVertexEntity clientMarketVertex = finalMarketVertex.client();

  343.         double derivativeXVAValueDeltaFinish =
  344.             initialPositionGreekVertex.derivativeXVAValueDelta() +
  345.             0.5 * (thetaPositionValueUp - thetaPositionValueDown) * timeIncrement / positionValueBump;

  347.         double clientGainOnDealerDefault = java.lang.Double.NaN;
  348.         double finalGainOnClientDefault = java.lang.Double.NaN;

  350.         double derivativeXVAValueFinish = initialPositionGreekVertex.derivativeXVAValue() - theta *
  351.             timeIncrement;

  353.         try
  354.         {
  355.             org.drip.xva.definition.CloseOut closeOutScheme = new
  356.                 org.drip.xva.definition.CloseOutBilateral (
  357.                     dealerMarketVertex.seniorRecoveryRate(),
  358.                     clientMarketVertex.seniorRecoveryRate()
  359.                 );

  361.             clientGainOnDealerDefault = closeOutScheme.dealerDefault (derivativeXVAValueFinish);

  363.             finalGainOnClientDefault = -1. * (derivativeXVAValueFinish - closeOutScheme.clientDefault
  364.                 (derivativeXVAValueFinish));
  365.         }
  366.         catch (java.lang.Exception e)
  367.         {
  368.             e.printStackTrace();

  370.             return null;
  371.         }

  373.         double dealerSubordinateFundingNumeraire = dealerMarketVertex.subordinateFundingReplicator();

  375.         double gainOnDealerDefaultFinish = -1. * (derivativeXVAValueFinish - clientGainOnDealerDefault);

  377.         double finalClientHoldings = finalGainOnClientDefault / clientMarketVertex.seniorFundingReplicator();

  379.         org.drip.xva.derivative.CashAccountRebalancer cashAccountRebalancer = rebalanceCash (
  380.             initialTrajectoryVertex,
  381.             marketEdge
  382.         );

  384.         if (null == cashAccountRebalancer)
  385.         {
  386.             return null;
  387.         }

  389.         org.drip.xva.derivative.CashAccountEdge cashAccountEdge = cashAccountRebalancer.cashAccountEdge();

  391.         double dealerSeniorFundingNumeraire = dealerMarketVertex.seniorFundingReplicator();

  393.         org.drip.exposure.evolver.PrimarySecurity csaTradeable = _tradeablesContainer.csa();

  395.         try
  396.         {
  397.             org.drip.xva.derivative.EvolutionTrajectoryVertex finalTrajectoryVertex = new
  398.                 org.drip.xva.derivative.EvolutionTrajectoryVertex (
  399.                 initialTime + timeIncrement,
  400.                 new org.drip.xva.derivative.ReplicationPortfolioVertex (
  401.                     -1. * derivativeXVAValueDeltaFinish,
  402.                     gainOnDealerDefaultFinish / dealerSeniorFundingNumeraire,
  403.                     !org.drip.numerical.common.NumberUtil.IsValid (dealerSubordinateFundingNumeraire) ? 0. :
  404.                         gainOnDealerDefaultFinish / dealerSubordinateFundingNumeraire,
  405.                     finalClientHoldings,
  406.                     initialTrajectoryVertex.replicationPortfolioVertex().cashAccount() +
  407.                         cashAccountEdge.accumulation()
  408.                 ),
  409.                 new org.drip.xva.derivative.PositionGreekVertex (
  410.                     derivativeXVAValueFinish,
  411.                     derivativeXVAValueDeltaFinish,
  412.                     initialPositionGreekVertex.derivativeXVAValueGamma() +
  413.                         (thetaPositionValueUp + thetaPositionValueDown - 2. * theta) *
  414.                         timeIncrement / (positionValueBump * positionValueBump),
  415.                     initialPositionGreekVertex.derivativeFairValue() * java.lang.Math.exp (
  416.                         -1. * timeIncrement *
  417.                         csaTradeable.evolver().evaluator().drift().value (
  418.                             new org.drip.measure.realization.JumpDiffusionVertex (
  419.                                 initialTime - 0.5 * timeIncrement,
  420.                                 marketEdge.start().csaReplicator(),
  421.                                 0.,
  422.                                 false
  423.                             )
  424.                         )
  425.                     )
  426.                 ),
  427.                 gainOnDealerDefaultFinish,
  428.                 finalGainOnClientDefault,
  429.                 collateral,
  430.                 burgardKjaerEdgeRun.derivativeXVAHedgeErrorGrowth()
  431.             );

  433.             return new org.drip.xva.derivative.EvolutionTrajectoryEdge (
  434.                 initialTrajectoryVertex,
  435.                 finalTrajectoryVertex,
  436.                 cashAccountEdge
  437.             );
  438.         }
  439.         catch (java.lang.Exception e)
  440.         {
  441.             e.printStackTrace();
  442.         }

  444.         return null;
  445.     }

  447.     /**
  448.      * Execute a Sequential Array of Euler Time Step Walks
  449.      * 
  450.      * @param marketVertexArray Array of Market Vertexes
  451.      * @param burgardKjaerOperator The Burgard Kjaer Operator Instance
  452.      * @param initialTrajectoryVertex The Starting EET Instance
  453.      * @param collateral The Applicable Collateral
  454.      * 
  455.      * @return Array of EvolutionTrajectoryEdge Instances
  456.      */

  458.     public org.drip.xva.derivative.EvolutionTrajectoryEdge[] eulerWalk (
  459.         final org.drip.exposure.universe.MarketVertex[] marketVertexArray,
  460.         final org.drip.xva.pde.BurgardKjaerOperator burgardKjaerOperator,
  461.         final org.drip.xva.derivative.EvolutionTrajectoryVertex initialTrajectoryVertex,
  462.         final double collateral)
  463.     {
  464.         if (null == marketVertexArray)
  465.         {
  466.             return null;
  467.         }

  469.         int vertexCount = marketVertexArray.length;
  470.         org.drip.xva.derivative.EvolutionTrajectoryVertex trajectoryVertex = initialTrajectoryVertex;
  471.         org.drip.xva.derivative.EvolutionTrajectoryEdge[] evolutionTrajectoryEdgeArray = 1 >= vertexCount ?
  472.             null : new org.drip.xva.derivative.EvolutionTrajectoryEdge[vertexCount - 1];

  474.         if (0 == vertexCount)
  475.         {
  476.             return null;
  477.         }

  479.         for (int i = vertexCount - 2; i >= 0; --i)
  480.         {
  481.             try
  482.             {
  483.                 if (null == (evolutionTrajectoryEdgeArray[i] = eulerWalk (
  484.                     new org.drip.exposure.universe.MarketEdge (
  485.                         marketVertexArray[i],
  486.                         marketVertexArray[i + 1]
  487.                     ),
  488.                     burgardKjaerOperator,
  489.                     trajectoryVertex,
  490.                     collateral)))
  491.                 {
  492.                     return null;
  493.                 }
  494.             }
  495.             catch (java.lang.Exception e)
  496.             {
  497.                 e.printStackTrace();
  498.             }

  500.             trajectoryVertex = evolutionTrajectoryEdgeArray[i].vertexFinish();
  501.         }

  503.         return evolutionTrajectoryEdgeArray;
  504.     }
  505. }
Created with JaCoCo 0.7.9.201702052155