Use Python like a spreadsheet!
What is modelx?
modelx is a numerical computing tool that enables you to use Python like a spreadsheet by quickly defining cached functions. modelx is best suited for implementing mathematical models expressed in a large system of recursive formulas, in such fields as actuarial science, quantitative finance and risk management.
See also the GitHub Copilot instructions for modelx.
Feature highlights
modelx enables you to interactively develop, run and debug complex models in smart ways. modelx allows you to:
Define cached functions as Cells objects by writing Python functions
Quickly build object-oriented models, utilizing prototype-based inheritance and composition
Quickly parameterize a set of formulas and get results for different parameters
Trace formula dependency
Import and use any Python modules, such as Numpy, pandas, SciPy, scikit-learn, etc..
See formula traceback upon error and inspect local variables
Save models to text files and version-control with Git
Save data such as pandas DataFrames in Excel or CSV files within models
Auto-document saved models by Python documentation generators, such as Sphinx
Use Spyder with a plugin for modelx (spyder-modelx) to interface with modelx through GUI
Export models as Python modules independent of modelx
Translate exported models to Cython optimized code and compile them for performance improvement using Cython through modelx-cython
modelx sites
Home page |
|
Blog |
|
Documentation site |
|
Development |
|
Discussion Forum |
|
modelx on PyPI |
Who is modelx for?
modelx is designed to be domain agnostic, so it’s useful for anyone in any field. Especially, modelx is suited for modeling in such fields such as:
Quantitative finance
Risk management
Actuarial science
lifelib (https://lifelib.io) is a library of actuarial and financial models that are built on top of modelx.
How modelx works
Below is an example showing how to build a simple model using modelx. The model performs a Monte Carlo simulation to generate 10,000 stochastic paths of a stock price that follow a geometric Brownian motion and to price an European call option on the stock.
import modelx as mx
import numpy as np
model = mx.new_model() # Create a new Model named "Model1"
space = model.new_space("MonteCarlo") # Create a UserSpace named "MonteCralo"
# Define names in MonteCarlo
space.np = np
space.M = 10000 # Number of scenarios
space.T = 3 # Time to maturity in years
space.N = 36 # Number of time steps
space.S0 = 100 # S(0): Stock price at t=0
space.r = 0.05 # Risk Free Rate
space.sigma = 0.2 # Volatility
space.K = 110 # Option Strike
# Define Cells objects in MonteCarlo from function definitions
@mx.defcells
def std_norm_rand():
gen = np.random.default_rng(1234)
return gen.standard_normal(size=(N, M))
@mx.defcells
def stock(i):
"""Stock price at time t_i"""
dt = T/N; t = dt * i
if i == 0:
return np.full(shape=M, fill_value=S0)
else:
epsilon = std_norm_rand()[i-1]
return stock(i-1) * np.exp((r - 0.5 * sigma**2) * dt + sigma * epsilon * dt**0.5)
@mx.defcells
def call_opt():
"""Call option price by Monte Carlo"""
return np.average(np.maximum(stock(N) - K, 0)) * np.exp(-r*T)Running the model from IPython is as simple as calling a function:
>>> stock(space.N) # Stock price at i=N i.e. t=T
array([ 78.58406132, 59.01504804, 115.148291 , ..., 155.39335662,
74.7907511 , 137.82730703])
>>> call_opt()
16.26919556999345Changing a parameter is as simple as assigning a value to a name:
>>> space.K = 100 # Cache is cleared by this assignment
>>> call_opt() # New option price for the updated strike
20.96156962064You can even dynamically create multiple copies of MonteCarlo with different combinations of r and sigma, by parameterizing MonteCarlo with r and sigma:
>>> space.parameters = ("r", "sigma") # Parameterize MonteCarlo with r and sigma
>>> space[0.03, 0.15].call_opt() # Dynamically create a copy of MonteCarlo with r=3% and sigma=15%
14.812014828333284
>>> space[0.06, 0.4].call_opt() # Dynamically create another copy with r=6% and sigma=40%
33.90481014639403License
Copyright 2017-2026, Fumito Hamamura
modelx is free software; you can redistribute it and/or modify it under the terms of GNU Lesser General Public License v3 (LGPLv3).
Contributions, productive comments, requests and feedback from the community are always welcome. Information on modelx development is found at Github https://github.com/fumitoh/modelx
Requirements
Python 3.7+
NetwrkX 2.0+
asttokens
LibCST
Pandas
OpenPyXL
1 maintainer
Release files for modelx 0.33.0
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | |
|---|---|---|---|
| modelx-0.33.0.tar.gz | 241.1 kB | Details |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Reset |
|---|---|---|---|---|
| modelx-0.33.0-py3-none-any.whl | Python 3 | none | any | Details |
Total release size: 521.1 kB
Release files / modelx-0.33.0.tar.gz
| Download URL | modelx-0.33.0.tar.gz |
|---|---|
| Size | 241.1 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
caff39e239bf395dd7f96fdf360d7af48b855d751c4a68bee3fb35482180d3de
|
|
BLAKE2b-256 checksum How to use checksums |
1e820df7665bf60eb60d34ee29e058ecd0c1486e256f0fe72787668dd0f75c4f
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/6.2.0 CPython/3.9.25
|
Release files / modelx-0.33.0-py3-none-any.whl
| Download URL | modelx-0.33.0-py3-none-any.whl |
|---|---|
| Size | 280.0 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
0931c547af0c04136817516bc3f26640a3226af0c92f363400e90d348aab5100
|
|
BLAKE2b-256 checksum How to use checksums |
dd6fb0af7a380d134055427ee20c398ccb41c78d58783407ebe96429e5ce6675
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/6.2.0 CPython/3.9.25
|
