Formula Reference

Complete Mathematical Reference | All Pricing Formulas

📐 How to Use This Reference

This page contains all the mathematical formulas used in structured products and options pricing. Each formula includes:

• Mathematical notation
• Variable definitions
• Practical example
• When to use it

Quick Navigation: Options Pricing | Greeks | Volatility | Statistics | Structured Products

Options Pricing

Black-Scholes Formula (European Call)

C = S × N(d₁) - K × e^(-rT) × N(d₂)

Where:
d₁ = [ln(S/K) + (r + σ²/2)T] / (σ√T)
d₂ = d₁ - σ√T

Variables:
C = Call option price
S = Current spot price
K = Strike price
T = Time to expiration (years)
σ = Volatility (annualized)
r = Risk-free interest rate
N(x) = Cumulative standard normal distribution
e = Euler's number ≈ 2.71828
ln = Natural logarithm

Example:

S = $50,000, K = $55,000, T = 0.25 years, σ = 0.80, r = 0.04

d₁ = [ln(50000/55000) + (0.04 + 0.64/2)×0.25] / (0.80×√0.25)
   = [-0.0953 + 0.09] / 0.40 = -0.0133

d₂ = -0.0133 - 0.40 = -0.4133

N(d₁) = 0.4947, N(d₂) = 0.3395

C = 50000×0.4947 - 55000×e^(-0.01)×0.3395
  = 24,735 - 18,479 = $6,256

Black-Scholes Formula (European Put)

P = K × e^(-rT) × N(-d₂) - S × N(-d₁)

Or using Put-Call Parity:
P = C - S + K × e^(-rT)

Put-Call Parity

C - P = S - K × e^(-rT)

Rearranged:
P = C - S + K × e^(-rT)
C = P + S - K × e^(-rT)

Use: Verify no-arbitrage relationship, calculate one option price from the other.

Greeks

Delta (Δ)

Call Delta:
Δ_call = N(d₁)

Put Delta:
Δ_put = N(d₁) - 1 = -N(-d₁)

Range:
Calls: 0 to +1
Puts: -1 to 0

Interpretation: For $1 increase in underlying, option changes by Δ dollars.

Gamma (Γ)

Γ = n(d₁) / (S × σ × √T)

Where:
n(x) = (1/√2π) × e^(-x²/2)  [Standard normal PDF]

Same for calls and puts:
Γ_call = Γ_put

Peak: Gamma is highest for ATM options near expiration.

Theta (Θ)

Call Theta:
Θ_call = -(S × n(d₁) × σ)/(2√T) - r × K × e^(-rT) × N(d₂)

Put Theta:
Θ_put = -(S × n(d₁) × σ)/(2√T) + r × K × e^(-rT) × N(-d₂)

Units: $ per day (typically negative for long options)

Note: Divide by 365 to get daily theta from annualized calculation.

Vega (ν)

ν = S × √T × n(d₁)

Same for calls and puts:
ν_call = ν_put

Units: $ per 1% change in volatility

Example:

S = $50,000, T = 0.25, n(d₁) = 0.398

ν = 50,000 × √0.25 × 0.398
  = 50,000 × 0.5 × 0.398
  = $9,950 per 1% IV change

Rho (ρ)

Call Rho:
ρ_call = K × T × e^(-rT) × N(d₂)

Put Rho:
ρ_put = -K × T × e^(-rT) × N(-d₂)

Units: $ per 1% change in interest rate

Volatility

Historical Volatility

σ_annual = σ_daily × √(Trading Days per Year)

Where:
σ_daily = √[Σ(R_i - R_mean)² / (N-1)]

R_i = ln(P_i / P_(i-1))  [Daily return]
N = Number of observations
Trading Days = 252 (stocks), 365 (crypto)

Example:

Daily returns: [2%, -1%, 3%, -2%, 1%]
Mean return = 0.6%
Variance = [(2-0.6)² + (-1-0.6)² + ...] / 4 = 4.8
σ_daily = √4.8 = 2.19%
σ_annual = 2.19% × √252 = 34.8%

Implied Volatility (Newton-Raphson Method)

Iterative formula:
σ_(n+1) = σ_n - [BS(σ_n) - Market Price] / Vega(σ_n)

Where:
BS(σ) = Black-Scholes price at volatility σ
Iterate until |σ_(n+1) - σ_n| < tolerance

Statistics

Normal Distribution

PDF (Probability Density Function):
f(x) = (1/√2π) × e^(-x²/2)

CDF (Cumulative Distribution Function):
N(x) = ∫_{-∞}^x f(t) dt

Properties:
N(0) = 0.5
N(-x) = 1 - N(x)

Log-Normal Distribution

Asset prices follow log-normal distribution in Black-Scholes framework.

If returns ~ Normal(μ, σ²)
Then prices ~ LogNormal

PDF:
f(x) = (1/(xσ√2π)) × e^(-(ln(x)-μ)²/(2σ²))

Variance and Standard Deviation

Variance:
Var(X) = E[(X - μ)²] = E[X²] - (E[X])²

Standard Deviation:
σ = √Var(X)

Annualization:
σ_annual = σ_period × √(Periods per Year)

Structured Products

Principal Protected Note Participation

Participation Rate = (Investment - Bond Cost) / (ATM Call Price)

Where:
Bond Cost = Principal / (1 + r)^T

Example:
Investment = $100,000
r = 5%, T = 1 year
Bond Cost = $100,000 / 1.05 = $95,238
Option Budget = $100,000 - $95,238 = $4,762
ATM Call Price = $8,000

Participation = $4,762 / $8,000 = 59.5%

Covered Call Return

Max Return = (Strike - Purchase Price + Premium) / Purchase Price

Example:
Bought BTC at $48,000
Sold $55,000 call for $2,500

Max Return = ($55,000 - $48,000 + $2,500) / $48,000
           = $9,500 / $48,000 = 19.8%

Break-Even Points

Long Call Break-Even:
BE = Strike + Premium Paid

Long Put Break-Even:
BE = Strike - Premium Paid

Covered Call Break-Even:
BE = Purchase Price - Premium Received

Monte Carlo Simulation

Geometric Brownian Motion (Discrete)

S_(t+Δt) = S_t × exp[(μ - σ²/2)Δt + σ√Δt × Z]

Where:
Z ~ N(0,1)  [Standard normal random variable]
μ = Drift (expected return)
σ = Volatility
Δt = Time step

Algorithm:

for simulation in range(N):
    S = S0
    for step in range(time_steps):
        Z = random.standard_normal()
        S = S * exp((r - 0.5*sigma**2)*dt + sigma*sqrt(dt)*Z)
    payoff[simulation] = max(S - K, 0)
 
option_price = exp(-r*T) * mean(payoff)

Standard Error (Monte Carlo)

SE = σ_payoffs / √N

95% Confidence Interval:
Price ± 1.96 × SE

Where:
σ_payoffs = Standard deviation of simulated payoffs
N = Number of simulations

Interest Rate Formulas

Present Value

PV = FV / (1 + r)^T

Or continuous compounding:
PV = FV × e^(-rT)

Future Value

FV = PV × (1 + r)^T

Or continuous compounding:
FV = PV × e^(rT)

Compound Interest

FV = PV × (1 + r/m)^(mT)

Where:
m = Compounding frequency per year

Correlation and Covariance

Correlation

ρ(X,Y) = Cov(X,Y) / (σ_X × σ_Y)

Range: -1 to +1
+1 = Perfect positive correlation
0 = No correlation
-1 = Perfect negative correlation

Covariance

Cov(X,Y) = E[(X - μ_X)(Y - μ_Y)]

Use: Multi-asset structures, basket options, portfolio risk.

Quick Reference Tables

Common N(d) Values

Time Conversions

Code Implementations

Python: Black-Scholes

from scipy.stats import norm
import numpy as np
 
def black_scholes_call(S, K, T, r, sigma):
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)
    return S*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
 
def black_scholes_put(S, K, T, r, sigma):
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)
    return K*np.exp(-r*T)*norm.cdf(-d2) - S*norm.cdf(-d1)

Python: Greeks

def delta_call(S, K, T, r, sigma):
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    return norm.cdf(d1)
 
def gamma(S, K, T, r, sigma):
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    return norm.pdf(d1) / (S*sigma*np.sqrt(T))
 
def vega(S, K, T, r, sigma):
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    return S*norm.pdf(d1)*np.sqrt(T)

Additional Resources

Learn More:

• Black-Scholes Module - Detailed explanation
• The Greeks Module - Greek sensitivities
• Monte Carlo Module - Simulation methods

Interactive Tools:

• Formula Calculator - Calculate any formula
• Greeks Calculator - Real-time Greek computation
• Options Pricer - Price any option

Last Updated: October 2025 Version: 1.0

All formulas verified and tested. Use with appropriate risk management and understanding of assumptions.