com.opengamma.strata.pricer.impl.option

Class BlackFormulaRepository

java.lang.Object

com.opengamma.strata.pricer.impl.option.BlackFormulaRepository

public final class BlackFormulaRepository
extends Object

The primary repository for Black formulas, including the price, common greeks and implied volatility.

Other classes that have higher level abstractions (e.g. option data bundles) should call these functions. As the numeraire (e.g. the zero bond p(0,T) in the T-forward measure) in the Black formula is just a multiplication factor, all prices, input/output, are forward prices, i.e. (spot price)/numeraire. Note that a "reference value" is returned if computation comes across an ambiguous expression.

Method Summary

Modifier and Type	Method and Description
static double	crossGamma(double forward, double strike, double timeToExpiry, double lognormalVol) Computes the driftless cross gamma.
static double	delta(double forward, double strike, double timeToExpiry, double lognormalVol, boolean isCall) Computes the forward driftless delta.
static double	driftlessTheta(double forward, double strike, double timeToExpiry, double lognormalVol) Computes the forward driftless theta.
static double	dualDelta(double forward, double strike, double timeToExpiry, double lognormalVol, boolean isCall) Computes the driftless dual delta.
static double	dualGamma(double forward, double strike, double timeToExpiry, double lognormalVol) Computes the driftless dual gamma.
static double	dualVanna(double forward, double strike, double timeToExpiry, double lognormalVol) Computes the driftless dual vanna.
static double	gamma(double forward, double strike, double timeToExpiry, double lognormalVol) Computes the forward driftless gamma.
static double	impliedStrike(double delta, boolean isCall, double forward, double time, double volatility) Computes the implied strike from delta and volatility in the Black formula.
static double	impliedStrike(double delta, boolean isCall, double forward, double time, double volatility, double[] derivatives) Computes the implied strike and its derivatives from delta and volatility in the Black formula.
static double	impliedVolatility(double price, double forward, double strike, double timeToExpiry, boolean isCall) Computes the log-normal implied volatility.
static double	impliedVolatility(double otmPrice, double forward, double strike, double timeToExpiry, double volGuess) Computes the log-normal (Black) implied volatility of an out-the-money European option starting from an initial guess.
static ValueDerivatives	impliedVolatilityAdjoint(double price, double forward, double strike, double timeToExpiry, boolean isCall) Computes the log-normal implied volatility and its derivative with respect to price.
static ValueDerivatives	impliedVolatilityAdjoint(double otmPrice, double forward, double strike, double timeToExpiry, double volGuess) Computes the log-normal (Black) implied volatility of an out-the-money European option starting from an initial guess and the derivative of the volatility w.r.t.
static double	impliedVolatilityFromNormalApproximated(double forward, double strike, double timeToExpiry, double normalVolatility) Compute the log-normal implied volatility from a normal volatility using an approximate initial guess and a root-finder.
static double	impliedVolatilityFromNormalApproximated2(double forward, double strike, double timeToExpiry, double normalVolatility) Compute the normal implied volatility from a normal volatility using an approximate explicit formula.
static ValueDerivatives	impliedVolatilityFromNormalApproximatedAdjoint(double forward, double strike, double timeToExpiry, double normalVolatility) Compute the log-normal implied volatility from a normal volatility using an approximate initial guess and a root-finder and compute the derivative of the log-normal volatility with respect to the input normal volatility.
static double	price(double forward, double strike, double timeToExpiry, double lognormalVol, boolean isCall) Computes the forward price.
static ValueDerivatives	priceAdjoint(double forward, double strike, double timeToExpiry, double lognormalVol, boolean isCall) Computes the price without numeraire and its derivatives.
static Pair<ValueDerivatives,double[][]>	priceAdjoint2(double forward, double strike, double timeToExpiry, double lognormalVol, boolean isCall) Computes the price without numeraire and its derivatives of the first and second order.
static double	simpleDelta(double forward, double strike, double timeToExpiry, double lognormalVol, boolean isCall) Computes the simple delta.
static double	strikeForDelta(double forward, double forwardDelta, double timeToExpiry, double lognormalVol, boolean isCall) Computes the strike for the delta.
static double	theta(double forward, double strike, double timeToExpiry, double lognormalVol, boolean isCall, double interestRate) Computes the theta (non-forward).
static double	thetaMod(double forward, double strike, double timeToExpiry, double lognormalVol, boolean isCall, double interestRate) Computes the theta (non-forward).
static double	vanna(double forward, double strike, double timeToExpiry, double lognormalVol) Computes the driftless vanna.
static double	vega(double forward, double strike, double timeToExpiry, double lognormalVol) Computes the forward vega.
static double	volga(double forward, double strike, double timeToExpiry, double lognormalVol) Computes the driftless volga (aka vomma).
static double	vomma(double forward, double strike, double timeToExpiry, double lognormalVol) Computes the driftless vomma (aka volga).

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

price

public static double price(double forward,
                           double strike,
                           double timeToExpiry,
                           double lognormalVol,
                           boolean isCall)

Computes the forward price.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

isCall - true for call, false for put

Returns:

the forward price

priceAdjoint

public static ValueDerivatives priceAdjoint(double forward,
                                            double strike,
                                            double timeToExpiry,
                                            double lognormalVol,
                                            boolean isCall)

Computes the price without numeraire and its derivatives.

The derivatives are in the following order:

• [0] derivative with respect to the forward
• [1] derivative with respect to the strike
• [2] derivative with respect to the time to expiry
• [3] derivative with respect to the volatility

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

isCall - true for call, false for put

Returns:

the forward price and its derivatives

priceAdjoint2

public static Pair<ValueDerivatives,double[][]> priceAdjoint2(double forward,
                                                              double strike,
                                                              double timeToExpiry,
                                                              double lognormalVol,
                                                              boolean isCall)

Computes the price without numeraire and its derivatives of the first and second order.

The first order derivatives are in the following order:

• [0] derivative with respect to the forward
• [1] derivative with respect to the strike
• [2] derivative with respect to the time to expiry
• [3] derivative with respect to the volatility

The price and the second order derivatives are in the ValueDerivatives which is the first element of the returned pair.

The second order derivatives are in the following order:

• [0] derivative with respect to the forward
• [1] derivative with respect to the strike
• [2] derivative with respect to the volatility

The second order derivatives are in the double[][] which is the second element of the returned pair.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

isCall - true for call, false for put

Returns:

the forward price and its derivatives

delta

public static double delta(double forward,
                           double strike,
                           double timeToExpiry,
                           double lognormalVol,
                           boolean isCall)

Computes the forward driftless delta.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

isCall - true for call, false for put

Returns:

the forward driftless delta

strikeForDelta

public static double strikeForDelta(double forward,
                                    double forwardDelta,
                                    double timeToExpiry,
                                    double lognormalVol,
                                    boolean isCall)

Computes the strike for the delta.

Parameters:

forward - the forward value of the underlying

forwardDelta - the forward delta

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

isCall - true for call, false for put

Returns:

the strike

dualDelta

public static double dualDelta(double forward,
                               double strike,
                               double timeToExpiry,
                               double lognormalVol,
                               boolean isCall)

Computes the driftless dual delta.

This is the first derivative of option price with respect to strike.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

isCall - true for call, false for put

Returns:

the driftless dual delta

simpleDelta

public static double simpleDelta(double forward,
                                 double strike,
                                 double timeToExpiry,
                                 double lognormalVol,
                                 boolean isCall)

Computes the simple delta.

Note that this is not the standard delta one is accustomed to. The argument of the cumulative normal is simply d = Math.log(forward / strike) / sigmaRootT.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

isCall - true for call, false for put

Returns:

the simple delta

gamma

public static double gamma(double forward,
                           double strike,
                           double timeToExpiry,
                           double lognormalVol)

Computes the forward driftless gamma.

This is the second order sensitivity of the forward option value to the forward.

$\frac{\partial^2 FV}{\partial^2 f}$

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

Returns:

the forward driftless gamma

dualGamma

public static double dualGamma(double forward,
                               double strike,
                               double timeToExpiry,
                               double lognormalVol)

Computes the driftless dual gamma.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

Returns:

the driftless dual gamma

crossGamma

public static double crossGamma(double forward,
                                double strike,
                                double timeToExpiry,
                                double lognormalVol)

Computes the driftless cross gamma.

This is the sensitity of the delta to the strike.

$\frac{\partial^2 V}{\partial f \partial K}$.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

Returns:

the driftless cross gamma

theta

public static double theta(double forward,
                           double strike,
                           double timeToExpiry,
                           double lognormalVol,
                           boolean isCall,
                           double interestRate)

Computes the theta (non-forward).

This is the sensitivity of the present value to a change in time to maturity.

$\-frac{\partial * V}{\partial T}$.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

isCall - true for call, false for put

interestRate - the interest rate

Returns:

theta

thetaMod

public static double thetaMod(double forward,
                              double strike,
                              double timeToExpiry,
                              double lognormalVol,
                              boolean isCall,
                              double interestRate)

Computes the theta (non-forward).

This is the sensitivity of the present value to a change in time to maturity

$\-frac{\partial * V}{\partial T}$.

This is consistent with BlackScholesFormulaRepository.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

isCall - true for call, false for put

interestRate - the interest rate

Returns:

theta

driftlessTheta

public static double driftlessTheta(double forward,
                                    double strike,
                                    double timeToExpiry,
                                    double lognormalVol)

Computes the forward driftless theta.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

Returns:

the driftless theta

vega

public static double vega(double forward,
                          double strike,
                          double timeToExpiry,
                          double lognormalVol)

Computes the forward vega.

This is the sensitivity of the option's forward price wrt the implied volatility (which is just the spot vega divided by the numeraire).

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

Returns:

the forward vega

vanna

public static double vanna(double forward,
                           double strike,
                           double timeToExpiry,
                           double lognormalVol)

Computes the driftless vanna.

This is the second order derivative of the option value, once to the underlying forward and once to volatility.

$\frac{\partial^2 FV}{\partial f \partial \sigma}$.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

Returns:

the driftless vanna

dualVanna

public static double dualVanna(double forward,
                               double strike,
                               double timeToExpiry,
                               double lognormalVol)

Computes the driftless dual vanna.

This is the second order derivative of the option value, once to the strike and once to volatility.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

Returns:

the driftless dual vanna

vomma

public static double vomma(double forward,
                           double strike,
                           double timeToExpiry,
                           double lognormalVol)

Computes the driftless vomma (aka volga).

This is the second order derivative of the option forward price with respect to the implied volatility.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

Returns:

the driftless vomma

volga

public static double volga(double forward,
                           double strike,
                           double timeToExpiry,
                           double lognormalVol)

Computes the driftless volga (aka vomma).

This is the second order derivative of the option forward price with respect to the implied volatility.

Parameters:

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

lognormalVol - the log-normal volatility

Returns:

the driftless volga

impliedVolatility

public static double impliedVolatility(double price,
                                       double forward,
                                       double strike,
                                       double timeToExpiry,
                                       boolean isCall)

Computes the log-normal implied volatility.

Parameters:

price - The forward price, which is the market price divided by the numeraire, for example the zero bond p(0,T) for the T-forward measure

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

isCall - true for call, false for put

Returns:

log-normal (Black) implied volatility

impliedVolatilityAdjoint

public static ValueDerivatives impliedVolatilityAdjoint(double price,
                                                        double forward,
                                                        double strike,
                                                        double timeToExpiry,
                                                        boolean isCall)

Computes the log-normal implied volatility and its derivative with respect to price.

Parameters:

price - The forward price, which is the market price divided by the numeraire, for example the zero bond p(0,T) for the T-forward measure

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

isCall - true for call, false for put

Returns:

log-normal (Black) implied volatility and tis derivative w.r.t. the price

impliedVolatility

public static double impliedVolatility(double otmPrice,
                                       double forward,
                                       double strike,
                                       double timeToExpiry,
                                       double volGuess)

Computes the log-normal (Black) implied volatility of an out-the-money European option starting from an initial guess.

Parameters:

otmPrice - The forward price, which is the market price divided by the numeraire, for example the zero bond p(0,T) for the T-forward measure This MUST be an OTM price, i.e. a call price for strike >= forward and a put price otherwise.

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

volGuess - a guess of the implied volatility

Returns:

log-normal (Black) implied volatility

impliedVolatilityAdjoint

public static ValueDerivatives impliedVolatilityAdjoint(double otmPrice,
                                                        double forward,
                                                        double strike,
                                                        double timeToExpiry,
                                                        double volGuess)

Computes the log-normal (Black) implied volatility of an out-the-money European option starting from an initial guess and the derivative of the volatility w.r.t. the price.

Parameters:

otmPrice - The forward price, which is the market price divided by the numeraire, for example the zero bond p(0,T) for the T-forward measure This MUST be an OTM price, i.e. a call price for strike >= forward and a put price otherwise.

forward - the forward value of the underlying

strike - the strike

timeToExpiry - the time to expiry

volGuess - a guess of the implied volatility

Returns:

log-normal (Black) implied volatility and derivative with respect to the price

impliedStrike

public static double impliedStrike(double delta,
                                   boolean isCall,
                                   double forward,
                                   double time,
                                   double volatility)

Computes the implied strike from delta and volatility in the Black formula.

Parameters:

delta - The option delta

isCall - true for call, false for put

forward - The forward.

time - The time to expiry.

volatility - The volatility.

Returns:

the strike.

impliedStrike

public static double impliedStrike(double delta,
                                   boolean isCall,
                                   double forward,
                                   double time,
                                   double volatility,
                                   double[] derivatives)

Computes the implied strike and its derivatives from delta and volatility in the Black formula.

Parameters:

delta - The option delta

isCall - true for call, false for put

forward - the forward

time - the time to expiry

volatility - the volatility

derivatives - the mutated array of derivatives of the implied strike with respect to the input Derivatives with respect to: [0] delta, [1] forward, [2] time, [3] volatility.

Returns:

the strike

impliedVolatilityFromNormalApproximated

public static double impliedVolatilityFromNormalApproximated(double forward,
                                                             double strike,
                                                             double timeToExpiry,
                                                             double normalVolatility)

Compute the log-normal implied volatility from a normal volatility using an approximate initial guess and a root-finder.

The forward and the strike must be positive.

Reference: Hagan, P. S. Volatility conversion calculator. Technical report, Bloomberg.

Parameters:

forward - the forward rate/price

strike - the option strike

timeToExpiry - the option time to expiration

normalVolatility - the normal implied volatility

Returns:

the Black implied volatility

impliedVolatilityFromNormalApproximatedAdjoint

public static ValueDerivatives impliedVolatilityFromNormalApproximatedAdjoint(double forward,
                                                                              double strike,
                                                                              double timeToExpiry,
                                                                              double normalVolatility)

Compute the log-normal implied volatility from a normal volatility using an approximate initial guess and a root-finder and compute the derivative of the log-normal volatility with respect to the input normal volatility.

The forward and the strike must be positive.

Reference: Hagan, P. S. Volatility conversion calculator. Technical report, Bloomberg.

Parameters:

forward - the forward rate/price

strike - the option strike

timeToExpiry - the option time to expiration

normalVolatility - the normal implied volatility

Returns:

the Black implied volatility and its derivative

impliedVolatilityFromNormalApproximated2

public static double impliedVolatilityFromNormalApproximated2(double forward,
                                                              double strike,
                                                              double timeToExpiry,
                                                              double normalVolatility)

Compute the normal implied volatility from a normal volatility using an approximate explicit formula.

The formula is usually not good enough to be used as such, but provide a good initial guess for a root-finding procedure. Use impliedVolatilityFromNormalApproximated(double, double, double, double) for more precision.

The forward and the strike must be positive.

Reference: Hagan, P. S. Volatility conversion calculator. Technical report, Bloomberg.

Parameters:

forward - the forward rate/price

strike - the option strike

timeToExpiry - the option time to expiration

normalVolatility - the normal implied volatility

Returns:

the Black implied volatility