avhz/rustquant

Rust library for quantitative finance.

A Rust library for quantitative finance.

🎯 If you are an experienced quant developer in any language and would like to help out, feel free to contact me!

Email	Discord	Latest Changes
[email protected]	https://discord.gg/gMdv8Hpuwr	Changelog

Modules

Module	Description
autodiff	Algorithmic adjoint differentiation (AAD) for efficiently computing gradients of scalar output functions $f: \mathbb{R}^n \rightarrow \mathbb{R}$.
data	Data types that can be used for pricing and similar tasks (curves, term-structures, surfaces, etc). Methods for reading and writing data from/to various sources (CSV, JSON, Parquet). Can also download data from Yahoo! Finance.
error	RustQuant error handling module.
instruments	Various implementations for instruments like Bonds and Options, and the pricing of them. Others coming in the future (swaps, futures, CDSs, etc).
iso	A few ISO code implementations. Currently: ISO-4217 (currency codes), ISO-3166 (country codes), ISO-10383 (market identifier codes).
math	Statistical distributions and their related functions (PDF, CDF, CF, etc), Fast Fourier Transform (FFT), numerical integration (double-exponential quadrature), optimisation/root-finding (gradient descent, Newton-Raphson), and risk-reward metrics. Also some sequence methods such as linspace and cumsum.
ml	Currently only linear and logistic regression, along with k-nearest neighbours classification are implemented. More to come in the future.
macros	Currently only plot_vector!() and assert_approx_equal!().
models	Various models commonly used in quantitative finance, such as the various forms of Brownian Motion, short rate models, curve models, etc.
money	Implementations for Cashflows, Currencies, and Quotes, and similar types.
portfolio	Implementation of a portfolio type, which is a collection (HashMap) of Positions.
stochastics	Stochastic process generators for Brownian Motion (standard, arithmetic, fractional, and geometric) and various short-rate models (CIR, OU, Vasicek, Hull-White, etc).
time	Time and date functionality, such as DayCounter, calendars, constants, conventions, schedules, etc.
trading	Currently only a basic limit order book (LOB). Hopefully adding additional trading tools in the future.

Examples

See /examples for various uses of RustQuant. You can run them with:

cargo run --example <example>

Note

Disclaimer: This is currently a free-time project and not a professional financial software library. Nothing in this library should be taken as financial advice, and I do not recommend you to use it for trading or making financial decisions.

rustquant's Issues

Implement Vasicek zero-coupon bond duration and convexity.

Documentation: improve docs.

Just generally improve the documentation, especially when it comes to explaining mathematical aspects of the library such that it is as user-friendly as possible.

Lookback (floating strike) options Monte Carlo pricer test failing.

---- options::lookback::tests::test_lookback_floating stdout ----
thread 'options::lookback::tests::test_lookback_floating' panicked at '
Left: 18.11050747911399,
Right: 25.35335527250393,
Delta: 0.5
', src/options/lookback.rs:273:9
note: run with RUST_BACKTRACE=1 environment variable to display a backtrace

Panic in `plotters` crate. Waiting on new version.

See here: plotters-rs/plotters#453

Implement Yahoo! Finance data download: latest quotes.

Implement CDS using CIR, Vasicek, etc.

`statistics`: finish `Distribution` trait impls.

Need to write doc-tests for the remaining distributions:

• Bernoulli
• Binomial
• Chi-Squared
• Exponential <-- In progress.
• Gamma
• Gaussian
• Poisson
• Uniform

Implement proper error handling.

I am writing my master thesis currently so I have been lazy and not made use of Rust's Result and Option enums like I should have.

Implement ability to read in data from .csv/JSON.

`RustQuant::data`: Create a PostgreSQL interface.

I would like a way for users to be able to store and retrieve data from performing various actions in RustQuant, like pricing etc.

Remove some camel case.

Binomial option pricer has it. Possibly elsewhere ?

Remove unnecessary f64 type annotations.

Compute returns from Yahoo! Finance data reader.

Write `/Examples/numerical_integration.rs`

Implement `std::fmt` for `autodiff` module objects.

Add tests for stochastic processes to test the terminal distributions.

Improve accuracy of tanh-sinh quadrature integrator.

Implement copulas module.

See here: https://en.wikipedia.org/wiki/Copula_(probability_theory)

Change stringly typed variables to enums, and replace if/else statements with match.

Such as:

if CallPutFlag == "c" {
    z = 1;
} else if CallPutFlag == "p" {
    z = -1;
} else {
    panic!("Check call/put flag. Should be either 'c' or 'p'.");
}

Enum is more ergonomic; the error will be spotted at compile time, and not cause a panic at run time when an incorrect &str is passed as an argument.

Find workaround for using `#[pyclass]` on a struct with lifetimes.

In autodiff::Variable, creating Python bindings is currently not possible due to #[pyclass] not being compatible on structs that have lifetime annotations, since Rust can no longer keep track of the references.

What I have:

/// Struct to contain the initial variables.
#[derive(Clone, Copy, Debug)]
pub struct Variable<'v> {
    /// Pointer to the tape.
    pub tape: &'v Tape,
    /// Index to the node.
    pub index: usize,
    /// Value associated to the node.
    pub value: f64,
}

What I wanted:

use pyo3::prelude::*;

/// Struct to contain the initial variables.
#[derive(Clone, Copy, Debug)]
#[pyclass]                           // <- This
pub struct Variable<'v> {
    /// Pointer to the tape.
    pub tape: &'v Tape,
    /// Index to the node.
    pub index: usize,
    /// Value associated to the node.
    pub value: f64,
}

I possibly need to change the Variable implementation such that it no longer uses explicit lifetime annotations. Open to suggestions.

Implement date/time functionality.

[Enhancement] signatures of `.drift()` and `.diffusion()`

At present, the implementations of StochasticProcess::drift() and StochasticProcess::diffusion() do not allow for implementation of models such as Ho-Lee and Hull-White which have time-varying parameters. I propose changing their signatures to accept another parameter t: f64 for the point in time to compute the drift/diffusion.

Additionally this would mean changing the implementation of the euler_murayama() function slightly. I can PR all of these changes and change the existing stochastics implementations if approved.

`autodiff::graphviz`: make `bgcolor="transparent";` for graphs.

Create `Python` bindings using `pyo3` and `maturin`.

Create portfolio interface that pulls from the Yahoo! Finance data reader for the stocks.

Write `/Examples/stochastic_processes.rs`

Implement `Math_Newton_Raphson.rs`

`ml::regression::logistic` not working.

The diagonal matrix W becomes singular (non-invertible) since the entries converge to zero.

Write `/Examples/option_pricing.rs`.

[Enhancement] Bond pricing ergonomics

With the current implementation of bonds, the user is required to initialize the struct with predefined maturity and price-at-time t.
From the little research I've done it seems that closed-form zero coupon bond pricing formulae allow for computation at arbitrary maturation T and times t (so long as T >= t).

So the current trait ZeroCouponBond is a little inflexible. How about computing the price via ZeroCouponBond::price(&self, t: f64, T: f64), where t is the time the user wants to compute the price at and T is the maturation?

Pricers: Asian options.

Migrate another library

Hi @avhz

i have started to develop a stochastic library in rust too. If you approve I can migrate my code and processes into your library, because I dont want to make a totally different like this. It would be great if the community has one strong and featuredull quant and stochastic analysis library in rust.

https://github.com/dancixx/stochastic-rs

Implement interpolation modules.

Interpolators to-do list:

• Linear
• Exponential
• B-Splines
• Polynomial

Pricers: American options.

Problem testing 'stochastics' functions. Can't plot.

Example error:

---- stochastics::cox_ingersoll_ross::tests::test_cox_ingersoll_ross stdout ----
thread 'stochastics::cox_ingersoll_ross::tests::test_cox_ingersoll_ross' panicked at 'misaligned pointer dereference: address must be a multiple of 0x8 but is 0x7f9c19cec269'

Implement calibration module using `argmin` crate.

All pricing models should be able to be calibrated to market prices.

A nice Crate called argmin available here looks like it can achieve this, using Brent method or something similar.

Can also perform calibration using RustQuant::autodiff possibly ?

This requires the ability to read in price data from .csv or .json, for example. See related issue #23

Tests: Increase coverage to 90% +.

Remove unnecessary #![deny(missing_docs)] since lint defined for whole library.

Lint defined in lib.rs applies to whole library.
So any additional #![deny(missing_docs)] are superfluous.

Need suggestions on how to structure the Python bindings.

It seems like a tedious task to maintain two separate libraries, one for "base" RustQuant and a separate one for the Python bindings.

Is there a better way?
I don't want to litter the base library with things like #[pyclass], #[new] and #[pymethods, but keeping two separate copies seems unnecessary.

Add CONTRIBUTING file.

Implement Yahoo! Finance data download: price history.

Want to be able to download:

• Price history.
• Option chains.
• Latest quotes.

Store as a Polars DataFrame.

Decrease compile time.

Compile time increased quite substantially after adding Polars as a dependency.
Should look into reducing the compile time a bit if possible.

Pricers: caps and floors.

Caps/floors are a series of caplets/floorlets (basically call/put options) on something like an interest rate or inflation rate.

Pricing is discussed in detail in Interest Rate Models by Brigo and Mercurio.

Implement Yahoo! Finance data download: option chains.

Reserve 'RustQuant' on crates.io

Write tests for `Greeks: Lambda, Theta, Phi/Epsilon, Zeta`

Include LICENCE header at start of each file.

Write `/Examples/automatic_differentiation.rs`.

`RustQuant::math`: Implement Fast Fourier Transform.

Add more tests for `BlackScholes` pricer.