Add docstrings everywhere

Author: aleCombi

src/delta_methods.jl

@@ -1,16 +1,44 @@
-"""A method for delta calculation"""
+"""A method for delta calculation."""
 abstract type AbstractDeltaMethod end
 
-"""A method for delta calculation analytically using black scholes"""
+"""A method for delta calculation analytically using the Black-Scholes model."""
 struct BlackScholesAnalyticalDelta <: AbstractDeltaMethod end
 
-"""Delta calculator"""
+"""A delta calculator that computes the sensitivity of an option's price to changes in the underlying asset's price.
+
+# Type Parameters
+- `D <: AbstractDeltaMethod`: The method used for delta calculation.
+- `P <: AbstractPayoff`: The type of payoff being priced.
+- `I <: AbstractMarketInputs`: The type of market data inputs required for pricing.
+- `S <: AbstractPricingMethod`: The pricing method used.
+
+# Fields
+- `pricer::Pricer{P, I, S}`: The pricer used to compute the option price.
+- `deltaMethod::D`: The delta calculation method.
+
+A `DeltaCalculator` is a callable struct that computes delta using the specified method.
+"""
 struct DeltaCalculator{D<:AbstractDeltaMethod, P<:AbstractPayoff, I<:AbstractMarketInputs, S<:AbstractPricingMethod}
     pricer::Pricer{P, I, S}
     deltaMethod::D
 end
 
-"""Callable struct: Computes delta when called, using black scholes on a call."""
+"""Computes delta analytically for a vanilla European call option using the Black-Scholes model.
+
+# Arguments
+- `delta_calc::DeltaCalculator{BlackScholesAnalyticalDelta, VanillaEuropeanCall, BlackScholesInputs, BlackScholesMethod}`: 
+  A `DeltaCalculator` configured for Black-Scholes analytical delta calculation.
+
+# Returns
+- The computed delta value.
+
+The Black-Scholes delta formula for a call option is:
+```
+d1 = (log(S / K) + (r + 0.5 * σ^2) * T) / (σ * sqrt(T))
+delta = Φ(d1)
+```
+where `Φ` is the CDF of the standard normal distribution.
+"""
 function (delta_calc::DeltaCalculator{BlackScholesAnalyticalDelta, VanillaEuropeanCall, BlackScholesInputs, BlackScholesMethod})()
     S = delta_calc.pricer.marketInputs.spot
     K = delta_calc.pricer.payoff.strike
@@ -21,10 +49,20 @@ function (delta_calc::DeltaCalculator{BlackScholesAnalyticalDelta, VanillaEurope
     return cdf(Normal(), d1)  # Black-Scholes delta for calls
 end
 
-"""Delta with AD"""
+"""A method for computing delta using automatic differentiation (AD)."""
 struct ADDelta <: AbstractDeltaMethod end
 
-"""Delta with AD callable"""
+"""Computes delta using automatic differentiation (AD).
+
+# Arguments
+- `delta_calc::DeltaCalculator{ADDelta, P, BlackScholesInputs, S}`: 
+  A `DeltaCalculator` configured for AD-based delta calculation.
+
+# Returns
+- The computed delta value using AD.
+
+This method uses `ForwardDiff.derivative` to compute the delta by differentiating the option price with respect to the spot price.
+"""
 function (delta_calc::DeltaCalculator{ADDelta, P, BlackScholesInputs, S})() where {P,S}
     pricer = delta_calc.pricer
     return ForwardDiff.derivative(

src/market_inputs.jl

@@ -1,9 +1,17 @@
-"""market data inputs for pricers"""
+"""An abstract type representing market data inputs required for pricers."""
 abstract type AbstractMarketInputs end
 
-"""Inputs for black scholes model"""
+"""Market data inputs for the Black-Scholes model.
+
+# Fields
+- `rate`: The risk-free interest rate.
+- `spot`: The current spot price of the underlying asset.
+- `sigma`: The volatility of the underlying asset.
+
+This struct encapsulates the necessary inputs for pricing derivatives under the Black-Scholes model.
+"""
 struct BlackScholesInputs <: AbstractMarketInputs
     rate
     spot
     sigma
-end
+end

src/payoffs.jl

@@ -1,13 +1,28 @@
-"""A payoff, such as a vanilla european option or an asian option or a forward."""
+"""An abstract type representing a financial payoff, such as a vanilla European option, an Asian option, or a forward."""
 abstract type AbstractPayoff end
 
-"""vanilla european call payoff"""
+"""A vanilla European call option payoff.
+
+# Fields
+- `strike`: The strike price of the option.
+- `time`: 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
 end
 
-"""vanilla european option callable to get the payoff given a spot price."""
+"""Computes the payoff of a vanilla European call option given a spot price.
+
+# Arguments
+- `payoff::VanillaEuropeanCall`: The call option payoff structure.
+- `spot`: The current spot price of the underlying asset.
+
+# Returns
+- The payoff value, calculated as `max(spot - payoff.strike, 0.0)`.
+"""
 function (payoff::VanillaEuropeanCall)(spot)
     return max(spot - payoff.strike, 0.0)
-end
+end

src/pricing_methods.jl

@@ -1,19 +1,50 @@
-"""A pricing method"""
+"""An abstract type representing a pricing method."""
 abstract type AbstractPricingMethod end
 
-"""Black scholes method"""
+"""The Black-Scholes pricing method.
+
+This struct represents the Black-Scholes pricing model for option pricing.
+"""
 struct BlackScholesMethod <: AbstractPricingMethod end
 
-"""# the whole algorithm to price a specific derivative, using specific market inputs and a pricing method.
-# it should be a callable made up of all the ingredients: a payoff, market data, a pricing model"""
-struct Pricer{P <: AbstractPayoff, M <: AbstractMarketInputs, S<:AbstractPricingMethod}
+"""A pricer that calculates the price of a derivative using a given payoff, market data, and a pricing model.
+
+# Type Parameters
+- `P <: AbstractPayoff`: The type of payoff being priced.
+- `M <: AbstractMarketInputs`: The type of market data inputs required for pricing.
+- `S <: AbstractPricingMethod`: The pricing method used.
+
+# Fields
+- `marketInputs::M`: The market data inputs used for pricing.
+- `payoff::P`: The derivative payoff.
+- `pricingMethod::S`: The pricing model used for valuation.
+
+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
 end
 
-"""Dispatch of pricer for call black scholes pricing"""
-function (pricer::Pricer{VanillaEuropeanCall, BlackScholesInputs, BlackScholesMethod})() 
+"""Computes the price of a vanilla European call option using the Black-Scholes model.
+
+# Arguments
+- `pricer::Pricer{VanillaEuropeanCall, BlackScholesInputs, BlackScholesMethod}`: 
+  A `Pricer` configured for Black-Scholes pricing of a vanilla European call.
+
+# Returns
+- The computed Black-Scholes price of the option.
+
+The Black-Scholes formula used is:
+```
+d1 = (log(S / K) + (r + 0.5 * σ^2) * T) / (σ * sqrt(T))
+d2 = d1 - σ * sqrt(T)
+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

test/runtests.jl

@@ -4,3 +4,4 @@ using Test
 @testset "Hedgehog2.jl" begin
     # Write your tests here.
 end
+