OrnsteinUhlenbeckSequence.java

  1. package org.drip.execution.latent;

  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>OrnsteinUhlenbeckSequence</i> holds the Sequence of the Market State that drives the Liquidity and the
  82.  * Volatility Market States driven using an Ornstein-Uhlenbeck Process. 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/ProductCore.md">Product Core Module</a></li>
  111.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/TransactionCostAnalyticsLibrary.md">Transaction Cost Analytics</a></li>
  112.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/execution/README.md">Optimal Impact/Capture Based Trading Trajectories - Deterministic, Stochastic, Static, and Dynamic</a></li>
  113.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/execution/latent/README.md">Correlated Latent Market State Sequence</a></li>
  114.  *  </ul>
  115.  * 
  116.  * @author Lakshmi Krishnamurthy
  117.  */

  119. public class OrnsteinUhlenbeckSequence {
  120.     private int _iCount = 0;
  121.     private org.drip.execution.latent.MarketState[] _aMS = null;
  122.     private double _dblGenerationInterval = java.lang.Double.NaN;
  123.     private org.drip.measure.process.OrnsteinUhlenbeck _ou = null;

  125.     /**
  126.      * Construct a Standard Systemic Instance of OrnsteinUhlenbeckSequence
  127.      * 
  128.      * @param deou The 1D Ornstein-Uhlenbeck Generator Scheme
  129.      * @param dblGenerationInterval The Generation Interval
  130.      * @param dblInitialMarketState The Initial Market State
  131.      * @param iCount Count of the Number of States to be generated
  132.      * 
  133.      * @return The OrnsteinUhlenbeckSequence Instance
  134.      */

  136.     public static final OrnsteinUhlenbeckSequence Systemic (
  137.         final org.drip.measure.dynamics.DiffusionEvaluatorOrnsteinUhlenbeck deou,
  138.         final double dblGenerationInterval,
  139.         final double dblInitialMarketState,
  140.         final int iCount)
  141.     {
  142.         if (null == deou || !org.drip.numerical.common.NumberUtil.IsValid (dblGenerationInterval) || 0 >=
  143.             dblGenerationInterval || 1 >= iCount)
  144.             return null;

  146.         double dblTime = 0.;
  147.         org.drip.execution.latent.MarketStateSystemic[] aMSS = new
  148.             org.drip.execution.latent.MarketStateSystemic[iCount];

  150.         try {
  151.             aMSS[0] = new org.drip.execution.latent.MarketStateSystemic (dblInitialMarketState);

  153.             org.drip.measure.process.DiffusionEvolver de = new org.drip.measure.process.DiffusionEvolver
  154.                 (deou);

  156.             for (int i = 0; i < iCount - 1; ++i) {
  157.                 org.drip.measure.realization.JumpDiffusionEdge gi = de.weinerIncrement (new
  158.                     org.drip.measure.realization.JumpDiffusionVertex (dblTime, aMSS[i].common(), 0., false),
  159.                         dblGenerationInterval);

  161.                 aMSS[i + 1] = new org.drip.execution.latent.MarketStateSystemic (aMSS[i].common() +
  162.                     gi.deterministic() + gi.diffusionStochastic());

  164.                 dblTime += dblGenerationInterval;
  165.             }
  166.         } catch (java.lang.Exception e) {
  167.             e.printStackTrace();

  169.             return null;
  170.         }

  172.         return new OrnsteinUhlenbeckSequence (deou, aMSS, dblGenerationInterval);
  173.     }

  175.     /**
  176.      * Construct a Standard Correlated Instance of OrnsteinUhlenbeckSequence
  177.      * 
  178.      * @param oup2D The 2D Ornstein-Uhlenbeck Generator Scheme
  179.      * @param dblGenerationInterval The Generation Interval
  180.      * @param dblInitialLiquidityMarketState The Initial Liquidity Market State
  181.      * @param dblInitialVolatilityMarketState The Initial Volatility Market State
  182.      * @param iCount Count of the Number of States to be generated
  183.      * 
  184.      * @return The OrnsteinUhlenbeckSequence Instance
  185.      */

  187.     public static final OrnsteinUhlenbeckSequence Correlated (
  188.         final org.drip.measure.process.OrnsteinUhlenbeckPair oup2D,
  189.         final double dblGenerationInterval,
  190.         final double dblInitialLiquidityMarketState,
  191.         final double dblInitialVolatilityMarketState,
  192.         final int iCount)
  193.     {
  194.         if (null == oup2D || !org.drip.numerical.common.NumberUtil.IsValid (dblGenerationInterval) || 0 >=
  195.             dblGenerationInterval || 1 >= iCount)
  196.             return null;

  198.         org.drip.execution.latent.MarketStateCorrelated[] aMSC = new
  199.             org.drip.execution.latent.MarketStateCorrelated[iCount];

  201.         try {
  202.             aMSC[0] = new org.drip.execution.latent.MarketStateCorrelated (dblInitialLiquidityMarketState,
  203.                 dblInitialVolatilityMarketState);

  205.             for (int i = 0; i < iCount - 1; ++i) {
  206.                 org.drip.measure.realization.JumpDiffusionEdge[] aGI = oup2D.weinerIncrement
  207.                     (aMSC[i].realization(), dblGenerationInterval);

  209.                 if (null == aGI || 2 != aGI.length) return null;

  211.                 aMSC[i + 1] = new org.drip.execution.latent.MarketStateCorrelated (aMSC[i].liquidity() +
  212.                     aGI[0].deterministic() + aGI[0].diffusionStochastic(), aMSC[i].volatility() +
  213.                         aGI[1].deterministic() + aGI[1].diffusionStochastic());
  214.             }
  215.         } catch (java.lang.Exception e) {
  216.             e.printStackTrace();

  218.             return null;
  219.         }

  221.         return new OrnsteinUhlenbeckSequence (oup2D, aMSC, dblGenerationInterval);
  222.     }

  224.     private OrnsteinUhlenbeckSequence (
  225.         final org.drip.measure.process.OrnsteinUhlenbeck ou,
  226.         final org.drip.execution.latent.MarketState[] aMS,
  227.         final double dblGenerationInterval)
  228.     {
  229.         _ou = ou;
  230.         _aMS = aMS;
  231.         _iCount = aMS.length;
  232.         _dblGenerationInterval = dblGenerationInterval;
  233.     }

  235.     /**
  236.      * Retrieve the Total Count of States realized
  237.      * 
  238.      * @return The Total Count of States realized
  239.      */

  241.     public int count()
  242.     {
  243.         return _iCount;
  244.     }

  246.     /**
  247.      * Retrieve the Generation Interval
  248.      * 
  249.      * @return The Generation Interval
  250.      */

  252.     public double generationInterval()
  253.     {
  254.         return _dblGenerationInterval;
  255.     }

  257.     /**
  258.      * Retrieve the Sequence of Market State Realization
  259.      * 
  260.      * @return The Sequence of Market State Realization
  261.      */

  263.     public org.drip.execution.latent.MarketState[] realizedMarketState()
  264.     {
  265.         return _aMS;
  266.     }

  268.     /**
  269.      * Retrieve the Ornstein-Uhlenbeck Generator Scheme Parameters
  270.      * 
  271.      * @return The Ornstein-Uhlenbeck Generator Scheme Parameters
  272.      */

  274.     public org.drip.measure.process.OrnsteinUhlenbeck scheme()
  275.     {
  276.         return _ou;
  277.     }

  279.     /**
  280.      * Retrieve the Initial Market State
  281.      * 
  282.      * @return The Initial Market State
  283.      */

  285.     public org.drip.execution.latent.MarketState initialMarketState()
  286.     {
  287.         return _aMS[0];
  288.     }
  289. }
Created with JaCoCo 0.7.9.201702052155