Java tutorial
/** * Copyright (C) 2016 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.strata.pricer.impl.option; import com.google.common.math.DoubleMath; import com.opengamma.strata.basics.value.ValueDerivatives; import com.opengamma.strata.collect.ArgChecker; import com.opengamma.strata.collect.array.DoubleArray; import com.opengamma.strata.math.impl.statistics.distribution.NormalDistribution; import com.opengamma.strata.math.impl.statistics.distribution.ProbabilityDistribution; import com.opengamma.strata.product.option.SimpleConstantContinuousBarrier; /** * The price function to compute the price of one-touch or no-touch (cash-or-nothing) option in the Black world. * <p> * This function prices one-touch/no-touch option, where the cash payment can occur at hit for a one-touch option, and * at expiry for a no-touch option. * Reference: E. G. Haug (2007) The complete guide to Option Pricing Formulas. Mc Graw Hill. Section 4.19.5. */ public class BlackOneTouchCashPriceFormulaRepository { /** * The normal distribution implementation used in the pricing. */ private static final ProbabilityDistribution<Double> NORMAL = new NormalDistribution(0, 1); /** * Small parameter. */ private static final double SMALL = 1.0e-6; /** * Computes the price of a one-touch/no-touch option. * * @param spot the spot * @param timeToExpiry the time to expiry * @param costOfCarry the cost of carry * @param rate the interest rate * @param lognormalVol the lognormal volatility * @param barrier the barrier * @return the price */ public double price(double spot, double timeToExpiry, double costOfCarry, double rate, double lognormalVol, SimpleConstantContinuousBarrier barrier) { ArgChecker.notNull(barrier, "barrier"); boolean isKnockIn = barrier.getKnockType().isKnockIn(); boolean isDown = barrier.getBarrierType().isDown(); double h = barrier.getBarrierLevel(); ArgChecker.isFalse(isDown && spot <= barrier.getBarrierLevel(), "The Data is not consistent with an alive barrier (DOWN and spot<=barrier)."); ArgChecker.isFalse(!isDown && spot >= barrier.getBarrierLevel(), "The Data is not consistent with an alive barrier (UP and spot>=barrier)."); double eta = isDown ? 1 : -1; double df2 = Math.exp(-rate * timeToExpiry); double lognormalVolSq = lognormalVol * lognormalVol; double lognormalVolT = lognormalVol * Math.sqrt(timeToExpiry); if (DoubleMath.fuzzyEquals(Math.min(timeToExpiry, lognormalVolSq), 0d, SMALL)) { return isKnockIn ? 0d : df2; } double mu = (costOfCarry - 0.5 * lognormalVolSq) / lognormalVolSq; double lambda = Math.sqrt(mu * mu + 2 * rate / lognormalVolSq); double m1 = lognormalVolT * (1 + mu); double x2 = Math.log(spot / h) / lognormalVolT + m1; double y2 = Math.log(h / spot) / lognormalVolT + m1; double z = Math.log(h / spot) / lognormalVolT + lambda * lognormalVolT; double xE = isKnockIn ? getF(spot, z, lognormalVolT, h, mu, lambda, eta) : getE(spot, df2, x2, y2, lognormalVolT, h, mu, eta); return xE; } /** * Computes the price and derivatives of a one-touch/no-touch option. * <p> * The derivatives are [0] spot, [1] rate, [2] cost-of-carry, [3] volatility, [4] timeToExpiry, [5] spot twice. * * @param spot the spot * @param timeToExpiry the time to expiry * @param costOfCarry the cost of carry * @param rate the interest rate * @param lognormalVol the lognormal volatility * @param barrier the barrier * @return the price and derivatives */ public ValueDerivatives priceAdjoint(double spot, double timeToExpiry, double costOfCarry, double rate, double lognormalVol, SimpleConstantContinuousBarrier barrier) { ArgChecker.notNull(barrier, "barrier"); double[] derivatives = new double[6]; boolean isKnockIn = barrier.getKnockType().isKnockIn(); boolean isDown = barrier.getBarrierType().isDown(); double h = barrier.getBarrierLevel(); ArgChecker.isFalse(isDown && spot <= barrier.getBarrierLevel(), "The Data is not consistent with an alive barrier (DOWN and spot<=barrier)."); ArgChecker.isFalse(!isDown && spot >= barrier.getBarrierLevel(), "The Data is not consistent with an alive barrier (UP and spot>=barrier)."); double eta = isDown ? 1 : -1; double df2 = Math.exp(-rate * timeToExpiry); double lognormalVolSq = lognormalVol * lognormalVol; double lognormalVolT = lognormalVol * Math.sqrt(timeToExpiry); if (DoubleMath.fuzzyEquals(Math.min(timeToExpiry, lognormalVolSq), 0d, SMALL)) { if (isKnockIn) { return ValueDerivatives.of(0d, DoubleArray.filled(6)); } double price = df2; derivatives[1] = -timeToExpiry * price; derivatives[4] = -rate * price; return ValueDerivatives.of(price, DoubleArray.ofUnsafe(derivatives)); } double mu = (costOfCarry - 0.5 * lognormalVolSq) / lognormalVolSq; double lambda = Math.sqrt(mu * mu + 2d * rate / lognormalVolSq); double m1 = lognormalVolT * (1d + mu); double x2 = Math.log(spot / h) / lognormalVolT + m1; double y2 = Math.log(h / spot) / lognormalVolT + m1; double z = Math.log(h / spot) / lognormalVolT + lambda * lognormalVolT; double[] eDerivFirst = new double[6]; double[] eDerivSecond = new double[6]; double[] fDerivFirst = new double[5]; double[] fDerivSecond = new double[5]; double price = isKnockIn ? getFAdjoint(spot, z, lognormalVolT, h, mu, lambda, eta, fDerivFirst, fDerivSecond) : getEAdjoint(spot, df2, x2, y2, lognormalVolT, h, mu, eta, eDerivFirst, eDerivSecond); double zBar = 0.0; double y2Bar = 0.0; double x2Bar = 0.0; double zSqBar = 0.0; double y2SqBar = 0.0; double x2SqBar = 0.0; double zsBar = 0.0; double y2sBar = 0.0; double lambdaBar = 0.0; double muBar = 0.0; double lognormalVolTBar = 0.0; double df2Bar = 0.0; if (isKnockIn) { zBar = fDerivFirst[1]; lambdaBar = fDerivFirst[4]; // only F has lambda dependence, which in turn is a function of mu, see muBar+= below muBar = fDerivFirst[3]; lognormalVolTBar = fDerivFirst[2]; derivatives[0] = fDerivFirst[0]; zSqBar = fDerivSecond[1]; zsBar = fDerivSecond[2]; derivatives[5] = fDerivSecond[0]; } else { y2Bar = eDerivFirst[3]; x2Bar = eDerivFirst[2]; muBar = eDerivFirst[5]; lognormalVolTBar = eDerivFirst[4]; df2Bar = eDerivFirst[1]; derivatives[0] = eDerivFirst[0]; y2SqBar = eDerivSecond[2]; x2SqBar = eDerivSecond[1]; y2sBar = eDerivSecond[3]; derivatives[5] = eDerivSecond[0]; } double dxyds = 1d / spot / lognormalVolT; double m1Bar = x2Bar + y2Bar; muBar += +lognormalVolT * m1Bar + mu / lambda * lambdaBar; lognormalVolTBar += +(lambda - Math.log(h / spot) / (lognormalVolT * lognormalVolT)) * zBar - Math.log(h / spot) / (lognormalVolT * lognormalVolT) * y2Bar - Math.log(spot / h) / (lognormalVolT * lognormalVolT) * x2Bar + (1 + mu) * m1Bar; double lognormalVolSqBar = -costOfCarry / (lognormalVolSq * lognormalVolSq) * muBar - rate / (lognormalVolSq * lognormalVolSq) / lambda * lambdaBar; derivatives[0] += dxyds * x2Bar - dxyds * y2Bar - dxyds * zBar; derivatives[1] = -timeToExpiry * df2 * df2Bar + lambdaBar / lambda / lognormalVolSq; derivatives[2] = muBar / lognormalVolSq; derivatives[3] = 2d * lognormalVol * lognormalVolSqBar + Math.sqrt(timeToExpiry) * lognormalVolTBar; derivatives[4] = -rate * df2 * df2Bar + lognormalVolTBar * lognormalVolT * 0.5 / timeToExpiry; derivatives[5] += -dxyds * x2Bar / spot + dxyds * y2Bar / spot + dxyds * zBar / spot + dxyds * dxyds * x2SqBar + dxyds * dxyds * y2SqBar - 2d * dxyds * y2sBar + dxyds * dxyds * zSqBar - 2d * dxyds * zsBar; return ValueDerivatives.of(price, DoubleArray.ofUnsafe(derivatives)); } //------------------------------------------------------------------------- private double getE(double s, double df2, double x, double y, double lognormalVolT, double h, double mu, double eta) { return df2 * (NORMAL.getCDF(eta * (x - lognormalVolT)) - Math.pow(h / s, 2d * mu) * NORMAL.getCDF(eta * (y - lognormalVolT))); } private double getF(double s, double z, double lognormalVolT, double h, double mu, double lambda, double eta) { return Math.pow(h / s, mu + lambda) * NORMAL.getCDF(eta * z) + Math.pow(h / s, mu - lambda) * NORMAL.getCDF(eta * (z - 2d * lambda * lognormalVolT)); } //------------------------------------------------------------------------- // The firstDerivatives are [0] s, [1] df2, [2] x, [3] y, [4] lognormalVolT, [5] mu. // The second derivatives are [0] s twice, [1] x twice, [2] y twice, [3] s and y. private double getEAdjoint(double s, double df2, double x, double y, double lognormalVolT, double h, double mu, double eta, double[] firstDerivatives, double[] secondDerivatives) { double n1 = NORMAL.getCDF(eta * (x - lognormalVolT)); double n2 = NORMAL.getCDF(eta * (y - lognormalVolT)); double hsMu = Math.pow(h / s, 2 * mu); double e = df2 * (n1 - hsMu * n2); double n1df = NORMAL.getPDF(eta * (x - lognormalVolT)); double n2df = NORMAL.getPDF(eta * (y - lognormalVolT)); double hsMuBar = df2 * -n2; double n2Bar = df2 * -hsMu; double n1Bar = df2; firstDerivatives[0] = -2d * mu * hsMu / s * hsMuBar; // s firstDerivatives[1] = n1 - hsMu * n2; // df2; firstDerivatives[2] = n1df * eta * n1Bar; // x firstDerivatives[3] = n2df * eta * n2Bar; // y firstDerivatives[4] = n2df * -eta * n2Bar + n1df * -eta * n1Bar; // lognormalVolT firstDerivatives[5] = 2d * Math.log(h / s) * hsMu * hsMuBar; // mu secondDerivatives[0] = hsMu * hsMuBar * 2d * mu * (2d * mu + 1d) / (s * s); secondDerivatives[1] = -n1df * n1Bar * (x - lognormalVolT) * eta; secondDerivatives[2] = -n2df * n2Bar * (y - lognormalVolT) * eta; secondDerivatives[3] = -2d * mu * n2df * eta * n2Bar / s; return e; } // The firstDerivatives are [0] s, [1] z, [2] lognormalVolT, [3] mu, [4] lambda. // The second derivatives are [0] s twice, [1] z twice, [2] s and z. private double getFAdjoint(double s, double z, double lognormalVolT, double h, double mu, double lambda, double eta, double[] firstDerivatives, double[] secondDerivatives) { double n1 = NORMAL.getCDF(eta * z); double n2 = NORMAL.getCDF(eta * (z - 2 * lambda * lognormalVolT)); double hsMuPLa = Math.pow(h / s, mu + lambda); double hsMuMLa = Math.pow(h / s, mu - lambda); double f = hsMuPLa * n1 + hsMuMLa * n2; double fBar = 1.0; double n1df = NORMAL.getPDF(eta * z); double n2df = NORMAL.getPDF(eta * (z - 2 * lambda * lognormalVolT)); double hsMuPLaBar = n1 * fBar; double hsMuMLaBar = n2 * fBar; double n2Bar = hsMuMLa * fBar; double n1Bar = hsMuPLa * fBar; firstDerivatives[0] = -(mu + lambda) * hsMuPLa / s * hsMuPLaBar - (mu - lambda) * hsMuMLa / s * hsMuMLaBar; //s firstDerivatives[1] = n1df * eta * n1Bar + n2df * eta * n2Bar; // z firstDerivatives[2] = -n2df * eta * 2 * lambda * n2Bar; //lognormalVolT firstDerivatives[3] = hsMuPLa * Math.log(h / s) * hsMuPLaBar + hsMuMLa * Math.log(h / s) * hsMuMLaBar; // mu firstDerivatives[4] = hsMuPLa * Math.log(h / s) * hsMuPLaBar - hsMuMLa * Math.log(h / s) * hsMuMLaBar; // lambda secondDerivatives[0] = hsMuPLa * hsMuPLaBar * (mu + lambda) * (mu + lambda + 1d) / (s * s) + hsMuMLa * hsMuMLaBar * (mu - lambda) * (mu - lambda + 1d) / (s * s); secondDerivatives[1] = -z * n1df * eta * n1Bar - (z - 2 * lambda * lognormalVolT) * n2df * eta * n2Bar; secondDerivatives[2] = -n1df * n1Bar * (mu + lambda) * eta / s - n2df * n2Bar * (mu - lambda) * eta / s; return f; } }