## 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.

`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 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`