TheilMixedEstimationModel.java

  1. package org.drip.measure.bayesian;

  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>TheilMixedEstimationModel</i> implements the Theil's Mixed Model for the Estimation of the Distribution
  82.  * Parameters. The Reference is:
  83.  * <br><br>
  84.  *  <ul>
  85.  *      <li>
  86.  *          Theil, H. (1971): <i>Principles of Econometrics</i> <b>Wiley</b>
  87.  *      </li>
  88.  *  </ul>
  89.  *
  90.  *  <br><br>
  91.  *  <ul>
  92.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  93.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/NumericalAnalysisLibrary.md">Numerical Analysis Library</a></li>
  94.  *      <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>
  95.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/bayesian/README.md">Prior, Conditional, Posterior Theil Bayesian</a></li>
  96.  *  </ul>
  97.  *
  98.  * @author Lakshmi Krishnamurthy
  99.  */

  101. public class TheilMixedEstimationModel {

  103.     /**
  104.      * Generate the Joint Mixed Estimation Model Joint/Posterior Metrics
  105.      * 
  106.      * @param meta The R^1 Multivariate Meta Descriptors
  107.      * @param pdl1 Projection Distribution and Loading #1
  108.      * @param pdl2 Projection Distribution and Loading #2
  109.      * @param r1mnUnconditional The R^1 Multivariate Normal Unconditional Distribution
  110.      * 
  111.      * @return The Joint Mixed Estimation Model Joint/Posterior Metrics
  112.      */

  114.     public static final org.drip.measure.bayesian.R1MultivariateConvolutionMetrics GenerateComposite (
  115.         final org.drip.measure.continuous.MultivariateMeta meta,
  116.         final org.drip.measure.bayesian.ProjectionDistributionLoading pdl1,
  117.         final org.drip.measure.bayesian.ProjectionDistributionLoading pdl2,
  118.         final org.drip.measure.gaussian.R1MultivariateNormal r1mnUnconditional)
  119.     {
  120.         if (null == meta || null == pdl1 || null == pdl2 || null == r1mnUnconditional) return null;

  122.         int iNumScopingVariate = meta.numVariable();

  124.         if (iNumScopingVariate != pdl1.numberOfScopingVariate() || iNumScopingVariate !=
  125.             pdl2.numberOfScopingVariate() || iNumScopingVariate != r1mnUnconditional.meta().numVariable())
  126.             return null;

  128.         org.drip.measure.continuous.R1Multivariate r1m1 = pdl1.distribution();

  130.         org.drip.measure.continuous.R1Multivariate r1m2 = pdl2.distribution();

  132.         if (!(r1m1 instanceof org.drip.measure.gaussian.R1MultivariateNormal) || !(r1m2 instanceof
  133.             org.drip.measure.gaussian.R1MultivariateNormal))
  134.             return null;

  136.         double[] adblJointPrecisionWeightedMean = new double[iNumScopingVariate];
  137.         double[][] aadblJointPrecision = new double[iNumScopingVariate][iNumScopingVariate];
  138.         double[][] aadblPosteriorCovariance = new double[iNumScopingVariate][iNumScopingVariate];
  139.         org.drip.measure.gaussian.R1MultivariateNormal r1mn1 =
  140.             (org.drip.measure.gaussian.R1MultivariateNormal) r1m1;
  141.         org.drip.measure.gaussian.R1MultivariateNormal r1mn2 =
  142.             (org.drip.measure.gaussian.R1MultivariateNormal) r1m2;

  144.         double[][] aadblScopingLoading1 = pdl1.scopingLoading();

  146.         double[][] aadblScopingLoading2 = pdl2.scopingLoading();

  148.         double[][] aadblScopingWeightedPrecision1 = org.drip.numerical.linearalgebra.Matrix.Product
  149.             (org.drip.numerical.linearalgebra.Matrix.Transpose (aadblScopingLoading1),
  150.                 r1mn1.covariance().precisionMatrix());

  152.         double[][] aadblScopingWeightedPrecision2 = org.drip.numerical.linearalgebra.Matrix.Product
  153.             (org.drip.numerical.linearalgebra.Matrix.Transpose (aadblScopingLoading2),
  154.                 r1mn2.covariance().precisionMatrix());

  156.         double[][] aadblScopingSpacePrecision1 = org.drip.numerical.linearalgebra.Matrix.Product
  157.             (aadblScopingWeightedPrecision1, aadblScopingLoading1);

  159.         double[][] aadblScopingSpacePrecision2 = org.drip.numerical.linearalgebra.Matrix.Product
  160.             (aadblScopingWeightedPrecision2, aadblScopingLoading2);

  162.         if (null == aadblScopingSpacePrecision1 || null == aadblScopingSpacePrecision2) return null;

  164.         double[] adblPrecisionWeightedMean1 = org.drip.numerical.linearalgebra.Matrix.Product
  165.             (aadblScopingWeightedPrecision1, r1mn1.mean());

  167.         double[] adblPrecisionWeightedMean2 = org.drip.numerical.linearalgebra.Matrix.Product
  168.             (aadblScopingWeightedPrecision2, r1mn2.mean());

  170.         if (null == adblPrecisionWeightedMean1 || null == adblPrecisionWeightedMean2) return null;

  172.         for (int i = 0; i < iNumScopingVariate; ++i) {
  173.             adblJointPrecisionWeightedMean[i] = adblPrecisionWeightedMean1[i] +
  174.                 adblPrecisionWeightedMean2[i];

  176.             for (int j = 0; j < iNumScopingVariate; ++j)
  177.                 aadblJointPrecision[i][j] = aadblScopingSpacePrecision1[i][j] +
  178.                     aadblScopingSpacePrecision2[i][j];
  179.         }

  181.         double[][] aadblJointCovariance = org.drip.numerical.linearalgebra.Matrix.InvertUsingGaussianElimination
  182.             (aadblJointPrecision);

  184.         double[] adblJointPosteriorMean = org.drip.numerical.linearalgebra.Matrix.Product (aadblJointCovariance,
  185.             adblJointPrecisionWeightedMean);

  187.         double[][] aadblUnconditionalCovariance = r1mnUnconditional.covariance().covarianceMatrix();

  189.         for (int i = 0; i < iNumScopingVariate; ++i) {
  190.             for (int j = 0; j < iNumScopingVariate; ++j)
  191.                 aadblPosteriorCovariance[i][j] = aadblJointCovariance[i][j] +
  192.                     aadblUnconditionalCovariance[i][j];
  193.         }

  195.         try {
  196.             return new org.drip.measure.bayesian.R1MultivariateConvolutionMetrics (r1mn1, r1mnUnconditional, r1mn2, new
  197.                 org.drip.measure.gaussian.R1MultivariateNormal (meta, adblJointPosteriorMean, new
  198.                     org.drip.measure.gaussian.Covariance (aadblJointCovariance)), new
  199.                         org.drip.measure.gaussian.R1MultivariateNormal (meta, adblJointPosteriorMean, new
  200.                             org.drip.measure.gaussian.Covariance (aadblPosteriorCovariance)));
  201.         } catch (java.lang.Exception e) {
  202.             e.printStackTrace();
  203.         }

  205.         return null;
  206.     }

  208.     /**
  209.      * Generate the Combined R^1 Multivariate Normal Distribution from the SPVD and the Named Projections
  210.      * 
  211.      * @param spvd The Scoping/Projection Distribution
  212.      * @param strProjection1 Name of Projection #1
  213.      * @param strProjection2 Name of Projection #2
  214.      * @param r1mnUnconditional The R^1 Multivariate Normal Unconditional Distribution
  215.      * 
  216.      * @return The Combined R^1 Multivariate Normal Distribution
  217.      */

  219.     public static final org.drip.measure.bayesian.R1MultivariateConvolutionMetrics GenerateComposite (
  220.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  221.         final java.lang.String strProjection1,
  222.         final java.lang.String strProjection2,
  223.         final org.drip.measure.gaussian.R1MultivariateNormal r1mnUnconditional)
  224.     {
  225.         return null == spvd ? null : GenerateComposite (spvd.scopingDistribution().meta(),
  226.             spvd.projectionDistributionLoading (strProjection1), spvd.projectionDistributionLoading
  227.                 (strProjection2), r1mnUnconditional);
  228.     }

  230.     /**
  231.      * Generate the Combined R^1 Multivariate Normal Distribution from the SPVD, the NATIVE Projection, and
  232.      *  the Named Projection
  233.      * 
  234.      * @param spvd The Scoping/Projection Distribution
  235.      * @param strProjection Name of Projection
  236.      * @param r1mnUnconditional The R^1 Multivariate Normal Unconditional Distribution
  237.      * 
  238.      * @return The Combined R^1 Multivariate Normal Distribution
  239.      */

  241.     public static final org.drip.measure.bayesian.R1MultivariateConvolutionMetrics GenerateComposite (
  242.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  243.         final java.lang.String strProjection,
  244.         final org.drip.measure.gaussian.R1MultivariateNormal r1mnUnconditional)
  245.     {
  246.         if (null == spvd) return null;

  248.         org.drip.measure.continuous.R1Multivariate r1m = spvd.scopingDistribution();

  250.         if (!(r1m instanceof org.drip.measure.gaussian.R1MultivariateNormal)) return null;

  252.         org.drip.measure.gaussian.R1MultivariateNormal r1mnScoping =
  253.             (org.drip.measure.gaussian.R1MultivariateNormal) r1m;

  255.         return GenerateComposite (r1mnScoping.meta(), spvd.projectionDistributionLoading ("NATIVE"),
  256.             spvd.projectionDistributionLoading (strProjection), r1mnUnconditional);
  257.     }

  259.     /**
  260.      * Generate the Projection Space Scoping Mean
  261.      * 
  262.      * @param spvd The Scoping/Projection Distribution
  263.      * @param strProjection Name of Projection
  264.      * 
  265.      * @return The Projection Space Scoping Mean
  266.      */

  268.     public static final double[] ProjectionSpaceScopingMean (
  269.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  270.         final java.lang.String strProjection)
  271.     {
  272.         if (null == spvd) return null;

  274.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  275.             (strProjection);

  277.         return null == pdl ? null : org.drip.numerical.linearalgebra.Matrix.Product (pdl.scopingLoading(),
  278.             spvd.scopingDistribution().mean());
  279.     }

  281.     /**
  282.      * Generate the Projection Space Projection-Scoping Mean Differential
  283.      * 
  284.      * @param spvd The Scoping/Projection Distribution
  285.      * @param strProjection Name of Projection
  286.      * 
  287.      * @return The Projection Space Projection-Scoping Mean Differential
  288.      */

  290.     public static final double[] ProjectionSpaceScopingDifferential (
  291.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  292.         final java.lang.String strProjection)
  293.     {
  294.         if (null == spvd) return null;

  296.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  297.             (strProjection);

  299.         if (null == pdl) return null;

  301.         double[] adblProjectionSpaceScopingMean = org.drip.numerical.linearalgebra.Matrix.Product
  302.             (pdl.scopingLoading(), spvd.scopingDistribution().mean());

  304.         if (null == adblProjectionSpaceScopingMean) return null;

  306.         int iNumProjection = adblProjectionSpaceScopingMean.length;
  307.         double[] adblProjectionSpaceScopingDifferential = new double[iNumProjection];

  309.         double[] adblProjectionMean = pdl.distribution().mean();

  311.         for (int i = 0; i < iNumProjection; ++i)
  312.             adblProjectionSpaceScopingDifferential[i] = adblProjectionMean[i] -
  313.                 adblProjectionSpaceScopingMean[i];

  315.         return adblProjectionSpaceScopingDifferential;
  316.     }

  318.     /**
  319.      * Generate the Projection Space Scoping Co-variance
  320.      * 
  321.      * @param spvd The Scoping/Projection Distribution
  322.      * @param strProjection Name of Projection
  323.      * 
  324.      * @return The Projection Space Scoping Co-variance
  325.      */

  327.     public static final org.drip.measure.gaussian.Covariance ProjectionSpaceScopingCovariance (
  328.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  329.         final java.lang.String strProjection)
  330.     {
  331.         if (null == spvd) return null;

  333.         org.drip.measure.continuous.R1Multivariate r1mScoping = spvd.scopingDistribution();

  335.         if (!(r1mScoping instanceof org.drip.measure.gaussian.R1MultivariateNormal)) return null;

  337.         org.drip.measure.gaussian.R1MultivariateNormal r1mnScoping =
  338.             (org.drip.measure.gaussian.R1MultivariateNormal) r1mScoping;

  340.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  341.             (strProjection);

  343.         if (null == pdl) return null;

  345.         double[][] aadblScopingLoading = pdl.scopingLoading();

  347.         try {
  348.             return new org.drip.measure.gaussian.Covariance (org.drip.numerical.linearalgebra.Matrix.Product
  349.                 (aadblScopingLoading, org.drip.numerical.linearalgebra.Matrix.Product
  350.                     (r1mnScoping.covariance().covarianceMatrix(),
  351.                         org.drip.numerical.linearalgebra.Matrix.Transpose (aadblScopingLoading))));
  352.         } catch (java.lang.Exception e) {
  353.             e.printStackTrace();
  354.         }

  356.         return null;
  357.     }

  359.     /**
  360.      * Compute the Shadow of the Scoping on Projection Transpose
  361.      * 
  362.      * @param spvd The Scoping/Projection Distribution
  363.      * @param strProjection Name of Projection
  364.      * 
  365.      * @return The Shadow of the Scoping on Projection Transpose
  366.      */

  368.     public static final double[][] ShadowScopingProjectionTranspose (
  369.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  370.         final java.lang.String strProjection)
  371.     {
  372.         if (null == spvd) return null;

  374.         org.drip.measure.continuous.R1Multivariate r1mScoping = spvd.scopingDistribution();

  376.         if (!(r1mScoping instanceof org.drip.measure.gaussian.R1MultivariateNormal)) return null;

  378.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  379.             (strProjection);

  381.         return null == pdl ? null : org.drip.numerical.linearalgebra.Matrix.Product
  382.             (((org.drip.measure.gaussian.R1MultivariateNormal) r1mScoping).covariance().covarianceMatrix(),
  383.                 org.drip.numerical.linearalgebra.Matrix.Transpose (pdl.scopingLoading()));
  384.     }

  386.     /**
  387.      * Compute the Shadow of the Scoping on Projection
  388.      * 
  389.      * @param spvd The Scoping/Projection Distribution
  390.      * @param strProjection Name of Projection
  391.      * 
  392.      * @return The Shadow of the Scoping on Projection
  393.      */

  395.     public static final double[][] ShadowScopingProjection (
  396.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  397.         final java.lang.String strProjection)
  398.     {
  399.         if (null == spvd) return null;

  401.         org.drip.measure.continuous.R1Multivariate r1mScoping = spvd.scopingDistribution();

  403.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  404.             (strProjection);

  406.         return !(r1mScoping instanceof org.drip.measure.gaussian.R1MultivariateNormal) || null == pdl ? null
  407.             : org.drip.numerical.linearalgebra.Matrix.Product (pdl.scopingLoading(),
  408.                 ((org.drip.measure.gaussian.R1MultivariateNormal)
  409.                     r1mScoping).covariance().covarianceMatrix());
  410.     }

  412.     /**
  413.      * Compute the Projection Precision Mean Dot Product Array
  414.      * 
  415.      * @param spvd The Scoping/Projection Distribution
  416.      * @param strProjection Name of Projection
  417.      * 
  418.      * @return The Projection Precision Mean Dot Product Array
  419.      */

  421.     public static final double[] ProjectionPrecisionMeanProduct (
  422.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  423.         final java.lang.String strProjection)
  424.     {
  425.         if (null == spvd) return null;

  427.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  428.             (strProjection);

  430.         if (null == pdl) return null;

  432.         org.drip.measure.continuous.R1Multivariate r1mProjection = pdl.distribution();

  434.         return !(r1mProjection instanceof org.drip.measure.gaussian.R1MultivariateNormal) ? null :
  435.             org.drip.numerical.linearalgebra.Matrix.Product (((org.drip.measure.gaussian.R1MultivariateNormal)
  436.                 r1mProjection).covariance().precisionMatrix(), r1mProjection.mean());
  437.     }

  439.     /**
  440.      * Compute the Projection Induced Scoping Mean Deviation
  441.      * 
  442.      * @param spvd The Scoping/Projection Distribution
  443.      * @param strProjection Name of Projection
  444.      * 
  445.      * @return The Projection Induced Scoping Mean Deviation
  446.      */

  448.     public static final double[] ProjectionInducedScopingDeviation (
  449.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  450.         final java.lang.String strProjection)
  451.     {
  452.         if (null == spvd) return null;

  454.         org.drip.measure.continuous.R1Multivariate r1mScoping = spvd.scopingDistribution();

  456.         if (!(r1mScoping instanceof org.drip.measure.gaussian.R1MultivariateNormal)) return null;

  458.         org.drip.measure.gaussian.R1MultivariateNormal r1mnScoping =
  459.             (org.drip.measure.gaussian.R1MultivariateNormal) r1mScoping;

  461.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  462.             (strProjection);

  464.         if (null == pdl) return null;

  466.         double[][] aadblScopingLoading = pdl.scopingLoading();

  468.         double[][] aadblProjectionScopingShadow = org.drip.numerical.linearalgebra.Matrix.Product
  469.             (r1mnScoping.covariance().covarianceMatrix(), org.drip.numerical.linearalgebra.Matrix.Transpose
  470.                 (aadblScopingLoading));

  472.         double[] adblProjectionSpaceScopingMean = org.drip.numerical.linearalgebra.Matrix.Product
  473.             (aadblScopingLoading, r1mScoping.mean());

  475.         if (null == adblProjectionSpaceScopingMean) return null;

  477.         int iNumProjection = adblProjectionSpaceScopingMean.length;
  478.         double[] adblProjectionSpaceScopingDifferential = new double[iNumProjection];

  480.         double[] adblProjectionMean = pdl.distribution().mean();

  482.         for (int i = 0; i < iNumProjection; ++i)
  483.             adblProjectionSpaceScopingDifferential[i] = adblProjectionMean[i] -
  484.                 adblProjectionSpaceScopingMean[i];

  486.         return org.drip.numerical.linearalgebra.Matrix.Product (aadblProjectionScopingShadow,
  487.             org.drip.numerical.linearalgebra.Matrix.Product
  488.                 (org.drip.numerical.linearalgebra.Matrix.InvertUsingGaussianElimination
  489.                     (org.drip.numerical.linearalgebra.Matrix.Product (aadblScopingLoading,
  490.                         aadblProjectionScopingShadow)), adblProjectionSpaceScopingDifferential));
  491.     }

  493.     /**
  494.      * Compute the Projection Induced Scoping Deviation Adjusted Mean
  495.      * 
  496.      * @param spvd The Scoping/Projection Distribution
  497.      * @param strProjection Name of Projection
  498.      * 
  499.      * @return The Projection Induced Scoping Deviation Adjusted Mean
  500.      */

  502.     public static final double[] ProjectionInducedScopingMean (
  503.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  504.         final java.lang.String strProjection)
  505.     {
  506.         if (null == spvd) return null;

  508.         org.drip.measure.continuous.R1Multivariate r1mScoping = spvd.scopingDistribution();

  510.         double[] adblScopingMean = r1mScoping.mean();

  512.         int iNumScopingVariate = r1mScoping.meta().numVariable();

  514.         if (!(r1mScoping instanceof org.drip.measure.gaussian.R1MultivariateNormal)) return null;

  516.         org.drip.measure.gaussian.R1MultivariateNormal r1mnScoping =
  517.             (org.drip.measure.gaussian.R1MultivariateNormal) r1mScoping;

  519.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  520.             (strProjection);

  522.         if (null == pdl) return null;

  524.         double[][] aadblScopingLoading = pdl.scopingLoading();

  526.         double[][] aadblProjectionScopingShadow = org.drip.numerical.linearalgebra.Matrix.Product
  527.             (r1mnScoping.covariance().covarianceMatrix(), org.drip.numerical.linearalgebra.Matrix.Transpose
  528.                 (aadblScopingLoading));

  530.         double[] adblProjectionSpaceScopingMean = org.drip.numerical.linearalgebra.Matrix.Product
  531.             (aadblScopingLoading, adblScopingMean);

  533.         if (null == adblProjectionSpaceScopingMean) return null;

  535.         int iNumProjection = adblProjectionSpaceScopingMean.length;
  536.         double[] adblProjectionInducedScopingMean = new double[iNumScopingVariate];
  537.         double[] adblProjectionSpaceScopingDifferential = new double[iNumProjection];

  539.         double[] adblProjectionMean = pdl.distribution().mean();

  541.         for (int i = 0; i < iNumProjection; ++i)
  542.             adblProjectionSpaceScopingDifferential[i] = adblProjectionMean[i] -
  543.                 adblProjectionSpaceScopingMean[i];

  545.         double[] adblProjectionInducedScopingDeviation = org.drip.numerical.linearalgebra.Matrix.Product
  546.             (aadblProjectionScopingShadow, org.drip.numerical.linearalgebra.Matrix.Product
  547.                 (org.drip.numerical.linearalgebra.Matrix.InvertUsingGaussianElimination
  548.                     (org.drip.numerical.linearalgebra.Matrix.Product (aadblScopingLoading,
  549.                         aadblProjectionScopingShadow)), adblProjectionSpaceScopingDifferential));

  551.         if (null == adblProjectionInducedScopingDeviation) return null;

  553.         for (int i = 0; i < iNumScopingVariate; ++i)
  554.             adblProjectionInducedScopingMean[i] = adblScopingMean[i] +
  555.                 adblProjectionInducedScopingDeviation[i];

  557.         return adblProjectionInducedScopingMean;
  558.     }

  560.     /**
  561.      * Compute the Asset Space Projection Co-variance
  562.      * 
  563.      * @param spvd The Scoping/Projection Distribution
  564.      * @param strProjection Name of Projection
  565.      * 
  566.      * @return The Asset Space Projection Co-variance
  567.      */

  569.     public static final double[][] AssetSpaceProjectionCovariance (
  570.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  571.         final java.lang.String strProjection)
  572.     {
  573.         if (null == spvd) return null;

  575.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  576.             (strProjection);

  578.         if (null == pdl) return null;

  580.         org.drip.measure.continuous.R1Multivariate r1mProjection = pdl.distribution();

  582.         if (!(r1mProjection instanceof org.drip.measure.gaussian.R1MultivariateNormal)) return null;

  584.         double[][] aadblScopingLoading = pdl.scopingLoading();

  586.         return org.drip.numerical.linearalgebra.Matrix.Product (org.drip.numerical.linearalgebra.Matrix.Transpose
  587.             (aadblScopingLoading), org.drip.numerical.linearalgebra.Matrix.Product
  588.                 (((org.drip.measure.gaussian.R1MultivariateNormal)
  589.                     r1mProjection).covariance().covarianceMatrix(), aadblScopingLoading));
  590.     }

  592.     /**
  593.      * Compute the Projection Space Asset Co-variance
  594.      * 
  595.      * @param spvd The Scoping/Projection Distribution
  596.      * @param strProjection Name of Projection
  597.      * 
  598.      * @return The Projection Space Asset Co-variance
  599.      */

  601.     public static final double[][] ProjectionSpaceAssetCovariance (
  602.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  603.         final java.lang.String strProjection)
  604.     {
  605.         if (null == spvd) return null;

  607.         org.drip.measure.continuous.R1Multivariate r1mScoping = spvd.scopingDistribution();

  609.         if (!(r1mScoping instanceof org.drip.measure.gaussian.R1MultivariateNormal)) return null;

  611.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  612.             (strProjection);

  614.         if (null == pdl) return null;

  616.         double[][] aadblScopingLoading = pdl.scopingLoading();

  618.         return org.drip.numerical.linearalgebra.Matrix.Product (aadblScopingLoading,
  619.             org.drip.numerical.linearalgebra.Matrix.Product (((org.drip.measure.gaussian.R1MultivariateNormal)
  620.                 r1mScoping).covariance().covarianceMatrix(), org.drip.numerical.linearalgebra.Matrix.Transpose
  621.                     (aadblScopingLoading)));
  622.     }

  624.     /**
  625.      * Compute the Projection Induced Scoping Deviation Adjusted Mean
  626.      * 
  627.      * @param spvd The Scoping/Projection Distribution
  628.      * @param strProjection Name of Projection
  629.      * @param r1mnUnconditional The Unconditional Distribution
  630.      * 
  631.      * @return The Projection Induced Scoping Deviation Adjusted Mean
  632.      */

  634.     public static final org.drip.measure.gaussian.R1MultivariateNormal ProjectionInducedScopingDistribution (
  635.         final org.drip.measure.bayesian.ScopingProjectionVariateDistribution spvd,
  636.         final java.lang.String strProjection,
  637.         final org.drip.measure.gaussian.R1MultivariateNormal r1mnUnconditional)
  638.     {
  639.         if (null == spvd || null == r1mnUnconditional) return null;

  641.         org.drip.measure.continuous.R1Multivariate r1mScoping = spvd.scopingDistribution();

  643.         double[] adblScopingMean = r1mScoping.mean();

  645.         int iNumScopingVariate = r1mScoping.meta().numVariable();

  647.         if (!(r1mScoping instanceof org.drip.measure.gaussian.R1MultivariateNormal)) return null;

  649.         org.drip.measure.gaussian.R1MultivariateNormal r1mnScoping =
  650.             (org.drip.measure.gaussian.R1MultivariateNormal) r1mScoping;

  652.         org.drip.measure.bayesian.ProjectionDistributionLoading pdl = spvd.projectionDistributionLoading
  653.             (strProjection);

  655.         if (null == pdl) return null;

  657.         double[][] aadblScopingLoading = pdl.scopingLoading();

  659.         double[][] aadblProjectionScopingShadow = org.drip.numerical.linearalgebra.Matrix.Product
  660.             (r1mnScoping.covariance().covarianceMatrix(), org.drip.numerical.linearalgebra.Matrix.Transpose
  661.                 (aadblScopingLoading));

  663.         double[] adblProjectionSpaceScopingMean = org.drip.numerical.linearalgebra.Matrix.Product
  664.             (aadblScopingLoading, adblScopingMean);

  666.         if (null == adblProjectionSpaceScopingMean) return null;

  668.         int iNumProjection = adblProjectionSpaceScopingMean.length;
  669.         double[] adblProjectionInducedScopingMean = new double[iNumScopingVariate];
  670.         double[] adblProjectionSpaceScopingDifferential = new double[iNumProjection];

  672.         double[] adblProjectionMean = pdl.distribution().mean();

  674.         for (int i = 0; i < iNumProjection; ++i)
  675.             adblProjectionSpaceScopingDifferential[i] = adblProjectionMean[i] -
  676.                 adblProjectionSpaceScopingMean[i];

  678.         double[] adblProjectionInducedScopingDeviation = org.drip.numerical.linearalgebra.Matrix.Product
  679.             (aadblProjectionScopingShadow, org.drip.numerical.linearalgebra.Matrix.Product
  680.                 (org.drip.numerical.linearalgebra.Matrix.InvertUsingGaussianElimination
  681.                     (org.drip.numerical.linearalgebra.Matrix.Product (aadblScopingLoading,
  682.                         aadblProjectionScopingShadow)), adblProjectionSpaceScopingDifferential));

  684.         if (null == adblProjectionInducedScopingDeviation) return null;

  686.         for (int i = 0; i < iNumScopingVariate; ++i)
  687.             adblProjectionInducedScopingMean[i] = adblScopingMean[i] +
  688.                 adblProjectionInducedScopingDeviation[i];

  690.         org.drip.measure.continuous.R1Multivariate r1mProjection = pdl.distribution();

  692.         if (!(r1mProjection instanceof org.drip.measure.gaussian.R1MultivariateNormal)) return null;

  694.         try {
  695.             return new org.drip.measure.gaussian.R1MultivariateNormal (r1mnUnconditional.meta(),
  696.                 adblProjectionInducedScopingMean, new org.drip.measure.gaussian.Covariance
  697.                     (org.drip.numerical.linearalgebra.Matrix.Product
  698.                         (org.drip.numerical.linearalgebra.Matrix.Transpose (aadblScopingLoading),
  699.                             org.drip.numerical.linearalgebra.Matrix.Product
  700.                                 (((org.drip.measure.gaussian.R1MultivariateNormal)
  701.                                     r1mProjection).covariance().covarianceMatrix(), aadblScopingLoading))));
  702.         } catch (java.lang.Exception e) {
  703.             e.printStackTrace();
  704.         }

  706.         return null;
  707.     }
  708. }
Created with JaCoCo 0.7.9.201702052155