```java.lang.Object TradingStrategies.TradingStrategy TradingStrategies.StrategyDeltaHedging
```

public class StrategyDeltaHedging

The trading strategy which trades in the underlying to hedge a short position in one option on one share of the underlying using one of the following weights:

• minimum variance deltas
(`whichDelta=Flag.MV_DELTA`)
• analytic minimum variance deltas
(`whichDelta=Flag.AM_DELTA`)
• quotient deltas
(`whichDelta=Flag.Q_DELTA`)
• analytic quotient deltas
(`whichDelta=Flag.AQ_DELTA`)
• Monte Carlo deltas
(`whichDelta=Flag.MC_DELTA`)
• (classic) analytic deltas
(`whichDelta=Flag.A_DELTA`)

The hedge is rebalanced whenever the Trigger rebalance triggers a hedge trade. The hedge is checked against price paths of the underlying simulated under the market probability.

WARNING: all analytic deltas disregard the trade trigger and operate as if the hedge were rebalanced at each time step. This is as intended in the case of classic analytic deltas and Monte Carlo deltas (the Monte Carlo version of analytic deltas). In the case of analytic minimum variance and quotient deltas it is a shortcoming of the present implementation.

At each trade nonanalytic hedge weights are derived from conditional expectations. For minimum variance deltas these conditional expectations are computed under the market probability, for Monte Carlo deltas they are computed under the risk neutral probability. See the TeX file HedgeWeights.tex.

The flag `whichDelta` indicate which type of delta is used in the hedge.

RUN TIME: Conditional expectations which are computed via branching the price paths of the underlying asset are computationally costly. Therefore analytic deltas are by orders of magnitude faster than the others.

Assume that N paths of the underlying are to be simulated and each conditional expectation uses N path branches. Then each minimum variance and quotient delta is O(N) if there is an analytic option price formula and O(N^2) if there is no such formula. Consequently the entire simulation is O(N^2) or O(N^3) respectively. O(N^3) means that you will not live to see the simulation finish for realistic values of N.

 Constructor Summary ```StrategyDeltaHedging(Asset underlying, Option option, Trigger rebalance, int whichDelta, int nBranch, double fixed_trc, double prop_trc)```

 Method Summary ` int` `get_nBranch()`           Number of path branches used in conditional expectations (hedge deltas). ` Option` `get_option()`           The option to be hedged. ` int` `get_whichDelta()`           Type of delta used in hedge ` double` `newWeight(int t)`           Hedge weight: number of shares of the underlying held at time t.

 Methods inherited from class TradingStrategies.TradingStrategy `discountedGainsAndNumberOfTrades, discountedGainsFromTrading, get_asset, get_B, get_currentWeight, get_dt, get_fixed_trc, get_nTrades, get_prop_trc, get_S, get_T, get_tradeTrigger, initialInvestment, newDiscountedGainsAndNumberOfTrades, newDiscountedGainsFromTrading, newReturnFromTrading, newTradeStatistics, returnsFromTrading, tradeStatistics`

 Methods inherited from class java.lang.Object `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

 Constructor Detail

### StrategyDeltaHedging

```public StrategyDeltaHedging(Asset underlying,
Option option,
Trigger rebalance,
int whichDelta,
int nBranch,
double fixed_trc,
double prop_trc)```
Parameters:
`underlying` - asset underlying the option.
`option` - option to be hedged.
`rebalance` - trigger triggering the hedge trades.
`whichDelta` - see deltas.
`nBranch` - number of asset price path branches spent on each conditional expectation.
`fixed_trc` - fixed transaction costs per trade.
`prop_trc` - proportional transaction costs per trade.
 Method Detail

### get_option

`public Option get_option()`
The option to be hedged.

### get_whichDelta

`public int get_whichDelta()`
Type of delta used in hedge

### get_nBranch

`public int get_nBranch()`
Number of path branches used in conditional expectations (hedge deltas).

### newWeight

`public double newWeight(int t)`

Hedge weight: number of shares of the underlying held at time t.

Specified by:
`newWeight` in class `TradingStrategy`
Parameters:
`t` - current time.