Options
Class BlackScholesCall

java.lang.Object
  Options.Option
      Options.PathIndependentOption
          Options.Call
              Options.BlackScholesCall

public class BlackScholesCall

extends Call

Plain vanilla European call. The underlying follows a geometric Brownian motion with constant drift and volatility.

This class implements a large variety of hedge weights ("deltas") and methods to compute the discounted hedge error. It is assumed that the hedge is rebalanced at each time step. The generality here is greater than in the case of a general option. For example we can simulate paths of the underlying both in the market probability and the risk neutral probability.

Analytic Price: All prices are discounted

prices, that is, delta is the derivative of the discounted call price with respect to the discounted price of the underlying and similarly for all the other greeks. No assumptions are made on the underlying asset. It should be noted that these analytic formulas are supported by theory only for nonstochastic volatility assets.

Field Summary

Fields inherited from class Options.Option

ANALYTIC_DELTA, ANALYTIC_MINIMUM_VARIANCE_DELTA, ANALYTIC_QUOTIENT_DELTA, MARKET_PROBABILITY, MINIMUM_VARIANCE_DELTA, MONTE_CARLO_DELTA, QUOTIENT_DELTA, RISK_NEUTRAL_PROBABILITY

Constructor Summary

BlackScholesCall(double K, ConstantVolatilityAsset asset)

Method Summary

double	analyticDelta(int t) Analytic delta exp(-q(T-t))N(d_+) computed from discounted price S[t]=S^B(t).
double	analyticDelta(int t, double hedge_sigma) Analytic delta: D(t)=exp(-q(T-t))N(d_+) based on arbitrary volatility hedge_sigma not necessarily equal to the true volatility of the underlying asset.
double	analyticGamma(int t) Analytic call gamma: (dDelta/dS) Present implementation only correct for zero dividends.
double	analyticSGamma(int t) S(t)*(dDelta/dS)(t).
double	analyticTheta(int t) Analytic theta: dC/dt.
double	analyticThetaDelta(int t) Analytic theta of delta: (dDelta/dt).
double	analyticVega(int t) Analytic vega: dC/dsigma.
double	currentDiscountedHedgeGain(double hedge_sigma, double fixed_trc, double prop_trc) Computes the discounted profit and loss of the delta hedge of a short position in one call along one path of the underlying simulated under the market probability.
double	discountedAnalyticPrice(int t) Analytic Black-Scholes price C(t).
double	hedgeErrorVarianceReduction(int nPath) Computes the reduction in the variance of the hedge error over the first hedge interval [0,dt] which the variance minimizing delta provides compared to the analytic delta as a percentage of the minimal variance.
static void	main(java.lang.String[] args) Program tests quality of the analytic approximation for market deltas accross a variety of strikes and times to maturity.

Methods inherited from class Options.Call

currentDiscountedPayoff, get_K

Methods inherited from class Options.PathIndependentOption

controlledDiscountedPayoff, discountedPayoff, minimumVarianceDelta, minimumVarianceDelta

Methods inherited from class Options.Option

analyticMinimumVarianceDelta, analyticQuotientDelta, conditionalControlVariateCorrelation, controlledDiscountedMonteCarloPrice, controlledDiscountedMonteCarloPrice, controlledDiscountedMonteCarloPrice, controlledDiscountedMonteCarloPrice, controlVariateCorrelation, currentDiscountedHedgeGain, discountedHedgeGain, discountedMonteCarloPrice, discountedMonteCarloPrice, discountedMonteCarloPrice, discountedMonteCarloPrice, get_C, get_dt, get_T, get_underlying, getName, hasAnalyticPrice, monteCarloDelta, newDiscountedPricePath, quotientDelta, quotientDelta, underlyingIsCVA, underlyingIsDividendFreeCVA

Methods inherited from class java.lang.Object

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

Constructor Detail

BlackScholesCall

public BlackScholesCall(double K,
                        ConstantVolatilityAsset asset)

Parameters:

K - strike price.

asset - underlying, must be of type ConstantVolatilityAsset.

Method Detail

discountedAnalyticPrice

public double discountedAnalyticPrice(int t)

Analytic Black-Scholes price C(t).

Overrides:

discountedAnalyticPrice in class Option

Parameters:

t - current time.

analyticDelta

public double analyticDelta(int t)

Analytic delta exp(-q(T-t))N(d_+) computed from discounted price S[t]=S^B(t).

Overrides:

analyticDelta in class Option

Parameters:

t - current time.

analyticDelta

public double analyticDelta(int t,
                            double hedge_sigma)

Analytic delta: D(t)=exp(-q(T-t))N(d_+) based on arbitrary volatility hedge_sigma not necessarily equal to the true volatility of the underlying asset.

Used to study the effect of misjudging the true volatility of the underlying asset on hedge performance.

Parameters:

t - current time

hedge_sigma - volatility employed in computing hegde weights

analyticTheta

public double analyticTheta(int t)

Analytic theta: dC/dt. Present implementation only correct for zero dividends.

Overrides:

analyticTheta in class Option

Parameters:

t - current time.

analyticVega

public double analyticVega(int t)

Analytic vega: dC/dsigma. Present implementation only correct for zero dividends.

Overrides:

analyticVega in class Option

Parameters:

t - current time.

analyticSGamma

public double analyticSGamma(int t)

S(t)*(dDelta/dS)(t). Present implementation only correct for zero dividends. This quantity rather than gamma is needed for discrete hedging. Note this.

Overrides:

analyticSGamma in class Option

Parameters:

t - current time.

analyticGamma

public double analyticGamma(int t)

Analytic call gamma: (dDelta/dS) Present implementation only correct for zero dividends.

Overrides:

analyticGamma in class Option

Parameters:

t - current time.

analyticThetaDelta

public double analyticThetaDelta(int t)

Analytic theta of delta: (dDelta/dt). Present implementation only correct for zero dividends.

Overrides:

analyticThetaDelta in class Option

Parameters:

t - current time.

currentDiscountedHedgeGain

public double currentDiscountedHedgeGain(double hedge_sigma,
                                         double fixed_trc,
                                         double prop_trc)

Computes the discounted profit and loss of the delta hedge of a short position in one call along one path of the underlying simulated under the market probability. The hedge is rebalanced at each time step.

The hedge employs analytic deltas computed using a volatility hedge_sigma which may be different from the true volatility sigma of the underlying. This is used to study the effect of misjudging the volatility on hedge performance.

Transaction costs have a fixed and a proportional component. The fixed component also has to be normalized to cost per one share. If you transact in lots of 1000 shares and such a trade costs 10 dollars fixed transaction costs are 10/1000=0.01. The proportional transaction costs come from bid-ask spread etc., 0.1 is a conservative number. Transaction costs are assumed to remain constant in today's dollars.

The option price path C[0] must be initialized with the option price at time zero before this routine is called. Current implementation of the class Call does this at call initialization.

Parameters:

hedge_sigma - volatility under which deltas are computed.

fixed_trc - fixed transaction costs (normalized to one share).

prop_trc - proportional transaction costs.

hedgeErrorVarianceReduction

public double hedgeErrorVarianceReduction(int nPath)

Computes the reduction in the variance of the hedge error over the first hedge interval [0,dt] which the variance minimizing delta provides compared to the analytic delta as a percentage of the minimal variance. The paths of the underlying are simulated in the risk neutral probability.

main

public static void main(java.lang.String[] args)
                 throws java.io.IOException

Program tests quality of the analytic approximation for market deltas accross a variety of strikes and times to maturity. Both are compared to classical deltas.

Throws:

java.io.IOException