ConvertsDetail.java

  1. package org.drip.sample.betafixedfloat;

  3. import java.util.Map;

  5. import org.drip.analytics.support.CaseInsensitiveHashMap;
  6. import org.drip.capital.allocation.CorrelationCategoryBeta;
  7. import org.drip.capital.allocation.CorrelationCategoryBetaManager;
  8. import org.drip.capital.allocation.EntityCapital;
  9. import org.drip.capital.allocation.EntityCapitalAssignmentSetting;
  10. import org.drip.capital.allocation.EntityComponentCapital;
  11. import org.drip.capital.allocation.EntityComponentCapitalAssignment;
  12. import org.drip.capital.allocation.EntityComponentCorrelationCategory;
  13. import org.drip.capital.allocation.EntityElasticityAttribution;
  14. import org.drip.capital.entity.CapitalUnit;
  15. import org.drip.capital.entity.ManagedSegmentL1;
  16. import org.drip.capital.env.CapitalEstimationContextManager;
  17. import org.drip.capital.explain.AllocatedPnLAttribution;
  18. import org.drip.capital.explain.CapitalSegmentStandaloneMarginal;
  19. import org.drip.capital.explain.PnLAttribution;
  20. import org.drip.capital.label.BusinessRegionRiskTypeCoordinate;
  21. import org.drip.capital.label.CapitalSegmentCoordinate;
  22. import org.drip.capital.label.Coordinate;
  23. import org.drip.capital.setting.CapitalAllocationControl;
  24. import org.drip.capital.setting.SimulationControl;
  25. import org.drip.capital.setting.SimulationPnLControl;
  26. import org.drip.numerical.common.FormatUtil;
  27. import org.drip.service.env.EnvManager;

  29. /*
  30.  * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  31.  */

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

  103. /**
  104.  * <i>ConvertsDetail</i> zeds the Managed Sub-segment Level Allocation for the Specified Managed Segment
  105.  *  using the Two Beta Scheme.
  106.  * 
  107.  *     MANAGED SEGMENT  - Converts
  108.  * 

  110.  *     HIGH   - Fixed    Beta
  111.  *     LOW    - Floating Beta
  112.  *     
  113.  * The References are:
  114.  * 
  115.  * <br><br>
  116.  *  <ul>
  117.  *      <li>
  118.  *          Bank for International Supervision (2005): Stress Testing at Major Financial Institutions: Survey
  119.  *              Results and Practice https://www.bis.org/publ/cgfs24.htm
  120.  *      </li>
  121.  *      <li>
  122.  *          Glasserman, P. (2004): <i>Monte Carlo Methods in Financial Engineering</i> <b>Springer</b>
  123.  *      </li>
  124.  *      <li>
  125.  *          Kupiec, P. H. (2000): Stress Tests and Risk Capital <i>Risk</i> <b>2 (4)</b> 27-39
  126.  *      </li>
  127.  *  </ul>
  128.  *
  129.  *  <br><br>
  130.  *  <ul>
  131.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/PortfolioCore.md">Portfolio Core Module</a></li>
  132.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/CapitalAnalyticsLibrary.md">Capital Analytics</a></li>
  133.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/README.md">DROP API Construction and Usage</a></li>
  134.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/betafixedfloat/README.md">Two Beta Float Float Scheme</a></li>
  135.  *  </ul>
  136.  *     
  137.  * @author Lakshmi Krishnamurthy
  138.  */

  140. public class ConvertsDetail
  141. {

  143.     private static final CapitalUnit MakeCapitalUnit (
  144.         final String business,
  145.         final String region,
  146.         final String riskType,
  147.         final double varNotional)
  148.         throws Exception
  149.     {
  150.         Coordinate capitalUnitCoordinate = new BusinessRegionRiskTypeCoordinate (
  151.             business,
  152.             region,
  153.             riskType
  154.         );

  156.         return new CapitalUnit (
  157.             capitalUnitCoordinate,
  158.             CapitalEstimationContextManager.ContextContainer().capitalUnitStressEventContext().capitalUnitEventMap().get
  159.             (
  160.                 capitalUnitCoordinate.fullyQualifiedName()
  161.             ),
  162.             varNotional
  163.         );
  164.     }

  166.     private static final void DisplayPnLAttribution (
  167.         final String capitalSegmentFQN,
  168.         final PnLAttribution pnlAttribution)
  169.         throws Exception
  170.     {
  171.         Map<String, Double> gsstPnLExplainMap = pnlAttribution.systemicPnLExplainMap();

  173.         Map<String, Double> cBSSTPnLExplainMap = pnlAttribution.correlatedPnLExplainMap();

  175.         Map<String, Double> iBSSTPnLExplainMap = pnlAttribution.idiosyncraticPnLExplainMap();

  177.         Map<String, Integer> gsstInstanceCountMap = pnlAttribution.systemicInstanceCountMap();

  179.         Map<String, Integer> cBSSTInstanceCountMap = pnlAttribution.correlatedInstanceCountMap();

  181.         Map<String, Integer> iBSSTInstanceCountMap = pnlAttribution.idiosyncraticInstanceCountMap();

  183.         Map<String, Double> gsstGrossPnLExplainMap = pnlAttribution.systemicGrossPnLExplainMap();

  185.         Map<String, Double> fsPnLDecompositionExplainMap = pnlAttribution.fsPnLDecompositionExplainMap();

  187.         System.out.println ("\t|---------------------------------------------------------||");

  189.         System.out.println ("\t|              CONTRIBUTORY PnL ATTRIBUTION               ||");

  191.         System.out.println ("\t|---------------------------------------------------------||");

  193.         System.out.println ("\t|    Capital Segment FQN => " + capitalSegmentFQN);

  195.         System.out.println ("\t|    Expected Short-fall => " +
  196.             FormatUtil.FormatDouble (pnlAttribution.expectedShortfall(), 10, 2, 1.)
  197.         );

  199.         if (null != gsstPnLExplainMap)
  200.         {
  201.             System.out.println ("\t|---------------------------------------------------------||");

  203.             for (Map.Entry<String, Double> gsstPnLExplainEntry : gsstPnLExplainMap.entrySet())
  204.             {
  205.                 System.out.println (
  206.                     "\t|\t GSST | " + gsstPnLExplainEntry.getKey() + " => " +
  207.                     FormatUtil.FormatDouble (gsstPnLExplainEntry.getValue(), 10, 2, 1.)
  208.                 );
  209.             }
  210.         }

  212.         if (null != cBSSTPnLExplainMap)
  213.         {
  214.             System.out.println ("\t|---------------------------------------------------------||");

  216.             for (Map.Entry<String, Double> cBSSTPnLExplainEntry : cBSSTPnLExplainMap.entrySet())
  217.             {
  218.                 System.out.println (
  219.                     "\t|\tcBSST | " + cBSSTPnLExplainEntry.getKey() + " => " +
  220.                     FormatUtil.FormatDouble (cBSSTPnLExplainEntry.getValue(), 10, 2, 1.)
  221.                 );
  222.             }
  223.         }

  225.         if (null != iBSSTPnLExplainMap)
  226.         {
  227.             System.out.println ("\t|---------------------------------------------------------||");

  229.             for (Map.Entry<String, Double> iBSSTPnLExplainEntry : iBSSTPnLExplainMap.entrySet())
  230.             {
  231.                 System.out.println (
  232.                     "\t|\tiBSST | " + iBSSTPnLExplainEntry.getKey() + " => " +
  233.                     FormatUtil.FormatDouble (iBSSTPnLExplainEntry.getValue(), 10, 2, 1.)
  234.                 );
  235.             }
  236.         }

  238.         if (null != fsPnLDecompositionExplainMap)
  239.         {
  240.             System.out.println ("\t|---------------------------------------------------------||");

  242.             for (Map.Entry<String, Double> fsPnLDecompositionExplainEntry :
  243.                 fsPnLDecompositionExplainMap.entrySet())
  244.             {
  245.                 System.out.println (
  246.                     "\t|\t cVaR  | " + fsPnLDecompositionExplainEntry.getKey() + " => " +
  247.                     FormatUtil.FormatDouble (fsPnLDecompositionExplainEntry.getValue(), 10, 2, 1.)
  248.                 );
  249.             }
  250.         }

  252.         System.out.println ("\t|---------------------------------------------------------||");

  254.         if (null != gsstGrossPnLExplainMap)
  255.         {
  256.             for (Map.Entry<String, Double> gsstGrossPnLExplainEntry : gsstGrossPnLExplainMap.entrySet())
  257.             {
  258.                 System.out.println (
  259.                     "\t|\t Gross  GSST | " + gsstGrossPnLExplainEntry.getKey() + " => " +
  260.                     FormatUtil.FormatDouble (gsstGrossPnLExplainEntry.getValue(), 10, 2, 1.)
  261.                 );
  262.             }
  263.         }

  265.         System.out.println (
  266.             "\t|\t GSST         => " +
  267.             FormatUtil.FormatDouble (pnlAttribution.systemicPnL(), 10, 2, 1.)
  268.         );

  270.         System.out.println (
  271.             "\t|\t Gross cBSST  => " +
  272.             FormatUtil.FormatDouble (pnlAttribution.correlatedPnL(), 10, 2, 1.)
  273.         );

  275.         System.out.println (
  276.             "\t|\t Gross iBSST  => " +
  277.             FormatUtil.FormatDouble (pnlAttribution.idiosyncraticGrossPnL(), 10, 2, 1.)
  278.         );

  280.         System.out.println (
  281.             "\t|\t Gross cVaR   => " +
  282.             FormatUtil.FormatDouble (pnlAttribution.fsGrossPnL(), 10, 2, 1.)
  283.         );

  285.         System.out.println ("\t|---------------------------------------------------------||");

  287.         if (null != gsstInstanceCountMap)
  288.         {
  289.             for (Map.Entry<String, Integer> gsstInstanceCountEntry : gsstInstanceCountMap.entrySet())
  290.             {
  291.                 System.out.println (
  292.                     "\t|\t GSST  Instance Count | " + gsstInstanceCountEntry.getKey() + " => " +
  293.                     FormatUtil.FormatDouble (gsstInstanceCountEntry.getValue(), 6, 0, 1.)
  294.                 );
  295.             }
  296.         }

  298.         if (null != cBSSTInstanceCountMap)
  299.         {
  300.             for (Map.Entry<String, Integer> cBSSTInstanceCountEntry : cBSSTInstanceCountMap.entrySet())
  301.             {
  302.                 System.out.println (
  303.                     "\t|\t cBSST Instance Count | " + cBSSTInstanceCountEntry.getKey() + " => " +
  304.                     FormatUtil.FormatDouble (cBSSTInstanceCountEntry.getValue(), 6, 0, 1.)
  305.                 );
  306.             }
  307.         }

  309.         if (null != iBSSTInstanceCountMap)
  310.         {
  311.             for (Map.Entry<String, Integer> iBSSTInstanceCountEntry : iBSSTInstanceCountMap.entrySet())
  312.             {
  313.                 System.out.println (
  314.                     "\t|\t iBSST Instance Count | " + iBSSTInstanceCountEntry.getKey() + " => " +
  315.                     FormatUtil.FormatDouble (iBSSTInstanceCountEntry.getValue(), 6, 0, 1.)
  316.                 );
  317.             }
  318.         }

  320.         System.out.println ("\t|---------------------------------------------------------||");

  322.         System.out.println();
  323.     }

  325.     private static final EntityCapitalAssignmentSetting LowUniformBeta()
  326.     {
  327.         return EntityCapitalAssignmentSetting.UniformBeta (
  328.             EntityComponentCorrelationCategory.LOW_CORRELATION,
  329.             EntityComponentCorrelationCategory.LOW_CORRELATION,
  330.             EntityComponentCorrelationCategory.LOW_CORRELATION,
  331.             EntityComponentCorrelationCategory.LOW_CORRELATION,
  332.             EntityComponentCorrelationCategory.LOW_CORRELATION
  333.         );
  334.     }

  336.     private static final EntityCapitalAssignmentSetting HighUniformBeta()
  337.     {
  338.         return EntityCapitalAssignmentSetting.UniformBeta (
  339.             EntityComponentCorrelationCategory.HIGH_CORRELATION,
  340.             EntityComponentCorrelationCategory.HIGH_CORRELATION,
  341.             EntityComponentCorrelationCategory.HIGH_CORRELATION,
  342.             EntityComponentCorrelationCategory.HIGH_CORRELATION,
  343.             EntityComponentCorrelationCategory.HIGH_CORRELATION
  344.         );
  345.     }

  347.     private static final EntityCapitalAssignmentSetting HighLowUniformBeta()
  348.     {
  349.         return Math.random() < 13. / 34. ? HighUniformBeta() : LowUniformBeta();
  350.     }

  352.     private static final void Allocate (
  353.         final CapitalUnit[] capitalUnitArray,
  354.         final EntityComponentCapitalAssignment entityComponentCapitalAssignment)
  355.         throws Exception
  356.     {

  358.         double unitFloatBeta = entityComponentCapitalAssignment.unitFloatBeta();

  360.         double allocatedBetaCapital = entityComponentCapitalAssignment.allocatedTotalCapital();

  362.         Map<String, EntityComponentCapital> entityComponentCapitalMap =
  363.             entityComponentCapitalAssignment.entityComponentCapitalMap();

  365.         System.out.println (
  366.             "\t|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------||"
  367.         );

  369.         System.out.println (
  370.             "\t|                                                                         THREE BETA CAPITAL ALLOCATION                                                                            ||"
  371.         );

  373.         System.out.println (
  374.             "\t|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------||"
  375.         );

  377.         System.out.println (
  378.             "\t|      L -> R:                                                                                                                                                                     ||"
  379.         );

  381.         System.out.println (
  382.             "\t|            - Capital Segment Allocation Fraction  - GSST                                                                                                                         ||"
  383.         );

  385.         System.out.println (
  386.             "\t|            - Capital Segment Allocation Fraction  - cBSST                                                                                                                        ||"
  387.         );

  389.         System.out.println (
  390.             "\t|            - Capital Segment Allocation Fraction  - iBSST                                                                                                                        ||"
  391.         );

  393.         System.out.println (
  394.             "\t|            - Capital Segment Allocation Fraction  - No Stress                                                                                                                    ||"
  395.         );

  397.         System.out.println (
  398.             "\t|            - Capital Segment Allocation Fraction  - Total                                                                                                                        ||"
  399.         );

  401.         System.out.println (
  402.             "\t|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------||"
  403.         );

  405.         System.out.println (
  406.             "\t|            - Capital Segment Allocation Absolute  - GSST                                                                                                                         ||"
  407.         );

  409.         System.out.println (
  410.             "\t|            - Capital Segment Allocation Absolute  - cBSST                                                                                                                        ||"
  411.         );

  413.         System.out.println (
  414.             "\t|            - Capital Segment Allocation Absolute  - iBSST                                                                                                                        ||"
  415.         );

  417.         System.out.println (
  418.             "\t|            - Capital Segment Allocation Absolute  - No Stress                                                                                                                    ||"
  419.         );

  421.         System.out.println (
  422.             "\t|            - Capital Segment Allocation Absolute  - Total                                                                                                                        ||"
  423.         );

  425.         System.out.println (
  426.             "\t|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------||"
  427.         );

  429.         System.out.println (
  430.             "\t|            - Capital Segment Coordinate                                                                                                                                          ||"
  431.         );

  433.         System.out.println (
  434.             "\t|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------||"
  435.         );

  437.         for (int capitalUnitIndex = 0;
  438.             capitalUnitIndex < capitalUnitArray.length;
  439.             ++capitalUnitIndex)
  440.         {
  441.             String capitalUnitFQN = capitalUnitArray[capitalUnitIndex].coordinate().fullyQualifiedName();

  443.             EntityComponentCapital entityComponentCapital = entityComponentCapitalMap.get (
  444.                 capitalUnitFQN
  445.             );

  447.             EntityCapital entityComponentCapitalNoStress = entityComponentCapital.noStress();

  449.             EntityCapital entityComponentCapitalTotal = entityComponentCapital.total();

  451.             EntityCapital entityComponentCapitalIBSST = entityComponentCapital.idiosyncratic();

  453.             EntityCapital entityComponentCapitalCBSST = entityComponentCapital.correlated();

  455.             EntityCapital entityComponentCapitalGSST = entityComponentCapital.systemic();

  457.             System.out.println (
  458.                 "\t|    " +
  459.                 FormatUtil.FormatDouble (entityComponentCapitalGSST.fractional(), 2, 2, 100.) + "% |" +
  460.                 FormatUtil.FormatDouble (entityComponentCapitalCBSST.fractional(), 2, 2, 100.) + "% |" +
  461.                 FormatUtil.FormatDouble (entityComponentCapitalIBSST.fractional(), 2, 2, 100.) + "% |" +
  462.                 FormatUtil.FormatDouble (entityComponentCapitalNoStress.fractional(), 2, 2, 100.) + "% | " +
  463.                 FormatUtil.FormatDouble (entityComponentCapitalTotal.fractional(), 2, 2, 100.) + "% || " +
  464.                 FormatUtil.FormatDouble (entityComponentCapitalGSST.absolute(), 10, 2, 1.) + " | " +
  465.                 FormatUtil.FormatDouble (entityComponentCapitalCBSST.absolute(), 10, 2, 1.) + " | " +
  466.                 FormatUtil.FormatDouble (entityComponentCapitalIBSST.absolute(), 10, 2, 1.) + " | " +
  467.                 FormatUtil.FormatDouble (entityComponentCapitalNoStress.absolute(), 10, 2, 1.) + " | " +
  468.                 FormatUtil.FormatDouble (entityComponentCapitalTotal.absolute(), 10, 2, 1.) +
  469.                     " <= " + capitalUnitFQN
  470.             );
  471.         }

  473.         System.out.println (
  474.             "\t|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------||"
  475.         );

  477.         EntityCapital entityCapitalGSST = entityComponentCapitalAssignment.systemic();

  479.         EntityCapital entityCapitalCBSST = entityComponentCapitalAssignment.correlated();

  481.         EntityCapital entityCapitalIBSST = entityComponentCapitalAssignment.idiosyncratic();

  483.         EntityCapital entityCapitalNoStress = entityComponentCapitalAssignment.noStress();

  485.         System.out.println (
  486.             "\t|    " +
  487.             FormatUtil.FormatDouble (entityCapitalGSST.fractional(), 2, 2, 100.) + "% |" +
  488.             FormatUtil.FormatDouble (entityCapitalCBSST.fractional(), 2, 2, 100.) + "% |" +
  489.             FormatUtil.FormatDouble (entityCapitalIBSST.fractional(), 2, 2, 100.) + "% |" +
  490.             FormatUtil.FormatDouble (entityCapitalNoStress.fractional(), 2, 2, 100.) + "% |" +
  491.             FormatUtil.FormatDouble (1., 2, 2, 100.) + "% || " +
  492.             FormatUtil.FormatDouble (entityCapitalGSST.absolute(), 10, 2, 1.) + " | " +
  493.             FormatUtil.FormatDouble (entityCapitalCBSST.absolute(), 10, 2, 1.) + " | " +
  494.             FormatUtil.FormatDouble (entityCapitalIBSST.absolute(), 10, 2, 1.) + " | " +
  495.             FormatUtil.FormatDouble (entityCapitalNoStress.absolute(), 10, 2, 1.) + " | " +
  496.             FormatUtil.FormatDouble (entityComponentCapitalAssignment.allocatedTotalCapital(), 10, 2, 1.) +
  497.             " <= TOTAL"
  498.         );

  500.         System.out.println (
  501.             "\t|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------||"
  502.         );

  504.         System.out.println();

  506.         EntityElasticityAttribution elasticityAttribution =
  507.             entityComponentCapitalAssignment.elasticityAttribution();

  509.         double fixedEntityCapital = elasticityAttribution.fixed();

  511.         double floatingEntityCapital = elasticityAttribution.floating() * unitFloatBeta;

  513.         System.out.println (
  514.             "\t|-----------------------------------------------------------------------------||"
  515.         );

  517.         System.out.println (
  518.             "\t| FIXED    Entity Capital                =>  " +
  519.             FormatUtil.FormatDouble (fixedEntityCapital, 10, 2, 1.) + " | " +
  520.             FormatUtil.FormatDouble (fixedEntityCapital / allocatedBetaCapital, 2, 2, 100.) + "%"
  521.         );

  523.         System.out.println (
  524.             "\t| FLOATING Entity Capital                =>  " +
  525.             FormatUtil.FormatDouble (floatingEntityCapital, 10, 2, 1.) + " | " +
  526.             FormatUtil.FormatDouble (floatingEntityCapital / allocatedBetaCapital, 2, 2, 100.) + "%"
  527.         );

  529.         System.out.println (
  530.             "\t|-----------------------------------------------------------------------------||"
  531.         );

  533.         System.out.println (
  534.             "\t| Allocated Beta Capital                 =>  " +
  535.             FormatUtil.FormatDouble (allocatedBetaCapital, 10, 2, 1.)
  536.         );

  538.         System.out.println (
  539.             "\t| Unit Float Beta                        =>  " +
  540.             FormatUtil.FormatDouble (unitFloatBeta, 1, 4, 1.)
  541.         );

  543.         System.out.println (
  544.             "\t|-----------------------------------------------------------------------------||"
  545.         );

  547.         System.out.println();
  548.     }

  550.     public static final void main (
  551.         final String[] argumentArray)
  552.         throws Exception
  553.     {
  554.         EnvManager.InitEnv ("");

  556.         double capitalUnitNotional = 10000.;
  557.         String capitalSegmentFQN = "Converts";
  558.         String[] regionArray =
  559.         {
  560.             "ASIA",
  561.             "EMEA",
  562.             "NORTH AMERICA",
  563.         };
  564.         String[] riskTypeArray =
  565.         {
  566.             "Trading",
  567.             "Trading",
  568.             "Trading",
  569.         };

  571.         CorrelationCategoryBetaManager correlationCategoryBetaManager =
  572.             CorrelationCategoryBetaManager.TwoBetaFixedFloat (
  573.                 1.0
  574.             );

  576.         SimulationControl simulationControl = SimulationControl.Standard();

  578.         SimulationPnLControl simulationPnLControl = SimulationPnLControl.Standard();

  580.         Map<String, EntityCapitalAssignmentSetting> entityCapitalAssignmentSettingMap =
  581.             new CaseInsensitiveHashMap<EntityCapitalAssignmentSetting>();

  583.         CapitalUnit[] capitalUnitArray = new CapitalUnit[riskTypeArray.length];

  585.         for (int capitalUnitIndex = 0;
  586.             capitalUnitIndex < riskTypeArray.length;
  587.             ++capitalUnitIndex)
  588.         {
  589.             capitalUnitArray[capitalUnitIndex] = MakeCapitalUnit (
  590.                 capitalSegmentFQN,
  591.                 regionArray[capitalUnitIndex],
  592.                 riskTypeArray[capitalUnitIndex],
  593.                 capitalUnitNotional
  594.             );

  596.             entityCapitalAssignmentSettingMap.put (
  597.                 capitalUnitArray[capitalUnitIndex].coordinate().fullyQualifiedName(),
  598.                 HighLowUniformBeta()
  599.             );
  600.         }

  602.         System.out.println ("\t|------------------------------------------------------------------");

  604.         System.out.println ("\t|     3 Beta Fixed/Float/Float Segment Capital Unit Coordinates    ");

  606.         System.out.println ("\t|------------------------------------------------------------------");

  608.         System.out.println ("\t|    L -> R:");

  610.         System.out.println ("\t|           - Correlation Category (1=HIGH; 2=MEDIUM; 3=LOW)");

  612.         System.out.println ("\t|           - Beta Type (0=FIXED; 1=FLOAT)");

  614.         System.out.println ("\t|           - Beta Value");

  616.         System.out.println ("\t|------------------------------------------------------------------");

  618.         for (int capitalUnitIndex = 0;
  619.             capitalUnitIndex < riskTypeArray.length;
  620.             ++capitalUnitIndex)
  621.         {
  622.             String capitalUnitFQN = capitalUnitArray[capitalUnitIndex].coordinate().fullyQualifiedName();

  624.             int capitalEntityCorrelationCategory = entityCapitalAssignmentSettingMap.get (
  625.                 capitalUnitFQN
  626.             ).allocationCorrelationCategory();

  628.             CorrelationCategoryBeta correlationCategoryBeta =
  629.                 correlationCategoryBetaManager.correlationCategoryBeta (
  630.                     capitalEntityCorrelationCategory
  631.                 );

  633.             System.out.println (
  634.                 "\t|    " + capitalEntityCorrelationCategory + " | " +
  635.                 correlationCategoryBeta.elasticity() + " | " +
  636.                 FormatUtil.FormatDouble (correlationCategoryBeta.loading(), 1, 1, 1.) + " <= " +
  637.                 capitalUnitFQN
  638.             );
  639.         }

  641.         System.out.println ("\t|------------------------------------------------------------------");

  643.         System.out.println ("\t|    [CAPITAL SEGMENT] => " + capitalSegmentFQN);

  645.         System.out.println ("\t|------------------------------------------------------------------");

  647.         System.out.println();

  649.         CapitalSegmentStandaloneMarginal capitalSegmentStandaloneMarginal = new ManagedSegmentL1 (
  650.             new CapitalSegmentCoordinate (
  651.                 capitalSegmentFQN
  652.             ),
  653.             capitalUnitArray
  654.         ).pathEnsemble (
  655.             simulationControl,
  656.             simulationPnLControl
  657.         ).marginalStandalonePnLAttribution (
  658.             simulationPnLControl.stress().expectedShortfallConfidenceLevel()
  659.         );

  661.         EntityComponentCapitalAssignment entityComponentCapitalAssignment =
  662.             capitalSegmentStandaloneMarginal.betaAllocation (
  663.                 new CapitalAllocationControl (
  664.                     false,
  665.                     null,
  666.                     correlationCategoryBetaManager,
  667.                     entityCapitalAssignmentSettingMap
  668.                 )
  669.             );

  671.         Map<String, EntityComponentCapital> entityComponentCapitalMap =
  672.             entityComponentCapitalAssignment.entityComponentCapitalMap();

  674.         Map<String, PnLAttribution> standalonePnLAttributionMap =
  675.             capitalSegmentStandaloneMarginal.standalonePnLAttributionMap();

  677.         for (Map.Entry<String, PnLAttribution> standalonePnLAttributionEntry :
  678.             standalonePnLAttributionMap.entrySet())
  679.         {
  680.             String capitalUnitCoordinate = standalonePnLAttributionEntry.getKey();

  682.             DisplayPnLAttribution (
  683.                 capitalUnitCoordinate,
  684.                 new AllocatedPnLAttribution (
  685.                     standalonePnLAttributionEntry.getValue(),
  686.                     entityComponentCapitalMap.get (
  687.                         capitalUnitCoordinate
  688.                     )
  689.                 )
  690.             );
  691.         }

  693.         Allocate (
  694.             capitalUnitArray,
  695.             entityComponentCapitalAssignment
  696.         );

  698.         EnvManager.TerminateEnv();
  699.     }
  700. }
Created with JaCoCo 0.7.9.201702052155