Slice.java

  1. package org.drip.execution.discrete;

  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>Slice</i> implements the Arithmetic Dynamics of the Price/Cost Movements exhibited by an Asset owing to
  82.  * the Volatility and the Market Impact Factors on a Trajectory Slice. 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/discrete/README.md">Trajectory Slice Execution Cost Distribution</a></li>
  114.  *  </ul>
  115.  * 
  116.  * @author Lakshmi Krishnamurthy
  117.  */

  119. public class Slice implements org.drip.execution.sensitivity.ControlNodesGreekGenerator {
  120.     private double _dblTimeInterval = java.lang.Double.NaN;
  121.     private double _dblLeftHoldings = java.lang.Double.NaN;
  122.     private double _dblRightHoldings = java.lang.Double.NaN;

  124.     /**
  125.      * Slice Constructor
  126.      * 
  127.      * @param dblLeftHoldings The Left-of-Slice Holdings
  128.      * @param dblRightHoldings The Right-of-Slice Holdings
  129.      * @param dblTimeInterval The Discrete Time Interval
  130.      * 
  131.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  132.      */

  134.     public Slice (
  135.         final double dblLeftHoldings,
  136.         final double dblRightHoldings,
  137.         final double dblTimeInterval)
  138.         throws java.lang.Exception
  139.     {
  140.         if (!org.drip.numerical.common.NumberUtil.IsValid (_dblLeftHoldings = dblLeftHoldings) ||
  141.             !org.drip.numerical.common.NumberUtil.IsValid (_dblRightHoldings = dblRightHoldings) ||
  142.                 !org.drip.numerical.common.NumberUtil.IsValid (_dblTimeInterval = dblTimeInterval) || 0. >=
  143.                     _dblTimeInterval)
  144.             throw new java.lang.Exception ("Slice Constructor => Invalid Inputs!");
  145.     }

  147.     /**
  148.      * Retrieve the Left-of-Slice Holdings
  149.      * 
  150.      * @return The Left-of-Slice Holdings
  151.      */

  153.     public double leftHoldings()
  154.     {
  155.         return _dblLeftHoldings;
  156.     }

  158.     /**
  159.      * Retrieve the Right Holdings
  160.      * 
  161.      * @return The Right Holdings
  162.      */

  164.     public double rightHoldings()
  165.     {
  166.         return _dblRightHoldings;
  167.     }

  169.     /**
  170.      * Retrieve the Evolution Time Interval of the Arithmetic Dynamics
  171.      * 
  172.      * @return The Evolution Time Interval of the Arithmetic Dynamics
  173.      */

  175.     public double timeInterval()
  176.     {
  177.         return _dblTimeInterval;
  178.     }

  180.     /**
  181.      * Indicate if the Slice is a Sell
  182.      * 
  183.      * @return TRUE - The Slice is a Sell
  184.      */

  186.     public boolean isSell()
  187.     {
  188.         return _dblLeftHoldings - _dblRightHoldings > 0.;
  189.     }

  191.     /**
  192.      * Generate the Price Evolution Increment Unit Realization given the Walk Realization
  193.      * 
  194.      * @param dblPreviousEquilibriumPrice The Previous Equilibrium Price
  195.      * @param ws Realized Walk Suite
  196.      * @param apep The Arithmetic Price Walk Evolution Parameters
  197.      * 
  198.      * @return The Realized Price Evolution Increment Unit given the Walk Realization
  199.      */

  201.     public org.drip.execution.discrete.PriceIncrement priceIncrementRealization (
  202.         final double dblPreviousEquilibriumPrice,
  203.         final org.drip.execution.dynamics.WalkSuite ws,
  204.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  205.     {
  206.         if (null == ws || null == apep) return null;

  208.         org.drip.execution.parameters.ArithmeticPriceDynamicsSettings apds =
  209.             apep.arithmeticPriceDynamicsSettings();

  211.         double dblSerialCorrelation = apds.serialCorrelation();

  213.         double dblTimeUnitSQRT = java.lang.Math.sqrt (_dblTimeInterval);

  215.         double dblExecutionRate = (_dblRightHoldings - _dblLeftHoldings) / _dblTimeInterval;

  217.         try {
  218.             double dblMarketCoreJumpUnit = apds.epochVolatility() * dblTimeUnitSQRT;

  220.             return new org.drip.execution.discrete.PriceIncrement (
  221.                 dblPreviousEquilibriumPrice,
  222.                 new org.drip.execution.evolution.MarketImpactComponent (
  223.                     _dblTimeInterval * apds.drift(),
  224.                     0.,
  225.                     _dblTimeInterval * apep.permanentExpectation().epochImpactFunction().evaluate (dblExecutionRate),
  226.                     apep.temporaryExpectation().epochImpactFunction().evaluate (dblExecutionRate)
  227.                 ),
  228.                 new org.drip.execution.evolution.MarketImpactComponent (
  229.                     dblMarketCoreJumpUnit * java.lang.Math.sqrt (1. + dblSerialCorrelation * dblSerialCorrelation) *
  230.                         ws.currentWanderer(),
  231.                     dblMarketCoreJumpUnit * dblSerialCorrelation * ws.previousWanderer(),
  232.                     dblTimeUnitSQRT * apep.permanentVolatility().epochImpactFunction().evaluate (dblExecutionRate) *
  233.                         ws.permanentImpactWanderer(),
  234.                     dblTimeUnitSQRT * apep.temporaryVolatility().epochImpactFunction().evaluate (dblExecutionRate) *
  235.                         ws.temporaryImpactWanderer()
  236.                 )
  237.             );
  238.         } catch (java.lang.Exception e) {
  239.             e.printStackTrace();
  240.         }

  242.         return null;
  243.     }

  245.     /**
  246.      * Generate the Cost Evolution Increment Unit Realization given the Walk Realization
  247.      * 
  248.      * @param dblPreviousEquilibriumPrice The Previous Equilibrium Price
  249.      * @param ws Realized Walk Suite
  250.      * @param apep The Arithmetic Price Walk Evolution Parameters
  251.      * 
  252.      * @return The Cost Evolution Increment Unit Realization given the Walk Realization
  253.      */

  255.     public org.drip.execution.discrete.ShortfallIncrement costIncrementRealization (
  256.         final double dblPreviousEquilibriumPrice,
  257.         final org.drip.execution.dynamics.WalkSuite ws,
  258.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  259.     {
  260.         return org.drip.execution.discrete.ShortfallIncrement.Standard (
  261.             priceIncrementRealization (dblPreviousEquilibriumPrice, ws, apep),
  262.             _dblLeftHoldings,
  263.             _dblRightHoldings - _dblLeftHoldings
  264.         );
  265.     }

  267.     /**
  268.      * Generate the R^1 Normal Cost Increment Distribution
  269.      * 
  270.      * @param apep The Arithmetic Price Walk Evolution Parameters
  271.      * 
  272.      * @return The R^1 Normal Cost Increment Distribution
  273.      */

  275.     public org.drip.execution.discrete.ShortfallIncrementDistribution costIncrementDistribution (
  276.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  277.     {
  278.         double dblTradeAmount = _dblRightHoldings > _dblLeftHoldings ? _dblRightHoldings - _dblLeftHoldings :
  279.             _dblLeftHoldings - _dblRightHoldings;
  280.         double dblExecutionRate = dblTradeAmount / _dblTimeInterval;

  282.         org.drip.execution.parameters.ArithmeticPriceDynamicsSettings apds =
  283.             apep.arithmeticPriceDynamicsSettings();

  285.         try {
  286.             double dblMarketCoreVolatility = apds.epochVolatility();

  288.             double dblTemporaryVolatility = apep.temporaryVolatility().epochImpactFunction().evaluate
  289.                 (dblTradeAmount, _dblTimeInterval);

  291.             return new org.drip.execution.discrete.ShortfallIncrementDistribution (
  292.                 _dblTimeInterval * _dblRightHoldings * apep.permanentExpectation().epochImpactFunction().evaluate
  293.                     (dblExecutionRate),
  294.                 dblTradeAmount * apep.temporaryExpectation().epochImpactFunction().evaluate (dblExecutionRate),
  295.                 -1. * _dblRightHoldings * apds.drift() * _dblTimeInterval,
  296.                 0.,
  297.                 dblExecutionRate * dblExecutionRate * dblTemporaryVolatility * dblTemporaryVolatility *
  298.                     _dblTimeInterval,
  299.                 _dblRightHoldings * _dblRightHoldings * dblMarketCoreVolatility * dblMarketCoreVolatility *
  300.                     _dblTimeInterval
  301.             );
  302.         } catch (java.lang.Exception e) {
  303.             e.printStackTrace();
  304.         }

  306.         return null;
  307.     }

  309.     @Override public org.drip.execution.sensitivity.ControlNodesGreek permanentImpactExpectation (
  310.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  311.     {
  312.         if (null == apep) return null;

  314.         double dblTradeAmount = _dblRightHoldings - _dblLeftHoldings;
  315.         double dblSign = _dblRightHoldings < _dblLeftHoldings ? -1. : 1.;

  317.         org.drip.execution.impact.TransactionFunction tfPermanentDrift =
  318.             apep.permanentExpectation().epochImpactFunction();

  320.         try {
  321.             double dblPermanentDrift = tfPermanentDrift.evaluate (dblTradeAmount, _dblTimeInterval);

  323.             double dblPermanentDriftLeftJacobian = tfPermanentDrift.leftHoldingsDerivative (dblTradeAmount,
  324.                 _dblTimeInterval, 1);

  326.             double dblPermanentDriftRightJacobian = tfPermanentDrift.rightHoldingsDerivative (dblTradeAmount,
  327.                 _dblTimeInterval, 1);

  329.             double dblPermanentDriftLeftHessian = tfPermanentDrift.leftHoldingsDerivative (dblTradeAmount,
  330.                 _dblTimeInterval, 2);

  332.             double dblPermanentDriftRightHessian = tfPermanentDrift.rightHoldingsDerivative (dblTradeAmount,
  333.                 _dblTimeInterval, 2);

  335.             double dblPermanentDriftCrossHessian = tfPermanentDrift.crossHoldingsDerivative (dblTradeAmount,
  336.                 _dblTimeInterval);

  338.             double dblPermanentDriftImpact = dblSign * _dblTimeInterval * _dblRightHoldings *
  339.                 dblPermanentDrift;
  340.             double dblPermanentDriftImpactLeftJacobian = dblSign * _dblTimeInterval * _dblRightHoldings *
  341.                 dblPermanentDriftLeftJacobian;
  342.             double dblPermanentDriftImpactRightJacobian = dblSign * _dblTimeInterval * _dblRightHoldings *
  343.                 dblPermanentDriftRightJacobian + dblSign * _dblTimeInterval * dblPermanentDrift;
  344.             double dblPermanentDriftImpactLeftHessian = dblSign * _dblTimeInterval * _dblRightHoldings *
  345.                 dblPermanentDriftLeftHessian;
  346.             double dblPermanentDriftImpactRightHessian = dblSign * _dblTimeInterval * _dblRightHoldings *
  347.                 dblPermanentDriftRightHessian + 2. *  dblSign * _dblTimeInterval *
  348.                     dblPermanentDriftRightJacobian;
  349.             double dblPermanentDriftImpactCrossHessian = dblSign * _dblTimeInterval *
  350.                 dblPermanentDriftLeftJacobian + dblSign * _dblTimeInterval * _dblRightHoldings *
  351.                     dblPermanentDriftCrossHessian;

  353.             return new org.drip.execution.sensitivity.ControlNodesGreek (
  354.                 dblPermanentDriftImpact,
  355.                 new double[] {
  356.                     dblPermanentDriftImpactLeftJacobian,
  357.                     dblPermanentDriftImpactRightJacobian
  358.                 },
  359.                 new double[][] {
  360.                     {dblPermanentDriftImpactLeftHessian, dblPermanentDriftImpactCrossHessian},
  361.                     {dblPermanentDriftImpactCrossHessian, dblPermanentDriftImpactRightHessian}
  362.                 }
  363.             );
  364.         } catch (java.lang.Exception e) {
  365.             e.printStackTrace();
  366.         }

  368.         return null;
  369.     }

  371.     @Override public org.drip.execution.sensitivity.ControlNodesGreek permanentImpactVariance (
  372.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  373.     {
  374.         try {
  375.             return new org.drip.execution.sensitivity.ControlNodesGreek (0., new double[] {0., 0.}, new
  376.                 double[][] {{0., 0.}, {0., 0.}});
  377.         } catch (java.lang.Exception e) {
  378.             e.printStackTrace();
  379.         }

  381.         return null;
  382.     }

  384.     @Override public org.drip.execution.sensitivity.ControlNodesGreek temporaryImpactExpectation (
  385.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  386.     {
  387.         if (null == apep) return null;

  389.         double dblTradeAmount = _dblRightHoldings - _dblLeftHoldings;

  391.         org.drip.execution.impact.TransactionFunction tfTemporaryDrift =
  392.             apep.temporaryExpectation().epochImpactFunction();

  394.         try {
  395.             double dblTemporaryDrift = tfTemporaryDrift.evaluate (dblTradeAmount, _dblTimeInterval);

  397.             double dblTemporaryDriftLeftJacobian = tfTemporaryDrift.leftHoldingsDerivative (dblTradeAmount,
  398.                 _dblTimeInterval, 1);

  400.             double dblTemporaryDriftRightJacobian = tfTemporaryDrift.rightHoldingsDerivative
  401.                 (dblTradeAmount, _dblTimeInterval, 1);

  403.             double dblTemporaryDriftLeftHessian = tfTemporaryDrift.leftHoldingsDerivative (dblTradeAmount,
  404.                 _dblTimeInterval, 2);

  406.             double dblTemporaryDriftRightHessian = tfTemporaryDrift.rightHoldingsDerivative (dblTradeAmount,
  407.                 _dblTimeInterval, 2);

  409.             double dblTemporaryDriftCrossHessian = tfTemporaryDrift.crossHoldingsDerivative (dblTradeAmount,
  410.                 _dblTimeInterval);

  412.             double dblTemporaryDriftImpact = dblTradeAmount * dblTemporaryDrift;

  414.             double dblTemporaryDriftImpactLeftJacobian = -1. * dblTemporaryDrift + dblTradeAmount *
  415.                 dblTemporaryDriftLeftJacobian;
  416.             double dblTemporaryDriftImpactRightJacobian = dblTemporaryDrift + dblTradeAmount *
  417.                 dblTemporaryDriftRightJacobian;
  418.             double dblTemporaryDriftImpactLeftHessian = -2. * dblTemporaryDriftLeftJacobian + dblTradeAmount
  419.                 * dblTemporaryDriftLeftHessian;
  420.             double dblTemporaryDriftImpactRightHessian = 2. * dblTemporaryDriftRightJacobian + dblTradeAmount
  421.                 * dblTemporaryDriftRightHessian;
  422.             double dblTemporaryDriftImpactCrossHessian = -1. * dblTemporaryDriftRightJacobian +
  423.                 dblTemporaryDriftLeftJacobian + dblTradeAmount * dblTemporaryDriftCrossHessian;

  425.             return new org.drip.execution.sensitivity.ControlNodesGreek (
  426.                 dblTemporaryDriftImpact,
  427.                 new double[] {
  428.                     dblTemporaryDriftImpactLeftJacobian,
  429.                     dblTemporaryDriftImpactRightJacobian
  430.                 },
  431.                 new double[][] {
  432.                     {dblTemporaryDriftImpactLeftHessian, dblTemporaryDriftImpactCrossHessian},
  433.                     {dblTemporaryDriftImpactCrossHessian, dblTemporaryDriftImpactRightHessian}
  434.                 }
  435.             );
  436.         } catch (java.lang.Exception e) {
  437.             e.printStackTrace();
  438.         }

  440.         return null;
  441.     }

  443.     @Override public org.drip.execution.sensitivity.ControlNodesGreek temporaryImpactVariance (
  444.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  445.     {
  446.         if (null == apep) return null;

  448.         double dblTradeAmount = _dblRightHoldings - _dblLeftHoldings;
  449.         double dblTradeAmountSquared = dblTradeAmount * dblTradeAmount;

  451.         org.drip.execution.impact.TransactionFunction tfTemporaryVolatility =
  452.             apep.temporaryVolatility().epochImpactFunction();

  454.         try {
  455.             if (null == tfTemporaryVolatility)
  456.                 return new org.drip.execution.sensitivity.ControlNodesGreek (0., new double[] {0., 0.}, new
  457.                     double[][] {{0., 0.}, {0., 0.}});

  459.             double dblTemporaryVolatility = tfTemporaryVolatility.evaluate (dblTradeAmount,
  460.                 _dblTimeInterval);

  462.             double dblTemporaryVolatilityLeftJacobian = tfTemporaryVolatility.leftHoldingsDerivative
  463.                 (dblTradeAmount, _dblTimeInterval, 1);

  465.             double dblTemporaryVolatilityRightJacobian = tfTemporaryVolatility.rightHoldingsDerivative
  466.                 (dblTradeAmount, _dblTimeInterval, 1);

  468.             double dblTemporaryVolatilityLeftHessian = tfTemporaryVolatility.leftHoldingsDerivative
  469.                 (dblTradeAmount, _dblTimeInterval, 2);

  471.             double dblTemporaryVolatilityRightHessian = tfTemporaryVolatility.rightHoldingsDerivative
  472.                 (dblTradeAmount, _dblTimeInterval, 2);

  474.             double dblTemporaryVolatilityCrossHessian = tfTemporaryVolatility.crossHoldingsDerivative
  475.                 (dblTradeAmount, _dblTimeInterval);

  477.             double dblTemporaryVolatilitySquared = dblTemporaryVolatility * dblTemporaryVolatility;

  479.             double dblTemporaryVarianceCrossHessian =
  480.                 2. * dblTradeAmountSquared * dblTemporaryVolatilityLeftJacobian * dblTemporaryVolatilityRightJacobian * _dblTimeInterval
  481.                     + 2. * dblTradeAmountSquared * dblTemporaryVolatility * dblTemporaryVolatilityCrossHessian * _dblTimeInterval
  482.                         + 4. * dblTradeAmount * dblTemporaryVolatility * dblTemporaryVolatilityLeftJacobian * _dblTimeInterval
  483.                             - 4. * dblTradeAmount * dblTemporaryVolatility * dblTemporaryVolatilityRightJacobian * _dblTimeInterval
  484.                                 - 2. * dblTemporaryVolatilitySquared * _dblTimeInterval;

  486.             return new org.drip.execution.sensitivity.ControlNodesGreek (
  487.                 dblTradeAmountSquared * dblTemporaryVolatilitySquared * _dblTimeInterval,
  488.                 new double[] {
  489.                     2. * dblTradeAmountSquared * dblTemporaryVolatility * dblTemporaryVolatilityLeftJacobian * _dblTimeInterval
  490.                         - 2. * dblTradeAmount * dblTemporaryVolatilitySquared * _dblTimeInterval,
  491.                     2. * dblTradeAmountSquared * dblTemporaryVolatility * dblTemporaryVolatilityRightJacobian * _dblTimeInterval
  492.                         + 2. * dblTradeAmount * dblTemporaryVolatilitySquared * _dblTimeInterval
  493.                 },
  494.                 new double[][] {
  495.                     {
  496.                         2. * dblTradeAmountSquared * dblTemporaryVolatilityLeftJacobian * dblTemporaryVolatilityLeftJacobian * _dblTimeInterval
  497.                             + 2. * dblTradeAmountSquared * dblTemporaryVolatility * dblTemporaryVolatilityLeftHessian * _dblTimeInterval
  498.                                 - 8. * dblTradeAmount * dblTemporaryVolatility * dblTemporaryVolatilityLeftJacobian * _dblTimeInterval
  499.                                     + 2. * dblTemporaryVolatilitySquared * _dblTimeInterval,
  500.                         dblTemporaryVarianceCrossHessian
  501.                     }, {
  502.                         dblTemporaryVarianceCrossHessian,
  503.                         2. * dblTradeAmountSquared * dblTemporaryVolatilityRightJacobian * dblTemporaryVolatilityRightJacobian * _dblTimeInterval
  504.                             + 2. * dblTradeAmountSquared * dblTemporaryVolatility * dblTemporaryVolatilityRightHessian * _dblTimeInterval
  505.                                 + 8. * dblTradeAmount * dblTemporaryVolatility * dblTemporaryVolatilityRightJacobian * _dblTimeInterval
  506.                                     + 2. * dblTemporaryVolatilitySquared * _dblTimeInterval
  507.                     }
  508.                 }
  509.             );
  510.         } catch (java.lang.Exception e) {
  511.             e.printStackTrace();
  512.         }

  514.         return null;
  515.     }

  517.     @Override public org.drip.execution.sensitivity.ControlNodesGreek marketDynamicsExpectation (
  518.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  519.     {
  520.         if (null == apep) return null;

  522.         double dblDrift = apep.arithmeticPriceDynamicsSettings().drift();

  524.         try {
  525.             return new org.drip.execution.sensitivity.ControlNodesGreek (
  526.                 -1. * _dblTimeInterval * dblDrift * _dblRightHoldings,
  527.                 new double[] {
  528.                     0.,
  529.                     -1. * _dblTimeInterval * dblDrift
  530.                 }, new
  531.                 double[][] {
  532.                     {0., 0.},
  533.                     {0., 0.}
  534.                 }
  535.             );
  536.         } catch (java.lang.Exception e) {
  537.             e.printStackTrace();
  538.         }

  540.         return null;
  541.     }

  543.     @Override public org.drip.execution.sensitivity.ControlNodesGreek marketDynamicsVariance (
  544.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  545.     {
  546.         if (null == apep) return null;

  548.         try {
  549.             double dblVolatility = apep.arithmeticPriceDynamicsSettings().epochVolatility();

  551.             return new org.drip.execution.sensitivity.ControlNodesGreek (
  552.                 _dblTimeInterval * dblVolatility * dblVolatility * _dblRightHoldings * _dblRightHoldings,
  553.                 new double[] {
  554.                     0.,
  555.                     2. * _dblTimeInterval * dblVolatility * dblVolatility * _dblRightHoldings
  556.                 }, new double[][] {
  557.                     {0., 0.},
  558.                     {0., 2. * _dblTimeInterval * dblVolatility * dblVolatility}
  559.                 }
  560.             );
  561.         } catch (java.lang.Exception e) {
  562.             e.printStackTrace();
  563.         }

  565.         return null;
  566.     }

  568.     @Override public org.drip.execution.sensitivity.ControlNodesGreek expectationContribution (
  569.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  570.     {
  571.         org.drip.execution.sensitivity.ControlNodesGreek cngPermanentImpact = permanentImpactExpectation
  572.             (apep);

  574.         if (null == cngPermanentImpact) return null;

  576.         org.drip.execution.sensitivity.ControlNodesGreek cngTemporaryImpact = temporaryImpactExpectation
  577.             (apep);

  579.         if (null == cngTemporaryImpact) return null;

  581.         org.drip.execution.sensitivity.ControlNodesGreek cngMarketCore = marketDynamicsExpectation (apep);

  583.         if (null == cngMarketCore) return null;

  585.         double[][] aadblPermanentImpactExpectationHessian = cngPermanentImpact.hessian();

  587.         double[][] aadblTemporaryImpactExpectationHessian = cngTemporaryImpact.hessian();

  589.         double[] adblPermanentImpactExpectationJacobian = cngPermanentImpact.jacobian();

  591.         double[] adblTemporaryImpactExpectationJacobian = cngTemporaryImpact.jacobian();

  593.         double[][] aadblMarketCoreExpectationHessian = cngMarketCore.hessian();

  595.         double[] adblMarketCoreExpectationJacobian = cngMarketCore.jacobian();

  597.         int iNumSliceNode = adblMarketCoreExpectationJacobian.length;
  598.         double[][] aadblHessian = new double[iNumSliceNode][iNumSliceNode];
  599.         double[] adblJacobian = new double[iNumSliceNode];

  601.         for (int i = 0; i < iNumSliceNode; ++i) {
  602.             adblJacobian[i] = adblPermanentImpactExpectationJacobian[i] +
  603.                 adblTemporaryImpactExpectationJacobian[i] + adblMarketCoreExpectationJacobian[i];

  605.             for (int j = 0; j < iNumSliceNode; ++j)
  606.                 aadblHessian[i][j] = aadblPermanentImpactExpectationHessian[i][j] +
  607.                     aadblTemporaryImpactExpectationHessian[i][j] + aadblMarketCoreExpectationHessian[i][j];
  608.         }

  610.         try {
  611.             return new org.drip.execution.sensitivity.ControlNodesGreek (cngPermanentImpact.value() +
  612.                 cngTemporaryImpact.value() + cngMarketCore.value(), adblJacobian, aadblHessian);
  613.         } catch (java.lang.Exception e) {
  614.             e.printStackTrace();
  615.         }

  617.         return null;
  618.     }

  620.     @Override public org.drip.execution.sensitivity.ControlNodesGreek varianceContribution (
  621.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  622.     {
  623.         org.drip.execution.sensitivity.ControlNodesGreek cngPermanentImpact = permanentImpactVariance (apep);

  625.         if (null == cngPermanentImpact) return null;

  627.         org.drip.execution.sensitivity.ControlNodesGreek cngTemporaryImpact = temporaryImpactVariance (apep);

  629.         if (null == cngTemporaryImpact) return null;

  631.         org.drip.execution.sensitivity.ControlNodesGreek cngMarketCore = marketDynamicsVariance (apep);

  633.         if (null == cngMarketCore) return null;

  635.         double[][] aadblPermanentImpactExpectationHessian = cngPermanentImpact.hessian();

  637.         double[][] aadblTemporaryImpactExpectationHessian = cngTemporaryImpact.hessian();

  639.         double[] adblPermanentImpactExpectationJacobian = cngPermanentImpact.jacobian();

  641.         double[] adblTemporaryImpactExpectationJacobian = cngTemporaryImpact.jacobian();

  643.         double[][] aadblMarketCoreExpectationHessian = cngMarketCore.hessian();

  645.         double[] adblMarketCoreExpectationJacobian = cngMarketCore.jacobian();

  647.         int iNumSliceNode = adblMarketCoreExpectationJacobian.length;
  648.         double[][] aadblHessian = new double[iNumSliceNode][iNumSliceNode];
  649.         double[] adblJacobian = new double[iNumSliceNode];

  651.         for (int i = 0; i < iNumSliceNode; ++i) {
  652.             adblJacobian[i] = adblPermanentImpactExpectationJacobian[i] +
  653.                 adblTemporaryImpactExpectationJacobian[i] + adblMarketCoreExpectationJacobian[i];

  655.             for (int j = 0; j < iNumSliceNode; ++j)
  656.                 aadblHessian[i][j] = aadblPermanentImpactExpectationHessian[i][j] +
  657.                     aadblTemporaryImpactExpectationHessian[i][j] + aadblMarketCoreExpectationHessian[i][j];
  658.         }

  660.         try {
  661.             return new org.drip.execution.sensitivity.ControlNodesGreek (cngPermanentImpact.value() +
  662.                 cngTemporaryImpact.value() + cngMarketCore.value(), adblJacobian, aadblHessian);
  663.         } catch (java.lang.Exception e) {
  664.             e.printStackTrace();
  665.         }

  667.         return null;
  668.     }

  670.     /**
  671.      * Estimate the Optimal Adjustment Attributable to the Serial Correlation
  672.      *  
  673.      * @param apep The Arithmetic Price Walk Parameters
  674.      * 
  675.      * @return The Optimal Adjustment Attributable to the Serial Correlation
  676.      */

  678.     public org.drip.execution.discrete.OptimalSerialCorrelationAdjustment serialCorrelationAdjustment (
  679.         final org.drip.execution.dynamics.ArithmeticPriceEvolutionParameters apep)
  680.     {
  681.         if (null == apep) return null;

  683.         org.drip.execution.parameters.ArithmeticPriceDynamicsSettings apds =
  684.             apep.arithmeticPriceDynamicsSettings();

  686.         double dblTradeRate = (_dblRightHoldings - _dblLeftHoldings) / _dblTimeInterval;

  688.         org.drip.execution.impact.TransactionFunction miTemporary =
  689.             apep.temporaryExpectation().epochImpactFunction();

  691.         try {
  692.             double dblRhoSigma = apds.serialCorrelation() * apds.epochVolatility();

  694.             double dblDenominator = 1. / (dblTradeRate * miTemporary.derivative (dblTradeRate, 2) + 2. *
  695.                 miTemporary.derivative (dblTradeRate, 1));

  697.             return new org.drip.execution.discrete.OptimalSerialCorrelationAdjustment (dblDenominator *
  698.                 dblRhoSigma * java.lang.Math.pow (_dblTimeInterval, 1.5), 0.5 * dblDenominator * dblRhoSigma
  699.                     * dblRhoSigma * _dblTimeInterval * _dblTimeInterval);
  700.         } catch (java.lang.Exception e) {
  701.             e.printStackTrace();
  702.         }

  704.         return null;
  705.     }
  706. }
Created with JaCoCo 0.7.9.201702052155