import random
import numpy as np
import pandas as pd
import scipy as sp
from scipy.stats import norm
import matplotlib.pyplot as plt
import datetime as dt
from pandas_datareader import data as pdr
import yfinance as yf
from yahoo_fin import options as op
import seaborn as sns
sns.set()
from IPython.core.display import HTML
HTML("""
<style>
ul.no-bullets {
  list-style-type: none;
  margin: 0;
  padding: 0;
}
table.GeneratedTable {
  width: 100%;
  background-color: #ffffff;
  border-collapse: collapse;
  border-width: 2px;
  border-color: #000000;
  border-style: solid;
  color: #000000;
}

table.GeneratedTable td, table.GeneratedTable th {
  border-width: 2px;
  border-color: #000000;
  border-style: solid;
  padding: 3px;
}

table.GeneratedTable thead {
  background-color: #3198ff;
}
</style>
""")

endDate=dt.datetime.now();
startDate=endDate-dt.timedelta(days=381);
stockData=pdr.get_data_yahoo(['MSFT'],startDate,endDate)
stockData

[*********************100%***********************]  1 of 1 completed

stockDataModified=stockData;
stockDataModified.reset_index(inplace=True);
stockDataModified

plt.rc('figure',figsize=(15,13));

font={'family' : 'Times New Roman',
      'weight' : 'bold',
      'size'   : 22};
plt.rc('font',**font);

fig,axes=plt.subplots(2,1,gridspec_kw={'height_ratios':[3, 1.5]});
fig.tight_layout(pad=3);

date=stockData['Date']; close=stockData['Close'];
volume=stockData['Volume'];

plt.subplot(211);
plt.plot(date,close,color='red',linewidth=2,label='Price');
plt.xlabel('Date: Year-Month');
plt.ylabel('Stock Price');
plt.title('Microsoft Stock Analysis: April 26, 2022 to May 12, 2023');

plt.subplot(212);
plt.bar(date,volume,width=2,color='darkgrey');
plt.xlabel('Date: Year-Month');
plt.ylabel('Trading Volume');
plt.show();

PercentChange=stockData['Close'].pct_change().dropna(); # percentage change in price; e.g. returns
RollingMean=PercentChange.rolling(3).mean().dropna(); # daily moving average
RollingSTD=PercentChange.rolling(3).std().dropna();   # daily standard deviation
AnnualVolatility=np.std(PercentChange)*np.sqrt(252);  # annualized volatility by simple returns

a=stockData['Close'];
r=[np.log(a[i+1]/a[i]) for i in range(len(a)-1)];
r=pd.Series(np.array(r));                             # Log-Returns
RollingMean2=r.rolling(3).mean().dropna();
RollingSTD2=r.rolling(3).std().dropna();
AnnualVolatility2=np.std(r)*np.sqrt(252);

print("Expected Average Return: " + str(np.mean(PercentChange)))
print("Standard deviation of Returns: " + str(np.std(PercentChange)))
print(" ")
print("STD of simple returns: " + " "*35 + "STD of Log Return:")
print("Annual Volatility: " + str(AnnualVolatility) + " "*22 + "Annual Volatility: " + str(AnnualVolatility2));
print("Monthly Volatility: " + str(AnnualVolatility/np.sqrt(12)) + " "*19 + "Monthly Volatility: " 
      + str(AnnualVolatility2/np.sqrt(12)));
print("Weekly Volatility: " + str(AnnualVolatility/np.sqrt(52)) + " "*20 + "Weekly Volatility: " 
      + str(AnnualVolatility2/np.sqrt(52)));
print("Daily Volatility: " + str(np.std(PercentChange)) + " "*21 + "Daily Volatility: " + str(np.std(r)) );


plt.rc('figure',figsize=(15,13));

font={'family' : 'Times New Roman',
      'weight' : 'bold',
      'size'   : 22};
plt.rc('font',**font);

fig,axes=plt.subplots(2,1,gridspec_kw={'height_ratios':[2, 2]});
fig.tight_layout(pad=3);

plt.subplot(211);
plt.bar(date[3:len(a)],RollingMean,width=1.5,color='darkgrey')
plt.xlabel('Date: Year-Month');
plt.ylabel('Daily Moving Average');
plt.title('Microsoft Stock Analysis: April 26, 2022 to May 12, 2023');

plt.subplot(212);
plt.bar(date[3:len(a)],RollingSTD,width=1.5,color='darkgrey')
plt.xlabel('Date: Year-Month');
plt.ylabel('Daily Moving Standard Deviation');
plt.show();

Expected Average Return: 0.0005614932289200549
Standard deviation of Returns: 0.02144256450318899
 
STD of simple returns:                                    STD of Log Return:
Annual Volatility: 0.34039015888139595                      Annual Volatility: 0.33975104162617137
Monthly Volatility: 0.09826217492983673                   Monthly Volatility: 0.0980776776701629
Weekly Volatility: 0.04720362198116181                    Weekly Volatility: 0.04711499236444081
Daily Volatility: 0.02144256450318899                     Daily Volatility: 0.021402303900428646

plt.rc('figure',figsize=(15,13));

font={'family' : 'Times New Roman',
      'weight' : 'bold',
      'size'   : 22};
plt.rc('font',**font);

fig,axes=plt.subplots(2,1,gridspec_kw={'height_ratios':[2, 2]});
fig.tight_layout(pad=3);

plt.subplot(211);
plt.plot(date,close,color='red',linewidth=2,label='Price');
plt.xlabel('Date: Year-Month');
plt.ylabel('Stock Price');
plt.title('Microsoft Stock Analysis: April 26, 2022 to May 12, 2023');

plt.subplot(212);
vol=RollingSTD/np.sqrt(52);
vol2=RollingSTD2/np.sqrt(52);
plt.plot(date[3:len(date)],vol,color='red',linewidth=1.5,label='Simple Returns');
plt.plot(date[3:len(date)],vol2,color='blue',linewidth=1.5,label='Logged-Returns');
plt.xlabel('Date: Year-Month');
plt.ylabel("Daily Volatility")
plt.title('Microsoft Stock Analysis: April 26, 2022 to May 12, 2023');
plt.legend();
plt.show()

# Calculate the price changes over the time span
price=stockDataModified['Close'];
price_diff=[price[i+1]-price[i] for i in range(len(price)-1)];

# Tests the normality of the price changes with Jarque-Bera test
print("To test the normality of the rate-of-return distribution of Microsoft stock:");
print(" ");
print("Jarque-Bera goodness of fit test: " + str(sp.stats.jarque_bera(stockDataModified['Close'])));
print(" ");
print("Shapiro-Wilk Test: " + str(sp.stats.shapiro(stockDataModified['Close'])));
print(" ");
print("Mean: " + str(np.mean(price_diff)) + " "*10 + "Standard deviation: " + str(np.std(price_diff)));

x_axis=np.linspace(min(price_diff),max(price_diff),len(price_diff));
mean=np.mean(price_diff); std=np.std(price_diff);

plt.rc('figure',figsize=(8,6));

fig,ax = plt.subplots();
temp = ax.hist(price_diff,100,density=True);
plt.plot(x_axis,norm.pdf(x_axis,mean,std));
plt.xlabel("Price change");
plt.ylabel("Probability");
plt.title("Distribution of Price Change - Microsoft Stock: April 26, 2022 to May 12, 2023");
plt.show();

To test the normality of the rate-of-return distribution of Microsoft stock:
 
Jarque-Bera goodness of fit test: SignificanceResult(statistic=9.41195194561631, pvalue=0.009041086056433497)
 
Shapiro-Wilk Test: ShapiroResult(statistic=0.9769615530967712, pvalue=0.0002916510566137731)
 
Mean: 0.0982824427480916          Standard deviation: 5.473574931430873

PercentP=stockDataModified['Close'].pct_change().dropna(); # percentage change of the stock price 

print("To test the normality of the percentage rate-of-return distribution of Microsoft stock:");
print(" ");
print(sp.stats.jarque_bera(PercentP));
print(" ");
print("Shapiro-Wilk Test: " + str(sp.stats.shapiro(PercentP)));
print(" ");
print("Mean: " + str(np.mean(PercentP)) + " "*10 + "Standard deviation: " + str(np.std(PercentP)));


x_axis=np.linspace(min(PercentP),max(PercentP),len(PercentP));
mean=np.mean(PercentP); std=np.std(PercentP);

plt.rc('figure',figsize=(8,6));

fig,ax = plt.subplots();
temp = ax.hist(PercentP,50,density=True);
plt.plot(x_axis,norm.pdf(x_axis,mean,std));
plt.xlabel("Rate-of-returns");
plt.ylabel("Frequency");
plt.title("Distribution of % Price Change - Microsoft Stock: April 26, 2022 to May 12, 2023");
plt.show();

To test the normality of the percentage rate-of-return distribution of Microsoft stock:
 
SignificanceResult(statistic=23.24002860265311, pvalue=8.984458547888842e-06)
 
Shapiro-Wilk Test: ShapiroResult(statistic=0.9830119013786316, pvalue=0.0032606280874460936)
 
Mean: 0.0005614932289200549          Standard deviation: 0.02144256450318899

def polar_method(n):
    i=0;
    output=np.zeros(n);
    while i < n:
        U1=np.random.uniform(0,1,1); U2=np.random.uniform(0,1,1);
        W1=2*U1-1; W2=2*U2-1;
        if (W1**2+W2**2) < 1:
            output[i]=W1*np.sqrt(-2*np.log(W1**2+W2**2)/(W1**2+W2**2));
            i=i+1;
    return output;

def cholesky_decomposition(M):
    A=np.copy(M); m,n=A.shape;
    R=np.zeros((m,n));

    for k in range(n):
        R[k,k]=np.sqrt(A[k,k]);
        R[k,k+1:]=A[k,k+1:]/R[k,k];
        for j in range(k+1,n):
            A[j,j:]=A[j,j:]-R[k,j]*R[k,j:];
    return R.T;

def get_data(stocks,start,end):
    stockData=pdr.get_data_yahoo(stocks,start,end);
    stockData=stockData['Close']
    returns=stockData.pct_change().dropna();
    meanReturnsVector=returns.mean();
    covMatrix=returns.cov();
    return returns,meanReturnsVector, covMatrix;

stockList=['MSFT','AAPL'];
endDate=dt.datetime.now(); startDate=endDate-dt.timedelta(days=1825);
Returns,meanReturnsVector,covMatrix=get_data(stockList,startDate,endDate);
weights=np.random.random(len(meanReturnsVector));
weights/=np.sum(weights);
print("Mean  Returns Vector: \n" + str(meanReturnsVector));
print(" ");
print("Covariance matrix: \n" + str(covMatrix));
print(" ");
print("Determinant: Det(covMatrix) =" + str(np.linalg.det(covMatrix)));
print(" ");
print("Portfolio Asset distribution: " + str(weights));

[*********************100%***********************]  2 of 2 completed
Mean  Returns Vector: 
AAPL    0.001254
MSFT    0.001105
dtype: float64
 
Covariance matrix: 
          AAPL      MSFT
AAPL  0.000440  0.000315
MSFT  0.000315  0.000383
 
Determinant: Det(covMatrix) =6.977306935631813e-08
 
Portfolio Asset distribution: [0.81337678 0.18662322]

iteration=100; # number of iterations
T=100; # number of time intervals

meanM=np.full(shape=(T,len(weights)),fill_value=meanReturnsVector);
meanM=meanM.T;

simulated_portfolios=np.zeros((T,iteration)); # zeros array of dim: T by iteration

initialDeposit=15000; # Initial investment
initial=np.array([15000 for _ in range(T)]).T;
time=np.arange(0,T);

for m in range(iteration):
    X=np.array([polar_method(T) for _ in range(len(weights))]).T;
    L=cholesky_decomposition(covMatrix);
    dailyReturns=meanM+np.inner(L,X);
    simulated_portfolios[:,m]=np.cumprod(np.inner(weights,dailyReturns.T)+1)*initialDeposit;
    
averaged_portfolio=[np.mean(i) for i in simulated_portfolios]; # the averaged portfolio 

sim_list=np.arange(0,simulated_portfolios.shape[1]);
sim_choice=random.choices(sim_list,k=10);

plt.plot(simulated_portfolios[:,sim_choice]);
plt.plot(time,initial,label='initial investment: zero returns');
plt.plot(time,averaged_portfolio,'--',linewidth=2,color='black',label='averaged portfolio');
plt.ylabel('Portfolio Value ($)');
plt.xlabel('Days');
plt.title('MC simulation of a stock portfolio');
plt.legend();
plt.show();

print("Initial investment: " + str(15000) + " USD");
print(" ");
print("Mimimum: " + str(round(np.min(averaged_portfolio),2)) + " USD");
print("Maximum: " + str(round(np.max(averaged_portfolio),2)) + " USD");
print(" ");
print("Expected value at Day 100: " + str(round(averaged_portfolio[99],2)));
print("Expected percentage gained at Day 100: " + 
      str(round((averaged_portfolio[99]-initialDeposit)/averaged_portfolio[99]*100,2)) + "%");
print(" ");
print("Standard Deviation: ")

Initial investment: 15000 USD
 
Mimimum: 15077.02 USD
Maximum: 17104.91 USD
 
Expected value at Day 100: 17019.86
Expected percentage gained at Day 100: 11.87%
 
Standard Deviation:

Returns['portfolio']=Returns.dot(weights);
Returns

def portfolioPerformance(weights,meanReturns,covMatrix,Time):
    returns=np.sum(meanReturns*weights)*Time;
    std=np.sqrt(np.dot(weights.T,np.dot(covMatrix,weights)))*np.sqrt(Time);
    return returns,std;

def historicalVaR(returns,alpha=5):
    """
    Input: Reads in pandas series/dataframe of returns
    Output: the VaR (Value at Risk)
    """
    if isinstance(returns,pd.Series):
        return np.percentile(returns,alpha);
    elif isinstance(returns,pd.DataFrame):
        return returns.aggregate(historicalVaR,alpha=alpha);
    else:
        raise TypeError("returns needs to be a dataframe or series");
    pass;

def historicalCVaR(returns,alpha=5):
    """
    Input: Reads in pandas series/dataframe of returns
    Output: the CVaR (Conditional Value at Risk)
    """
    if isinstance(returns,pd.Series):
        belowVaR = returns <= historicalVaR(returns,alpha=alpha);
        return returns[belowVaR].mean();
    elif isinstance(returns,pd.DataFrame):
        return returns.aggregate(historicalCVaR, alpha=alpha);
    else:
        raise TypeError("returns needs to be a dataframe or series");
    pass;

# Time span: 100 days
Time=100;

hVaR=-historicalVaR(Returns['portfolio'],alpha=5)*np.sqrt(Time);
hCVaR=-historicalCVaR(Returns['portfolio'],alpha=5)*np.sqrt(Time);
pRet,pStd=portfolioPerformance(weights,meanReturnsVector,covMatrix,Time);

print("Initial Deposit: " + str(initialDeposit));
print(" ")
print("Expected Portfolio Return:  +/-" + str(round(initialDeposit*pRet,2)) + " USD");
print("Value at Risk 95th CI    : +/-" + str(round(initialDeposit*hVaR,2)) + " USD");
print("Conditional VaR 95th CI  : +/-" + str(round(initialDeposit*hCVaR,2)) + " USD");

Initial Deposit: 15000
 
Expected Portfolio Return:  +/-1839.07 USD
Value at Risk 95th CI    : +/-4592.07 USD
Conditional VaR 95th CI  : +/-6844.94 USD

def mcVaR(returns, alpha=5):
    """
    Input: Reads in pandas series of returns
    Output: percentile on return distribution to a given confidence level alpha=5 (e.g. \alpha=0.05)
    """
    if isinstance(returns,pd.Series):
        return np.percentile(returns,alpha);
    else:
        raise TypeError("returns must be a pandas data series.");
    pass;
def mcCVaR(returns, alpha=5):
    """ Input: pandas series of returns
        Output: CVaR or Expected Shortfall to a given confidence level alpha=5 (e.g. \alpha=0.05)
    """
    if isinstance(returns,pd.Series):
        belowVaR = returns <= mcVaR(returns,alpha=alpha);
        return returns[belowVaR].mean();
    else:
        raise TypeError("returns must be a pandas data series.");
    pass;

portfolio_Results=pd.Series(simulated_portfolios[-1,:]);

VaR=initialDeposit-mcVaR(portfolio_Results,alpha=5);
CVaR=initialDeposit-mcCVaR(portfolio_Results,alpha=5);

print("VaR: +/-" + str(round(VaR,2)) + " USD");
print("CVaR: +/-" + str(round(CVaR,2)) + " USD");

VaR: +/-1790.73 USD
CVaR: +/-2580.95 USD

ticker='MSFT';
expirationDates=op.get_expiration_dates(ticker);
expirationDates

['May 19, 2023',
 'May 26, 2023',
 'June 2, 2023',
 'June 9, 2023',
 'June 16, 2023',
 'June 23, 2023',
 'July 21, 2023',
 'August 18, 2023',
 'September 15, 2023',
 'October 20, 2023',
 'November 17, 2023',
 'January 19, 2024',
 'March 15, 2024',
 'June 21, 2024',
 'December 20, 2024',
 'January 17, 2025',
 'June 20, 2025',
 'December 19, 2025']

Options=op.get_options_chain('MSFT',"5/19/2023");
Options['calls']

CallsOptions=Options['calls'];
OpData=CallsOptions.iloc[[25]];
OpData

S=np.array(close[-1:]); 
K=np.array(OpData['Strike']);
volatility=np.array(vol[-1:]);
riskless=0.0339; # 0.0339 - 10 - year U.S. Government Bond
N=100;
M=100;

market_value=np.array(OpData['Ask']);

TimeStep=((dt.date(2022,3,17)-dt.date(2022,2,17)).days+5)/365;
print("Time Step size is " + str(TimeStep));

Time Step size is 0.09041095890410959

# Constants
date=TimeStep/N;
nudt=(riskless-0.5*volatility**2)*date;
volsdt=volatility*np.sqrt(date);
lnS=np.log(S);

# Monte Carlo Method
Z=np.array([polar_method(N) for _ in range(M)]).T;
delta_lnSt=nudt+volsdt*Z; 
lnSt=lnS+np.cumsum(delta_lnSt,axis=0)
lnSt=np.concatenate((np.full(shape=(1,M),fill_value=lnS),lnSt));

# Compute Expectation and SE
ST=np.exp(lnSt);
CT=np.maximum(0,ST-K);
C0=np.exp(-riskless*TimeStep)*np.sum(CT[-1])/M;

sigma=np.sqrt(np.sum((CT[-1]-C0)**2)/(M-1));
SE=5*sigma/np.sqrt(M);

print("Call value is ${0} with SE +/- {1}".format(np.round(C0,2),np.round(SE,2)))

Call value is $57.25 with SE +/- 0.12

x1=np.linspace(C0-3*SE,C0-1*SE,100);
x2=np.linspace(C0-1*SE,C0+1*SE,100);
x3=np.linspace(C0+1*SE,C0+3*SE,100);
s1=norm.pdf(x1,C0,SE);
s2=norm.pdf(x2,C0,SE);
s3=norm.pdf(x3,C0,SE);
plt.fill_between(x1,s1,color='tab:blue',label='> StDev');
plt.fill_between(x2,s2,color='cornflowerblue',label='1 StDev');
plt.fill_between(x3,s3,color='tab:blue');
plt.plot([C0,C0],[0,max(s2)*1.1],'k',label='Theoretical Value');
plt.plot([market_value,market_value],[0, max(s2)*1.1],'r',label='Market Value');
plt.ylabel("Probability");
plt.xlabel("Option Price");
plt.legend();
plt.show();

	Open	High	Low	Close	Adj Close	Volume
Date
2022-04-27	282.100006	290.970001	279.160004	283.220001	280.468506	63477700
2022-04-28	285.190002	290.980011	281.459991	289.630005	286.816254	33646600
2022-04-29	288.609985	289.880005	276.500000	277.519989	274.823853	37073900
2022-05-02	277.709991	284.940002	276.220001	284.470001	281.706360	35151100
2022-05-03	283.959991	284.130005	280.149994	281.779999	279.042511	25978600
...	...	...	...	...	...	...
2023-05-08	310.130005	310.200012	306.089996	308.649994	308.649994	21318600
2023-05-09	308.000000	310.040009	306.309998	307.000000	307.000000	21340800
2023-05-10	308.619995	313.000000	307.670013	312.309998	312.309998	30078000
2023-05-11	310.100006	311.119995	306.260010	310.109985	310.109985	31680200
2023-05-12	310.549988	310.440002	306.600189	308.970001	308.970001	19774696

	Date	Open	High	Low	Close	Adj Close	Volume
0	2022-04-27	282.100006	290.970001	279.160004	283.220001	280.468506	63477700
1	2022-04-28	285.190002	290.980011	281.459991	289.630005	286.816254	33646600
2	2022-04-29	288.609985	289.880005	276.500000	277.519989	274.823853	37073900
3	2022-05-02	277.709991	284.940002	276.220001	284.470001	281.706360	35151100
4	2022-05-03	283.959991	284.130005	280.149994	281.779999	279.042511	25978600
...	...	...	...	...	...	...	...
258	2023-05-08	310.130005	310.200012	306.089996	308.649994	308.649994	21318600
259	2023-05-09	308.000000	310.040009	306.309998	307.000000	307.000000	21340800
260	2023-05-10	308.619995	313.000000	307.670013	312.309998	312.309998	30078000
261	2023-05-11	310.100006	311.119995	306.260010	310.109985	310.109985	31680200
262	2023-05-12	310.549988	310.440002	306.600189	308.970001	308.970001	19774696

Jarque–Bera test
Null Hypothesis ($H_{0}$):	Skewness is zero and the excess kurtosis is zero.
Alternative Hypothesis ($H_{a}$):	Skewness is greater than zero and also excess kurtosis is greater than zero.

Shapiro–Wilk test
Null Hypothesis ($H_{0}$):	Sample originate from a normally distributed population.
Alternative Hypothesis ($H_{a}$):	Sample originate from a non-gaussian distributed population.

	AAPL	MSFT	portfolio
Date
2018-05-15	-0.009088	-0.007243	-0.008744
2018-05-16	0.009333	-0.001747	0.007265
2018-05-17	-0.006324	-0.009985	-0.007007
2018-05-18	-0.003637	0.001871	-0.002609
2018-05-21	0.007085	0.012868	0.008164
...	...	...	...
2023-05-08	-0.000403	-0.006438	-0.001530
2023-05-09	-0.009971	-0.005346	-0.009108
2023-05-10	0.010421	0.017296	0.011704
2023-05-11	0.001095	-0.007044	-0.000424
2023-05-12	-0.006791	-0.003676	-0.006210

Monte Carlo Methods to Simulate Stock Portfolio

Southern Methodist University

By Barry Daemi

Updated: May 12, 2023

1. Introduction

2. Stock Data Importation and Analysis

3. Simulate a Stock Portfolio

4. Implementation of Value at Risk and Conditional Value at Risk

5. Simulate European Call Option with Black-Scholes

Citations:

	Contract Name	Last Trade Date	Strike	Last Price	Bid	Ask	Change	% Change	Volume	Open Interest	Implied Volatility
0	MSFT230519C00125000	2023-05-05 11:31AM EDT	125.0	183.20	183.00	184.85	0.0	-	1	21	335.94%
1	MSFT230519C00130000	2023-04-27 3:39PM EDT	130.0	175.21	178.20	179.95	0.0	-	1	1	242.58%
2	MSFT230519C00140000	2023-05-01 10:29AM EDT	140.0	166.54	168.10	169.80	0.0	-	2	1	294.53%
3	MSFT230519C00145000	2023-05-01 10:29AM EDT	145.0	161.57	162.75	164.90	0.0	-	2	0	288.18%
4	MSFT230519C00150000	2023-03-14 3:57PM EDT	150.0	112.00	139.10	141.75	0.0	-	4	25	0.00%
...	...	...	...	...	...	...	...	...	...	...	...
63	MSFT230519C00385000	2023-05-05 9:34AM EDT	385.0	0.01	0.00	0.01	0.0	-	2	99	50.00%
64	MSFT230519C00390000	2023-04-27 2:21PM EDT	390.0	0.01	0.00	0.01	0.0	-	4	1093	53.13%
65	MSFT230519C00395000	2023-04-27 3:28PM EDT	395.0	0.01	0.00	0.01	0.0	-	2	46	56.25%
66	MSFT230519C00400000	2023-05-04 1:17PM EDT	400.0	0.02	0.00	0.01	0.0	-	16	1516	57.81%
67	MSFT230519C00410000	2023-05-12 9:30AM EDT	410.0	0.01	0.00	0.01	0.0	-	1	54	62.50%

Monte Carlo Methods to Simulate Stock PortfolioSouthern Methodist UniversityBy Barry DaemiUpdated: May 12, 2023

1. Introduction

2. Stock Data Importation and Analysis

3. Simulate a Stock Portfolio

4. Implementation of Value at Risk and Conditional Value at Risk

5. Simulate European Call Option with Black-Scholes

Citations:

Monte Carlo Methods to Simulate Stock Portfolio

Southern Methodist University

By Barry Daemi

Updated: May 12, 2023