Working on CRR

Author: aleCombi

examples/example.jl

@@ -3,20 +3,28 @@ using BenchmarkTools
 
 """Example code with benchmarks"""
 # Define market data and payoff
-market_inputs = h.BlackScholesInputs(0.01, 1, 0.4)
+market_inputs = h.BlackScholesInputs(0, 0.4, 1, 0.4)
 payoff = h.VanillaEuropeanCall(1, 1)
-pricer = h.Pricer(market_inputs, payoff, h.BlackScholesMethod())
-println(pricer())
+analytical_pricer = h.Pricer(payoff, market_inputs, h.BlackScholesMethod())
+price = h.price(payoff, market_inputs, h.BlackScholesMethod())
+
+crr = h.CoxRossRubinsteinMethod(2000)
+crr_pricer = h.Pricer(payoff, market_inputs, crr)
+println("Cox Ross Rubinstein:")
+println(crr_pricer())
+
+println("Analytical price:")
+println(analytical_pricer())
 # Analytical Delta
-analytical_delta_calc = h.DeltaCalculator(pricer, h.BlackScholesAnalyticalDelta())
+analytical_delta_calc = h.DeltaCalculator(analytical_pricer, h.BlackScholesAnalyticalDelta())
 println(analytical_delta_calc())
 
 # AD Delta
-ad_delta_calc = h.DeltaCalculator(pricer, h.ADDelta())
+ad_delta_calc = h.DeltaCalculator(analytical_pricer, h.ADDelta())
 println(ad_delta_calc())
 
 println("Benchmarking pricer:")
-@btime pricer()
+@btime analytical_pricer()
 
 # Run benchmarks
 println("Benchmarking Analytical Delta:")

src/Hedgehog2.jl

@@ -2,6 +2,10 @@ module Hedgehog2
 
 using BenchmarkTools, ForwardDiff, Distributions, Accessors
 
+if false 
+    include("../examples/example.jl")
+end
+
 include("payoffs.jl")
 include("market_inputs.jl")
 include("pricing_methods.jl")

src/delta_methods.jl

@@ -44,7 +44,7 @@ function (delta_calc::DeltaCalculator{BlackScholesAnalyticalDelta, VanillaEurope
     K = delta_calc.pricer.payoff.strike
     r = delta_calc.pricer.marketInputs.rate
     σ = delta_calc.pricer.marketInputs.sigma
-    T = delta_calc.pricer.payoff.time
+    T = delta_calc.pricer.payoff.expiry
     d1 = (log(S / K) + (r + 0.5 * σ^2) * T) / (σ * sqrt(T))
     return cdf(Normal(), d1)  # Black-Scholes delta for calls
 end

src/market_inputs.jl

@@ -9,8 +9,10 @@ abstract type AbstractMarketInputs end
 - `sigma`: The volatility of the underlying asset.
 
 This struct encapsulates the necessary inputs for pricing derivatives under the Black-Scholes model.
+It is assumed that the volatility is annual.
 """
 struct BlackScholesInputs <: AbstractMarketInputs
+    today
     rate
     spot
     sigma

src/payoffs.jl

@@ -5,13 +5,13 @@ abstract type AbstractPayoff end
 
 # Fields
 - `strike`: The strike price of the option.
-- `time`: The time to maturity of the option.
+- `expiry`: The time to maturity of the option.
 
 This struct represents a European call option, which provides a payoff of `max(spot - strike, 0.0)`.
 """
 struct VanillaEuropeanCall <: AbstractPayoff
     strike
-    time
+    expiry
 end
 
 """Computes the payoff of a vanilla European call option given a spot price.
@@ -24,5 +24,5 @@ end
 - The payoff value, calculated as `max(spot - payoff.strike, 0.0)`.
 """
 function (payoff::VanillaEuropeanCall)(spot)
-    return max(spot - payoff.strike, 0.0)
+    return max.(spot .- payoff.strike, 0.0)
 end

src/pricing_methods.jl

@@ -22,9 +22,24 @@ struct BlackScholesMethod <: AbstractPricingMethod end
 A `Pricer` is a callable struct that computes the price of the derivative using the specified pricing method.
 """
 struct Pricer{P <: AbstractPayoff, M <: AbstractMarketInputs, S <: AbstractPricingMethod}
-    marketInputs::M
-    payoff::P
-    pricingMethod::S
+  payoff::P  
+  marketInputs::M
+  pricingMethod::S
+end
+
+"""
+  Computes the price based on a Pricer input object.
+
+  # Arguments
+- `pricer::Pricer{A, B, C}`: 
+  A `Pricer`, specifying a payoff, a market inputs and a method.
+
+# Returns
+- The computed price of the derivative.
+
+"""
+function (pricer::Pricer{A,B,C})() where {A<:AbstractPayoff,B<:AbstractMarketInputs,C<:AbstractPricingMethod}
+  return price(pricer.payoff, pricer.marketInputs, pricer.pricingMethod)
 end
 
 """Computes the price of a vanilla European call option using the Black-Scholes model.
@@ -44,13 +59,41 @@ price = S * Φ(d1) - K * exp(-r * T) * Φ(d2)
 ```
 where `Φ` is the CDF of the standard normal distribution.
 """
-function (pricer::Pricer{VanillaEuropeanCall, BlackScholesInputs, BlackScholesMethod})()
-    S = pricer.marketInputs.spot
-    K = pricer.payoff.strike
-    r = pricer.marketInputs.rate
-    σ = pricer.marketInputs.sigma
-    T = pricer.payoff.time
+function price(payoff::VanillaEuropeanCall, marketInputs::BlackScholesInputs, method::BlackScholesMethod)
+    S = marketInputs.spot
+    K = payoff.strike
+    r = marketInputs.rate
+    σ = marketInputs.sigma
+    T = payoff.expiry
     d1 = (log(S / K) + (r + 0.5 * σ^2) * T) / (σ * sqrt(T))
     d2 = d1 - σ * sqrt(T)
     return S * cdf(Normal(), d1) - K * exp(-r * T) * cdf(Normal(), d2)
 end
+
+"""The Cox-Ross-Rubinstein binomial tree pricing method.
+
+This struct represents the Cox-Ross-Rubinstein binomial pricing model for option pricing.
+"""
+struct CoxRossRubinsteinMethod <: AbstractPricingMethod 
+  steps
+end
+
+function price(payoff::P, market_inputs::BlackScholesInputs, method::CoxRossRubinsteinMethod) where P <: AbstractPayoff
+  ΔT = (payoff.expiry - market_inputs.today) / method.steps
+  step_size = exp(market_inputs.sigma * sqrt(ΔT))
+  up_probability = 1 / (1 + step_size) # this should be specified by the tree choices, configurations of the
+  spots_at_i = i -> step_size .^ (-i:2:i)
+
+  p = up_probability
+  value = payoff(spots_at_i(method.steps))
+
+  for step in method.steps-1:-1:0
+    continuation = p * value[2:end] + (1 - p) * value[1:end-1]
+    df = exp(-market_inputs.rate * ΔT)
+    value = df * continuation
+
+  end
+
+  return value
+
+end