avhz/rustquant

Rust library for quantitative finance.

rustquant's Issues

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.

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.

Implement cap/floor pricers.

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.

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'

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

Implement `Math_Newton_Raphson.rs`

Implement interpolation modules.

Interpolators to-do list:

• Linear
• Exponential
• B-Splines
• Polynomial

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

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

Add tests for stochastic processes to test the terminal distributions.

Compute returns from Yahoo! Finance data reader.

Reserve 'RustQuant' on crates.io

Write `/Examples/option_pricing.rs`.

Implement American options pricer.

Implement Yahoo! Finance data download: option chains.

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

Implement date/time functionality.

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

Improve accuracy of tanh-sinh quadrature integrator.

Write `/Examples/automatic_differentiation.rs`.

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

Implement Asian options pricer.

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.

`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.

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

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

Write `/Examples/numerical_integration.rs`

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

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

[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.

Add/improve documentation.

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.

Include LICENCE header at start of each file.

Add CONTRIBUTING file.

Implement Vasicek zero-coupon bond duration and convexity.

[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?

`RustQuant::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 copulas module.

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

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

Increase test 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.

Implement Yahoo! Finance data download: latest quotes.

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 Yahoo! Finance data download: price history.

Want to be able to download:

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

Store as a Polars DataFrame.

Write `/Examples/stochastic_processes.rs`

Remove unnecessary f64 type annotations.

Remove some camel case.

Binomial option pricer has it. Possibly elsewhere ?

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

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

See here: plotters-rs/plotters#453

Implement CDS using CIR, Vasicek, etc.

Add more tests for `BlackScholes` pricer.

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.