finmat 0.1.0__py3-none-any.whl

finmat-0.1.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: finmat
+Version: 0.1.0
+Summary: A financial math library for options pricing, stochastic processes, and fixed income analytics
+Author-email: Daniel Butler <danielbutler245@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/dbu79/fin-mat-library
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+
+# Financial Math Library
+
+A Python library for pricing derivatives, simulating stochastic processes, and analyzing fixed income instruments.
+
+## Features
+
+- **Options Pricing**
+  - Black-Scholes analytical pricing
+  - Heston stochastic volatility model
+  - Monte Carlo simulation
+  - Binomial/trinomial trees
+  - Implied volatility calculation
+
+- **Stochastic Processes**
+  - Arithmetic Brownian Motion (ABM)
+  - Geometric Brownian Motion (GBM)
+  - Cox-Ingersoll-Ross (CIR)
+  - Ornstein-Uhlenbeck (OU)
+  - Vasicek
+  - Jump diffusion (Merton)
+
+- **Fixed Income**
+  - Bond pricing and yield curve tools
+
+- **Portfolio**
+  - Risk and performance metrics
+
+## Project Structure
+
+```
+fixed_income/
+    fixed_income.py        # Fixed income pricing and analytics
+
+options/
+    iv.py                  # Implied volatility solver
+    option.py              # Option contract definitions
+
+portfolio/
+    metrics.py             # Portfolio risk/performance metrics
+
+pricing/
+    black_scholes.py       # Black-Scholes model
+    heston.py               # Heston stochastic volatility model
+    monte_carlo.py          # Monte Carlo pricing engine
+    trees.py                 # Binomial/trinomial tree pricing
+
+processes/
+    abm.py                  # Arithmetic Brownian Motion
+    cir.py                    # Cox-Ingersoll-Ross process
+    gbm.py                   # Geometric Brownian Motion
+    jump_diffusion.py        # Jump diffusion process
+    ou.py                      # Ornstein-Uhlenbeck process
+    vasicek.py                # Vasicek interest rate model
+
+testing.ipynb              # Example usage and validation notebook
+```
+
+## Installation
+
+```bash
+git clone <repo-url>
+cd <repo-name>
+pip install -r requirements.txt
+```
+
+## Usage
+
+See `testing.ipynb` for example workflows, including:
+
+- Pricing European options with Black-Scholes and comparing to Monte Carlo
+- Simulating asset paths with GBM, CIR, and jump diffusion processes
+- Calibrating the Heston model to market data
+- Computing implied volatility surfaces
+- Evaluating fixed income instruments and portfolio metrics
+
+## Requirements
+
+- Python 3.8+
+- NumPy
+- SciPy
+- matplotlib (for notebook visualizations)
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

finmat-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+fixed_income/__init__.py,sha256=-M03eqOgKmpDdcE76SG2NOOlcv07Muaes_WgEgRSwdk,135
+fixed_income/fixed_income.py,sha256=nmy1c0H-GogKWjTaEcbbVvBdKsnY0Dbcwb4BAN7O5fg,1047
+options/__init__.py,sha256=wgfUg5YBENTIG-caoRvS15_zi9rgt2A6onunFwT2d24,61
+options/iv.py,sha256=UgRGXKrMz4_Bu27dyy-rQJi9P9s7Jn3HYY5AptQmIjM,1143
+options/option.py,sha256=eZZKQn2oqOKi49QtQ5efZXoyDLcoNUx5g9tphc75mJM,845
+portfolio/__init__.py,sha256=6FryqsNsq8vrr9goVaWJ_9P9DbrTC2jnLNYHzGA7pVM,36
+portfolio/metrics.py,sha256=-ppV2CQlml3ejYCwkDAzYzayOSh5wLFZpb4RXsPr2os,1670
+pricing/__init__.py,sha256=A35P97bWugX7mqbDQaiz4CqK2X9I78SovuGd7wmrZNo,166
+pricing/black_scholes.py,sha256=l60HxrasZGn_qzNXE_HvIhYYesJXkTqJIMUA6vZwgNY,3350
+pricing/heston.py,sha256=7OEtU-cu9IpkCw62tuzHugkROsh6gVwkib4isdHYZww,1397
+pricing/monte_carlo.py,sha256=XcbrK9wVpZDUsu2EjecN7kFl2nPPmymJ13BE45_9lm0,1336
+pricing/trees.py,sha256=YIpaBlNyW5EODsP1gWl-byawwn81zN4quYft3o0fSj4,1446
+processes/__init__.py,sha256=dPljFrEtNr4EHmeGWgiP1PEPPiazInuu_ZGzn9R_HM4,231
+processes/abm.py,sha256=XpuqxCrk2MASU6w6xW2lS0SigbB1JzEJx7ZDOA2OZ4w,1511
+processes/cir.py,sha256=4SHR8Y4OpvKHM1BwPDWKfoeugLMcguwDvwbpQYQgk1Y,1623
+processes/gbm.py,sha256=gG0U6P8syxy1iA-FXmvK_sLsXxdvyfWUhq6-PH4KY7Q,1553
+processes/jump_diffusion.py,sha256=s7eJ-dmEB-oHk7AvS0Q7dzQ4uhWcspI8wd1HfAhTIC0,2022
+processes/ou.py,sha256=oKM3XYXRl9ZeD1YiKYjAKZnJfcy18KTun1_juHC5y-4,1638
+processes/vasicek.py,sha256=M6zRIY2KB_cu6DicRHt1-C93_3zoIJEqXHcBPGUE-_0,1792
+finmat-0.1.0.dist-info/METADATA,sha256=j5sC7OQWf20qHh5v009x2HHIinDUdjWBXd2c2xkP1Bs,2798
+finmat-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+finmat-0.1.0.dist-info/top_level.txt,sha256=O5eTQpngFkm0pXOfoaknqSOt5dQpMYLPLDqFPJCIYrg,49
+finmat-0.1.0.dist-info/RECORD,,

finmat-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

finmat-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+fixed_income
+options
+portfolio
+pricing
+processes

fixed_income/__init__.py

@@ -0,0 +1 @@
+from fixed_income import simple_interest, compound_interest, future_value, present_value, annuity_pv, annuity_fv, bond_price, convexity

fixed_income/fixed_income.py

@@ -0,0 +1,27 @@
+def simple_interest(P: float, r: float, t: float) -> float:
+    return P * (1 + r * t)
+
+def compound_interest(P: float, r: float, n: int, t: float) -> float:
+    return P * (1 + r/n)**(n*t)
+
+def future_value(PV: float, r: float, n: int) -> float:
+    return PV * (1 + r)**n
+
+def present_value(FV: float, r: float, n: int) -> float:
+    return FV / (1 + r)**n
+
+def annuity_pv(PMT: float, r: float, n: int) -> float:
+    return PMT * (1 - (1 + r)**-n) / r
+
+def annuity_fv(PMT: float, r: float, n: int) -> float:
+    return PMT * ((1 + r)**n - 1) / r
+
+def bond_price(PMT: float, FV: float, r: float, n: int) -> float:
+    """PMT: coupon per period, FV: face value, r: yield per period, n: number of periods"""
+    coupons = sum(PMT / (1 + r)**t for t in range(1, n + 1))
+    principal = FV / (1 + r)**n
+    return coupons + principal
+
+def convexity(P0: float, P_plus: float, P_minus: float, dy: float) -> float:
+    """P_plus/P_minus: prices after +dy/-dy yield shock"""
+    return (P_plus + P_minus - 2 * P0) / (P0 * dy**2)

options/__init__.py

@@ -0,0 +1,2 @@
+from .iv import ImpliedVolatility
+from .option import Option

options/iv.py

@@ -0,0 +1,33 @@
+import numpy as np
+from copy import deepcopy
+from .option import Option
+
+class ImpliedVolatility:
+    @staticmethod
+    def solve(option: Option, market_price, pricer, initial=0.2, tol=1e-8, max_iter=100, h=1e-4, seed=None):
+        sigma = initial
+        copy_ = deepcopy(option)
+        def price_at(sigma_val):
+            copy_.sigma = sigma_val
+            if seed is not None:
+                np.random.seed(seed)
+            return pricer(copy_)
+        
+        for _ in range(max_iter):
+            model_price = price_at(sigma)
+            
+            if abs(model_price - market_price) < tol:
+                return sigma
+            
+            price_up = price_at(sigma + h)
+            price_down = price_at(sigma - h)
+            vega = (price_up - price_down) / (2 * h)
+            if abs(vega) < 1e-10 or not np.isfinite(vega):
+                return np.nan
+            
+            sigma_new = sigma - (model_price - market_price) / vega
+            if not np.isfinite(sigma_new) or sigma_new <= 0: 
+                return np.nan
+            sigma = sigma_new
+        
+        return np.nan

options/option.py

@@ -0,0 +1,23 @@
+class Option:
+    """European option contract with Black-Scholes-style parameters."""
+
+    VALID_TYPES = ('call', 'put')
+
+    def __init__(self, S: float, K: float, T: float, r: float, sigma: float, opt_type: str = 'call'):
+        if S <= 0:
+            raise ValueError("Spot price must be greater than 0")
+        if K <= 0:
+            raise ValueError("Strike price must be greater than 0")
+        if T < 0:
+            raise ValueError("Time to expiry must be non-negative")
+        if sigma <= 0:
+            raise ValueError("Sigma must be greater than 0")
+        if opt_type not in self.VALID_TYPES:
+            raise ValueError(f"opt_type must be one of {self.VALID_TYPES}")
+
+        self.S = S
+        self.K = K
+        self.T = T
+        self.r = r
+        self.sigma = sigma
+        self.opt_type = opt_type

portfolio/__init__.py

@@ -0,0 +1 @@
+from metrics import PortfolioMetrics

portfolio/metrics.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+
+class PortfolioMetrics:
+    """Performance/risk metrics for a daily returns series."""
+
+    def __init__(self, returns, risk_free_rate: float = 0.0):
+        self.returns = np.asarray(returns, dtype=float)
+        self.risk_free_rate = risk_free_rate  # annualized
+
+    def annualized_return(self) -> float:
+        return np.mean(self.returns) * 252
+
+    def annualized_volatility(self) -> float:
+        return np.std(self.returns, ddof=1) * np.sqrt(252)
+
+    def sharpe_ratio(self) -> float:
+        vol = self.annualized_volatility()
+        return (self.annualized_return() - self.risk_free_rate) / vol if vol != 0 else np.inf
+
+    def downside_deviation(self) -> float:
+        daily_rf = self.risk_free_rate / 252
+        downside = self.returns[self.returns < daily_rf]
+        if len(downside) == 0:
+            return 0.0
+        return np.sqrt(np.mean((downside - daily_rf)**2)) * np.sqrt(252)
+
+    def sortino_ratio(self) -> float:
+        downside_vol = self.downside_deviation()
+        if downside_vol == 0:
+            return np.inf
+        return (self.annualized_return() - self.risk_free_rate) / downside_vol
+
+    def max_drawdown(self) -> float:
+        """Assumes self.returns is chronologically ordered."""
+        cumulative_returns = np.cumprod(1 + self.returns)
+        running_max = np.maximum.accumulate(cumulative_returns)
+        drawdowns = (cumulative_returns - running_max) / running_max
+        return np.min(drawdowns)
+
+    def calmar_ratio(self) -> float:
+        max_dd = self.max_drawdown()
+        return self.annualized_return() / abs(max_dd) if max_dd < 0 else np.inf

pricing/__init__.py

@@ -0,0 +1,4 @@
+from .monte_carlo import MonteCarloPricer   
+from .black_scholes import BlackScholesPricer
+from .trees import BinomialTreePricer
+from .heston import HestonPricer

pricing/black_scholes.py

@@ -0,0 +1,107 @@
+from options.option import Option
+import numpy as np
+from scipy.stats import norm
+
+class BlackScholesPricer:
+    """Black-Scholes pricing and Greeks for European Options."""
+    @staticmethod
+    def price(option: Option):
+        S = option.S
+        K = option.K
+        T = option.T
+        r = option.r
+        sigma = option.sigma
+        opt_type = option.opt_type
+
+        d1 = (np.log(S / K) + (r + (sigma**2)/2)*T)/(sigma*np.sqrt(T))
+        d2 = d1 - sigma*np.sqrt(T)
+
+        if opt_type == 'call':
+            return S * norm.cdf(d1) - K * np.exp(-r*T) * norm.cdf(d2)
+        elif opt_type == 'put':
+            return K * np.exp(-r*T) * norm.cdf(-d2) - S * norm.cdf(-d1)
+        else:
+            raise ValueError("Valid types are: 'call' and 'put'")
+    
+    @staticmethod
+    def delta(option: Option) -> float:
+        S = option.S
+        K = option.K
+        T = option.T
+        r = option.r
+        sigma = option.sigma
+        opt_type = option.opt_type
+
+        d1 = (np.log(S / K) + (r + (sigma**2)/2)*T)/(sigma*np.sqrt(T))
+
+        if opt_type == 'call':
+            return norm.cdf(d1)
+        elif opt_type == 'put':
+            return norm.cdf(d1) - 1
+        else:
+            raise ValueError("Valid types are: 'call' and 'put'")
+    
+    @staticmethod
+    def gamma(option: Option) -> float:
+        S = option.S
+        K = option.K
+        T = option.T
+        r = option.r
+        sigma = option.sigma
+
+        d1 = (np.log(S / K) + (r + (sigma**2)/2)*T)/(sigma*np.sqrt(T))
+        return norm.pdf(d1)/(S * sigma * np.sqrt(T))
+
+    @staticmethod
+    def vega(option: Option) -> float:
+        """Per 1% change in volatility"""
+        S = option.S
+        K = option.K
+        T = option.T
+        r = option.r
+        sigma = option.sigma
+
+        d1 = (np.log(S / K) + (r + (sigma**2)/2)*T)/(sigma*np.sqrt(T))
+        return S * norm.pdf(d1) * np.sqrt(T) / 100
+    
+    @staticmethod
+    def theta(option: Option) -> float:
+        """Per day"""
+        S = option.S
+        K = option.K
+        T = option.T
+        r = option.r
+        sigma = option.sigma
+        opt_type = option.opt_type
+
+        d1 = (np.log(S / K) + (r + (sigma**2)/2)*T)/(sigma*np.sqrt(T))
+        d2 = d1 - sigma*np.sqrt(T)
+
+        base_theta = -(S * norm.pdf(d1) * sigma) / (2 * np.sqrt(T))
+        if opt_type == 'call':
+            return (base_theta - (r * K * np.exp(-r * T) * norm.cdf(d2)))/365
+        elif opt_type == 'put':
+            return (base_theta + (r * K * np.exp(-r * T) * norm.cdf(-d2)))/365
+        else:
+            raise ValueError("Valid types are 'call' and 'put'")
+    
+    @staticmethod
+    def rho(option: Option) -> float:
+        """Per 1% change in interest rate"""
+        S = option.S
+        K = option.K
+        T = option.T
+        r = option.r
+        sigma = option.sigma
+        opt_type = option.opt_type
+
+        d1 = (np.log(S / K) + (r + (sigma**2)/2)*T)/(sigma*np.sqrt(T))
+        d2 = d1 - sigma*np.sqrt(T)
+
+        if opt_type == 'call':
+            return K * T * np.exp(-r*T) * norm.cdf(d2) / 100
+        elif opt_type == 'put':
+            return -K * T * np.exp(-r * T) * norm.cdf(-d2) / 100
+        else:
+            raise ValueError("Valid types are 'call' and 'put'")
+        

pricing/heston.py

@@ -0,0 +1,44 @@
+import numpy as np
+from options.option import Option
+
+class HestonPricer:
+    """Heston model for option pricing."""
+    @staticmethod
+    def price(
+        option: Option, 
+        kappa: float, 
+        theta: float, 
+        sigma: float, 
+        rho: float, v0: 
+        float, 
+        n_paths: int = 10000, 
+        n_steps: int = 252) -> float:
+        S0 = option.S
+        K = option.K
+        T = option.T
+        r = option.r
+        opt_type = option.opt_type
+
+        dt = T / n_steps
+        
+        dW1 = np.random.normal(0, np.sqrt(dt), (n_paths, n_steps))
+        dW2 = rho * dW1 + np.sqrt(1 - rho**2) * np.random.normal(0, np.sqrt(dt), (n_paths, n_steps))
+
+        S = np.zeros((n_paths, n_steps + 1))    
+        v = np.zeros((n_paths, n_steps + 1))
+
+        S[:, 0] = S0
+        v[:, 0] = v0 
+
+        for i in range(1, n_steps + 1):
+            S[:, i] = S[:, i - 1] * np.exp((r - 0.5 * v[:, i - 1]) * dt + np.sqrt(v[:, i - 1]) * dW1[:, i - 1])
+            sqrt_v = np.sqrt(np.maximum(v[:, i-1], 0))
+            v_next = (v[:, i-1] + kappa*(theta - v[:, i-1])*dt + sigma*sqrt_v*dW2[:, i-1])
+            v[:, i] = np.maximum(v_next, 0)
+        
+        S_t = S[:, -1]
+        payoff = np.maximum(S_t - K, 0) if opt_type == 'call' else np.maximum(K - S_t, 0)
+        price = np.exp(-r * T) * np.mean(payoff)
+        return price
+
+

pricing/monte_carlo.py

@@ -0,0 +1,33 @@
+from processes.gbm import GeometricBrownianMotion
+import numpy as np
+from options.option import Option
+
+class MonteCarloPricer: 
+    """Monte Carlo pricing for European and Asian options."""
+    @staticmethod
+    def price_european(option: Option, n_paths: int = 10000, n_steps: int = 252) -> float:
+        gbm = GeometricBrownianMotion(S0=option.S, mu=option.r, sigma=option.sigma)
+        paths = gbm.sim_paths(T=option.T, dt=option.T/n_steps, n_paths=n_paths)
+        S_t = paths[:, -1]
+
+        if option.opt_type == 'call':
+            payoffs = np.maximum(S_t - option.K, 0)
+        else:
+            payoffs = np.maximum(option.K - S_t, 0)
+
+        price = np.exp(-option.r * option.T) * np.mean(payoffs)
+        return price
+    
+    @staticmethod
+    def price_asian(option: Option, n_paths: int = 10000, n_steps: int = 252) -> float:
+        gbm = GeometricBrownianMotion(S0=option.S, mu=option.r, sigma=option.sigma)
+        paths = gbm.sim_paths(T=option.T, dt=option.T/n_steps, n_paths=n_paths)
+        path_avg = np.mean(paths, axis=1)
+
+        if option.opt_type == 'call':
+            payoffs = np.maximum(path_avg - option.K, 0)
+        else: 
+            payoffs = np.maximum(option.K - path_avg, 0)
+
+        price = np.exp(-option.r * option.T) * np.mean(payoffs)
+        return price

pricing/trees.py

@@ -0,0 +1,37 @@
+import numpy as np
+from options.option import Option
+
+class BinomialTreePricer:
+    """Binomial tree pricing for American options."""
+    @staticmethod
+    def price_american(option: Option, u: float, d: float, n_steps: int = 100) -> float:
+        S0 = option.S
+        K = option.K
+        T = option.T
+        r = option.r
+        opt_type = option.opt_type
+
+        dt = T / n_steps
+        q = (np.exp(r * dt) - d) / (u - d)
+        discount = np.exp(-r * dt)
+
+        asset_prices = np.zeros(n_steps + 1)
+        for i in range(n_steps + 1):
+            asset_prices[i] = S0 * (u ** i) * (d ** (n_steps - i))
+        
+        option_values = np.zeros(n_steps + 1)
+        for i in range(n_steps + 1):
+            if opt_type == 'call':
+                option_values[i] = np.maximum(asset_prices[i] - K, 0)
+            else:
+                option_values[i] = np.maximum(K - asset_prices[i], 0)
+
+        for i in np.arange(n_steps - 1, -1, -1):
+            for j in range(i + 1):
+                option_values[j] = discount * (q * option_values[j + 1] + (1 - q) * option_values[j])
+                asset_price = S0 * (u ** j) * (d ** (i - j))
+                if opt_type == 'call':
+                    option_values[j] = np.maximum(option_values[j], asset_price - K)
+                else:
+                    option_values[j] = np.maximum(option_values[j], K - asset_price)
+        return option_values[0]

processes/__init__.py

@@ -0,0 +1,6 @@
+from .gbm import GeometricBrownianMotion
+from .abm import ArithmeticBrownianMotion
+from .jump_diffusion import JumpDiffusion
+from .ou import OrnsteinUhlenbeck
+from .vasicek import VasicekModel
+from .cir import CoxIngersollRoss

processes/abm.py

@@ -0,0 +1,44 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+class ArithmeticBrownianMotion:
+    """Arithmetic Brownian Motion (ABM) process."""
+    def __init__(self, S0: float, mu: float, sigma: float):
+        self.S0 = S0
+        self.mu = mu
+        self.sigma = sigma
+
+    def sim_paths(self, dt: float, T: float, n_paths: int) -> np.ndarray:
+        n_steps = int(T / dt)
+        paths = np.zeros((n_paths, n_steps + 1))
+
+        dW = np.random.normal(0, 1, (n_paths, n_steps))        
+        paths[:, 0] = self.S0
+
+        for i in range(1, n_steps + 1):
+            paths[:, i] = paths[:, i-1] + self.mu*dt + self.sigma*np.sqrt(dt)*dW[:, i - 1]
+
+        return paths
+    
+    def plot_paths(self, paths, title='ABM Simulated Paths', xlabel='Steps', ylabel='Price', average=True, largest=True, smallest=True):
+        fig, ax = plt.subplots()
+        
+        for path in paths:
+            ax.plot(path, color='#1f77b4', linewidth=0.75, alpha=0.5)
+        
+        average_ = np.mean(paths, axis=0)
+        largest_ = np.max(paths, axis=0)
+        smallest_ = np.min(paths, axis=0)
+        if average:
+            ax.plot(average_, color='purple', linewidth=0.8, alpha=0.4)
+        if largest:
+            ax.plot(largest_, color='green', linewidth=0.8, alpha=0.4)
+        if smallest:
+            ax.plot(smallest_, color="red", linewidth=0.8, alpha=0.4)
+
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        plt.show()
+
+

processes/cir.py

@@ -0,0 +1,46 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+class CoxIngersollRoss:
+    """Cox-Ingersoll-Ross (CIR) process."""
+    def __init__(self, r0: float, a: float, b: float, sigma: float):
+        self.r0 = r0
+        self.a = a
+        self.b = b
+        self.sigma = sigma
+
+    def sim_paths(self, T: float, dt: float, n_paths: int) -> np.ndarray:
+        n_steps = int(T / dt)
+        paths = np.zeros((n_paths, n_steps + 1))
+        paths[:, 0] = self.r0
+
+        sqrt_dt = np.sqrt(dt)
+        for i in range(1, n_steps + 1):
+            r_prev = paths[:, i - 1]
+            z = np.random.normal(size=n_paths)
+            dr = (self.a * (self.b - r_prev) * dt
+                  + self.sigma * np.sqrt(r_prev) * sqrt_dt * z)
+            paths[:, i] = np.maximum(r_prev + dr, 0)
+
+        return paths
+
+    def plot_paths(self, paths, title='CIR Simulated Paths', xlabel='Steps', ylabel='Rate', average=True, largest=True, smallest=True):
+        fig, ax = plt.subplots()
+
+        for path in paths:
+            ax.plot(path, color='#1f77b4', linewidth=0.75, alpha=0.5)
+
+        average_ = np.mean(paths, axis=0)
+        largest_ = np.max(paths, axis=0)
+        smallest_ = np.min(paths, axis=0)
+        if average:
+            ax.plot(average_, color='purple', linewidth=0.8, alpha=0.4)
+        if largest:
+            ax.plot(largest_, color='green', linewidth=0.8, alpha=0.4)
+        if smallest:
+            ax.plot(smallest_, color="red", linewidth=0.8, alpha=0.4)
+
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        plt.show()

processes/gbm.py

@@ -0,0 +1,44 @@
+import numpy as np
+import matplotlib.pyplot as plt 
+
+class GeometricBrownianMotion:
+    """Geometric Brownian Motion (GBM) process."""
+    def __init__(self, S0: float, mu: float, sigma: float):
+        self.S0 = S0
+        self.mu = mu 
+        self.sigma = sigma
+
+
+    def sim_paths(self, T: float, dt: float, n_paths: int) -> np.ndarray:
+        n_steps = int(T / dt)
+        paths = np.zeros((n_paths, n_steps + 1))
+        paths[:, 0] = self.S0
+
+        dW = np.random.normal(0, np.sqrt(dt), (n_paths, n_steps))
+
+        for i in range(1, n_steps + 1):
+            paths[:, i] = paths[:, i-1] * np.exp(
+                (self.mu - 0.5*self.sigma**2)*dt + self.sigma*dW[:, i-1]
+            )
+        return paths
+
+    def plot_paths(self, paths, title='GBM Simulated Paths', xlabel='Steps', ylabel='Price', average=True, largest=True, smallest=True):
+        fig, ax = plt.subplots()
+        
+        for path in paths:
+            ax.plot(path, color='#1f77b4', linewidth=0.75, alpha=0.5)
+        
+        average_ = np.mean(paths, axis=0)
+        largest_ = np.max(paths, axis=0)
+        smallest_ = np.min(paths, axis=0)
+        if average:
+            ax.plot(average_, color='purple', linewidth=0.8, alpha=0.4)
+        if largest:
+            ax.plot(largest_, color='green', linewidth=0.8, alpha=0.4)
+        if smallest:
+            ax.plot(smallest_, color="red", linewidth=0.8, alpha=0.4)
+
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        plt.show()

processes/jump_diffusion.py

@@ -0,0 +1,54 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+class JumpDiffusion:
+    """Jump Diffusion process."""
+    def __init__(self, S0: float, mu: float, sigma: float, lambda_j: float, mu_j: float, sigma_j: float):
+        self.S0 = S0
+        self.mu = mu
+        self.sigma = sigma
+        self.lambda_j = lambda_j
+        self.mu_j = mu_j
+        self.sigma_j = sigma_j
+
+    def sim_paths(self, T: float, dt: float, n_paths: int) -> np.ndarray:
+        n_steps = int(T / dt)
+        paths = np.zeros((n_paths, n_steps + 1))
+        paths[:, 0] = self.S0
+
+        dW = np.random.normal(0, np.sqrt(dt), (n_paths, n_steps))
+
+        n_jumps = np.random.poisson(self.lambda_j * dt, (n_paths, n_steps))
+        jump_mean = n_jumps * self.mu_j
+        jump_std = np.sqrt(n_jumps) * self.sigma_j
+        log_jumps = np.random.normal(jump_mean, np.where(jump_std > 0, jump_std, 1e-12))
+        log_jumps = np.where(n_jumps > 0, log_jumps, 0)
+
+
+
+        for i in range(1, n_steps + 1):
+            paths[:, i] = paths[:, i-1] * np.exp(
+                (self.mu - 0.5*self.sigma**2)*dt + self.sigma*dW[:, i-1] + log_jumps[:, i-1]
+            )
+        return paths
+        
+    def plot_paths(self, paths, title='Jump Diffusion Simulated Paths', xlabel='Steps', ylabel='Price', average=True, largest=True, smallest=True):
+        fig, ax = plt.subplots()
+        
+        for path in paths:
+            ax.plot(path, color='#1f77b4', linewidth=0.75, alpha=0.5)
+        
+        average_ = np.mean(paths, axis=0)
+        largest_ = np.max(paths, axis=0)
+        smallest_ = np.min(paths, axis=0)
+        if average:
+            ax.plot(average_, color='purple', linewidth=0.8, alpha=0.4)
+        if largest:
+            ax.plot(largest_, color='green', linewidth=0.8, alpha=0.4)
+        if smallest:
+            ax.plot(smallest_, color="red", linewidth=0.8, alpha=0.4)
+
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        plt.show()

processes/ou.py

@@ -0,0 +1,46 @@
+import numpy as np 
+import matplotlib.pyplot as plt
+
+class OrnsteinUhlenbeck:
+    """Ornstein-Uhlenbeck (OU) process."""
+    def __init__(self, X0: float, theta: float, mu: float, sigma: float, T: float, dt: float):
+        self.X0 = X0
+        self.theta = theta
+        self.mu = mu 
+        self.sigma = sigma
+        self.T = T
+        self.dt = dt
+
+    def process(self, n_paths: int) -> np.ndarray:
+        n_steps = int(self.T / self.dt)
+
+        paths = np.zeros((n_paths, n_steps + 1))
+        paths[:, 0] = self.X0
+
+        dW = np.random.normal(0, np.sqrt(self.dt), (n_paths, n_steps))
+        for i in range(1, n_steps + 1):
+            paths[:, i] = paths[:, i-1] + self.theta * (self.mu - paths[:, i-1]) * self.dt + self.sigma * dW[:, i-1]
+            
+
+        return paths
+    
+    def plot_paths(self, paths, title='Ornstein-Uhlenbeck Simulated Paths', xlabel='Steps', ylabel='Value', average=True, largest=True, smallest=True):
+        fig, ax = plt.subplots()
+        for path in paths:
+            ax.plot(path, color='#1f77b4', linewidth=0.8, alpha=0.5)
+        
+        average_ = np.mean(paths, axis=0)
+        largest_ = np.max(paths, axis=0)
+        smallest_ = np.min(paths, axis=0)
+        if average:
+            ax.plot(average_, color='purple', linewidth=0.8, alpha=0.4)
+        if largest:
+            ax.plot(largest_, color='green', linewidth=0.8, alpha=0.4)
+        if smallest:
+            ax.plot(smallest_, color="red", linewidth=0.8, alpha=0.4)
+
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        plt.show()
+

processes/vasicek.py

@@ -0,0 +1,48 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+class VasicekModel:
+    """Vasicek model for interest rate simulation."""
+    def __init__(self, theta: float, mu: float, sigma: float, r0: float):
+        self.theta = theta
+        self.mu = mu
+        self.sigma = sigma
+        self.r0 = r0
+
+    def sim_paths(self, T: float, dt: float, n_paths: int) -> np.ndarray:
+        n_steps = int(T / dt)
+        paths = np.zeros((n_paths, n_steps + 1))
+        paths[:, 0] = self.r0
+
+        sqrt_dt = np.sqrt(dt)
+        for i in range(1, n_steps + 1):
+            r_prev = paths[:, i - 1]
+            z = np.random.normal(size=n_paths)
+            dr = self.theta * (self.mu - r_prev) * dt + self.sigma * sqrt_dt * z
+            paths[:, i] = r_prev + dr
+
+        return paths
+
+    def plot_paths(self, paths, T, dt, title='Simulated Vasicek Interest Rate Paths', xlabel='Time', ylabel='Interest Rate', average=True, largest=True, smallest=True):
+        n_steps = int(T / dt)
+        time_points = np.linspace(0, T, n_steps + 1)
+
+        fig, ax = plt.subplots()
+        for path in paths:
+            ax.plot(time_points, path, color='#1f77b4', linewidth=0.75, alpha=0.5)
+
+        average_ = np.mean(paths, axis=0)
+        largest_ = np.max(paths, axis=0)
+        smallest_ = np.min(paths, axis=0)
+        if average:
+            ax.plot(time_points, average_, color='purple', linewidth=0.8, alpha=0.4)
+        if largest:
+            ax.plot(time_points, largest_, color='green', linewidth=0.8, alpha=0.4)
+        if smallest:
+            ax.plot(time_points, smallest_, color="red", linewidth=0.8, alpha=0.4)
+
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        ax.set_xlim(0, T)
+        plt.show()