Black–Scholes model

The Black–Scholes model (Black and Scholes 1973), introduced in 1973, is a foundational model in option pricing. Its main idea is to model the underlying asset price through a lognormal dynamics. Under the risk-neutral measure, the asset price follows the stochastic differential equation

where is a constant volatility, is a deterministic risk-free rate, and is a standard Brownian motion, that is normally distributed with law .

That being said, one can obtain an explicit expression for the spot price .

Taking a close look at this formulae, we can identify a log normal structure of spot price that allows European option prices to be computed explicitly. For example, for a European call option with strike and maturity , the risk-neutral price at time is

where , is the cumulative distribution function of the standard normal distribution, and $ d_= $.

The main limitation of this model is the assumption that volatility is constant. In practice, market option prices imply different volatilities for different strikes and maturities, producing the well-known implied volatility smile or skew. This observation motivates the introduction of richer volatility models.

Local Volatility: Dupire model

To address the empirical fact that volatility is not constant across strikes and maturities, Bruno Dupire introduced the local volatility model in 1994 (Dupire et al. 1994). In this framework, the volatility is no longer constant, but is instead a deterministic function of time and the underlying asset price. The asset price dynamics are given by

Allowing the volatility to depend on both and is particularly useful because it gives enough flexibility to match the full implied volatility surface observed in the market. However, market quotes are not directly expressed as functions of the future spot process . Instead, European option prices are observed as a function of strike and maturity . We can therefore view market call prices as a surface

By differentiating this surface with respect to strike and maturity, Dupire derived a formula linking the observed option price surface to the local volatility function. Assuming constant interest rate , the local volatility is given by

This formula shows that, under suitable regularity and no-arbitrage conditions, the local volatility surface can be recovered from European call prices. The local volatility model can therefore be calibrated exactly to the market implied volatility surface at the initial calibration date. Its main drawback, however, is dynamic. Although the model perfectly reproduces today’s vanilla option prices, the future evolution of the smile generated by the model is generally not consistent with the forward smile dynamics observed in the market. This limitation motivates the introduction of stochastic volatility models and, ultimately, stochastic local volatility models.

Stochastic volatility models

Stochastic volatility models were introduced to better reproduce the empirical dynamics of financial markets by allowing volatility itself to evolve randomly over time. Unlike the Black–Scholes model, where volatility is constant, these models introduce additional state variables that generate richer smile dynamics and more realistic volatility behavior. However, by adding a second source of randomness, they generally lead to market incompleteness. This mean, we could not perfectly hedge a derivative with the spot as underlying. Moreover, when specified with a finite number of parameters, they usually cannot fit an arbitrary implied volatility surface exactly.

In such models, the spot price typically follows a dynamics of the form : , where is now a stochastic process. Several stochastic volatility models have been proposed in the literature. One of the most widely used is the Heston model, introduced by Steven Heston. Under the risk-neutral measure, its dynamics are given by

where denotes the instantaneous variance. The parameter is the mean-reversion speed, is the long-term variance level, is the volatility of volatility, and is the instantaneous correlation between the Brownian motion driving the asset price and the Brownian motion driving the variance. Through these parameters, the model captures the stylized features of volatility dynamics.

Stochastic local volatility models

Knowing the respective advantages and drawbacks of local and stochastic volatility models, the stochastic local volatility framework was developed to combine the exact calibration capability of local volatility models with the richer smile dynamics generated by stochastic volatility models. A stochastic local volatility model can be written as follows :

where is a stochastic volatility factor and is a deterministic function called the leverage function.

The goal of introducing the stochastic factor is to capture featurs of stochastic volatility models. That is to reproduce more realistic forward smile dynamics and volatility clustering effects observed in the market, while retaining enough flexibility to calibrate the model to vanilla option prices. The leverage function is then chosen so that the SLV model matches the market prices of European vanilla options, or equivalently, the market implied volatility surface.

More precisely, the leverage function is calibrated so that the one-dimensional marginal distributions of the SLV model coincide with those implied by the corresponding local volatility model. This condition leads to the relation

where denotes the local volatility surface obtained from Dupire’s formula.

Hence, the local volatility component ensures exact calibration to European vanilla option prices, while the stochastic volatility factor provides more realistic dynamics for exotic derivatives and forward smiles. The main numerical difficulty lies in the conditional expectation appearing in the denominator, since it depends on the joint distribution of the spot and the stochastic volatility factor. This is precisely where the particle method of Guyon and Henry-Labordère becomes useful.

The calibration problem is therefore transformed into the numerical estimation of a conditional expectation. Since this expectation depends on the law of the process being calibrated, the resulting dynamics are nonlinear in the McKean sense. Guyon and Henry-Labordère propose a particle method to approximate this nonlinear dynamics and recover the leverage function iteratively.

Monte carlo scheme

We now describe a Monte Carlo simulation scheme for the SLV model. Let be a discretization of the interval , with time steps . In order to simulate both volatility and the spot process, we will use respectively the conditional moments of the euler discretisation and the log-euler discretisation scheme knowing since the processes followed a normal distribution. In order to take in account the correlation between both processes, we use the conditional correlation between by using a cholesky decomposition which is :

Hence, one can jointly simulate by generating two independent standard Gaussian random variables and .

The simulation scheme is then

This procedure is repeated sequentially over all time intervals in order to generate Monte Carlo trajectories of the SLV model.

Results

To calibrate the leverage function, we simulate paths. For the minimum and maximum values of , take the 0.1% and 99.9% quantiles of the risk-neutral distribution of at , i.e., since the smile is flat at , of the distribution of , with a standard Gaussian random variable. We suggest that the grid contain 30 equally spaced spot values. We also use the quartic kernel to perform kernel regression to estimate the conditional expectation, while fine-tuning the dimensionless bandwidth parameter . The kernel is defined as follows:

To check that the resulting model is indeed calibrated to the market implied volatilities , we compute estimates of the call prices (maturity ) in the calibrated model for strikes , and invert the Black-Scholes formula to get the corresponding estimation of the implied volatilities . To estimate the call prices in the calibrated model, we simulated a new set of independent paths with the calibrated leverage function and paths.

As shown in the following results, the SLV model calibrated via the particle method reproduces vanilla option prices with an implied volatility close to the market input. The mean absolute error is 12.3 bp, with the largest deviations occurring at deep in-the-money and out-of-the-money strikes, as expected.

The leverage function (blue) is strongly increasing with the spot price, ranging from approximately 0.5 near to values above 1.5 at the right tail. This shape reflects the correction that the leverage function must apply to compensate for the stochastic volatility factor : since (orange) is itself decreasing with the spot level, must increase to ensure that their product remains consistent with the market implied volatility surface.

The total volatility (green) remains remarkably flat across the entire spot range, hovering around 0.15. This is precisely the calibration objective: the particle method has successfully determined a leverage function such that the SLV model reproduces a flat implied volatility surface consistent with the market input .

Python codes

import numpy as np
from scipy.optimize import minimize_scalar

def quartic_kernel(x):
    """
    Quartic kernel used in the Nadaraya-Watson regression.
    """
    # Values outside [-1, 1] are clipped, which gives zero weight at the boundary.
    x = np.clip(x, -1, 1)

    return (x + 1)**2 * (1 - x)**2

def bandwidth(kappa_bw, tk, sigma_tk, S0, N):
    """
    Compute the kernel bandwidth in spot-price units.
    """
    return kappa_bw * sigma_tk * S0 * np.sqrt(max(tk, 0.15)) * N**(-0.2)


def cv_bandwidth(S_particles,a2_particles,tk,sigma_tk,S0,N,kernel=quartic_kernel,bounds=(0.3, 3.0)):
    """
    Select the bandwidth multiplier by leave-one-out cross-validation.
    """

    def cv_loss(kappa_bw):
        # Convert the bandwidth multiplier into an actual bandwidth.
        h = bandwidth(kappa_bw, tk, sigma_tk, S0, N)

        # Compute pairwise normalized distances between particles.
        u = (S_particles[None, :] - S_particles[:, None]) / h

        # Kernel weights between particles.
        W = kernel(u)

        # Exclude each particle from its own regression estimate.
        np.fill_diagonal(W, 0.0)

        # Nadaraya-Watson numerator and denominator.
        num_loo = W @ a2_particles
        den_loo = W.sum(axis=1)

        # Use the global mean if too few neighbours are available.
        valid = den_loo > 1e-10
        m_hat = np.full_like(a2_particles, a2_particles.mean(), dtype=float)
        m_hat[valid] = num_loo[valid] / den_loo[valid]

        # Cross-validation error.
        return np.mean((a2_particles - m_hat) ** 2)

    result = minimize_scalar(cv_loss, bounds=bounds, method="bounded")
    return result.x

def kernel_regression(S_particles, a2_particles, grid, h, kernel=quartic_kernel):
    """
    Estimate E[a_t^2 | S_t = s] on a spot grid.
    """
    # Compute normalized distances between grid points and particles.
    u = (S_particles[None, :] - grid[:, None]) / h

    # Kernel weights around each grid point.
    W = kernel(u)

    # Nadaraya-Watson numerator and denominator.
    num = W @ a2_particles
    denom = W.sum(axis=1)

    # Use the global mean when no particle contributes to a grid point.
    valid = denom > 1e-12
    cond_exp = np.full_like(grid, a2_particles.mean(), dtype=float)
    cond_exp[valid] = num[valid] / denom[valid]

    # Avoid division by zero later in the leverage function.
    return np.maximum(cond_exp, 1e-8)

import numpy as np
from scipy.interpolate import CubicSpline
from scipy.stats import norm

def spot_grid(tk, S0, sigma_mkt, n_points=30):
    """
    Build the spot grid G_{t_k} from lognormal quantiles.
    """
    # At time zero, all particles start from the same initial spot.
    if tk <= 0:
        return np.array([S0])

    # Lower bound of the grid: 0.1% lognormal quantile.
    S_min = S0 * np.exp( sigma_mkt * np.sqrt(tk) * norm.ppf(0.001) - 0.5 * sigma_mkt**2 * tk)

    # Upper bound of the grid: 99.9% lognormal quantile.
    S_max = S0 * np.exp( sigma_mkt * np.sqrt(tk) * norm.ppf(0.999) - 0.5 * sigma_mkt**2 * tk)

    return np.linspace(S_min, S_max, n_points)


def particle_method( S0, Y0, sigma0, rho, gamma, kappa, sigma_mkt, N, n_steps, Dt, seed=123):
    """
    Calibrate the leverage function l(t_k, S) with the Guyon-Henry-Labordere
    particle method.
    """
    np.random.seed(seed)

    # Initial stochastic volatility factor and initial leverage value.
    a0 = sigma0 * np.exp(Y0)
    l0 = sigma_mkt / a0

    # Initialize all particles at the same spot and volatility state.
    S_tk = np.full(N, S0, dtype=float)
    Y_tk = np.full(N, Y0, dtype=float)

    # Initial spot grid and initial constant leverage spline.
    K_grid_init = spot_grid(Dt, S0, sigma_mkt, n_points=30)
    spline_prev = CubicSpline(K_grid_init, np.full(30, l0))
    K_grid_prev = K_grid_init

    # Store the calibrated leverage splines and their associated grids.
    splines = {}
    Stoch_vol = {}
    K_grids = {}

    for k in range(1, n_steps + 1):
        tk = k * Dt

        # Evaluate the previous leverage function at current particle spots.
        l_prev = spline_prev( np.clip(S_tk, K_grid_prev[0], K_grid_prev[-1]) )

        # Effective correlation induced by exact simulation of the OU factor.
        rho_bar = rho * np.sqrt(
            2 * (1 - np.exp(-kappa * Dt))
            / (kappa * Dt * (1 + np.exp(-kappa * Dt)))
        )

        # Independent Gaussian variables used to generate correlated increments.
        Z1 = np.random.randn(N)
        Z2 = np.random.randn(N)

        # Exact simulation of the Ornstein-Uhlenbeck volatility factor.
        Y_new = (
            np.exp(-kappa * Dt) * Y_tk
            + gamma
            * np.sqrt((1 - np.exp(-2 * kappa * Dt)) / (2 * kappa))
            * Z2
        )

        # Effective volatility of each particle over the current time step.
        sig_eff = sigma0 * np.exp(Y_tk) * l_prev

        # Log-Euler update of the spot process.
        log_S_new = (
            np.log(np.maximum(S_tk, 1e-8))
            - 0.5 * sig_eff**2 * Dt
            + sig_eff
            * np.sqrt(Dt)
            * (np.sqrt(1 - rho_bar**2) * Z1 + rho_bar * Z2)
        )

        S_new = np.exp(log_S_new)
        a_new = sigma0 * np.exp(Y_new)

        # Build the spot grid at the current time.
        K_grid = spot_grid(tk, S0, sigma_mkt, n_points=30)

        # Squared stochastic volatility factor used in the conditional expectation.
        a2_new = a_new**2

        # Select the bandwidth parameter once, then reuse it at later dates.
        if k == 1:
            kappa_opt = cv_bandwidth(S_new, a2_new, tk, sigma_mkt, S0, N, kernel=quartic_kernel)

        h = bandwidth(kappa_opt, tk, sigma_mkt, S0, N)

        # Estimate E[a_t^2 | S_t = S] on the spot grid.
        cond_exp = kernel_regression(S_new, a2_new, K_grid, h, kernel=quartic_kernel)

        # Compute the leverage function from the calibration identity.
        l_values = sigma_mkt / np.sqrt(cond_exp)

        # Interpolate the leverage function on the current spot grid.
        spline_curr = CubicSpline(K_grid, l_values)

        # Store current leverage spline and grid.
        splines[k] = spline_curr
        K_grids[k] = K_grid
        Stoch_vol[k] = np.sqrt(cond_exp)

        # Move to the next time step.
        spline_prev = spline_curr
        K_grid_prev = K_grid
        S_tk = S_new
        Y_tk = Y_new

    print(f"Optimal bandwidth multiplier: {kappa_opt:.2f}")

    return splines, K_grids, Stoch_vol


def simulate_calibrated(S0, Y0, sigma0, rho, gamma, kappa, sigma_mkt, N2, n_steps, Dt, splines=None, K_grids=None, seed=42):
    """
    Simulate paths under the calibrated SLV model.
    """
    np.random.seed(seed)

    # Initialize validation particles.
    S_tk = np.full(N2, S0, dtype=float)
    Y_tk = np.full(N2, Y0, dtype=float)

    # Store simulated spot paths.
    S_paths = np.zeros((n_steps + 1, N2))
    S_paths[0] = S_tk

    Y_paths = np.zeros((n_steps + 1, N2))
    Y_paths[0] = Y_tk

    for k in range(1, n_steps + 1):

        # Use calibrated leverage if provided; otherwise simulate pure stochastic volatility.
        if splines is None or K_grids is None:
            l_prev = np.ones(N2)
        else:
            # Use the leverage function calibrated at the previous time step.
            spline_prev = splines[k - 1] if k > 1 else splines[1]
            K_grid_prev = K_grids[k - 1] if k > 1 else K_grids[1]

            l_prev = spline_prev(
                np.clip(S_tk, K_grid_prev[0], K_grid_prev[-1])
            )

        # Effective correlation for the joint simulation of log-spot and OU factor.
        rho_bar = rho * np.sqrt(
            2 * (1 - np.exp(-kappa * Dt))
            / (kappa * Dt * (1 + np.exp(-kappa * Dt)))
        )

        # Independent Gaussian variables.
        Z1 = np.random.randn(N2)
        Z2 = np.random.randn(N2)

        # Exact update of the OU volatility factor.
        Y_new = (
            np.exp(-kappa * Dt) * Y_tk
            + gamma
            * np.sqrt((1 - np.exp(-2 * kappa * Dt)) / (2 * kappa))
            * Z2
        )

        # Effective volatility under the calibrated SLV model.
        sig_eff = sigma0 * np.exp(Y_tk) * l_prev

        # Log-Euler update of the spot process.
        log_S_new = (
            np.log(np.maximum(S_tk, 1e-8))
            - 0.5 * sig_eff**2 * Dt
            + sig_eff
            * np.sqrt(Dt)
            * (np.sqrt(1 - rho_bar**2) * Z1 + rho_bar * Z2)
        )

        # Store new spot values and update the volatility factor.
        S_tk = np.exp(log_S_new)
        S_paths[k] = S_tk
        Y_tk = Y_new
        Y_paths[k] = Y_tk

    return S_paths, Y_paths

from py_vollib.black_scholes.implied_volatility import implied_volatility
vec_find_vol_rat = np.vectorize(implied_volatility)   # a better implied vol estimator based on "P Jäckel Let's be rational"

def blackscholes_price(K, T, S, vol, r=0, q=0, callput='call'):
    """
    Compute the call/put option price in Black-Scholes model
    """
    F = S*np.exp((r-q)*T)
    w = vol**2*T
    d1 = (np.log(F/K)+0.5*w)/np.sqrt(w)
    d2 = d1 - np.sqrt(w)
    callput = callput.lower()
    if callput == 'call':
        opttype = 1
    elif callput == 'put':
        opttype = -1
    else:
        raise ValueError('The value of callput must be either "call" or "put".')
    price = (opttype*F*norm.cdf(opttype*d1)-opttype*K*norm.cdf(opttype*(d2)))*np.exp(-r*T)
    return price

# ── Paramètres du modèle
T       = 1.0
S0      = 100.0
sigma0  = 0.15
Y0      = 0.0
rho     = -0.50
gamma   = 0.50
kappa   = 1.0
sigma_mkt = 0.15    # smile plat

# ── Paramètres numériques
Dt       = 1 / 100
n_steps  = int(T / Dt)
N_calib  = 10_000
N_valid  = 100_000

# Strikes pour la validation
strikes = np.array([70, 80, 90, 100, 110, 120, 130, 140], dtype=float)

# ── Étape A : Calibration ─────────────────────────────────────────────
print("=" * 60)
print(f"CALIBRATION  N={N_calib}  Nt={n_steps}")
splines, K_grids, Stoch_vol = particle_method(
    S0=S0, Y0=Y0, sigma0=sigma0, rho=rho,
    gamma=gamma, kappa=kappa,
    sigma_mkt=sigma_mkt,
    N=N_calib, n_steps=n_steps, Dt=Dt, seed=42
)
print("Calibration terminée.\n")


# ── Étape B : Simulation avec levier calibré
print("=" * 60)
print(f"VALIDATION   N={N_valid}")
S_paths, Y_paths = simulate_calibrated(
    S0=S0, Y0=Y0, sigma0=sigma0, rho=rho,
    gamma=gamma, kappa=kappa, sigma_mkt=sigma_mkt,
    N2=N_valid, n_steps=n_steps, Dt=Dt,
    splines=splines, K_grids=K_grids, seed=123
)

import matplotlib.pyplot as plt

# Show simulation paths
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
axes[1].plot(sigma0 * np.exp(Y_paths[:, :100]))
axes[1].set_title("$a_t$ paths")

axes[0].set_title(f"$S_t$ paths")
axes[0].plot(S_paths[:, :100])

plt.tight_layout()
plt.show()

# Decomposition of leverage functions
#=======================

K_grid = K_grids[max(K_grids.keys())]
l_vals = splines[max(splines.keys())](K_grid)
a_vals = Stoch_vol[max(Stoch_vol.keys())]

plt.figure(figsize=(12, 4))
plt.plot(K_grid, l_vals, label=r'$l(t, K)$ — leverage function')
plt.plot(K_grid, a_vals, label=r'$a_t$ — stochastic volatility factor')
plt.plot(K_grid, l_vals * a_vals, label=r'$\sigma(t, K) = l(t,K)\cdot a_t$ — total volatility')
plt.xlabel("Spot price $S_t$")
plt.ylabel("Volatility")
plt.title("Decomposition of the fitted SLV volatility")
plt.legend()
plt.show()

# ── Étape C : Prix des calls et volatilités implicites
print(f"\n{'Strike':>8}  {'Call MC':>10}  {'Call BS':>10}  {'IV hat':>10}  {'Erreur (bp)':>12}")
print("-" * 58)

S_T = S_paths[-1,:] # spot prices at T
for K in strikes:
    # Prix Monte-Carlo
    call_mc = np.mean(np.maximum(S_T - K, 0))

    # Prix Black-Scholes à sigma_mkt
    call_bs = blackscholes_price(K=K,T=T,S=S0,vol=sigma_mkt,callput='call')

    # Volatilité implicite
    try:
        iv = vec_find_vol_rat(price=call_mc, S=S0, K=K, t=T, r=0, flag='c')        
        err_bp = np.abs(iv - sigma_mkt)* 1e4
        print(f"{K:>8.0f}  {call_mc:>10.4f}  {call_bs:>10.4f}  {iv:>10.4%}  {err_bp:>+12.1f}")
    except Exception:
        print(f"{K:>8.0f}  {call_mc:>10.4f}  {call_bs:>10.4f}  {'  N/A':>10}  {'  N/A':>12}")

print("-" * 58)
ivs = []
for K in strikes:
    try:
        price = np.mean(np.maximum(S_T - K, 0))
        ivs.append(vec_find_vol_rat(price, S0, K, T, 0, 'c'))
    except Exception:
        ivs.append(np.nan)
ivs = np.array(ivs)
valid = ~np.isnan(ivs)
mae_bp = np.mean(np.abs(ivs[valid] - sigma_mkt)) * 1e4
print(f"Erreur absolue moyenne : {mae_bp:.1f} bp")
print("=" * 60)

Mathematical details of simulation

Hedging

A French company needs to purchase oil in three months to supply its factories, but fears that the price per barrel may rise in the meantime. To protect itself, it buys a call option on oil with a strike price fixed today at $80.

• If in three months the barrel price rises to $95, the company exercises its call and buys at $80. Hence, the company has avoided the price increase.
• If the price stays at $75, it does not exercise the option and buys directly on the market, meaning the company has only lost the option premium.

Speculation

An investor anticipates a rise in a given stock, currently at $200. Rather than buying the stock outright, they buy a call with a strike of $210, which costs $8.

• If the stock rises to $230, they exercise the option: they buy at $210 what is worth $230. This represents a gain of $20 for an initial outlay of only $8, illustrating the leverage effect of options.
• If the stock stays below $210, they do not exercise and only lose the $8 premium.

The option allows one to benefit from an anticipated rise without investing the full amount, while capping the maximum loss at the premium paid.

Arbitrage

Consider a stock worth €105, with a call and a put both struck at €100, priced at €12 and €6 respectively, and a zero risk-free rate. The call–put parity states that:

In our case, , but . There is a €1 discrepancy: the call is overpriced. An investor can therefore build the following arbitrage portfolio today:

At maturity, the stock is delivered against the strike of €100, repaying the loan exactly, and the portfolio closes flat regardless of the final stock price. The investor locks in a risk-free gain of €1 today ,a textbook arbitrage.

Black scholes model

The Black-Scholes model (Black and Scholes 1973) was published in 1973 by Fischer Black and Myron Scholes to provide a theoretical valuation formula for options. Under this model, the underlying asset is assumed to follow a geometric Brownian motion:

under the historical probability measure , where is the drift and is the constant volatility.

By Girsanov’s theorem, there exists a risk-neutral probability measure under which the discounted asset price is a martingale. The change of measure is characterized by the market price of risk , and under the dynamics become:

where is a Brownian motion under , and is the risk-free rate.

This means that under , the stock grows on average at the risk-free rate — not because investors are assumed to be risk-neutral, but because the change of measure absorbs the risk premium, making discounted prices martingales for pricing purposes. The remaining term captures the random fluctuations of the stock price.

By applying Itô’s formula to , we obtain an analytical expression for :

Since is a Brownian motion under , it follows a normal distribution . Hence, is normally distributed:

and follows a log-normal distribution.

Knowing this, the price of a call option can be computed explicitly :

where is the cumulative distribution function of the standard normal distribution, and:

Zero-coupon bond price and simple spot interest rate

Assume we pay at time to buy a zero-coupon bond that will pay at maturity . Hence, at maturity . Alternatively, we can invest in the money market account that pays the simple spot rate . At maturity , we obtain . Since we are in a no-arbitrage framework, we must have the same payoff at maturity for both strategies, which implies . Hence, we deduce the following link between the zero-coupon bond price and the simple spot interest rate:

In continuous compounding, we have , which gives :

Therefore, the short-term interest rate is defined as .

Zero-coupon bond price and simple forward interest rate

The forward rate is the rate that can be locked at time for a loan starting at date and ending at date . At time , one can invest in a zero-coupon bond maturing at and obtain at maturity . Alternatively, one can invest in a zero-coupon bond maturing at , obtain at time , and then reinvest the proceeds from to at the forward rate . At maturity , this yields . Under no-arbitrage, we must have . Hence,

The instantaneous forward rate satisfies . Moreover,

FRA

A FRA (Forward Rate Agreement) is a contract that fixes at time an interest rate for the period on a nominal . Its payoff at time is

Its price at time is

Swap

A swap exchanges fixed and floating interest rates between two counterparties over dates on a nominal . The fixed leg pays . The floating leg pays . The swap can be seen as a sum of FRA. Its price is

Cap/Floor

A caplet (resp. floorlet) is an option that gives the right to the buyer to receive (resp. pay) the excess of the floating rate over a strike on a nominal . The caplet payoff is

The floorlet payoff is

Hence a cap is a chain of caplets for , and a floor is a chain of floorlets for .

Swaption

A swaption is an option based on interest rate swap of maturity and fixed rate . Assuming is the starting date of the swap, the payoff of a swaption is

Thus, the swaption can be seen as a put option on a classical bond with coupon

Structural properties of a financial market

For a financial market to function efficiently, several properties are desirable. Liquidity ensures that assets can be traded without significant price impact. Transparency guarantees that relevant information is accessible to participants. Fairness implies equal access to market information. Efficiency requires that prices reflect available information and that arbitrage opportunities do not persist.

The absence of arbitrage is a central assumption in modern financial mathematics and underlies pricing theory.

Trading strategies and wealth process

A trading strategy is a predictable process where represents the number of units of asset held at time .

The associated wealth process is defined by

A strategy is said to be self-financing if changes in wealth are solely due to variations in asset prices. In discrete time, this condition reads Equivalently,

Risk-neutral measure

Under the absence of arbitrage, there exists an equivalent probability measure under which discounted asset prices are martingales. Let denote the discounted price process. Then This result allows derivative pricing via expectation: where denotes the contingent claim payoff at maturity.

Market completeness

The market is said to be complete if every contingent claim can be replicated by a self-financing strategy. In a complete market, the risk-neutral measure is unique and every derivative admits a unique arbitrage-free price. In an incomplete market, multiple risk-neutral measures may exist and perfect replication is not always possible, leading to pricing and hedging challenges.

As an illustration, the payoff of a European call option with strike and maturity is given by

Explicit Euler Scheme or Euler Forward Scheme

Le schéma d’Euler explicite est un schéma basé sur une discrétisation explicite en temps. La discrétisation de l’EDP est basée sur des approximations centrées. Dès lors, on approxime les dérivées partielles de la manière suivante :

On peut la réécrire sous la forme matricielle afin d’extraire une solution numérique dite explicite : Sous forma matricielle, le schéma s’écrit :

où - g est un vecteur de défini par pour ,

• est une matrice carrée tridiagonale de taille . En posant et , les coefficients de la matrice sont donnés par :

  

• un vecteur de qui dépendent des paramètres du modèle et de la discrétisation spatiale donné par :

  

De fait, on obtient la relation de récurrence explicite permettant de calculer en fonction de :

Implicit Euler Scheme

Pour des raisons de stabilité, on peut également utiliser un schéma d’Euler implicite, qui est basé sur une discrétisation implicite en temps.

Higher order schemes

Enfin, nous envisagerons de comparer les schémas d’Euler implicite, les schémas de type Crank-Nicolson, et un schéma d’ordre 2 tel que le BDF2.

Euler Explicit Scheme

Nous étudions ici le comportement du schéma d’Euler explicite appliqué à l’équation de Black–Scholes pour une option américaine de type put. Les simulations sont réalisées en faisant varier les paramètres de discrétisation spatiale J et temporelle N, tout en imposant la contrainte d’obstacle à chaque pas de temps.

Les figures présentées correspondent aux cas suivants (pour les deux payoffs considérés) :

• N = 20, J = 50
• N = 20, J = 20
• N = 50, J = 20

Pour chaque configuration, le prix numérique de l’option est comparé au payoff, et la valeur associée à la condition de CFL est calculée.

r_ = 0.1
sigma_ = 0.3
K_ = 100
T_ = 1
Smin_ = 50
Smax_ = 250
print("Paramètres financiers:")
print("r=%.2f" %r_, "sigma=%.2f" %sigma_, "K=%.0f" %K_, "T=%.0f" %T_)

# Definition des paramètres dans un dictionnaire
params = dict(
    r=r_,
    sigma=sigma_,
    K=K_,
    T=T_,
    N=None, # Valeur à définir plus tard
    J=None, # Valeur à définir plus tard
    Smin=Smin_,
    Smax=Smax_
)

Paramètres financiers:
r=0.10 sigma=0.30 K=100 T=1

J_values = [50, 20, 20]
N_values = [20, 20, 50]

cfl_records1 = []

fig, axes = plt.subplots(1, 3, figsize=(24, 8), sharey=False)
for j, (N_, J_) in enumerate(zip(N_values, J_values)):
    params['N'] = N_
    params['J'] = J_

    ee = SchemeEE(**params, payoff=1)
    U, t = ee.solve()
    s = ee.s
    dt = ee.dt

    #CFL condition
    CFL = dt / (ee.h ** 2) * (ee.sigma ** 2) * (ee.Smax ** 2)

    # Enregistrement dans la table
    cfl_records1.append({
        "N": N_,
        "J": J_,
        "CFL": CFL
    })

    ax = axes[j]
    ax.plot(s, U, label="Prix option")
    ax.plot(s, ee.phi(s), 'k--', label="Payoff")

    ax.set_title(f"N = {N_}, J = {J_}")
    ax.set_xlabel("s")
    if j == 0:
        ax.set_ylabel("u(t,s)")
    ax.legend()

plt.suptitle(
    f"Evolution du prix du put américain -- Scheme {ee.scheme_name}",
    fontsize=16
)
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()

J_values = [50, 20, 20]
N_values = [20, 20, 50]

cfl_records2 = []

fig, axes = plt.subplots(1, 3, figsize=(24, 8), sharey=False)
for j, (N_, J_) in enumerate(zip(N_values, J_values)):
    params['N'] = N_
    params['J'] = J_

    ee = SchemeEE(**params, payoff=2)
    U, t = ee.solve()
    s = ee.s
    dt = ee.dt

    #CFL condition
    CFL = dt / (ee.h ** 2) * (ee.sigma ** 2) * (ee.Smax ** 2)

    # Enregistrement dans la table
    cfl_records2.append({
        "N": N_,
        "J": J_,
        "CFL": CFL
    })

    ax = axes[j]
    ax.plot(s, U, label="Prix option")
    ax.plot(s, ee.phi(s), 'k--', label="Payoff")

    ax.set_title(f"N = {N_}, J = {J_}")
    ax.set_xlabel("s")
    if j == 0:
        ax.set_ylabel("u(t,s)")
    ax.legend()

plt.suptitle(
    f"Evolution du prix du put américain -- Scheme {ee.scheme_name}, N fixé à {N_}",
    fontsize=16
)
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()

Les figures ci - dessus représentent le prix numérique de l’option au temps final, comparé au payoff, pour différentes configurations de maillage.

Les résultats montrent que le comportement du schéma dépend fortement du choix de N et J. Lorsque le maillage spatial est fin ( J=50) et que le nombre de pas de temps est relativement faible ( N=20), la solution numérique devient instable et présente de fortes oscillations, avec des valeurs non physiques. Ce phénomène traduit une instabilité du schéma explicite. En revanche, pour un maillage spatial plus grossier ( J=20) et un pas de temps suffisamment petit ( N=20 ou N=50), la solution obtenue est plus régulière et respecte correctement la contrainte d’option américaine, la solution restant au-dessus du payoff.

Ces observations suggèrent que la stabilité du schéma d’Euler explicite est étroitement liée à la relation entre le pas de temps et le pas d’espace, ce qui motive l’analyse de la condition de stabilité de type CFL.

cfl_df1 = pd.DataFrame(cfl_records1)  # Cas 1 : N fixé
cfl_df2 = pd.DataFrame(cfl_records2)  # Cas 2 : N = J

cfl_df1 = cfl_df1.rename(columns={"CFL": "CFL (N=10)"})
cfl_df2 = cfl_df2.rename(columns={"CFL": "CFL (N=J)"})

print("Payoff standard:")
print("="*20)
print(cfl_df1)
print("Payoff tronqué:")
print("="*20)
print(cfl_df2)

Payoff standard:
====================
    N   J  CFL (N=10)
0  20  50   18.288281
1  20  20    3.100781
2  50  20    1.240312
Payoff tronqué:
====================
    N   J  CFL (N=J)
0  20  50  18.288281
1  20  20   3.100781
2  50  20   1.240312

L’étude de la condition de CFL met en évidence le caractère conditionnellement stable du schéma d’Euler explicite. Comme observé sur les figures, lorsque le maillage spatial est raffiné sans diminution suffisante du pas de temps, la condition de stabilité est violée et la solution numérique présente des oscillations marquées. À l’inverse, lorsque N et J sont augmentés conjointement, la condition de CFL est mieux respectée et le comportement du schéma s’améliore.

On remarque par ailleurs que les valeurs calculées de la CFL sont identiques pour le payoff standard et pour le payoff tronqué. Ce résultat est attendu, puisque la condition de stabilité dépend uniquement des paramètres numériques et du modèle, en particulier du pas de temps Δt, du pas d’espace h, de la volatilité σ et de la borne supérieure Smax et non de la régularité du payoff.

def get_convergence_table(N_grid, J_grid, params, Sval, scheme_class):

    est_prices = []
    errex = []
    errors = []
    cpu_times = []

    for N, J in zip(N_grid, J_grid):
        params['N'] = N
        params['J'] = J

        start = time.time()
        scheme = scheme_class(**params)
        U, _ = scheme.solve()
        tcpu = time.time() - start

        price_est = scheme.interpolate(Sval, U)

        est_prices.append(price_est)
        cpu_times.append(tcpu)

    est_prices = np.array(est_prices)
    errors = np.zeros(len(est_prices))
    errors[1:] = np.abs(np.diff(est_prices))
    cpu_times = np.array(cpu_times)

    # Ordre de convergence global
    alpha = np.zeros(len(errors))
    h_step = (params["Smax"] - params["Smin"]) / (J_grid + 1)
    alpha[1:] = np.where(
        (errors[:-1] > 0) & (errors[1:] > 0) & (h_step[:-1] > h_step[1:]),
        np.log(errors[:-1] / errors[1:]) / np.log(h_step[:-1] / h_step[1:]),
        0
    )
    df = pd.DataFrame({
        "J": J_grid,
        "N": N_grid,
        "U(s)": est_prices,
        "error": errors,
        "alpha": alpha,
        "tcpu": cpu_times
    })

    return df.round(6)

Sval = 90
J_grid = np.array([20, 40, 80, 160, 320])

N_grid = np.array([2*(j**2)/10 for j in J_grid]).astype(int)

print("Cas N = J\n", "="*75)

print("Convergence Table for Scheme EE:")
print(get_convergence_table(N_grid, J_grid-1, params, Sval, SchemeEE))

Cas N = J
 ===========================================================================
Convergence Table for Scheme EE:
     J      N       U(s)     error     alpha      tcpu
0   19     80  12.947098  0.000000  0.000000  0.000573
1   39    320  13.064717  0.117619  0.000000  0.001415
2   79   1280  13.109572  0.044855  1.390781  0.005432
3  159   5120  13.117805  0.008233  2.445784  0.019646
4  319  20480  13.119987  0.002183  1.915301  0.082647

ordre h^2 + dt ==> division de l’erreur par 4.

Pour compléter l’analyse de la stabilité, il est également intéressant d’étudier la convergence du schéma. Pour étudier l’ordre de convergence du schéma, nous avons utilisé une grille pour J qui varie en doublant à chaque fois, et une grille pour N qui varie selon la règle . Etant donné le fait que l’ordre théorique de convergence du schéma d’Euler explicite pour l’équation de Black-Scholes est de 2 en espace et de 1 en temps, on s’attend à ce que l’erreur diminue d’un facteur de 4 à chaque évolution de la grille. La table de convergence présentée ci-dessous montre l’évolution de la solution numérique U(s) lorsque le nombre de points spatiaux J et le nombre de pas temporels N sont augmentés.

En respectant la règle de variation des grilles pour J et N, on s’assure que les deux contributions à l’erreur, i.e. l’erreur spatiale et l’erreur temporelle, diminuent de manière cohérente, ce qui permet d’observer une convergence plus régulière du schéma et donc un ordre de convergence plus clair.

On observe que l’erreur diminue progressivement au fur et à mesure que le maillage spatial et temporel est raffiné, tandis que le facteur α (estimant l’ordre de convergence en espace) tend vers la valeur théorique attendue (2), ce qui confirme que le schéma d’Euler explicite converge correctement sous la condition de CFL.

La colonne tcpu montre que ce raffinement s’accompagne d’un coût computationnel croissant, le temps de calcul augmentant rapidement lorsque le maillage spatial et temporel est affiné.

Schemas implicites

Après avoir étudié le schéma d’Euler explicite, nous nous intéressons à des schémas implicites et semi-implicites (Euler implicite, Crank-Nicolson…). Ce passage est principalement motivé par le fait que le schéma explicite est conditionnellement stable et impose une limitation relativement stricte sur le pas de temps Δt et le maillage via la condition CFL. Les schémas implicites, eux, offrent une stabilité plus grande, permettant d’utiliser des pas de temps plus importants.

Dans le cas du schéma d’Euler implicite (et plus généralement pour tout schéma implicite appliqué aux options américaines), on est conduit à résoudre à chaque pas de temps un système non linéaire discret, correspondant à un problème d’obstacle v≥ϕ. Pour traiter ce système, nous utilisons diverses méthodes numériques, telles que la méthode PSOR (Projected Successive Over-Relaxation) ou une méthode de type Newton semi-smooth.

Ces schémas complémentaires nous permettent donc de comparer précision, stabilité et coût computationnel, tout en gérant correctement la contrainte inhérente aux options américaines.

params['J'] = 20
params['N'] = 50

print("Paramètres financiers:")
print("r=%.2f" %r_, "sigma=%.2f" %sigma_, "K=%.0f" %K_, "T=%.0f" %T_)

print("Paramètres numériques:")
print("J=%.0f" %params['J'], "N=%.0f" %params['N'])

Paramètres financiers:
r=0.10 sigma=0.30 K=100 T=1
Paramètres numériques:
J=20 N=50

ei_split = SplittingScheme(**params)
U,t = ei_split.solve()
s = ei_split.s
dt = ei_split.dt

plt.plot(s,U,label="t=%.2f" %(t+dt))
plt.plot(s,ei_split.phi(s), 'k--', label="payoff")
plt.xlabel("s")
plt.ylabel("u(t,s)")
plt.title("Evolution du prix du put au cours du temps [Splitting Euler Implicite]")
plt.legend()
plt.show()

N_grid = J_grid = np.array([20*(2**k) for k in range(5)]).astype(int)

print("Splitting scheme")
print("="*75, "\nConvergence Table for Scheme EI:")
print(get_convergence_table(N_grid, J_grid-1, params, Sval, SplittingScheme))

print("="*75, "\nConvergence Table for Scheme CN:")
print(get_convergence_table(N_grid, J_grid-1, params, Sval, SchemeCN))

Splitting scheme
=========================================================================== 
Convergence Table for Scheme EI:
     J    N       U(s)     error     alpha      tcpu
0   19   20  12.771151  0.000000  0.000000  0.001442
1   39   40  12.958929  0.187778  0.000000  0.001753
2   79   80  13.054834  0.095904  0.969364  0.004257
3  159  160  13.089790  0.034957  1.456030  0.010195
4  319  320  13.105599  0.015809  1.144811  0.026634
=========================================================================== 
Convergence Table for Scheme CN:
     J    N       U(s)     error     alpha      tcpu
0   19   20  12.888852  0.000000  0.000000  0.000767
1   39   40  13.021900  0.133049  0.000000  0.001050
2   79   80  13.090984  0.069084  0.945528  0.002674
3  159  160  13.107807  0.016823  2.037952  0.006654
4  319  320  13.114979  0.007172  1.229912  0.019724

params['J'] = 100 -1
params['N'] = 10


print("Paramètres financiers:")
print("r=%.2f" %r_, "sigma=%.2f" %sigma_, "K=%.0f" %K_, "T=%.0f" %T_)

print("Paramètres numériques:")
print("J=%.0f" %params['J'], "N=%.0f" %params['N'])

Paramètres financiers:
r=0.10 sigma=0.30 K=100 T=1
Paramètres numériques:
J=99 N=10

psor = PSOR(**params, payoff=1)
U,t = psor.solve() # omega = 1.5 pour une convergence rapide
s = psor.s
dt = psor.dt

plt.figure(figsize=(6, 5))
plt.plot(s,U,label="t=%.2f" %(t))
plt.plot(s,psor.phi(s), 'k--', label="payoff")
plt.xlabel("s")
plt.ylabel("u(t,s)")
plt.title("Evolution du prix du put européen au cours du temps [PSOR]")
plt.legend()
plt.show()

# comparing time

omegas = [1.2, 1.5, 1.8, 1.9]

for omega in omegas:
    psor = PSOR(**params, payoff=1)
    start_time = time.time()
    U, t = psor.solve(omega=omega)
    end_time = time.time()
    print(f"Omega: {omega}, Time taken: {end_time - start_time:.4f} seconds")

Omega: 1.2, Time taken: 50.6897 seconds
Omega: 1.5, Time taken: 44.9621 seconds
Omega: 1.8, Time taken: 27.1073 seconds
Omega: 1.9, Time taken: 50.4578 seconds

params['J'] = 100 -1
params['N'] = 10


print("Paramètres financiers:")
print("r=%.2f" %r_, "sigma=%.2f" %sigma_, "K=%.0f" %K_, "T=%.0f" %T_)

print("Paramètres numériques:")
print("J=%.0f" %params['J'], "N=%.0f" %params['N'])

Paramètres financiers:
r=0.10 sigma=0.30 K=100 T=1
Paramètres numériques:
J=99 N=10

newtonss = NewtonSemiSmooth(**params, payoff=1)
U,t = newtonss.solve()
s = newtonss.s
dt = newtonss.dt

plt.figure(figsize=(6, 5))
plt.plot(s,U,label="t=%.2f" %(t))
plt.plot(s,newtonss.phi(s), 'k--', label="payoff")
plt.xlabel("s")
plt.ylabel("u(t,s)")
plt.title("Evolution du prix du put européen au cours du temps [Newton Semi-Smooth]")
plt.legend()
plt.show()

Higher order schemes

Après avoir étudié les schémas implicites classiques et les méthodes de résolution pour le problème d’obstacle, nous considérons également un schéma d’ordre 2, le BDF2, qui améliore la précision temporelle tout en prenant en compte l’obstacle.

params['J'] = 100 -1
params['N'] = 10

bdf2 = BdfScheme(**params, payoff=1)
U,t = bdf2.solve()
s = bdf2.s
dt = bdf2.dt

plt.figure(figsize=(6, 5))
plt.plot(s,U,label="t=%.2f" %(t))
plt.plot(s,bdf2.phi(s), 'k--', label="payoff")
plt.xlabel("s")
plt.ylabel("u(t,s)")
plt.title("Evolution du prix du put européen au cours du temps [BDF2]")
plt.legend()
plt.show()

Price formation

The price of a share is determined by the interaction of supply and demand. When demand increases, the price tends to rise. Conversely, when supply exceeds demand, the price falls. The traded price corresponds to the effective intersection between a bid and an ask, that is, where an order is matched.

Fundamental factors also influence prices, including corporate earnings, dividend distributions, growth prospects, and general economic conditions.

At market close, the closing price corresponds to the last traded price of the session. This price may differ from the next opening price due to events occurring outside trading hours.

Bond valuation

Bond valuation consists of determining its present value, that is, the amount an investor is willing to pay today. The price of a bond is given by

The bond value depends on the market interest rate (r), the remaining maturity (T-t), the coupon rate, and the issuer’s credit quality. When market interest rates increase, existing bond prices decline, as new bonds offer higher yields.

A zero-coupon bond does not pay periodic interest. Its value simplifies to

Forward contracts

A forward contract is an agreement between two parties to buy or sell an asset at a price (K) at a future date (T). The payoff for a long position is and for a short position,

Forwards are primarily used for hedging purposes.

Options

An option gives the holder the right, but not the obligation, to buy or sell an underlying asset at a strike price (K) before or at maturity (T).

The payoff of a european call is while the payoff of a european put is

Options may be used for hedging, speculation, or income generation.

Futures

Futures contracts are standardized agreements traded on organized exchanges. They are marked to market daily, and margin accounts are adjusted accordingly. Futures prices converge to spot prices at maturity to prevent arbitrage.

Swaps

A swap is a derivative contract in which two parties exchange cash flows based on a notional amount over a specified period. The most common type is the interest rate swap, in which one party pays a fixed rate while receiving a floating rate, typically linked to libor or a similar benchmark.

The swap can be viewed as a combination of a fixed-rate bond and a floating-rate bond. Its value equals the difference between the present values of fixed and floating cash flows:

When the fixed rate equals the swap rate, the contract initially has zero net value.

Swap markets provide quoted bid and ask fixed rates across maturities, which are used to construct the zero-coupon yield curve through bootstrapping techniques.

Although swap rates are not strictly risk-free, they are often used as reference discount rates for long maturities under normal market conditions.

Source: john c. hull, options, futures, and other derivatives, 11th edition.

Schéma d’Euler explicite (EE)

Le schéma d’Euler explicite est un schéma basé sur une discrétisation explicite en temps. La discrétisation de l’EDP est basée sur des approximations centrées. Dès lors, on approxime les dérivées partielles de la manière suivante :

On peut la réécrire sous la forme matricielle afin d’extraire une solution numérique dite explicite : Sous forme matricielle, le schéma s’écrit :

où

• est une matrice carrée tridiagonale de taille . En posant et , les coefficients de la matrice sont donnés par :

  

• un vecteur de qui dépendent des paramètres du modèle et de la discrétisation spatiale donné par :

  

De fait, on obtient la relation de récurrence explicite permettant de calculer en fonction de :

Schéma d’Euler implicite (EI)

Le schéma d’Euler implicite est un schéma basé sur une discrétisation implicite en temps. La discrétisation de l’EDP est basée sur des approximations centrées. Dès lors, on approxime les dérivées partielles de la manière suivante :

Dans ce cas, la relation de récurrence s’écrit sous la forme matricielle suivante :

où et sont définis comme précédemment. On obtient ainsi la relation de récurrence implicite suivante :

où est la matrice identité de taille .

Schéma de Crank-Nicolson (CN)

Le schéma de Crank-Nicolson est un schéma basé sur une discrétisation implicite en temps. La discrétisation de l’EDP est basée sur des approximations centrées. Dès lors, on approxime les dérivées partielles de la manière suivante :

La relation de récurrence s’écrit sous la forme matricielle suivante : où et sont définis comme précédemment. On obtient ainsi la relation de récurrence implicite suivante : où est la matrice identité de taille .

Choix d’implémentations

Puisque les schémas implémentés partagent de nombreuses caractéristiques communes, nous définissons une classe de base abstraite SchemeBase qui encapsule les paramètres financiers, la grille discrète, les conditions initiales et aux limites, ainsi que la construction de la matrice et du vecteur . Les schémas spécifiques hériteront de cette classe de base et implémenteront la méthode solve() pour résoudre le schéma numérique particulier.

Trois classes filles seront ensuite définies : SchemeEE pour le schéma d’Euler explicite, SchemeEI pour le schéma d’Euler implicite, et SchemeCN pour le schéma de Crank-Nicolson. Chacune de ces classes implémentera la méthode solve() en fonction de la nature explicite ou implicite du schéma.

Les codes sont retrouvés sur ce lien github github.

# Package imports

import numpy as np
import matplotlib.pyplot as plt
import numpy.linalg as lng
from scipy.sparse import diags,eye
from abc import ABC, abstractmethod
import scipy.stats as stats
from scipy.sparse import csr_matrix as sparse
from scipy.sparse.linalg import spsolve
import pandas as pd
import time
from pprint import pprint

class SchemeBase(ABC):
    """
    Classe de base pour les schémas numériques de l'équation de Black-Scholes.
    """
    def __init__(self, r, sigma, K, T, N, J, Smin, Smax):
        # Financial parameters
        self.r = r
        self.sigma = sigma
        self.K = K
        self.T = T

        # Numerical parameters
        self.N = N
        self.J = J
        self.Smin = Smin
        self.Smax = Smax

        # Grids
        self.dt = T / N
        self.h = (Smax - Smin) / (J + 1)
        self.s = Smin + self.h * np.arange(1, J + 1)

        # Operator
        self.A, self.alpha, self.beta = self._build_matrix_A()

    def phi(self, s):
        """
        Condition initiale (payoff) pour un put européen.
        𝜙(s) = max(K - s, 0)
        """
        return np.maximum(self.K - s, 0)

    def uleft(self, t):
        """
        Condition aux limites à gauche pour un put européen.
        u( t, Smin ) = K * exp(-r * t) - S
        """
        return self.K * np.exp(-self.r * t) - self.Smin

    def uright(self, t):
        """
        Condition aux limites à droite pour un put européen.
        u( t, Smax ) = 0
        """
        return 0.0

    def _build_matrix_A(self):
        """
        Matrice d'amplification A.
        """
        alpha = 0.5 * self.sigma**2 * (self.s**2 / self.h**2)
        beta  = self.r * self.s / (2 * self.h)

        lower = -alpha[1:] + beta[1:]        # sous-diagonale
        main  = 2 * alpha + self.r            # diagonale principale
        upper = -alpha[:-1] - beta[:-1]       # sur-diagonale

        A = diags(
            diagonals=[lower, main, upper],
            offsets=[-1, 0, 1],
            shape=(self.J, self.J),
            format="csr"
        )

        return A, alpha, beta


    def q(self, t):
        """
        Vecteur des conditions aux limites.
        """
        y = np.zeros(self.J)
        y[0]  = (-self.alpha[0] + self.beta[0]) * self.uleft(t)
        y[-1] = (-self.alpha[-1] - self.beta[-1]) * self.uright(t)
        return y

    def interpolate(self, Sval, U):
        """
        Interpolation linéaire pour obtenir la valeur approximée d'un put
        en un point spot Sval donné.
        """
        if Sval <= self.Smin:
            return self.uleft(self.T)
        elif Sval >= self.Smax:
            return self.uright(self.T)
        else:
            return np.interp(Sval, self.s, U)

    # Abstract method
    @abstractmethod
    def solve(self):
        """
        Méthode abstraite de résolution du schéma numérique.
        """
        raise NotImplementedError("Méthode solve() à implémenter dans la classe fille")

class SchemeEE(SchemeBase):
    """
    Schéma d'Euler explicite.
    """
    def __init__(self, r, sigma, K, T, N, J, Smin, Smax):
        super().__init__(r, sigma, K, T, N, J, Smin, Smax)
        self.scheme_name = "Euler Explicite"

    def solve(self):
        """
        Résolution du schéma d'Euler explicite.
        """
        U = self.phi(self.s)

        for n in range(self.N):
            t = n * self.dt
            U = U - self.dt * (self.A @ U + self.q(t))

        return U,t

class SchemeEI(SchemeBase):
    """
    Schéma d'Euler implicite.
    """
    def __init__(self, r, sigma, K, T, N, J, Smin, Smax):
        super().__init__(r, sigma, K, T, N, J, Smin, Smax)
        self.scheme_name = "Euler Implicite"

    def solve(self):
        U = self.phi(self.s)
        I = eye(self.J, format="csr")

        for n in range(self.N):
            t = n * self.dt
            U = spsolve(I + self.dt * self.A, U - self.dt * self.q(t))

        return U,t

class SchemeCN(SchemeBase):
    """
    Schéma de Crank-Nicolson.
    """
    def __init__(self, r, sigma, K, T, N, J, Smin, Smax):
        super().__init__(r, sigma, K, T, N, J, Smin, Smax)
        self.scheme_name = "Crank-Nicolson"

    def solve(self):
        U = self.phi(self.s)
        I = eye(self.J, format="csr")
        factor_minus = I - 0.5 * self.dt * self.A
        factor_plus = I + 0.5 * self.dt * self.A

        for n in range(self.N):
            t = n * self.dt
            U = spsolve(factor_plus, factor_minus@U - self.dt * self.q(t))
        return U,t

Résultat du schéma d’Euler explicite

Pour étudier le comportement du schéma d’Euler explicite, nous avons réalisé des simulations en faisant varier les paramètres (nombre de points spatiaux) et (nombre de points temporels). Nous avons considéré deux cas distincts :

• Cas 1 : fixé à 10 et variant parmi les valeurs .
• Cas 2 : et variant simultanément parmi les valeurs , avec .

Les résultats obtenus sont présentés dans les graphiques ci-dessous. Par ailleurs, pour aider à l’interprétation des résultats, le résultat de la condition de CFL (Courant-Friedrichs-Lewy) est également affiché sur chaque graphique.

# Cas 1 : N = 10, J varie dans `values`

values = [10, 20, 50]
N_fixed = 10

cfl_records1 = []

fig, axes = plt.subplots(1, 3, figsize=(24, 8), sharey=False)
for j, J_ in enumerate(values):
    params['N'] = N_fixed
    params['J'] = J_

    ee = SchemeEE(**params)
    U, t = ee.solve()
    s = ee.s
    dt = ee.dt

    #CFL condition
    CFL = dt / (ee.h ** 2) * (ee.sigma ** 2) * (ee.Smax ** 2)

    # Enregistrement dans la table
    cfl_records1.append({
        "N": N_fixed,
        "J": J_,
        "CFL": CFL
    })

    ax = axes[j]
    ax.plot(s, U, label="Prix option")
    ax.plot(s, ee.phi(s), 'k--', label="Payoff")

    ax.set_title(f"N = {N_fixed}, J = {J_}")
    ax.set_xlabel("s")
    if j == 0:
        ax.set_ylabel("u(t,s)")
    ax.legend()

plt.suptitle(
    f"Evolution du prix du put européen -- Scheme {ee.scheme_name}, N fixé à {N_fixed}",
    fontsize=16
)
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()

# Cas 2 : N = J avec N, J dans `values`
values = [10, 20, 50]
cfl_records2 = []

fig, axes = plt.subplots(1, 3, figsize=(24, 8), sharey=False)
for j, N_ in enumerate(values):
    params['N'] = N_
    params['J'] = N_

    ee = SchemeEE(**params)
    U, t = ee.solve()
    s = ee.s
    dt = ee.dt

    #CFL condition
    CFL = dt / (ee.h ** 2) * (ee.sigma ** 2) * (ee.Smax ** 2)

    cfl_records2.append({
        "N": N_,
        "J": N_,
        "CFL": CFL
    })

    ax = axes[j]
    ax.plot(s, U, label="Prix option")
    ax.plot(s, ee.phi(s), 'k--', label="Payoff")

    ax.set_title(f"N = J = {N_}, CFL={CFL:.2f}")
    ax.set_xlabel("s")
    if j == 0:
        ax.set_ylabel("u(t,s)")
    ax.legend()

plt.suptitle(
    f"Evolution du prix du put européen -- Scheme {ee.scheme_name}, N = J",
    fontsize=16
)
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()

En analysant les graphiques ci-dessus, nous constatons que le choix de et , i.e. le maillage spatial et temporel, influence la stabilité de l’approximation du prix du put européen.

Dans le cas 1, avec fixé à 10 et variant, nous constatons que l’approximation de prix est très proche du prix du put européen pour N=J=10, ce qui est attendu pour un schéma stable. Cependant, lorsque augmente, des oscillations apparaissent dans la solution numérique, indiquant une instabilité du schéma.

Par ailleurs, dans le cas 2, où et varient simultanément avec , nous observons également des oscillations et des instabilités pour des valeurs plus élevées de et . Ce comportement instable est similaire à celui observé dans le cas 1, lorsque augmente pour un fixé.

Ces oscillations et instabilités observées dans les deux cas étudiés sont caractéristiques des schémas explicites lorsqu’ils ne respectent pas la condition de stabilité requise, dite condition CFL. En effet,le schéma d’euler explicite est stable conditionnellement au respect de la condition CFL dépendant du rapport entre et .

La condition CFL qui, pour le schéma explicite appliqué à l’équation de Black-Scholes, peut être exprimée comme suit : .Cette condition impose une relation entre le pas de temps et le pas d’espace h. De fait, lorsque J augmente et N diminue, cette condition de stabilité peut être violée. Dans notre cas, lorsque J=50 et N=10 ou N=50, la condition CFL n’est pas respectée comme on peut l’observer dans le tableau ci-dessous, ce qui explique les oscillations et l’instabilité observées dans les résultats numériques.

cfl_df1 = pd.DataFrame(cfl_records1)  # Cas 1 : N fixé
cfl_df2 = pd.DataFrame(cfl_records2)  # Cas 2 : N = J

cfl_df1 = cfl_df1.rename(columns={"CFL": "CFL (N=10)"})
cfl_df2 = cfl_df2.rename(columns={"CFL": "CFL (N=J)"})

cfl_table = pd.merge(
    cfl_df1[["J", "CFL (N=10)"]],
    cfl_df2[["J", "CFL (N=J)"]],
    on="J",
    how="inner"
)

cfl_table

Pour mieux comprendre l’origine des oscillations, nous avons étudié la matrice d’amplification du schéma explicite pour N=10 et J=50. La matrice d’amplification est définie par où A est la matrice tridiagonale associée au schéma implicite. En calculant les valeurs propres de cette matrice, nous pouvons analyser la stabilité du schéma.

En effet, cette matrice intervient dans l’évolution de la solution numérique à chaque pas de temps, et on a :

Si la norme de B est supérieure à 1, alors les valeurs prises par la solution numérique peuvent croître de manière exponentielle par rapport à la condition initiale, conduisant à des erreurs d’approximation possiblement importantes, des oscillations et ainsi une instabilité dans la solution numérique. Pour savoir si la norme de B est supérieure à 1, nous avons calculé le spectre de B et constaté que la valeur absolue de la plus grande valeur propre dépasse 1. Cela confirme que le schéma explicite est instable pour les paramètres choisis, ce qui explique les oscillations observées dans les résultats numériques.

Pour cette raison, nous avons testé d’autres schémas numériques tels que le schéma d’Euler implicite et le schéma de Crank-Nicolson, qui sont connus pour leur stabilité inconditionnelle.

# Paramètres
params['N'] = 10
params['J'] = 50

ee = SchemeEE(**params)
ee.solve()

# Matrice d'amplification
A = ee.A.toarray()
B = np.eye(ee.J) - ee.dt * A

# Valeurs propres
eigenvalues = lng.eigvals(B)
spectral_radius = np.max(np.abs(eigenvalues))
norm_B = lng.norm(B, 2)

# Tableau récapitulatif
df_spectrum = pd.DataFrame({
    "Valeur propre": eigenvalues,
    "|Valeur propre|": np.abs(eigenvalues)
}).sort_values("|Valeur propre|", ascending=False)

# Affichage
print("=== Analyse de stabilité du schéma explicite ===\n")

print("Paramètres numériques :")
print(f"  N = {ee.N},  J = {ee.J},  dt = {ee.dt:.2f},  h  = {ee.h:.2f}\n")

print("10 plus grandes valeurs propres de B (triées par module décroissant) :")
print(df_spectrum.head(10).to_string(index=False))

print("Norme matricielle induite (norme 2) :")
print(f"  ||B||₂ = {norm_B:.6f}\n")

=== Analyse de stabilité du schéma explicite ===

Paramètres numériques :
  N = 10,  J = 50,  dt = 0.10,  h  = 3.92

10 plus grandes valeurs propres de B (triées par module décroissant) :
 Valeur propre  |Valeur propre|
    -16.469570        16.469570
    -14.218162        14.218162
    -12.525602        12.525602
    -11.138073        11.138073
     -9.955409         9.955409
     -8.924546         8.924546
     -8.012865         8.012865
     -7.198391         7.198391
     -6.465369         6.465369
     -5.801977         5.801977
Norme matricielle induite (norme 2) :
  ||B||₂ = 16.473976

Résultat du schéma d’Euler implicite et de Crank-Nicolson

params['J'] = 50
params['N'] = 10

print("Paramètres financiers:")
print("r=%.2f" %r_, "sigma=%.2f" %sigma_, "K=%.0f" %K_, "T=%.0f" %T_)

print("Paramètres numériques:")
print("J=%.0f" %params['J'], "N=%.0f" %params['N'])

Paramètres financiers:
r=0.10 sigma=0.20 K=100 T=1
Paramètres numériques:
J=50 N=10

ei = SchemeEI(**params)
U,t = ei.solve()
s = ei.s
dt = ei.dt

plt.figure(figsize=(6, 5))
plt.plot(s,U,label="t=%.2f" %(t+dt))
plt.plot(s,ei.phi(s), 'k--', label="payoff")
plt.xlabel("s")
plt.ylabel("u(t,s)")
plt.title("Evolution du prix du put européen au cours du temps [Euler Implicite]")
plt.legend()
plt.show()

params['J'] = 50
params['N'] = 10

print("Paramètres financiers:")
print("r=%.2f" %r_, "sigma=%.2f" %sigma_, "K=%.0f" %K_, "T=%.0f" %T_)

print("Paramètres numériques:")
print("J=%.0f" %params['J'], "N=%.0f" %params['N'])

Paramètres financiers:
r=0.10 sigma=0.20 K=100 T=1
Paramètres numériques:
J=50 N=10

cn = SchemeCN(**params)
U,t = cn.solve()
s = cn.s
dt = cn.dt

plt.figure(figsize=(6, 5))
plt.plot(s,U,label="t=%.2f" %(t+dt))
plt.plot(s,cn.phi(s), 'k--', label="payoff")
plt.xlabel("s")
plt.ylabel("u(t,s)")
plt.title("Evolution du prix du put européen au cours du temps [Crank-Nicolson]")
plt.legend()
plt.show()

Méthodes

Afin de comparer les résultats numériques obtenus avec les différents schémas au prix théorique du put européen, nous avons implémenté la formule de Black and Scholes dans une fonction Python. Cette fonction calcule le prix du put en utilisant les paramètres financiers tels que le prix de l’actif sous-jacent, le prix d’exercice, le taux d’intérêt sans risque, la volatilité et le temps jusqu’à l’échéance.

Nous analysons la convergence des schémas numériques considérés, ainsi que les ordres de convergence. La convergence est ensuite étudiée numériquement en comparant les prix obtenus par les schémas avec la solution analytique du put européen, et les ordres de convergence sont estimés à partir du comportement asymptotique de l’erreur lorsque les pas de temps et d’espace tendent vers zéro.

Pour estimer numériquement l’ordre de convergence des schémas, on utilise la relation , où est une constante indépendante de et est l’ordre de convergence du schéma, étant le pas de discrétisation spatial, défini par , et le nombre de points spatiaux utilisés dans la discrétisation. De fait, on obtient l’ordre de convergence en comparant les erreurs et pour deux maillages successifs. D’où

Nous considérons deux grilles de discrétisation successives définies par les couples , à savoir et , avec .

print("Paramètres financiers:")
Sval = 80
print("r=%.2f" %r_, "sigma=%.2f" %sigma_, "K=%.0f" %K_, "T=%.0f" %T_, "Sval=%.2f" %Sval)

Paramètres financiers:
r=0.10 sigma=0.20 K=100 T=1 Sval=80.00

# Implementation de la formule de Black and Scholes
def dplus(x,K,r,sigma,T,t):
    tau = T-t
    numerator = np.log(x/K) + tau * (r + 0.5*sigma**2)
    denominator = sigma * np.sqrt(tau)
    return numerator / denominator

def dmoins(dplus_,sigma,tau):
    return dplus_ - sigma * np.sqrt(tau)

def compute_BS_price(x,K,r,sigma,T,t=0,type_='call'):
    tau = T-t
    dplus_ = dplus(x,K,r,sigma,T,t)
    dmoins_ = dmoins(dplus_,sigma,tau)
    if type_ == 'call':
        return x*stats.norm.cdf(dplus_) - K * np.exp(-r*tau) * stats.norm.cdf(dmoins_)
    elif type_=='put':
        return K* np.exp(-r*tau)* stats.norm.cdf(-dmoins_) - x * stats.norm.cdf(-dplus_)

price_BS = compute_BS_price(Sval, params['K'], params['r'], params['sigma'], params['T'], t=0, type_='put')
print("Prix théorique du put pour S=%.2f : %.4f" %(Sval, price_BS))

Prix théorique du put pour S=80.00 : 13.2737

def get_convergence_table(N_grid, J_grid, params, Sval, scheme_class):

    est_prices = []
    errex = []
    errors = []
    cpu_times = []

    # Prix exact (identique pour tous)
    BS_price = compute_BS_price(
        Sval, params['K'], params['r'],
        params['sigma'], params['T'],
        t=0, type_='put'
    )

    for N, J in zip(N_grid, J_grid):
        params['N'] = N
        params['J'] = J

        start = time.time()
        scheme = scheme_class(**params)
        U, _ = scheme.solve()
        tcpu = time.time() - start

        price_est = scheme.interpolate(Sval, U)

        est_prices.append(price_est)
        errex.append(abs(price_est - BS_price))
        cpu_times.append(tcpu)

    est_prices = np.array(est_prices)
    errors = np.zeros(len(est_prices))
    errors[1:] = np.abs(np.diff(est_prices))
    errex = np.array(errex)
    cpu_times = np.array(cpu_times)

    # Ordre de convergence global
    alpha = np.zeros(len(errors))
    h_step = (params["Smax"] - params["Smin"]) / (J_grid + 1)
    alpha[1:] = np.log(errex[:-1] / errex[1:]) / np.log(h_step[:-1] / h_step[1:])

    df = pd.DataFrame({
        "J": J_grid,
        "N": N_grid,
        "U(s)": est_prices,
        "error": errors,
        "alpha": alpha,
        "errex": errex,
        "tcpu": cpu_times
    })

    return df.round(6)

Résultats

On constate que les trois schémas présentent des comportements très contrastés en termes de stabilité, ordre de convergence et coût de calcul lorsque l’on impose .

On observe tout d’abord que le schéma d’Euler explicite ne peut pas être considéré comme fiable dans ce cadre, comme précisé précédemment. Pour des maillages grossiers, l’erreur semble initialement décroître et l’ordre estimé est proche de 2, ce qui pourrait suggérer une bonne convergence. Cependant, dès que la discrétisation devient plus fine, la solution diverge et on observe une explosion numérique à partir de qui montre clairement que la condition de stabilité n’est plus satisfaite lorsque et sont raffinés simultanément.

Le schéma d’Euler implicite est parfaitement stable sur toute la plage de discrétisations considérée. L’erreur décroît de façon régulière lorsque augmente, sans aucune instabilité numérique. De plus, l’ordre de convergence estimé reste inférieur à 2 et tend progressivement vers une valeur proche de 1, ce qui est cohérent avec le fait que, lorsque , l’erreur temporelle d’ordre 1 domine l’erreur spatiale.

Enfin, on constate que le schéma de Crank–Nicolson présente le comportement le plus satisfaisant. Il est stable sur toute la grille, l’erreur décroît rapidement et l’ordre de convergence estimé est très proche de 2 dès les maillages intermédiaires, puis se stabilise autour de cette valeur pour les maillages fins. Ce résultat est parfaitement conforme à la théorie, puisque le schéma est d’ordre 2 à la fois en temps et en espace.

Pour conclure, lorsque , en termes de temps de calcul, le schéma EE est certes le plus rapide sur les grilles grossières, avec des temps de simulation de l’ordre de la milliseconde, mais cet avantage est sans intérêt pratique puisque la solution devient totalement inutilisable pour des maillages fins. Le schéma implicite constitue une solution robuste mais relativement coûteuse et moins précise. En effet, il nécessite la résolution d’un système linéaire à chaque pas de temps. Cela se reflète clairement dans les temps de calcul, qui augmentent sensiblement avec le raffinement et deviennent significatifs pour les maillages fins, atteignant plus de 0.1 seconde pour .

Le schéma de Crank–Nicolson apparaît comme le meilleur compromis, combinant stabilité, convergence d’ordre 2 et temps de calcul raisonnables. En termes de coût de calcul, le schéma CN est plus cher que le schéma explicite mais reste nettement plus efficace que le schéma implicite pur. Les temps de simulation restent modérés, même pour des valeurs élevées de , et demeurent largement compatibles avec une utilisation pratique, tout en offrant une précision bien supérieure.

N_grid = J_grid = np.array([10, 20, 40, 80, 160])
print("Cas N = J\n", "="*75)

print("Convergence Table for Scheme EE:")
print(get_convergence_table(N_grid, J_grid, params, Sval, SchemeEE))

print("="*75, "\nConvergence Table for Scheme EI:")
print(get_convergence_table(N_grid, J_grid, params, Sval, SchemeEI))

print("="*75, "\nConvergence Table for Scheme CN:")
print(get_convergence_table(N_grid, J_grid, params, Sval, SchemeCN))

Cas N = J
 ===========================================================================
Convergence Table for Scheme EE:
     J    N          U(s)         error       alpha         errex      tcpu
0   10   10  1.425509e+01  0.000000e+00    0.000000  9.814290e-01  0.000212
1   20   20  1.351532e+01  7.397760e-01    2.167407  2.416540e-01  0.000158
2   40   40  1.332033e+01  1.949870e-01    2.457937  4.666600e-02  0.000257
3   80   80 -1.061474e+04  1.062806e+04  -18.117778  1.062801e+04  0.000558
4  160  160 -8.121408e+69  8.121408e+69 -220.831903  8.121408e+69  0.001096
=========================================================================== 
Convergence Table for Scheme EI:
     J    N       U(s)     error     alpha     errex      tcpu
0   10   10  14.448406  0.000000  0.000000  1.174743  0.000530
1   20   20  13.642159  0.806247  1.792956  0.368496  0.000878
2   40   40  13.386145  0.256015  1.773621  0.112482  0.001978
3   80   80  13.310502  0.075642  1.639391  0.036839  0.003961
4  160  160  13.287066  0.023436  1.471804  0.013403  0.009982
=========================================================================== 
Convergence Table for Scheme CN:
     J    N       U(s)     error     alpha     errex      tcpu
0   10   10  14.353451  0.000000  0.000000  1.079788  0.000380
1   20   20  13.578892  0.774559  1.953920  0.305229  0.000576
2   40   40  13.353140  0.225752  2.011209  0.079477  0.001089
3   80   80  13.293944  0.059195  2.005878  0.020281  0.002566
4  160  160  13.278788  0.015156  2.002416  0.005125  0.006933

On constate que le choix modifie l’analyse par rapport au cas , en particulier pour le schéma explicite. Alors que ce dernier était instable lorsque les pas de temps et d’espace étaient raffinés simultanément, il devient ici parfaitement stable. L’erreur décroît régulièrement et l’ordre de convergence est très proche de 2 sur l’ensemble des maillages, ce qui montre que la condition de stabilité est désormais respectée et que l’erreur spatiale domine. Le schéma EE retrouve ainsi une convergence théoriquement optimale, tout en conservant un coût de calcul globalement inférieur à celui des schémas implicites.

Le schéma d’Euler implicite reste, comme précédemment, inconditionnellement stable. Cependant, contrairement au cas , l’ordre de convergence n’est plus limité par l’erreur temporelle et tend lui aussi vers 2 lorsque augmente. Cette amélioration de la précision se fait au prix d’un coût de calcul très élevé, les temps de simulation augmentant fortement avec , ce qui rend le schéma peu compétitif pour des grilles fines.

Le schéma de Crank–Nicolson conserve un comportement très régulier et conforme à la théorie. Il est stable, présente une convergence d’ordre 2 et offre des erreurs comparables à celles du schéma explicite stabilisé. En revanche, son coût de calcul augmente sensiblement avec le raffinement et devient proche de celui du schéma implicite pour les maillages les plus fins.

Ainsi, contrairement au cas où Crank–Nicolson apparaissait clairement comme le meilleur compromis, le régime met en évidence l’efficacité du schéma explicite, qui combine ici stabilité, convergence d’ordre 2 et temps de calcul plus faibles, à condition d’accepter une contrainte forte sur le pas de temps.

N_grid = np.array([(j**2)/10 for j in J_grid]).astype(int)

print("Cas N = J^2/10\n", "="*75)
print("Convergence Table for Scheme EE:")
print(get_convergence_table(N_grid, J_grid, params, Sval, SchemeEE))

print("="*75, "\nConvergence Table for Scheme EI:")
print(get_convergence_table(N_grid, J_grid, params, Sval, SchemeEI))

print("="*75, "\nConvergence Table for Scheme CN:")
print(get_convergence_table(N_grid, J_grid, params, Sval, SchemeCN))

Cas N = J^2/10
 ===========================================================================
Convergence Table for Scheme EE:
     J     N       U(s)     error     alpha     errex      tcpu
0   10    10  14.255092  0.000000  0.000000  0.981429  0.000155
1   20    40  13.547634  0.707459  1.973300  0.273971  0.000214
2   40   160  13.345106  0.202528  2.009007  0.071443  0.000719
3   80   640  13.291930  0.053175  2.002965  0.018267  0.002883
4  160  2560  13.278284  0.013646  2.000790  0.004621  0.010337
=========================================================================== 
Convergence Table for Scheme EI:
     J     N       U(s)     error     alpha     errex      tcpu
0   10    10  14.448406  0.000000  0.000000  1.174743  0.000565
1   20    40  13.611061  0.837345  1.929307  0.337398  0.001650
2   40   160  13.361562  0.249499  2.010421  0.087899  0.006941
3   80   640  13.296062  0.065500  2.007975  0.022399  0.031444
4  160  2560  13.279318  0.016744  2.003733  0.005655  0.157797
=========================================================================== 
Convergence Table for Scheme CN:
     J     N       U(s)     error     alpha     errex      tcpu
0   10    10  14.353451  0.000000  0.000000  1.079788  0.000538
1   20    40  13.579386  0.774065  1.951418  0.305723  0.001003
2   40   160  13.353328  0.226058  2.010092  0.079665  0.003859
3   80   640  13.293996  0.059332  2.005652  0.020333  0.019154
4  160  2560  13.278801  0.015195  2.002383  0.005138  0.106421

Choix d’implémentations

L’implémentation des schémas numériques est restée globalement inchangée par rapport au cas du put européen. La même classe de base SchemeBase est utilisée pour définir la grille de discrétisation et les opérateurs numériques, tandis que seules la condition initiale, correspondant au payoff du call européen, ainsi que les conditions aux limites ont été adaptées. Les schémas d’Euler explicite, d’Euler implicite et de Crank–Nicolson sont implémentés de manière identique via les classes SchemeEE, SchemeEI et SchemeCN.

class SchemeBase(ABC):
    """
    Classe de base pour les schémas numériques de l'équation de Black-Scholes.
    """
    def __init__(self, r, sigma, K, T, N, J, Smin, Smax):
        # Financial parameters
        self.r = r
        self.sigma = sigma
        self.K = K
        self.T = T

        # Numerical parameters
        self.N = N
        self.J = J
        self.Smin = Smin
        self.Smax = Smax

        # Grids
        self.dt = T / N
        self.h = (Smax - Smin) / (J + 1)
        self.s = Smin + self.h * np.arange(1, J + 1)

        # Operator
        self.A, self.alpha, self.beta = self._build_matrix_A()

    def phi(self, s):
        """
        Condition initiale (payoff) pour un call européen.
        𝜙(s) = max(s - K, 0)
        """
        return np.maximum(s-self.K, 0)

    def uleft(self, t):
        """
        Condition aux limites à gauche pour un call européen.
        """
        return 0.0

    def uright(self, t):
        """
        Condition aux limites à droite pour un put européen.
        """
        return self.Smax - self.K * np.exp(-self.r * t)

    def _build_matrix_A(self):
        """
        Matrice d'amplification A.
        """
        alpha = 0.5 * self.sigma**2 * (self.s**2 / self.h**2)
        beta  = self.r * self.s / (2 * self.h)

        lower = -alpha[1:] + beta[1:]        # sous-diagonale
        main  = 2 * alpha + self.r            # diagonale principale
        upper = -alpha[:-1] - beta[:-1]       # sur-diagonale

        A = diags(
            diagonals=[lower, main, upper],
            offsets=[-1, 0, 1],
            shape=(self.J, self.J),
            format="csr"
        )

        return A, alpha, beta

    def q(self, t):
        """
        Vecteur des conditions aux limites.
        """
        y = np.zeros(self.J)
        y[0]  = (-self.alpha[0] + self.beta[0]) * self.uleft(t)
        y[-1] = (-self.alpha[-1] - self.beta[-1]) * self.uright(t)
        return y

    def interpolate(self, Sval, U):
        """
        Interpolation linéaire pour obtenir la valeur approximée d'un put
        en un point spot Sval donné.
        """
        if Sval <= self.Smin:
            return self.uleft(self.T)
        elif Sval >= self.Smax:
            return self.uright(self.T)
        else:
            return np.interp(Sval, self.s, U)

    # Abstract method
    @abstractmethod
    def solve(self):
        """
        Méthode abstraite de résolution du schéma numérique.
        """
        raise NotImplementedError("Méthode solve() à implémenter dans la classe fille")

class SchemeEE(SchemeBase):
    """
    Schéma d'Euler explicite.
    """
    def __init__(self, r, sigma, K, T, N, J, Smin, Smax):
        super().__init__(r, sigma, K, T, N, J, Smin, Smax)
        self.scheme_name = "Euler Explicite"

    def solve(self):
        """
        Résolution du schéma d'Euler explicite.
        """
        U = self.phi(self.s)

        for n in range(self.N):
            t = n * self.dt
            U = U - self.dt * (self.A @ U + self.q(t))

        return U,t

class SchemeEI(SchemeBase):
    """
    Schéma d'Euler implicite.
    """
    def __init__(self, r, sigma, K, T, N, J, Smin, Smax):
        super().__init__(r, sigma, K, T, N, J, Smin, Smax)
        self.scheme_name = "Euler Implicite"

    def solve(self):
        U = self.phi(self.s)
        I = eye(self.J, format="csr")

        for n in range(self.N):
            t = n * self.dt
            U = spsolve(I + self.dt * self.A, U - self.dt * self.q(t))

        return U,t

class SchemeCN(SchemeBase):
    """
    Schéma de Crank-Nicolson.
    """
    def __init__(self, r, sigma, K, T, N, J, Smin, Smax):
        super().__init__(r, sigma, K, T, N, J, Smin, Smax)
        self.scheme_name = "Crank-Nicolson"

    def solve(self):
        U = self.phi(self.s)
        I = eye(self.J, format="csr")
        factor_minus = I - 0.5 * self.dt * self.A
        factor_plus = I + 0.5 * self.dt * self.A

        for n in range(self.N):
            t = n * self.dt

            U = spsolve(factor_plus, factor_minus@U - self.dt * self.q(t))
        return U,t

Résultats des schémas numériques

# Cas 1 : N = 10, J varie dans `values` pour le call européen
values = [10, 20, 50]
N_fixed = 10
cfl_records1 = []

fig, axes = plt.subplots(1, 3, figsize=(24, 8), sharey=False)
for j, J_ in enumerate(values):
    params['N'] = N_fixed
    params['J'] = J_

    ee = SchemeEE(**params)
    U, t = ee.solve()
    s = ee.s
    dt = ee.dt

    # Condition CFL
    CFL = dt / (ee.h ** 2) * (ee.sigma ** 2) * (ee.Smax ** 2)

    # Enregistrement
    cfl_records1.append({
        "N": N_fixed,
        "J": J_,
        "CFL": CFL
    })

    ax = axes[j]
    ax.plot(s, U, label="Prix option")
    ax.plot(s, ee.phi(s), 'k--', label="Payoff")

    ax.set_title(f"N = {N_fixed}, J = {J_}, CFL={CFL:.2f}")
    ax.set_xlabel("s")
    if j == 0:
        ax.set_ylabel("u(t,s)")
    ax.legend()

plt.suptitle(
    f"Evolution du prix du call européen -- Scheme {ee.scheme_name}, N fixé à {N_fixed}",
    fontsize=16
)
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()

#Cas 2 : N = J avec N, J dans `values` pour le call européen
cfl_records2 = []

fig, axes = plt.subplots(1, 3, figsize=(24, 8), sharey=False)
for j, N_ in enumerate(values):
    params['N'] = N_
    params['J'] = N_

    ee = SchemeEE(**params)
    U, t = ee.solve()
    s = ee.s
    dt = ee.dt

    # Condition CFL
    CFL = dt / (ee.h ** 2) * (ee.sigma ** 2) * (ee.Smax ** 2)

    cfl_records2.append({
        "N": N_,
        "J": N_,
        "CFL": CFL
    })

    ax = axes[j]
    ax.plot(s, U, label="Prix option")
    ax.plot(s, ee.phi(s), 'k--', label="Payoff")

    ax.set_title(f"N = J = {N_}, CFL={CFL:.2f}")
    ax.set_xlabel("s")
    if j == 0:
        ax.set_ylabel("u(t,s)")
    ax.legend()

plt.suptitle(
    f"Evolution du prix du call européen -- Scheme {ee.scheme_name}, N = J",
    fontsize=16
)
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()

params['J'] = 50
params['N'] = 10

print("Paramètres financiers:")
print("r=%.2f" %r_, "sigma=%.2f" %sigma_, "K=%.0f" %K_, "T=%.0f" %T_)

print("Paramètres numériques:")
print("J=%.0f" %params['J'], "N=%.0f" %params['N'])

Paramètres financiers:
r=0.10 sigma=0.20 K=100 T=1
Paramètres numériques:
J=50 N=10

ei = SchemeEI(**params)
U,t = ei.solve()
s = ei.s
dt = ei.dt

plt.figure(figsize=(6, 5))
plt.plot(s,U,label="t=%.2f" %(t+dt))
plt.plot(s,ei.phi(s), 'k--', label="payoff")
plt.xlabel("s")
plt.ylabel("u(t,s)")
plt.title("Evolution du prix du call européen au cours du temps [Euler Implicite]")
plt.legend()
plt.show()

cn = SchemeCN(**params)
U,t = cn.solve()
s = cn.s
dt = cn.dt

plt.figure(figsize=(6, 5))
plt.plot(s,U,label="t=%.2f" %(t+dt))
plt.plot(s,cn.phi(s), 'k--', label="payoff")
plt.xlabel("s")
plt.ylabel("u(t,s)")
plt.title("Evolution du prix du call européen au cours du temps [Crank-Nicolson]")
plt.legend()
plt.show()

a. Cas extrêmes

Nous avons analysé l’évolution du prix de l’obligation dans deux cas extrêmes afin d’observer l’impact du coupon sur la dynamique des prix. Toutes choses égales par ailleurs, nous avons modifié le coupon de l’obligation tout en conservant les autres paramètres constants. Les deux scénarios étudiés sont les suivants :

• $ c = 0.01 $ : le coupon est inférieur au taux d’intérêt sans risque.
  
• $ c = 0.05 $ : le coupon est supérieur au taux d’intérêt sans risque.

lambda_ = 1/100
r = 2/100
T = 10
c1 = 1/100
R = 40/100
N=1

clean_prices1 = []
dirty_prices1 = []
for t in grid_values_c:
    B_t_dirty = pricing_bond(t=t,c=c1,T=T,r=r,lambda_=lambda_,R=R,N=N)
    B_t_clean = clean_price(t=t,c=c1,T=T,r=r,lambda_=lambda_,R=R,N=N)
    clean_prices1.append(B_t_clean)
    dirty_prices1.append(B_t_dirty)

plt.plot(grid_values_c,clean_prices1, label="Clean prices")
plt.plot(grid_values_c,dirty_prices1, label="Dirty prices")
plt.title("Clean prices vs Dirty prices")
plt.legend()
plt.grid()
plt.xlabel("t")
plt.ylabel("Prix de l'obligation")

Text(0, 0.5, "Prix de l'obligation")

lambda_ = 1/100
r = 2/100
T = 10
c2 = 5/100
R = 40/100
N=1

clean_prices2 = []
dirty_prices2 = []
for t in grid_values_c:
    B_t_dirty = pricing_bond(t=t,c=c2,T=T,r=r,lambda_=lambda_,R=R,N=N)
    B_t_clean = clean_price(t=t,c=c2,T=T,r=r,lambda_=lambda_,R=R,N=N)
    clean_prices2.append(B_t_clean)
    dirty_prices2.append(B_t_dirty)

plt.plot(grid_values_c,clean_prices2, label="Clean prices")
plt.plot(grid_values_c,dirty_prices2, label="Dirty prices")
plt.title("Clean prices vs Dirty prices")
plt.legend()
plt.grid()
plt.xlabel("t")
plt.ylabel("Prix de l'obligation")

Text(0, 0.5, "Prix de l'obligation")

Obligation au pair

Autour de $c - = 2% $, le prix de l’obligation est égal au nominal. Cela s’explique par le fait que le taux de coupon est exactement égal au taux de marché. L’obligation est alors dite “au pair”, car les investisseurs n’ont ni prime ni décote à appliquer sur son prix.

Explication de la relation négative entre prix et taux

La relation négative entre le prix d’une obligation et le taux d’intérêt s’explique par l’effet de substitution avec les nouvelles émissions obligataires.

• Lorsque les taux d’intérêt augmentent, de nouvelles obligations sont émises avec des coupons plus attractifs.
  
• En conséquence, les obligations existantes, qui offrent un coupon fixe plus faible, deviennent moins intéressantes pour les investisseurs. Leur prix diminue afin d’ajuster leur rendement effectif au nouveau niveau des taux du marché.
  
• Inversement, si les taux d’intérêt baissent, les obligations existantes deviennent plus attractives puisqu’elles offrent un coupon plus élevé que les nouvelles émissions, ce qui entraîne une hausse de leur prix sur le marché secondaire.

Ainsi, la sensibilité d’une obligation aux variations de taux d’intérêt, appelée “duration”, est un élément clé dans l’évaluation du risque de taux et la gestion de portefeuille obligataire.

t=0
lambda_ = 1/100
T = 10
c =3/100
R = 40/100
N=1

dirty_prices = []
grid_values_r = np.arange(0,1,0.001) 
for r in grid_values_r:
    B_t_dirty = pricing_bond(t=t,c=c,T=T,r=r,lambda_=lambda_,R=R,N=N)
    dirty_prices.append(B_t_dirty)

plt.plot(grid_values_r,dirty_prices, label="Dirty prices")
plt.title("Prix de l'obligation en fonction du taux d'intérêt")
plt.legend()
plt.grid()
plt.xlabel("r")
plt.ylabel("Prix de l'obligation")

Text(0, 0.5, "Prix de l'obligation")

Lien entre duration et maturité

• La duration est une approximation de la durée d’exposition au risque, ajustée en fonction des flux de paiements.
  
• Elle est souvent proche de la maturité moyenne de l’obligation, bien que légèrement inférieure (environ 80% de la maturité totale, en fonction des conditions de marché et du niveau des coupons).

Ainsi, plus l’échéance de l’obligation se rapproche, plus la duration tend à augmenter, car les flux futurs deviennent plus proches dans le temps, rendant l’obligation plus sensible aux variations des taux d’intérêt.

Lorsque la maturité de l’obligation approche, sa sensibilité au taux d’intérêt tend à augmenter. En effet, la duration peut être interprétée comme une mesure du temps moyen pondéré pendant lequel l’investisseur est exposé au risque de taux.

t=0
lambda_ = 1/100
r = 2/100
c =3/100
R = 40/100
N=1

dirty_prices = []
grid_values_T = np.arange(1,20,1)
for T in grid_values_T:
    B_t_dirty = sensivity_to_rate(t,c,T,r,lambda_,R,N)
    dirty_prices.append(B_t_dirty)

plt.plot(grid_values_T,dirty_prices, label="Dirty prices")
plt.title("Sensibilité en fonction de la maturité")
plt.legend()
plt.grid()
plt.xlabel("T")
plt.ylabel("Sensibilité")