CustomDiscountCurveBuilder.java

  1.     
  2. package org.drip.sample.stretch;

  4. /*
  5.  * Java Imports
  6.  */

  8. import java.util.*;

  10. import org.drip.function.r1tor1.QuadraticRationalShapeControl;
  11. import org.drip.numerical.common.FormatUtil;
  12. import org.drip.spline.basis.*;
  13. import org.drip.spline.params.*;
  14. import org.drip.spline.stretch.*;

  16. /*
  17.  * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  18.  */

  20. /*!
  21.  * Copyright (C) 2018 Lakshmi Krishnamurthy
  22.  * Copyright (C) 2017 Lakshmi Krishnamurthy
  23.  * Copyright (C) 2016 Lakshmi Krishnamurthy
  24.  * Copyright (C) 2015 Lakshmi Krishnamurthy
  25.  * Copyright (C) 2014 Lakshmi Krishnamurthy
  26.  * Copyright (C) 2013 Lakshmi Krishnamurthy
  27.  * 
  28.  *  This file is part of DRIP, a free-software/open-source library for buy/side financial/trading model
  29.  *      libraries targeting analysts and developers
  30.  *      https://lakshmidrip.github.io/DRIP/
  31.  *  
  32.  *  DRIP is composed of four main libraries:
  33.  *  
  34.  *  - DRIP Fixed Income - https://lakshmidrip.github.io/DRIP-Fixed-Income/
  35.  *  - DRIP Asset Allocation - https://lakshmidrip.github.io/DRIP-Asset-Allocation/
  36.  *  - DRIP Numerical Optimizer - https://lakshmidrip.github.io/DRIP-Numerical-Optimizer/
  37.  *  - DRIP Statistical Learning - https://lakshmidrip.github.io/DRIP-Statistical-Learning/
  38.  * 
  39.  *  - DRIP Fixed Income: Library for Instrument/Trading Conventions, Treasury Futures/Options,
  40.  *      Funding/Forward/Overnight Curves, Multi-Curve Construction/Valuation, Collateral Valuation and XVA
  41.  *      Metric Generation, Calibration and Hedge Attributions, Statistical Curve Construction, Bond RV
  42.  *      Metrics, Stochastic Evolution and Option Pricing, Interest Rate Dynamics and Option Pricing, LMM
  43.  *      Extensions/Calibrations/Greeks, Algorithmic Differentiation, and Asset Backed Models and Analytics.
  44.  * 
  45.  *  - DRIP Asset Allocation: Library for model libraries for MPT framework, Black Litterman Strategy
  46.  *      Incorporator, Holdings Constraint, and Transaction Costs.
  47.  * 
  48.  *  - DRIP Numerical Optimizer: Library for Numerical Optimization and Spline Functionality.
  49.  * 
  50.  *  - DRIP Statistical Learning: Library for Statistical Evaluation and Machine Learning.
  51.  * 
  52.  *  Licensed under the Apache License, Version 2.0 (the "License");
  53.  *      you may not use this file except in compliance with the License.
  54.  *   
  55.  *  You may obtain a copy of the License at
  56.  *      http://www.apache.org/licenses/LICENSE-2.0
  57.  *  
  58.  *  Unless required by applicable law or agreed to in writing, software
  59.  *      distributed under the License is distributed on an "AS IS" BASIS,
  60.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  61.  *  
  62.  *  See the License for the specific language governing permissions and
  63.  *      limitations under the License.
  64.  */

  66. /**
  67.  * CustomDiscountCurveBuilder contains samples that demo how to build a discount curve from purely the cash
  68.  *  flows. It provides for elaborate curve builder control, both at the segment level and at the Stretch
  69.  *  level. In particular, it shows the following:
  70.  *  - Construct a discount curve from the discount factors available purely from the cash and the euro-dollar
  71.  *      instruments.
  72.  *  - Construct a discount curve from the cash flows available from the swap instruments.
  73.  * 
  74.  * In addition, the sample demonstrates the following ways of controlling curve construction:
  75.  *  - Control over the type of segment basis spline
  76.  *  - Control over the polynomial basis spline order, Ck, and tension parameters
  77.  *  - Provision of custom shape controllers (in this case rational shape controller)
  78.  *  - Calculation of segment monotonicity and convexity
  79.  * 
  80.  * @author Lakshmi Krishnamurthy
  81.  */

  83. public class CustomDiscountCurveBuilder {

  85.     /*
  86.      * Sample API demonstrating the creation of the segment builder parameters based on Koch-Lyche-Kvasov tension spline.
  87.      * 
  88.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  89.      */

  91.     private static final SegmentCustomBuilderControl MakeKLKTensionSCBC (
  92.         final double dblTension)
  93.         throws Exception
  94.     {
  95.         return new SegmentCustomBuilderControl (
  96.             MultiSegmentSequenceBuilder.BASIS_SPLINE_KLK_HYPERBOLIC_TENSION, // Spline Type KLK Hyperbolic Basis Tension
  97.             new ExponentialTensionSetParams (dblTension), // Segment Tension Parameter Value
  98.             SegmentInelasticDesignControl.Create (2, 2), // Ck = 2; Curvature penalty (if necessary) order: 2
  99.             new ResponseScalingShapeControl (
  100.                 true,
  101.                 new QuadraticRationalShapeControl (0.0)), // Univariate Rational Shape Controller
  102.             null
  103.         );
  104.     }

  106.     /*
  107.      * Sample API demonstrating the creation of the segment builder parameters based on polynomial spline.
  108.      * 
  109.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  110.      */

  112.     public static final SegmentCustomBuilderControl MakePolynomialSBP (
  113.         final int iNumDegree)
  114.         throws Exception
  115.     {
  116.         return new SegmentCustomBuilderControl (
  117.             MultiSegmentSequenceBuilder.BASIS_SPLINE_POLYNOMIAL, // Spline Type Polynomial
  118.             new PolynomialFunctionSetParams (iNumDegree + 1), // Polynomial of degree (i.e, cubic would be 3+1; 4 basis functions - 1 "intercept")
  119.             SegmentInelasticDesignControl.Create (2, 2), // Ck = 2; Curvature penalty (if necessary) order: 2
  120.             new ResponseScalingShapeControl (
  121.                 true,
  122.                 new QuadraticRationalShapeControl (0.0)), // Univariate Rational Shape Controller
  123.             null
  124.         );
  125.     }

  127.     /*
  128.      * Sample API demonstrating the creation of the segment builder parameters
  129.      * 
  130.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  131.      */

  133.     private static final SegmentCustomBuilderControl MakeSCBC (
  134.         final String strBasisSpline)
  135.         throws Exception
  136.     {
  137.         if (strBasisSpline.equalsIgnoreCase (MultiSegmentSequenceBuilder.BASIS_SPLINE_POLYNOMIAL)) // Polynomial Basis Spline
  138.             return new SegmentCustomBuilderControl (
  139.                 MultiSegmentSequenceBuilder.BASIS_SPLINE_POLYNOMIAL, // Spline Type Polynomial
  140.                 new PolynomialFunctionSetParams (4), // Polynomial of order 3 (i.e, cubic - 4 basis functions - 1 "intercept")
  141.                 SegmentInelasticDesignControl.Create (2, 2), // Ck = 2; Curvature penalty (if necessary) order: 2
  142.                 new ResponseScalingShapeControl (
  143.                     true,
  144.                     new QuadraticRationalShapeControl (0.0)), // Univariate Rational Shape Controller
  145.                 null
  146.             );

  148.         if (strBasisSpline.equalsIgnoreCase (MultiSegmentSequenceBuilder.BASIS_SPLINE_EXPONENTIAL_TENSION)) // Exponential Tension Basis Spline
  149.             return new SegmentCustomBuilderControl (
  150.                 MultiSegmentSequenceBuilder.BASIS_SPLINE_EXPONENTIAL_TENSION, // Spline Type Exponential Basis Tension
  151.                 new ExponentialTensionSetParams (1.), // Segment Tension Parameter Value = 1.
  152.                 SegmentInelasticDesignControl.Create (2, 2), // Ck = 2; Curvature penalty (if necessary) order: 2
  153.                 new ResponseScalingShapeControl (
  154.                     true,
  155.                     new QuadraticRationalShapeControl (0.0)), // Univariate Rational Shape Controller
  156.                 null
  157.             );

  159.         return null;
  160.     }

  162.     /*
  163.      * Generate the sample Swap Cash Flows to a given maturity, for the frequency/coupon.
  164.      *  Cash Flow is in the form of <Date, Cash Amount> Map.
  165.      * 
  166.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  167.      */

  169.     private static final TreeMap<Double, Double> SwapCashFlow (
  170.         final double dblCoupon,
  171.         final int iFreq,
  172.         final double dblTenorInYears)
  173.     {
  174.         TreeMap<Double, Double> mapCF = new TreeMap<Double, Double>();

  176.         for (double dblCFDate = 1. / iFreq; dblCFDate < dblTenorInYears; dblCFDate += 1. / iFreq)
  177.             mapCF.put (
  178.                 dblCFDate,
  179.                 dblCoupon / iFreq
  180.             );

  182.         mapCF.put (
  183.             0.,
  184.             -1.
  185.         );

  187.         mapCF.put (
  188.             1. * dblTenorInYears,
  189.             1. + dblCoupon / iFreq
  190.         );

  192.         return mapCF;
  193.     }

  195.     /**
  196.      * Generate the DRIP linear constraint corresponding to an exclusive swap segment. This constraint is
  197.      *  used to calibrate the discount curve in this segment.
  198.      *  
  199.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  200.      */

  202.     private static final SegmentResponseValueConstraint GenerateSegmentConstraint (
  203.         final TreeMap<Double, Double> mapCF,
  204.         final MultiSegmentSequence mssDF)
  205.         throws Exception
  206.     {
  207.         double dblValue = 0.;

  209.         List<Double> lsTime = new ArrayList<Double>();

  211.         List<Double> lsWeight = new ArrayList<Double>();

  213.         for (Map.Entry<Double, Double> me : mapCF.entrySet()) {
  214.             double dblTime = me.getKey();

  216.             if (null != mssDF && mssDF.in (dblTime))
  217.                 dblValue += mssDF.responseValue (dblTime) * me.getValue();
  218.             else {
  219.                 lsTime.add (me.getKey());

  221.                 lsWeight.add (me.getValue());
  222.             }
  223.         }

  225.         int iSize = lsTime.size();

  227.         double[] adblNode = new double[iSize];
  228.         double[] adblNodeWeight = new double[iSize];

  230.         for (int i = 0; i < iSize; ++i) {
  231.             adblNode[i] = lsTime.get (i);

  233.             adblNodeWeight[i] = lsWeight.get (i);
  234.         }

  236.         return new SegmentResponseValueConstraint (
  237.             adblNode,
  238.             adblNodeWeight,
  239.             -dblValue
  240.         );
  241.     }

  243.     /**
  244.      * The set of Par Swap Quotes.
  245.      * 
  246.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  247.      */

  249.     private static final Map<Double, Double> SwapQuotes()
  250.     {
  251.         Map<Double, Double> mapSwapQuotes = new TreeMap<Double, Double>();

  253.         mapSwapQuotes.put (4., 0.0166);

  255.         mapSwapQuotes.put (5., 0.0206);

  257.         mapSwapQuotes.put (6., 0.0241);

  259.         mapSwapQuotes.put (7., 0.0269);

  261.         mapSwapQuotes.put (8., 0.0292);

  263.         mapSwapQuotes.put (9., 0.0311);

  265.         mapSwapQuotes.put (10., 0.0326);

  267.         mapSwapQuotes.put (11., 0.0340);

  269.         mapSwapQuotes.put (12., 0.0351);

  271.         mapSwapQuotes.put (15., 0.0375);

  273.         mapSwapQuotes.put (20., 0.0393);

  275.         mapSwapQuotes.put (25., 0.0402);

  277.         mapSwapQuotes.put (30., 0.0407);

  279.         mapSwapQuotes.put (40., 0.0409);

  281.         mapSwapQuotes.put (50., 0.0409);

  283.         return mapSwapQuotes;
  284.     }

  286.     /**
  287.      * Sample Function illustrating the construction of the discount curve off of swap cash flows and
  288.      *  detailed segment level controls for the swap instruments.Further, the Segment Builder Parameters
  289.      *  for the cash/swap bridging stretch shown here illustrate using an exponential/hyperbolic spline with
  290.      *  very high tension (100000.) to "stitch" the cash stretch with the swaps Stretch.
  291.      * 
  292.      * Each of the respective stretches have their own tension settings, so the "high" tension
  293.      *  ensures that there is no propagation of derivatives and therefore high locality.
  294.      *  
  295.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  296.      */

  298.     private static final MultiSegmentSequence BuildSwapCurve (
  299.         MultiSegmentSequence mss,
  300.         final BoundarySettings bs,
  301.         final int iCalibrationDetail)
  302.         throws Exception
  303.     {
  304.         boolean bFirstNode = true;

  306.         /*
  307.          * Iterate through the swap instruments and their quotes.
  308.          */

  310.         for (Map.Entry<Double, Double> meSwapQuote : SwapQuotes().entrySet()) {
  311.             double dblTenorInYears = meSwapQuote.getKey(); // Swap Maturity in Years

  313.             double dblQuote = meSwapQuote.getValue(); // Par Swap Quote

  315.             /*
  316.              * Generate the Cash flow for the swap Instrument
  317.              */

  319.             TreeMap<Double, Double> mapCF = SwapCashFlow (
  320.                 dblQuote,
  321.                 2,
  322.                 dblTenorInYears
  323.             );

  325.             /*
  326.              * Convert the Cash flow into a DRIP segment constraint using the "prior" curve stretch
  327.              */

  329.             SegmentResponseValueConstraint srvc = GenerateSegmentConstraint (
  330.                 mapCF,
  331.                 mss
  332.             );

  334.             /*
  335.              * If it is the head segment, create a stretch instance for the discount curve.
  336.              */

  338.             if (null == mss) {
  339.                 /*
  340.                  * Set the Segment Builder Parameters. This may be set on a segment-by-segment basis.
  341.                  */

  343.                 SegmentCustomBuilderControl scbc = MakeSCBC (MultiSegmentSequenceBuilder.BASIS_SPLINE_EXPONENTIAL_TENSION);

  345.                 /*
  346.                  * Start off with a single segment stretch, with the corresponding Builder Parameters
  347.                  */

  349.                 mss = MultiSegmentSequenceBuilder.CreateUncalibratedStretchEstimator (
  350.                     "SWAP",
  351.                     new double[] {0., dblTenorInYears},
  352.                     new SegmentCustomBuilderControl[] {scbc}
  353.                 );

  355.                 /*
  356.                  * Set the stretch up by carrying out a "Natural Boundary" Spline Calibration
  357.                  */

  359.                 mss.setup (
  360.                     1.,
  361.                     new SegmentResponseValueConstraint[] {srvc},
  362.                     null,
  363.                     bs,
  364.                     iCalibrationDetail
  365.                 );
  366.             } else {
  367.                 /*
  368.                  * The Segment Builder Parameters shown here illustrate using an exponential/hyperbolic
  369.                  *  spline with high tension (15.) to "stitch" the cash stretch with the swaps stretch.
  370.                  *  
  371.                  * Each of the respective stretches have their own tension settings, so the "high" tension
  372.                  *  ensures that there is no propagation of derivatives and therefore high locality.
  373.                  */

  375.                 SegmentCustomBuilderControl scbcLocal = null;

  377.                 if (bFirstNode) {
  378.                     bFirstNode = false;

  380.                     scbcLocal = MakeKLKTensionSCBC (1.);
  381.                 } else
  382.                     scbcLocal = MakeKLKTensionSCBC (1.);

  384.                 /*
  385.                  * If not the head segment, just append the exclusive swap instrument segment to the tail of
  386.                  *  the current stretch state, using the constraint generated from the swap cash flow.
  387.                  */

  389.                 mss = org.drip.spline.stretch.MultiSegmentSequenceModifier.AppendSegment (
  390.                     mss,
  391.                     dblTenorInYears,
  392.                     srvc,
  393.                     scbcLocal,
  394.                     bs,
  395.                     iCalibrationDetail
  396.                 );
  397.             }
  398.         }

  400.         return mss;
  401.     }

  403.     /**
  404.      * The set of Cash Discount Factors.
  405.      * 
  406.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  407.      */

  409.     private static final Map<Double, Double> CashDFQuotes()
  410.     {
  411.         Map<Double, Double> mapDFCashQuotes = new TreeMap<Double, Double>();

  413.         mapDFCashQuotes.put (0.005556, 0.999991);

  415.         mapDFCashQuotes.put (0.019444, 0.999967);

  417.         mapDFCashQuotes.put (0.038889, 0.999931);

  419.         mapDFCashQuotes.put (0.083333, 0.999836);

  421.         mapDFCashQuotes.put (0.166667, 0.999622);

  423.         mapDFCashQuotes.put (0.250000, 0.999360);

  425.         mapDFCashQuotes.put (0.500000, 0.998686);

  427.         mapDFCashQuotes.put (0.750000, 0.997888);

  429.         mapDFCashQuotes.put (1.000000, 0.996866);

  431.         mapDFCashQuotes.put (1.250000, 0.995522);

  433.         mapDFCashQuotes.put (1.500000, 0.993609);

  435.         mapDFCashQuotes.put (1.750000, 0.991033);

  437.         mapDFCashQuotes.put (2.000000, 0.987724);

  439.         mapDFCashQuotes.put (2.250000, 0.983789);

  441.         return mapDFCashQuotes;
  442.     }

  444.     /**
  445.      * Sample Function illustrating the construction of the discount curve off of discount factors and
  446.      *  detailed segment level controls for the cash instruments.
  447.      * 
  448.      *      USE WITH CARE: This sample ignores errors and does not handle exceptions.
  449.      */

  451.     private static final MultiSegmentSequence BuildCashCurve (
  452.         final org.drip.spline.stretch.BoundarySettings bs,
  453.         final int iCalibrationDetail)
  454.         throws Exception
  455.     {
  456.         /*
  457.          * For the head segment, create a calibrated stretch instance for the discount curve.
  458.          */

  460.         MultiSegmentSequence mssCash = MultiSegmentSequenceBuilder.CreateCalibratedStretchEstimator (
  461.             "CASH",
  462.             new double[] {0., 0.002778}, // t0 and t1 for the segment
  463.             new double[] {1., 0.999996}, // the corresponding discount factors
  464.             new SegmentCustomBuilderControl[] {
  465.                 // MakeSCBC (MultiSegmentSequenceBuilder.BASIS_SPLINE_EXPONENTIAL_TENSION)
  466.                 MakeKLKTensionSCBC (1.)
  467.             }, // Exponential Tension Basis Spline
  468.             null,
  469.             bs,
  470.             iCalibrationDetail // "Natural" Spline Boundary Condition + Calibrate the full stretch
  471.         );

  473.         /*
  474.          * Construct the discount curve by iterating through the cash instruments and their discount
  475.          *  factors, and inserting them as "knots" onto the existing stretch.
  476.          */

  478.         for (Map.Entry<Double, Double> meCashDFQuote : CashDFQuotes().entrySet()) {
  479.             double dblTenorInYears = meCashDFQuote.getKey(); // Instrument Tenor in Years

  481.             double dblDF = meCashDFQuote.getValue(); // Discount Factor

  483.             /*
  484.              * Insert the instrument/quote as a "knot" entity into the stretch. Given the "natural" spline
  485.              */

  487.             mssCash = MultiSegmentSequenceModifier.InsertKnot (
  488.                 mssCash,
  489.                 dblTenorInYears,
  490.                 dblDF,
  491.                 bs,
  492.                 iCalibrationDetail
  493.             );
  494.         }

  496.         return mssCash;
  497.     }

  499.     /*
  500.      * This sample demonstrates the usage construction and usage of Custom Curve Building. It shows the following:
  501.      *  - Construct the Cash Curve Sequence with the Standard Natural Boundary Condition.
  502.      *  - Construct the Cash Curve Sequence with the Standard Financial Boundary Condition.
  503.      *  - Construct the Cash Curve Sequence with the Standard Not-A-Knot Boundary Condition.
  504.      *  - Display the DF and the monotonicity for the cash instruments.
  505.      *  - Construct the Swap Curve Sequence with the Standard Natural Boundary Condition.
  506.      *  - Construct the Swap Curve Sequence with the Standard Financial Boundary Condition.
  507.      *  - Construct the Swap Curve Sequence with the Standard Not-A-Knot Boundary Condition.
  508.      *  - Display the DF and the monotonicity for the swap instruments.
  509.      */

  511.     private static final void CustomCurveBuilderTest()
  512.         throws Exception
  513.     {
  514.         /*
  515.          * Construct the Cash Curve Sequence with the Standard Natural Boundary Condition
  516.          */

  518.         MultiSegmentSequence mssNaturalCash = BuildCashCurve (
  519.             BoundarySettings.NaturalStandard(),
  520.             MultiSegmentSequence.CALIBRATE
  521.         );

  523.         /*
  524.          * Construct the Cash Curve Sequence with the Standard Financial Boundary Condition
  525.          */

  527.         MultiSegmentSequence mssFinancialCash = BuildCashCurve (
  528.             BoundarySettings.FinancialStandard(),
  529.             MultiSegmentSequence.CALIBRATE
  530.         );

  532.         /*
  533.          * Construct the Cash Curve Sequence with the Standard Not-A-Knot Boundary Condition
  534.          */

  536.         MultiSegmentSequence mssNotAKnotCash = BuildCashCurve (
  537.             BoundarySettings.NotAKnotStandard (1, 1),
  538.             MultiSegmentSequence.CALIBRATE
  539.         );

  541.         double dblXShift = 0.1 * (mssNaturalCash.getRightPredictorOrdinateEdge() - mssNaturalCash.getLeftPredictorOrdinateEdge());

  543.         System.out.println ("\n\t\t\t----------------       <====>    ------------------       <====>    ------------------");

  545.         System.out.println ("\t\t\tNATURAL BOUNDARY       <====>   NOT A KNOT BOUNDARY       <====>    FINANCIAL BOUNDARY");

  547.         System.out.println ("\t\t\t----------------       <====>    ------------------       <====>    ------------------\n");

  549.         /*
  550.          * Display the DF and the monotonicity for the cash instruments.
  551.          */

  553.         for (double dblX = mssNaturalCash.getLeftPredictorOrdinateEdge(); dblX <= mssNaturalCash.getRightPredictorOrdinateEdge(); dblX = dblX + dblXShift)
  554.             System.out.println ("Cash DF[" +
  555.                 FormatUtil.FormatDouble (dblX, 1, 3, 1.) + "Y] => " +
  556.                 FormatUtil.FormatDouble (mssNaturalCash.responseValue (dblX), 1, 6, 1.) + " | " +
  557.                 mssNaturalCash.monotoneType (dblX) + "  <====>  " +
  558.                 FormatUtil.FormatDouble (mssNotAKnotCash.responseValue (dblX), 1, 6, 1.) + " | " +
  559.                 mssNotAKnotCash.monotoneType (dblX) + "  <====>  " +
  560.                 FormatUtil.FormatDouble (mssFinancialCash.responseValue (dblX), 1, 6, 1.) + " | " +
  561.                 mssNaturalCash.monotoneType (dblX));

  563.         System.out.println ("\n");

  565.         /*
  566.          * Construct the Swap Curve Sequence with the Standard Natural Boundary Condition
  567.          */

  569.         MultiSegmentSequence mssNaturalSwap = BuildSwapCurve (
  570.             mssNaturalCash,
  571.             BoundarySettings.NaturalStandard(),
  572.             MultiSegmentSequence.CALIBRATE
  573.         );

  575.         /*
  576.          * Construct the Swap Curve Sequence with the Standard Financial Boundary Condition
  577.          */

  579.         MultiSegmentSequence mssFinancialSwap = BuildSwapCurve (
  580.             mssFinancialCash,
  581.             BoundarySettings.FinancialStandard(),
  582.             MultiSegmentSequence.CALIBRATE
  583.         );

  585.         /*
  586.          * Construct the Swap Curve Sequence with the Standard Not-A-Knot Boundary Condition
  587.          */

  589.         MultiSegmentSequence mssNotAKnotSwap = BuildSwapCurve (
  590.             mssNotAKnotCash,
  591.             BoundarySettings.NotAKnotStandard (1, 1),
  592.             MultiSegmentSequence.CALIBRATE
  593.         );

  595.         /*
  596.          * Display the DF and the monotonicity for the swaps.
  597.          */

  599.         dblXShift = 0.05 * (mssNaturalSwap.getRightPredictorOrdinateEdge() - mssNaturalSwap.getLeftPredictorOrdinateEdge());

  601.         for (double dblX = mssNaturalSwap.getLeftPredictorOrdinateEdge(); dblX <= mssNaturalSwap.getRightPredictorOrdinateEdge(); dblX = dblX + dblXShift)
  602.             System.out.println (
  603.                 "Swap DF   [" +
  604.                 FormatUtil.FormatDouble (dblX, 2, 0, 1.) + "Y] => " +
  605.                 FormatUtil.FormatDouble (mssNaturalSwap.responseValue (dblX), 1, 6, 1.) + " | " +
  606.                 mssNaturalSwap.monotoneType (dblX) + "  <====>  " +
  607.                 FormatUtil.FormatDouble (mssNotAKnotSwap.responseValue (dblX), 1, 6, 1.) + " | " +
  608.                 mssNotAKnotSwap.monotoneType (dblX) + "  <====>  " +
  609.                 FormatUtil.FormatDouble (mssFinancialSwap.responseValue (dblX), 1, 6, 1.) + " | " +
  610.                 mssFinancialSwap.monotoneType (dblX)
  611.             );
  612.     }

  614.     public static final void main (
  615.         final String[] astrArgs)
  616.         throws Exception
  617.     {
  618.         CustomCurveBuilderTest();
  619.     }
  620. }
Created with JaCoCo 0.7.9.201702052155