OrnsteinUhlenbeckPair.java

  1. package org.drip.measure.process;

  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>OrnsteinUhlenbeckPair</i> guides the Random Variable Evolution according to 2D Ornstein-Uhlenbeck Mean
  82.  * Reverting Process. The References are:
  83.  * 
  84.  * <br><br>
  85.  *  <ul>
  86.  *      <li>
  87.  *          Almgren, R. F. (2009): Optimal Trading in a Dynamic Market
  88.  *              https://www.math.nyu.edu/financial_mathematics/content/02_financial/2009-2.pdf
  89.  *      </li>
  90.  *      <li>
  91.  *          Almgren, R. F. (2012): Optimal Trading with Stochastic Liquidity and Volatility <i>SIAM Journal
  92.  *              of Financial Mathematics</i> <b>3 (1)</b> 163-181
  93.  *      </li>
  94.  *      <li>
  95.  *          Geman, H., D. B. Madan, and M. Yor (2001): Time Changes for Levy Processes <i>Mathematical
  96.  *              Finance</i> <b>11 (1)</b> 79-96
  97.  *      </li>
  98.  *      <li>
  99.  *          Jones, C. M., G. Kaul, and M. L. Lipson (1994): Transactions, Volume, and Volatility <i>Review of
  100.  *              Financial Studies</i> <b>7 (4)</b> 631-651
  101.  *      </li>
  102.  *      <li>
  103.  *          Walia, N. (2006): <i>Optimal Trading - Dynamic Stock Liquidation Strategies</i> <b>Princeton
  104.  *              University</b>
  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/process/README.md">Jump Diffusion Evolver Process Variants</a></li>
  114.  *  </ul>
  115.  *
  116.  * @author Lakshmi Krishnamurthy
  117.  */

  119. public class OrnsteinUhlenbeckPair implements org.drip.measure.process.OrnsteinUhlenbeck {
  120.     private double _dblCorrelation = java.lang.Double.NaN;
  121.     private org.drip.measure.dynamics.DiffusionEvaluatorOrnsteinUhlenbeck _deouDerived = null;
  122.     private org.drip.measure.dynamics.DiffusionEvaluatorOrnsteinUhlenbeck _deouReference = null;

  124.     /**
  125.      * OrnsteinUhlenbeckPair Constructor
  126.      * 
  127.      * @param deouReference The Reference R^1 Ornstein-Uhlenbeck Evaluator
  128.      * @param deouDerived The Derived R^1 Ornstein-Uhlenbeck Evaluator
  129.      * @param dblCorrelation The Correlation between the Two Ornstein-Uhlenbeck Processes
  130.      * 
  131.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  132.      */

  134.     public OrnsteinUhlenbeckPair (
  135.         final org.drip.measure.dynamics.DiffusionEvaluatorOrnsteinUhlenbeck deouReference,
  136.         final org.drip.measure.dynamics.DiffusionEvaluatorOrnsteinUhlenbeck deouDerived,
  137.         final double dblCorrelation)
  138.         throws java.lang.Exception
  139.     {
  140.         if (null == (_deouReference = deouReference) || null == (_deouDerived = deouDerived) ||
  141.             !org.drip.numerical.common.NumberUtil.IsValid (_dblCorrelation = dblCorrelation) || _dblCorrelation <
  142.                 -1. || _dblCorrelation > 1.)
  143.             throw new java.lang.Exception ("OrnsteinUhlenbeckPair Constructor => Invalid Inputs");
  144.     }

  146.     /**
  147.      * Retrieve the Reference R^1 Ornstein-Uhlenbeck Evaluator
  148.      * 
  149.      * @return The Reference R^1 Ornstein-Uhlenbeck Evaluator
  150.      */

  152.     public org.drip.measure.dynamics.DiffusionEvaluatorOrnsteinUhlenbeck reference()
  153.     {
  154.         return _deouReference;
  155.     }

  157.     /**
  158.      * Retrieve the Derived R^1 Ornstein-Uhlenbeck Evaluator
  159.      * 
  160.      * @return The Derived R^1 Ornstein-Uhlenbeck Evaluator
  161.      */

  163.     public org.drip.measure.dynamics.DiffusionEvaluatorOrnsteinUhlenbeck derived()
  164.     {
  165.         return _deouDerived;
  166.     }

  168.     /**
  169.      * Retrieve the Correlation between the Ornstein-Uhlenbeck Processes
  170.      * 
  171.      * @return The Correlation between the Ornstein-Uhlenbeck Processes
  172.      */

  174.     public double correlation()
  175.     {
  176.         return _dblCorrelation;
  177.     }

  179.     /**
  180.      * Generate the Adjacent JumpDiffusionEdge Increment Array from the specified Ornstein Uhlenbeck Random
  181.      *      Variate Pair
  182.      * 
  183.      * @param adblVariatePair The Pair of the Ornstein Uhlenbeck Random Variates
  184.      * @param adblDiffusionPair The Pair of Diffusion Realizations
  185.      * @param dblTimeIncrement The Time Increment Evolution Unit
  186.      * 
  187.      * @return The Adjacent JumpDiffusionEdge Increment Array
  188.      */

  190.     public org.drip.measure.realization.JumpDiffusionEdge[] increment (
  191.         final double[] adblVariatePair,
  192.         final double[] adblDiffusionPair,
  193.         final double dblTimeIncrement)
  194.     {
  195.         if (null == adblVariatePair || 2 != adblVariatePair.length ||
  196.             !org.drip.numerical.common.NumberUtil.IsValid (adblVariatePair) || null == adblDiffusionPair || 2 !=
  197.                 adblDiffusionPair.length || !org.drip.numerical.common.NumberUtil.IsValid (adblDiffusionPair) ||
  198.                     !org.drip.numerical.common.NumberUtil.IsValid (dblTimeIncrement) || 0. >= dblTimeIncrement)
  199.             return null;

  201.         double dblRelaxationTime0 = _deouReference.relaxationTime();

  203.         double dblRelaxationTime1 = _deouDerived.relaxationTime();

  205.         try {
  206.             return new org.drip.measure.realization.JumpDiffusionEdge[] {
  207.                 org.drip.measure.realization.JumpDiffusionEdge.Standard (
  208.                     adblVariatePair[0],
  209.                     -1. * adblVariatePair[0] / dblRelaxationTime0 * dblTimeIncrement,
  210.                     _deouReference.burstiness() * adblDiffusionPair[0] * java.lang.Math.sqrt (dblTimeIncrement / dblRelaxationTime0),
  211.                     null,
  212.                     new org.drip.measure.realization.JumpDiffusionEdgeUnit (
  213.                         dblTimeIncrement,
  214.                         adblDiffusionPair[0],
  215.                         0.
  216.                     )
  217.                 ),
  218.                 org.drip.measure.realization.JumpDiffusionEdge.Standard (
  219.                     adblVariatePair[1],
  220.                     -1. * adblVariatePair[1] / dblRelaxationTime1 * dblTimeIncrement,
  221.                     _deouDerived.burstiness() * adblDiffusionPair[1] * java.lang.Math.sqrt (dblTimeIncrement / dblRelaxationTime1),
  222.                     null,
  223.                     new org.drip.measure.realization.JumpDiffusionEdgeUnit (
  224.                         dblTimeIncrement,
  225.                         adblDiffusionPair[1],
  226.                         0.
  227.                     )
  228.                 )
  229.             };
  230.         } catch (java.lang.Exception e) {
  231.             e.printStackTrace();
  232.         }

  234.         return null;
  235.     }

  237.     /**
  238.      * Generate the Weiner Based JumpDiffusionEdge Increment Sequence from the Current Ornstein Uhlenbeck
  239.      *      Random Variate
  240.      * 
  241.      * @param adblVariatePair The Ornstein Uhlenbeck Random Variate Pair
  242.      * @param dblTimeIncrement The Time Increment
  243.      * 
  244.      * @return The Weiner Based JumpDiffusionEdge Increment Sequence from the Current Ornstein Uhlenbeck
  245.      *      Random Variate
  246.      */

  248.     public org.drip.measure.realization.JumpDiffusionEdge[] weinerIncrement (
  249.         final double[] adblVariatePair,
  250.         final double dblTimeIncrement)
  251.     {
  252.         try {
  253.             double dblFirstWeiner = org.drip.measure.gaussian.NormalQuadrature.Random();

  255.             return increment (adblVariatePair, new double[] {dblFirstWeiner, dblFirstWeiner * _dblCorrelation
  256.                 + org.drip.measure.gaussian.NormalQuadrature.Random() * java.lang.Math.sqrt (1. -
  257.                     _dblCorrelation * _dblCorrelation)}, dblTimeIncrement);
  258.         } catch (java.lang.Exception e) {
  259.             e.printStackTrace();
  260.         }

  262.         return null;
  263.     }

  265.     @Override public double referenceRelaxationTime()
  266.     {
  267.         return _deouReference.relaxationTime();
  268.     }

  270.     @Override public double referenceBurstiness()
  271.     {
  272.         return _deouReference.burstiness();
  273.     }

  275.     @Override public double referenceMeanReversionLevel()
  276.     {
  277.         return _deouReference.meanReversionLevel();
  278.     }
  279. }
Created with JaCoCo 0.7.9.201702052155