def test_hhg():
# Against a randomly defined data set
X = np.array([
1.1728, 2.4941, 2.4101, 0.1814, 1.1978, 1.5806, 1.2504, 1.9706, 1.8839,
0.8760
])[:, np.newaxis]
Y = np.array([
3.2311, 12.1113, 11.1350, 1.1989, 3.3127, 4.8580, 3.4917, 7.1748,
6.5792, 2.4012
])[:, np.newaxis]
hhg = HHG()
test_stat = hhg.test_statistic(X, Y)[0]
assert np.round(test_stat, decimals=2) == 411.88
# Against linear simulations
np.random.seed(0)
X, Y = sims.linear_sim(100, 1)
test_stat = hhg.test_statistic(X, Y)[0]
assert np.round(test_stat, decimals=2) == 28986.52
X, Y = sims.linear_sim(100, 1, noise=0)
test_stat = hhg.test_statistic(X, Y)[0]
assert np.round(test_stat, decimals=2) == 950600.00
def test_kendall_spearman():
# Against a randomly defined data set
X = np.array([
1.1728, 2.4941, 2.4101, 0.1814, 1.1978, 1.5806, 1.2504, 1.9706, 1.8839,
0.8760
])[:, np.newaxis]
Y = np.array([
3.2311, 12.1113, 11.1350, 1.1989, 3.3127, 4.8580, 3.4917, 7.1748,
6.5792, 2.4012
])[:, np.newaxis]
kspear = KendallSpearman(None)
kspear2 = KendallSpearman(None, 'spearman')
test_stat1 = kspear.test_statistic(X, Y)[0]
test_stat2 = kspear2.test_statistic(X, Y)[0]
assert np.round(test_stat1, decimals=2) == 1.00
assert np.round(test_stat2, decimals=2) == 1.00
# Against linear simulations
np.random.seed(0)
X, Y = sims.linear_sim(100, 1)
kspear = KendallSpearman(None)
kspear2 = KendallSpearman(None, 'spearman')
assert kspear.get_name() == 'kendall'
assert kspear2.get_name() == 'spearman'
test_stat1 = kspear.test_statistic(X, Y)[0]
test_stat2 = kspear2.test_statistic(X, Y)[0]
assert np.round(test_stat1, decimals=2) == 0.33
assert np.round(test_stat2, decimals=2) == 0.48
def test_local_corr():
# Against a randomly defined data set
X = np.array([1.1728, 2.4941, 2.4101, 0.1814, 1.1978, 1.5806, 1.2504,
1.9706, 1.8839, 0.8760], dtype=np.float64).reshape(-1, 1)
Y = np.array([3.2311, 12.1113, 11.1350, 1.1989, 3.3127, 4.8580, 3.4917,
7.1748, 6.5792, 2.4012], dtype=np.float64).reshape(-1, 1)
rvcorr = RVCorr(None)
rvcorr2 = RVCorr(None, 'pearson')
rvcorr3 = RVCorr(None, 'cca')
test_stat1 = rvcorr.test_statistic(X, Y)[0]
test_stat2 = rvcorr2.test_statistic(X, Y)[0]
test_stat3 = rvcorr3.test_statistic(X, Y)[0]
assert np.round(test_stat1, decimals=2) == 0.90
assert np.round(test_stat2, decimals=2) == 0.95
assert np.round(test_stat3, decimals=2) == 0.90
# Against linear simulations
np.random.seed(0)
X, Y = sims.linear_sim(100, 1)
rvcorr = RVCorr(None)
rvcorr2 = RVCorr(None, 'pearson')
rvcorr3 = RVCorr(None, 'cca')
assert rvcorr.get_name() == 'rv'
assert rvcorr2.get_name() == 'pearson'
assert rvcorr3.get_name() == 'cca'
test_stat1 = rvcorr.test_statistic(X, Y)[0]
test_stat2 = rvcorr2.test_statistic(X, Y)[0]
test_stat3 = rvcorr3.test_statistic(X, Y)[0]
assert np.round(test_stat1, decimals=2) == 0.24
assert np.round(test_stat2, decimals=2) == 0.49
assert np.round(test_stat3, decimals=2) == 0.24
cbar.ax.set_ylabel("", rotation=-90, va="bottom")
# fig.colorbar(ax.get_children()[0], cax=cax, orientation="vertical")
ax.invert_yaxis()
# Turn spines off and create white grid.
for edge, spine in ax.spines.items():
spine.set_visible(False)
# optimal scale
optimal_scale = independence_test_metadata["optimal_scale"]
ax.scatter(optimal_scale[0],
optimal_scale[1],
marker='X',
s=200,
color='red')
# other formatting
ax.tick_params(bottom="off", left="off")
ax.set_xlabel('#Neighbors for X', fontsize=15)
ax.set_ylabel('#Neighbors for Y', fontsize=15)
ax.set_xlim(0, 60)
ax.set_ylim(0, 60)
plt.savefig(name_graph, bbox_inches='tight')
# here I generate some random X and Y values (1D graph: only one Y for each X)
x, y = sims.linear_sim(num_samp=100, num_dim=1, noise=0.1)
mgc_plot(x, y, "MGC Test", "firstTestMGC.png", "firstTestMGC2.png")
def test_simulations():
num_samps = 1000
num_dim1 = 1
num_dim2 = 300
independent = True
# Linear Simulation
returns_low_dim = sims.linear_sim(num_samps, num_dim1)
returns_high_dim = sims.linear_sim(num_samps, num_dim2, indep=independent)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Exponential Simulation
returns_low_dim = sims.exp_sim(num_samps, num_dim1)
returns_high_dim = sims.exp_sim(num_samps, num_dim2, indep=independent)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Cubic Simulation
returns_low_dim = sims.cub_sim(num_samps, num_dim1)
returns_high_dim = sims.cub_sim(num_samps, num_dim2, indep=independent)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Joint-Normal Simulation
returns_low_dim = sims.joint_sim(num_samps, num_dim1)
returns_high_dim = sims.joint_sim(num_samps, num_dim2)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Step Simulation
returns_low_dim = sims.step_sim(num_samps, num_dim1)
returns_high_dim = sims.step_sim(num_samps, num_dim2, indep=independent)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Quadratic Simulation
returns_low_dim = sims.quad_sim(num_samps, num_dim1)
returns_high_dim = sims.quad_sim(num_samps, num_dim2, indep=independent)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# W Simulation
returns_low_dim = sims.w_sim(num_samps, num_dim1)
returns_high_dim = sims.w_sim(num_samps, num_dim2, indep=independent)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Spiral Simulation
returns_low_dim = sims.spiral_sim(num_samps, num_dim1)
returns_high_dim = sims.spiral_sim(num_samps, num_dim2)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Uncorrelated Bernoulli Simulation
returns = sims.ubern_sim(num_samps, num_dim2)
assert np.all(returns[0].shape == (num_samps, num_dim2))
# Logarithmic Simulation
returns_low_dim = sims.log_sim(num_samps, num_dim1)
returns_high_dim = sims.log_sim(num_samps, num_dim2, indep=independent)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Nth Root Simulation
returns_low_dim = sims.root_sim(num_samps, num_dim1)
returns_high_dim = sims.root_sim(num_samps, num_dim2, indep=independent)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Sinusoidal Simulation (4*pi)
returns_low_dim = sims.sin_sim(num_samps, num_dim1)
returns_high_dim = sims.sin_sim(num_samps, num_dim2, indep=independent)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Sinusoidal Simulation (16*pi)
returns_low_dim = sims.sin_sim(num_samps, num_dim1, period=16 * np.pi)
returns_high_dim = sims.sin_sim(num_samps,
num_dim2,
period=16 * np.pi,
indep=independent)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Square Simulation
returns = sims.square_sim(num_samps, num_dim2, indep=independent)
assert np.all(returns[0].shape == (num_samps, num_dim2))
# Two Parabolas Simulation
returns_low_dim = sims.two_parab_sim(num_samps, num_dim1)
returns_high_dim = sims.two_parab_sim(num_samps, num_dim2)
assert np.all(returns_low_dim[0].shape == (num_samps, num_dim1))
assert np.all(returns_high_dim[0].shape == (num_samps, num_dim2))
# Circle Simulation
returns = sims.circle_sim(num_samps, num_dim2)
assert np.all(returns[0].shape == (num_samps, num_dim2))
# Ellipse Simulation
returns = sims.circle_sim(num_samps, num_dim2, radius=5)
assert np.all(returns[0].shape == (num_samps, num_dim2))
# Diamond Simulation
returns = sims.square_sim(num_samps,
num_dim2,
period=-np.pi / 4,
indep=independent)
assert np.all(returns[0].shape == (num_samps, num_dim2))
# Multiplicative Noise Simulation
returns = sims.multi_noise_sim(num_samps, num_dim2)
assert np.all(returns[0].shape == (num_samps, num_dim2))
# Multimodal Independence Simulation
returns = sims.multi_indep_sim(num_samps, num_dim2)
assert np.all(returns[0].shape == (num_samps, num_dim2))