def testNormalInverseGaussianLogPdfScipyMultidimensional(self):
loc_v = np.linspace(-10., 10., 5).astype(self.dtype).reshape(
(5, 1, 1, 1))
scale_v = self.dtype(1.)
tailweight_v = np.array([2., 0.5], dtype=self.dtype).reshape((2, 1))
skewness_v = 0.5 * tailweight_v
x_v = np.linspace(-9., 9., 20).astype(self.dtype)
normal_inverse_gaussian = tfd.NormalInverseGaussian(loc_v,
scale_v,
tailweight_v,
skewness_v,
validate_args=True)
log_prob = normal_inverse_gaussian.log_prob(x_v)
self.assertAllClose(
self.evaluate(log_prob),
stats.norminvgauss(a=tailweight_v,
b=skewness_v,
loc=loc_v,
scale=scale_v).logpdf(x_v))
prob = normal_inverse_gaussian.prob(x_v)
self.assertAllClose(
self.evaluate(prob),
stats.norminvgauss(a=tailweight_v,
b=skewness_v,
loc=loc_v,
scale=scale_v).pdf(x_v))
def testNormalInverseGaussianScipyLogPdf(self):
loc_v = self.dtype(0.)
scale_v = self.dtype(1.)
tailweight_v = self.dtype(1.)
skewness_v = self.dtype(0.2)
x_v = np.array([3., 3.1, 4., 5., 6., 7.]).astype(self.dtype)
normal_inverse_gaussian = tfd.NormalInverseGaussian(loc_v,
scale_v,
tailweight_v,
skewness_v,
validate_args=True)
log_prob = normal_inverse_gaussian.log_prob(x_v)
self.assertAllClose(
self.evaluate(log_prob),
stats.norminvgauss(a=tailweight_v,
b=skewness_v,
loc=loc_v,
scale=scale_v).logpdf(x_v))
pdf = normal_inverse_gaussian.prob(x_v)
self.assertAllClose(
self.evaluate(pdf),
stats.norminvgauss(a=tailweight_v,
b=skewness_v,
loc=loc_v,
scale=scale_v).pdf(x_v))
def normalNumbers():
for size in sizes:
fig, ax = plt.subplots(1, 1)
ax.hist(norminvgauss.rvs(1, 0, size=size), histtype='stepfilled', alpha=0.5, color='blue', density=True)
x = np.linspace(norminvgauss(1, 0).ppf(0.01), norminvgauss(1, 0).ppf(0.99), 100)
ax.plot(x, norminvgauss(1, 0).pdf(x), '-')
ax.set_title('NormalNumbers n = ' + str(size))
ax.set_xlabel('NormalNumbers')
ax.set_ylabel('density')
plt.grid()
plt.show()
return
def get_functions():
rv_n = norminvgauss(1, 0)
rv_l = laplace(scale=1 / m.sqrt(2), loc=0)
rv_p = poisson(10)
rv_c = cauchy()
rv_u = uniform(loc=-m.sqrt(3), scale=2 * m.sqrt(3))
return [rv_n, rv_l, rv_p, rv_c, rv_u]
def __init__(self, alpha, beta, mu, delta):
self.alpha = alpha
self.beta = beta
self.mu = mu
self.delta = delta
self.gamma = gamma = math.sqrt(alpha**2 - beta**2)
scipy_alpha = delta * alpha
scipy_beta = delta * beta
self.scipy_dist = norminvgauss(scipy_alpha, scipy_beta, mu, delta)
# Moment formulas from Wikipedia.
self.mean = mu + delta * beta / gamma
self.variance = delta * alpha**2 / gamma**3
self.skewness = 3 * beta / alpha / math.sqrt(delta * gamma)
self.kurtosis = 3 + 3 * (1 + 4 * beta**2 / alpha**2) / delta / gamma
self.stddev = math.sqrt(self.variance)
self.kappa_3 = self.skewness * self.stddev**3
self.kappa_4 = (self.kurtosis - 3) * self.stddev**4
# Extra variables...
self.rho = self.alpha**2 / self.beta**2
def testNormalInverseGaussianVarianceScale1(self):
loc_v = np.linspace(-10., 10., 5).astype(self.dtype).reshape((5, 1, 1, 1))
scale_v = self.dtype(1.)
tailweight_v = np.array([2., 0.5], dtype=self.dtype).reshape((2, 1))
skewness_v = 0.5 * tailweight_v
normal_inverse_gaussian = tfd.NormalInverseGaussian(
loc_v, scale_v, tailweight_v, skewness_v, validate_args=True)
self.assertAllClose(
self.evaluate(normal_inverse_gaussian.variance()),
stats.norminvgauss(
a=tailweight_v, b=skewness_v, loc=loc_v, scale=scale_v).var())
def Gauss():
for s in size:
den = norminvgauss(1, 0)
hist = norminvgauss.rvs(1, 0, size=s)
fig, ax = plt.subplots(1, 1)
ax.hist(hist, density=True, alpha=0.6)
x = np.linspace(den.ppf(0.01), den.ppf(0.99), 100)
ax.plot(x, den.pdf(x), LINE_TYPE, lw=1.5)
ax.set_xlabel("NORMAL")
ax.set_ylabel("DENSITY")
ax.set_title("SIZE: " + str(s))
plt.grid()
plt.show()
def Hist_Normal():
normal_scale = 1 # Параметры
normal_loc = 0
normal_label = "Normal distribution"
normal_color = "green"
for size in selection_size:
fig, ax = plt.subplots(1, 1)
pdf = norminvgauss(normal_scale, normal_loc)
random_values = norminvgauss.rvs(normal_scale, normal_loc, size=size)
ax.hist(random_values,
density=True,
histtype=HIST_TYPE,
alpha=hist_visibility,
color=normal_color)
Create_plot(ax, normal_label, pdf, size)
e_param = stats.laplace.fit(euro_log) VaR = stats.laplace(param[0], param[1]).ppf(q) e_var = stats.laplace(e_param[0], e_param[1]).ppf(q) d, p = stats.kstest(logreturns[1], cdf = 'laplace', args = (param[0], param[1])) ks.append(p) #plt.plot(q, VaR, 'r-', label = 'Ethereum') #plt.plot(q, e_var, 'b--', label = 'Euro') #plt.legend() ###############DOGECOIN################ param = [0.11944945909723138, -0.026530755256677835, 0.0024121276834745383, 0.01998674804467044] q = np.linspace(0, 1, 100) e_param = stats.norminvgauss.fit(euro_log) VaR = stats.norminvgauss(param[0], param[1], param[2], param[3]).ppf(q) e_var = stats.norminvgauss(e_param[0], e_param[1], e_param[2], e_param[3]).ppf(q) d, p = stats.kstest(logreturns[2], cdf = 'norminvgauss', args = (param[0], param[1], param[2], param[3])) ks.append(p) #plt.plot(q, VaR, 'r-', label = 'Dogecoin') #plt.plot(q, e_var, 'b--', label = 'Euro') #plt.legend() ################LITECOIN############### param = [1.8693373494312953, -0.08195764686173776, 0.0017432733966738605, 0.021626187586807188] q = np.linspace(0, 1, 100) e_param = stats.nct.fit(euro_log) VaR = stats.nct(param[0], param[1], param[2], param[3]).ppf(q) e_var = stats.nct(e_param[0], e_param[1], e_param[2], e_param[3]).ppf(q) d, p = stats.kstest(logreturns[3], cdf = 'nct', args = (param[0], param[1], param[2], param[3]))
x = np.linspace(norminvgauss.ppf(0.01, a, b), norminvgauss.ppf(0.99, a, b),
100)
ax.plot(x,
norminvgauss.pdf(x, a, b),
'r-',
lw=5,
alpha=0.6,
label='norminvgauss pdf')
# Alternatively, the distribution object can be called (as a function)
# to fix the shape, location and scale parameters. This returns a "frozen"
# RV object holding the given parameters fixed.
# Freeze the distribution and display the frozen ``pdf``:
rv = norminvgauss(a, b)
ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')
# Check accuracy of ``cdf`` and ``ppf``:
vals = norminvgauss.ppf([0.001, 0.5, 0.999], a, b)
np.allclose([0.001, 0.5, 0.999], norminvgauss.cdf(vals, a, b))
# True
# Generate random numbers:
r = norminvgauss.rvs(a, b, size=1000)
# And compare the histogram:
ax.hist(r, density=True, histtype='stepfilled', alpha=0.2)
from scipy.stats import norminvgauss, laplace, poisson, cauchy, uniform
import numpy as np
import matplotlib.pyplot as plt
import math as m
sizes = [10, 50, 1000]
rv_n = norminvgauss(1, 0)
rv_l = laplace(scale=1 / m.sqrt(2), loc=0)
rv_p = poisson(10)
rv_c = cauchy()
rv_u = uniform(loc=-m.sqrt(3), scale=2 * m.sqrt(3))
densities = [rv_n, rv_l, rv_p, rv_c, rv_u]
names = ["Normal", "Laplace", "Poisson", "Cauchy", "Uniform"]
for size in sizes:
n = norminvgauss.rvs(1, 0, size=size)
l = laplace.rvs(size=size, scale=1 / m.sqrt(2), loc=0)
p = poisson.rvs(10, size=size)
c = cauchy.rvs(size=size)
u = uniform.rvs(size=size, loc=-m.sqrt(3), scale=2 * m.sqrt(3))
distributions = [n, l, p, c, u]
build = list(zip(distributions, densities, names))
for histogram, density, name in build:
fig, ax = plt.subplots(1, 1)
ax.hist(histogram,
density=True,
histtype='stepfilled',
alpha=0.6,
color="green")
