Antoine Savine - Modern Computational Finance

The purpose of this publication is to provide a complete reference for the implementation of scripting and its application in derivatives systems to its full potential. The defining foundations of a well‐designed scripting library are described and illustrated with C++ code, available online on:

https://github.com/asavine/Scripting/tree/Book-V1

Readers will find significant differences between the repository code and the code printed in the book. The repository has been undergoing substantial modernization and performance improvements not covered in this edition of the text. Make sure you connect to the branch Book‐V1, not the master . Besides, the code base evolves throughout the book and the online repository contains the final version. It is advisable to type by hand the code printed in the text rather than rely on the online repository while reading the book.

This code constitutes a self‐contained, professional implementation of scripting in C++. It is written in standard, modern C++ without any external dependency. It was tested to compile on Visual Studio 2017. The library is fully portable across financial libraries and platforms and includes an API, described in section 3.7, to communicate with any model.

The code as it stands can deal with a model of any complexity as long as it is a single underlying model. It works with the Black and Scholes model of [5] and all kind of extensions, including with local and/or stochastic volatility, like Dupire's [9] and [10], or single underlying stochastic volatility models. 4 The library cannot deal with multiple underlying assets, stochastic interest rates, or advanced features such as the Longstaff‐Schwartz algorithm of [22]. It doesn't cover the management of transactions throughout their life cycle or deal with past fixings. All those features, necessary in a production environment, would distract us from correctly establishing the defining bases. These extensions are discussed in detail in parts IIand III, although not in code.

Our online repository also provides an implementation of Fuzzy Logic for automatic risk smoothing, an excel interface to the library, a tutorial for exporting C++ code to Excel, a prebuilt xll, and a demonstration spreadsheet.

The C++ implementation is discussed in part I, where we explore in detail the key concepts of expression trees and visitors. We show how they are implemented in modern C++ and define the foundations for an efficient, scalable scripting library. We also provide some (very) basic self‐contained models to test the library, although the library is model agnostic by design and meant to work with any model that implements an API that we specify. For clarity, the code and comments related to parsing (the transformation of a text script into an expression tree) are moved from the body of the text into an appendix.

We discuss in part IIthe implementation of some basic extensions, and in part IIImore advanced features like interest rates and multiple currencies and assets. We discuss the key notion of indexing simulated data. Indexing is a special flavor of pre‐processing, crucial for performance. We also discuss the support for LSM, the regression‐based algorithm designed by Carriere and Longstaff‐Schwartz in [6] and [22] to deal with early exercise in the context of Monte‐Carlo simulations, and later reused in the industry in the context of xVA and other regulatory calculations. These parts include extensive guidance for the development of the extensions, but not source code.

The rest of the publication describes some applications of scripting outside the strict domain of pricing and demonstrates that our framework, based on visitors, can resolve many other problems.

Part IVshows how our framework can accommodate a systematic smoothing of discontinuities to resolve the problem of unstable risk sensitivities for products like digitals or barriers with Monte‐Carlo simulations. Smoothing consists of the approximation of the discontinuous payoffs by close continuous ones, like the approximation of digitals by tight call spreads. Bergomi discusses and optimizes smoothing in [4]. Our purpose is different. We demonstrate that smoothing can be abstracted as a particular application of fuzzy logic . This realization leads to an algorithm to systematically smooth not only digitals and barriers but also any payoff, automatically. The practical implementation of the algorithm is facilitated by the design of our scripting library. For clarity, the source code is not provided in the body of the text, but it is provided in our online repository.

Part Vintroduces the application to xVA, which is further covered in our upcoming dedicated publication. The code for xVA calculations is not provided.

While scripted payoffs are now part of the standard toolkit for the structuring of derivatives, it does not appear to be widely used yet in the wider context of xVA, CCR, VAR, FRTB, capital charges, or other related calculations. This is an unfortunate oversight. Market risk, value adjustments, and capital calculations over large heterogeneous portfolios of transactions are best conducted when all cash‐flows from all transactions are represented in a consistent manner, which the software can understand, analyze, and otherwise manipulate. This is exactly what scripting offers, for a small performance cost if implemented correctly.

Further, a CVA (similarly to other xVAs and other regulatory calculations) is a real option that a bank gives away any time it trades with a defaultable counterparty. That option is a put on the netting set, contingent to default. It is therefore an exotic option with a complex payoff written on the sum of all the cash‐flows of all the transactions in a netting set. This is however still an option, and as such, it can be scripted like any other transaction. Scripting is ideally suited in this context, both for the representation of the cash‐flow of the underlying transactions and the description of the value adjustments themselves. We explore the details in part Vand will extend that discussion in our upcoming publication dedicated to xVA.

As exotic transactions fell out of favor in the aftermaths of the 2008 global crisis, some practitioners believe that scripting lost relevance. That could not be more wrong. From the reasons enumerated, scripting is more relevant now than ever, not only for exotics but more importantly today as the centerpiece of correctly designed systems for the calculation of risks, value adjustments, and capital charges for large heterogeneous portfolios.

We therefore believe that scripting is not limited to an external interface for users to conveniently create transactions on the fly. Scripting does offer such convenience, but its main purpose is to represent transactions internally as collections of cash‐flows consistently accessible to all components in a system. Code (actually, visitors that are part of the code) can “see” the cash‐flows and manipulate them in a number of ways. Evaluation is just one such manipulation. The design of our scripting library in part Iis driven by such considerations.

What did lose relevance is scripting for exotics only. Scripting must be rethought today, no longer as a means of valuing complex transactions but as a way to represent cash‐flows so that these cash‐flows may be visited from various components of system and analyzed and modified in various ways, including, but not limited to, valuation. For this purpose, it is essential that it is the actual cash‐flows that are scripted and not option payoffs.

For example, a receiver swaption with physical settlement would frequently be represented as a European option on the PV of the underlying swap at the exercise date. This would produce a script resembling: