EntityComponentElasticityAttribution.java

  1. package org.drip.capital.allocation;

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

  77. /**
  78.  * <i>EntityComponentElasticityAttribution</i> holds the Attributions of a single Individual Entity Component
  79.  *  into Fixed, Float, and Pro-rata Elasticities. The References are:
  80.  * 
  81.  * <br><br>
  82.  *  <ul>
  83.  *      <li>
  84.  *          Bank for International Supervision(2005): Stress Testing at Major Financial Institutions: Survey
  85.  *              Results and Practice https://www.bis.org/publ/cgfs24.htm
  86.  *      </li>
  87.  *      <li>
  88.  *          Glasserman, P. (2004): <i>Monte Carlo Methods in Financial Engineering</i> <b>Springer</b>
  89.  *      </li>
  90.  *      <li>
  91.  *          Kupiec, P. H. (2000): Stress Tests and Risk Capital <i>Risk</i> <b>2 (4)</b> 27-39
  92.  *      </li>
  93.  *  </ul>
  94.  *
  95.  *  <br><br>
  96.  *  <ul>
  97.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/PortfolioCore.md">Portfolio Core Module</a></li>
  98.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/CapitalAnalyticsLibrary.md">Capital Analytics</a></li>
  99.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/capital/README.md">Basel Market Risk and Operational Capital</a></li>
  100.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/capital/allocation/README.md">Economic Risk Capital Entity Allocation</a></li>
  101.  *  </ul>
  102.  * 
  103.  * @author Lakshmi Krishnamurthy
  104.  */

  106. public class EntityComponentElasticityAttribution
  107. {
  108.     private double _fixed = -0.;
  109.     private double _proRata = -0.;
  110.     private double _floating = -0.;
  111.     private boolean _unitLoading = false;
  112.     private org.drip.capital.allocation.CorrelationCategoryBetaManager _correlationCategoryBetaManager =
  113.         null;

  115.     /**
  116.      * EntityComponentElasticityAttribution Constructor
  117.      * 
  118.      * @param correlationCategoryBetaManager The Correlation Category Beta Manager
  119.      * @param unitLoading The Unit Loading Flag
  120.      * 
  121.      * @throws java.lang.Exception Thrown if the Inputs are Invalid
  122.      */

  124.     public EntityComponentElasticityAttribution (
  125.         final org.drip.capital.allocation.CorrelationCategoryBetaManager correlationCategoryBetaManager,
  126.         final boolean unitLoading)
  127.         throws java.lang.Exception
  128.     {
  129.         if (null == (_correlationCategoryBetaManager = correlationCategoryBetaManager))
  130.         {
  131.             throw new java.lang.Exception (
  132.                 "EntityComponentElasticityAttribution Constructor => Invalid Inputs"
  133.             );
  134.         }

  136.         _unitLoading = unitLoading;
  137.     }

  139.     /**
  140.      * Retrieve the Correlation Category Beta Manager
  141.      * 
  142.      * @return The Correlation Category Beta Manager
  143.      */

  145.     public org.drip.capital.allocation.CorrelationCategoryBetaManager correlationCategoryBetaManager()
  146.     {
  147.         return _correlationCategoryBetaManager;
  148.     }

  150.     /**
  151.      * Retrieve the Fixed Attribution
  152.      * 
  153.      * @return Total Fixed Attribution
  154.      */

  156.     public double fixed()
  157.     {
  158.         return _fixed;
  159.     }

  161.     /**
  162.      * Retrieve the Floating Attribution
  163.      * 
  164.      * @return Floating Attribution
  165.      */

  167.     public double floating()
  168.     {
  169.         return _floating;
  170.     }

  172.     /**
  173.      * Retrieve the Pro-Rata Attribution
  174.      * 
  175.      * @return Pro-Rata Attribution
  176.      */

  178.     public double proRata()
  179.     {
  180.         return _proRata;
  181.     }

  183.     /**
  184.      * Retrieve the Unit Loading Flag
  185.      * 
  186.      * @return Unit Loading Flag
  187.      */

  189.     public boolean unitLoading()
  190.     {
  191.         return _unitLoading;
  192.     }

  194.     /**
  195.      * Accumulate the Fixed Attribution
  196.      * 
  197.      * @param fixedAttribution The Component Fixed Attribution
  198.      * 
  199.      * @return TRUE - The Fixed Attribution successfully updated
  200.      */

  202.     public boolean accumulateFixed (
  203.         final double fixedAttribution)
  204.     {
  205.         if (!org.drip.numerical.common.NumberUtil.IsValid (
  206.             fixedAttribution
  207.         ))
  208.         {
  209.             return false;
  210.         }

  212.         _fixed += fixedAttribution;
  213.         return true;
  214.     }

  216.     /**
  217.      * Accumulate the Floating Attribution
  218.      * 
  219.      * @param floatingAttribution The Component Floating Attribution
  220.      * 
  221.      * @return TRUE - The Floating Attribution successfully updated
  222.      */

  224.     public boolean accumulateFloating (
  225.         final double floatingAttribution)
  226.     {
  227.         if (!org.drip.numerical.common.NumberUtil.IsValid (
  228.             floatingAttribution
  229.         ))
  230.         {
  231.             return false;
  232.         }

  234.         _floating += floatingAttribution;
  235.         return true;
  236.     }

  238.     /**
  239.      * Accumulate the Pro-Rata Attribution
  240.      * 
  241.      * @param proRataAttribution The Component Pro-Rata Attribution
  242.      * 
  243.      * @return TRUE - The Pro-Rata Attribution successfully updated
  244.      */

  246.     public boolean accumulateProRata (
  247.         final double proRataAttribution)
  248.     {
  249.         if (!org.drip.numerical.common.NumberUtil.IsValid (
  250.             proRataAttribution
  251.         ))
  252.         {
  253.             return false;
  254.         }

  256.         _proRata += proRataAttribution;
  257.         return true;
  258.     }

  260.     /**
  261.      * Accumulate the Appropriate Attribution with the Beta-Adjusted Component Attribution
  262.      * 
  263.      * @param attribution The Component Attribution
  264.      * @param componentAllocationCategory The Component Allocation Category
  265.      * @param componentAllocationScheme The Component Allocation Scheme
  266.      * 
  267.      * @return TRUE - The Appropriate Partition with the Beta-Adjusted Increment
  268.      */

  270.     public boolean accumulate (
  271.         final double attribution,
  272.         final int componentAllocationCategory,
  273.         final int componentAllocationScheme)
  274.     {
  275.         if (org.drip.capital.allocation.EntityComponentAssignmentScheme.PRO_RATA ==
  276.             componentAllocationScheme)
  277.         {
  278.             return accumulateProRata (
  279.                 attribution
  280.             );
  281.         }

  283.         org.drip.capital.allocation.CorrelationCategoryBeta correlationCategoryBeta =
  284.             _correlationCategoryBetaManager.correlationCategoryBeta (
  285.                 componentAllocationCategory
  286.             );

  288.         if (null == correlationCategoryBeta)
  289.         {
  290.             return false;
  291.         }

  293.         if (org.drip.capital.allocation.EntityComponentCorrelationCategory.HEDGE ==
  294.             componentAllocationCategory)
  295.         {
  296.             return true;
  297.         }

  299.         int componentElasticity = correlationCategoryBeta.elasticity();

  301.         if (org.drip.capital.allocation.CorrelationCategoryBeta.ELASTICITY_FIXED == componentElasticity)
  302.         {
  303.             return accumulateFixed (
  304.                 (_unitLoading ? 1. : correlationCategoryBeta.loading()) * attribution
  305.             );
  306.         }

  308.         if (org.drip.capital.allocation.CorrelationCategoryBeta.ELASTICITY_FLOAT == componentElasticity)
  309.         {
  310.             return accumulateFloating (
  311.                 (_unitLoading ? 1. : correlationCategoryBeta.loading()) * attribution
  312.             );
  313.         }

  315.         return false;
  316.     }
  317. }
Created with JaCoCo 0.7.9.201702052155