We will participate in the 7th Americas Structured Products & Derivatives Conference 2018.
LexiFi is delighted to be sponsoring the SRP’s 5th Asia-Pacific Wealth Management & Fintech Conference 2018. Come and meet us!
LexiFi will exhibit at the 15th Annual European Structured Products & Derivatives conference, on the 8 & 9th of February 2018 in London. Come and meet us!
LexiFi will exhibit at the 3rd Annual Nordic Structured Products & Derivatives conference, on the 27th of September 2017 in Stockholm. Come and meet us!
Financial modeling with jump processes is a fully explored domain. We present in this post some of the theoretical aspects of Lévy processes. We also expose a subset of jump diffusion models available into LexiFi Apropos. Underlying dynamics, European call pricing and calibration procedures are developed for the Merton and Bates models. For the sake of clarity, some theoretical aspects and figures are hidden, don't hesitate to expand them for having more information.
This post describes how unboxing for float values works in OCaml, focusing on recent evolutions. Most of the content here applies to boxed integer types as well (int32, int64 and nativeint).
Building the (zero-coupon) yield curve is the first step in most of the financial modeling problems. We will present in this post how the yield curve is computed into LexiFi Apropos, and how we make our algorithm generic so that it can easily be used to compute different kinds of yield curves or solve different problems. Simple formulation of the problem We assume a simplified market where we can observe the Deposit Rates and the Swap Rates.
LexiFi is currently experimenting with the js_of_ocaml compiler in order to create some browser-side applications in OCaml.
This post is about the special representation that OCaml uses for arrays of floating point values. My claim is that this special representation is useful, but also harmful in some contexts. There are better alternatives that achieve the same benefits without the drawbacks.
The release of OCaml 4.02 is approaching and amongst many other new stuff, it will include the work on -ppx and extension points, supporting light-weight syntactic tools (without Camlp4).
I’d like to introduce a new language feature, inlined record arguments on constructors, which I propose for inclusion in OCaml. In a nutshell, it allows you to define a record directly within a sum type constructor:
Classical equity models don't handle very well dividends, in particular constant ones. We present in this post an approach to model equities with (deterministic) dividends. In a first time, we will show the necessary form of an equity in order there is no arbitrage with its forward. Then, we will use this form to extend the classical models to handle constant dividends. To finish, we will see how it work on an important example: the local volatility model.
The “O” part of OCaml is not very popular amongst OCaml developpers and many of them explain (with some pride) that they avoid any contact with the OO sublanguage altogether.
Being lazy is sometimes good, especially if you don’t have to work too hard to be lazy.
In this post, I propose Static Exceptions as a new language feature allowing programmers to express interesting control flows in a compact way.
Poisson distribution is a classical distribution that often appears in mathematical finance, like in jump diffusion. In this article, I will present an efficient simulation method under the constraint to use only one random variate per simulation.
The goal is to display the following to stdout:
(0,0) (1,1) (2,2) … (1000000,1000000).
Most languages provide some way to manipulate tuples of values with a proper label for each field. They are called structures in C, records in OCaml; objects as found in most mainstream OO languages extend this same notion.
Partial Differential Equation (PDE) solving is an important part of numerical analysis in mathematical finance. The classical approach to solve PDE that appears in finance is to use finite difference method. As most of numerical analysis problems, the goal is to find a solution with an error that converges quickly. The academic way to achieve this goal is to use Crank-Nicolson to solve our PDE, which provides an "order 2"
In a previous post, I’ve described a proposal on how to get rid of Camlp4 to write simple syntax extensions. This proposal slowly becomes a reality:
As my first subject (and the first subject on LexiFi's quantitative blog), I would like to focus on something I particularly appreciate at LexiFi: our formal contract description, that allows one to treat quantitative topics in a surprisingly elegant and easily generalisable way. I will focus on a particular topic: control variates methods. In the first section, I will introduce the underlying theory. Then, I will explain its use in mathematical finance.
It is often useful to get access to types at runtime, in order to implement generic type-driven operations. A typical example is a generic value pretty-printer.
A little teaser for OCaml gurus: what does the function below do?
In OCaml, generic functions like comparison and hashing are quite useful but not very flexible. In this post, I’ll explain some tricks that might be useful when you want to tweak the behavior of these generic functions for your own data structures.
Thanks to an ongoing work by Jacques Le Normand, there is some hope to see Generalized Algebraic Datatypes (GADTs) in OCaml soon, so it’s time to get familiar with them! In this post, I’ll show how to use this new feature to represent OCaml types at runtime and define generic type-driven operations.
This is a follow-up on yesterday’s post about implicit values. With five more lines added to the branch, we know have implicit arguments as well.
In this post, I’ll not describe an existing extension to OCaml that we use at LexiFi, but rather some ideas for a future possible extension.
OCaml is a very important language at LexiFi. We use it as our primary internal development language. We also expose it to some of our power users: they can write their own applications or extend LexiFi Apropos (our flagship product) with custom addins written in OCaml.