def uncond_max_ir(k, sig2=sig2):
# Monte Carlo scenarios for the signals
s_j = simulate_normal(np.zeros((2)), sig2[-2:, -2:], 1000).T
cond_mu_x_j = cond_exp_x(s_j[:k, :], k, sig2)
# Monte Carlo scenarios for the conditioned max info ratio
max_ir_j = cond_mu_x_j.T @ \
np.linalg.solve(cond_cov_x(k, sig2),
cond_mu_x_j)
return np.sqrt(np.trace(max_ir_j) / 1000)
labels = np.array(df_stocks.columns.codes)[0, :] # sector indices
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_shrink_corr_clusters-implementation-step01): Compute the correlation matrix from the log-returns
epsi = np.diff(np.log(df_stocks), axis=0) # log-returns
c2 = np.corrcoef(epsi.T) # historical correlation
t_, n_ = epsi.shape
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_shrink_corr_clusters-implementation-step02): Sort the correlation matrix by sectors
i_s = np.argsort(labels)
c2_sec = c2[np.ix_(i_s, i_s)] # correlation matrix sorted by sectors
# ## [Step 3](https://www.arpm.co/lab/redirect.php?permalink=s_shrink_corr_clusters-implementation-step03): Compute the initial clustering by computing the average of each sector
x = simulate_normal(np.zeros(n_), c2, 2 * n_)
k_ = sectors.shape[0] # number of sectors
c0 = np.zeros((2 * n_, k_))
for k in range(k_):
c0[:, k] = np.mean(x[:, labels == k], axis=1)
# ## [Step 4](https://www.arpm.co/lab/redirect.php?permalink=s_shrink_corr_clusters-implementation-step04): Determine clusters and sort the correlation matrix accordingly
kmeans = KMeans(n_clusters=k_, init=c0.T, n_init=1).fit(x.T) # fit
i_c = np.argsort(kmeans.labels_)
c2_clus = c2[np.ix_(i_c, i_c)]
# ## [Step 5](https://www.arpm.co/lab/redirect.php?permalink=s_shrink_corr_clusters-implementation-step05): Compute the minimum spanning tree
d = np.sqrt(2 * (1 - c2)) # distance matrix
gr = nx.from_numpy_matrix(d)
p = 0.6 # unconditional probability of the true dist
q = 0.5 # unconditional probability of the model
mu_x_0 = 3.5 # conditional expectation of the true distribution
mu_x_1 = 6 # conditional expectation of the true distribution
m_0 = 3 # conditional expectation of the model
m_1 = 5.5 # conditional expectation of the model
sig2_x_0 = 1.21 # conditional variance
sig2_x_1 = 0.64 # conditional variance
j_ = 10**5 # number of simulations
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_continuum_discrete_generative_pred-implementation-step01): Generate samples
# +
z = np.random.binomial(1, p, 100)
x = (1-z)*simulate_normal(mu_x_0, sig2_x_0, 100) +\
z*simulate_normal(mu_x_1, sig2_x_1, 100)
z_q = np.random.binomial(1, q, j_)
x_q = (1 - z_q) * simulate_normal(m_0, 1, j_) + z_q * simulate_normal(
m_1, 1, j_)
no_points_grid = 500
x_grid = np.linspace(min(np.percentile(x, 1), np.percentile(x_q, 1)),
max(np.percentile(x, 99), np.percentile(x_q, 99)),
no_points_grid)
# -
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_continuum_discrete_generative_pred-implementation-step02): Compute expected score of the model
# +
j_ = 10**5 # number of scenarios
v_tnow = np.array([1, 1]) # current values
mu = np.array([0, 0]) # instruments P&L's expectations
h = np.array([45, 55]) # portfolio holdings
lambda_ = np.array([1 / 150, 1 / 200, 1 / 300]) # risk aversion parameters
rho = -0.5 # correlation parameter
# standard deviations appearing in the P&L's distributions
sig_11, sig_22 = 0.1, 0.3
sig2 = np.array([[(sig_11)**2, rho * sig_11 * sig_22],
[rho * sig_11 * sig_22, (sig_22)**2]])
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_evaluation_certainty_equiv-implementation-step01): Simulate j_ scenarios for the instruments P&L's
n_ = len(h) # number of the instruments
# scenarios for the standard normal random variable Z
z = simulate_normal(np.zeros(n_), np.eye(n_), j_, 'PCA')
sigma_riccati = solve_riccati(sig2, np.eye(n_)) # Riccati root of sigma2
mu = np.array([mu] * j_) # duplicate expectation for j_ scenarios
v_tnow = np.array([v_tnow] * j_) # duplicate initial values for j_scenarios
pi = np.exp(mu + z @ sigma_riccati) - v_tnow # P&L's scenarios
p = np.ones(j_) / j_ # flat scenario-probabilities
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_evaluation_certainty_equiv-implementation-step02): Compute the ex-ante performance scenarios
y_h = h @ pi.T # ex-ante performance scenarios
# number of bins for the ex-ante performance histogram
bins = np.round(150 * np.log(j_))
# centers and heights of the bins
heights, centers = histogram_sp(y_h, p=p, k_=bins)
# ## [Step 3](https://www.arpm.co/lab/redirect.php?permalink=s_evaluation_certainty_equiv-implementation-step03): Compute the certainty-equivalent
import matplotlib.pyplot as plt from arpym.tools import plot_ellipse, mahalanobis_dist, add_logo from arpym.statistics import simulate_normal # - # ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_min_vol_ellips-parameters) j_ = 5000 mu = np.array([0, 0]) # expectation rho = .6 # correlation sigma2 = np.array([[1, rho], [rho, 1]]) # covariance # ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_min_vol_ellips-implementation-step01): Generate j_normal scenarios x = simulate_normal(mu, sigma2, j_) # ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_min_vol_ellips-implementation-step02): Rescale the covariance matrix n_ = sigma2.shape[0] sigma2_rescaled = n_ * sigma2 # ## [Step 3](https://www.arpm.co/lab/redirect.php?permalink=s_min_vol_ellips-implementation-step03): Generate location and dispersion to satisfy Mah distance constraint # + m = mu + np.random.rand(2) a = np.random.rand(2, 2) s2 = a @ a.T # generate symmetric covariance matrix mah_dist2 = np.zeros(j_) for j in range(j_):
mu_x_0 = -1 # conditional expectation mu_x_1 = 1.5 # conditional expectation sigma2_x_0 = 0.36 # conditional variance sigma2_x_1 = 0.49 # conditional variance x_c = 1.5 # generic boundary point x0 = -0.73 # generic decoder at 0 x1 = 1.92 # generic decoder at 1 # - # ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_autoencoders_kmeans-implementation-step01): Generate simulations of target variable # + # simulations of hidden variable h = np.random.binomial(1, p_h, j_).reshape(-1) # simulations of conditional target variable x_h0 = simulate_normal(mu_x_0, sigma2_x_0, j_) x_h1 = simulate_normal(mu_x_1, sigma2_x_1, j_) # simulations of target variable x = (1 - h) * x_h0 + h * x_h1 # mean and variance of target variable e_x, cv_x = meancov_sp(x) # - # ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_autoencoders_kmeans-implementation-step02): Generic encoder, generic and best decoder, errors # + # encoding induced by generic cluster def zeta_c2(x):
j_ = 10**4 # number of simulations
def chi_arb(var):
return 1 / var
# -
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_logn_mean_regression-implementation-step01): Generate samples
# +
sig2_xz = np.array([[sig_x**2, rho_xz * sig_x * sig_z],
[rho_xz * sig_x * sig_z, sig_z**2]])
# jointly lognormal samples
x, z = np.exp(simulate_normal(mu_xz, sig2_xz, j_).T)
no_points_grid = 500
x_grid = np.linspace(10**-6,
2 * max(np.percentile(x, 95), np.percentile(z, 95)),
no_points_grid)
# -
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_logn_mean_regression-implementation-step02): Compute prediction, residuals and E{X|z}
# +
def chi(var):
return np.exp(mu_xz[0] + rho_xz * sig_x / sig_z *
(np.log(var) - mu_xz[1]) + 0.5 * (1 - rho_xz**2) * sig_x)
r2 = np.trace(
sigma_xz @ np.linalg.inv(sigma2_z) @ sigma_xz.T) / np.trace(sigma2_x)
# -
# ## [Step 4](https://www.arpm.co/lab/redirect.php?permalink=s_regression_lfm-implementation-step04): Compute joint distribution of residulas and factors
a = np.zeros(n_ + k_)
a[:n_] = -alpha
b = np.eye(n_ + k_)
b[:n_, n_:] = -beta
mu_uz = a + b @ mu_xz
sigma2_uz = b @ sigma2_xz @ b.T
# ## [Step 5](https://www.arpm.co/lab/redirect.php?permalink=s_regression_lfm-implementation-step05): Compute simulations of target variable and factors
xz = simulate_normal(mu_xz, sigma2_xz, j_)
x_reg = alpha + beta @ xz[:, n_:].T
# ## Plots
# +
# number of simulations to plot
d = 200
z_1_low = np.percentile(xz[:, n_], 1)
z_1_upp = np.percentile(xz[:, n_], 99)
z_1 = np.arange(z_1_low, z_1_upp, 0.5)
z_2_low = np.percentile(xz[:, n_ + 1], 1)
z_2_upp = np.percentile(xz[:, n_ + 1], 99)
z_2 = np.arange(z_2_low, z_2_upp, 0.5)
# - # ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_simulate_payoff-parameters) n_ = 50 # number of instruments j_ = 50 # number of scenarios rf = 0.05 # risk-free rate a_p, b_p = 0.7, 1 # window for non-normalized probabilities of the scenarios a_mu, b_mu = -0.3, 0.7 # window for random shifts of the payoffs a_sd, b_sd = 0.8, 1 # window for random rescales of the payoffs rho = 0.7 # correlation between initial normal variables that are used to generate the payoffs # ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_simulate_payoff-implementation-step01): Generate the normal vector c2 = (1 - rho) * np.eye(n_) + rho * np.ones((n_, n_)) # correlation matrix x = simulate_normal(np.zeros(n_), c2, j_**2) # ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_simulate_payoff-implementation-step02): Generate the payoff matrix at time u = t + 2 # + mu = np.exp(0.5) # expectation of std lognormal distribution sd = mu * np.sqrt(np.exp(1) - 1) # stdev of std lognormal distribution v_t2 = np.ones((j_**2, n_)) v_t2[:, 1] = np.exp(x[:, 1]) / sd v_t2[:, 2::2] = (np.exp(x[:, 2::2]) - mu) / sd v_t2[:, 3::2] = (-np.exp(-x[:, 3::2]) + mu) / sd v_t2[:, 2:] = v_t2[:, 2:] * np.random.uniform(a_sd, b_sd, n_ - 2) # scale v_t2[:, 2:] = v_t2[:, 2:] + np.random.uniform(a_mu, b_mu, n_ - 2) # shift # -
# -
# ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_factor_replication_logn-parameters)
n_max = 500 # max target dimension
n_step = np.arange(25, n_max + 25, 25) # target dimension grid
j_ = 10000 # number of scenarios
mu = np.append(1, np.zeros(n_max))
delta = np.random.rand(n_max)
sigma2 = np.diag(np.append(1, delta**2))
c = np.exp(mu + np.diag(sigma2) / 2)
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_factor_replication_logn-implementation-step01): Choose arbitrary parameters
alpha = np.zeros(n_max)
beta = simulate_normal(np.zeros(1), np.eye(1),
n_max).reshape(-1, 1) # generate normal scenarios
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_factor_replication_logn-implementation-step02): Compute scenarios of the factor, residuals and target variables
h = np.random.lognormal(mu[0], sigma2[0, 0], size=(j_, 1)) - c[0]
l = simulate_normal(np.zeros(n_max), np.eye(n_max), j_).reshape(-1, n_max)
u = np.exp(l * delta) - np.exp(delta**2 / 2.)
x = alpha + h @ beta.T + u
# ## [Step 3](https://www.arpm.co/lab/redirect.php?permalink=s_factor_replication_logn-implementation-step03): Compute expectation and covariance of the target variables
mu_x = alpha
sigma2_x = beta @ beta.T + np.diag(delta**2)
# ## [Step 4](https://www.arpm.co/lab/redirect.php?permalink=s_factor_replication_logn-implementation-step04): Compute extraction matrix and r-squared
invariance_test_ellipsoid, \
simulate_normal
from arpym.tools import add_logo
# -
# ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_elltest_normal-parameters)
t_ = 1000 # time series length
mu = 0 # expectation
sigma2 = 0.0625 # variance
l_ = 10 # lag for the ellipsoid test
conf_lev = 0.95 # confidence level
# ## [Step 0](https://www.arpm.co/lab/redirect.php?permalink=s_elltest_normal-implementation-step00): Generate normal simulations
epsi = simulate_normal(mu, sigma2, t_)
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_elltest_normal-implementation-step01): Compute absolute values of normal simulations
epsi_abs = abs(epsi)
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_elltest_normal-implementation-step02): Compute normalized absolute values
# grades of absolute values
epsi_abs_grade, *_ = cop_marg_sep(epsi_abs)
# normalized absolute values
epsiabs_tilde = st.norm.ppf(epsi_abs_grade).squeeze()
# ## [Step 3](https://www.arpm.co/lab/redirect.php?permalink=s_elltest_normal-implementation-step03): Ellipsoid test on normal simulations
plt.style.use('arpm')
from arpym.statistics import meancov_sp, simulate_normal from arpym.tools import add_logo, pca_cov, plot_ellipse # - # ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_uncorr_no_indep-parameters) # + j_ = 5*10**4 # number of simulations # - # ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_uncorr_no_indep-implementation-step01): Generate simulations # + # simulations of X x = simulate_normal(0, 1, j_) # simulations of Y y = x ** 2 # - # ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_uncorr_no_indep-implementation-step02): Compute sample mean and covariance # + # sample expecation and covariance e_xy, cv_xy = meancov_sp(np.c_[x, y]) cv_x_y = meancov_sp(np.c_[x, y]) # - # ## [Step 3](https://www.arpm.co/lab/redirect.php?permalink=s_uncorr_no_indep-implementation-step03): Generate mean/covariance ellipse
import matplotlib.pyplot as plt
from arpym.estimation import effective_num_scenarios
from arpym.statistics import simulate_normal
from arpym.tools import add_logo
# -
# ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_generalized_expon_entropy-parameters)
t_ = 10000 # number of scenarios for flexible probabilities
k_ = 100 # number of values of gamma
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_generalized_expon_entropy-implementation-step01): Generate a random vector of flexible probabilities
# generate a vector of positive values
p = np.abs(simulate_normal(0, 1, t_))
p = p / np.sum(p) # rescale so the probabilities add to one
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_generalized_expon_entropy-implementation-step02): Create a grid of gamma values
gamma_grid = np.linspace(0, 1 - 1.0e-7, num=k_)
# ## [Step 3](https://www.arpm.co/lab/redirect.php?permalink=s_generalized_expon_entropy-implementation-step03): Calculate the effective number of scenarios
ens = effective_num_scenarios(p)
# ## [Step 4](https://www.arpm.co/lab/redirect.php?permalink=s_generalized_expon_entropy-implementation-step04): Calculate the generalized effective number of scenarios for various values of gamma
ens_gamma = np.zeros(k_)
for k in range(k_):
ens_gamma[k] = effective_num_scenarios(p,
]])
mu_epsi = np.zeros(n_)
s_1 = np.cos(theta[0])
s_2 = np.cos(theta[3])
rho = np.sin(theta[1])
sigma2_epsi = np.array([[s_1**2, rho * s_1 * s_2], [rho * s_1 * s_2, s_2**2]])
# -
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_dyn_principal_component_var-implementation-step01): Simulate VAR(1) process
# +
mu_inf = np.linalg.solve(np.eye(n_) - b, mu_epsi)
sigma2_inf = np.linalg.solve(
np.eye(n_**2) - np.kron(b, b), sigma2.reshape(n_**2, 1)).reshape(n_, n_)
x_tnow = simulate_normal(mu_inf, sigma2_inf, 1).reshape(n_)
x = simulate_var1(x_tnow, b, mu_epsi, sigma2_epsi, t_, j_=1).squeeze()
mu_x = np.linalg.solve((np.eye(n_) - b), mu_epsi)
sigma2_x = np.linalg.solve(
np.eye(n_**2) - np.kron(b, b), sigma2_epsi.reshape(n_**2,
1)).reshape(n_, n_)
# -
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_dyn_principal_component_var-implementation-step02): Compute spectral density
# +
ktilde_x = np.zeros((m_, n_, n_), dtype=complex)
sigma_epsi = transpose_square_root(sigma2_epsi)
for m in range(m_):
# -
# ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_gaussian_mixture-parameters)
p = 0.6 # unconditional probability
mu_x_0 = 3.5 # conditional expectation
mu_x_1 = 6 # conditional expectation
sig2_x_0 = 1.21 # conditional variance
sig2_x_1 = 0.64 # conditional variance
x_cond = 5.5 # realization of X
j_ = 10**5 # number of simulations
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_gaussian_mixture-implementation-step01): Generate samples
z = np.random.binomial(1, p, j_)
x = (1-z)*simulate_normal(mu_x_0, sig2_x_0, j_) +\
z*simulate_normal(mu_x_1, sig2_x_1, j_)
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_gaussian_mixture-implementation-step02): Compute Z|x
# +
alpha = logit(p) - 0.5 * (np.log(sig2_x_1) - np.log(sig2_x_0) + mu_x_1 /
sig2_x_1 * mu_x_1 - mu_x_0 / sig2_x_0 * mu_x_0)
beta = mu_x_1 / sig2_x_1 - mu_x_0 / sig2_x_0
gamma = -0.5 * (1 / sig2_x_1 - 1 / sig2_x_0)
def logit_px(x):
return alpha + beta * x + gamma * x**2
from arpym.tools import add_logo # - # ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_display_norm_copula-parameters) j_ = 5000 # number of simulations mu = np.array([0, 0]) # expectations rho = -0.5 # correlation svec = np.array([1, 1]) # standard deviations # ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_display_norm_copula-implementation-step01): Generate normal scenarios and scenarios for the grades # + sigma2 = np.diag(svec) @ np.array([[1, rho], [rho, 1]]) @ np.diag(svec) x = simulate_normal(mu, sigma2, j_) # normal scenarios u1 = stats.norm.cdf(x[:, 0], mu[0], svec[0]) u2 = stats.norm.cdf(x[:, 1], mu[1], svec[1]) u_x = np.array([u1, u2]).T # grade scenarios # - # ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_display_norm_copula-implementation-step02): Compute pdf and cdf surfaces # + # grid in the unit square grid = np.arange(0.01, 1, 0.01) n_grid = len(grid) pdf_u = np.zeros((n_grid, n_grid))
mu = [1, 3] # location parameter
# dispersion parameters
rho_12 = -0.2
sig_1 = 0.5
sig_2 = 0.3
j_ = 10**2 # number of simulations
k_strk = 2.71 # strike
h = 0.5 # aproximation level
# # Step 1: Generate log-normal samples
sig2 = np.array([[sig_1**2, rho_12*sig_1*sig_2],
[rho_12*sig_1*sig_2, sig_2**2]])
# jointly lognormal samples
x = np.exp(simulate_normal(mu, sig2, j_))
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_dependence_structure_call_put-implementation-step01): Compute call and put payoffs
v_put = np.maximum(k_strk - x[:, 0], 0)
v_call = np.maximum(x[:, 0] - k_strk, 0)
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_dependence_structure_call_put-implementation-step02): Compute regularized call and put payoffs
v_put_h = regularized_payoff(x[:, 0], k_strk, h, method='put') # regularized payoff of put option
v_call_h = regularized_payoff(x[:, 0], k_strk, h, method='call') # regularized payoff of call option
# ## [Step 3](https://www.arpm.co/lab/redirect.php?permalink=s_dependence_structure_call_put-implementation-step03): Compute Schweizer and Wolff
sw_x = schweizer_wolff(x)
sw_x1v_put_h = 1
import scipy as sp
import matplotlib.pyplot as plt
from arpym.statistics import simulate_normal
from arpym.tools import add_logo
# -
# ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_strong_dominance-parameters)
mu_ = np.array([1, 0]) # mean vector of jointly normal variables
sigma2_ = np.array([[1, 0], [0, 1]]) # covariance matrix
j_ = 1000 # number of simulations
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_strong_dominance-implementation-step01): Simulate jointly normal random variables X_1 and X_2
x = simulate_normal(mu_, sigma2_, j_)
x_1, x_2 = x[:, 0], x[:, 1]
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_strong_dominance-implementation-step02): Simulate X_3 = X_2 + Y, Y chi-squared with 1 degree of freedom
x_3 = x_2 + sp.stats.chi2.rvs(1, size=(1, j_))
# ## Plots
# +
# set figure specifications
plt.style.use('arpm')
f, ax = plt.subplots(1,
2,
figsize=(1280.0 / 72.0, 720.0 / 72.0),
dpi=72.0,
b = 0.7 # autoregression parameter
mu_eps = 0 # location of the shocks
sigma2_eps = 1 - b**2 # dispersion of the shocks
t_ = 350 # lags
t_vec = np.arange(2 * t_ + 1)
tau = 100 # truncation
tau_vec = np.arange(-tau, tau + 1)
omega0 = 1 / 4 * np.pi
omega1 = 1 / 2 * np.pi
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_bandpass_filter_ar1-implementation-step01): Simulate stationary AR(1) process
mu_x = mu_eps / (1 - b) # expectation of (stationary) AR(1)
sigma2_x = sigma2_eps / (1 - b**2) # variance of (stationary) AR(1)
x0 = simulate_normal(mu_x, sigma2_x, 1)
x = simulate_var1(x0,
np.atleast_2d(b),
np.atleast_2d(mu_eps),
np.atleast_2d(sigma2_eps),
2 * t_,
j_=1).squeeze()
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_bandpass_filter_ar1-implementation-step02): Compute spectral density and bandpass filter
# +
omega_vec = np.zeros((2 * t_ + 1, 1))
for j in range(1, 2 * t_ + 2):
omega_vec[j - 1] = ((-1)**(j - 1)) * j * np.pi / (2 * t_ + 1)
omega_vec = np.sort(omega_vec, axis=None)
ktilde_x = sigma2_eps / (1 - 2 * b * np.cos(omega_vec) + b**2)
# ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_display_corr_norm_ellips-parameters)
mu_x = np.array([0, 0]) # expectation
rho = 0.75 # correlation
sigma2_x = np.array([[1, rho], [rho, 1]]) # covariance
r = 2 # radius
j_ = 10000 # number of scenarios
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_display_corr_norm_ellips-implementation-step01): Compute eigenvalue and eigenvectors
e, lambda2 = pca_cov(sigma2_x)
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_display_corr_norm_ellips-implementation-step02): Compute simulations of the target and factors
x = simulate_normal(mu_x, sigma2_x, j_)
z = (x - mu_x) @ e
# ## [Step 3](https://www.arpm.co/lab/redirect.php?permalink=s_display_corr_norm_ellips-implementation-step03): Perform computations for plots
x_bar = plot_ellipse(mu_x,
sigma2_x,
r=r,
display_ellipse=False,
plot_axes=True,
plot_tang_box=True,
color='k')
[f_z1, xi_z1] = histogram_sp(z[:, 0], k_=300)
[f_z2, xi_z2] = histogram_sp(z[:, 1], k_=300)
# ## Plots
# ## [Input parameters](https://www.arpm.co/lab/redirect.php?permalink=s_capm_like_identity-parameters)
# +
n_ = 100 # number of financial instruments
j_ = 10000 # number of simulations
v_budget = 5 # current budget
r_tnow_thor = 0.02 # risk-free interest rate
v_tnow = np.ones(n_) # current values
sigma_mu = 1 / 30 # scale of compounded returns' expectation
sigma_bar = 1 / 40 # scale of compounded returns' covariance
# -
# ## [Step 1](https://www.arpm.co/lab/redirect.php?permalink=s_capm_like_identity-implementation-step01): Generate the parameters of the compounded returns distribution
# +
mu = simulate_normal(np.zeros(n_), sigma_mu**2 * np.eye(n_),
1) # expectation of compunded returns
a = np.zeros((n_, n_))
for n in range(n_):
a[n, :] = simulate_normal(np.zeros(n_), sigma_bar**2 * np.eye(n_), 1)
sigma2 = (a @ a.T) # covariance of compounded returns
# -
# ## [Step 2](https://www.arpm.co/lab/redirect.php?permalink=s_capm_like_identity-implementation-step02): Generate the MC scenarios of the compounded returns
# +
c_tnow_thor = simulate_normal(mu, sigma2, j_) # compounded returns scenarios
# -
# ## [Step 3](https://www.arpm.co/lab/redirect.php?permalink=s_capm_like_identity-implementation-step03): Compute the scenarios of the linear returns
# +
