{ "cells": [ { "cell_type": "markdown", "id": "f841da38", "metadata": {}, "source": [ "# Computation of the skew in rough Heston\n", "\n", "$$\n", "\\def\\R{\\mathbb{R}}\n", "\\def\\dd{\\mathrm{d}}\n", "\\def\\ii{\\mathrm{i}}\n", "$$\n", "\n", "We compute the skew in rough Heston using **Fourier pricing**. Recall the definition of rough Heston:\n", "$$\n", "\\begin{gather*}\n", "\\dd S_t = \\sqrt{v_t} S_t \\dd Z_t, \\quad Z_t = \\rho W_t + \\sqrt{1-\\rho^2} W^\\perp_t,\\\\\n", "v_t = v_0 + \\int_0^t K(t-s) \\kappa(\\theta - v_s) \\dd s + \\int_0^t K(t-s) \\sigma \\sqrt{v_s} \\dd W_s, \\\\ \n", "K(r) \\coloneqq \\frac{r^{H-1/2}}{\\Gamma(H+1/2)}.\n", "\\end{gather*}\n", "$$\n", "\n", "Further recall that the characteristic function of the log-price $X_t$ is given by\n", "$$\n", "\\phi_0(u) \\coloneqq \\mathbb{E}\\left[ \\exp\\left( \\ii u X_T \\right) \\right] = \\exp\\left( \\ii u X_0 + \\int_0^T \\xi_t(s) Q(u, \\psi(u, T-s)) \\dd s \\right),\n", "$$\n", "where $\\psi$ solves the fractional Riccati equation\n", "$$\n", "\\psi(u, \\tau) = K \\ast \\left( Q(u, \\psi(u, \\cdot)) - \\kappa \\psi(u, \\cdot)\\right)(\\tau),\\quad Q(u,z) \\coloneqq \\frac{1}{2} \\ii u(\\ii u - 1) + \\ii \\sigma \\rho u z + \\frac{\\sigma^2}{2} z^2.\n", "$$\n", "\n", "We start by importing some functions. The code below is largely taken from **Simon Breneis**' public github repository [approximations_to_fractional_stochastic_volterra_equations](https://github.com/SimonBreneis/approximations_to_fractional_stochastic_volterra_equations).\n", "\n", "Let us first import some needed packages." ] }, { "cell_type": "code", "execution_count": 2, "id": "70ed2ced", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from numpy.polynomial.polynomial import Polynomial\n", "import matplotlib.pyplot as plt\n", "import time\n", "import psutil\n", "from scipy.special import gamma\n", "from scipy.stats import norm" ] }, { "cell_type": "markdown", "id": "849fe953", "metadata": {}, "source": [ "Next we import the Fourier pricing function from Simon's packages. Note that I have put here a slimmed down version of Simon's full package, containing only the needed functions. We will go through the code one by one.\n", "\n", "## Fourier pricing\n", "\n", "First, suppose that we are given the characteristic function of the log-price of a stock, and we want to compute the implied volatilities.\n", "\n", "#### Integrand in the Fourier domain" ] }, { "cell_type": "code", "execution_count": 3, "id": "40d65aea", "metadata": {}, "outputs": [], "source": [ "def fourier_payoff_call_put(K, u, call=True, digital=False, logarithmic=True):\n", " \"\"\"\n", " Returns the value of the Fourier transform of the payoff of a (digital or standard) \n", " put or call option. Is a complex number.\n", " :param K: Strike price, may also be a numpy array\n", " :param u: Argument of the Fourier transform\n", " :param call: If True, returns the Fourier transform of a call option. If False, of a put \n", " option\n", " :param digital: If True, returns the Fourier transform of a digital option. If False, \n", " of a standard option\n", " :param logarithmic: If True, assumes that the payoff is a function of the log-stock price. If False, assumes it is a function of the (normal) stock price\n", " :return: hat(f)(u) (or hat(f)(K, u) if K is a numpy array)\n", " \"\"\"\n", " u = complex(0, 1) * u\n", " if digital:\n", " sign = -1 if call else 1\n", " if logarithmic:\n", " if isinstance(K, np.ndarray):\n", " return sign * np.exp(np.multiply.outer(np.log(K), u)) / u\n", " return sign * np.exp(np.log(K) * u) / u\n", " if isinstance(K, np.ndarray):\n", " return sign * np.exp(np.multiply.outer(K, u)) / u\n", " return sign * np.exp(K * u) / u\n", " if logarithmic:\n", " if isinstance(K, np.ndarray):\n", " return np.exp(np.multiply.outer(np.log(K), 1 + u)) / (u * (1 + u))\n", " return np.exp(np.log(K) * (1 + u)) / (u * (1 + u))\n", " if isinstance(K, np.ndarray):\n", " return np.exp(np.multiply.outer(K, u)) / u ** 2\n", " return np.exp(K * u) / u ** 2" ] }, { "cell_type": "markdown", "id": "7b1e1a94", "metadata": {}, "source": [ "#### Compute the price\n", "\n", "As discussed in the lecture, we use a variant of Lewis' method, i.e., a proper contour integral. Note that the function assumes the characteristic function of $X_T = \\log S_T$ for some fixed maturity $T$ as input, but allows for an array of strike prices $K$." ] }, { "cell_type": "code", "execution_count": 4, "id": "da0b8a38", "metadata": {}, "outputs": [], "source": [ "def price_eur_call_put_fourier(mgf, K, r=0., T=1., R=2., L=50., N=300, log_price=True, \n", " call=True, digital=False):\n", " \"\"\"\n", " Computes the option price of a (digital or standard) European call or put option using \n", " Fourier inversion.\n", " :param mgf: The moment generating function of the log-variable that should be priced \n", " (e.g. the final log-price, or the final log-average), a function of the Fourier \n", " argument only\n", " :param R: The (dampening) shift that we use\n", " :param K: The strike prices, assumed to be a numpy array\n", " :param r: Interest rate\n", " :param T: Maturity (only needed for discounting, i.e. if r != 0)\n", " :param L: The value at which we cut off the integral, so we do not integrate over the \n", " reals, but only over [-L, L]\n", " :param N: The number of points used in the trapezoidal rule for the approximation of \n", " the integral\n", " :param log_price: If True, assumes that the mgf is the mgf of the log-price. If False, \n", " assumes it is the mgf of the price (without the logarithm)\n", " :param call: If True, returns the call price. Else, returns the put price\n", " :param digital: If True, computes the price of a digital option. Else, of a standard \n", " option\n", " :return: The estimate of the option price\n", " \"\"\"\n", " if call:\n", " R = np.abs(R)\n", " else:\n", " R = - np.abs(R)\n", " x = np.linspace(0, L, N + 1)\n", " y = np.zeros(N+1)\n", " y[:N] = x[1:] - x[:-1]\n", " y[1:] += x[1:] - x[:-1]\n", " y /= 2\n", " mgf_output = np.empty(len(x), dtype=np.cdouble)\n", " total_rounds = 1\n", " current_round = 0\n", " while current_round < total_rounds:\n", " n_inputs = int(np.ceil(len(x) / total_rounds))\n", " try:\n", " mgf_output[current_round * n_inputs:(current_round + 1) * n_inputs] = \\\n", " mgf(R - complex(0, 1) * \\\n", " x[current_round * n_inputs:(current_round + 1) * n_inputs])\n", " except MemoryError:\n", " if total_rounds < len(x):\n", " total_rounds = total_rounds * 2\n", " current_round = current_round * 2 - 1\n", " else:\n", " raise MemoryError('Not enough memory to carry out Fourier inversion.')\n", " current_round = current_round + 1\n", " fourier_payoff = fourier_payoff_call_put(K=K, u=x + complex(0, 1) * R, call=call, \n", " digital=digital, logarithmic=log_price)\n", " return np.exp(-r * T) / np.pi * np.real(fourier_payoff @ (mgf_output * y))" ] }, { "cell_type": "markdown", "id": "e5f15a9c", "metadata": {}, "source": [ "#### Compute the implied volatility\n", "\n", "This time, we use our own function to compute implied volatilities from prices." ] }, { "cell_type": "code", "execution_count": 5, "id": "aa0b836e", "metadata": {}, "outputs": [], "source": [ "def BS_price_eur_call_put(S_0, K, sigma, T, r=0., call=True, digital=False):\n", " \"\"\"\n", " Computes the price of a (digital or standard) European call or put option under the \n", " Black-Scholes model.\n", " :param S_0: Initial stock price\n", " :param K: Strike price\n", " :param sigma: Volatility\n", " :param r: Drift\n", " :param T: Final time\n", " :param call: If True, prices a call option. Else prices a put option\n", " :param digital: If True, prices a digital option. Else prices a standard option\n", " :return: The price of a call option\n", " \"\"\"\n", " T = T[..., None] if (isinstance(T, np.ndarray) and len(T.shape) == 1) else T\n", "\n", " def BS_nodes(regularize=True):\n", " \"\"\"\n", " Computes the two nodes of the Black-Scholes model where the CDF is evaluated.\n", " :param regularize: Ensures that the results are in the interval [-30, 30] to \n", " avoid overflow/underflow errors.\n", " :return: The nodes\n", " \"\"\"\n", " d1_ = (np.log(S_0 / K) + (r + sigma ** 2 / 2) * T) / (sigma * np.sqrt(T))\n", " d2_ = (np.log(S_0 / K) + (r - sigma ** 2 / 2) * T) / (sigma * np.sqrt(T))\n", " if regularize:\n", " d1_ = np.fmax(np.fmin(d1_, 30), -30)\n", " d2_ = np.fmax(np.fmin(d2_, 30), -30)\n", " return d1_, d2_\n", "\n", " if digital:\n", " put_price = norm.cdf((np.log(K / S_0) + sigma ** 2 * T / 2 - r * T) / \\\n", " (sigma * np.sqrt(T)))\n", " if call:\n", " return 1 - put_price\n", " else:\n", " return put_price\n", " d1, d2 = BS_nodes()\n", " if call:\n", " return S_0 * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)\n", " return - S_0 * norm.cdf(-d1) + K * np.exp(-r * T) * norm.cdf(-d2)\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "5ad68cd3", "metadata": {}, "outputs": [], "source": [ "def iv(BS_price_fun, price, tol=1e-10, sl=1e-10, sr=10.):\n", " \"\"\"\n", " Computes the implied volatility of an option given its price, assuming the volatility \n", " is in [sl, sr].\n", " :param BS_price_fun: A function of the volatility sigma that returns the corresponding \n", " Black-Scholes price\n", " :param price: (Market) price of the option\n", " :param tol: Error tolerance in the approximation of the implied volatility\n", " :param sl: Left point of the search interval\n", " :param sr: Right point of the search interval\n", " :return: The implied volatility\n", " \"\"\"\n", " threshold = sl + tol\n", " sm = (sl + sr) / 2\n", " while np.amax(sr - sl) > tol:\n", " em = BS_price_fun(sm) - price\n", " sl = (em < 0) * sm + (em >= 0) * sl\n", " sr = (em >= 0) * sm + (em < 0) * sr\n", " sm = (sl + sr) / 2\n", " return np.where(sm < threshold, np.nan, sm)\n", "\n", "def iv_eur(S_0, K, T, price, payoff, r=0., stat=None):\n", " \"\"\"\n", " Computes the implied volatility of a European call or put option given its price.\n", " :param S_0: Initial stock price\n", " :param K: Strike price\n", " :param r: Drift\n", " :param T: Final time/maturity\n", " :param price: (Market) price of the option\n", " :param payoff: Either 'call' or 'put' or a payoff function taking as input S (final \n", " stock price samples) and K (strike or other parameters), and returning the payoffs \n", " for all the stock prices S\n", " :param stat: Can specify a MC error (statistical variance interval). In this case, \n", " returns the implied volatility as well as the corresponding MC interval\n", " :return: The implied volatility\n", " \"\"\"\n", " T = T[..., None] if (isinstance(T, np.ndarray) and len(T.shape) == 1) else T\n", "\n", " if payoff == 'call' or payoff == payoff_call:\n", " def price_fun(s):\n", " return BS_price_eur_call_put(S_0=S_0, K=K, sigma=s, r=r, T=T, call=True, \n", " digital=False)\n", " elif payoff == 'digital call':\n", " def price_fun(s):\n", " return BS_price_eur_call_put(S_0=S_0, K=K, sigma=s, r=r, T=T, call=True, \n", " digital=True)\n", " elif payoff == 'put' or payoff == payoff_put:\n", " def price_fun(s):\n", " return BS_price_eur_call_put(S_0=S_0, K=K, sigma=s, r=r, T=T, call=False, \n", " digital=False)\n", " elif payoff == 'digital put':\n", " def price_fun(s):\n", " return BS_price_eur_call_put(S_0=S_0, K=K, sigma=s, r=r, T=T, call=False, \n", " digital=True)\n", " else:\n", " if isinstance(T, np.ndarray):\n", " normal_rv = np.sqrt(T) * np.random.normal(0, 1, (T.shape[0], 1000000))\n", " else:\n", " normal_rv = np.sqrt(T) * np.random.normal(0, 1, 1000000)\n", "\n", " def price_fun(s):\n", " return np.average(np.exp(-r * T) * \\\n", " payoff(S=np.exp(s * normal_rv + (r - 0.5 * s ** 2) * T), K=K), \n", " axis=-1)\n", " if stat is None:\n", " return iv(BS_price_fun=price_fun, price=price)\n", " return iv(BS_price_fun=price_fun, price=price), iv(BS_price_fun=price_fun, \n", " price=price - stat), \\\n", " iv(BS_price_fun=price_fun, price=price + stat)\n", "\n", "def iv_eur_call_put_fourier(mgf, S_0, K, T, r=0., R=2., L=50., N=300, call=True, \n", " digital=False):\n", " \"\"\"\n", " Computes the implied volatility of a (digital or standard) European call or put option \n", " using Fourier inversion.\n", " :param mgf: The moment generating function of the final log-price, a function of the \n", " Fourier argument only\n", " :param S_0: Initial stock price\n", " :param T: Maturity\n", " :param r: Drift\n", " :param R: The (dampening) shift that we use\n", " :param K: The strike prices, assumed to be a numpy array\n", " :param L: The value at which we cut off the integral, so we do not integrate over the \n", " reals, but only over [-L, L]\n", " :param N: The number of points used in the trapezoidal rule for the approximation of \n", " the integral\n", " :param call: If True, computes the implied volatility of a call option. Else, of a \n", " put option\n", " :param digital: If True, computes the implied volatility of a digital option. Else, of \n", " a standard option\n", " :return: The estimate of the implied volatility\n", " \"\"\"\n", " payoff = 'call'\n", " if digital:\n", " if call:\n", " payoff = 'digital call'\n", " else:\n", " payoff = 'digital put'\n", " return iv_eur(S_0=S_0, K=K, T=T, \n", " price=price_eur_call_put_fourier(mgf=mgf, K=K, r=r, T=T, R=R, L=L, N=N, \n", " call=True), r=r, \n", " payoff=payoff)" ] }, { "cell_type": "markdown", "id": "53623222", "metadata": {}, "source": [ "## The characteristic function\n", "\n", "Next we need the characteristic function. In what follows, we are going to use the characteristic function of the **Heston model**. Your homework will be to replace this with the characteristic function of the **rough Heston model**." ] }, { "cell_type": "code", "execution_count": 7, "id": "4b5204a6", "metadata": {}, "outputs": [], "source": [ "def solve_fractional_Riccati(F, T, N_Riccati, H=None, nodes=None, weights=None, verbose=0):\n", " \"\"\"\n", " Solves psi(t) = int_0^t K(t - s) F(s, psi(s)) ds.\n", " :param F: Right-hand side (time-dependent!)\n", " :param T: Final time\n", " :param N_Riccati: Number of time steps used for solving the fractional Riccati equation. \n", " This is only an initial choice, this number may be adaptively increased if the \n", " computation otherwise fails\n", " :param H: Hurst parameter\n", " :param nodes: Nodes of the Markovian approximation\n", " :param weights: Weights of the Markovian approximation\n", " :param verbose: Determines the number of intermediary results printed to the console\n", " :return: The solution psi\n", " \"\"\"\n", " dim = len(F(0, 0))\n", " dt = T / N_Riccati\n", " available_memory = np.sqrt(psutil.virtual_memory().available)\n", " necessary_memory = np.sqrt(5 * dim) * np.sqrt(N_Riccati) * \\\n", " np.sqrt(np.array([0.], dtype=np.cdouble).nbytes)\n", " if necessary_memory > available_memory:\n", " raise MemoryError(f'Not enough memory to compute the characteristic function of the rough Heston model with'\n", " f'{dim} inputs and {N_Riccati} time steps. Roughly {necessary_memory}**2 bytes needed, '\n", " f'while only {available_memory}**2 bytes are available.')\n", "\n", " if nodes is None or weights is None:\n", " coefficient = dt ** (H + 0.5) / gamma(H + 2.5)\n", " v_1 = coefficient * np.arange(N_Riccati + 1) ** (H + 1.5)\n", " v_2 = v_1[N_Riccati:1:-1] + v_1[N_Riccati - 2::-1] - 2 * v_1[N_Riccati - 1:0:-1]\n", " v_3 = v_1[:-1] - coefficient * (np.arange(N_Riccati) - H - 0.5) * \\\n", " np.arange(1, N_Riccati + 1) ** (H + 0.5)\n", "\n", " psi = np.zeros(shape=(dim, N_Riccati + 1), dtype=np.cdouble)\n", " F_vec = np.zeros(shape=(dim, N_Riccati), dtype=np.cdouble)\n", " F_vec[:, 0] = F(0, psi[:, 0])\n", " psi_P = F_vec[:, 0] * (v_3[0] + coefficient)\n", " psi[:, 1] = F_vec[:, 0] * v_3[0] + coefficient * F(1 / N_Riccati, psi_P)\n", " for k in range(1, N_Riccati):\n", " F_vec[:, k] = F(k / N_Riccati, psi[:, k])\n", " first_summands = F_vec[:, 0] * v_3[k] + F_vec[:, 1:k + 1] @ v_2[-k:]\n", " psi_P = first_summands + coefficient * F_vec[:, k]\n", " psi[:, k + 1] = first_summands + coefficient * F((k + 1) / N_Riccati, psi_P)\n", " if np.amax(np.abs(psi[:, k + 1])) > 1e+70:\n", " if verbose >= 1:\n", " print(f'Increase N_Riccati from {N_Riccati} to {int(N_Riccati * 1.3)}')\n", " return solve_fractional_Riccati(F=F, T=T, N_Riccati=int(N_Riccati * 1.3), \n", " H=H, verbose=verbose)\n", "\n", " else:\n", " nodes, weights = rk.sort(nodes, weights)\n", " n_zero_nodes = np.sum(nodes < 1e-08)\n", " N = len(nodes)\n", "\n", " exp_nodes = np.zeros(N)\n", " temp = nodes * dt\n", " exp_nodes[temp < 300] = np.exp(-temp[temp < 300])\n", " div_nodes = np.zeros(N)\n", " div_nodes[:n_zero_nodes] = dt\n", " div_nodes[n_zero_nodes:] = (1 - exp_nodes[n_zero_nodes:]) / nodes[n_zero_nodes:]\n", " div_weights = div_nodes * weights\n", " new_div = np.sum(div_weights)\n", "\n", " psi_x = np.zeros((dim, N), dtype=np.cdouble)\n", " psi = np.zeros((dim, N_Riccati + 1), dtype=np.cdouble)\n", "\n", " for i in range(N_Riccati):\n", " psi_P = new_div * F(i / N_Riccati, psi[:, i]) + psi_x @ exp_nodes\n", " psi_x = div_weights[None, :] * F((i + 0.5) / N_Riccati, 0.5 * \n", " (psi[:, i] + psi_P))[:, None] \\\n", " + psi_x * exp_nodes[None, :]\n", " psi[:, i + 1] = np.sum(psi_x, axis=1)\n", " if np.amax(np.abs(psi[:, i + 1])) > 1e+70:\n", " if verbose >= 1:\n", " print(f'Increase N_Riccati from {N_Riccati} to {int(N_Riccati * 1.3)}')\n", " return solve_fractional_Riccati(F=F, T=T, N_Riccati=int(N_Riccati * 1.3), \n", " H=H, nodes=nodes,\n", " weights=weights, verbose=verbose)\n", "\n", " return psi\n", "\n", "def cf_log_price(z, S_0, lambda_, rho, nu, theta, V_0, T, N_Riccati, r=0., H=None, \n", " nodes=None, weights=None, verbose=0):\n", " \"\"\"\n", " Gives the characteristic function of the log-price of the rough Heston model.\n", " :param z: Argument of the characteristic function (assumed to be a numpy array)\n", " :param S_0: Initial stock price\n", " :param lambda_: Mean-reversion speed\n", " :param rho: Correlation between Brownian motions\n", " :param nu: Volatility of volatility\n", " :param theta: Mean variance\n", " :param V_0: Initial variance\n", " :param T: Final time\n", " :param N_Riccati: Number of time steps used for solving the fractional Riccati equation\n", " :param r: Interest rate\n", " :param H: Hurst parameter\n", " :param nodes: Nodes of the Markovian approximation\n", " :param weights: Weights of the Markovian approximation\n", " :param verbose: Determines the number of intermediary results printed to the console\n", " :return: The characteristic function, and the number of time steps N_Riccati that were \n", " actually used\n", " \"\"\"\n", " z = complex(0, 1) * z\n", " a = nu * nu / 2\n", " b = rho * nu * z - lambda_\n", " c = (z - 1) * z / 2\n", "\n", " def F(t, x):\n", " return c + (b + a * x) * x\n", "\n", " psi = solve_fractional_Riccati(F=F, T=T, N_Riccati=N_Riccati, H=H, nodes=nodes, \n", " weights=weights, verbose=verbose)\n", " N_Riccati = psi.shape[1] - 1 \n", " # The function solve_fractional_Riccati may finally use a different number N_Riccati\n", " integral = np.trapz(psi, dx=T / N_Riccati)\n", " integral_sq = np.trapz(psi ** 2, dx=T / N_Riccati)\n", " return np.exp((np.log(S_0) + r * T) * z + V_0 * T * c + \n", " (theta + V_0 * b) * integral + V_0 * a * integral_sq), N_Riccati" ] }, { "cell_type": "markdown", "id": "21226e32", "metadata": {}, "source": [ "## Putting all together\n", "\n", "We want to compute the implied volatility surface, and then also the implied volatility skews.\n", "\n", "#### Computation of the implied volatilities" ] }, { "cell_type": "code", "execution_count": 8, "id": "6f19786d", "metadata": {}, "outputs": [], "source": [ "def compute_Fourier_inversion(S_0, K, T, fun, rel_tol=1e-03, return_error=False, \n", " H=None, verbose=0):\n", " \"\"\"\n", " Computes the Fourier inversion given a relative error tolerance by finding the \n", " appropriate parameters for\n", " solving the Riccati equations, and computing the inverse Fourier integral.\n", " :param S_0: Initial stock price\n", " :param K: Strike price, assumed to be a numpy array (1d or 2d)\n", " :param T: Numpy array of maturities\n", " :param fun: Function that computes the Fourier inversion given the numerical parameters. \n", " Is a function of\n", " T_ (single maturity), K_ (array of strikes), N_Riccati (number of Riccati intervals),\n", " L (cutoff for the Fourier integral), N_Fourier (number of Fourier intervals),\n", " R (dampening shift that makes the Fourier inversion integrable)\n", " :param rel_tol: Required maximal relative error in the implied volatility\n", " :param return_error: If True, also returns a relative error estimate\n", " :param H: Hurst parameter. Specifying may improve convergence speed\n", " :param verbose: Determines how many intermediate results are printed to the console\n", " return: The implied volatility of the call option\n", " \"\"\"\n", " R = 2. # The (dampening) shift that we use for the Fourier inversion\n", "\n", " def single_maturity(T_, compute, eps):\n", " \"\"\"\n", " Computes the Fourier inversion for a single maturity given a relative error \n", " tolerance by finding the appropriate parameters for solving the Riccati \n", " equations, and computing the inverse Fourier integral.\n", " :param T_: Single maturity\n", " :param compute: Function that computes the Fourier inversion given the numerical \n", " parameters for a single maturity. Is a function of\n", " N_Riccati (number of Riccati intervals), L (cutoff for the Fourier integral),\n", " N_Fourier (number of Fourier intervals),\n", " and returns the Fourier inversion, together with the actual number of N_Riccati \n", " that was finally used\n", " :param eps: Relative error tolerance\n", " return: The implied volatility of the call option\n", " \"\"\"\n", " L = 100 * T_ ** (-0.5 + (0 if H is None else H)) \n", " # The value at which we cut off the Fourier integral,\n", " # so we do not integrate over the reals, but only over [0, L]\n", " N_Riccati = int(10 * L)\n", " N_Fourier = int(8 * L) \n", " # The number of points used in the trapezoidal rule for the approximation of the Fourier\n", " # integral\n", " np.seterr(all='warn')\n", " tic = time.perf_counter()\n", " smile = compute(N_Riccati=N_Riccati, L=L, N_Fourier=N_Fourier)\n", " duration = time.perf_counter() - tic\n", " smile_approx = compute(N_Riccati=int(N_Riccati / 1.6), L=L / 1.2, \n", " N_Fourier=N_Fourier // 2)\n", " error = np.amax(np.abs(smile_approx - smile) / smile)\n", " if verbose >= 4:\n", " print(np.abs(smile_approx - smile) / smile)\n", " if verbose >= 2:\n", " print(error)\n", "\n", " while np.isnan(error) or error > eps or np.sum(np.isnan(smile)) > 0:\n", " if np.sum(np.isnan(smile)) == 0:\n", " if H is None or H > 0:\n", " smile_approx = compute(N_Riccati=int(N_Riccati / 1.8), L=L, \n", " N_Fourier=N_Fourier)\n", " error_Riccati = np.amax(np.abs(smile_approx - smile) / smile)\n", " if not np.isnan(error_Riccati) and error_Riccati < eps / 5 and \\\n", " np.sum(np.isnan(smile_approx)) == 0:\n", " N_Riccati = int(N_Riccati / 1.6)\n", " else:\n", " error_Riccati = np.inf\n", "\n", " smile_approx = compute(N_Riccati=N_Riccati, L=L, N_Fourier=N_Fourier // 2)\n", " error_Fourier = np.amax(np.abs(smile_approx - smile) / smile)\n", " if not np.isnan(error_Fourier) and error_Fourier < eps / 5 and \\\n", " np.sum(np.isnan(smile_approx)) == 0:\n", " N_Fourier = int(N_Fourier / 1.8)\n", " else:\n", " error_Fourier, error_Riccati = np.nan, np.nan\n", "\n", " smile_approx = smile\n", " if np.sum(np.isnan(smile)) > 0:\n", " L = L * 1.6\n", " N_Fourier = int(N_Fourier * 1.7)\n", " N_Riccati = int(N_Riccati * 2.5)\n", " else:\n", " L = L * 1.4\n", " N_Fourier = int(N_Fourier * 1.4) if error_Fourier < eps / 2 else N_Fourier * 2\n", " N_Riccati = int(N_Riccati * 1.4) if error_Riccati < eps / 2 else N_Riccati * 2\n", " if verbose >= 2:\n", " print(error, error_Fourier, error_Riccati, L, N_Fourier, N_Riccati, duration,\n", " time.strftime(\"%H:%M:%S\", time.localtime()))\n", "\n", " tic = time.perf_counter()\n", " smile = compute(N_Riccati=N_Riccati, L=L, N_Fourier=N_Fourier)\n", " duration = time.perf_counter() - tic\n", " error = np.amax(np.abs(smile_approx - smile) / smile)\n", " if verbose >= 4:\n", " print(np.abs(smile_approx - smile) / smile)\n", " if verbose >= 2:\n", " print(error)\n", "\n", " return smile, error\n", "\n", " T_is_float = False\n", " if not isinstance(T, np.ndarray):\n", " T = np.array([T])\n", " T_is_float = True\n", " if len(K.shape) == 1:\n", " K = S_0 * np.exp(np.sqrt(T / T[-1])[:, None] * np.log(K / S_0)[None, :])\n", "\n", " surface = np.empty_like(K)\n", " errors = np.empty(len(T))\n", " for i in range(len(T)):\n", " if verbose >= 1 and len(T) > 1:\n", " print(f'Now simulating maturity {i+1} of {len(T)}')\n", "\n", " def fun_maturity(N_Riccati, L, N_Fourier):\n", " return fun(T_=T[i], K_=K[i, :], N_Riccati=N_Riccati, L=L, N_Fourier=N_Fourier, R=R)\n", " surface[i, :], errors[i] = single_maturity(compute=fun_maturity, T_=T[i],\n", " eps=rel_tol[i] if isinstance(rel_tol, \n", " np.ndarray) \n", " else rel_tol)\n", " if T_is_float:\n", " surface = surface[0, :]\n", " errors = errors[0]\n", " if return_error:\n", " return surface, errors\n", " return surface" ] }, { "cell_type": "markdown", "id": "fd7925ef", "metadata": {}, "source": [ "#### Implied volatility surface and skew" ] }, { "cell_type": "code", "execution_count": 9, "id": "ef7f1f90", "metadata": {}, "outputs": [], "source": [ "def eur_call_put(S_0, K, lambda_, rho, nu, theta, V_0, T, r=0., N=0, mode=\"european\", \n", " rel_tol=1e-03, H=None, nodes=None, weights=None, implied_vol=True, \n", " call=True, digital=False, return_error=False, verbose=0):\n", " \"\"\"\n", " Computes the implied volatility or price of a (digital or standard) European call or \n", " put option in the rough Heston model.\n", " Uses Fourier inversion.\n", " :param S_0: Initial stock price\n", " :param K: Strike price, assumed to be a numpy array\n", " :param H: Hurst parameter\n", " :param lambda_: Mean-reversion speed\n", " :param rho: Correlation between Brownian motions\n", " :param nu: Volatility of volatility\n", " :param theta: Mean variance\n", " :param V_0: Initial variance\n", " :param T: Maturity\n", " :param r: Interest rate\n", " :param N: Total number of points in the quadrature rule\n", " :param mode: If observation, uses the parameters from the interpolated numerical optimum. \n", " If theorem, uses the parameters from the theorem. If optimized, optimizes over the \n", " nodes and weights directly. If best, chooses any of these three options that seems \n", " most suitable\n", " :param rel_tol: Required maximal relative error in the implied volatility\n", " :param nodes: Can specify the nodes directly\n", " :param weights: Can specify the weights directly\n", " :param implied_vol: If True, computes the implied volatility, else computes the price\n", " :param call: If True, uses the call option, else uses the put option\n", " :param digital: If True, uses a digital option, else uses a standard option\n", " :param return_error: If True, also returns a relative maximal error estimate\n", " :param verbose: Determines how many intermediate results are printed to the console\n", " return: The implied volatility of the call option\n", " \"\"\"\n", " if N >= 1 and (nodes is None or weights is None):\n", " nodes, weights = rk.quadrature_rule(H=H, N=N, T=T, mode=mode)\n", "\n", " def mgf(z, T_, N_):\n", " return cf_log_price(z=complex(0, -1) * z, S_0=S_0, lambda_=lambda_, rho=rho, nu=nu, \n", " theta=theta, r=r, V_0=V_0, T=T_, N_Riccati=N_, H=H, nodes=nodes, \n", " weights=weights, verbose=verbose - 2)[0]\n", "\n", " if implied_vol:\n", " def compute(T_, K_, N_Riccati, L, N_Fourier, R):\n", " return iv_eur_call_put_fourier(mgf=lambda u: mgf(z=u, T_=T_, N_=N_Riccati), \n", " S_0=S_0, K=K_, T=T_, r=r,R=R, L=L, N=N_Fourier, \n", " digital=digital)\n", " else:\n", " def compute(T_, K_, N_Riccati, L, N_Fourier, R):\n", " return price_eur_call_put_fourier(mgf=lambda u: mgf(z=u, T_=T_, N_=N_Riccati), \n", " K=K_, T=T_, r=r, R=R, L=L, N=N_Fourier, \n", " log_price=True, call=call, digital=digital)\n", "\n", " return compute_Fourier_inversion(fun=compute, S_0=S_0, K=K, T=T, rel_tol=rel_tol, \n", " return_error=return_error, H=H, verbose=verbose)\n", "\n", "\n", "def skew_eur_call_put(lambda_, rho, nu, theta, V_0, T, r=0., N=0, mode=\"european\", \n", " rel_tol=1e-03, H=None, nodes=None, weights=None, verbose=0):\n", " \"\"\"\n", " Gives the skew of the European call or put option (skew is the same in both cases) in \n", " the rough Heston model. Uses Fourier inversion.\n", " :param H: Hurst parameter\n", " :param lambda_: Mean-reversion speed\n", " :param rho: Correlation between Brownian motions\n", " :param nu: Volatility of volatility\n", " :param theta: Mean variance\n", " :param V_0: Initial variance\n", " :param T: Maturity\n", " :param r: Interest rate\n", " :param N: Total number of points in the quadrature rule\n", " :param mode: If observation, uses the parameters from the interpolated numerical \n", " optimum. If theorem, uses the parameters from the theorem. If optimized, optimizes \n", " over the nodes and weights directly. If best, chooses any of these three options \n", " that seems most suitable\n", " :param rel_tol: Required maximal relative error in the implied volatility\n", " :param nodes: Can specify the nodes directly\n", " :param weights: Can specify the weights directly\n", " :param verbose: Determines how many intermediate results are printed to the console\n", " return: The skew of the call option\n", " \"\"\"\n", " if N >= 1 and (nodes is None or weights is None):\n", " nodes, weights = rk.quadrature_rule(H, N, T, mode)\n", "\n", " def single_skew(T_):\n", "\n", " def compute_smile(eps_, h_):\n", " if verbose >= 2:\n", " print(f'Computing smile with {eps_} and {h_}')\n", " K = np.exp(np.linspace(-200 * h_, 200 * h_, 401))\n", " smile_, error_ = eur_call_put(S_0=1., K=K, lambda_=lambda_, rho=rho, nu=nu, \n", " theta=theta, V_0=V_0, T=T_, r=r, N=N, mode=mode, \n", " rel_tol=eps_, H=H, nodes=nodes, weights=weights, \n", " implied_vol=True, call=True, return_error=True, \n", " verbose=verbose - 2)\n", " return np.array([smile_[198], smile_[199], smile_[201], smile_[202]]), error_\n", "\n", " eps = rel_tol\n", " h = 0.0005 * np.sqrt(T_)\n", " smile, eps = compute_smile(eps_=eps, h_=h)\n", " skew_ = np.abs(smile[2] - smile[1]) / (2 * h)\n", " skew_h = np.abs(smile[3] - smile[0]) / (4 * h)\n", " old_eps = eps\n", " smile, eps = compute_smile(eps_=0.9 * eps, h_=h)\n", " skew_eps = skew_\n", " skew_eps_h = skew_h\n", " skew_ = np.abs(smile[2] - smile[1]) / (2 * h)\n", " skew_h = np.abs(smile[3] - smile[0]) / (4 * h)\n", " error = np.abs(skew_eps_h - skew_) / skew_\n", " error_eps = np.abs(skew_eps - skew_) / skew_\n", " error_h = np.abs(skew_h - skew_) / skew_\n", " if verbose >= 2:\n", " print(error, error_eps, error_h)\n", "\n", " while error > rel_tol:\n", " if error_eps > rel_tol * 0.8:\n", " old_eps = eps\n", " smile, eps = compute_smile(eps_=0.9 * eps, h_=h)\n", " skew_eps = skew_\n", " skew_eps_h = skew_h\n", " skew_ = np.abs(smile[2] - smile[1]) / (2 * h)\n", " skew_h = np.abs(smile[3] - smile[0]) / (4 * h)\n", " error = np.abs(skew_eps_h - skew_) / skew_\n", " error_eps = np.abs(skew_eps - skew_) / skew_\n", " error_h = np.abs(skew_h - skew_) / skew_\n", " else:\n", " h = h / 2\n", " smile, old_eps = compute_smile(eps_=1.1 * old_eps, h_=h)\n", " skew_eps = np.abs(smile[2] - smile[1]) / (2 * h)\n", " skew_eps_h = np.abs(smile[3] - smile[0]) / (4 * h)\n", " smile, eps = compute_smile(eps_=np.fmin(1.1 * eps, 0.99 * old_eps), h_=h)\n", " skew_ = np.abs(smile[2] - smile[1]) / (2 * h)\n", " skew_h = np.abs(smile[3] - smile[0]) / (4 * h)\n", " error = np.abs(skew_eps_h - skew_) / skew_\n", " error_eps = np.abs(skew_eps - skew_) / skew_\n", " error_h = np.abs(skew_h - skew_) / skew_\n", "\n", " if verbose >= 2:\n", " print(error, error_eps, error_h)\n", " return skew_\n", "\n", " T_is_float = False\n", " if not isinstance(T, np.ndarray):\n", " T = np.array([T])\n", " T_is_float = True\n", "\n", " skew = np.empty(len(T))\n", " for i in range(len(T)):\n", " if verbose >= 1:\n", " print(f'Now computing skew {i + 1} of {len(T)}')\n", " skew[i] = single_skew(T_=T[i])\n", " if T_is_float:\n", " skew = skew[0]\n", " return skew\n" ] }, { "cell_type": "markdown", "id": "2c4dc88d", "metadata": {}, "source": [ "## Finally run some code and plot the results\n", "\n", "First we fix the parameters." ] }, { "cell_type": "code", "execution_count": 18, "id": "db3edcb8", "metadata": {}, "outputs": [], "source": [ "S_0 = 1\n", "kappa = 0\n", "rho = -0.7\n", "nu = 0.3\n", "theta = 0.04\n", "V_0 = 0.04\n", "H = 0.1\n", "\n", "maturities = np.linspace(0.05, 2, 100)\n", "strikes = S_0 * np.linspace(0.9, 1.2, 100)" ] }, { "cell_type": "markdown", "id": "2208d8e1", "metadata": {}, "source": [ "#### Implied volatility surface\n", "\n", "First we compute the implied volatility surface." ] }, { "cell_type": "code", "execution_count": 22, "id": "ee8355cf", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_30478/1428634637.py:113: DeprecationWarning: `trapz` is deprecated. Use `trapezoid` instead, or one of the numerical integration functions in `scipy.integrate`.\n", " integral = np.trapz(psi, dx=T / N_Riccati)\n", "/tmp/ipykernel_30478/1428634637.py:114: DeprecationWarning: `trapz` is deprecated. Use `trapezoid` instead, or one of the numerical integration functions in `scipy.integrate`.\n", " integral_sq = np.trapz(psi ** 2, dx=T / N_Riccati)\n" ] } ], "source": [ "vols = np.empty((len(maturities), len(strikes)))\n", "for i in range(len(maturities)):\n", " vols[i, :] = eur_call_put(S_0, strikes, kappa, rho, nu, theta, V_0, maturities[i], H=H)" ] }, { "cell_type": "code", "execution_count": 23, "id": "9fb3f7a5", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "K_mesh, T_mesh = np.meshgrid(strikes, maturities)\n", "\n", "fig = plt.figure(figsize=(12, 8))\n", "ax = fig.add_subplot(111, projection='3d')\n", "\n", "ax.view_init(elev=30, azim=-60)\n", "\n", "# Plot the surface\n", "surf = ax.plot_surface(K_mesh, T_mesh, vols, cmap='cividis',\n", " linewidth=0, antialiased=True)\n", "\n", "# Add labels and title\n", "ax.set_xlabel('Strike')\n", "ax.set_ylabel('Maturity')\n", "ax.set_zlabel('Implied Volatility')\n", "ax.set_title('Implied Volatility Surface')\n", "\n", "# Add a color bar\n", "fig.colorbar(surf, shrink=0.5, aspect=5)\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "048f1517", "metadata": {}, "source": [ "#### Skew\n", "\n", "Next, compute the skew." ] }, { "cell_type": "code", "execution_count": 19, "id": "805a4e30", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_30478/1428634637.py:113: DeprecationWarning: `trapz` is deprecated. Use `trapezoid` instead, or one of the numerical integration functions in `scipy.integrate`.\n", " integral = np.trapz(psi, dx=T / N_Riccati)\n", "/tmp/ipykernel_30478/1428634637.py:114: DeprecationWarning: `trapz` is deprecated. Use `trapezoid` instead, or one of the numerical integration functions in `scipy.integrate`.\n", " integral_sq = np.trapz(psi ** 2, dx=T / N_Riccati)\n" ] } ], "source": [ "skew = skew_eur_call_put(kappa, rho, nu, theta, V_0, maturities, r=0., N=0, H=H)" ] }, { "cell_type": "markdown", "id": "e4932799", "metadata": {}, "source": [ "Estimate the behaviour of the skew." ] }, { "cell_type": "code", "execution_count": 20, "id": "989eb954", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "beta = -0.5270578545783561, H - 1/2 = -0.4\n" ] } ], "source": [ "new_series = Polynomial.fit(np.log(maturities), np.log(np.abs(skew)), deg=1)\n", "l_alpha, beta = new_series.convert().coef\n", "alpha = np.exp(l_alpha)\n", "print(f\"beta = {beta}, H - 1/2 = {H - 0.5}\")" ] }, { "cell_type": "markdown", "id": "a742a0b0", "metadata": {}, "source": [ "Plot the skew." ] }, { "cell_type": "code", "execution_count": 21, "id": "02b0d95e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(figsize=(10,5))\n", "ax.plot(maturities, np.abs(skew), \"b-\", label=r\"$\\psi(t)$\")\n", "ax.plot(maturities, alpha * maturities ** beta, \"r--\", label=r\"Fit: $\\alpha t^{\\beta}$\")\n", "ax.set_xscale('log')\n", "ax.set_yscale('log')\n", "ax.set_xlabel(\"t\")\n", "ax.set_ylabel(r\"$\\psi(t)$\")\n", "ax.legend()" ] } ], "metadata": { "kernelspec": { "display_name": "winterschool", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.14.2" } }, "nbformat": 4, "nbformat_minor": 5 }