def test_loop_directed(self):
np.random.seed(12345)
Abin = er_nm(self.n, self.M, directed=True, loops=True)
Awt = er_nm(self.n,
self.M,
directed=True,
loops=True,
wt=self.wt,
wtargs=self.wtargs)
# check that correct number of edges assigned
# sum of nonzero entries and correct for the fact that the diagonal
# is part of the model now
self.assertTrue(Abin.sum() == self.M)
self.assertTrue((Awt != 0).sum() == self.M)
# check that the nonzero edges have mean self.mean and var self.var
self.assertTrue(np.isclose(np.mean(Awt[Awt != 0]), self.mean,
atol=0.2))
self.assertTrue(np.isclose(np.std(Awt[Awt != 0]), self.std, atol=0.2))
# check loopless and undirected
self.assertFalse(is_symmetric(Abin))
self.assertFalse(is_symmetric(Awt))
self.assertFalse(is_loopless(Abin))
self.assertFalse(is_loopless(Awt))
# check dimensions
self.assertTrue(Abin.shape == (self.n, self.n))
self.assertTrue(Awt.shape == (self.n, self.n))
pass
def test_noloop_directed(self):
np.random.seed(12345)
Abin = er_nm(self.n, self.M, directed=True)
Awt = er_nm(self.n,
self.M,
wt=self.wt,
directed=True,
wtargs=self.wtargs)
# check that correct number of edges assigned
self.assertTrue(Abin.sum() == self.M)
self.assertTrue((Awt != 0).sum() == self.M)
dind = remove_diagonal(Awt)
# check that the nonzero edges have mean self.mean and var self.var
self.assertTrue(
np.isclose(np.mean(dind[dind != 0]), self.mean, atol=0.15))
self.assertTrue(
np.isclose(np.std(dind[dind != 0]), self.std, atol=0.15))
# check loopless and undirected
self.assertFalse(is_symmetric(Abin))
self.assertFalse(is_symmetric(Awt))
self.assertTrue(is_loopless(Abin))
self.assertTrue(is_loopless(Awt))
# check dimensions
self.assertTrue(Abin.shape == (self.n, self.n))
self.assertTrue(Awt.shape == (self.n, self.n))
pass
def test_loop_undirected(self):
np.random.seed(12345)
Abin = er_np(self.n, self.p, loops=True)
Awt = er_np(self.n, self.p, loops=True, wt=self.wt, wtargs=self.wtargs)
# check that correct number of edges assigned
self.assertTrue(
np.isclose(Abin.sum() / float(np.prod(Abin.shape)),
self.p,
atol=0.02))
self.assertTrue(
np.isclose((Awt != 0).sum() / float(np.prod(Awt.shape)),
self.p,
atol=0.02))
# check that the nonzero edges have mean self.mean and var self.var
self.assertTrue(
np.isclose(np.mean(Awt[Awt != 0]), self.mean, atol=0.15))
self.assertTrue(np.isclose(np.std(Awt[Awt != 0]), self.std, atol=0.15))
# check loopless and undirected
self.assertTrue(is_symmetric(Abin))
self.assertTrue(is_symmetric(Awt))
self.assertFalse(is_loopless(Abin))
self.assertFalse(is_loopless(Awt))
# check dimensions
self.assertTrue(Abin.shape == (self.n, self.n))
self.assertTrue(Awt.shape == (self.n, self.n))
pass
def test_noloop_undirected(self):
np.random.seed(123)
Abin = er_np(self.n, self.p)
Awt = er_np(self.n, self.p, wt=self.wt, wtargs=self.wtargs)
# check that correct number of edges assigned
dind = remove_diagonal(Abin)
dindwt = remove_diagonal(Awt)
self.assertTrue(
np.isclose(dind.sum() / float(len(dind)), self.p, atol=0.02))
self.assertTrue(
np.isclose((dindwt != 0).sum() / float(len(dindwt)),
self.p,
atol=0.02))
# check that the nonzero edges have mean self.mean and var self.var
self.assertTrue(
np.isclose(np.mean(dindwt[dindwt != 0]), self.mean, atol=0.15))
self.assertTrue(
np.isclose(np.std(dindwt[dindwt != 0]), self.std, atol=0.15))
# check loopless and undirected
self.assertTrue(is_symmetric(Abin))
self.assertTrue(is_symmetric(Awt))
self.assertTrue(is_loopless(Abin))
self.assertTrue(is_loopless(Awt))
# check dimensions
self.assertTrue(Abin.shape == (self.n, self.n))
self.assertTrue(Awt.shape == (self.n, self.n))
def test_kwarg_passing(self):
np.random.seed(8888)
X = 0.5 * np.ones((300, 2))
g = rdpg(X, rescale=True, loops=True, directed=True)
self.assertFalse(is_symmetric(g))
self.assertFalse(is_loopless(g))
g = rdpg(X, rescale=True, loops=False, directed=True)
self.assertFalse(is_symmetric(g))
self.assertTrue(is_loopless(g))
g = rdpg(X, rescale=True, loops=False, directed=False)
self.assertTrue(is_symmetric(g))
self.assertTrue(is_loopless(g))
def test_sbm_singlewt_undirected_loopless(self):
np.random.seed(12345)
wt = np.random.normal
params = {"loc": 2, "scale": 2}
A = sbm(self.n, self.Psy, wt=wt, wtargs=params)
for i in range(0, len(self.n)):
for j in range(0, len(self.n)):
irange = np.arange(self.vcount[i] - self.n[i], self.vcount[i])
jrange = np.arange(self.vcount[j] - self.n[j], self.vcount[j])
block = A[(self.vcount[i] - self.n[i]):self.vcount[i],
(self.vcount[j] - self.n[j]):self.vcount[j], ]
if i == j:
block = remove_diagonal(block)
self.assertTrue(
np.isclose(np.mean(block != 0), self.Psy[i, j], atol=0.02))
self.assertTrue(
np.isclose(np.mean(block[block != 0]),
params["loc"],
atol=0.2))
self.assertTrue(
np.isclose(np.std(block[block != 0]),
params["scale"],
atol=0.2))
self.assertTrue(is_symmetric(A))
self.assertTrue(is_loopless(A))
# check dimensions
self.assertTrue(A.shape == (np.sum(self.n), np.sum(self.n)))
def test_sbm_dc_dc_kws_directed_loopy(self):
np.random.seed(self.seed)
funcs = [np.random.power, np.random.uniform]
dc_kwss = [{"a": 3}, {"low": 5, "high": 10}]
for i in range(len(funcs)):
A = sbm(
self.n,
self.Psy,
directed=True,
loops=True,
dc=funcs[i],
dc_kws=dc_kwss[i],
)
for i in range(0, len(self.n)):
for j in range(0, len(self.n)):
block = A[(self.vcount[i] - self.n[i]):self.vcount[i],
(self.vcount[j] - self.n[j]):self.vcount[j], ]
if i == j:
block = remove_diagonal(block)
self.assertTrue(
np.isclose(np.mean(block), self.Psy[i, j], atol=0.02))
self.assertFalse(is_symmetric(A))
self.assertFalse(is_loopless(A))
# check dimensions
self.assertTrue(A.shape == (np.sum(self.n), np.sum(self.n)))
pass
def test_is_almost_symmetric(self):
np.random.seed(8888)
vec1 = np.random.normal(0, 1, (100, 100))
vec2 = np.random.normal(0, 1, (100, 100))
corr = np.corrcoef(vec1, vec2)
self.assertTrue(gus.is_almost_symmetric(corr, atol=1e-15))
self.assertFalse(gus.is_symmetric(corr))
def test_omni_matrix_symmetric():
np.random.seed(3)
n = 15
p = 0.4
n_graphs = [2, 5, 10]
for n in n_graphs:
graphs = [er_np(n, p) for _ in range(n)]
output = _get_omni_matrix(graphs)
assert is_symmetric(output)
def test_sbm_multi_dc_empty_dc_kws(self):
np.random.seed(self.seed)
dc = [np.random.rayleigh, np.random.uniform]
A = sbm(self.n, self.Psy, directed=True, loops=True, dc=dc)
for i in range(0, len(self.n)):
for j in range(0, len(self.n)):
block = A[(self.vcount[i] - self.n[i]):self.vcount[i],
(self.vcount[j] - self.n[j]):self.vcount[j], ]
if i == j:
block = remove_diagonal(block)
self.assertTrue(
np.isclose(np.mean(block), self.Psy[i, j], atol=0.02))
self.assertFalse(is_symmetric(A))
self.assertFalse(is_loopless(A))
# check dimensions
self.assertTrue(A.shape == (np.sum(self.n), np.sum(self.n)))
pass
def test_sbm_multiwt_directed_loopy(self):
np.random.seed(12345)
Wt = np.vstack((
[np.random.normal, np.random.poisson],
[np.random.exponential, np.random.uniform],
))
Wtargs = np.vstack((
[{
"loc": 2,
"scale": 2
}, {
"lam": 5
}],
[{
"scale": 2
}, {
"low": 5,
"high": 10
}],
))
check = np.vstack(([self.exp_normal,
self.exp_poisson], [self.exp_exp, self.exp_unif]))
A = sbm(self.n,
self.Psy,
wt=Wt,
directed=True,
loops=True,
wtargs=Wtargs)
for i in range(0, len(self.n)):
for j in range(0, len(self.n)):
irange = np.arange(self.vcount[i] - self.n[i], self.vcount[i])
jrange = np.arange(self.vcount[j] - self.n[j], self.vcount[j])
block = A[(self.vcount[i] - self.n[i]):self.vcount[i],
(self.vcount[j] - self.n[j]):self.vcount[j], ]
self.assertTrue(
np.isclose(np.mean(block != 0), self.Psy[i, j], atol=0.02))
fit = check[i, j](block[block != 0])
for k, v in fit.items():
self.assertTrue(np.isclose(v, Wtargs[i, j][k], atol=0.2))
self.assertFalse(is_symmetric(A))
self.assertFalse(is_loopless(A))
# check dimensions
self.assertTrue(A.shape == (np.sum(self.n), np.sum(self.n)))
pass
def test_sbm(self):
n = [50, 60, 70]
vcount = np.cumsum(n)
# define symmetric probability as evenly weighted
Psy = np.vstack(([0.6, 0.2, 0.3], [0.3, 0.4, 0.2], [0.2, 0.8, 0.1]))
Psy = symmetrize(Psy)
np.random.seed(12345)
A = sbm(n, Psy)
for i in range(0, len(n)):
for j in range(0, len(n)):
irange = np.arange(vcount[i] - n[i], vcount[i])
jrange = np.arange(vcount[j] - n[j], vcount[j])
block = A[(vcount[i] - n[i]):vcount[i],
(vcount[j] - n[j]):vcount[j]]
if i == j:
block = remove_diagonal(block)
self.assertTrue(
np.isclose(np.mean(block), Psy[i, j], atol=0.02))
self.assertTrue(is_symmetric(A))
self.assertTrue(is_loopless(A))
# check dimensions
self.assertTrue(A.shape == (np.sum(n), np.sum(n)))
pass
def test_to_laplace_symmetric(self):
L_normed = gus.to_laplace(self.A, form="DAD")
self.assertTrue(gus.is_symmetric(L_normed))
