## Transcribed Text

Q1: Root-finding methods
For this question, it is fine to use the code provided in class as your starting point. You will need
make changes to the functions.
For the following exercise, we are going to use the polynomial:
f(x) = (x + 1) (x - 4) (x - 10) = x3 - 13x² + 26x + 40
f'(x) = 3x² - 26x + 26
Clearly, the function has 3 roots: -1, 4 and 10. Also, for x < -1, f(x) < o and for X > 10, f(x) > o
a.
Implement a function double f (double x) that returns the polynomial value and a
function double fPrime (x) that returns the derivative of the polynomial.
b. Implement double findRootNewton (double x, int N) that implements the
Newton Raphson root finding method for starting point x and iterating N times. That is,
we're not trying to find a root to a specified precision. Rather, we want to 'loop' N
times and return the estimated root.
c. Implement double findRootsecant (double x, int N) that implements the
secant root finding method for starting point X and iterating N times. For your second
starting point, use X + 0.25.
Note: your code should check whether f(x_prev) - f(x) is essentially zero. For our
purposes, you can use the fabs() function for the difference and check whether it is less
than 1e-10. Hint: look at the lecture notes :-)
d.
Implement double findRootBisection (double x, int N) that
implements the bisection root finding method for starting point x and iterating N times.
For your second starting point, use -2 if f(x) > o and 11 if f(x) < o. Note: the bisection
function in the lecture notes uses two parameters, a & b, to define starting points. For
the homework, only one starting point is passed in as a parameter.
e. Create a program whose main() function calls each root finding function with starting
points: 1, 3.8, 20 and -40 and N=5. Print out both the estimated root, r, each function
finds and the value of f(r). Include these values in your homework text file. Hint: you
may want to create a function that takes starting point X and number of iterations N as
parameters and then calls the root-finding methods and prints out results.
f.
Repeat step e but use N = 10
Q2 : Arrays and Pointers
Start with an array of doubles:
double A[] = {5.6, 3.2, 1.0, 199, 32, 5.7, 9.9, 11.0, 999, 0.0001} ;
We want to copy the array values into a new array and then sort the values in the new array. We will
use a simple bubble sort with pseudocode below:
procedure bubbleSort ( A : list of sortable items
)
n = length (A)
repeat
swapped = false
for i = 1 to n-1 inclusive do
/ * if this pair is out of order */
if A[i-1] - > A[i] then
swap them and remember something changed */
swap ( A [i-1], A[i] )
swapped = true
end if
end for
until not swapped
end procedure
https://en.wikipedia.org/wiki/Bubble: sort#Pseudocode implementation
Note: pseudocode is not "real" code. Rather, it describes how to implement an algorithm. Notice, for
example that the pseudocode starts indexing at 1 whereas C++ arrays begin indexing at o.
What to do in main():
1. Create A as described above
2. Create an array B with 10 elements
3. Copy all the elements of A into B
4. Sort the elements of B using the bubble sort described above
5. Create a pointer C that points to B
6. Using a loop and pointer arithmetic, print out the values of B by dereferencing C. That is, don't
use B directly to print the values, use C and pointer arithmetic (either ++ or +).
Q3: Simulation - Valuing Calls and Puts
This question requires the lecture notes from Lectures 6&7.
For
this question, we are going to value at-the-money European calls and puts with one (1) year until -
expiration. Remember, a European call's value at expiration is max(o, S-K) and a European put's value at
expiration is max(o, K-S) where K = strike price and S = spot price.
Assume that at T=0, spot and strike price are $100. Further, assume that the risk-free rate (interest
rate) is 0%, that is the present value of $1 is equal to the future value of $1. Finally, assume that the
stock in question has a drift of 0% and volatility of 20% and has lognormal returns.
We simulate the stock's stochastic process as: as = udt + odZ
After solving using Ito's Lemma and with our horizon as 1 year, we generate log returns as
1
r = 1 + oZ 0.5 0.2 0.2) 0.2 Z -0.02 + Z
= - * * + * = -
where Z is a standard normal variable.
We then can estimate our stock price as S1 = Se"
We want to simulate 100,000 1-year stock returns. Refer to class notes (Lectures 6+7) for how to
generate standard normal random variables
1.
For
each
simulated
return,
calculate
the
expected
stock
price,
the
value
of
call
option
and
value
of a put option
2. Keep a running sum of each of these values so that you can calculate average (expected) values
3. Print out the average stock price, call price and put price at the following iterations: 100, 1000,
10000, 100000. That is, after 100 iterations, calculate the average stock, call and put price and
print it out. After 1000 iterations, do the same, etc.
4. Using Excel, R or some other handy tool (not C++), create a chart that shows expected call and
put values for these iterations. That is, iteration is the X-axis, value is the Y-axis. Include the
chart in your homework write-up.
Remember: we are calculating values for at-the-money calls at puts. S = 100, K = 100 and thus the value
of the call at T=1 will be max(o, S1-100) and the value of the put will be max(o, 100-S1) where S1 is the
simulated stock price after 1 year.
Lecture Notes that are related to question 3:
C++ - Lecture 6
Simulation
For our purposes, simulation refers to randomly repeating a task
multiple times and recording the results.
This is often called Monte Carlo Simulation
We will focus on generating random price paths using a lognormal
distribution
When we couple these price paths with something like asset values,
we are integrating to find an expected value (like in the homework)
A (Very) Brief Foray into Stochastic Calculus
We want to model equity returns with an expected return (drift)
and volatility o
When we say volatility, we are talking about the standard deviation of
(natural) log returns
Note: in C++, log() computes the natural log
There is a lot going on here, so we are going to stick to the parts that
get us to implementing simulation

These solutions may offer step-by-step problem-solving explanations or good writing examples that include modern styles of formatting and construction
of bibliographies out of text citations and references. Students may use these solutions for personal skill-building and practice.
Unethical use is strictly forbidden.

//

// Problem1.cpp

// HomeworkCplusplus

//

//

//

//

#include <iostream>

#include "Problem1.hpp"

#include "math.h"

double f(double x){

double y=pow(x,3)-13*pow(x,2)+26.0*x+40.0;

return y;

};

double fPrime(double x){

double y=3.0*pow(x,2)-26.0*x+26.0;

return y;

};

double findRootNewton(double x, const int N){

double xold=x;

double xnew=0.0; int i;

for (i=0; i<N; i++){

xnew=xold-f(xold)/fPrime(xold);

xold=xnew;

}

return xnew;

};

double findRootSecant(double x, const int N){

const double tolerance=1e-10;

double xnminustwo=x; double xnminusone=x+0.25; double error=1.0;

double xn=0.0; int i;

for (i=0; i<N; i++){

error = fabs(f(xnminusone)-f(xnminustwo));

if (error >=tolerance...