R1Multivariate.java

  1. package org.drip.measure.continuous;

  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>R1Multivariate</i> contains the Generalized R<sup>1</sup> Multivariate Distributions.
  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/continuous/README.md">R<sup>1</sup> and R<sup>d</sup> Continuous Random Measure</a></li>
  89.  *  </ul>
  90.  *
  91.  * @author Lakshmi Krishnamurthy
  92.  */

  94. public abstract class R1Multivariate {
  95.     private org.drip.measure.continuous.MultivariateMeta _meta = null;

  97.     protected R1Multivariate (
  98.         final org.drip.measure.continuous.MultivariateMeta meta)
  99.         throws java.lang.Exception
  100.     {
  101.         if (null == (_meta = meta))
  102.             throw new java.lang.Exception ("R1Multivariate Constructor => Invalid Inputs");
  103.     }

  105.     /**
  106.      * Retrieve the Multivariate Meta Instance
  107.      * 
  108.      * @return The Multivariate Meta Instance
  109.      */

  111.     public org.drip.measure.continuous.MultivariateMeta meta()
  112.     {
  113.         return _meta;
  114.     }

  116.     /**
  117.      * Retrieve the Left Edge Bounding Multivariate
  118.      * 
  119.      * @return The Left Edge Bounding Multivariate
  120.      */

  122.     public double[] leftEdge()
  123.     {
  124.         int iNumVariate = _meta.numVariable();

  126.         double[] adblLeftEdge = new double[iNumVariate];

  128.         for (int i = 0; i < iNumVariate; ++i)
  129.             adblLeftEdge[i] = java.lang.Double.MIN_NORMAL;

  131.         return adblLeftEdge;
  132.     }

  134.     /**
  135.      * Retrieve the Right Edge Bounding Multivariate
  136.      * 
  137.      * @return The Right Edge Bounding Multivariate
  138.      */

  140.     public double[] rightEdge()
  141.     {
  142.         int iNumVariate = _meta.numVariable();

  144.         double[] adblRightEdge = new double[iNumVariate];

  146.         for (int i = 0; i < iNumVariate; ++i)
  147.             adblRightEdge[i] = java.lang.Double.MAX_VALUE;

  149.         return adblRightEdge;
  150.     }

  152.     /**
  153.      * Compute the Density under the Distribution at the given Multivariate
  154.      * 
  155.      * @param adblVariate The Multivariate at which the Density needs to be computed
  156.      * 
  157.      * @return The Density
  158.      * 
  159.      * @throws java.lang.Exception Thrown if the Density cannot be computed
  160.      */

  162.     public abstract double density (
  163.         final double[] adblVariate)
  164.         throws java.lang.Exception;

  166.     /**
  167.      * Convert the Multivariate Density into an RdToR1 Functions Instance
  168.      * 
  169.      * @return The Multivariate Density converted into an RdToR1 Functions Instance
  170.      */

  172.     public org.drip.function.definition.RdToR1 densityRdToR1()
  173.     {
  174.         return new org.drip.function.definition.RdToR1 (null) {
  175.             @Override public int dimension()
  176.             {
  177.                 return _meta.numVariable();
  178.             }

  180.             @Override public double evaluate (
  181.                 final double[] adblVariate)
  182.                 throws java.lang.Exception
  183.             {
  184.                 return density (adblVariate);
  185.             }
  186.         };
  187.     }

  189.     /**
  190.      * Compute the Cumulative under the Distribution to the given Variate Values
  191.      * 
  192.      * @param adblVariate Array of Variate Values to which the Cumulative is to be computed
  193.      * 
  194.      * @return The Cumulative
  195.      * 
  196.      * @throws java.lang.Exception Thrown if the Cumulative cannot be computed
  197.      */

  199.     public double cumulative (
  200.         final double[] adblVariate)
  201.         throws java.lang.Exception
  202.     {
  203.         return densityRdToR1().integrate (leftEdge(), adblVariate);
  204.     }

  206.     /**
  207.      * Compute the Incremental under the Distribution between the 2 Multivariate Instances
  208.      * 
  209.      * @param adblVariateLeft Left Multivariate Instance to which the Cumulative is to be computed
  210.      * @param adblVariateRight Right Multivariate Instance to which the Cumulative is to be computed
  211.      * 
  212.      * @return The Incremental
  213.      * 
  214.      * @throws java.lang.Exception Thrown if the Incremental cannot be computed
  215.      */

  217.     public double incremental (
  218.         final double[] adblVariateLeft,
  219.         final double[] adblVariateRight)
  220.         throws java.lang.Exception
  221.     {
  222.         return densityRdToR1().integrate (adblVariateLeft, adblVariateRight);
  223.     }

  225.     /**
  226.      * Compute the Expectation of the Specified R^d To R^1 Function Instance
  227.      * 
  228.      * @param funcRdToR1 The R^d To R^1 Function Instance
  229.      * 
  230.      * @return The Expectation of the Specified R^d To R^1 Function Instance
  231.      * 
  232.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  233.      */

  235.     public double expectation (
  236.         final org.drip.function.definition.RdToR1 funcRdToR1)
  237.         throws java.lang.Exception
  238.     {
  239.         if (null == funcRdToR1)
  240.             throw new java.lang.Exception ("R1Multivariate::expectation => Invalid Inputs");

  242.         return new org.drip.function.definition.RdToR1 (null) {
  243.             @Override public int dimension()
  244.             {
  245.                 return _meta.numVariable();
  246.             }

  248.             @Override public double evaluate (
  249.                 final double[] adblVariate)
  250.                 throws java.lang.Exception
  251.             {
  252.                 return density (adblVariate) * funcRdToR1.evaluate (adblVariate);
  253.             }
  254.         }.integrate (leftEdge(), rightEdge());
  255.     }

  257.     /**
  258.      * Compute the Mean of the Distribution
  259.      * 
  260.      * @return The Mean of the Distribution
  261.      */

  263.     public double[] mean()
  264.     {
  265.         int iNumVariate = _meta.numVariable();

  267.         double[] adblMean = new double[iNumVariate];

  269.         for (int i = 0; i < iNumVariate; ++i) {
  270.             final int iVariate = i;

  272.             try {
  273.                 adblMean[i] = expectation (new org.drip.function.definition.RdToR1 (null) {
  274.                     @Override public int dimension()
  275.                     {
  276.                         return _meta.numVariable();
  277.                     }

  279.                     @Override public double evaluate (
  280.                         final double[] adblVariate)
  281.                         throws java.lang.Exception
  282.                     {
  283.                         return density (adblVariate) * adblVariate[iVariate];
  284.                     }
  285.                 });
  286.             } catch (java.lang.Exception e) {
  287.                 e.printStackTrace();

  289.                 return null;
  290.             }
  291.         }

  293.         return adblMean;
  294.     }

  296.     /**
  297.      * Compute the Variance of the Distribution
  298.      * 
  299.      * @return The Variance of the Distribution
  300.      */

  302.     public double[] variance()
  303.     {
  304.         final double[] adblMean = mean();

  306.         if (null == adblMean) return null;

  308.         final int iNumVariate = adblMean.length;
  309.         double[] adblVariance = new double[iNumVariate];

  311.         for (int i = 0; i < iNumVariate; ++i) {
  312.             final int iVariate = i;

  314.             try {
  315.                 adblVariance[i] = expectation (new org.drip.function.definition.RdToR1 (null) {
  316.                     @Override public int dimension()
  317.                     {
  318.                         return _meta.numVariable();
  319.                     }

  321.                     @Override public double evaluate (
  322.                         final double[] adblVariate)
  323.                         throws java.lang.Exception
  324.                     {
  325.                         double dblSecondMoment = 0.;

  327.                         for (int i = 0; i < iNumVariate; ++i) {
  328.                             double dblOffset = adblVariate[iVariate] - adblMean[iVariate];
  329.                             dblSecondMoment = dblSecondMoment + dblOffset * dblOffset;
  330.                         }

  332.                         return density (adblVariate) * dblSecondMoment;
  333.                     }
  334.                 });
  335.             } catch (java.lang.Exception e) {
  336.                 e.printStackTrace();

  338.                 return null;
  339.             }
  340.         }

  342.         return adblVariance;
  343.     }
  344. }
Created with JaCoCo 0.7.9.201702052155