EuropeanCallPut.java

  1. package org.drip.product.option;

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

  82. /**
  83.  * <i>EuropeanCallPut</i> implements a simple European Call/Put Option, and its Black Scholes Price.
  84.  * 
  85.  * <br><br>
  86.  *  <ul>
  87.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ProductCore.md">Product Core Module</a></li>
  88.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/FixedIncomeAnalyticsLibrary.md">Fixed Income Analytics</a></li>
  89.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/product/README.md">Product Components/Baskets for Credit, FRA, FX, Govvie, Rates, and Option AssetClasses</a></li>
  90.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/product/option/README.md">Options on Fixed Income Components</a></li>
  91.  *  </ul>
  92.  * <br><br>
  93.  * 
  94.  * @author Lakshmi Krishnamurthy
  95.  */

  97. public class EuropeanCallPut {
  98.     private double _dblStrike = java.lang.Double.NaN;
  99.     private org.drip.analytics.date.JulianDate _dtMaturity = null;

  101.     /**
  102.      * EuropeanCallPut constructor
  103.      * 
  104.      * @param dtMaturity Option Maturity
  105.      * @param dblStrike Option Strike
  106.      * 
  107.      * @throws java.lang.Exception Thrown if Inputs are Invalid
  108.      */

  110.     public EuropeanCallPut (
  111.         final org.drip.analytics.date.JulianDate dtMaturity,
  112.         final double dblStrike)
  113.         throws java.lang.Exception
  114.     {
  115.         if (null == (_dtMaturity = dtMaturity) || !org.drip.numerical.common.NumberUtil.IsValid (_dblStrike =
  116.             dblStrike) || 0. >= _dblStrike)
  117.             throw new java.lang.Exception ("EuropeanCallPut ctr: Invalid Inputs");
  118.     }

  120.     /**
  121.      * Retrieve the Option Maturity
  122.      * 
  123.      * @return The Option Maturity
  124.      */

  126.     public org.drip.analytics.date.JulianDate maturity()
  127.     {
  128.         return _dtMaturity;
  129.     }

  131.     /**
  132.      * Retrieve the Option Strike
  133.      * 
  134.      * @return The Option Strike
  135.      */

  137.     public double strike()
  138.     {
  139.         return _dblStrike;
  140.     }

  142.     /**
  143.      * Generate the Measure Set for the Option
  144.      * 
  145.      * @param valParams The Valuation Parameters
  146.      * @param dblUnderlier The Underlier
  147.      * @param bIsForward TRUE - The Underlier represents the Forward, FALSE - it represents Spot
  148.      * @param dc Discount Curve
  149.      * @param auVolatility The Option Volatility Function
  150.      * @param fpg The Fokker Planck-based Option Pricer
  151.      * 
  152.      * @return The Map of the Measures
  153.      */

  155.     public org.drip.analytics.support.CaseInsensitiveTreeMap<java.lang.Double> value (
  156.         final org.drip.param.valuation.ValuationParams valParams,
  157.         final double dblUnderlier,
  158.         final boolean bIsForward,
  159.         final org.drip.state.discount.MergedDiscountForwardCurve dc,
  160.         final org.drip.function.definition.R1ToR1 auVolatility,
  161.         final org.drip.pricer.option.FokkerPlanckGenerator fpg)
  162.     {
  163.         if (null == valParams || null == dc || null == auVolatility || null == fpg) return null;

  165.         int iValueDate = valParams.valueDate();

  167.         int iMaturityDate = _dtMaturity.julian();

  169.         if (iValueDate >= iMaturityDate) return null;

  171.         long lStartTime = System.nanoTime();

  173.         double dblRiskFreeRate = java.lang.Double.NaN;
  174.         double dblTTE = (iMaturityDate - iValueDate) / 365.25;
  175.         double dblImpliedPutVolatility = java.lang.Double.NaN;
  176.         double dblImpliedCallVolatility = java.lang.Double.NaN;
  177.         double dblTimeAveragedVolatility = java.lang.Double.NaN;
  178.         double dblBlackScholesPutVolatility = java.lang.Double.NaN;
  179.         double dblBlackScholesCallVolatility = java.lang.Double.NaN;

  181.         try {
  182.             dblRiskFreeRate = dc.zero (iMaturityDate);

  184.             dblTimeAveragedVolatility = auVolatility.integrate (iValueDate, iMaturityDate) / (iMaturityDate -
  185.                 iValueDate);
  186.         } catch (java.lang.Exception e) {
  187.             e.printStackTrace();

  189.             return null;
  190.         }

  192.         org.drip.pricer.option.Greeks callGreeks = fpg.greeks (_dblStrike, dblTTE, dblRiskFreeRate,
  193.             dblUnderlier, false, bIsForward, dblTimeAveragedVolatility);

  195.         org.drip.pricer.option.PutGreeks putGreeks = (org.drip.pricer.option.PutGreeks) fpg.greeks
  196.             (_dblStrike, dblTTE, dblRiskFreeRate, dblUnderlier, true, bIsForward, dblTimeAveragedVolatility);

  198.         if (null == callGreeks || null == putGreeks) return null;

  200.         double dblCallPrice = callGreeks.price();

  202.         double dblPutPrice = putGreeks.price();

  204.         try {
  205.             dblBlackScholesCallVolatility = fpg.impliedBlackScholesVolatility (_dblStrike, dblTTE,
  206.                 dblRiskFreeRate, dblUnderlier, false, bIsForward, dblCallPrice);

  208.             dblBlackScholesPutVolatility = fpg.impliedBlackScholesVolatility (_dblStrike, dblTTE,
  209.                 dblRiskFreeRate, dblUnderlier, true, bIsForward, dblPutPrice);

  211.             dblImpliedCallVolatility = fpg.impliedVolatilityFromPrice (_dblStrike, dblTTE, dblRiskFreeRate,
  212.                 dblUnderlier, false, bIsForward, dblCallPrice);

  214.             dblImpliedPutVolatility = fpg.impliedVolatilityFromPrice (_dblStrike, dblTTE, dblRiskFreeRate,
  215.                 dblUnderlier, true, bIsForward, dblPutPrice);
  216.         } catch (java.lang.Exception e) {
  217.             e.printStackTrace();

  219.             return null;
  220.         }

  222.         org.drip.analytics.support.CaseInsensitiveTreeMap<java.lang.Double> mapMeasure = new
  223.             org.drip.analytics.support.CaseInsensitiveTreeMap<java.lang.Double>();

  225.         mapMeasure.put ("BlackScholesCallVolatility", dblBlackScholesCallVolatility);

  227.         mapMeasure.put ("BlackScholesPutVolatility", dblBlackScholesPutVolatility);

  229.         mapMeasure.put ("CalcTime", (System.nanoTime() - lStartTime) * 1.e-09);

  231.         mapMeasure.put ("CallCharm", callGreeks.charm());

  233.         mapMeasure.put ("CallColor", callGreeks.color());

  235.         mapMeasure.put ("CallDelta", callGreeks.delta());

  237.         mapMeasure.put ("CallGamma", callGreeks.gamma());

  239.         mapMeasure.put ("CallPrice", callGreeks.price());

  241.         mapMeasure.put ("CallProb1", callGreeks.prob1());

  243.         mapMeasure.put ("CallProb2", callGreeks.prob2());

  245.         mapMeasure.put ("CallRho", callGreeks.rho());

  247.         mapMeasure.put ("CallSpeed", callGreeks.speed());

  249.         mapMeasure.put ("CallTheta", callGreeks.theta());

  251.         mapMeasure.put ("CallUltima", callGreeks.ultima());

  253.         mapMeasure.put ("CallVanna", callGreeks.vanna());

  255.         mapMeasure.put ("CallVega", callGreeks.vega());

  257.         mapMeasure.put ("CallVeta", callGreeks.veta());

  259.         mapMeasure.put ("CallVomma", callGreeks.vomma());

  261.         mapMeasure.put ("DF", callGreeks.df());

  263.         mapMeasure.put ("EffectiveVolatility", callGreeks.effectiveVolatility());

  265.         mapMeasure.put ("ImpliedCallVolatility", dblImpliedCallVolatility);

  267.         mapMeasure.put ("ImpliedPutVolatility", dblImpliedPutVolatility);

  269.         mapMeasure.put ("PutCharm", putGreeks.charm());

  271.         mapMeasure.put ("PutColor", putGreeks.color());

  273.         mapMeasure.put ("PutDelta", putGreeks.delta());

  275.         mapMeasure.put ("PutGamma", putGreeks.gamma());

  277.         mapMeasure.put ("PutPrice", putGreeks.price());

  279.         mapMeasure.put ("PutPriceFromParity", putGreeks.putPriceFromParity());

  281.         mapMeasure.put ("PutProb1", putGreeks.prob1());

  283.         mapMeasure.put ("PutProb2", putGreeks.prob2());

  285.         mapMeasure.put ("PutRho", putGreeks.rho());

  287.         mapMeasure.put ("PutSpeed", putGreeks.speed());

  289.         mapMeasure.put ("PutTheta", putGreeks.theta());

  291.         mapMeasure.put ("PutUltima", putGreeks.ultima());

  293.         mapMeasure.put ("PutVanna", putGreeks.vanna());

  295.         mapMeasure.put ("PutVega", putGreeks.vega());

  297.         mapMeasure.put ("PutVeta", putGreeks.veta());

  299.         mapMeasure.put ("PutVomma", putGreeks.vomma());

  301.         mapMeasure.put ("TTE", dblTTE);

  303.         return mapMeasure;
  304.     }

  306.     /**
  307.      * Imply the Option Volatility given the Call Price
  308.      * 
  309.      * @param valParams The Valuation Parameters
  310.      * @param dblUnderlier The Underlier
  311.      * @param bIsForward TRUE - The Underlier represents the Forward, FALSE - it represents Spot
  312.      * @param dc Discount Curve
  313.      * @param dblCallPrice The Option Call Price
  314.      * 
  315.      * @return The Option's Implied Volatility
  316.      * 
  317.      * @throws java.lang.Exception Thrown if Inputs are Invalid
  318.      */

  320.     public double implyVolatilityFromCallPrice (
  321.         final org.drip.param.valuation.ValuationParams valParams,
  322.         final double dblUnderlier,
  323.         final boolean bIsForward,
  324.         final org.drip.state.discount.MergedDiscountForwardCurve dc,
  325.         final double dblCallPrice)
  326.         throws java.lang.Exception
  327.     {
  328.         if (null == valParams || null == dc)
  329.             throw new java.lang.Exception ("EuropeanCallPut::implyVolatilityFromCallPrice => Invalid Inputs");

  331.         int iValueDate = valParams.valueDate();

  333.         int iMaturityDate = _dtMaturity.julian();

  335.         if (iValueDate >= iMaturityDate)
  336.             throw new java.lang.Exception ("EuropeanCallPut::implyVolatilityFromCallPrice => Invalid Inputs");

  338.         double dblTTE = 1. * (iMaturityDate - iValueDate) / 365.25;

  340.         return new org.drip.pricer.option.BlackScholesAlgorithm().impliedVolatilityFromPrice (_dblStrike,
  341.             dblTTE, dc.zero (iMaturityDate), dblUnderlier, false, bIsForward, dblCallPrice);
  342.     }

  344.     /**
  345.      * Imply the Option Volatility given the Put Price
  346.      * 
  347.      * @param valParams The Valuation Parameters
  348.      * @param dblUnderlier The Underlier
  349.      * @param bIsForward TRUE - The Underlier represents the Forward, FALSE - it represents Spot
  350.      * @param dc Discount Curve
  351.      * @param dblPutPrice The Option Put Price
  352.      * 
  353.      * @return The Option's Implied Volatility
  354.      * 
  355.      * @throws java.lang.Exception Thrown if Inputs are Invalid
  356.      */

  358.     public double implyVolatilityFromPutPrice (
  359.         final org.drip.param.valuation.ValuationParams valParams,
  360.         final double dblUnderlier,
  361.         final boolean bIsForward,
  362.         final org.drip.state.discount.MergedDiscountForwardCurve dc,
  363.         final double dblPutPrice)
  364.         throws java.lang.Exception
  365.     {
  366.         if (null == valParams || null == dc)
  367.             throw new java.lang.Exception ("EuropeanCallPut::implyVolatilityFromPutPrice => Invalid Inputs");

  369.         int iValueDate = valParams.valueDate();

  371.         int iMaturityDate = _dtMaturity.julian();

  373.         if (iValueDate >= iMaturityDate)
  374.             throw new java.lang.Exception ("EuropeanCallPut::implyVolatilityFromPutPrice => Invalid Inputs");

  376.         double dblTTE = 1. * (iMaturityDate - iValueDate) / 365.25;

  378.         return new org.drip.pricer.option.BlackScholesAlgorithm().impliedVolatilityFromPrice (_dblStrike,
  379.             dblTTE, dc.zero (iMaturityDate), dblUnderlier, true, bIsForward, dblPutPrice);
  380.     }

  382.     /**
  383.      * Retrieve the Set of the Measure Names
  384.      * 
  385.      * @return The Set of the Measure Names
  386.      */

  388.     public java.util.Set<java.lang.String> getMeasureNames()
  389.     {
  390.         java.util.Set<java.lang.String> setstrMeasureNames = new java.util.TreeSet<java.lang.String>();

  392.         setstrMeasureNames.add ("BlackScholesCallVolatility");

  394.         setstrMeasureNames.add ("BlackScholesPutVolatility");

  396.         setstrMeasureNames.add ("CalcTime");

  398.         setstrMeasureNames.add ("CallCharm");

  400.         setstrMeasureNames.add ("CallColor");

  402.         setstrMeasureNames.add ("CallDelta");

  404.         setstrMeasureNames.add ("CallGamma");

  406.         setstrMeasureNames.add ("CallPrice");

  408.         setstrMeasureNames.add ("CallProb1");

  410.         setstrMeasureNames.add ("CallProb2");

  412.         setstrMeasureNames.add ("CallRho");

  414.         setstrMeasureNames.add ("CallSpeed");

  416.         setstrMeasureNames.add ("CallTheta");

  418.         setstrMeasureNames.add ("CallUltima");

  420.         setstrMeasureNames.add ("CallVanna");

  422.         setstrMeasureNames.add ("CallVega");

  424.         setstrMeasureNames.add ("CallVeta");

  426.         setstrMeasureNames.add ("CallVomma");

  428.         setstrMeasureNames.add ("DF");

  430.         setstrMeasureNames.add ("EffectiveVolatility");

  432.         setstrMeasureNames.add ("ImpliedCallVolatility");

  434.         setstrMeasureNames.add ("ImpliedPutVolatility");

  436.         setstrMeasureNames.add ("PutCharm");

  438.         setstrMeasureNames.add ("PutColor");

  440.         setstrMeasureNames.add ("PutDelta");

  442.         setstrMeasureNames.add ("PutGamma");

  444.         setstrMeasureNames.add ("PutPrice");

  446.         setstrMeasureNames.add ("PutPriceFromParity");

  448.         setstrMeasureNames.add ("PutProb1");

  450.         setstrMeasureNames.add ("PutProb2");

  452.         setstrMeasureNames.add ("PutRho");

  454.         setstrMeasureNames.add ("PutSpeed");

  456.         setstrMeasureNames.add ("PutTheta");

  458.         setstrMeasureNames.add ("PutUltima");

  460.         setstrMeasureNames.add ("PutVanna");

  462.         setstrMeasureNames.add ("PutVega");

  464.         setstrMeasureNames.add ("PutVeta");

  466.         setstrMeasureNames.add ("PutVomma");

  468.         setstrMeasureNames.add ("TTE");

  470.         return setstrMeasureNames;
  471.     }
  472. }
Created with JaCoCo 0.7.9.201702052155