CorrelatedPathVertexDimension.java

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

  79. /**
  80.  * <i>CorrelatedPathVertexDimension</i> generates Correlated R^d Random Numbers at the specified Vertexes,
  81.  * over the Specified Paths.
  82.  *
  83.  *  <br><br>
  84.  *  <ul>
  85.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  86.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/NumericalAnalysisLibrary.md">Numerical Analysis Library</a></li>
  87.  *      <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>
  88.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/discrete/README.md">Antithetic, Quadratically Re-sampled, De-biased Distribution</a></li>
  89.  *  </ul>
  90.  *
  91.  * @author Lakshmi Krishnamurthy
  92.  */

  94. public class CorrelatedPathVertexDimension {
  95.     private int _iNumPath = -1;
  96.     private int _iNumVertex = -1;
  97.     private double[][] _aadblCholesky = null;
  98.     private boolean _bApplyAntithetic = false;
  99.     private double[][] _aadblCorrelation = null;
  100.     private org.drip.measure.crng.RandomNumberGenerator _rng = null;
  101.     private org.drip.measure.discrete.QuadraticResampler _qr = null;

  103.     /**
  104.      * CorrelatedPathVertexDimension Constructor
  105.      * 
  106.      * @param rng The Random Number Generator
  107.      * @param aadblCorrelation The Correlation Matrix
  108.      * @param iNumVertex Number of Vertexes
  109.      * @param iNumPath Number of Paths
  110.      * @param bApplyAntithetic TRUE - Apply Antithetic Variables Based Variance Reduction
  111.      * @param qr Quadratic Resampler Instance
  112.      * 
  113.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  114.      */

  116.     public CorrelatedPathVertexDimension (
  117.         final org.drip.measure.crng.RandomNumberGenerator rng,
  118.         final double[][] aadblCorrelation,
  119.         final int iNumVertex,
  120.         final int iNumPath,
  121.         final boolean bApplyAntithetic,
  122.         final org.drip.measure.discrete.QuadraticResampler qr)
  123.         throws java.lang.Exception
  124.     {
  125.         if (null == (_rng = rng) || 0 >= (_iNumVertex = iNumVertex) || 0 >= (_iNumPath = iNumPath))
  126.             throw new java.lang.Exception ("CorrelatedPathVertexDimension Constructor => Invalid Inputs");

  128.         _qr = qr;
  129.         _bApplyAntithetic = bApplyAntithetic;

  131.         if (null == (_aadblCholesky = org.drip.numerical.linearalgebra.Matrix.CholeskyBanachiewiczFactorization
  132.             (_aadblCorrelation = aadblCorrelation)))
  133.             throw new java.lang.Exception ("CorrelatedPathVertexDimension Constructor => Invalid Inputs");
  134.     }

  136.     /**
  137.      * Retrieve the Random Number Generator
  138.      * 
  139.      * @return The Random Number Generator Instance
  140.      */

  142.     public org.drip.measure.crng.RandomNumberGenerator randomNumberGenerator()
  143.     {
  144.         return _rng;
  145.     }

  147.     /**
  148.      * Retrieve the Correlation Matrix
  149.      * 
  150.      * @return The Correlation Matrix
  151.      */

  153.     public double[][] correlation()
  154.     {
  155.         return _aadblCorrelation;
  156.     }

  158.     /**
  159.      * Retrieve the Cholesky Matrix
  160.      * 
  161.      * @return The Cholesky Matrix
  162.      */

  164.     public double[][] cholesky()
  165.     {
  166.         return _aadblCholesky;
  167.     }

  169.     /**
  170.      * Retrieve the Number of Vertexes
  171.      * 
  172.      * @return The Number of Vertexes
  173.      */

  175.     public int numVertex()
  176.     {
  177.         return _iNumVertex;
  178.     }

  180.     /**
  181.      * Retrieve the Number of Paths
  182.      * 
  183.      * @return The Number of Paths
  184.      */

  186.     public int numPath()
  187.     {
  188.         return _iNumPath;
  189.     }

  191.     /**
  192.      * Retrieve the Number of Dimensions
  193.      * 
  194.      * @return The Number of Dimensions
  195.      */

  197.     public int numDimension()
  198.     {
  199.         return _aadblCholesky.length;
  200.     }

  202.     /**
  203.      * Indicate if the Antithetic Variable Generation is to be applied
  204.      * 
  205.      * @return TRUE - Apply Antithetic Variables Based Variance Reduction
  206.      */

  208.     public boolean applyAntithetic()
  209.     {
  210.         return _bApplyAntithetic;
  211.     }

  213.     /**
  214.      * Retrieve the Quadratic Resampler Instance
  215.      * 
  216.      * @return The Quadratic Resampler Instance
  217.      */

  219.     public org.drip.measure.discrete.QuadraticResampler quadraticResampler()
  220.     {
  221.         return _qr;
  222.     }

  224.     /**
  225.      * Generate a Straight Single R^d Vertex Realization
  226.      * 
  227.      * @return Straight Single R^d Vertex Realization
  228.      */

  230.     public double[] straightVertexRealization()
  231.     {
  232.         int iDimension = _aadblCholesky.length;
  233.         double[] adblRdCorrelated = new double[iDimension];
  234.         double[] adblRdUncorrelated = new double[iDimension];

  236.         for (int i = 0; i < iDimension; ++i) {
  237.             try {
  238.                 adblRdUncorrelated[i] = org.drip.measure.gaussian.NormalQuadrature.InverseCDF
  239.                     (_rng.nextDouble01());
  240.             } catch (java.lang.Exception e) {
  241.                 e.printStackTrace();

  243.                 return null;
  244.             }
  245.         }

  247.         for (int i = 0; i < iDimension; ++i) {
  248.             adblRdCorrelated[i] = 0.;

  250.             for (int j = 0; j < iDimension; ++j)
  251.                 adblRdCorrelated[i] += _aadblCholesky[i][j] * adblRdUncorrelated[j];
  252.         }

  254.         return adblRdCorrelated;
  255.     }

  257.     /**
  258.      * Generate an Antithetic R^d Vertex Pair Realization
  259.      * 
  260.      * @return Antithetic R^d Vertex Pair Realization
  261.      */

  263.     public double[][] antitheticVertexPairRealization()
  264.     {
  265.         double[] adblStraightVertexRealization = straightVertexRealization();

  267.         int iDimension = _aadblCholesky.length;
  268.         double[] adblAntitheticVertexRealization = new double[iDimension];

  270.         for (int i = 0; i < iDimension; ++i)
  271.             adblAntitheticVertexRealization[i] = -1. * adblStraightVertexRealization[i];

  273.         return new double[][] {adblStraightVertexRealization, adblAntitheticVertexRealization};
  274.     }

  276.     /**
  277.      * Generate a Single Straight Path R^d Vertex Realization
  278.      * 
  279.      * @return Single Straight Path R^d Vertex Realization
  280.      */

  282.     public org.drip.measure.discrete.VertexRd straightPathVertexRd()
  283.     {
  284.         org.drip.measure.discrete.VertexRd vertexRealization = new
  285.             org.drip.measure.discrete.VertexRd();

  287.         for (int i = 0; i < _iNumVertex; ++i) {
  288.             if (!vertexRealization.add (i, straightVertexRealization())) return null;
  289.         }

  291.         return null != _qr ? org.drip.measure.discrete.VertexRd.FromFlatForm (_qr.transform
  292.             (vertexRealization.flatform())) : vertexRealization;
  293.     }

  295.     /**
  296.      * Generate an Antithetic Pair Path R^d Vertex Realizations
  297.      * 
  298.      * @return Antithetic Pair Path R^d Vertex Realizations
  299.      */

  301.     public org.drip.measure.discrete.VertexRd[] antitheticPairPathVertexRd()
  302.     {
  303.         org.drip.measure.discrete.VertexRd straightVertexRealization = new
  304.             org.drip.measure.discrete.VertexRd();

  306.         org.drip.measure.discrete.VertexRd antitheticVertexRealization = new
  307.             org.drip.measure.discrete.VertexRd();

  309.         for (int i = 0; i < _iNumVertex; ++i) {
  310.             double[][] aadblStraightAntitheticRealization = antitheticVertexPairRealization();

  312.             if (!straightVertexRealization.add (i, aadblStraightAntitheticRealization[0]) ||
  313.                 !antitheticVertexRealization.add (i, aadblStraightAntitheticRealization[1]))
  314.                 return null;
  315.         }

  317.         if (null == _qr)
  318.             return new org.drip.measure.discrete.VertexRd[] {straightVertexRealization,
  319.                 antitheticVertexRealization};

  321.         return new org.drip.measure.discrete.VertexRd[] {org.drip.measure.discrete.VertexRd.FromFlatForm
  322.             (_qr.transform (straightVertexRealization.flatform())),
  323.                 org.drip.measure.discrete.VertexRd.FromFlatForm (_qr.transform
  324.                     (antitheticVertexRealization.flatform()))};
  325.     }

  327.     /**
  328.      * Generate Straight Multi-Path R^d Vertex Realizations Array
  329.      * 
  330.      * @return Straight Multi-Path R^d Vertex Realizations Array
  331.      */

  333.     public org.drip.measure.discrete.VertexRd[] straightMultiPathVertexRd()
  334.     {
  335.         org.drip.measure.discrete.VertexRd[] aVertexRd = new
  336.             org.drip.measure.discrete.VertexRd[_iNumPath];

  338.         for (int i = 0; i < _iNumPath; ++i) {
  339.             if (null == (aVertexRd[i] = straightPathVertexRd())) return null;
  340.         }

  342.         return aVertexRd;
  343.     }

  345.     /**
  346.      * Generate Antithetic Multi-Path R^d Vertex Realizations Array
  347.      * 
  348.      * @return Antithetic Multi-Path R^d Vertex Realizations Array
  349.      */

  351.     public org.drip.measure.discrete.VertexRd[] antitheticMultiPathVertexRd()
  352.     {
  353.         org.drip.measure.discrete.VertexRd[] aVertexRd = new
  354.             org.drip.measure.discrete.VertexRd[_iNumPath];

  356.         int iNumGeneration = _iNumPath / 2;

  358.         for (int i = 0; i < iNumGeneration; ++i) {
  359.             org.drip.measure.discrete.VertexRd[] aAntitheticVertexRd = antitheticPairPathVertexRd();

  361.             if (null == aAntitheticVertexRd || 2 != aAntitheticVertexRd.length) return null;

  363.             if (null == (aVertexRd[i] = aAntitheticVertexRd[0]) || null == (aVertexRd[i + iNumGeneration] =
  364.                 aAntitheticVertexRd[1]))
  365.                 return null;
  366.         }

  368.         if (1 == (_iNumPath % 2)) aVertexRd[_iNumPath - 1] = straightPathVertexRd();

  370.         return aVertexRd;
  371.     }

  373.     /**
  374.      * Generate Multi-Path R^d Vertex Realizations Array
  375.      * 
  376.      * @return Multi-Path R^d Vertex Realizations Array
  377.      */

  379.     public org.drip.measure.discrete.VertexRd[] multiPathVertexRd()
  380.     {
  381.         return _bApplyAntithetic ? antitheticMultiPathVertexRd() : straightMultiPathVertexRd();
  382.     }
  383. }
Created with JaCoCo 0.7.9.201702052155