Pricing Models

Pricing models used with the price! function all have a corresponding Model subtype. Current pricing models supported are BlackScholes, BinomialTree, MonteCarlo{<:MonteCarloModel}, and StockPrice.

Pricing Base Assets (Widgets)

All Widget subtypes can be priced with any pricing model subtype of Model. price! returns the last price in the array of the prices field. To make code more explicit, the StockPrice type may be used which does not have a method for any Financial Instrument.

Pricing FinancialInstruments

Pricing a FinancialInstrument with the price! function returns the theoretical price and mutates the values_library field of the FinancialInstrument. values_library contains all theoretical prices for the Financial Instrument that have been calculated with the function arguments used in the calculation.

Black Scholes Model

The Black-Scholes-Merton model for pricing European options.

Use BlackScholes with the price!.

Only defined for EuroCallOption and EuroPutOption.

Example: pricing a three month European call option

# creating a stock
stock = Stock(50.0; volatility=.32)

# creating a 3 month European call option with a $55 strike price 
call = EuroCallOption(;widget=stock, strike_price=55, maturity=.25, risk_free_rate=.02)

call_price = price!(call, BlackScholes)
call_price == call.values_library["BlackScholes"]["value"]

Binomial Pricing Model

The Binomial options pricing model.

Use BinomialTree with the price!.

Defined for all Option subtypes.

Extra function arguments:

  • tree_depth: The number of levels or time steps included in the tree. Default is three.
  • delta: The continuous dividend rate of the underlying stock (or other base asset). Default is zero.

Example: pricing a three month American call option.

# creating a stock
stock = Stock(50.0; volatility=.32)

# creating a 3 month American call option with a $55 strike price 
call = AmericanCallOption(;widget=stock, strike_price=55, maturity=.25, risk_free_rate=.02)

# calculating the options price using 5 time steps in the tree
call_price = price!(call, BinomialTree; tree_depth=5)
call_price == call.values_library["BinomialTree"]["value"]

Monte Carlo Pricing Model

Monte Carlo simulation valuation for options. Returns the average discounted payoff of the option at the end of the stochasticly simulated time-series. Current possible simulation methods are:

Use MonteCarlo{T} with price! where T is either LogDiffusion or MCBootstrap type.

Only defined for EuroCallOption and EuroPutOption. For MCBootstrap, a static Widget cannot be used, Widget.prices field must have at least three prices, and timesteps_per_period cannot be zero.

Extra function arguments for LogDiffusion :

  • n_sims: The number of simulations to run in the Monte Carlo analysis. Default 100.
  • sim_size: The number of generated steps in each simulation. Defualt 100.

For MCBootstrap:

  • n_sims: The number of simulations to run in the Monte Carlo analysis. Default 100.
  • bootstrap_method: The type of time-series bootstrap to be used. Possiple types are Stationary, CircularBlock, and MovingBlock. Default is Stationary.

Note: values are stored in the Option.values_library field with the keys "MC_LogDiffusion" and "MC_Bootstrap{bootstrap_method}".

Example: pricing a three month European call option

# creating a stock with a random array for historic prices
historic_prices = rand(45:50, 20)
stock = Stock(;prices = historic_prices)

# creating a 6 month European call option with a $55 strike price 
call = EuroCallOption(stock, 55, .5, .02)

# calculating the options price using log diffusion sim model
mc_logdiff_price = price!(call, MonteCarlo{LogDiffusion}; n_sims=50, sim_size=60)

# calculate the option price using time-series bootstrap
mc_stationary = price!(call, MonteCarlo{MCBootstrap}; n_sims=50, bootstrap_method=Stationary)
mc_circular = price!(call, MonteCarlo{MCBootstrap}; n_sims=50, bootstrap_method=CircularBlock)
mc_movingblock = price!(call, MonteCarlo{MCBootstrap}; n_sims=50, bootstrap_method=MovingBlock)

# accessing the values
mc_logdiff_price == call.values_library["MC_LogDiffusion"]["value"]
mc_stationary == call.values_library["MC_Bootstrap{Stationary}"]["value"]
mc_circular == call.values_library["MC_Bootstrap{CircularBlock}"]["value"]
mc_movingblock == call.values_library["MC_Bootstrap{MovingBlock}"]["value"]