CreditIndexAPI.java

  1. package org.drip.service.product;

  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>CreditIndexAPI</i> contains the Functionality associated with the Horizon Analysis of the CDS Index.
  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/ComputationSupportLibrary.md">Computation Support</a></li>
  87.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/service/README.md">Environment, Product/Definition Containers, and Scenario/State Manipulation APIs</a></li>
  88.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/service/product/README.md">Product Horizon PnL Attribution Decomposition</a></li>
  89.  *  </ul>
  90.  * <br><br>
  91.  * 
  92.  * @author Lakshmi Krishnamurthy
  93.  */

  95. public class CreditIndexAPI {

  97.     static class ParCDS {
  98.         double _dblFairPremium = java.lang.Double.NaN;
  99.         double _dblFixedCoupon = java.lang.Double.NaN;
  100.         org.drip.product.definition.CreditDefaultSwap _cds = null;

  102.         ParCDS (
  103.             final org.drip.product.definition.CreditDefaultSwap cds,
  104.             final double dblFixedCoupon,
  105.             final double dblFairPremium)
  106.         {
  107.             _cds = cds;
  108.             _dblFixedCoupon = dblFixedCoupon;
  109.             _dblFairPremium = dblFairPremium;
  110.         }

  112.         double fairPremium()
  113.         {
  114.             return _dblFairPremium;
  115.         }

  117.         double fixedCoupon()
  118.         {
  119.             return _dblFixedCoupon;
  120.         }

  122.         org.drip.product.definition.CreditDefaultSwap cds()
  123.         {
  124.             return _cds;
  125.         }
  126.     };

  128.     private static final ParCDS HorizonCreditIndex (
  129.         final org.drip.state.discount.DiscountCurve dc,
  130.         final org.drip.state.credit.CreditCurve cc,
  131.         final java.lang.String strFullCreditIndexName)
  132.     {
  133.         org.drip.market.otc.CreditIndexConvention cic =
  134.             org.drip.market.otc.CreditIndexConventionContainer.ConventionFromFullName
  135.                 (strFullCreditIndexName);

  137.         if (null == cic) return null;

  139.         org.drip.product.definition.CreditDefaultSwap cdsIndex = cic.indexCDS();

  141.         if (null == cdsIndex) return null;

  143.         org.drip.param.market.CurveSurfaceQuoteContainer csqc = new
  144.             org.drip.param.market.CurveSurfaceQuoteContainer();

  146.         if (!csqc.setFundingState ((org.drip.state.discount.MergedDiscountForwardCurve) dc) ||
  147.             !csqc.setCreditState (cc))
  148.             return null;

  150.         try {
  151.             return new ParCDS (cdsIndex, cic.fixedCoupon(), 0.0001 * cdsIndex.measureValue
  152.                 (org.drip.param.valuation.ValuationParams.Spot (dc.epoch().julian()), null, csqc, null,
  153.                     "FairPremium"));
  154.         } catch (java.lang.Exception e) {
  155.             e.printStackTrace();
  156.         }

  158.         return null;
  159.     }

  161.     private static final org.drip.historical.attribution.CDSMarketSnap MarketValuationSnap (
  162.         final org.drip.product.definition.CreditDefaultSwap cds,
  163.         final org.drip.state.discount.DiscountCurve dc,
  164.         final org.drip.state.credit.CreditCurve cc,
  165.         final org.drip.param.market.CurveSurfaceQuoteContainer csqc,
  166.         final double dblRollDownFairPremium)
  167.     {
  168.         if (!csqc.setFundingState ((org.drip.state.discount.MergedDiscountForwardCurve) dc) ||
  169.             !csqc.setCreditState (cc))
  170.             return null;

  172.         org.drip.analytics.date.JulianDate dt = dc.epoch();

  174.         java.util.Map<java.lang.String, java.lang.Double> mapCDS = cds.value
  175.             (org.drip.param.valuation.ValuationParams.Spot (dt.julian()), null, csqc, null);

  177.         if (null == mapCDS || !mapCDS.containsKey ("Accrued") || !mapCDS.containsKey ("CleanDV01") ||
  178.             !mapCDS.containsKey ("CleanPV") || !mapCDS.containsKey ("CleanCouponPV") || !mapCDS.containsKey
  179.                 ("CumulativeCouponAmount") || !mapCDS.containsKey ("FairPremium") || !mapCDS.containsKey
  180.                     ("LossPV"))
  181.             return null;

  183.         double dblCleanPV = mapCDS.get ("CleanPV");

  185.         double dblFairPremium = 0.0001 * mapCDS.get ("FairPremium");

  187.         org.drip.analytics.date.JulianDate dtEffective = cds.effectiveDate();

  189.         double dblFairPremiumSensitivity = 10000. * mapCDS.get ("CleanDV01");

  191.         try {
  192.             org.drip.historical.attribution.CDSMarketSnap cdsms = new
  193.                 org.drip.historical.attribution.CDSMarketSnap (dt, dblCleanPV);

  195.             return cdsms.setEffectiveDate (dtEffective) && cdsms.setMaturityDate (cds.maturityDate()) &&
  196.                 cdsms.setCleanDV01 (dblFairPremiumSensitivity) && cdsms.setCurrentFairPremium
  197.                     (dblFairPremium) && cdsms.setRollDownFairPremium (dblRollDownFairPremium) &&
  198.                         cdsms.setAccrued (mapCDS.get ("Accrued")) && cdsms.setCumulativeCouponAmount
  199.                             (mapCDS.get ("CumulativeCouponAmount")) && cdsms.setCreditLabel
  200.                                 (cds.creditLabel().fullyQualifiedName()) && cdsms.setRecoveryRate
  201.                                     (cds.recovery (dtEffective.julian(), cc)) && cdsms.setCouponPV
  202.                                         (mapCDS.get ("CleanCouponPV")) && cdsms.setLossPV (mapCDS.get
  203.                                             ("LossPV")) && cdsms.setFairPremiumMarketFactor (dblFairPremium,
  204.                                                 -1. * dblFairPremiumSensitivity, dblRollDownFairPremium) ?
  205.                                                     cdsms : null;
  206.         } catch (java.lang.Exception e) {
  207.             e.printStackTrace();
  208.         }

  210.         return null;
  211.     }

  213.     private static final double RollDownFairPremium (
  214.         final org.drip.product.definition.CreditDefaultSwap cds,
  215.         final int iSpotDate,
  216.         final org.drip.state.discount.DiscountCurve dcPrevious,
  217.         final org.drip.state.credit.CreditCurve ccPrevious,
  218.         final org.drip.param.market.CurveSurfaceQuoteContainer csqc)
  219.         throws java.lang.Exception
  220.     {
  221.         if (!csqc.setFundingState ((org.drip.state.discount.MergedDiscountForwardCurve) dcPrevious) ||
  222.             !csqc.setCreditState (ccPrevious))
  223.             throw new java.lang.Exception ("CreditIndexAPI::RollDownFairPremium => Invalid Inputs");

  225.         java.util.Map<java.lang.String, java.lang.Double> mapCDS = cds.value
  226.             (org.drip.param.valuation.ValuationParams.Spot (iSpotDate), null, csqc, null);

  228.         if (null == mapCDS || !mapCDS.containsKey ("FairPremium"))
  229.             throw new java.lang.Exception ("CreditIndexAPI::RollDownFairPremium => Invalid Inputs");

  231.         return 0.0001 * mapCDS.get ("FairPremium");
  232.     }

  234.     /**
  235.      * Generate the CDS Horizon Change Attribution
  236.      * 
  237.      * @param dcFirst The First Discount Curve
  238.      * @param ccFirst The First Credit Curve
  239.      * @param dcSecond The Second Discount Curve
  240.      * @param ccSecond The Second Credit Curve
  241.      * @param strFullCreditIndexName The Full Credit Index Name
  242.      * 
  243.      * @return The CDS Horizon Change Attribution
  244.      */

  246.     public static final org.drip.historical.attribution.PositionChangeComponents HorizonChangeAttribution (
  247.         final org.drip.state.discount.DiscountCurve dcFirst,
  248.         final org.drip.state.credit.CreditCurve ccFirst,
  249.         final org.drip.state.discount.DiscountCurve dcSecond,
  250.         final org.drip.state.credit.CreditCurve ccSecond,
  251.         final java.lang.String strFullCreditIndexName)
  252.     {
  253.         if (null == dcFirst || null == ccFirst || null == dcSecond || null == ccSecond) return null;

  255.         int iFirstDate = dcFirst.epoch().julian();

  257.         int iSecondDate = dcSecond.epoch().julian();

  259.         java.lang.String strCurrency = dcSecond.currency();

  261.         if (!strCurrency.equalsIgnoreCase (dcFirst.currency()) || iFirstDate >= iSecondDate ||
  262.             ccFirst.epoch().julian() != iFirstDate || ccSecond.epoch().julian() != iSecondDate)
  263.             return null;

  265.         ParCDS parCDS = HorizonCreditIndex (dcFirst, ccFirst, strFullCreditIndexName);

  267.         if (null == parCDS) return null;

  269.         org.drip.product.definition.CreditDefaultSwap cds = parCDS.cds();

  271.         if (null == cds) return null;

  273.         double dblFixedCoupon = parCDS.fixedCoupon();

  275.         double dblInitialFairPremium = parCDS.fairPremium();

  277.         org.drip.param.market.CurveSurfaceQuoteContainer csqc = new
  278.             org.drip.param.market.CurveSurfaceQuoteContainer();

  280.         double dblRollDownFairPremium = java.lang.Double.NaN;

  282.         try {
  283.             dblRollDownFairPremium = RollDownFairPremium (cds, iSecondDate, dcFirst, ccFirst, csqc);
  284.         } catch (java.lang.Exception e) {
  285.             e.printStackTrace();

  287.             return null;
  288.         }

  290.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblRollDownFairPremium)) return null;

  292.         org.drip.historical.attribution.CDSMarketSnap cdsmsFirst = MarketValuationSnap (cds, dcFirst,
  293.             ccFirst, csqc, dblRollDownFairPremium);

  295.         if (null == cdsmsFirst || !cdsmsFirst.setInitialFairPremium (dblInitialFairPremium) ||
  296.             !cdsmsFirst.setFixedCoupon (dblFixedCoupon))
  297.             return null;

  299.         org.drip.historical.attribution.CDSMarketSnap cdsmsSecond = MarketValuationSnap (cds, dcSecond,
  300.             ccSecond, csqc, dblRollDownFairPremium);

  302.         if (null == cdsmsSecond || !cdsmsSecond.setInitialFairPremium (dblInitialFairPremium) ||
  303.             !cdsmsSecond.setFixedCoupon (dblFixedCoupon))
  304.             return null;

  306.         try {
  307.             return new org.drip.historical.attribution.PositionChangeComponents (false, cdsmsFirst,
  308.                 cdsmsSecond, cdsmsSecond.cumulativeCouponAmount() - cdsmsFirst.cumulativeCouponAmount(),
  309.                     null);
  310.         } catch (java.lang.Exception e) {
  311.             e.printStackTrace();
  312.         }

  314.         return null;
  315.     }

  317.     /**
  318.      * Generate the Funding/Credit Curve Horizon Metrics
  319.      * 
  320.      * @param adtSpot Array of Spot
  321.      * @param iHorizonGap The Horizon Gap
  322.      * @param astrFundingFixingMaturityTenor Array of Funding Fixing Maturity Tenors
  323.      * @param aadblFundingFixingQuote Double Array of Funding Fixing Swap Rates
  324.      * @param astrFullCreditIndexName Array of the Full Credit Index Names
  325.      * @param adblCreditIndexQuotedSpread Array of the Quoted Spreads
  326.      * 
  327.      * @return The Funding/Credit Curve Horizon Metrics
  328.      */

  330.     public static final java.util.List<org.drip.historical.attribution.PositionChangeComponents>
  331.         HorizonChangeAttribution (
  332.             final org.drip.analytics.date.JulianDate[] adtSpot,
  333.             final int iHorizonGap,
  334.             final java.lang.String[] astrFundingFixingMaturityTenor,
  335.             final double[][] aadblFundingFixingQuote,
  336.             final java.lang.String[] astrFullCreditIndexName,
  337.             final double[] adblCreditIndexQuotedSpread)
  338.     {
  339.         if (null == adtSpot || 0 >= iHorizonGap || null == astrFundingFixingMaturityTenor || null ==
  340.             aadblFundingFixingQuote || null == astrFullCreditIndexName || null ==
  341.                 adblCreditIndexQuotedSpread)
  342.             return null;

  344.         int iNumClose = adtSpot.length;
  345.         int iNumFundingInstrument = astrFundingFixingMaturityTenor.length;

  347.         java.util.List<org.drip.historical.attribution.PositionChangeComponents> lsPCC = new
  348.             java.util.ArrayList<org.drip.historical.attribution.PositionChangeComponents>();

  350.         for (int i = iHorizonGap; i < iNumClose; ++i) {
  351.             int iNumSecondFundingQuote = null == aadblFundingFixingQuote[i] ? 0 :
  352.                 aadblFundingFixingQuote[i].length;
  353.             int iNumFirstFundingQuote = null == aadblFundingFixingQuote[i - iHorizonGap] ? 0 :
  354.                 aadblFundingFixingQuote[i - iHorizonGap].length;

  356.             if (0 == iNumFirstFundingQuote || iNumFirstFundingQuote != iNumFundingInstrument || 0 ==
  357.                 iNumSecondFundingQuote || iNumSecondFundingQuote != iNumFundingInstrument)
  358.                 continue;

  360.             org.drip.market.otc.CreditIndexConvention cic =
  361.                 org.drip.market.otc.CreditIndexConventionContainer.ConventionFromFullName
  362.                     (astrFullCreditIndexName[i]);

  364.             if (null == cic) return null;

  366.             java.lang.String strCurrency = cic.currency();

  368.             org.drip.product.definition.CreditDefaultSwap cdsIndex = cic.indexCDS();

  370.             org.drip.state.discount.MergedDiscountForwardCurve dcFundingFixingFirst =
  371.                 org.drip.service.template.LatentMarketStateBuilder.FundingCurve (adtSpot[i - iHorizonGap],
  372.                     strCurrency, null, null, "ForwardRate", null, "ForwardRate",
  373.                         astrFundingFixingMaturityTenor, aadblFundingFixingQuote[i - iHorizonGap], "SwapRate",
  374.                             org.drip.service.template.LatentMarketStateBuilder.SHAPE_PRESERVING);

  376.             org.drip.state.credit.CreditCurve ccFirst =
  377.                 org.drip.service.template.LatentMarketStateBuilder.CreditCurve (adtSpot[i - iHorizonGap], new
  378.                     org.drip.product.definition.CreditDefaultSwap[] {cdsIndex}, new double[]
  379.                         {adblCreditIndexQuotedSpread[i - iHorizonGap]}, "FairPremium", dcFundingFixingFirst);

  381.             org.drip.state.discount.MergedDiscountForwardCurve dcFundingFixingSecond =
  382.                 org.drip.service.template.LatentMarketStateBuilder.FundingCurve (adtSpot[i], strCurrency,
  383.                     null, null, "ForwardRate", null, "ForwardRate", astrFundingFixingMaturityTenor,
  384.                         aadblFundingFixingQuote[i], "SwapRate",
  385.                             org.drip.service.template.LatentMarketStateBuilder.SHAPE_PRESERVING);

  387.             org.drip.state.credit.CreditCurve ccSecond =
  388.                 org.drip.service.template.LatentMarketStateBuilder.CreditCurve (adtSpot[i], new
  389.                     org.drip.product.definition.CreditDefaultSwap[] {cdsIndex}, new double[]
  390.                         {adblCreditIndexQuotedSpread[i]}, "FairPremium", dcFundingFixingSecond);

  392.             lsPCC.add (HorizonChangeAttribution (dcFundingFixingFirst, ccFirst, dcFundingFixingSecond,
  393.                 ccSecond, astrFullCreditIndexName[i]));
  394.         }

  396.         return lsPCC;
  397.     }
  398. }
Created with JaCoCo 0.7.9.201702052155