TrajectoryShortfallAggregate.java

  1. package org.drip.execution.capture;

  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>TrajectoryShortfallAggregate</i> aggregates the  Execution Short-fall Distribution across each Interval
  82.  * in the Trade. The References are:
  83.  * 
  84.  * <br><br>
  85.  *  <ul>
  86.  *      <li>
  87.  *          Almgren, R., and N. Chriss (1999): Value under Liquidation <i>Risk</i> <b>12 (12)</b>
  88.  *      </li>
  89.  *      <li>
  90.  *          Almgren, R., and N. Chriss (2000): Optimal Execution of Portfolio Transactions <i>Journal of
  91.  *              Risk</i> <b>3 (2)</b> 5-39
  92.  *      </li>
  93.  *      <li>
  94.  *          Bertsimas, D., and A. W. Lo (1998): Optimal Control of Execution Costs <i>Journal of Financial
  95.  *              Markets</i> <b>1</b> 1-50
  96.  *      </li>
  97.  *      <li>
  98.  *          Chan, L. K. C., and J. Lakonishak (1995): The Behavior of Stock Prices around Institutional
  99.  *              Trades <i>Journal of Finance</i> <b>50</b> 1147-1174
  100.  *      </li>
  101.  *      <li>
  102.  *          Keim, D. B., and A. Madhavan (1997): Transaction Costs and Investment Style: An Inter-exchange
  103.  *              Analysis of Institutional Equity Trades <i>Journal of Financial Economics</i> <b>46</b>
  104.  *              265-292
  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/capture/README.md">Execution Trajectory Transaction Cost Capture</a></li>
  114.  *  </ul>
  115.  * 
  116.  * @author Lakshmi Krishnamurthy
  117.  */

  119. public class TrajectoryShortfallAggregate {
  120.     private java.util.List<org.drip.execution.discrete.ShortfallIncrementDistribution> _lsSID = null;

  122.     /**
  123.      * TrajectoryShortfallAggregate Constructor
  124.      * 
  125.      * @param lsSID List of the Incremental Slice Short-fall Distributions
  126.      * 
  127.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  128.      */

  130.     public TrajectoryShortfallAggregate (
  131.         final java.util.List<org.drip.execution.discrete.ShortfallIncrementDistribution> lsSID)
  132.         throws java.lang.Exception
  133.     {
  134.         if (null == (_lsSID = lsSID))
  135.             throw new java.lang.Exception ("TrajectoryShortfallAggregate Constructor => Invalid Inputs");

  137.         int iNumInterval = _lsSID.size();

  139.         if (0 == iNumInterval)
  140.             throw new java.lang.Exception ("TrajectoryShortfallAggregate Constructor => Invalid Inputs");

  142.         for (org.drip.execution.discrete.ShortfallIncrementDistribution sid : _lsSID) {
  143.             if (null == sid)
  144.                 throw new java.lang.Exception ("TrajectoryShortfallAggregate Constructor => Invalid Inputs");
  145.         }
  146.     }

  148.     /**
  149.      * Retrieve the List of the Interval Cost Distributions
  150.      * 
  151.      * @return The List of the Interval Cost Distributions
  152.      */

  154.     public java.util.List<org.drip.execution.discrete.ShortfallIncrementDistribution> list()
  155.     {
  156.         return _lsSID;
  157.     }

  159.     /**
  160.      * Generate the Total Cost R^1 Normal Distribution
  161.      * 
  162.      * @return The Total Cost R^1 Normal Distribution
  163.      */

  165.     public org.drip.measure.gaussian.R1UnivariateNormal totalCostDistribution()
  166.     {
  167.         double dblTotalCostMean = 0.;
  168.         double dblTotalCostVariance = 0.;

  170.         for (org.drip.measure.gaussian.R1UnivariateNormal r1un : _lsSID) {
  171.             dblTotalCostMean = dblTotalCostMean + r1un.mean();

  173.             dblTotalCostVariance = dblTotalCostVariance + r1un.variance();
  174.         }

  176.         try {
  177.             return new org.drip.measure.gaussian.R1UnivariateNormal (dblTotalCostMean, java.lang.Math.sqrt
  178.                 (dblTotalCostVariance));
  179.         } catch (java.lang.Exception e) {
  180.             e.printStackTrace();
  181.         }

  183.         return null;
  184.     }

  186.     /**
  187.      * Generate the Array of Incremental Expectation Sequence
  188.      * 
  189.      * @return The Array of Incremental Expectation Sequence
  190.      */

  192.     public double[] incrementalExpectation()
  193.     {
  194.         int iNumInterval = _lsSID.size();

  196.         double[] adblIncrementalExpectationSequence = new double[iNumInterval];

  198.         for (int i = 0; i < iNumInterval; ++i)
  199.             adblIncrementalExpectationSequence[i] = _lsSID.get (i).mean();

  201.         return adblIncrementalExpectationSequence;
  202.     }

  204.     /**
  205.      * Generate the Array of Cumulative Expectation Sequence
  206.      * 
  207.      * @return The Array of Cumulative Expectation Sequence
  208.      */

  210.     public double[] cumulativeExpectation()
  211.     {
  212.         int iNumInterval = _lsSID.size();

  214.         double[] adblCumulativeExpectationSequence = new double[iNumInterval];

  216.         for (int i = 0; i < iNumInterval; ++i)
  217.             adblCumulativeExpectationSequence[i] = 0 == i ? _lsSID.get (i).expectation() :
  218.                 adblCumulativeExpectationSequence[i - 1] + _lsSID.get (i).expectation();

  220.         return adblCumulativeExpectationSequence;
  221.     }

  223.     /**
  224.      * Generate the Array of Incremental Variance Sequence
  225.      * 
  226.      * @return The Array of Incremental Variance Sequence
  227.      */

  229.     public double[] incrementalVariance()
  230.     {
  231.         int iNumInterval = _lsSID.size();

  233.         double[] adblIncrementalVarianceSequence = new double[iNumInterval];

  235.         for (int i = 0; i < iNumInterval; ++i)
  236.             adblIncrementalVarianceSequence[i] = _lsSID.get (i).variance();

  238.         return adblIncrementalVarianceSequence;
  239.     }

  241.     /**
  242.      * Generate the Array of Cumulative Variance Sequence
  243.      * 
  244.      * @return The Array of Cumulative Variance Sequence
  245.      */

  247.     public double[] cumulativeVariance()
  248.     {
  249.         int iNumInterval = _lsSID.size();

  251.         double[] adblCumulativeVarianceSequence = new double[iNumInterval];

  253.         for (int i = 0; i < iNumInterval; ++i)
  254.             adblCumulativeVarianceSequence[i] = 0 == i ? _lsSID.get (i).variance() :
  255.                 adblCumulativeVarianceSequence[i - 1] + _lsSID.get (i).variance();

  257.         return adblCumulativeVarianceSequence;
  258.     }

  260.     /**
  261.      * Generate the Array of Incremental Market Dynamic Expectation Sequence
  262.      * 
  263.      * @return The Array of Incremental Market Dynamic Expectation Sequence
  264.      */

  266.     public double[] incrementalMarketDynamicExpectation()
  267.     {
  268.         int iNumInterval = _lsSID.size();

  270.         double[] adblIncrementalMarketDynamicExpectationSequence = new double[iNumInterval];

  272.         for (int i = 0; i < iNumInterval; ++i)
  273.             adblIncrementalMarketDynamicExpectationSequence[i] = _lsSID.get (i).marketDynamicExpectation();

  275.         return adblIncrementalMarketDynamicExpectationSequence;
  276.     }

  278.     /**
  279.      * Generate the Array of Cumulative Market Dynamic Expectation Sequence
  280.      * 
  281.      * @return The Array of Cumulative Market Dynamic Expectation Sequence
  282.      */

  284.     public double[] cumulativeMarketDynamicExpectation()
  285.     {
  286.         int iNumInterval = _lsSID.size();

  288.         double[] adblCumulativeMarketDynamicExpectationSequence = new double[iNumInterval];

  290.         for (int i = 0; i < iNumInterval; ++i)
  291.             adblCumulativeMarketDynamicExpectationSequence[i] = 0 == i ? _lsSID.get
  292.                 (i).marketDynamicExpectation() : adblCumulativeMarketDynamicExpectationSequence[i - 1] +
  293.                     _lsSID.get (i).marketDynamicExpectation();

  295.         return adblCumulativeMarketDynamicExpectationSequence;
  296.     }

  298.     /**
  299.      * Generate the Array of Incremental Permanent Impact Expectation Sequence
  300.      * 
  301.      * @return The Array of Incremental Permanent Impact Expectation Sequence
  302.      */

  304.     public double[] incrementalPermanentImpactExpectation()
  305.     {
  306.         int iNumInterval = _lsSID.size();

  308.         double[] adblIncrementalPermanentImpactExpectationSequence = new double[iNumInterval];

  310.         for (int i = 0; i < iNumInterval; ++i)
  311.             adblIncrementalPermanentImpactExpectationSequence[i] = _lsSID.get
  312.                 (i).permanentImpactExpectation();

  314.         return adblIncrementalPermanentImpactExpectationSequence;
  315.     }

  317.     /**
  318.      * Generate the Array of Cumulative Permanent Impact Expectation Sequence
  319.      * 
  320.      * @return The Array of Cumulative Permanent Impact Expectation Sequence
  321.      */

  323.     public double[] cumulativePermanentImpactExpectation()
  324.     {
  325.         int iNumInterval = _lsSID.size();

  327.         double[] adblCumulativePermanentImpactExpectationSequence = new double[iNumInterval];

  329.         for (int i = 0; i < iNumInterval; ++i)
  330.             adblCumulativePermanentImpactExpectationSequence[i] = 0 == i ? _lsSID.get
  331.                 (i).permanentImpactExpectation() : adblCumulativePermanentImpactExpectationSequence[i - 1] +
  332.                     _lsSID.get (i).permanentImpactExpectation();

  334.         return adblCumulativePermanentImpactExpectationSequence;
  335.     }

  337.     /**
  338.      * Generate the Array of Incremental Temporary Impact Expectation Sequence
  339.      * 
  340.      * @return The Array of Incremental Temporary Impact Expectation Sequence
  341.      */

  343.     public double[] incrementalTemporaryImpactExpectation()
  344.     {
  345.         int iNumInterval = _lsSID.size();

  347.         double[] adblIncrementalTemporaryImpactExpectationSequence = new double[iNumInterval];

  349.         for (int i = 0; i < iNumInterval; ++i)
  350.             adblIncrementalTemporaryImpactExpectationSequence[i] = _lsSID.get
  351.                 (i).temporaryImpactExpectation();

  353.         return adblIncrementalTemporaryImpactExpectationSequence;
  354.     }

  356.     /**
  357.      * Generate the Array of Cumulative Temporary Impact Expectation Sequence
  358.      * 
  359.      * @return The Array of Cumulative Temporary Impact Expectation Sequence
  360.      */

  362.     public double[] cumulativeTemporaryImpactExpectation()
  363.     {
  364.         int iNumInterval = _lsSID.size();

  366.         double[] adblCumulativeTemporaryImpactExpectationSequence = new double[iNumInterval];

  368.         for (int i = 0; i < iNumInterval; ++i)
  369.             adblCumulativeTemporaryImpactExpectationSequence[i] = 0 == i ? _lsSID.get
  370.                 (i).temporaryImpactExpectation() : adblCumulativeTemporaryImpactExpectationSequence[i - 1] +
  371.                     _lsSID.get (i).temporaryImpactExpectation();

  373.         return adblCumulativeTemporaryImpactExpectationSequence;
  374.     }

  376.     /**
  377.      * Generate the Expected Short-fall
  378.      * 
  379.      * @return The Expected Short-fall
  380.      */

  382.     public double shortfallExpectation()
  383.     {
  384.         int iNumInterval = _lsSID.size();

  386.         double dblExpectedShortfall = 0.;

  388.         for (int i = 0; i < iNumInterval; ++i)
  389.             dblExpectedShortfall = dblExpectedShortfall + _lsSID.get (i).expectation();

  391.         return dblExpectedShortfall;
  392.     }

  394.     /**
  395.      * Generate the Short-fall Variance
  396.      * 
  397.      * @return The Short-fall Variance
  398.      */

  400.     public double shortfallVariance()
  401.     {
  402.         int iNumInterval = _lsSID.size();

  404.         double dblShortfallVariance = 0.;

  406.         for (int i = 0; i < iNumInterval; ++i)
  407.             dblShortfallVariance = dblShortfallVariance + _lsSID.get (i).variance();

  409.         return dblShortfallVariance;
  410.     }
  411. }
Created with JaCoCo 0.7.9.201702052155