PathVertexForwardRealization.java

  1. package org.drip.sample.govviemc;

  3. import java.util.List;

  5. import org.drip.analytics.date.*;
  6. import org.drip.analytics.support.Helper;
  7. import org.drip.measure.crng.RandomNumberGenerator;
  8. import org.drip.measure.discrete.*;
  9. import org.drip.measure.dynamics.DiffusionEvaluatorLogarithmic;
  10. import org.drip.measure.process.DiffusionEvolver;
  11. import org.drip.measure.realization.*;
  12. import org.drip.numerical.common.FormatUtil;
  13. import org.drip.service.env.EnvManager;
  14. import org.drip.service.template.LatentMarketStateBuilder;
  15. import org.drip.state.curve.BasisSplineGovvieYield;
  16. import org.drip.state.govvie.GovvieCurve;
  17. import org.drip.state.nonlinear.FlatForwardGovvieCurve;

  19. /*
  20.  * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  21.  */

  23. /*!
  24.  * Copyright (C) 2019 Lakshmi Krishnamurthy
  25.  * Copyright (C) 2018 Lakshmi Krishnamurthy
  26.  * Copyright (C) 2017 Lakshmi Krishnamurthy
  27.  * 
  28.  *  This file is part of DROP, an open-source library targeting risk, transaction costs, exposure, margin
  29.  *      calculations, valuation adjustment, and portfolio construction within and across fixed income,
  30.  *      credit, commodity, equity, FX, and structured products.
  31.  *  
  32.  *      https://lakshmidrip.github.io/DROP/
  33.  *  
  34.  *  DROP is composed of three modules:
  35.  *  
  36.  *  - DROP Analytics Core - https://lakshmidrip.github.io/DROP-Analytics-Core/
  37.  *  - DROP Portfolio Core - https://lakshmidrip.github.io/DROP-Portfolio-Core/
  38.  *  - DROP Numerical Core - https://lakshmidrip.github.io/DROP-Numerical-Core/
  39.  * 
  40.  *  DROP Analytics Core implements libraries for the following:
  41.  *  - Fixed Income Analytics
  42.  *  - Asset Backed Analytics
  43.  *  - XVA Analytics
  44.  *  - Exposure and Margin Analytics
  45.  * 
  46.  *  DROP Portfolio Core implements libraries for the following:
  47.  *  - Asset Allocation Analytics
  48.  *  - Transaction Cost Analytics
  49.  * 
  50.  *  DROP Numerical Core implements libraries for the following:
  51.  *  - Statistical Learning
  52.  *  - Numerical Optimizer
  53.  *  - Spline Builder
  54.  *  - Algorithm Support
  55.  * 
  56.  *  Documentation for DROP is Spread Over:
  57.  * 
  58.  *  - Main                     => https://lakshmidrip.github.io/DROP/
  59.  *  - Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
  60.  *  - GitHub                   => https://github.com/lakshmiDRIP/DROP
  61.  *  - Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
  62.  *  - Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
  63.  *  - Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
  64.  *  - Release Versions         => https://lakshmidrip.github.io/DROP/version.html
  65.  *  - Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
  66.  *  - Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
  67.  *  - JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
  68.  *  - Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html
  69.  * 
  70.  *  Licensed under the Apache License, Version 2.0 (the "License");
  71.  *      you may not use this file except in compliance with the License.
  72.  *   
  73.  *  You may obtain a copy of the License at
  74.  *      http://www.apache.org/licenses/LICENSE-2.0
  75.  *  
  76.  *  Unless required by applicable law or agreed to in writing, software
  77.  *      distributed under the License is distributed on an "AS IS" BASIS,
  78.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  79.  *  
  80.  *  See the License for the specific language governing permissions and
  81.  *      limitations under the License.
  82.  */

  84. /**
  85.  * <i>PathVertexForwardRealization</i> demonstrates the Simulations of the Per-Path Forward Vertex Govvie
  86.  * Yield Nodes.
  87.  *  
  88.  * <br><br>
  89.  *  <ul>
  90.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/AnalyticsCore.md">Analytics Core Module</a></li>
  91.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/FixedIncomeAnalyticsLibrary.md">Fixed Income Analytics Library</a></li>
  92.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/README.md">Sample</a></li>
  93.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/govviemc/README.md">Govvie Curve Monte Carlo Runs</a></li>
  94.  *  </ul>
  95.  * <br><br>
  96.  * 
  97.  * @author Lakshmi Krishnamurthy
  98.  */

  100. public class PathVertexForwardRealization {

  102.     private static final GovvieCurve GovvieCurve (
  103.         final JulianDate dtSpot,
  104.         final String strCode,
  105.         final String[] astrTenor,
  106.         final double[] adblCoupon,
  107.         final double[] adblYield)
  108.         throws Exception
  109.     {
  110.         JulianDate[] adtMaturity = new JulianDate[astrTenor.length];
  111.         JulianDate[] adtEffective = new JulianDate[astrTenor.length];

  113.         for (int i = 0; i < astrTenor.length; ++i) {
  114.             adtEffective[i] = dtSpot;

  116.             adtMaturity[i] = dtSpot.addTenor (astrTenor[i]);
  117.         }

  119.         return LatentMarketStateBuilder.GovvieCurve (
  120.             strCode,
  121.             dtSpot,
  122.             adtEffective,
  123.             adtMaturity,
  124.             adblCoupon,
  125.             adblYield,
  126.             "Yield",
  127.             LatentMarketStateBuilder.SHAPE_PRESERVING
  128.         );
  129.     }

  131.     public static final void main (
  132.         final String[] astrArgs)
  133.         throws Exception
  134.     {
  135.         EnvManager.InitEnv ("");

  137.         JulianDate dtSpot = DateUtil.CreateFromYMD (
  138.             2017,
  139.             DateUtil.MARCH,
  140.             24
  141.         );

  143.         int iNumPath = 50;
  144.         int iNumVertex = 1;
  145.         double dblTimeWidth = 1.0;
  146.         double dblVolatility = 0.10;
  147.         String strTreasuryCode = "UST";

  149.         String[] astrTenor = new String[] {
  150.             "01Y",
  151.             "02Y",
  152.             "03Y",
  153.             "05Y",
  154.             "07Y",
  155.             "10Y",
  156.             "20Y",
  157.             "30Y"
  158.         };

  160.         double[] adblTreasuryCoupon = new double[] {
  161.             0.0100,
  162.             0.0100,
  163.             0.0125,
  164.             0.0150,
  165.             0.0200,
  166.             0.0225,
  167.             0.0250,
  168.             0.0300
  169.         };

  171.         double[] adblTreasuryYield = new double[] {
  172.             0.0083, //  1Y
  173.             0.0122, //  2Y
  174.             0.0149, //  3Y
  175.             0.0193, //  5Y
  176.             0.0227, //  7Y
  177.             0.0248, // 10Y
  178.             0.0280, // 20Y
  179.             0.0308  // 30Y
  180.         };

  182.         BasisSplineGovvieYield bsgyGround = (BasisSplineGovvieYield) GovvieCurve (
  183.             dtSpot,
  184.             strTreasuryCode,
  185.             astrTenor,
  186.             adblTreasuryCoupon,
  187.             adblTreasuryYield
  188.         );

  190.         double[] adblInitialForward = bsgyGround.flatForward (astrTenor).nodeValues();

  192.         DiffusionEvolver de = new DiffusionEvolver (
  193.             DiffusionEvaluatorLogarithmic.Standard (
  194.                 0.,
  195.                 dblVolatility
  196.             )
  197.         );

  199.         int iNumDimension = astrTenor.length;
  200.         DiffusionEvolver[] aDE = new DiffusionEvolver[iNumDimension];
  201.         double[][] aadblCorrelation = new double[iNumDimension][iNumDimension];
  202.         double[][] aadblPathForwardYield = new double[iNumVertex][iNumDimension];

  204.         for (int i = 0; i < iNumDimension; ++i) {
  205.             aDE[i] = de;

  207.             for (int j = 0; j < iNumDimension; ++j)
  208.                 aadblCorrelation[i][j] = i == j ? 1. : 0.;
  209.         }

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

  213.         String strDump = "\t|| TENOR ";

  215.         for (int i = 0; i < iNumDimension; ++i)
  216.             strDump += " |   " + astrTenor[i] + "  ";

  218.         for (int i = 0; i < iNumDimension; ++i)
  219.             strDump += " |   " + astrTenor[i] + "  ";

  221.         System.out.println (strDump + " ||");

  223.         strDump = "\t|| " + FormatUtil.FormatDouble (0, 3, 0, 1.) + " => ";

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

  227.         for (int i = 0; i < iNumDimension; ++i)
  228.             strDump += " " + FormatUtil.FormatDouble (adblInitialForward[i], 1, 3, 100.) + "% |";

  230.         for (int iDimension = 0; iDimension < iNumDimension; ++iDimension)
  231.             strDump = strDump + " " + FormatUtil.FormatDouble (bsgyGround.yield (astrTenor[iDimension]), 1, 3, 100.) + "% |";

  233.         System.out.println (strDump + "|");

  235.         CorrelatedPathVertexDimension cpvd = new CorrelatedPathVertexDimension (
  236.             new RandomNumberGenerator(),
  237.             aadblCorrelation,
  238.             iNumVertex,
  239.             iNumPath,
  240.             false,
  241.             null
  242.         );

  244.         VertexRd[] aVertexRd = cpvd.multiPathVertexRd();

  246.         for (int iPath = 0; iPath < iNumPath; ++iPath) {
  247.             List<double[]> lsVertexRd = aVertexRd[iPath].vertexList();

  249.             JumpDiffusionEdgeUnit[][] aaUR = new JumpDiffusionEdgeUnit[iNumDimension][iNumVertex];
  250.             JumpDiffusionVertex[][] aaJDV = new JumpDiffusionVertex[iNumDimension][iNumVertex + 1];

  252.             for (int iTimeVertex = 0; iTimeVertex < iNumVertex; ++iTimeVertex) {
  253.                 double[] adblRd = lsVertexRd.get (iTimeVertex);

  255.                 for (int iDimension = 0; iDimension < iNumDimension; ++iDimension)
  256.                     aaUR[iDimension][iTimeVertex] = new JumpDiffusionEdgeUnit (
  257.                         dblTimeWidth,                           
  258.                         adblRd[iDimension],
  259.                         0.
  260.                     );
  261.             }

  263.             for (int iDimension = 0; iDimension < iNumDimension; ++iDimension)
  264.                 aaJDV[iDimension] = aDE[iDimension].vertexSequence (
  265.                     new JumpDiffusionVertex (
  266.                         0.,
  267.                         adblInitialForward[iDimension],
  268.                         0.,
  269.                         false
  270.                     ),
  271.                     aaUR[iDimension],
  272.                     dblTimeWidth
  273.                 );

  275.             for (int iTimeVertex = 0; iTimeVertex < iNumVertex; ++iTimeVertex) {
  276.                 strDump = "\t|| " + FormatUtil.FormatDouble (iTimeVertex + 1, 3, 0, 1.) + " => ";

  278.                 for (int iDimension = 0; iDimension < iNumDimension; ++iDimension)
  279.                     strDump = strDump + " " + FormatUtil.FormatDouble (
  280.                         aadblPathForwardYield[iTimeVertex][iDimension] = aaJDV[iDimension][iTimeVertex].value(), 1, 3, 100.
  281.                     ) + "% |";

  283.                 JulianDate dtEvent = dtSpot.addYears (iTimeVertex + 1);

  285.                 FlatForwardGovvieCurve ffgc = new FlatForwardGovvieCurve (
  286.                     dtEvent.julian(),
  287.                     strTreasuryCode,
  288.                     bsgyGround.currency(),
  289.                     Helper.TenorToDate (
  290.                         dtEvent,
  291.                         astrTenor
  292.                     ),
  293.                     aadblPathForwardYield[iTimeVertex]
  294.                 );

  296.                 for (int iDimension = 0; iDimension < iNumDimension; ++iDimension)
  297.                     strDump = strDump + " " + FormatUtil.FormatDouble (ffgc.yield (astrTenor[iDimension]), 1, 3, 100.) + "% |";

  299.                 System.out.println (strDump + "|");
  300.             }
  301.         }

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

  305.         EnvManager.TerminateEnv();
  306.     }
  307. }
Created with JaCoCo 0.7.9.201702052155