def test_tse1(i, j): """ Test identity comparing TSE to B from Olbrich's talk """ d = n_mod_m(i, j) indices = [[k] for k in range(i)] tse = TSE(d) x = 1/2 * sum(B(d, rv)/nCk(i, len(rv)) for rv in powerset(indices)) assert tse == pytest.approx(x)
def test_coi1(): """ Test I for xor """ d = n_mod_m(3, 2) assert_almost_equal(I(d), -1.0) assert_almost_equal(I(d, [[0], [1], [2]]), -1.0) assert_almost_equal(I(d, [[0], [1], [2]], [2]), 0.0) assert_almost_equal(I(d, [[0], [1]], [2]), 1.0)
def test_sp2(): """ Test all possible info measures, with rv_names """ d = n_mod_m(4, 2) d.set_rv_names('xyzw') ip = ShannonPartition(d) for meas in all_info_measures('xyzw'): yield assert_almost_equal, ip[meas], I(d, meas[0], meas[1])
def test_coi1(): """ Test I for xor """ d = n_mod_m(3, 2) assert I(d) == pytest.approx(-1.0) assert I(d, [[0], [1], [2]]) == pytest.approx(-1.0) assert I(d, [[0], [1], [2]], [2]) == pytest.approx(0.0) assert I(d, [[0], [1]], [2]) == pytest.approx(1.0)
def test_tse1(i, j): """ Test identity comparing TSE to B from Olbrich's talk """ d = n_mod_m(i, j) indices = [[k] for k in range(i)] tse = TSE(d) x = 1 / 2 * sum(B(d, rv) / nCk(i, len(rv)) for rv in powerset(indices)) assert tse == pytest.approx(x)
def test_tse1(): """ Test identity comparing TSE to B from Olbrich's talk """ for i, j in zip(range(3, 6), range(2, 5)): d = n_mod_m(i, j) indices = [[k] for k in range(i)] tse = TSE(d) x = 1/2 * sum(B(d, rv)/nCk(i, len(rv)) for rv in powerset(indices)) yield assert_almost_equal, tse, x
def test_dd2(): """ Test against known values. """ d = n_mod_m(3, 2) d.set_rv_names('XYZ') dd = DependencyDecomposition(d) assert dd[(('X', 'Y', 'Z'), )]['H'] == pytest.approx(2.0)
def test_dd2(): """ Test against known values. """ d = n_mod_m(3, 2) d.set_rv_names('XYZ') dd = DependencyDecomposition(d) assert dd[(('X', 'Y', 'Z'),)]['H'] == pytest.approx(2.0)
def test_dd3(): """ Test dependencies. """ d = n_mod_m(3, 2) dd = DependencyDecomposition(d) deps = dd.get_dependencies() true_deps = {'012', '01:02:12', '01:02', '01:12', '02:12', '01:2', '02:1', '12:0', '0:1:2'} assert deps == true_deps
def test_iimi1(): """ Test against known value. """ iimi = interactive_intrinsic_mutual_information(n_mod_m(3, 2), rvs=[[0], [1]], crvs=[2], rounds=1) assert iimi == pytest.approx(0.0)
def test_sp3(): """ Test get_atoms() """ d = n_mod_m(3, 2) ip = ShannonPartition(d) atoms1 = { 'H[0|1,2]', 'H[1|0,2]', 'H[2|0,1]', 'I[0:1:2]', 'I[0:1|2]', 'I[0:2|1]', 'I[1:2|0]' } atoms2 = ip.get_atoms() assert (atoms1 - atoms2) | (atoms2 - atoms1) == set()
def test_dd4(): """ Test dependencies. """ d = n_mod_m(3, 2) dd = DependencyDecomposition(d) deps = dd.get_dependencies(string=False) true_deps = {((0, 1, 2), ), ((0, 1), (0, 2), (1, 2)), ((0, 1), (0, 2)), ((0, 1), (1, 2)), ((0, 2), (1, 2)), ((0, 1), (2, )), ((0, 2), (1, )), ((1, 2), (0, )), ((0, ), (1, ), (2, ))} assert deps == true_deps
def test_sp3(): """ Test get_atoms() """ d = n_mod_m(3, 2) ip = ShannonPartition(d) atoms1 = set([ 'H[0|1,2]', 'H[1|0,2]', 'H[2|0,1]', 'I[0:1:2]', 'I[0:1|2]', 'I[0:2|1]', 'I[1:2|0]' ]) atoms2 = ip.get_atoms() assert_equal(atoms1 - atoms2, set()) assert_equal(atoms2 - atoms1, set())
def test_sp3(): """ Test get_atoms() """ d = n_mod_m(3, 2) ip = ShannonPartition(d) atoms1 = {'H[0|1,2]', 'H[1|0,2]', 'H[2|0,1]', 'I[0:1:2]', 'I[0:1|2]', 'I[0:2|1]', 'I[1:2|0]' } atoms2 = ip.get_atoms() assert (atoms1 - atoms2) | (atoms2 - atoms1) == set()
def test_sp3(): """ Test get_atoms() """ d = n_mod_m(3, 2) ip = ShannonPartition(d) atoms1 = set(['H[0|1,2]', 'H[1|0,2]', 'H[2|0,1]', 'I[0:1:2]', 'I[0:1|2]', 'I[0:2|1]', 'I[1:2|0]' ]) atoms2 = ip.get_atoms() assert_equal(atoms1 - atoms2, set()) assert_equal(atoms2 - atoms1, set())
def test_dd4(): """ Test dependencies. """ d = n_mod_m(3, 2) dd = DependencyDecomposition(d) deps = dd.get_dependencies(string=False) true_deps = {((0, 1, 2),), ((0, 1), (0, 2), (1, 2)), ((0, 1), (0, 2)), ((0, 1), (1, 2)), ((0, 2), (1, 2)), ((0, 1), (2,)), ((0, 2), (1,)), ((1, 2), (0,)), ((0,), (1,), (2,))} assert deps == true_deps
def test_sp4(): """ Test printing """ d = n_mod_m(3, 2) ip = ShannonPartition(d) string = """\ +----------+--------+ | measure | bits | +----------+--------+ | H[0|1,2] | 0.000 | | H[1|0,2] | 0.000 | | H[2|0,1] | 0.000 | | I[0:1|2] | 1.000 | | I[0:2|1] | 1.000 | | I[1:2|0] | 1.000 | | I[0:1:2] | -1.000 | +----------+--------+""" assert str(ip) == string
def test_ep1(): """ Test against known values. """ d = n_mod_m(3, 2) ep = ExtropyPartition(d) string = """\ +----------+--------+ | measure | exits | +----------+--------+ | X[0|1,2] | 0.000 | | X[1|0,2] | 0.000 | | X[2|0,1] | 0.000 | | X[0:1|2] | 0.245 | | X[0:2|1] | 0.245 | | X[1:2|0] | 0.245 | | X[0:1:2] | 0.510 | +----------+--------+""" assert str(ep) == string
def test_dd4(): """ Test dependencies. """ d = n_mod_m(3, 2) dd = DependencyDecomposition(d) deps = dd.get_dependencies(string=False) a = frozenset([0]) b = frozenset([1]) c = frozenset([2]) true_deps = {frozenset([a | b | c]), frozenset([a | b, a | c, b | c]), frozenset([a | b, a | c]), frozenset([a | b, b | c]), frozenset([a | c, b | c]), frozenset([a | b, c]), frozenset([a | c, b]), frozenset([b | c, a]), frozenset([a, b, c])} assert deps == true_deps
def test_dd1(): """ Test against known values. """ d = n_mod_m(3, 2) ep = DependencyDecomposition(d, measures={'B': B}) string = """\ +------------+--------+ | dependency | B | +------------+--------+ | 012 | 2.000 | | 01:02:12 | 0.000 | | 01:02 | 0.000 | | 01:12 | 0.000 | | 02:12 | 0.000 | | 01:2 | 0.000 | | 02:1 | 0.000 | | 12:0 | 0.000 | | 0:1:2 | 0.000 | +------------+--------+""" assert str(ep) == string
def test_n_mod_m2(): """ Test that m < 1 fails """ with pytest.raises(ValueError): n_mod_m(1, -1)
def test_n_mod_m1(): """ Test that n < 1 fails """ with pytest.raises(ValueError): n_mod_m(-1, 1)
def test_coi4(): """ Test conditional I, with and without names """ d = n_mod_m(4, 2) assert I(d, [[0], [1], [2]], [3]) == pytest.approx(-1.0) d.set_rv_names("XYZW") assert I(d, [['X'], ['Y'], ['Z']], ['W']) == pytest.approx(-1.0)
def test_tc5(): """ Test T with subvariables """ d = n_mod_m(4, 2) assert T(d, [[0, 1], [2], [3]]) == pytest.approx(1.0) d.set_rv_names("XYZW") assert T(d, [['X', 'Y'], ['Z'], ['W']]) == pytest.approx(1.0)
def test_tc2(): """ Test T of subvariables, with names """ d = n_mod_m(4, 2) assert T(d, [[0], [1], [2]]) == pytest.approx(0.0) d.set_rv_names("XYZW") assert T(d, [['X'], ['Y'], ['Z']]) == pytest.approx(0.0)
def test_n_mod_m5(n): """ Test that the interaction information is always 1 """ d = n_mod_m(n, 2) assert II(d) == pytest.approx(1.0)
def test_coi2(): """ Test I for larger parity distribution """ d = n_mod_m(4, 2) assert I(d) == pytest.approx(1.0)
def test_n_mod_m3(): """ Test that noninteger n failes """ with pytest.raises(ValueError): n_mod_m(3/2, 1)
def test_n_mod_m5(): """ Test that the interaction information is always 1 """ for n in range(3, 6): d = n_mod_m(n, 2) yield assert_almost_equal, II(d), 1.0
def test_coi3(): """ Test I for subsets of variables, with and without names """ d = n_mod_m(4, 2) assert I(d, [[0], [1], [2]]) == pytest.approx(0.0) d.set_rv_names("XYZW") assert I(d, [['X'], ['Y'], ['Z']]) == pytest.approx(0.0)
def test_n_mod_m3(): """ Test that noninteger n failes """ with pytest.raises(ValueError): n_mod_m(3 / 2, 1)
def test_n_mod_m4(): """ Test that noninteger m fails """ with pytest.raises(ValueError): n_mod_m(1, 3 / 2)
def test_tc6(): """ Test T with overlapping subvariables """ d = n_mod_m(4, 2) assert T(d, [[0, 1, 2], [1, 2, 3]]) == pytest.approx(3.0) d.set_rv_names("XYZW") assert T(d, [['X', 'Y', 'Z'], ['Y', 'Z', 'W']]) == pytest.approx(3.0)
def test_n_mod_m6(m): """ Test that II is the log of m """ d = n_mod_m(3, m) assert II(d) == pytest.approx(log2(m))
def test_tc1(n): """ Test T of parity distributions """ d = n_mod_m(n, 2) assert T(d) == pytest.approx(1.0)
def test_tc4(): """ Test conditional T """ d = n_mod_m(4, 2) assert T(d, [[0], [1]], [2, 3]) == pytest.approx(1.0) d.set_rv_names("XYZW") assert T(d, [['X'], ['Y']], ['Z', 'W']) == pytest.approx(1.0)
def test_GB(order, rvs, crvs, value): """ Tests for the generalized dual total correlation. """ d = n_mod_m(5, 2) assert GB(d, order=order, rvs=rvs, crvs=crvs) == pytest.approx(value)
def test_coi6(): """ Test conditional I, with and without names """ d = n_mod_m(4, 2) assert I(d, [[0]], [1, 2, 3]) == pytest.approx(0.0) d.set_rv_names("XYZW") assert I(d, [['X']], ['Y', 'Z', 'W']) == pytest.approx(0.0)
def test_n_mod_m6(): """ Test that II is the log of m """ for m in range(2, 5): d = n_mod_m(3, m) yield assert_almost_equal, II(d), log2(m)
def test_n_mod_m4(): """ Test that noninteger m fails """ with pytest.raises(ValueError): n_mod_m(1, 3/2)
def test_sp1(meas): """ Test all possible info measures """ d = n_mod_m(4, 2) ip = ShannonPartition(d) assert ip[meas] == pytest.approx(I(d, meas[0], meas[1]))
def test_sp2(meas): """ Test all possible info measures, with rv_names """ d = n_mod_m(4, 2) d.set_rv_names('xyzw') ip = ShannonPartition(d) assert ip[meas] == pytest.approx(I(d, meas[0], meas[1]))