C++程序代做、代写c++程序、代写program编程语言

日期：2021-05-08 10:13

Project 2 (50% of the final mark)

Path dependent options pricing

using object-oriented programming

C++ Programming with Applications to Finance Spring 2021

The aim of this project is to create a program in C++ that can be used to study the prices of Path

Dependent on an underlying asset driven by a binomial model in discrete time. Your program

should be accompanied by end-user and developer documentation. The project is aimed at testing

your knowledge from the Term 2 of the course and must be implemented in the object-oriented

programming paradigm. You must use object-oriented approach when creating this project.

A path dependent option is an exotic option that's value depends not only on the price of the

underlying asset but the path that asset took during all or part of the life of the option.

(source: Investopedia)

We assume that the price of the underlying is strictly positive at moment 0 (S0 = S(0) > 0) and at

each moment t in can either move up (1+u) times or down (1+d) times. As always in the binomial

model there is a risk-free security growing by a factor (1+r) during each time step. For more

details on binomial model please see Capinski & Zastawniak (2012) pp. 1-2.

Further we use S(t) for the price of the underlying asset at moment t, K for the strike, T for

maturity and A(0,T) for the average price for the period [0, T].

You should create a project that includes pricing of four types of path dependent options: a

lookback option, a fixed strike Asian call option (with arithmetic average), a Parisian option and

the one that we will refer to as Consecutive Growth option.

A lookback option is a path dependent option where the option owner has the right to buy the

underlying instrument at its lowest price over some preceding period:

( ( ) ( ))

0

min lookback t T

C S T S t

? ?

= ?

. Pleases notice that the minimum is taken over all

t T ??0, ?.

Fixed strike Asian call payoff is given by

C A T K Asian Call = ? max 0, , 0 ( ( ) ) , where A(0,T) stands

for arithmetic mean

( ) ( )

1

1

0,

T

t

A T S t

T =

= ? .

The payoff of a standard Parisian option is dependent on the maximum amount of time the

underlying asset value has spent consecutively above or below a strike price

( ) ( ) ( )

( ) ? ? ( )

, 1 ,...,

max 1 , 0,

0,

S s K S s K S t K

Parisian

t s if t T such that S t K

C

otherwise

? + ? ?

? ? + ? ? ? ?

= ?

??

. Notice that we

consider the maximal number of consecutive moments (not the periods between the moments)

when the price S(t) of the underlying is at or above some strike value K, and the payoff equals the

number of the moments in such streak. If at all moments from 0 to T the price S(t) is below K (i.e.,

S(t)<K) then the payoff is zero.

The payoff of the Consecutive Growth option is also defined in terms of the number of days:

( ) ( ) ( )

( ) ? ? ( ) ( )

1

max , 0, 1 1

0,

S s S s S t

Consecutive Growth

t s if t T such that S t S t

C

otherwise

? + ?

? ? ? ? ? ? + ?

= ?

??

. Notice that

we consider the maximal number of consecutive periods (not the moments, but the periods

between them) of growth when the price S(t) of the underlying is non-decreasing. If the price S(t)

always decreases, then the payoff is zero.

General hints and tips

? Read the submission instructions at the end of this document before starting work on the

project.

? Read through all the tasks before starting work on the project. Tasks do not have to be

completed in the order that they are listed here.

? You are free to recycle any code produced by yourself during the module. You are also free

to use any code provided in Moodle during the module, provided that such code is

acknowledged.

This project contributes 50% to the mark for this module. The deadline for submission is

23:59pm on Monday 17 May 2021 (Week 5 Summer Term). The marks for each of the tasks

below will be split into 60% for coding style, clarity, accuracy, and efficiency of computation, and

40% for documentation (including comments within the code) and ease of use.

Task.

You will do this project in the object-oriented paradigm. There are 10 header files and 2 cpp files

attached to the task. You project must include the following classes:

1) BinModel (h file and cpp files are attached to the task)

2) Pathinfo (h file is attached to the task)

3) AllPaths (h file is attached to the task)

4) PricePathGenerator (h file is attached to the task)

5) Option (h file is attached to the task)

6) EurOption (h file is attached, the class is intentionally left empty as it is not a matter of

interest in this project and you do NOT need to write any implementation in this class)

7) AmOption (h file is attached, the class is intentionally left empty as it is not a matter of

interest in this project, and you do NOT need to write any implementation in this class)

8) PathDependentOption (h file is attached to the task)

9) AsianCallOption

10) ParOption (h file is attached to the task)

11) LookbackOption

12) GrowOption (h file is attached to the task)

Two classes that do not have h files are AsianCallOption and LookbackOption. It means that they

must be created from scratch. If you want you can create additional classes or members in the

existing classes, but you must justify and describe them in the comments and in the

documentation.

BinModel.h and BinModel.cpp form the class for binomial model (they repeat BinModel02.h and

BinModel02.cpp from the project for the book Capinski & Zastawniak (2012)). This class is

already implemented.

Class Pathinfo contains information about a single path: its number, the path itself represented

as a vector of length N of numbers from {0,1} set (according to the bijection explained below, you

need to create and implement this bijection), the vector of prices along this path and the riskneutral

probability of this path. Please notice that the main goal this class to store the information

about the path and provide an access to this information via getters. Generation of the path (as a

vector of numbers from {0,1}), the prices along the path and the probability of the path are left in

a separate class PricePathGenerator. Finally, class AllPaths contains the vector of objects of

PathInfo and a method GetPathsNumber that returns the number of paths in the vector. Such

design provides greater flexibility as, for example, one may prefer to read the paths, from the file

instead of generating them in the program. Notice that three classes mentioned in this paragraph

are related to the price paths of the underlying assets only and do not require a presence of any

options. If the paths are needed for some reasons other than option pricing, then these classes

can be used there as well. You need to write implementation of all necessary functions in this

classes. You are allowed to add members to these classes, but you must justify and describe them

all in the comments and in the documentation.

There are several classes related to the options. First, there is a general class Option, that has

three children: class EurOption of European options, class AmOption of American options and

class PathDependentOption of path dependent options. Classes EurOption and AmOption are

intentionally left totally empty as they are not a matter of interest in this project, and you do NOT

need to write any implementation in these two classes. Class Option contains the information

about the binary model Model associated with this option and the number of steps to expiry N, it

also has a virtual function GetPrice that will be redefine in the subclasses and will return the price

of the option.

Class PathDependentOption is inherited from Option and should contain information about all

paths, a virtual function GetPayoffByPathInfo that will be redefined in the subclasses and return

a payoff on each path. It also has a sketch of a GetPrice function that prices a path dependent

option (the implementation of this function must be moved to a corresponding cpp file, you may

also want to modify it).

All four path dependent options that you need to price in this project: Lookback, Asian call,

Parisian, and Consecutive Growth options are particular cases of path dependent options. Their

classes then must be inherited from PathDependentOption. Class ParOption stands for Parisian

option, class GrowOption stands Consecutive Growth option. Notice that there is a considerable

difference between these two options as Parisian option has an extra parameter Strike price. You

need to create a class AsianCallOption for Asian call option and a class LookbackOption for

Lookback option from scratch. Perhaps, you will want to create some intermediary classes such

as AsianOption for Asian options. If you decide to create such class, then you must justify and

document it properly. When working on the project, please keep in mind the idea of the

reusability of your code and its possible extensions. These aspects must necessarily be

addressed in the documentation.

Your program should ask the user to enter the value of the parameters S0, U, D, R, Ka (a strike

price for the Asian Call option), Kp (a strike price for the Parisian option) and N (the number of

steps to expiry – the same as T in the description of the model).

Clearly, for the N-period model there are 2N different paths, and one can easily construct a

bijection between these paths and the set of arrays of length N consisting of zeros and ones. For

example, if N = 3 then then an array {0,0,1} may correspond to the underlying asset growing in

the first two periods and then falling in the period 3, i.e. getting S1=S0(1+U), S2=S0(1+U)2 and

S3=S0(1+U)2(1+D), if one codes an upward moving of the asset with 0 and a downward moving

with 1 (or falling in the first two periods and then growing in the period 3 if one codes a

downward moving of the asset with 0 and an upward moving with 1, or perhaps, even the

elements of the array may describe the changes in the underlying asset in the opposite order with

the last elements corresponding to the moves in the first periods – you can use any approach that

suits you, but you need to describe it carefully and be consistent). For this purpose, you should

use the function GenPathByNumber.

After successfully coding the path with number x as an array of zeros and ones you can generate

a vector of prices along this path with GenPricesByPath. The probability of moving along the path

should be calculated with GenProbabilityByPath. The probability of getting a path along which the

price moves up i times and down (N-i) times equals qi(1-q)

N-i

, where q is the risk-neutral

probability

R D

q

U D

?

=

?

.

For pricing the option, one needs to find the discounted value of the average payoff. The main

difficulty you may face is that the payoff is defined by all values of the underlying asset along the

path, so the payoffs must be computed along each path separately.

Your program should then calculate the prices of Lookback, Asian call, Parisian, and Consecutive

Growth options according to the formulas listed on pages 1 and 2.

Please notice that this project tests your understanding of object-oriented programming. Before

writing a code, you need to think on the design of your project. As mentioned above, reusability

of your code and its possible extensions also affect the mark for the assignment!

Submission instructions

Submit your work by uploading it in Moodle by 23:59pm on Monday 17 May 2021 (Week 5

Summer Term).

Format

Submit the code as a single compressed .zip file, including all Code::Blocks project (.cbp) files (if

you used Code::Blocks), source code and header (.cpp and .h) files, all residing in a single parent

directory. The .zip file should preserve the subdirectory structure of the parent directory (that is,

the subdirectory structure must be automatically recreated when unzipping the file).

The code should be accompanied by detailed documentation, split into two parts:

1. Code developer documentation containing information to help understand the code.

It should contain the following:

? Description of the file structure.

? Description of the available functions.

? Instructions on how to extend the code by adding new options or derivatives.

? Test runs, including tables. Graphs are optional but encouraged.

The developer documentation should not include extensive extracts from the code (brief

snippets are perfectly fine, if typeset correctly—no screenshots!), and there is no need to

describe the mathematical methods in any detail. It is expected that the developer

documentation will be less than 10 pages in length.

2. The end user instructions should contain instructions on how to use the compiled .exe

program, how to input data and how the results are presented, and a brief description of the

methods implemented. The contents of this document should be appropriate for a reader

who is not familiar with C++. It is expected that the end user instructions will be less than 5

pages in length.

The documentation files must be submitted in .pdf format (two separate .pdf files containing

developer documentation and user instructions) and uploaded in Moodle separately from the

code .zip file.

It is advisable to allow enough time (at least one hour) to upload your files to avoid possible

congestion in Moodle before the deadline. In the unlikely event of technical problems in Moodle

please email your .zip files to sergei.belkov@york.ac.uk before the deadline.

Code usage permissions and academic integrity

You may use and adapt any code submitted by yourself as part of this module, including your own

solutions to the exercises. You may use and adapt all C++ code provided in Moodle as part of this

module, including code from Capinski & Zastawniak (2012) and the solutions to exercises. Any

code not written by yourself must be acknowledged and referenced both in your source

files and developer documentation.

This is an individual project. You may not collaborate with anybody else or use code that has

not been provided in Moodle. You may not use code written by other students. Collusion and

plagiarism detection software will be used to detect academic misconduct, and suspected offences

will be investigated.

If things go wrong

Late submissions will incur penalties according to the standard University rules for assessed

work.

It may prove impossible to examine projects that cannot be unzipped and opened due to file

corruption, or projects that cannot be compiled and run due to coding errors. In such cases a

mark of 0 will be recorded. It is therefore essential that all project files and the directory

structure are tested thoroughly on your machine before being submitted in Moodle. It is advisable

to run all such tests starting from the .zip files about to be submitted and using a different

computer to that on which the files have been created.

All files must be submitted inside the zipped project directory, and all the files in the

project directory should be connected to the project. A common error is to place some files

on a network drive rather than in the submitted directory. Please bear in mind that testing on a

lab computer may not catch this error if the machine has access to the network drive. However,

the markers would have no access to the file (since they have no access to your part of the network

drive) and would be unable to compile the project.

References

Capinski, M. J. & Zastawniak, T. (2012), Numerical Methods in Finance with C++, Mastering

Mathematical Finance, Cambridge University Press.