Uitgever: Apress. As an important part of the financial industry, options and derivatives trading has become increasingly sophisticated. Advanced trading techniques using financial derivatives have been used at banks, hedge funds, and pension funds. Readers will enjoy the how-to examples covering all the major tools and concepts used to build working solutions for quantitative finance.
The topics covered in the book are introduced in a logical and structured way and even novice programmers will be able to absorb the most important topics and competencies. This book is written with the goal of reaching readers who need a concise, algorithms-based book, providing basic information through well-targeted examples and ready to use solutions.
Readers will be able to directly apply the concepts and sample code to some of the most common problems faced in the analysis of options and derivative contracts. Toon meer Toon minder. Verschijningsdatum september Afmetingen 25,6 x 18,2 x 2 cm Aantal pagina's pagina's Illustraties Nee. An example of a selector method would be a getter, which is a method used to return a value of some member data. Another example would be a price calculation method that has no need to modify the data, only the need to read it and calculate with it. They can accomplish everything a selector can do, with additional privileges.
An example of a selector mehtod is a setter, which is a method used to set directly a value of some member data.
We need to be careful to distinguish between methods that cannot modify their parameters and methods that cannot modify anything at all. This is where the const keyword comes in. This is a very good habit to form as it sets expectations between other clients of our code. In our VanillaOption class, we will implement these values as private member data. This is because once they have been set, via construction of the class, we do not wish to modify them further. Later on we will consider class interfaces where we may wish to modify this data at code run-time. We can implement these as selector methods of our VanillaOption class, since calculating a price does not need to modify any underlying member data.
The preprocessor step is carried out prior to code compilation. It is a legacy feature from the days of C programming. This is a mechanism that stops us importing the same code twice for the compiler, which we obviously do not wish to do! The next section of the code declares the VanillaOption class.
It is customary to capitalise class names and to avoid the use of an underscore separator, which are used instead for functions and methods. This helps programmers rapidly distinguish them as classes as opposed to functions, methods or variables. These are helper methods. Helper methods are not called directly by the client, but are used by constructors and assignment operators to assign member data upon class initialisation and copying.
This is known as a pass-by-reference-to- const. The destructor is prepended via the virtual keyword. We will go into a substantial amount of depth about virtual methods and virtual destructors in particular later on in the book. For now you should note that a virtual destructor is necessary for correct memory deallocation to occur when we use the process of class inheritance. This is because the copy constructor and assignment operator do not need to modify the object they are copying from, nor do they wish to directly copy it before using it in the method, as copying can be an expensive operation in terms of processor usage and memory allocation.
Although this is not strictly necessary you can return void , by returning a reference to a VanillaOption, it allows what is known as chained assignment. The next set of methods in the public section are selectors getters used to access the private member data. The public block also contains two calculation selector methods for the call and put prices, respectively. All of these selector methods return a non-void value in fact they return a double precision value. All of the selector methods are post-marked with const. This means that these methods are unable to modify member data or anything else!
Note that the const keyword appears at the end of the method prototype. One could argue that because of these semantic issues it would be easier not to use it anywhere in the code. We have also imported the cmath library containing the mathematical functions we need such as sqrt square root , exp exponential function and log natural logarithm.
Notice that vanillaoption. The quotes tell the compiler to look in the current directory for vanillaoption. Initialisation of data does not need to return any value. The init method signature is prepended with VanillaOption The initialisation of the member data is separated this way, as init is used by other methods to initialise member data and hence it stops repeated code.
The copy method is another helper method used by the copy constructor and assignment operator. It is once again designed to stop repeated code, via the DRY pattern. In our code there are two constructors: Default and parameter-based. Notice the underscores prepended to the parameters. This is to avoid having to have alternative names for the option parameters, but still keeping them unique from the member data.
The parameters are once again passed-by-ref-to-const. This is not strictly necessary here as they are simple types. Copying them would not generate unnecessary overhead.
Financial Computing with C++ Part I (2016-2017)
Once again, as the copy constructor IS a constructor it does not possess a return type. All it does it call the copy helper method. In fact both methods make use of the copy method, ensuring DRY. We have described copy above. The mechanism through which this occurs is via a pointer known as this. If you are somewhat unsure of pointers and references the following article at QuantStart.
Practical C++ Financial Programming by Carlos Oliveira
It contains no implementation! This does NOT mean that the compiled program ends up with no implementation, however. Instead the compiler is smart enough to provide one for us. The VanillaOption class only contains private member data based on simple types double precision values. Notice also that the destructor has no return type not even void , as with constructors. This is not the case with constructors, where adding const, for instance, actually implements a new constructor, from one that does not possess the const keyword.
Join Kobo & start eReading today
There is no means of modifying the member I will only display one method here in this instance the retrieval of the strike price, K as the rest are extremely similar. They are both public and const. This forces them to be selector methods. This is what we want because a calculation should not modify the underlying member data of the class instance. This is the cumulative distribution function of the normal distribution.
Why would I want to learn C or C++?
They can be obtained from any introductory quantitative analysis textbook. I would hope that you recognise them! If you are unfamiliar with these functions, then I suggest taking a look at Joshi, Wilmott or Hull to brush up on your derivatives pricing theory.
The main issue for us is to study the implementation. These concepts refer to how a parameter is passed to a function or method. When passing by value, the type or object being passed is copied. If the type has a small memory footprint, such as an int or double this copying process is rapid. If the object being passed by value is a large matrix containing double values, for instance, it can be extremely expensive to copy as all values within the matrix need to be duplicated and stored. We usually want to avoid situations like this. Following is an example of a function prototype passing a double precision type by value: double my function double s t r i k e p r i c e ; The following is an example of an object in this case a Matrix being passed by reference into a matrix norm method.
We need to be careful that this is the intended behaviour, otherwise we can end up modifying an object in place. The compiler would not stop us from doing so, even if we intended not to. This can lead to bugs! What if we want to restrict copying for performance reasons and hence pass by reference , but do not want the function to ever modify the passed object data? We use the const keyword and pass-by-reference-to-const. The compiler will catch any attempts to modify our Matrix, mat, within the function. This stops the function modifying any data whatsoever. In this case, it might be data which resides in a larger scope It allows us to model a type of relationship between objects known as is-a.
Hence an American Call Option should inherit all properties that a Call Option possesses, such as a strike price and an underlying asset price.
At the moment we only have analytical prices for calls and puts, but we would like to allow for additional option types such as digital options, double digital options or power options. For instance, a double digital option requires two barrier values, while a power option requires the value of the power as well as spot. Is there a better way? This is the essence of object-oriented inheritance.
An abstract base class is a class that has at least one pure virtual method.
Related Practical C++ Financial Programming
Copyright 2019 - All Right Reserved