Using python # Problem 2: Pricing an Option Using the Black-Scholes-Merton Model### Formula for Option Pricing:To compute the price \( C_0 \) of an option, which is a derivative of BLM stock prices with a payoff at time \( T \), denoted by \( C_T \), we use the following formula:\[ C_0 = \frac{1}{(1 + r)^T} E^* (C_T) \]where:- The asterisk (*) indicates the use of the value \( p^* \) instead of the original probability \( P \) for the up/down probability of the BLM model. The actual value of \( P \) is not needed for pricing. - For \( C_T = (S_T - K)^+ \), representing a European call option, the expected value \( E^* ((S_T - K)^+) \) can be computed using the Black-Scholes-Merton option pricing formula:\[ C_0 = \frac{1}{(1 + r)^T} \sum_{k=0}^{T} \binom{T}{k} (p^*)^k (1 - p^*)^{T-k} (u^k d^{T-k} S_0 - K)^+ \]### Instructions:- Utilize the above formula to precisely calculate the option price.- Additionally, perform a Monte Carlo simulation to verify the accuracy of your result.### Parameters:- Time, \( T = 10 \)- Interest rate, \( r = 0.05 \)- Upward movement factor, \( u = 1.15 \)- Downward movement factor, \( d = 1.01 \)- Initial stock price, \( S_0 = 50 \)- Strike price, \( K = 70 \)Recall the probability adjustment formula:\[ p^* = \frac{1 + r - d}{u - d} \]### Monte Carlo Simulation:- Conduct simulations with \( n = 100 \), \( n = 1000 \), and \( n = 10,000 \) independent and identically distributed copies of \( C_T \) for averaging, and observe the increase in accuracy as \( n \) increases.```python# Code placeholder# You can write your code here# Feel free to add more cells if needed```

pfa the attcahed code import numpy as np # Optional seed np.random.seed(12345678) # Stocastic walk # This function calculates the stochastic integral after periods # and returns the final price. def stoc_walk(p,dr,vol,periods): w = np.random.normal(0,1,size=periods) for i in range(periods): p += dr*p + w[i]*vol*p return p # Parameters s0 = 114.64 drift = 0.0016273 volatility = 0.088864 # Volatility (daily) t_ = 365 # Total periods in a year r = 0.033 # Risk free rate (yearly) days = 2 # Days until option expiration N = 100000 # Number of Monte Carlo trials zero_trials = 0 # Number of trials where the option payoff = 0 k = 100 # Strike price avg = 0 # Temporary variable to be assigned to the sum # of the simulated payoffs # Simulation loop for i in range(N): temp = stoc_walk(s0,drift,volatility,days) if temp > k: payoff = temp-k payoff = payoff*np.exp(-r/t_*days) avg += payoff else: zero_trials += 1 # Averaging the payoffs price = avg/float(N) # Priting the results print("MONTE CARLO PLAIN VANILLA CALL OPTION PRICING") print("Option price: ",price) print("Initial price: ",s0) print("Strike price: ",k) print("Daily expected drift: ",drift*100,"%") print("Daily expected volatility: ",volatility*100,"%") print("Total trials: ",N) print("Zero trials: ",zero_trials) print("Percentage of total trials: ",zero_trials/N*100,"%") K = 70 r = 0.05 sigma = 0.2 T = 10 S0 = 50 # call option d1 <- (log(S0/K) + (r + sigma^2/2) * T)/(sigma * sqrt(T)) d2 <- d1 - sigma * sqrt(T) phid1 <- pnorm(d1) call_price <- S0 * phid1 - K * exp(-r * T) * pnorm(d2) # put option d1 <- (log(S0/K) + (r + sigma^2/2) * T)/(sigma * sqrt(T)) d2 <- d1 - sigma * sqrt(T) phimd1 <- pnorm(-d1) put_price <- -S0 * phimd1 + K * exp(-r * T) * pnorm(-d2) c(call_price, put_price) call_put_mc<-function(nSim=1000000, tau, r, sigma, S0, K) { Z <- rnorm(nSim, mean=0, sd=1) WT <- sqrt(tau) * Z ST = S0*exp((r - 0.5*sigma^2)*tau + sigma*WT) # price and standard error of call option simulated_call_payoffs <- exp(-r*tau)*pmax(ST-K,0) price_call <- mean(simulated_call_payoffs) sterr_call <- sd(simulated_call_payoffs)/sqrt(nSim) # price and standard error of put option simulated_put_payoffs <- exp(-r*tau)*pmax(K-ST,0) price_put <- mean(simulated_put_payoffs) sterr_put <- sd(simulated_put_payoffs)/sqrt(nSim) output<-list(price_call=price_call, sterr_call=sterr_call, price_put=price_put, sterr_put=sterr_put) return(output) } set.seed(1) results<-call_put_mc(n=10000, tau=10, r=0.05, sigma=0.2, S0=50, K=70) # call put option monte carlo call_put_mc<-function(nSim=1000000, tau, r, sigma, S0, K) { Z <- rnorm(nSim, mean=0, sd=1) WT <- sqrt(tau) * Z ST = S0*exp((r - 0.5*sigma^2)*tau + sigma*WT) # price and standard error of call option simulated_call_payoffs <- exp(-r*tau)*pmax(ST-K,0) price_call <- mean(simulated_call_payoffs) sterr_call <- sd(simulated_call_payoffs)/sqrt(nSim) # price and standard error of put option simulated_put_payoffs <- exp(-r*tau)*pmax(K-ST,0) price_put <- mean(simulated_put_payoffs) sterr_put <- sd(simulated_put_payoffs)/sqrt(nSim) output<-list(price_call=price_call, sterr_call=sterr_call, price_put=price_put, sterr_put=sterr_put) return(output) }

Engineering

Computer Engineering

Problem 2: Recall the formula for computing the price Co of an option (derivative of the BLM stock prices) That yields a payoff at time T, denote by CT: 1 Co= E* (CT), (1+r)T where* refers to the fact that we must use the value p* instead of the original (real) P for the up/down probability of the BLM. (The real value of P is not needed for pricing.) Also recall that for Cr= (ST-K)+, the European call option, the expected value, E* (ST-K) can be computed explicitly yielding the famous Black-Scholes-Merton option pricing formula: Σ(1) Φ You are to use this formula to exactly obtain the price on the one hand, and then use Monte Carlo simulation on the other hand to compare and thus see how accurate the Monte Carlo method can be. Co= #write your code here 1 (1+r)T (p*)*(1-p*)-(ud- So - K)+. T-k Here are the parameters to use: T = 10, r = 0.05, u = 1.15, d = 1.01, So= 50, K = 70. Recall that p* = 1+r-d u-d For the Monte Carlo, use n = 100, n = 1000, n = 10, 000 iid copies of Cr (for averaging) to see how it gets more accurate as n increases.

Problem 2: Recall the formula for computing the price Co of an option (derivative of the BLM stock prices) That yields a payoff at time T, denote by CT: 1 Co= E* (CT), (1+r)T where* refers to the fact that we must use the value p* instead of the original (real) P for the up/down probability of the BLM. (The real value of P is not needed for pricing.) Also recall that for Cr= (ST-K)+, the European call option, the expected value, E* (ST-K) can be computed explicitly yielding the famous Black-Scholes-Merton option pricing formula: Σ(1) Φ You are to use this formula to exactly obtain the price on the one hand, and then use Monte Carlo simulation on the other hand to compare and thus see how accurate the Monte Carlo method can be. Co= #write your code here 1 (1+r)T (p)(1-p)-(ud- So - K)+. T-k Here are the parameters to use: T = 10, r = 0.05, u = 1.15, d = 1.01, So= 50, K = 70. Recall that p = 1+r-d u-d For the Monte Carlo, use n = 100, n = 1000, n = 10, 000 iid copies of Cr (for averaging) to see how it gets more accurate as n increases.

Computer Networking: A Top-Down Approach (7th Edition)

7th Edition

ISBN:9780133594140

Author:James Kurose, Keith Ross

Publisher:James Kurose, Keith Ross

Chapter1: Computer Networks And The Internet

Section: Chapter Questions

Problem R1RQ: What is the difference between a host and an end system? List several different types of end...

See similar textbooks

Related questions

Q: Explain how a computer's Random Access Memory works in your own words.

A: RAM (or Random Access Memory): It is a hardware device in computer where the programs and data in…

Q: Describe the concept of pipelining in computer architecture

A: Pipelining is a fundamental idea in laptop architecture that improves the performance and…

Q: The xor operation in python programming

A: The xor operator sets the bits true if one of the values of the bit is true otherwise it set the bit…

Q: Explain the meaning and application of Boolean expressions

A: The answer is given in the below step

Q: did not use raptor program

A: Program Approach: Step 1: Add an Assignment symbol after Start. Set i to 10. Step 2: Add a Loop…

Q: Develop Python code to perform numerical interpolation

A: Python code to perform numerical interpolation: # Lagrange Interpolation # Importing NumPy…

Q: using python code 1. determine y at x = 0 using (a) Neville's method Given the data points x…

A: Neville's algorithm is an higher order Lagrange interpolation method used for find approximate value…

Q: Rototyping is a valuable tool in the field of software engineering.

A: What is Software: Software refers to computer programs, data, and instructions that enable a…

Q: Python language, What is the syntax for reverting/flipping the x-axis?

A: Reverting axis It is the property to reverse axis in matplotlib of python. To revert x axis, in…

Q: Problem #1 A Y C F X В

Q: Distinguish between open-loop and closed-loop systems

A: Open Loop System Closed Loop system 1 Control action is not depend on the output. Output depends…

Q: MATLAB provide the code for the following problem: given the (x,y) coordinates of a point, compute…

A: The input() function is used to prompt the user to enter the x and y coordinates. The sqrt()…

Q: Pictured above are graphs representing algorithmic complexity of Big Oh notation functions. Assign…

A: Asymptotic notations are used to express an algorithm's efficiency so that it can be easily…

Question

Using python

# Problem 2: Pricing an Option Using the Black-Scholes-Merton Model

### Formula for Option Pricing:
To compute the price \( C_0 \) of an option, which is a derivative of BLM stock prices with a payoff at time \( T \), denoted by \( C_T \), we use the following formula:

\[ C_0 = \frac{1}{(1 + r)^T} E^* (C_T) \]

where:
- The asterisk (*) indicates the use of the value \( p^* \) instead of the original probability \( P \) for the up/down probability of the BLM model. The actual value of \( P \) is not needed for pricing.

- For \( C_T = (S_T - K)^+ \), representing a European call option, the expected value \( E^* ((S_T - K)^+) \) can be computed using the Black-Scholes-Merton option pricing formula:

\[ C_0 = \frac{1}{(1 + r)^T} \sum_{k=0}^{T} \binom{T}{k} (p^*)^k (1 - p^*)^{T-k} (u^k d^{T-k} S_0 - K)^+ \]

### Instructions:
- Utilize the above formula to precisely calculate the option price.
- Additionally, perform a Monte Carlo simulation to verify the accuracy of your result.

### Parameters:
- Time, \( T = 10 \)
- Interest rate, \( r = 0.05 \)
- Upward movement factor, \( u = 1.15 \)
- Downward movement factor, \( d = 1.01 \)
- Initial stock price, \( S_0 = 50 \)
- Strike price, \( K = 70 \)

Recall the probability adjustment formula:
\[ p^* = \frac{1 + r - d}{u - d} \]

### Monte Carlo Simulation:
- Conduct simulations with \( n = 100 \), \( n = 1000 \), and \( n = 10,000 \) independent and identically distributed copies of \( C_T \) for averaging, and observe the increase in accuracy as \( n \) increases.

```python
# Code placeholder
# You can write your code here
# Feel free to add more cells if needed
```

Expert Solution

This question has been solved!

Explore an expertly crafted, step-by-step solution for a thorough understanding of key concepts.

This is a popular solution!

SEE SOLUTION Check out a sample Q&A here

Step 1

VIEW

Step 2

VIEW

Trending now

This is a popular solution!

Step by step

Solved in 2 steps

SEE SOLUTION Check out a sample Q&A here