Fix SVJ model (#22)

Author: lsbardel

notebooks/_config.yml

@@ -56,7 +56,6 @@ sphinx:
     }
   extra_extensions:
     - "sphinx.ext.autodoc"
-    - "sphinx_autodoc_typehints"
     - "sphinx.ext.autosummary"
     - "sphinx.ext.intersphinx"
     - "sphinx_autosummary_accessors"

notebooks/_toc.yml

@@ -33,6 +33,7 @@ parts:
   - file: examples/overview
     sections:
     - file: examples/gaussian_sampling
+    - file: examples/exponential_sampling
     - file: examples/poisson_sampling
     - file: examples/heston_vol_surface
 

notebooks/api/options/black.rst

@@ -6,6 +6,8 @@ Black Pricing
 
 .. autofunction:: black_price
 
+.. autofunction:: black_delta
+
 .. autofunction:: black_vega
 
 .. autofunction:: implied_black_volatility

notebooks/api/utils/bins.rst

@@ -0,0 +1,9 @@
+===========
+Bins
+===========
+
+.. module:: quantflow.utils.bins
+
+.. autofunction:: pdf
+
+.. autofunction:: event_density

notebooks/api/utils/distributions.rst

@@ -0,0 +1,25 @@
+==============
+Distributions
+==============
+
+.. module:: quantflow.utils.distributions
+
+.. autoclass:: Exponential
+   :members:
+   :member-order: groupwise
+   :autosummary:
+   :autosummary-nosignatures:
+
+
+.. autoclass:: DoubleExponential
+   :members:
+   :member-order: groupwise
+   :autosummary:
+   :autosummary-nosignatures:
+
+
+.. autoclass:: Normal
+   :members:
+   :member-order: groupwise
+   :autosummary:
+   :autosummary-nosignatures:

notebooks/api/utils/index.rst

@@ -8,3 +8,5 @@ Utils
     :maxdepth: 1
 
     marginal1d
+    distributions
+    bins

notebooks/examples/exponential_sampling.md

@@ -0,0 +1,61 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.16.6
+kernelspec:
+  display_name: .venv
+  language: python
+  name: python3
+---
+
+# Exponential Sampling
+
+Here we sample the Asymmetric Laplace distribution. We will set the mean to 0 and the variance to 1 so that the distribution is fully determined by the asymmetric parameter $\kappa$.
+
+```{code-cell} ipython3
+from quantflow.utils.distributions import DoubleExponential
+from quantflow.utils import bins
+import numpy as np
+import ipywidgets as widgets
+import plotly.graph_objects as go
+
+def simulate():
+    pr = DoubleExponential.from_moments(kappa=np.exp(asym.value))
+    data = pr.sample(samples.value)
+    pdf = bins.pdf(data, num_bins=50, symmetric=0)
+    pdf["simulation"] = pdf["pdf"]
+    pdf["analytical"] = pr.pdf(pdf.index)
+    cha = pr.pdf_from_characteristic()
+    return pdf, cha
+
+def on_change(change):
+    df, cha = simulate()
+    fig.data[0].x = df.index
+    fig.data[0].y = df["simulation"]
+    fig.data[1].x = df.index
+    fig.data[1].y = df["analytical"]
+    fig.data[2].x = cha.x
+    fig.data[2].y = cha.y
+
+asym = widgets.FloatSlider(description="asymmetry (log of k)", min=-2, max=2)
+samples = widgets.IntSlider(description="paths", min=100, max=10000, step=100)
+asym.value = 0
+samples.value = 1000
+asym.observe(on_change)
+samples.observe(on_change)
+
+df, cha = simulate()
+simulation = go.Bar(x=df.index, y=df["simulation"], name="simulation")
+analytical = go.Scatter(x=df.index, y=df["analytical"], name="analytical")
+cha = go.Scatter(x=cha.x, y=cha.y, name="from characteristic", mode="markers")
+fig = go.FigureWidget(data=[simulation, cha, analytical])
+
+widgets.VBox([asym, samples, fig])
+```
+
+```{code-cell} ipython3
+
+```

notebooks/examples/heston_vol_surface.md

@@ -6,36 +6,46 @@ jupytext:
     format_version: 0.13
     jupytext_version: 1.16.6
 kernelspec:
-  display_name: Python 3 (ipykernel)
+  display_name: .venv
   language: python
   name: python3
 ---
 
 # Heston Volatility Surface
 
-```{code-cell}
+Here we study the Implied volatility surface of the Heston model. The Heston model is a stochastic volatility model that is widely used in the finance industry to price options.
+
+```{code-cell} ipython3
 from quantflow.sp.heston import HestonJ
 from quantflow.options.pricer import OptionPricer
 
-pricer = OptionPricer(model=HestonJ.create(
+pricer = OptionPricer(model=HestonJ.exponential(
     vol=0.5,
     kappa=2,
-    rho=-0.3,
-    sigma=0.8,
-    theta=0.36,
-    jump_fraction=0.3,
-    jump_asymmetry=1.2
+    rho=0.0,
+    sigma=0.6,
+    jump_fraction=0.5,
+    jump_asymmetry=1.0
 ))
 pricer
 ```
 
-```{code-cell}
+```{code-cell} ipython3
+fig = None
+for ttm in (0.1, 0.5, 1):
+    fig = pricer.maturity(ttm).plot(fig=fig, name=f"ttm={ttm}")
+fig
+```
+
+
+
+```{code-cell} ipython3
 pricer.plot3d(max_moneyness_ttm=1.5, support=31).update_layout(
     height=800,
     title="Heston volatility surface",
 )
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 
 ```

notebooks/models/poisson.md

@@ -7,14 +7,14 @@ jupytext:
     format_version: 0.13
     jupytext_version: 1.16.6
 kernelspec:
-  display_name: Python 3 (ipykernel)
+  display_name: .venv
   language: python
   name: python3
 ---
 
 # Poisson Processes
 
-In this section, we look at the family of pure jump processes which are Lévy provcesses.
+In this section, we look at the family of pure jump processes which are Lévy processes.
 The most common process is the Poisson process.
 
 ## Poisson Process
@@ -31,48 +31,48 @@ The characteristic exponent is given by
 \phi_{N_t, u} = t \lambda \left(1 - e^{iu}\right)
 \end{equation}
 
-```{code-cell}
+```{code-cell} ipython3
 from quantflow.sp.poisson import PoissonProcess
 pr = PoissonProcess(intensity=1)
 pr
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 m = pr.marginal(0.1)
 import numpy as np
 cdf = m.cdf(np.arange(5))
 cdf
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 n = 128*8
 m.cdf_from_characteristic(5, frequency_n=n).y
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 cdf1 = m.cdf_from_characteristic(5, frequency_n=n).y
 cdf2 = m.cdf_from_characteristic(5, frequency_n=n, simpson_rule=False).y
 10000*np.max(np.abs(cdf-cdf1)), 10000*np.max(np.abs(cdf-cdf2))
 ```
 
 ### Marginal
 
-```{code-cell}
+```{code-cell} ipython3
 import numpy as np
 from quantflow.utils import plot
 
 m = pr.marginal(1)
 plot.plot_marginal_pdf(m, frequency_n=128*8)
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 from quantflow.utils.plot import plot_characteristic
 plot_characteristic(m)
 ```
 
 ### Sampling Poisson
 
-```{code-cell}
+```{code-cell} ipython3
 p = pr.sample(10, time_horizon=10, time_steps=1000)
 p.plot().update_traces(line_width=1)
 ```
@@ -101,41 +101,41 @@ The mean and variance of the compund Poisson is given by
     {\mathbb Var}\left[x_t^2\right] &= \lambda t \left({\mathbb Var}\left[j\right] + {\mathbb E}\left[j\right]^2\right)
 \end{align}
 
-### Exponential Compound Poisson Process
+## Exponential Compound Poisson Process
 
-The library includes the Exponential Poisson Process, a compound Poisson process where the jump sizes are sampled from an exponential distribution.
+The Exponential Poisson Process is a compound Poisson process where the jump sizes are sampled from an exponential distribution. To create an Exponential Compound Poisson process we simply pass the `Exponential` distribution as the jump distribution.
 
-```{code-cell}
+```{code-cell} ipython3
 from quantflow.sp.poisson import CompoundPoissonProcess
 from quantflow.utils.distributions import Exponential
 
 pr = CompoundPoissonProcess(intensity=1, jumps=Exponential(decay=1))
 pr
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 from quantflow.utils.plot import plot_characteristic
 m = pr.marginal(1)
 plot_characteristic(m)
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 m.mean(), m.mean_from_characteristic()
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 m.variance(), m.variance_from_characteristic()
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 pr.sample(10, time_horizon=10, time_steps=1000).plot().update_traces(line_width=1)
 ```
 
 ### MC simulations
 
 Here we test the simulated mean and standard deviation against the analytical values.
 
-```{code-cell}
+```{code-cell} ipython3
 import pandas as pd
 from quantflow.utils import plot
 
@@ -145,7 +145,7 @@ df = pd.DataFrame(mean, index=paths.time)
 plot.plot_lines(df)
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 std = dict(std=pr.marginal(paths.time).std(), simulated=paths.std())
 df = pd.DataFrame(std, index=paths.time)
 plot.plot_lines(df)
@@ -155,19 +155,19 @@ plot.plot_lines(df)
 
 A compound Poisson process with a normal jump distribution
 
-```{code-cell}
+```{code-cell} ipython3
 from quantflow.utils.distributions import Normal
 from quantflow.sp.poisson import CompoundPoissonProcess
 pr = CompoundPoissonProcess(intensity=10, jumps=Normal(mu=0.01, sigma=0.1))
 pr
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 m = pr.marginal(1)
 m.mean(), m.std()
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 m.mean_from_characteristic(), m.std_from_characteristic()
 ```
 
@@ -222,14 +222,14 @@ The intensity function of a DSPP is given by:
 {\mathbb P}\left(N_T - N_t = n\right) = {\mathbb E}_t\left[e^{-\Lambda_{t,T}} \frac{\Lambda_{t, T}^n}{n!}\right] = \frac{1}{n!}
 \end{equation}
 
-```{code-cell}
+```{code-cell} ipython3
 from quantflow.sp.dsp import DSP, PoissonProcess, CIR
 pr = DSP(intensity=CIR(sigma=2, kappa=1), poisson=PoissonProcess(intensity=2))
 pr2 = DSP(intensity=CIR(rate=2, sigma=4, kappa=2, theta=2), poisson=PoissonProcess(intensity=1))
 pr, pr2
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 import numpy as np
 from quantflow.utils import plot
 import plotly.graph_objects as go
@@ -242,28 +242,28 @@ plot.plot_marginal_pdf(pr2.marginal(1), n, analytical=False, fig=fig, marker_col
 fig.add_trace(go.Scatter(x=pdf.x, y=pr.poisson.marginal(1).pdf(pdf.x), name="Poisson", mode="markers", marker_color="blue"))
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 pr.marginal(1).mean(), pr.marginal(1).variance()
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 pr2.marginal(1).mean(), pr2.marginal(1).variance()
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 from quantflow.utils.plot import plot_characteristic
 m = pr.marginal(2)
 plot_characteristic(m)
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 pr.sample(10, time_horizon=10, time_steps=1000).plot().update_traces(line_width=1)
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 m.characteristic(2)
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 m.characteristic(-2).conj()
 ```