JumpDiffusionEdge.java

  1. package org.drip.measure.realization;

  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.  * Copyright (C) 2016 Lakshmi Krishnamurthy
  13.  * 
  14.  *  This file is part of DROP, an open-source library targeting analytics/risk, transaction cost analytics,
  15.  *      asset liability management analytics, capital, exposure, and margin analytics, valuation adjustment
  16.  *      analytics, and portfolio construction analytics within and across fixed income, credit, commodity,
  17.  *      equity, FX, and structured products. It also includes auxiliary libraries for algorithm support,
  18.  *      numerical analysis, numerical optimization, spline builder, model validation, statistical learning,
  19.  *      and computational support.
  20.  *  
  21.  *      https://lakshmidrip.github.io/DROP/
  22.  *  
  23.  *  DROP is composed of three modules:
  24.  *  
  25.  *  - DROP Product Core - https://lakshmidrip.github.io/DROP-Product-Core/
  26.  *  - DROP Portfolio Core - https://lakshmidrip.github.io/DROP-Portfolio-Core/
  27.  *  - DROP Computational Core - https://lakshmidrip.github.io/DROP-Computational-Core/
  28.  * 
  29.  *  DROP Product Core implements libraries for the following:
  30.  *  - Fixed Income Analytics
  31.  *  - Loan Analytics
  32.  *  - Transaction Cost Analytics
  33.  * 
  34.  *  DROP Portfolio Core implements libraries for the following:
  35.  *  - Asset Allocation Analytics
  36.  *  - Asset Liability Management Analytics
  37.  *  - Capital Estimation Analytics
  38.  *  - Exposure Analytics
  39.  *  - Margin Analytics
  40.  *  - XVA Analytics
  41.  * 
  42.  *  DROP Computational Core implements libraries for the following:
  43.  *  - Algorithm Support
  44.  *  - Computation Support
  45.  *  - Function Analysis
  46.  *  - Model Validation
  47.  *  - Numerical Analysis
  48.  *  - Numerical Optimizer
  49.  *  - Spline Builder
  50.  *  - Statistical Learning
  51.  * 
  52.  *  Documentation for DROP is Spread Over:
  53.  * 
  54.  *  - Main                     => https://lakshmidrip.github.io/DROP/
  55.  *  - Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
  56.  *  - GitHub                   => https://github.com/lakshmiDRIP/DROP
  57.  *  - Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
  58.  *  - Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
  59.  *  - Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
  60.  *  - Release Versions         => https://lakshmidrip.github.io/DROP/version.html
  61.  *  - Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
  62.  *  - Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
  63.  *  - JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
  64.  *  - Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html
  65.  * 
  66.  *  Licensed under the Apache License, Version 2.0 (the "License");
  67.  *      you may not use this file except in compliance with the License.
  68.  *   
  69.  *  You may obtain a copy of the License at
  70.  *      http://www.apache.org/licenses/LICENSE-2.0
  71.  *  
  72.  *  Unless required by applicable law or agreed to in writing, software
  73.  *      distributed under the License is distributed on an "AS IS" BASIS,
  74.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  75.  *  
  76.  *  See the License for the specific language governing permissions and
  77.  *      limitations under the License.
  78.  */

  80. /**
  81.  * <i>JumpDiffusionEdge</i> implements the Deterministic and the Stochastic Components of a R<sup>d</sup>
  82.  * Marginal Random Increment Edge as well the Original Marginal Random Variate. The References are:
  83.  * 
  84.  * <br><br>
  85.  *  <ul>
  86.  *      <li>
  87.  *          Almgren, R. F., and N. Chriss (2000): Optimal Execution of Portfolio Transactions <i>Journal of
  88.  *              Risk</i> <b>3 (2)</b> 5-39
  89.  *      </li>
  90.  *      <li>
  91.  *          Almgren, R. F. (2009): Optimal Trading in a Dynamic Market
  92.  *              https://www.math.nyu.edu/financial_mathematics/content/02_financial/2009-2.pdf
  93.  *      </li>
  94.  *      <li>
  95.  *          Almgren, R. F. (2012): Optimal Trading with Stochastic Liquidity and Volatility <i>SIAM Journal
  96.  *              of Financial Mathematics</i> <b>3 (1)</b> 163-181
  97.  *      </li>
  98.  *      <li>
  99.  *          Geman, H., D. B. Madan, and M. Yor (2001): Time Changes for Levy Processes <i>Mathematical
  100.  *              Finance</i> <b>11 (1)</b> 79-96
  101.  *      </li>
  102.  *      <li>
  103.  *          Jones, C. M., G. Kaul, and M. L. Lipson (1994): Transactions, Volume, and Volatility <i>Review of
  104.  *              Financial Studies</i> <b>7 (4)</b> 631-651
  105.  *      </li>
  106.  *  </ul>
  107.  *
  108.  *  <br><br>
  109.  *  <ul>
  110.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  111.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/NumericalAnalysisLibrary.md">Numerical Analysis Library</a></li>
  112.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/README.md">R<sup>d</sup> Continuous/Discrete Probability Measures</a></li>
  113.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/realization/README.md">Stochastic Jump Diffusion Vertex Edge</a></li>
  114.  *  </ul>
  115.  * 
  116.  * @author Lakshmi Krishnamurthy
  117.  */

  119. public class JumpDiffusionEdge {
  120.     private double _dblStart = java.lang.Double.NaN;
  121.     private double _dblDeterministic = java.lang.Double.NaN;
  122.     private org.drip.measure.realization.StochasticEdgeJump _sej = null;
  123.     private org.drip.measure.realization.JumpDiffusionEdgeUnit _jdeu = null;
  124.     private org.drip.measure.realization.StochasticEdgeDiffusion _sed = null;

  126.     /**
  127.      * Construct the Standard JumpDiffusionEdge Instance
  128.      * 
  129.      * @param dblStart The Starting Random Variable Realization
  130.      * @param dblDeterministic The Deterministic Increment Component
  131.      * @param dblDiffusionStochastic The Diffusion Stochastic Edge Change Amount
  132.      * @param bJumpOccurred TRUE - The Jump Occurred in this Edge Period
  133.      * @param dblHazardRate The Hazard Rate
  134.      * @param dblHazardIntegral The Level Hazard Integral
  135.      * @param dblJumpTarget The Jump Target
  136.      * @param dblTimeIncrement The Time Increment
  137.      * @param dblUnitDiffusion The Diffusion Random Variable
  138.      * @param dblUnitJump The Jump Random Variable
  139.      * 
  140.      * @return The JumpDiffusionEdge Instance
  141.      */

  143.     public static final JumpDiffusionEdge Standard (
  144.         final double dblStart,
  145.         final double dblDeterministic,
  146.         final double dblDiffusionStochastic,
  147.         final boolean bJumpOccurred,
  148.         final double dblHazardRate,
  149.         final double dblHazardIntegral,
  150.         final double dblJumpTarget,
  151.         final double dblTimeIncrement,
  152.         final double dblUnitDiffusion,
  153.         final double dblUnitJump)
  154.     {
  155.         try {
  156.             return new JumpDiffusionEdge (dblStart, dblDeterministic, new
  157.                 org.drip.measure.realization.StochasticEdgeDiffusion (dblDiffusionStochastic), new
  158.                     org.drip.measure.realization.StochasticEdgeJump (bJumpOccurred, dblHazardRate,
  159.                         dblHazardIntegral, dblJumpTarget), new
  160.                             org.drip.measure.realization.JumpDiffusionEdgeUnit (dblTimeIncrement,
  161.                                 dblUnitDiffusion, dblUnitJump));
  162.         } catch (java.lang.Exception e) {
  163.             e.printStackTrace();
  164.         }

  166.         return null;
  167.     }

  169.     /**
  170.      * Construct the Standard JumpDiffusionEdge Instance
  171.      * 
  172.      * @param dblStart The Starting Random Variable Realization
  173.      * @param dblDeterministic The Deterministic Increment Component
  174.      * @param dblDiffusionStochastic The Diffusion Stochastic Edge Change Amount
  175.      * @param sej The Stochastic Jump Edge Instance
  176.      * @param jdeu The Random Unit Realization
  177.      * 
  178.      * @return The JumpDiffusionEdge Instance
  179.      */

  181.     public static final JumpDiffusionEdge Standard (
  182.         final double dblStart,
  183.         final double dblDeterministic,
  184.         final double dblDiffusionStochastic,
  185.         final org.drip.measure.realization.StochasticEdgeJump sej,
  186.         final org.drip.measure.realization.JumpDiffusionEdgeUnit jdeu)
  187.     {
  188.         try {
  189.             return new JumpDiffusionEdge (dblStart, dblDeterministic, new
  190.                 org.drip.measure.realization.StochasticEdgeDiffusion (dblDiffusionStochastic), sej, jdeu);
  191.         } catch (java.lang.Exception e) {
  192.             e.printStackTrace();
  193.         }

  195.         return null;
  196.     }

  198.     /**
  199.      * JumpDiffusionEdge Constructor
  200.      * 
  201.      * @param dblStart The Starting Random Variable Realization
  202.      * @param dblDeterministic The Deterministic Increment Component
  203.      * @param sed The Stochastic Diffusion Edge Instance
  204.      * @param sej The Stochastic Jump Edge Instance
  205.      * @param jdeu The Random Unit Realization
  206.      * 
  207.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  208.      */

  210.     public JumpDiffusionEdge (
  211.         final double dblStart,
  212.         final double dblDeterministic,
  213.         final org.drip.measure.realization.StochasticEdgeDiffusion sed,
  214.         final org.drip.measure.realization.StochasticEdgeJump sej,
  215.         final org.drip.measure.realization.JumpDiffusionEdgeUnit jdeu)
  216.         throws java.lang.Exception
  217.     {
  218.         _sed = sed;
  219.         _sej = sej;

  221.         if (!org.drip.numerical.common.NumberUtil.IsValid (_dblStart = dblStart) ||
  222.             !org.drip.numerical.common.NumberUtil.IsValid (_dblDeterministic = dblDeterministic) || (null == _sed
  223.                 && null == _sej) || null == (_jdeu = jdeu))
  224.             throw new java.lang.Exception ("JumpDiffusionEdge Constructor => Invalid Inputs");
  225.     }

  227.     /**
  228.      * Retrieve the Edge Time Increment
  229.      * 
  230.      * @return The Edge Time Increment
  231.      */

  233.     public double timeIncrement()
  234.     {
  235.         return _jdeu.timeIncrement();
  236.     }

  238.     /**
  239.      * Retrieve the Start Realization
  240.      * 
  241.      * @return The Start Realization
  242.      */

  244.     public double start()
  245.     {
  246.         return _dblStart;
  247.     }

  249.     /**
  250.      * Retrieve the Deterministic Component
  251.      * 
  252.      * @return The Deterministic Component
  253.      */

  255.     public double deterministic()
  256.     {
  257.         return _dblDeterministic;
  258.     }

  260.     /**
  261.      * Retrieve the Diffusion Stochastic Component
  262.      * 
  263.      * @return The Diffusion Stochastic Component
  264.      */

  266.     public double diffusionStochastic()
  267.     {
  268.         return null == _sed ? 0. : _sed.change();
  269.     }

  271.     /**
  272.      * Retrieve the Diffusion Wander Realization
  273.      * 
  274.      * @return The Diffusion Wander Realization
  275.      */

  277.     public double diffusionWander()
  278.     {
  279.         return _jdeu.diffusion();
  280.     }

  282.     /**
  283.      * Retrieve the Jump Stochastic Component
  284.      * 
  285.      * @return The Jump Stochastic Component
  286.      */

  288.     public double jumpStochastic()
  289.     {
  290.         return null == _sej ? 0. : _sej.target();
  291.     }

  293.     /**
  294.      * Retrieve the Jump Wander Realization
  295.      * 
  296.      * @return The Jump Wander Realization
  297.      */

  299.     public double jumpWander()
  300.     {
  301.         return _jdeu.jump();
  302.     }

  304.     /**
  305.      * Retrieve the Finish Realization
  306.      * 
  307.      * @return The Finish Realization
  308.      */

  310.     public double finish()
  311.     {
  312.         return null == _sej || !_sej.jumpOccurred() ? _dblStart + _dblDeterministic + diffusionStochastic() :
  313.             _sej.target();
  314.     }

  316.     /**
  317.      * Retrieve the Gross Change
  318.      * 
  319.      * @return The Gross Change
  320.      */

  322.     public double grossChange()
  323.     {
  324.         return finish() - _dblStart;
  325.     }

  327.     /**
  328.      * Retrieve the Stochastic Diffusion Edge Instance
  329.      * 
  330.      * @return The Stochastic Diffusion Edge Instance
  331.      */

  333.     public org.drip.measure.realization.StochasticEdgeDiffusion stochasticDiffusionEdge()
  334.     {
  335.         return _sed;
  336.     }

  338.     /**
  339.      * Retrieve the Stochastic Jump Edge Instance
  340.      * 
  341.      * @return The Stochastic Jump Edge Instance
  342.      */

  344.     public org.drip.measure.realization.StochasticEdgeJump stochasticJumpEdge()
  345.     {
  346.         return _sej;
  347.     }
  348. }
Created with JaCoCo 0.7.9.201702052155