About finmath lib

Mathematical Finance Library: Algorithms and methodologies related to mathematical finance.

The finmath lib libraries provides implementations of methodologies related to mathematical finance, but applicable to other fields. Examples are

  • General numerical algorithms like
    • Generation of random numbers
    • Optimization (a Levenberg–Marquardt algorithm is provided)
  • Valuation using Fourtier transforms / characteristic functions
    • Black-Scholes model
    • Heston model
    • Bates model
    • Two factor Bates model
  • Monte-Carlo simulation of multi-dimensional, multi-factor stochastic differential equations (SDEs)
    • LIBOR Market Model
    • Black Scholes type multi-asset model (multi-factor, multi-dimensional geometric Brownian motion)
    • Equity Hybrid LIBOR Market Model
    • Hull-White Short Rate Model (with time dependent parameters)
    • Merton Model (as Monte-Carlo Simulation)
    • Heston Model (as Monte-Carlo Simulation)
  • Estimation of conditional expectations in a Monte-Carlo framework
  • Stochastic Automatic Differentiation (AAD) (requires finmath-lib-automaticdifferentiation-extensions https://github.com/finmath/finmath-lib-automaticdifferentiation-extensions )
  • Monte-Carlo Simulation on GPGPUs (via Cuda) (requires finmath-lib-cuda-extensions https://github.com/finmath/finmath-lib-cuda-extensions )
  • Calibration of market data objects like curves (discount and forward curve) or volatility surfaces
    • Various interpolation methods (linear, cubic spline, harmonic spline, Akima).
    • Various interpolation entities (value, log-value, rate, etc.).
    • Parametric curves like Nelson-Siegel and Nelson-Siegel-Svensson.
  • Simulation of interest rate term structure models (LIBOR market model with local and stochastic volatility)
  • Calibration of the LIBOR market model
  • Valuation of complex derivatives (e.g. Bermudan/multi-callables)
  • Hedge Simulation

The libraries have a focus on Monte-Carlo methods, interest rate products and models and hybrid models.

finmath lib is now on Java 8 (since February 2nd, 2014), but a Java 6 version is provided too.

Note: for convenience the provided Eclipse project is configured for Java 6. The maven pom defaults to Java 6. To build the Java 8 version use the profile “java-8”, i.e. the maven command line option “-P java-8”


finmath lib is distributed through the central maven repository. It’s coordinates are:

For the Java 6 version:


For the Java 8 version:


You may build the Java 8 version via Maven using

mvn -P java-8

and the Java 6 version using

mvn -P java-6

Source code

The finmath lib Java library comes in two flavors which have a slightly different code base: a Java 8/9 version and a Java 6 version. We will use Java 8 and Java 9 concepts in the future and try to provide Java 6 compatibility where possible.

For that reason, the source code is duplicated: - src/main/java contains the Java 8 compatible source files - src/main/java6 contains the Java 6 compatible source files

Although the two folder share some/many identical source files, we prefer this two folder layout over one with a third folder like java-common.

  • To build finmath lib for Java 8 use src/main/java
  • To build finmath lib for java 6 use src/main/java-6

These builds may be performed via Maven the profiles “java-8” and “java-6”. The eclipse project file is pre-configured to Java 6.

The maven pom defaults to the Java 8 build. To build finmath lib for Java 6 use the maven profile “java-6”.


Source code and demos are provided via Github repository.

Although not recommended, the repository contains an Eclipse project and classpath file including all dependencies. We provide this for convenience. We provide instructions on how to checkout the code using the Eclipse IDE. Of course, you may use the IDE of your choice by simply importing the maven pom.


For documentation please check out


The code of “finmath lib” and “finmath experiments” (packages net.finmath.*) are distributed under the Apache License version 2.0, unless otherwise explicitly stated.


The finmath-lib-cuda-extensions implement the RandomVariableInterface via Cuda GPU code. This allows to perform Monte-Carlo simulations on the GPUs with a minimal change: a replacement of the random variable factory.

The finmath-lib-automaticdifferentiation-extensions implement the RandomVariableInterface via an AAD enabled version. This allows to access automatic differentiations with a minimal change: a replacement of the random variable factory.

Coding Conventions

We follow losely the Eclipse coding conventions, which are a minmal modification of the original Java coding conventions. See https://wiki.eclipse.org/Coding_Conventions

We deviate in some places:

  • We allow for long code lines. Some coding conventions limit the length of a line to something like 80 characters (like FORTRAN did in the 70’ies). Given widescreen monitors we believe that line wrapping makes code much harder to read than code with long(er) lines.

  • We usually do not make a space after statements like íf, for. We interpred íf and for as functions and for functions and methods we do not have a space between the name and the argument list either. That is, we write

    if(condition) { // code }