BlackScholesAlgorithm.java

  1. package org.drip.pricer.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>BlackScholesAlgorithm</i> implements the Black Scholes based European Call and Put Options Pricer.
  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/pricer/README.md">Custom Pricing Algorithms and the Derivative Fokker Planck Trajectory Generators</a></li>
  90.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/pricer/option/README.md">Deterministic/Stochastic Volatility Settings/Greeks</a></li>
  91.  *  </ul>
  92.  * <br><br>
  93.  * 
  94.  * @author Lakshmi Krishnamurthy
  95.  */

  97. public class BlackScholesAlgorithm extends org.drip.pricer.option.FokkerPlanckGenerator {

  99.     /**
  100.      * Empty BlackScholesAlgorithm Constructor - nothing to be filled in with
  101.      */

  103.     public BlackScholesAlgorithm()
  104.     {
  105.     }

  107.     @Override public double payoff (
  108.         final double dblStrike,
  109.         final double dblTimeToExpiry,
  110.         final double dblRiskFreeRate,
  111.         final double dblUnderlier,
  112.         final boolean bIsPut,
  113.         final boolean bIsForward,
  114.         final double dblVolatility,
  115.         final boolean bAsPrice)
  116.         throws java.lang.Exception
  117.     {
  118.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblStrike) ||
  119.             !org.drip.numerical.common.NumberUtil.IsValid (dblUnderlier) ||
  120.                 !org.drip.numerical.common.NumberUtil.IsValid (dblVolatility) ||
  121.                     !org.drip.numerical.common.NumberUtil.IsValid (dblTimeToExpiry) ||
  122.                         !org.drip.numerical.common.NumberUtil.IsValid (dblRiskFreeRate))
  123.             throw new java.lang.Exception ("BlackScholesAlgorithm::payoff => Invalid Inputs");

  125.         double dblD1D2Diff = dblVolatility * java.lang.Math.sqrt (dblTimeToExpiry);

  127.         double dblDF = java.lang.Math.exp (-1. * dblRiskFreeRate * dblTimeToExpiry);

  129.         double dblD1 = java.lang.Double.NaN;
  130.         double dblD2 = java.lang.Double.NaN;
  131.         double dblForward = bIsForward ? dblUnderlier : dblUnderlier / dblDF;

  133.         if (0. != dblVolatility) {
  134.             dblD1 = (java.lang.Math.log (dblForward / dblStrike) + dblTimeToExpiry * (dblRiskFreeRate + (0.5
  135.                 * dblVolatility * dblVolatility))) / dblD1D2Diff;

  137.             dblD2 = dblD1 - dblD1D2Diff;
  138.         } else {
  139.             dblD1 = dblForward > dblStrike ? java.lang.Double.POSITIVE_INFINITY :
  140.                 java.lang.Double.NEGATIVE_INFINITY;
  141.             dblD2 = dblD1;
  142.         }

  144.         double dblCallPayoff = dblForward * org.drip.measure.gaussian.NormalQuadrature.CDF (dblD1) - dblStrike *
  145.             org.drip.measure.gaussian.NormalQuadrature.CDF (dblD2);

  147.         if (!bAsPrice) return bIsPut ? dblCallPayoff + dblStrike - dblForward : dblCallPayoff;

  149.         return bIsPut ? dblDF * (dblCallPayoff + dblStrike - dblForward) : dblDF * dblCallPayoff;
  150.     }

  152.     @Override public org.drip.pricer.option.Greeks greeks (
  153.         final double dblStrike,
  154.         final double dblTimeToExpiry,
  155.         final double dblRiskFreeRate,
  156.         final double dblUnderlier,
  157.         final boolean bIsPut,
  158.         final boolean bIsForward,
  159.         final double dblVolatility)
  160.     {
  161.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblStrike) ||
  162.             !org.drip.numerical.common.NumberUtil.IsValid (dblUnderlier) ||
  163.                 !org.drip.numerical.common.NumberUtil.IsValid (dblVolatility) ||
  164.                     !org.drip.numerical.common.NumberUtil.IsValid (dblTimeToExpiry) ||
  165.                         !org.drip.numerical.common.NumberUtil.IsValid (dblRiskFreeRate))
  166.             return null;

  168.         double dblTimeRoot = java.lang.Math.sqrt (dblTimeToExpiry);

  170.         double dblDF = java.lang.Math.exp (-1. * dblRiskFreeRate * dblTimeToExpiry);

  172.         double dblVega = java.lang.Double.NaN;
  173.         double dblVeta = java.lang.Double.NaN;
  174.         double dblCharm = java.lang.Double.NaN;
  175.         double dblColor = java.lang.Double.NaN;
  176.         double dblGamma = java.lang.Double.NaN;
  177.         double dblSpeed = java.lang.Double.NaN;
  178.         double dblVanna = java.lang.Double.NaN;
  179.         double dblVomma = java.lang.Double.NaN;
  180.         double dblUltima = java.lang.Double.NaN;
  181.         double dblCallProb1 = java.lang.Double.NaN;
  182.         double dblCallProb2 = java.lang.Double.NaN;
  183.         double dblTimeDecay = java.lang.Double.NaN;
  184.         double dblATMCallProb1 = java.lang.Double.NaN;
  185.         double dblATMCallProb2 = java.lang.Double.NaN;
  186.         double dblD1D2Diff = dblVolatility * dblTimeRoot;
  187.         double dblForward = bIsForward ? dblUnderlier : dblUnderlier / dblDF;

  189.         double dblATMD1 = dblTimeToExpiry * (dblRiskFreeRate + (0.5 * dblVolatility * dblVolatility)) /
  190.             dblD1D2Diff;
  191.         double dblATMD2 = dblATMD1 - dblD1D2Diff;

  193.         double dblD1 = dblATMD1 + (java.lang.Math.log (dblForward / dblStrike)) / dblD1D2Diff;

  195.         double dblD2 = dblD1 - dblD1D2Diff;
  196.         double dblD1D2 = dblD1 * dblD2;

  198.         try {
  199.             dblCallProb1 = org.drip.measure.gaussian.NormalQuadrature.CDF (dblD1);

  201.             dblCallProb2 = org.drip.measure.gaussian.NormalQuadrature.CDF (dblD2);

  203.             dblATMCallProb1 = org.drip.measure.gaussian.NormalQuadrature.CDF (dblATMD1);

  205.             dblATMCallProb2 = org.drip.measure.gaussian.NormalQuadrature.CDF (dblATMD2);

  207.             double dblD1Density = org.drip.measure.gaussian.NormalQuadrature.Density (dblD1);

  209.             dblVega = dblForward * dblD1Density * dblTimeRoot;
  210.             dblVomma = dblVega * dblD1 * dblD2 / dblVolatility;
  211.             dblGamma = dblD1Density / (dblForward * dblD1D2Diff);
  212.             dblUltima = -1. * dblVega * (dblD1D2 * (1. - dblD1D2) + dblD1 * dblD1 + dblD2 * dblD2) /
  213.                 (dblVolatility * dblVolatility);
  214.             dblSpeed = -1. * dblGamma / dblForward * (1. + (dblD1 / dblD1D2Diff));
  215.             dblTimeDecay = -0.5 * dblForward * dblD1Density * dblVolatility / dblTimeRoot;
  216.             dblVanna = dblVega / dblForward * (1. - (dblD1 / dblD1D2Diff));
  217.             dblCharm = dblD1Density * (2. * dblRiskFreeRate * dblTimeToExpiry - dblD2 * dblD1D2Diff) / (2. *
  218.                 dblVolatility * dblD1D2Diff);
  219.             dblVeta = dblForward * dblD1Density * dblTimeRoot * ((dblRiskFreeRate * dblD1 / (dblD1D2Diff))
  220.                 - ((1. + dblD1D2) / (2. * dblTimeToExpiry)));
  221.             dblColor = -0.5 * dblD1Density / (dblForward * dblTimeToExpiry * dblD1D2Diff) * (1. + dblD1 *
  222.                 (2. * dblRiskFreeRate * dblTimeToExpiry - dblD2 * dblD1D2Diff) / dblD1D2Diff);
  223.         } catch (java.lang.Exception e) {
  224.             e.printStackTrace();

  226.             return null;
  227.         }

  229.         double dblExpectedCallPayoff = dblForward * dblCallProb1 - dblStrike * dblCallProb2;
  230.         double dblExpectedATMCallPayoff = dblStrike * (dblATMCallProb1 - dblATMCallProb2);
  231.         double dblCallRho = dblStrike * dblTimeToExpiry * dblCallProb2;
  232.         double dblCallPrice = dblDF * dblExpectedCallPayoff;

  234.         try {
  235.             if (!bIsPut)
  236.                 return new org.drip.pricer.option.Greeks (
  237.                     dblDF,
  238.                     dblVolatility,
  239.                     dblExpectedCallPayoff,
  240.                     dblExpectedATMCallPayoff,
  241.                     dblCallPrice,
  242.                     dblCallProb1,
  243.                     dblCallProb2,
  244.                     dblCallProb1,
  245.                     dblVega,
  246.                     dblTimeDecay - dblRiskFreeRate * dblStrike * dblCallProb2,
  247.                     dblCallRho,
  248.                     dblGamma,
  249.                     dblVanna,
  250.                     dblVomma,
  251.                     dblCharm,
  252.                     dblVeta,
  253.                     dblColor,
  254.                     dblSpeed,
  255.                     dblUltima
  256.                 );

  258.             double dblPutProb1 = org.drip.measure.gaussian.NormalQuadrature.CDF (-1. * dblD1);

  260.             double dblPutProb2 = org.drip.measure.gaussian.NormalQuadrature.CDF (-1. * dblD2);

  262.             return new org.drip.pricer.option.PutGreeks (
  263.                 dblDF,
  264.                 dblVolatility,
  265.                 dblExpectedCallPayoff + dblStrike - dblForward,
  266.                 dblExpectedATMCallPayoff,
  267.                 dblDF * (dblStrike * dblPutProb2 - dblForward * dblPutProb1),
  268.                 dblCallPrice + dblDF * (dblStrike - dblForward),
  269.                 dblPutProb1,
  270.                 dblPutProb2,
  271.                 -1. * dblPutProb1,
  272.                 dblVega,
  273.                 dblTimeDecay + dblRiskFreeRate * dblStrike * dblPutProb2,
  274.                 -1. * dblStrike * dblTimeToExpiry * dblPutProb2,
  275.                 dblGamma,
  276.                 dblVanna,
  277.                 dblVomma,
  278.                 dblCharm,
  279.                 dblVeta,
  280.                 dblColor,
  281.                 dblSpeed,
  282.                 dblUltima
  283.             );
  284.         } catch (java.lang.Exception e) {
  285.             e.printStackTrace();
  286.         }

  288.         return null;
  289.     }
  290. }
Created with JaCoCo 0.7.9.201702052155