本文整理汇总了Python中arch.univariate.distribution.Normal类的典型用法代码示例。如果您正苦于以下问题:Python Normal类的具体用法?Python Normal怎么用?Python Normal使用的例子?那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了Normal类的13个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: test_ewma
def test_ewma(self):
ewma = EWMAVariance()
sv = ewma.starting_values(self.resids)
assert_equal(sv.shape[0], ewma.num_params)
bounds = ewma.bounds(self.resids)
assert_equal(len(bounds), 0)
var_bounds = ewma.variance_bounds(self.resids)
backcast = ewma.backcast(self.resids)
parameters = np.array([])
names = ewma.parameter_names()
names_target = []
assert_equal(names, names_target)
ewma.compute_variance(parameters, self.resids, self.sigma2,
backcast, var_bounds)
cond_var_direct = np.zeros_like(self.sigma2)
parameters = np.array([0.0, 0.06, 0.94])
rec.garch_recursion(parameters,
self.resids ** 2.0,
np.sign(self.resids),
cond_var_direct,
1, 0, 1, self.T, backcast, var_bounds)
# sigma3 = np.zeros_like(self.sigma2)
# sigma3[0] = backcast
# for t in range(1,self.T):
# sigma3[t] = 0.94 * sigma3[t-1] + 0.06 * self.resids[t-1]**2.0
assert_allclose(self.sigma2 / cond_var_direct,
np.ones_like(self.sigma2))
A, b = ewma.constraints()
A_target = np.empty((0, 0))
b_target = np.empty((0,))
assert_array_equal(A, A_target)
assert_array_equal(b, b_target)
state = np.random.get_state()
rng = Normal()
sim_data = ewma.simulate(parameters, self.T, rng.simulate([]))
np.random.set_state(state)
e = np.random.standard_normal(self.T + 500)
initial_value = 1.0
sigma2 = np.zeros(self.T + 500)
data = np.zeros(self.T + 500)
sigma2[0] = initial_value
data[0] = np.sqrt(initial_value)
for t in range(1, self.T + 500):
sigma2[t] = 0.94 * sigma2[t - 1] + 0.06 * data[t - 1] ** 2.0
data[t] = e[t] * np.sqrt(sigma2[t])
data = data[500:]
sigma2 = sigma2[500:]
assert_almost_equal(data - sim_data[0] + 1.0, np.ones_like(data))
assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
assert_equal(ewma.num_params, 0)
assert_equal(ewma.name, 'EWMA/RiskMetrics')
示例2: test_riskmetrics
def test_riskmetrics(self):
rm06 = RiskMetrics2006()
sv = rm06.starting_values(self.resids)
assert_equal(sv.shape[0], rm06.num_params)
bounds = rm06.bounds(self.resids)
assert_equal(len(bounds), 0)
var_bounds = rm06.variance_bounds(self.resids)
backcast = rm06.backcast(self.resids)
assert_equal(backcast.shape[0], 14)
parameters = np.array([])
names = rm06.parameter_names()
names_target = []
assert_equal(names, names_target)
# TODO: Test variance fit by RM06
rm06.compute_variance(parameters, self.resids, self.sigma2,
backcast, var_bounds)
A, b = rm06.constraints()
A_target = np.empty((0, 0))
b_target = np.empty((0,))
assert_array_equal(A, A_target)
assert_array_equal(b, b_target)
# TODO: Test RM06 Simulation
state = np.random.get_state()
rng = Normal()
sim_data = rm06.simulate(parameters, self.T, rng.simulate([]))
assert_equal(rm06.num_params, 0)
assert_equal(rm06.name, 'RiskMetrics2006')
示例3: test_garch_no_symmetric
def test_garch_no_symmetric(self):
garch = GARCH(p=0, o=1, q=1)
sv = garch.starting_values(self.resids)
assert_equal(sv.shape[0], garch.num_params)
bounds = garch.bounds(self.resids)
assert_equal(bounds[0], (0.0, 10.0 * np.mean(self.resids ** 2.0)))
assert_equal(bounds[1], (0.0, 2.0))
assert_equal(bounds[2], (0.0, 1.0))
var_bounds = garch.variance_bounds(self.resids)
backcast = garch.backcast(self.resids)
parameters = np.array([.1, .1, .8])
names = garch.parameter_names()
names_target = ['omega', 'gamma[1]', 'beta[1]']
assert_equal(names, names_target)
garch.compute_variance(parameters, self.resids, self.sigma2,
backcast, var_bounds)
cond_var_direct = np.zeros_like(self.sigma2)
rec.garch_recursion(parameters,
self.resids ** 2.0,
np.sign(self.resids),
cond_var_direct,
0, 1, 1, self.T, backcast, var_bounds)
assert_allclose(self.sigma2, cond_var_direct)
A, b = garch.constraints()
A_target = np.vstack((np.eye(3), np.array([[0, -0.5, -1.0]])))
b_target = np.array([0.0, 0.0, 0.0, -1.0])
assert_array_equal(A, A_target)
assert_array_equal(b, b_target)
state = np.random.get_state()
rng = Normal()
sim_data = garch.simulate(parameters, self.T, rng.simulate([]))
np.random.set_state(state)
e = np.random.standard_normal(self.T + 500)
initial_value = 1.0
sigma2 = np.zeros(self.T + 500)
data = np.zeros(self.T + 500)
for t in range(self.T + 500):
sigma2[t] = parameters[0]
shock = 0.5 * initial_value if t == 0 else \
data[t - 1] ** 2.0 * (data[t - 1] < 0)
sigma2[t] += parameters[1] * shock
lagged_value = initial_value if t == 0 else sigma2[t - 1]
sigma2[t] += parameters[2] * lagged_value
data[t] = e[t] * np.sqrt(sigma2[t])
data = data[500:]
sigma2 = sigma2[500:]
assert_almost_equal(data - sim_data[0] + 1.0, np.ones_like(data))
assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
assert_equal(garch.p, 0)
assert_equal(garch.o, 1)
assert_equal(garch.q, 1)
assert_equal(garch.num_params, 3)
assert_equal(garch.name, 'GJR-GARCH')
示例4: test_arch
def test_arch(self):
arch = ARCH()
sv = arch.starting_values(self.resids)
assert_equal(sv.shape[0], arch.num_params)
bounds = arch.bounds(self.resids)
assert_equal(bounds[0], (0.0, 10.0 * np.mean(self.resids ** 2.0)))
assert_equal(bounds[1], (0.0, 1.0))
backcast = arch.backcast(self.resids)
w = 0.94 ** np.arange(75)
assert_almost_equal(backcast,
np.sum((self.resids[:75] ** 2) * (w / w.sum())))
parameters = np.array([0.5, 0.7])
var_bounds = arch.variance_bounds(self.resids)
arch.compute_variance(parameters, self.resids, self.sigma2, backcast,
var_bounds)
cond_var_direct = np.zeros_like(self.sigma2)
rec.arch_recursion(parameters, self.resids, cond_var_direct, 1,
self.T, backcast, var_bounds)
assert_allclose(self.sigma2, cond_var_direct)
A, b = arch.constraints()
A_target = np.vstack((np.eye(2), np.array([[0, -1.0]])))
b_target = np.array([0.0, 0.0, -1.0])
assert_array_equal(A, A_target)
assert_array_equal(b, b_target)
state = np.random.get_state()
rng = Normal()
sim_data = arch.simulate(parameters, self.T, rng.simulate([]))
np.random.set_state(state)
e = np.random.standard_normal(self.T + 500)
initial_value = 1.0
sigma2 = np.zeros(self.T + 500)
data = np.zeros(self.T + 500)
for t in range(self.T + 500):
sigma2[t] = parameters[0]
shock = initial_value if t == 0 else data[t - 1] ** 2.0
sigma2[t] += parameters[1] * shock
data[t] = e[t] * np.sqrt(sigma2[t])
data = data[500:]
sigma2 = sigma2[500:]
assert_almost_equal(data - sim_data[0] + 1.0, np.ones_like(data))
assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
names = arch.parameter_names()
names_target = ['omega', 'alpha[1]']
assert_equal(names, names_target)
assert_equal(arch.name, 'ARCH')
assert_equal(arch.num_params, 2)
assert_equal(arch.p, 1)
assert_true(isinstance(arch.__str__(), str))
repr = arch.__repr__()
assert_true(str(hex(id(arch))) in repr)
示例5: test_garch_power
def test_garch_power(self):
garch = GARCH(power=1.0)
assert_equal(garch.num_params, 3)
assert_equal(garch.name, 'AVGARCH')
assert_equal(garch.power, 1.0)
sv = garch.starting_values(self.resids)
assert_equal(sv.shape[0], garch.num_params)
bounds = garch.bounds(self.resids)
assert_equal(bounds[0], (0.0, 10.0 * np.mean(np.abs(self.resids))))
assert_equal(bounds[1], (0.0, 1.0))
assert_equal(bounds[2], (0.0, 1.0))
var_bounds = garch.variance_bounds(self.resids)
backcast = garch.backcast(self.resids)
w = 0.94 ** np.arange(75)
assert_almost_equal(backcast,
np.sum(np.abs(self.resids[:75]) * (w / w.sum())))
parameters = np.array([.1, .1, .8])
garch.compute_variance(parameters, self.resids, self.sigma2, backcast,
var_bounds)
cond_var_direct = np.zeros_like(self.sigma2)
rec.garch_recursion(parameters,
np.abs(self.resids),
np.sign(self.resids),
cond_var_direct,
1, 0, 1, self.T, backcast, var_bounds)
cond_var_direct **= 2.0 # Square since recursion does not apply power
assert_allclose(self.sigma2, cond_var_direct)
A, b = garch.constraints()
A_target = np.vstack((np.eye(3), np.array([[0, -1.0, -1.0]])))
b_target = np.array([0.0, 0.0, 0.0, -1.0])
assert_array_equal(A, A_target)
assert_array_equal(b, b_target)
state = np.random.get_state()
rng = Normal()
sim_data = garch.simulate(parameters, self.T, rng.simulate([]))
np.random.set_state(state)
e = np.random.standard_normal(self.T + 500)
initial_value = 1.0
sigma = np.zeros(self.T + 500)
data = np.zeros(self.T + 500)
for t in range(self.T + 500):
sigma[t] = parameters[0]
shock = initial_value if t == 0 else np.abs(data[t - 1])
sigma[t] += parameters[1] * shock
lagged_value = initial_value if t == 0 else sigma[t - 1]
sigma[t] += parameters[2] * lagged_value
data[t] = e[t] * sigma[t]
data = data[500:]
sigma2 = sigma[500:] ** 2.0
assert_almost_equal(data - sim_data[0] + 1.0, np.ones_like(data))
assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
示例6: test_arch_multiple_lags
def test_arch_multiple_lags(self):
arch = ARCH(p=5)
sv = arch.starting_values(self.resids)
assert_equal(sv.shape[0], arch.num_params)
bounds = arch.bounds(self.resids)
assert_equal(bounds[0], (0.0, 10.0 * np.mean(self.resids ** 2.0)))
for i in range(1, 6):
assert_equal(bounds[i], (0.0, 1.0))
var_bounds = arch.variance_bounds(self.resids)
backcast = arch.backcast(self.resids)
parameters = np.array([0.25, 0.17, 0.16, 0.15, 0.14, 0.13])
arch.compute_variance(parameters, self.resids, self.sigma2, backcast,
var_bounds)
cond_var_direct = np.zeros_like(self.sigma2)
rec.arch_recursion(parameters, self.resids, cond_var_direct, 5,
self.T, backcast, var_bounds)
assert_allclose(self.sigma2, cond_var_direct)
A, b = arch.constraints()
A_target = np.vstack((np.eye(6),
np.array([[0, -1.0, -1.0, -1.0, -1.0, -1.0]])))
b_target = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0])
assert_array_equal(A, A_target)
assert_array_equal(b, b_target)
state = np.random.get_state()
rng = Normal()
sim_data = arch.simulate(parameters, self.T, rng.simulate([]))
np.random.set_state(state)
e = np.random.standard_normal(self.T + 500)
initial_value = 1.0
sigma2 = np.zeros(self.T + 500)
data = np.zeros(self.T + 500)
for t in range(self.T + 500):
sigma2[t] = parameters[0]
for i in range(5):
if t - i - 1 < 0:
sigma2[t] += parameters[i + 1] * initial_value
else:
sigma2[t] += parameters[i + 1] * data[t - i - 1] ** 2.0
data[t] = e[t] * np.sqrt(sigma2[t])
data = data[500:]
sigma2 = sigma2[500:]
assert_almost_equal(data - sim_data[0] + 1.0, np.ones_like(data))
assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
names = arch.parameter_names()
names_target = ['omega']
names_target.extend(['alpha[' + str(i + 1) + ']' for i in range(5)])
assert_equal(names, names_target)
assert_equal(arch.num_params, 6)
assert_equal(arch.name, 'ARCH')
示例7: test_constant_variance
def test_constant_variance(self):
cv = ConstantVariance()
sv = cv.starting_values(self.resids)
assert_equal(sv.shape[0], cv.num_params)
bounds = cv.bounds(self.resids)
mean_square = np.mean(self.resids ** 2.0)
assert_almost_equal(bounds[0],
(self.resid_var / 100000.0, 10.0 * mean_square))
backcast = cv.backcast(self.resids)
var_bounds = cv.variance_bounds(self.resids)
assert_almost_equal(self.resid_var, backcast)
parameters = np.array([self.resid_var])
cv.compute_variance(parameters, self.resids, self.sigma2, backcast,
var_bounds)
assert_allclose(np.ones_like(self.sigma2) * self.resid_var,
self.sigma2)
A, b = cv.constraints()
A_target = np.eye(1)
b_target = np.array([0.0])
assert_array_equal(A, A_target)
assert_array_equal(b, b_target)
state = np.random.get_state()
rng = Normal()
sim_data = cv.simulate(parameters, self.T, rng.simulate([]))
np.random.set_state(state)
e = np.random.standard_normal(self.T + 500)
sigma2 = np.zeros(self.T + 500)
sigma2[:] = parameters[0]
data = np.zeros(self.T + 500)
data[:] = np.sqrt(sigma2) * e
data = data[500:]
sigma2 = sigma2[500:]
names = cv.parameter_names()
names_target = ['sigma2']
assert_equal(names, names_target)
assert_almost_equal(data - sim_data[0] + 1.0, np.ones_like(data))
assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
assert_equal(cv.num_params, 1)
assert_equal(cv.name, 'Constant Variance')
assert_true(isinstance(cv.__str__(), str))
repr = cv.__repr__()
assert_true(str(hex(id(cv))) in repr)
示例8: test_egarch_100
def test_egarch_100(self):
egarch = EGARCH(p=1, o=0, q=0)
sv = egarch.starting_values(self.resids)
assert_equal(sv.shape[0], egarch.num_params)
backcast = egarch.backcast(self.resids)
w = 0.94 ** np.arange(75)
backcast_test = np.sum((self.resids[:75] ** 2) * (w / w.sum()))
assert_almost_equal(backcast, np.log(backcast_test))
var_bounds = egarch.variance_bounds(self.resids)
parameters = np.array([.1, .4])
egarch.compute_variance(parameters, self.resids, self.sigma2, backcast,
var_bounds)
cond_var_direct = np.zeros_like(self.sigma2)
lnsigma2 = np.empty(self.T)
std_resids = np.empty(self.T)
abs_std_resids = np.empty(self.T)
rec.egarch_recursion(parameters, self.resids, cond_var_direct, 1, 0, 0,
self.T, backcast, var_bounds, lnsigma2,
std_resids, abs_std_resids)
assert_allclose(self.sigma2, cond_var_direct)
state = np.random.get_state()
rng = Normal()
sim_data = egarch.simulate(parameters, self.T, rng.simulate([]))
np.random.set_state(state)
e = np.random.standard_normal(self.T + 500)
initial_value = 0.1 / (1 - 0.95)
lnsigma2 = np.zeros(self.T + 500)
lnsigma2[0] = initial_value
sigma2 = np.zeros(self.T + 500)
sigma2[0] = np.exp(lnsigma2[0])
data = np.zeros(self.T + 500)
data[0] = np.sqrt(sigma2[0]) * e[0]
norm_const = np.sqrt(2 / np.pi)
for t in range(1, self.T + 500):
lnsigma2[t] = parameters[0]
lnsigma2[t] += parameters[1] * (np.abs(e[t - 1]) - norm_const)
sigma2 = np.exp(lnsigma2)
data = e * np.sqrt(sigma2)
data = data[500:]
sigma2 = sigma2[500:]
assert_almost_equal(data - sim_data[0] + 1.0, np.ones_like(data))
assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
示例9: test_normal
def test_normal(self):
dist = Normal()
ll1 = dist.loglikelihoood([], self.resids, self.sigma2)
scipy_dist = stats.norm
ll2 = scipy_dist.logpdf(self.resids, scale=np.sqrt(self.sigma2)).sum()
assert_almost_equal(ll1, ll2)
assert_equal(dist.num_params, 0)
bounds = dist.bounds(self.resids)
assert_equal(len(bounds), 0)
a, b = dist.constraints()
assert_equal(len(a), 0)
assert_array_equal(dist.starting_values(self.resids), np.empty((0,)))
示例10: test_invalid_params
def test_invalid_params():
pits = np.arange(1, 100.0) / 100.0
dist = Normal()
with pytest.raises(ValueError):
dist.ppf(pits, [1.0])
dist = StudentsT()
with pytest.raises(ValueError):
dist.ppf(pits, [1.0])
示例11: test_egarch
def test_egarch(self):
egarch = EGARCH(p=1, o=1, q=1)
sv = egarch.starting_values(self.resids)
assert_equal(sv.shape[0], egarch.num_params)
bounds = egarch.bounds(self.resids)
assert_equal(len(bounds), egarch.num_params)
const = np.log(10000.0)
lnv = np.log(np.mean(self.resids ** 2.0))
assert_equal(bounds[0], (lnv - const, lnv + const))
assert_equal(bounds[1], (-np.inf, np.inf))
assert_equal(bounds[2], (-np.inf, np.inf))
assert_equal(bounds[3], (0.0, 1.0))
backcast = egarch.backcast(self.resids)
w = 0.94 ** np.arange(75)
backcast_test = np.sum((self.resids[:75] ** 2) * (w / w.sum()))
assert_almost_equal(backcast, np.log(backcast_test))
var_bounds = egarch.variance_bounds(self.resids)
parameters = np.array([.1, .1, -.1, .95])
egarch.compute_variance(parameters, self.resids, self.sigma2, backcast,
var_bounds)
cond_var_direct = np.zeros_like(self.sigma2)
lnsigma2 = np.empty(self.T)
std_resids = np.empty(self.T)
abs_std_resids = np.empty(self.T)
rec.egarch_recursion(parameters, self.resids, cond_var_direct, 1, 1, 1,
self.T, backcast, var_bounds, lnsigma2, std_resids,
abs_std_resids)
assert_allclose(self.sigma2, cond_var_direct)
A, b = egarch.constraints()
A_target = np.vstack((np.array([[0, 0, 0, -1.0]])))
b_target = np.array([-1.0])
assert_array_equal(A, A_target)
assert_array_equal(b, b_target)
state = np.random.get_state()
rng = Normal()
sim_data = egarch.simulate(parameters, self.T, rng.simulate([]))
np.random.set_state(state)
e = np.random.standard_normal(self.T + 500)
initial_value = 0.1 / (1 - 0.95)
lnsigma2 = np.zeros(self.T + 500)
lnsigma2[0] = initial_value
sigma2 = np.zeros(self.T + 500)
sigma2[0] = np.exp(lnsigma2[0])
data = np.zeros(self.T + 500)
data[0] = np.sqrt(sigma2[0]) * e[0]
norm_const = np.sqrt(2 / np.pi)
for t in range(1, self.T + 500):
lnsigma2[t] = parameters[0]
lnsigma2[t] += parameters[1] * (np.abs(e[t - 1]) - norm_const)
lnsigma2[t] += parameters[2] * e[t - 1]
lnsigma2[t] += parameters[3] * lnsigma2[t - 1]
sigma2 = np.exp(lnsigma2)
data = e * np.sqrt(sigma2)
data = data[500:]
sigma2 = sigma2[500:]
assert_almost_equal(data - sim_data[0] + 1.0, np.ones_like(data))
assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
names = egarch.parameter_names()
names_target = ['omega', 'alpha[1]', 'gamma[1]', 'beta[1]']
assert_equal(names, names_target)
assert_equal(egarch.name, 'EGARCH')
assert_equal(egarch.num_params, 4)
assert_equal(egarch.p, 1)
assert_equal(egarch.o, 1)
assert_equal(egarch.q, 1)
示例12: test_harch
def test_harch(self):
harch = HARCH(lags=[1, 5, 22])
sv = harch.starting_values(self.resids)
assert_equal(sv.shape[0], harch.num_params)
bounds = harch.bounds(self.resids)
assert_equal(bounds[0], (0.0, 10.0 * np.mean(self.resids ** 2.0)))
assert_equal(bounds[1], (0.0, 1.0))
assert_equal(bounds[2], (0.0, 1.0))
assert_equal(bounds[3], (0.0, 1.0))
var_bounds = harch.variance_bounds(self.resids)
backcast = harch.backcast(self.resids)
w = 0.94 ** np.arange(75)
assert_almost_equal(backcast,
np.sum((self.resids[:75] ** 2) * (w / w.sum())))
parameters = np.array([.1, .4, .3, .2])
var_bounds = harch.variance_bounds(self.resids)
harch.compute_variance(parameters, self.resids, self.sigma2,
backcast, var_bounds)
cond_var_direct = np.zeros_like(self.sigma2)
lags = np.array([1, 5, 22], dtype=np.int32)
rec.harch_recursion(parameters,
self.resids,
cond_var_direct,
lags,
self.T,
backcast,
var_bounds)
names = harch.parameter_names()
names_target = ['omega', 'alpha[1]', 'alpha[5]', 'alpha[22]']
assert_equal(names, names_target)
assert_allclose(self.sigma2, cond_var_direct)
A, b = harch.constraints()
A_target = np.vstack((np.eye(4), np.array([[0, -1.0, -1.0, -1.0]])))
b_target = np.array([0.0, 0.0, 0.0, 0.0, -1.0])
assert_array_equal(A, A_target)
assert_array_equal(b, b_target)
state = np.random.get_state()
rng = Normal()
sim_data = harch.simulate(parameters, self.T, rng.simulate([]))
np.random.set_state(state)
e = np.random.standard_normal(self.T + 500)
initial_value = 1.0
sigma2 = np.zeros(self.T + 500)
data = np.zeros(self.T + 500)
lagged = np.zeros(22)
for t in range(self.T + 500):
sigma2[t] = parameters[0]
lagged[:] = backcast
if t > 0:
if t == 1:
lagged[0] = data[0] ** 2.0
elif t < 22:
lagged[:t] = data[t - 1::-1] ** 2.0
else:
lagged = data[t - 1:t - 22:-1] ** 2.0
shock1 = data[t - 1] ** 2.0 if t > 0 else backcast
if t >= 5:
shock5 = np.mean(data[t - 5:t] ** 2.0)
else:
shock5 = 0.0
for i in range(5):
shock5 += data[t - i - 1] if t - i - 1 >= 0 else backcast
shock5 = shock5 / 5.0
if t >= 22:
shock22 = np.mean(data[t - 22:t] ** 2.0)
else:
shock22 = 0.0
for i in range(22):
shock22 += data[t - i - 1] if t - i - 1 >= 0 else backcast
shock22 = shock22 / 22.0
sigma2[t] += parameters[1] * shock1 \
+ parameters[2] * shock5 \
+ parameters[3] * shock22
data[t] = e[t] * np.sqrt(sigma2[t])
data = data[500:]
sigma2 = sigma2[500:]
assert_almost_equal(data - sim_data[0] + 1.0, np.ones_like(data))
assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
assert_equal(harch.name, 'HARCH')
assert_equal(harch.lags, [1, 5, 22])
assert_equal(harch.num_params, 4)
示例13: test_garch
def test_garch(self):
garch = GARCH()
sv = garch.starting_values(self.resids)
assert_equal(sv.shape[0], garch.num_params)
bounds = garch.bounds(self.resids)
assert_equal(bounds[0], (0.0, 10.0 * np.mean(self.resids ** 2.0)))
assert_equal(bounds[1], (0.0, 1.0))
assert_equal(bounds[2], (0.0, 1.0))
backcast = garch.backcast(self.resids)
w = 0.94 ** np.arange(75)
assert_almost_equal(backcast,
np.sum((self.resids[:75] ** 2) * (w / w.sum())))
var_bounds = garch.variance_bounds(self.resids)
parameters = np.array([.1, .1, .8])
garch.compute_variance(parameters, self.resids, self.sigma2,
backcast, var_bounds)
cond_var_direct = np.zeros_like(self.sigma2)
rec.garch_recursion(parameters,
self.resids ** 2.0,
np.sign(self.resids),
cond_var_direct,
1, 0, 1, self.T, backcast, var_bounds)
assert_allclose(self.sigma2, cond_var_direct)
a, b = garch.constraints()
a_target = np.vstack((np.eye(3), np.array([[0, -1.0, -1.0]])))
b_target = np.array([0.0, 0.0, 0.0, -1.0])
assert_array_equal(a, a_target)
assert_array_equal(b, b_target)
state = np.random.get_state()
rng = Normal()
sim_data = garch.simulate(parameters, self.T, rng.simulate([]))
np.random.set_state(state)
e = np.random.standard_normal(self.T + 500)
initial_value = 1.0
sigma2 = np.zeros(self.T + 500)
data = np.zeros(self.T + 500)
for t in range(self.T + 500):
sigma2[t] = parameters[0]
shock = initial_value if t == 0 else data[t - 1] ** 2.0
sigma2[t] += parameters[1] * shock
lagged_value = initial_value if t == 0 else sigma2[t - 1]
sigma2[t] += parameters[2] * lagged_value
data[t] = e[t] * np.sqrt(sigma2[t])
data = data[500:]
sigma2 = sigma2[500:]
assert_almost_equal(data / sim_data[0], np.ones_like(data))
assert_almost_equal(sigma2 / sim_data[1], np.ones_like(sigma2))
names = garch.parameter_names()
names_target = ['omega', 'alpha[1]', 'beta[1]']
assert_equal(names, names_target)
assert isinstance(garch.__str__(), str)
txt = garch.__repr__()
assert str(hex(id(garch))) in txt
assert_equal(garch.name, 'GARCH')
assert_equal(garch.num_params, 3)
assert_equal(garch.power, 2.0)
assert_equal(garch.p, 1)
assert_equal(garch.o, 0)
assert_equal(garch.q, 1)