コード例 #1
0
ファイル: table_product_test.py プロジェクト: rpazuki/algos
def test_product_with_single_column_table():
    single_table = Table({"A": 3, "B": 4, "C": 7}, names=["Y1"])
    table1 = Table(sample_1, names=["X1", "X2", "X3", "X4"])

    # without common names
    table3 = table1 * single_table
    assert all(compare(table3.names, ["X1", "X2", "X3", "X4", "Y1"]))

    # check probabilites
    assert table3[("a", "y", 2, 33, "B")] == 24

    table3 = single_table * table1
    assert all(compare(table3.names, ["Y1", "X1", "X2", "X3", "X4"]))

    # check probabilites
    assert table3[("B", "a", "y", 2, 33)] == 24

    # with common names
    single_table = Table({"x": 3, "y": 4}, names=["X2"])
    table1 = Table(sample_1, names=["X1", "X2", "X3", "X4"])

    table3 = table1 * single_table
    assert all(compare(table3.names, ["X1", "X2", "X3", "X4"]))

    # check probabilites
    assert table3["a", "x", 2, 44] == 12
    assert table3["a", "y", 2, 44] == 32

    table3 = single_table * table1
    assert all(compare(table3.names, ["X2", "X1", "X3", "X4"]))
コード例 #2
0
def test_product_with_frequency_table_discrete_distribution():
    freq_table1 = FrequencyTable({"A": 3, "B": 4, "C": 7}, name="Y1")
    dist1 = DiscreteDistribution(sample_1, names=["X1", "X2", "X3", "X4"])

    # without common names
    dist3 = dist1 * freq_table1
    assert all(compare(dist3.names, ["X1", "X2", "X3", "X4", "Y1"]))
    assert dist3.total == (dist1.total * freq_table1.total)

    # check probabilites
    assert dist3.frequency(("a", "y", 2, 33, "B")) == 6 * 4
    assert dist3.probability(("a", "y", 2, 33, "B")) == 24 / 1708
    assert dist3[("a", "y", 2, 33, "B")] == 24

    dist3 = freq_table1 * dist1
    assert all(compare(dist3.names, ["Y1", "X1", "X2", "X3", "X4"]))
    assert dist3.total == (dist1.total * freq_table1.total)

    # check probabilites
    assert dist3.frequency(("B", "a", "y", 2, 33)) == 6 * 4
    assert dist3.probability(("B", "a", "y", 2, 33)) == 24 / 1708
    assert dist3[("B", "a", "y", 2, 33)] == 24

    # with common names
    freq_table1 = FrequencyTable({"x": 3, "y": 4}, name="X2")
    dist1 = DiscreteDistribution(sample_1, names=["X1", "X2", "X3", "X4"])

    dist3 = dist1 * freq_table1
    assert all(compare(dist3.names, ["X1", "X2", "X3", "X4"]))
    assert dist3.total == 52 * 3 + 70 * 4

    dist3 = freq_table1 * dist1
    assert all(compare(dist3.names, ["X2", "X1", "X3", "X4"]))
    assert dist3.total == 52 * 3 + 70 * 4
コード例 #3
0
def test_conditional_on_table():

    table1 = Table(samples, names=["X1", "X2", "X3", "X4"])
    con_table1 = table1.condition_on("X2")
    assert all(compare(con_table1.names, ["X2"]))
    for x2 in con_table1.keys():
        child_table = con_table1[x2]
        assert all(compare(child_table.names, ["X1", "X3", "X4"]))

    child_table1 = con_table1["x"]
    child_table2 = con_table1["y"]
    assert child_table1["a", 1, 33] == 1 / 52
    assert child_table2["a", 1, 33] == 5 / 84
    assert child_table1["a", 1, 44] == 3 / 52
    assert child_table2["a", 1, 44] == 7 / 84
    assert child_table1["b", 1, 33] == 9 / 52
    assert child_table2["b", 1, 33] == 13 / 84
    assert child_table1["b", 1, 44] == 11 / 52
    assert child_table2["b", 1, 44] == 15 / 84
    assert child_table1["b", 2, 44] == 12 / 52
    assert child_table2["b", 2, 33] == 14 / 84

    # combined indexing
    assert con_table1["x"]["a", 1, 33] == 1 / 52
    assert con_table1["y"]["a", 1, 33] == 5 / 84
コード例 #4
0
def test_conditional_discrete_distribution():
    # Four levels dist.
    samples = {
        ("a", "x", 1, 33): 1,
        ("a", "x", 2, 33): 2,
        ("a", "x", 1, 44): 3,
        ("a", "x", 2, 44): 4,
        ("a", "y", 1, 33): 5,
        ("a", "y", 2, 33): 6,
        ("a", "y", 1, 44): 7,
        ("a", "y", 2, 44): 8,
        ("b", "x", 1, 33): 9,
        ("b", "x", 2, 33): 10,
        ("b", "x", 1, 44): 11,
        ("b", "x", 2, 44): 12,
        ("b", "y", 1, 33): 13,
        ("b", "y", 2, 33): 14,
        ("b", "y", 1, 44): 15,
        ("b", "y", 2, 44): 16,
    }
    disc_dist = DiscreteDistribution(samples)
    con_disc_dist = disc_dist.condition_on("X2")
    assert all(compare(con_disc_dist.conditional_rvs.names, ["X2"]))
    assert all(
        compare(con_disc_dist.distributions["x"].names, ["X1", "X3", "X4"]))
    assert all(
        compare(con_disc_dist.distributions["y"].names, ["X1", "X3", "X4"]))

    assert con_disc_dist.frequency(("a", 1, 33), "x") == 1
    assert con_disc_dist.frequency(("a", 1, 33), "y") == 5
    assert con_disc_dist.frequency(("a", 1, 44), "x") == 3
    assert con_disc_dist.frequency(("a", 1, 44), "y") == 7
    assert con_disc_dist.frequency(("b", 1, 33), "x") == 9
    assert con_disc_dist.frequency(("b", 1, 33), "y") == 13
    assert con_disc_dist.frequency(("b", 1, 44), "x") == 11
    assert con_disc_dist.frequency(("b", 1, 44), "y") == 15
    assert con_disc_dist.frequency(("b", 2, 44), "x") == 12
    assert con_disc_dist.frequency(("b", 2, 33), "y") == 14

    assert con_disc_dist.probability(("a", 1, 33), "x") == 1 / 52
    assert con_disc_dist.probability(("a", 1, 33), "y") == 5 / 84
    assert con_disc_dist.probability(("a", 1, 44), "x") == 3 / 52
    assert con_disc_dist.probability(("a", 1, 44), "y") == 7 / 84
    assert con_disc_dist.probability(("b", 1, 33), "x") == 9 / 52
    assert con_disc_dist.probability(("b", 1, 33), "y") == 13 / 84
    assert con_disc_dist.probability(("b", 1, 44), "x") == 11 / 52
    assert con_disc_dist.probability(("b", 1, 44), "y") == 15 / 84
    assert con_disc_dist.probability(("b", 2, 44), "x") == 12 / 52
    assert con_disc_dist.probability(("b", 2, 33), "y") == 14 / 84
コード例 #5
0
def test_marginals_operator_discrete_distribution():
    # Four levels dist.
    samples = {
        ("a", "x", 1, 33): 1,
        ("a", "x", 2, 33): 2,
        ("a", "x", 1, 44): 3,
        ("a", "x", 2, 44): 4,
        ("a", "y", 1, 33): 5,
        ("a", "y", 2, 33): 6,
        ("a", "y", 1, 44): 7,
        ("a", "y", 2, 44): 8,
        ("b", "x", 1, 33): 9,
        ("b", "x", 2, 33): 10,
        ("b", "x", 1, 44): 11,
        ("b", "x", 2, 44): 12,
        ("b", "y", 1, 33): 13,
        ("b", "y", 2, 33): 14,
        ("b", "y", 1, 44): 15,
        ("b", "y", 2, 44): 16,
    }
    disc_dist = DiscreteDistribution(samples)
    assert (disc_dist << "X2").total == disc_dist.total
    assert (disc_dist << ("X2", "X3")).total == disc_dist.total
    assert (disc_dist << ("X2", "X3", "X4")).total == disc_dist.total

    assert all(
        compare((disc_dist << ("X1", "X2", "X4")).keys_as_list(), [1, 2]))
    assert all(
        compare((disc_dist << ("X1", "X2", "X3")).keys_as_list(), [33, 44]))
    assert all(
        compare((disc_dist << ("X2", "X3", "X4")).keys_as_list(), ["a", "b"]))
    assert all(
        compare(
            (disc_dist << ("X2", "X3")).keys_as_list(),
            [("a", 33), ("a", 44), ("b", 33), ("b", 44)],
        ))

    disc_dist = DiscreteDistribution(samples,
                                     names=["Age", "Sex", "Education", "City"])
    assert (disc_dist << ("Age")).total == disc_dist.total
    assert (disc_dist << ("Sex", "Education")).total == disc_dist.total
    assert (disc_dist << ("Sex", "Education", "City")).total == disc_dist.total

    assert all(
        compare((disc_dist << ("Age", "Sex", "City")).keys_as_list(), [1, 2]))
    assert all(
        compare((disc_dist << ("Age", "Sex", "Education")).keys_as_list(),
                [33, 44]))
    assert all(
        compare((disc_dist << ("Sex", "Education", "City")).keys_as_list(),
                ["a", "b"]))
    assert all(
        compare(
            (disc_dist << ("Sex", "Education")).keys_as_list(),
            [("a", 33), ("a", 44), ("b", 33), ("b", 44)],
        ))
コード例 #6
0
def test_avg_discrete_distribution():
    samples = {
        (1, 1, 1): 1,
        (1, 1, 2): 1,
        (1, 1, 3): 1,
        (1, 2, 1): 2,
        (1, 2, 2): 2,
        (1, 2, 3): 2,
        (1, 3, 1): 3,
        (1, 3, 2): 3,
        (1, 3, 3): 3,
    }
    dist = DiscreteDistribution(samples)
    assert all(compare(dist.avg(), [1, (3 + 12 + 27) / 18, 2]))
    assert all(compare(dist.avg(indices=[0, 1, 2]), [1,
                                                     (3 + 12 + 27) / 18, 2]))
    assert all(compare(dist.avg(indices=[0, 2, 1]), [1, 2,
                                                     (3 + 12 + 27) / 18]))
    assert all(compare(dist.avg(indices=[0, 1]), [1, (3 + 12 + 27) / 18]))
    assert all(compare(dist.avg(indices=[0, 2]), [1, 2]))
    assert all(compare(dist.avg(indices=[2, 0]), [2, 1]))
    assert all(compare(dist.avg(indices=[1, 2]), [(3 + 12 + 27) / 18, 2]))
    assert dist.avg(indices=[0]) == 1
    assert dist.std(indices=[0]) == 0
    assert dist.avg(indices=[1]) == (3 + 12 + 27) / 18
    assert dist.std(indices=[1]) == approx(0.55555555555556)
    assert dist.avg(indices=[2]) == 2
    assert dist.std(indices=[2]) == approx(0.66666666666667)
コード例 #7
0
ファイル: exceptions_tests.py プロジェクト: virtusize/nap
def test_nap_exception():
    ne = NapException()
    compare(str(ne), u"{'message': 'NapException'}")

    ne = NapException('A nice message')
    compare(str(ne), u"{'message': 'A nice message'}")

    ne = NapException('A nice message', some='some123', values='values321')
    compare(str(ne), u"{'some': 'some123', 'message': 'A nice message', 'values': 'values321'}")

    compare(ne.to_dict(), {'some': 'some123', 'message': 'A nice message', 'values': 'values321'})
コード例 #8
0
def test_one_levels_discrete_distribution():
    dist = DiscreteDistribution({"Dog": 2})
    assert all(compare(dist.keys_as_list(), ["Dog"]))
    assert dist.rvs.size == 1
    assert dist["Dog"] == 2
    assert dist["Cat"] == 0
    assert all(compare(dist.frequencies(normalised=True), [1]))
    assert all(compare(dist.frequencies(normalised=False), [2]))
    assert dist.prob("Dog") == 1
    assert dist.prob(X1="Dog") == 1

    dist = DiscreteDistribution({"Dog": 2, "Cat": 3})
    assert all(compare(dist.keys_as_list(), ["Dog", "Cat"]))
    assert dist.rvs.size == 1
    assert dist["Dog"] == 2
    assert dist["Cat"] == 3
    assert dist["Dolphin"] == 0
    assert all(compare(dist.frequencies(normalised=True), [2 / 5, 3 / 5]))
    assert all(compare(dist.frequencies(normalised=False), [2, 3]))
    assert dist.prob("Dog") == 2 / 5
    assert dist.prob(X1="Dog") == 2 / 5
    assert dist.prob("Cat") == 3 / 5
    assert dist.prob(X1="Cat") == 3 / 5
    assert dist.prob("Dolphin") == 0
    assert dist.prob(X1="Dolphin") == 0

    dist = DiscreteDistribution({"Dog": 2, "Cat": 3, "Dolphin": 4})
    assert all(compare(dist.keys_as_list(), ["Dog", "Cat", "Dolphin"]))
    assert dist.rvs.size == 1
    assert dist["Dog"] == 2
    assert dist["Cat"] == 3
    assert dist["Dolphin"] == 4
    assert dist["Tiger"] == 0
    assert all(
        compare(dist.frequencies(normalised=True), [2 / 9, 3 / 9, 4 / 9]))
    assert all(compare(dist.frequencies(normalised=False), [2, 3, 4]))
    assert dist.prob("Dog") == 2 / 9
    assert dist.prob(X1="Dog") == 2 / 9
    assert dist.prob("Cat") == 3 / 9
    assert dist.prob(X1="Cat") == 3 / 9
    assert dist.prob("Dolphin") == 4 / 9
    assert dist.prob(X1="Dolphin") == 4 / 9
    assert dist.prob("Tiger") == 0
    assert dist.prob(X1="Tiger") == 0
コード例 #9
0
ファイル: table_reduce_test.py プロジェクト: rpazuki/algos
def test_reduce_by_name_on_conditioned_table():

    table = Table(samples, names=["X1", "X2", "X3", "X4"])
    con_1 = table.condition_on("X1")
    reduced_table = con_1.reduce(X2="y")
    assert reduced_table.columns.size == 1
    assert all(compare(reduced_table.columns.children_names, ["X3", "X4"]))
    assert reduced_table["a"][1, 33] == 5 / 36
    assert reduced_table["b"][(2, 44)] == 16 / 100

    reduced_table = con_1.reduce(X2="y", X3=1)
    assert reduced_table.columns.size == 1
    assert all(compare(reduced_table.columns.children_names, ["X4"]))
    assert reduced_table["a"][33] == 5 / 36
    assert reduced_table["b"][44] == 15 / 100

    con_1 = table.condition_on("X1", "X3")
    reduced_table = con_1.reduce(X2="y")
    assert reduced_table.columns.size == 2
    assert all(compare(reduced_table.columns.children_names, ["X4"]))
    assert reduced_table["a", 1][33] == 5 / 16
    assert reduced_table["b", 2][44] == 16 / 52
コード例 #10
0
ファイル: table_product_test.py プロジェクト: rpazuki/algos
def test_product_with_two_common_vars_table():
    table1 = Table(sample_1, names=["X1", "X2", "X3", "X4"])
    table2 = Table(sample_2, names=["X3", "X5", "X6", "X2"])

    table3 = table1 * table2
    assert all(compare(table3.names, ["X1", "X2", "X3", "X4", "X5", "X6"]))

    # check probabilites
    assert table3[("a", "y", 2, 33, "high", "under")] == 150
    # check the case that the right does not have the common
    assert table3[("a", "y", 2, 33, "low", "under")] is None
    # check the case that the left does not have the common
    assert table3[("b", "y", 2, 33, "high", "under")] is None
コード例 #11
0
ファイル: table_product_test.py プロジェクト: rpazuki/algos
def test_product_with_no_common_vars_table():

    table1 = Table(sample_1, names=["X1", "X2", "X3", "X4"])
    table2 = Table(sample_2, names=["Y1", "Y2", "Y3", "Y4"])

    table3 = table1 * table2
    assert all(
        compare(table3.names,
                ["X1", "X2", "X3", "X4", "Y1", "Y2", "Y3", "Y4"]))

    # check probabilites
    assert table3[("a", "x", 1, 33, 2, "high", "normal", "x")] == 10

    assert table3[("b", "x", 1, 44, 1, "low", "over", "y")] == 253
コード例 #12
0
def test_conditional_operator_discrete_distribution():
    # Four levels dist.
    samples = {
        ("a", "x", 1, 33): 1,
        ("a", "x", 2, 33): 2,
        ("a", "x", 1, 44): 3,
        ("a", "x", 2, 44): 4,
        ("a", "y", 1, 33): 5,
        ("a", "y", 2, 33): 6,
        ("a", "y", 1, 44): 7,
        ("a", "y", 2, 44): 8,
        ("b", "x", 1, 33): 9,
        ("b", "x", 2, 33): 10,
        ("b", "x", 1, 44): 11,
        ("b", "x", 2, 44): 12,
        ("b", "y", 1, 33): 13,
        ("b", "y", 2, 33): 14,
        ("b", "y", 1, 44): 15,
        ("b", "y", 2, 44): 16,
    }
    disc_dist = DiscreteDistribution(samples)
    con_disc_dist = disc_dist | "X2"
    assert all(compare(con_disc_dist.conditional_rvs.names, ["X2"]))
    assert all(
        compare(con_disc_dist.distributions["x"].names, ["X1", "X3", "X4"]))
    assert all(
        compare(con_disc_dist.distributions["y"].names, ["X1", "X3", "X4"]))

    assert con_disc_dist.frequency(("a", 1, 33), "x") == 1
    assert con_disc_dist.frequency(("a", 1, 33), "y") == 5

    assert con_disc_dist.probability(("a", 1, 33), "x") == 1 / 52
    assert con_disc_dist.probability(("a", 1, 33), "y") == 5 / 84

    con_disc_dist = disc_dist | ("X2", "X3")
    assert all(compare(con_disc_dist.conditional_rvs.names, ["X2", "X3"]))
    assert all(
        compare(con_disc_dist.distributions[("x", 1)].names, ["X1", "X4"]))
    assert all(
        compare(con_disc_dist.distributions[("x", 2)].names, ["X1", "X4"]))
    assert all(
        compare(con_disc_dist.distributions[("y", 1)].names, ["X1", "X4"]))
    assert all(
        compare(con_disc_dist.distributions[("y", 2)].names, ["X1", "X4"]))
    assert con_disc_dist.frequency(("a", 33), ("x", 1)) == 1
    assert con_disc_dist.probability(("a", 33), ("x", 1)) == 1 / 24
コード例 #13
0
ファイル: table_product_test.py プロジェクト: rpazuki/algos
def test_product_with_one_common_var_table():

    table1 = Table(sample_1, names=["X1", "X2", "X3", "X4"])
    table2 = Table(sample_2, names=["X3", "X5", "X6", "X7"])

    table3 = table1 * table2
    assert all(
        compare(table3.names, ["X1", "X2", "X3", "X4", "X5", "X6", "X7"]))

    # check probabilites
    assert table3["a", "x", 1, 33, "high", "normal", "x"] == 2
    # check the case that the right does not have the common
    assert table3[("b", "y", 2, 44, "high", "over", "y")] is None
    # check the case that the left does not have the common
    assert table3[("b", "y", 2, 33, "high", "normal", "y")] is None
コード例 #14
0
def test_product_with_two_common_vars_discrete_distribution():
    dist1 = DiscreteDistribution(sample_1, names=["X1", "X2", "X3", "X4"])
    dist2 = DiscreteDistribution(sample_2, names=["X3", "X5", "X6", "X2"])

    dist3 = dist1 * dist2
    assert all(compare(dist3.names, ["X1", "X2", "X3", "X4", "X5", "X6"]))
    assert dist3.total == 24 * 36 + 28 * 100 + 40 * 164 + 30 * 51

    # check probabilites
    assert dist3.frequency(("a", "y", 2, 33, "high", "under")) == 6 * 25
    assert dist3.probability(("a", "y", 2, 33, "high", "under")) == 150 / 11754
    assert dist3[("a", "y", 2, 33, "high", "under")] == 150
    # check the case that the right does not have the common
    assert dist3.frequency(("a", "y", 2, 33, "low", "under")) == 0
    assert dist3.probability(("a", "y", 2, 33, "low", "under")) == 0
    assert dist3[("a", "y", 2, 33, "low", "under")] == 0
    # check the case that the left does not have the common
    assert dist3.frequency(("b", "y", 2, 33, "high", "under")) == 0
    assert dist3.probability(("b", "y", 2, 33, "high", "under")) == 0
    assert dist3[("b", "y", 2, 33, "high", "under")] == 0
コード例 #15
0
def test_product_with_no_common_vars_discrete_distribution():

    dist1 = DiscreteDistribution(sample_1, names=["X1", "X2", "X3", "X4"])
    dist2 = DiscreteDistribution(sample_2, names=["Y1", "Y2", "Y3", "Y4"])

    dist3 = dist1 * dist2
    assert all(
        compare(dist3.names, ["X1", "X2", "X3", "X4", "Y1", "Y2", "Y3", "Y4"]))
    assert dist3.total == (dist1.total * dist2.total)

    # check probabilites
    assert dist3.frequency(("a", "x", 1, 33, 2, "high", "under", "x")) == 9
    assert dist3.probability(
        ("a", "x", 1, 33, 2, "high", "normal", "x")) == 10 / 42822
    assert dist3[("a", "x", 1, 33, 2, "high", "normal", "x")] == 10

    assert dist3.frequency(("b", "x", 1, 44, 1, "low", "over", "y")) == 253
    assert dist3.probability(
        ("b", "x", 1, 44, 1, "low", "over", "y")) == 253 / 42822
    assert dist3[("b", "x", 1, 44, 1, "low", "over", "y")] == 253
コード例 #16
0
def test_product_with_one_common_var_discrete_distribution():

    dist1 = DiscreteDistribution(sample_1, names=["X1", "X2", "X3", "X4"])
    dist2 = DiscreteDistribution(sample_2, names=["X3", "X5", "X6", "X7"])

    dist3 = dist1 * dist2
    assert all(compare(dist3.names,
                       ["X1", "X2", "X3", "X4", "X5", "X6", "X7"]))
    assert dist3.total == (36 + 164) * 64 + (100 + 51) * 58

    # check probabilites
    assert dist3.frequency(("a", "x", 1, 33, "high", "normal", "x")) == 2
    assert dist3.probability(
        ("a", "x", 1, 33, "high", "normal", "x")) == 2 / 21558
    assert dist3[("a", "x", 1, 33, "high", "normal", "x")] == 2
    # check the case that the right does not have the common
    assert dist3.frequency(("b", "y", 2, 44, "high", "over", "y")) == 0
    assert dist3.probability(("b", "y", 2, 44, "high", "over", "y")) == 0
    assert dist3[("b", "y", 2, 44, "high", "over", "y")] == 0
    # check the case that the left does not have the common
    assert dist3.frequency(("b", "y", 2, 33, "high", "normal", "y")) == 0
    assert dist3.probability(("b", "y", 2, 33, "high", "normal", "y")) == 0
    assert dist3[("b", "y", 2, 33, "high", "normal", "y")] == 0
コード例 #17
0
ファイル: table_reduce_test.py プロジェクト: rpazuki/algos
def test_reduce_by_name_table():

    table = Table(samples)
    reduced_table = table.reduce(X2="y")
    assert reduced_table.columns.size == 3
    assert all(compare(reduced_table.names, ["X1", "X3", "X4"]))
    assert reduced_table[("a", 1, 33)] == 5
    assert reduced_table[("b", 2, 44)] == 16

    reduced_table = table.reduce(X2="y", X3=1)
    assert reduced_table.columns.size == 2
    assert all(compare(reduced_table.names, ["X1", "X4"]))
    assert reduced_table[("a", 33)] == 5
    assert reduced_table[("b", 44)] == 15

    reduced_table = table.reduce(X1="b", X3=1, X4=44)
    assert reduced_table.columns.size == 1
    assert all(compare(reduced_table.names, ["X2"]))
    assert reduced_table["x"] == 11
    assert reduced_table["y"] == 15

    table = Table(samples, names=["Y", "Z", "W", "X"])

    reduced_table = table.reduce(Z="y")
    assert reduced_table.columns.size == 3
    assert all(compare(reduced_table.names, ["Y", "W", "X"]))
    assert reduced_table[("a", 1, 33)] == 5
    assert reduced_table[("b", 2, 44)] == 16

    reduced_table = table.reduce(Z="y", W=1)
    assert reduced_table.columns.size == 2
    assert all(compare(reduced_table.names, ["Y", "X"]))
    assert reduced_table[("a", 33)] == 5
    assert reduced_table[("b", 44)] == 15

    reduced_table = table.reduce(Y="b", W=1, X=44)
    assert reduced_table.columns.size == 1
    assert all(compare(reduced_table.names, ["Z"]))
    assert reduced_table["x"] == 11
    assert reduced_table["y"] == 15
コード例 #18
0
ファイル: exceptions_tests.py プロジェクト: virtusize/nap
def test_unauthorized_exception():
    ne = UnauthorizedException(model_name='User')
    compare(str(ne), u"{'message': 'Unauthorized.', 'model_name': 'User'}")
コード例 #19
0
ファイル: exceptions_tests.py プロジェクト: virtusize/nap
def test_model_invalid_exception():
    ne = ModelInvalidException(model_name='User', errors=['Field missing'])
    compare(str(ne), u"{'message': 'Model is invalid.', 'errors': ['Field missing'], 'model_name': 'User'}")
コード例 #20
0
ファイル: exceptions_tests.py プロジェクト: virtusize/nap
def test_model_not_found_exception():
    ne = ModelNotFoundException(model_name='User', model_id=1)
    compare(str(ne), u"{'model_id': 1, 'message': 'Model not found.', 'model_name': 'User'}")
コード例 #21
0
def test_marginals_names_discrete_distribution():
    samples = {("a", "x"): 4, ("a", "y"): 4, ("b", "x"): 6, ("b", "y"): 6}
    disc_dist = DiscreteDistribution(samples)

    disc_dist2 = disc_dist.marginal("X1")
    assert all(compare(disc_dist2.names, ["X2"]))

    disc_dist2 = disc_dist.marginal("X2")
    assert all(compare(disc_dist2.names, ["X1"]))
    #
    disc_dist = DiscreteDistribution(samples, names=["Y", "Z"])

    disc_dist2 = disc_dist.marginal("Y")
    assert all(compare(disc_dist2.names, ["Z"]))

    disc_dist2 = disc_dist.marginal("Z")
    assert all(compare(disc_dist2.names, ["Y"]))

    # Three levels dist.
    samples = {
        ("a", "x", 1): 4,
        ("a", "x", 2): 4,
        ("a", "y", 1): 6,
        ("a", "y", 2): 6,
        ("b", "x", 1): 8,
        ("b", "x", 2): 8,
        ("b", "y", 1): 10,
        ("b", "y", 2): 10,
    }

    disc_dist = DiscreteDistribution(samples)

    disc_dist2 = disc_dist.marginal("X1")
    assert all(compare(disc_dist2.names, ["X2", "X3"]))

    disc_dist2 = disc_dist.marginal("X2")
    assert all(compare(disc_dist2.names, ["X1", "X3"]))

    disc_dist2 = disc_dist.marginal("X3")
    assert all(compare(disc_dist2.names, ["X1", "X2"]))

    disc_dist2 = disc_dist.marginal("X1", "X3")
    assert all(compare(disc_dist2.names, ["X2"]))

    disc_dist2 = disc_dist.marginal("X2", "X3")
    assert all(compare(disc_dist2.names, ["X1"]))

    #
    disc_dist = DiscreteDistribution(samples, names=["Y", "Z", "W"])

    disc_dist2 = disc_dist.marginal("Y")
    assert all(compare(disc_dist2.names, ["Z", "W"]))

    disc_dist2 = disc_dist.marginal("Z")
    assert all(compare(disc_dist2.names, ["Y", "W"]))

    disc_dist2 = disc_dist.marginal("W")
    assert all(compare(disc_dist2.names, ["Y", "Z"]))

    disc_dist2 = disc_dist.marginal("Y", "W")
    assert all(compare(disc_dist2.names, ["Z"]))

    disc_dist2 = disc_dist.marginal("Z", "W")
    assert all(compare(disc_dist2.names, ["Y"]))
コード例 #22
0
ファイル: table_product_test.py プロジェクト: rpazuki/algos
def test_product_with_table_of_table_with_no_common_table():
    table1 = Table(sample_1, names=["X1", "X2", "X3", "X4"])
    table2 = Table({"one": 1, "two": 2, "three": 3}, names=["X1"])
    con_1 = table1.condition_on("X1")
    # P(X2, X3, X4 | X1) * P(X1) -> P(X2, X3, X4, X1)
    product_1 = con_1 * table2
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X2", "X3", "X4", "X1"]))
    # P(X1) * P(X2, X3, X4 | X1) -> P(X1, X2, X3, X4)
    product_1 = table2 * con_1
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X1", "X2", "X3", "X4"]))

    table2 = Table({
        ("one", "x"): 1,
        ("two", "x"): 2,
        ("three", "y"): 3
    },
                   names=["X1", "X2"])

    con_1 = table1.condition_on("X1", "X2")
    # P(X3, X4 | X1, X2) * P(X1, X2) -> P(X3, X4 , X1, X2)
    product_1 = con_1 * table2
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X3", "X4", "X1", "X2"]))
    # P(X1, X2) * P(X3, X4 | X1, X2) -> P( X1, X2, X3, X4)
    product_1 = table2 * con_1
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X1", "X2", "X3", "X4"]))

    con_2 = table2.condition_on("X1")
    # P(X3, X4 | X1, X2) * P(X2 | X1) -> P(X3, X4, X2 | X1)
    product_1 = con_1 * con_2
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X1"]))
    assert all(compare(product_1.columns.children_names, ["X3", "X4", "X2"]))
    # P(X2 | X1) * P(X3, X4 | X1, X2) -> P(X2, X3, X4 | X1)
    product_1 = con_2 * con_1
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X1"]))
    assert all(compare(product_1.columns.children_names, ["X2", "X3", "X4"]))

    table3 = Table(
        {
            ("one", "x", 1): 1,
            ("two", "x", 1): 2,
            ("three", "y", 2): 3
        },
        names=["X1", "X2", "X3"],
    )

    con_1 = table1.condition_on("X1", "X2", "X3")
    # P(X4 | X1, X2, X3) * P(X1, X2, X3) -> P(X4, X1, X2, X3)
    product_1 = con_1 * table3
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X4", "X1", "X2", "X3"]))
    # P(X1, X2) * P(X3, X4 | X1, X2) -> P( X1, X2, X3, X4)
    product_1 = table3 * con_1
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X1", "X2", "X3", "X4"]))

    con_2 = table3.condition_on("X1")
    # P(X4 | X1, X2, X3) * P(X2, X3 | X1) -> P(X4, X2, X3 | X1)
    product_1 = con_1 * con_2
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X1"]))
    assert all(compare(product_1.columns.children_names, ["X4", "X2", "X3"]))
    # P(X2, X3 | X1) * P(X4 | X1, X2, X3) -> P(X2, X3, X4 | X1)
    product_1 = con_2 * con_1
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X1"]))
    assert all(compare(product_1.columns.children_names, ["X2", "X3", "X4"]))

    con_2 = table3.condition_on("X1", "X2")
    # P(X4 | X1, X2, X3) * P(X3 | X1, X2) -> P(X4, X3 | X1, X2)
    product_1 = con_1 * con_2
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X1", "X2"]))
    assert all(compare(product_1.columns.children_names, ["X4", "X3"]))
    # P(X3 | X1, X2) * P(X4 | X1, X2, X3) -> P(X3, X4 | X1, X2)
    product_1 = con_2 * con_1
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X1", "X2"]))
    assert all(compare(product_1.columns.children_names, ["X3", "X4"]))

    con_2 = table3.condition_on("X2", "X3")
    # P(X4 | X1, X2, X3) * P(X1 | X2, X3) -> P(X4, X1 | X2, X3)
    product_1 = con_1 * con_2
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X2", "X3"]))
    assert all(compare(product_1.columns.children_names, ["X4", "X1"]))
    # P(X1 | X2, X3) * P(X4 | X1, X2, X3) -> P(X1, X4 | X2, X3)
    product_1 = con_2 * con_1
    assert len(product_1) == 0
    assert all(compare(product_1.names, ["X2", "X3"]))
    assert all(compare(product_1.columns.children_names, ["X1", "X4"]))
コード例 #23
0
def test_marginals_names_table():
    samples = {("a", "x"): 4, ("a", "y"): 4, ("b", "x"): 6, ("b", "y"): 6}
    table = Table(samples)

    table2 = table.marginal("X1")
    assert all(compare(table2.names, ["X2"]))

    table2 = table.marginal("X2")
    assert all(compare(table2.names, ["X1"]))
    #
    table = Table(samples, names=["Y", "Z"])

    table2 = table.marginal("Y")
    assert all(compare(table2.names, ["Z"]))

    table2 = table.marginal("Z")
    assert all(compare(table2.names, ["Y"]))

    # Three levels dist.
    samples = {
        ("a", "x", 1): 4,
        ("a", "x", 2): 4,
        ("a", "y", 1): 6,
        ("a", "y", 2): 6,
        ("b", "x", 1): 8,
        ("b", "x", 2): 8,
        ("b", "y", 1): 10,
        ("b", "y", 2): 10,
    }

    table = Table(samples)

    table2 = table.marginal("X1")
    assert all(compare(table2.names, ["X2", "X3"]))

    table2 = table.marginal("X2")
    assert all(compare(table2.names, ["X1", "X3"]))

    table2 = table.marginal("X3")
    assert all(compare(table2.names, ["X1", "X2"]))

    table2 = table.marginal("X1", "X3")
    assert all(compare(table2.names, ["X2"]))

    table2 = table.marginal("X2", "X3")
    assert all(compare(table2.names, ["X1"]))

    #
    table = Table(samples, names=["Y", "Z", "W"])

    table2 = table.marginal("Y")
    assert all(compare(table2.names, ["Z", "W"]))

    table2 = table.marginal("Z")
    assert all(compare(table2.names, ["Y", "W"]))

    table2 = table.marginal("W")
    assert all(compare(table2.names, ["Y", "Z"]))

    table2 = table.marginal("Y", "W")
    assert all(compare(table2.names, ["Z"]))

    table2 = table.marginal("Z", "W")
    assert all(compare(table2.names, ["Y"]))
コード例 #24
0
def test_marginal_if_table_of_table():
    sample_1 = {
        ("a", "x", 1, 33): 1,
        ("a", "x", 2, 33): 2,
        ("a", "x", 1, 44): 3,
        ("a", "x", 2, 44): 4,
        ("a", "y", 1, 33): 5,
        ("a", "y", 2, 33): 6,
        ("a", "y", 1, 44): 7,
        ("a", "y", 2, 44): 8,
        ("b", "x", 1, 33): 9,
        ("b", "x", 2, 33): 10,
        ("b", "x", 1, 44): 11,
        ("b", "x", 2, 44): 12,
        ("b", "y", 1, 33): 13,
        # ("b", "y", 2, 33): 14,
        ("b", "y", 1, 44): 15,
        ("b", "y", 2, 44): 16,
    }

    table1 = Table(sample_1, names=["X1", "X2", "X3", "X4"])
    con_1 = table1.condition_on("X1")
    with pytest.raises(ValueError):
        con_1.marginal("X1")

    marginal_1 = con_1.marginal("X2")
    assert all(compare(marginal_1.names, ["X1"]))
    assert all(compare(marginal_1.children_names, ["X3", "X4"]))
    assert marginal_1["a"][1, 33] == approx((1 + 5) / 36)
    assert marginal_1["a"][1, 44] == approx((3 + 7) / 36)
    assert marginal_1["a"][2, 33] == approx((2 + 6) / 36)
    assert marginal_1["a"][2, 44] == approx((4 + 8) / 36)
    assert marginal_1["b"][1, 33] == approx((9 + 13) / 86)
    assert marginal_1["b"][1, 44] == approx((11 + 15) / 86)

    con_1 = table1.condition_on("X1", normalise=False)
    marginal_1 = con_1.marginal("X2", normalise=False)
    assert marginal_1["a"][1, 33] == (1 + 5)
    assert marginal_1["a"][1, 44] == (3 + 7)
    assert marginal_1["a"][2, 33] == (2 + 6)
    assert marginal_1["a"][2, 44] == (4 + 8)
    assert marginal_1["b"][1, 33] == (9 + 13)
    assert marginal_1["b"][1, 44] == (11 + 15)

    marginal_1 = con_1.marginal("X2", "X3")
    assert all(compare(marginal_1.names, ["X1"]))
    assert all(compare(marginal_1.children_names, ["X4"]))
    assert marginal_1["a"][33] == approx((1 + 5 + 2 + 6) / 36)
    assert marginal_1["a"][44] == approx((3 + 7 + 4 + 8) / 36)
    assert marginal_1["b"][33] == approx((9 + 10 + 13) / 86)
    assert marginal_1["b"][44] == approx((11 + 12 + 15 + 16) / 86)

    marginal_1 = con_1.marginal("X2", "X4")
    assert all(compare(marginal_1.names, ["X1"]))
    assert all(compare(marginal_1.children_names, ["X3"]))
    assert marginal_1["a"][1] == approx((1 + 3 + 5 + 7) / 36)
    assert marginal_1["a"][2] == approx((2 + 4 + 6 + 8) / 36)
    assert marginal_1["b"][1] == approx((9 + 11 + 13 + 15) / 86)
    assert marginal_1["b"][2] == approx((10 + 12 + 16) / 86)

    con_2 = table1.condition_on("X1", "X3")
    with pytest.raises(ValueError):
        con_2.marginal("X1")

    with pytest.raises(ValueError):
        con_2.marginal("X3")

    with pytest.raises(ValueError):
        con_2.marginal("X2", "X4")

    marginal_2 = con_2.marginal("X2")
    assert all(compare(marginal_2.names, ["X1", "X3"]))
    assert all(compare(marginal_2.children_names, ["X4"]))
    assert marginal_2["a", 1][33] == approx((1 + 5) / 16)
    assert marginal_2["a", 1][44] == approx((3 + 7) / 16)
    assert marginal_2["a", 2][44] == approx((4 + 8) / 20)
    assert marginal_2["b", 1][33] == approx((9 + 13) / 48)
    assert marginal_2["b", 2][33] == approx(10 / 38)
    assert marginal_2["b", 2][44] == approx((12 + 16) / 38)

    con_3 = table1.condition_on("X1", "X3", "X4")
    with pytest.raises(ValueError):
        con_3.marginal("X2")
コード例 #25
0
def test_marginal_by_name_table():
    # Four levels dist.
    samples = {
        ("a", "x", 1, 33): 1,
        ("a", "x", 2, 33): 2,
        ("a", "x", 1, 44): 3,
        ("a", "x", 2, 44): 4,
        ("a", "y", 1, 33): 5,
        ("a", "y", 2, 33): 6,
        ("a", "y", 1, 44): 7,
        ("a", "y", 2, 44): 8,
        ("b", "x", 1, 33): 9,
        ("b", "x", 2, 33): 10,
        ("b", "x", 1, 44): 11,
        ("b", "x", 2, 44): 12,
        ("b", "y", 1, 33): 13,
        ("b", "y", 2, 33): 14,
        ("b", "y", 1, 44): 15,
        ("b", "y", 2, 44): 16,
    }
    table = Table(samples, names=["Age", "Sex", "Edu", "Etn"])
    table2 = table.marginal("Edu")
    assert all(
        compare(
            table2.keys(),
            [
                ("a", "x", 33),
                ("a", "x", 44),
                ("a", "y", 33),
                ("a", "y", 44),
                ("b", "x", 33),
                ("b", "x", 44),
                ("b", "y", 33),
                ("b", "y", 44),
            ],
        ))
    assert table2[("a", "x", 33)] == 3 / 136
    assert table2[("a", "x", 44)] == 7 / 136
    assert table2[("a", "y", 33)] == 11 / 136
    assert table2[("a", "y", 44)] == 15 / 136
    assert table2[("b", "x", 33)] == 19 / 136
    assert table2[("b", "x", 44)] == 23 / 136
    assert table2[("b", "y", 33)] == 27 / 136
    assert table2[("b", "y", 44)] == 31 / 136

    table2 = table.marginal("Edu", normalise=False)
    assert table2[("a", "x", 33)] == 3
    assert table2[("a", "x", 44)] == 7
    assert table2[("a", "y", 33)] == 11
    assert table2[("a", "y", 44)] == 15
    assert table2[("b", "x", 33)] == 19
    assert table2[("b", "x", 44)] == 23
    assert table2[("b", "y", 33)] == 27
    assert table2[("b", "y", 44)] == 31

    table2 = table.marginal("Etn")
    assert all(
        compare(
            table2.keys(),
            [
                ("a", "x", 1),
                ("a", "x", 2),
                ("a", "y", 1),
                ("a", "y", 2),
                ("b", "x", 1),
                ("b", "x", 2),
                ("b", "y", 1),
                ("b", "y", 2),
            ],
        ))
    assert table2[("a", "x", 1)] == 4 / 136
    assert table2[("a", "x", 2)] == 6 / 136
    assert table2[("a", "y", 1)] == 12 / 136
    assert table2[("a", "y", 2)] == 14 / 136
    assert table2[("b", "x", 1)] == 20 / 136
    assert table2[("b", "x", 2)] == 22 / 136
    assert table2[("b", "y", 1)] == 28 / 136
    assert table2[("b", "y", 2)] == 30 / 136

    table2 = table.marginal("Age", "Etn")
    assert all(compare(table2.keys(), [("x", 1), ("x", 2), ("y", 1),
                                       ("y", 2)]))
    assert table2[("x", 1)] == 24 / 136
    assert table2[("x", 2)] == 28 / 136
    assert table2[("y", 1)] == 40 / 136
    assert table2[("y", 2)] == 44 / 136

    table2 = table.marginal("Age", "Sex", "Etn")
    assert all(compare(table2.keys(), [(1, ), (2, )]))
    assert table2[1] == 64 / 136
    assert table2[2] == 72 / 136

    # marginalize two times
    table2 = table.marginal("Age", "Etn")
    table3 = table2.marginal("Sex")
    assert all(compare(table3.keys(), [(1, ), (2, )]))
    assert table3[1] == 64 / 136
    assert table3[2] == 72 / 136

    # marginalize three times
    table2 = table.marginal("Etn")
    table3 = table2.marginal("Edu")
    table4 = table3.marginal("Sex")
    assert all(compare(table4.keys(), [("a", ), ("b", )]))
    assert table4["a"] == 36 / 136
    assert table4["b"] == 100 / 136
コード例 #26
0
def test_marginals_table():
    # Single RV dist.
    with pytest.raises(ValueError):
        table = Table({"A": 2, "B": 3, "C": 4})
        table.marginal("X1")

    # Two levels dist.
    samples = {(1, 1): 4, (1, 2): 4, (2, 1): 6, (2, 2): 6}
    table = Table(samples)
    table2 = table.marginal("X1")
    assert all(compare(table2.keys(), [(1, ), (2, )]))
    assert table2[1] == 10 / 20
    assert table2[2] == 10 / 20

    table2 = table.marginal("X2")
    assert all(compare(table2.keys(), [(1, ), (2, )]))
    assert table2[1] == 8 / 20
    assert table2[2] == 12 / 20

    samples = {("a", "x"): 4, ("a", "y"): 4, ("b", "x"): 6, ("b", "y"): 6}
    table = Table(samples)
    table2 = table.marginal("X1")
    assert all(compare(table2.keys(), [("x", ), ("y", )]))
    assert table2["x"] == 10 / 20
    assert table2["y"] == 10 / 20

    table2 = table.marginal("X1")
    assert all(compare(table2.keys(), [("x", ), ("y", )]))
    assert table2["x"] == 10 / 20
    assert table2["y"] == 10 / 20

    table2 = table.marginal("X2")
    assert all(compare(table2.keys(), [("a", ), ("b", )]))
    assert table2["a"] == 8 / 20
    assert table2["b"] == 12 / 20

    # Three levels dist.
    samples = {
        ("a", "x", 1): 4,
        ("a", "x", 2): 4,
        ("a", "y", 1): 6,
        ("a", "y", 2): 6,
        ("b", "x", 1): 8,
        ("b", "x", 2): 8,
        ("b", "y", 1): 10,
        ("b", "y", 2): 10,
    }
    table = Table(samples)
    table2 = table.marginal("X1")
    assert all(compare(table2.keys(), [("x", 1), ("x", 2), ("y", 1),
                                       ("y", 2)]))
    assert table2[("x", 1)] == 12 / 56
    assert table2[("x", 2)] == 12 / 56
    assert table2[("y", 1)] == 16 / 56
    assert table2[("y", 2)] == 16 / 56

    table2 = table.marginal("X2")
    assert all(compare(table2.keys(), [("a", 1), ("a", 2), ("b", 1),
                                       ("b", 2)]))
    assert table2[("a", 1)] == 10 / 56
    assert table2[("a", 2)] == 10 / 56
    assert table2[("b", 1)] == 18 / 56
    assert table2[("b", 2)] == 18 / 56

    table2 = table.marginal("X3")
    assert all(
        compare(table2.keys(), [("a", "x"), ("a", "y"), ("b", "x"),
                                ("b", "y")]))
    assert table2[("a", "x")] == 8 / 56
    assert table2[("a", "y")] == 12 / 56
    assert table2[("b", "x")] == 16 / 56
    assert table2[("b", "y")] == 20 / 56

    table2 = table.marginal("X1", "X2")
    assert all(compare(table2.keys(), [(1, ), (2, )]))
    assert table2[1] == 28 / 56
    assert table2[2] == 28 / 56

    table2 = table.marginal("X1", "X3")
    assert all(compare(table2.keys(), [("x", ), ("y", )]))
    assert table2["x"] == 24 / 56
    assert table2["y"] == 32 / 56

    table2 = table.marginal("X2", "X3")
    assert all(compare(table2.keys(), [("a", ), ("b", )]))
    assert table2["a"] == 20 / 56
    assert table2["b"] == 36 / 56

    # Four levels dist.
    samples = {
        ("a", "x", 1, 33): 1,
        ("a", "x", 2, 33): 2,
        ("a", "x", 1, 44): 3,
        ("a", "x", 2, 44): 4,
        ("a", "y", 1, 33): 5,
        ("a", "y", 2, 33): 6,
        ("a", "y", 1, 44): 7,
        ("a", "y", 2, 44): 8,
        ("b", "x", 1, 33): 9,
        ("b", "x", 2, 33): 10,
        ("b", "x", 1, 44): 11,
        ("b", "x", 2, 44): 12,
        ("b", "y", 1, 33): 13,
        ("b", "y", 2, 33): 14,
        ("b", "y", 1, 44): 15,
        ("b", "y", 2, 44): 16,
    }
    table = Table(samples)
    table2 = table.marginal("X3")
    assert all(
        compare(
            table2.keys(),
            [
                ("a", "x", 33),
                ("a", "x", 44),
                ("a", "y", 33),
                ("a", "y", 44),
                ("b", "x", 33),
                ("b", "x", 44),
                ("b", "y", 33),
                ("b", "y", 44),
            ],
        ))
    assert table2[("a", "x", 33)] == 3 / 136
    assert table2[("a", "x", 44)] == 7 / 136
    assert table2[("a", "y", 33)] == 11 / 136
    assert table2[("a", "y", 44)] == 15 / 136
    assert table2[("b", "x", 33)] == 19 / 136
    assert table2[("b", "x", 44)] == 23 / 136
    assert table2[("b", "y", 33)] == 27 / 136
    assert table2[("b", "y", 44)] == 31 / 136

    table2 = table.marginal("X4")
    assert all(
        compare(
            table2.keys(),
            [
                ("a", "x", 1),
                ("a", "x", 2),
                ("a", "y", 1),
                ("a", "y", 2),
                ("b", "x", 1),
                ("b", "x", 2),
                ("b", "y", 1),
                ("b", "y", 2),
            ],
        ))
    assert table2[("a", "x", 1)] == 4 / 136
    assert table2[("a", "x", 2)] == 6 / 136
    assert table2[("a", "y", 1)] == 12 / 136
    assert table2[("a", "y", 2)] == 14 / 136
    assert table2[("b", "x", 1)] == 20 / 136
    assert table2[("b", "x", 2)] == 22 / 136
    assert table2[("b", "y", 1)] == 28 / 136
    assert table2[("b", "y", 2)] == 30 / 136

    table2 = table.marginal("X1", "X4")
    assert all(compare(table2.keys(), [("x", 1), ("x", 2), ("y", 1),
                                       ("y", 2)]))
    assert table2[("x", 1)] == 24 / 136
    assert table2[("x", 2)] == 28 / 136
    assert table2[("y", 1)] == 40 / 136
    assert table2[("y", 2)] == 44 / 136

    table2 = table.marginal("X1", "X2", "X4")
    assert all(compare(table2.keys(), [(1, ), (2, )]))
    assert table2[1] == 64 / 136
    assert table2[2] == 72 / 136

    # marginalize two times
    table2 = table.marginal("X1", "X4")
    table3 = table2.marginal("X2")
    assert all(compare(table3.keys(), [(1, ), (2, )]))
    assert table3[1] == 64 / 136
    assert table3[2] == 72 / 136

    # marginalize three times
    table2 = table.marginal("X4")
    table3 = table2.marginal("X3")
    table4 = table3.marginal("X2")
    assert all(compare(table4.keys(), [("a", ), ("b", )]))
    assert table4["a"] == 36 / 136
    assert table4["b"] == 100 / 136
コード例 #27
0
def test_marginal_by_name_discrete_distribution():
    # Four levels dist.
    samples = {
        ("a", "x", 1, 33): 1,
        ("a", "x", 2, 33): 2,
        ("a", "x", 1, 44): 3,
        ("a", "x", 2, 44): 4,
        ("a", "y", 1, 33): 5,
        ("a", "y", 2, 33): 6,
        ("a", "y", 1, 44): 7,
        ("a", "y", 2, 44): 8,
        ("b", "x", 1, 33): 9,
        ("b", "x", 2, 33): 10,
        ("b", "x", 1, 44): 11,
        ("b", "x", 2, 44): 12,
        ("b", "y", 1, 33): 13,
        ("b", "y", 2, 33): 14,
        ("b", "y", 1, 44): 15,
        ("b", "y", 2, 44): 16,
    }
    disc_dist = DiscreteDistribution(samples,
                                     names=["Age", "Sex", "Edu", "Etn"])
    disc_dist2 = disc_dist.marginal("Edu")
    assert disc_dist2.total == disc_dist.total
    assert all(
        compare(
            disc_dist2.keys_as_list(),
            [
                ("a", "x", 33),
                ("a", "x", 44),
                ("a", "y", 33),
                ("a", "y", 44),
                ("b", "x", 33),
                ("b", "x", 44),
                ("b", "y", 33),
                ("b", "y", 44),
            ],
        ))
    assert disc_dist2[("a", "x", 33)] == 3
    assert disc_dist2[("a", "x", 44)] == 7
    assert disc_dist2[("a", "y", 33)] == 11
    assert disc_dist2[("a", "y", 44)] == 15
    assert disc_dist2[("b", "x", 33)] == 19
    assert disc_dist2[("b", "x", 44)] == 23
    assert disc_dist2[("b", "y", 33)] == 27
    assert disc_dist2[("b", "y", 44)] == 31
    assert disc_dist2.probability(("a", "x", 33)) == 3 / 136
    assert disc_dist2.probability(("a", "x", 44)) == 7 / 136
    assert disc_dist2.probability(("a", "y", 33)) == 11 / 136
    assert disc_dist2.probability(("a", "y", 44)) == 15 / 136
    assert disc_dist2.probability(("b", "x", 33)) == 19 / 136
    assert disc_dist2.probability(("b", "x", 44)) == 23 / 136
    assert disc_dist2.probability(("b", "y", 33)) == 27 / 136
    assert disc_dist2.probability(("b", "y", 44)) == 31 / 136

    disc_dist2 = disc_dist.marginal("Etn")
    assert disc_dist2.total == disc_dist.total
    assert all(
        compare(
            disc_dist2.keys_as_list(),
            [
                ("a", "x", 1),
                ("a", "x", 2),
                ("a", "y", 1),
                ("a", "y", 2),
                ("b", "x", 1),
                ("b", "x", 2),
                ("b", "y", 1),
                ("b", "y", 2),
            ],
        ))
    assert disc_dist2[("a", "x", 1)] == 4
    assert disc_dist2[("a", "x", 2)] == 6
    assert disc_dist2[("a", "y", 1)] == 12
    assert disc_dist2[("a", "y", 2)] == 14
    assert disc_dist2[("b", "x", 1)] == 20
    assert disc_dist2[("b", "x", 2)] == 22
    assert disc_dist2[("b", "y", 1)] == 28
    assert disc_dist2[("b", "y", 2)] == 30
    assert disc_dist2.probability(("a", "x", 1)) == 4 / 136
    assert disc_dist2.probability(("a", "x", 2)) == 6 / 136
    assert disc_dist2.probability(("a", "y", 1)) == 12 / 136
    assert disc_dist2.probability(("a", "y", 2)) == 14 / 136
    assert disc_dist2.probability(("b", "x", 1)) == 20 / 136
    assert disc_dist2.probability(("b", "x", 2)) == 22 / 136
    assert disc_dist2.probability(("b", "y", 1)) == 28 / 136
    assert disc_dist2.probability(("b", "y", 2)) == 30 / 136

    disc_dist2 = disc_dist.marginal("Age", "Etn")
    assert disc_dist2.total == disc_dist.total
    assert all(
        compare(disc_dist2.keys_as_list(), [("x", 1), ("x", 2), ("y", 1),
                                            ("y", 2)]))
    assert disc_dist2[("x", 1)] == 24
    assert disc_dist2[("x", 2)] == 28
    assert disc_dist2[("y", 1)] == 40
    assert disc_dist2[("y", 2)] == 44
    assert disc_dist2.probability(("x", 1)) == 24 / 136
    assert disc_dist2.probability(("x", 2)) == 28 / 136
    assert disc_dist2.probability(("y", 1)) == 40 / 136
    assert disc_dist2.probability(("y", 2)) == 44 / 136

    disc_dist2 = disc_dist.marginal("Age", "Sex", "Etn")
    assert disc_dist2.total == disc_dist.total
    assert all(compare(disc_dist2.keys_as_list(), [1, 2]))
    assert disc_dist2[1] == 64
    assert disc_dist2[2] == 72
    assert disc_dist2.probability(1) == 64 / 136
    assert disc_dist2.probability(2) == 72 / 136

    # marginalize two times
    disc_dist2 = disc_dist.marginal("Age", "Etn")
    disc_dist3 = disc_dist2.marginal("Sex")
    assert disc_dist3.total == disc_dist.total
    assert all(compare(disc_dist3.keys_as_list(), [1, 2]))
    assert disc_dist3[1] == 64
    assert disc_dist3[2] == 72
    assert disc_dist3.probability(1) == 64 / 136
    assert disc_dist3.probability(2) == 72 / 136

    # marginalize three times
    disc_dist2 = disc_dist.marginal("Etn")
    disc_dist3 = disc_dist2.marginal("Edu")
    disc_dist4 = disc_dist3.marginal("Sex")
    assert disc_dist4.total == disc_dist.total
    assert all(compare(disc_dist4.keys_as_list(), ["a", "b"]))
    assert disc_dist4["a"] == 36
    assert disc_dist4["b"] == 100
    assert disc_dist4.probability("a") == 36 / 136
    assert disc_dist4.probability("b") == 100 / 136
コード例 #28
0
ファイル: exceptions_tests.py プロジェクト: virtusize/nap
def test_invalid_json_exception():
    ne = InvalidJSONException(data={'some': 'value'})
    compare(str(ne), u"{'message': 'Mime-type is JSON, but no JSON object could be decoded.', 'data': {'some': 'value'}}")
コード例 #29
0
ファイル: exceptions_tests.py プロジェクト: virtusize/nap
def test_invalid_mimetype_exception():
    ne = InvalidMimetypeException(mimetype='text/xml')
    compare(str(ne), u"{'mimetype': 'text/xml', 'message': 'Mime-type has to be application/json.'}")
コード例 #30
0
def test_marginals_discrete_distribution():
    # Single RV dist.
    with pytest.raises(ValueError):
        disc_dist = DiscreteDistribution({"A": 2, "B": 3, "C": 4})
        disc_dist.marginal("X1")

    # Two levels dist.
    samples = {(1, 1): 4, (1, 2): 4, (2, 1): 6, (2, 2): 6}
    disc_dist = DiscreteDistribution(samples)
    disc_dist2 = disc_dist.marginal("X1")
    assert disc_dist2.total == disc_dist.total
    assert all(compare(disc_dist2.keys_as_list(), [1, 2]))
    assert disc_dist2[1] == 10
    assert disc_dist2[2] == 10
    assert disc_dist2.probability(1) == 0.5
    assert disc_dist2.probability(2) == 0.5

    disc_dist2 = disc_dist.marginal("X2")
    assert disc_dist2.total == disc_dist.total
    assert all(compare(disc_dist2.keys_as_list(), [1, 2]))
    assert disc_dist2[1] == 8
    assert disc_dist2[2] == 12
    assert disc_dist2.probability(1) == 0.4
    assert disc_dist2.probability(2) == 0.6

    samples = {("a", "x"): 4, ("a", "y"): 4, ("b", "x"): 6, ("b", "y"): 6}
    disc_dist = DiscreteDistribution(samples)
    disc_dist2 = disc_dist.marginal("X1")
    assert disc_dist2.total == disc_dist.total
    assert all(compare(disc_dist2.keys_as_list(), ["x", "y"]))
    assert disc_dist2["x"] == 10
    assert disc_dist2["y"] == 10
    assert disc_dist2.probability("x") == 0.5
    assert disc_dist2.probability("y") == 0.5

    disc_dist2 = disc_dist.marginal("X1")
    assert disc_dist2.total == disc_dist.total
    assert all(compare(disc_dist2.keys_as_list(), ["x", "y"]))
    assert disc_dist2["x"] == 10
    assert disc_dist2["y"] == 10
    assert disc_dist2.probability("x") == 0.5
    assert disc_dist2.probability("y") == 0.5

    disc_dist2 = disc_dist.marginal("X2")
    assert disc_dist2.total == disc_dist.total
    assert all(compare(disc_dist2.keys_as_list(), ["a", "b"]))
    assert disc_dist2["a"] == 8
    assert disc_dist2["b"] == 12
    assert disc_dist2.probability("a") == 0.4
    assert disc_dist2.probability("b") == 0.6

    # Three levels dist.
    samples = {
        ("a", "x", 1): 4,
        ("a", "x", 2): 4,
        ("a", "y", 1): 6,
        ("a", "y", 2): 6,
        ("b", "x", 1): 8,
        ("b", "x", 2): 8,
        ("b", "y", 1): 10,
        ("b", "y", 2): 10,
    }
    disc_dist = DiscreteDistribution(samples)
    disc_dist2 = disc_dist.marginal("X1")
    assert disc_dist2.total == disc_dist.total
    assert all(
        compare(disc_dist2.keys_as_list(), [("x", 1), ("x", 2), ("y", 1),
                                            ("y", 2)]))
    assert disc_dist2[("x", 1)] == 12
    assert disc_dist2[("x", 2)] == 12
    assert disc_dist2[("y", 1)] == 16
    assert disc_dist2[("y", 2)] == 16
    assert disc_dist2.probability(("x", 1)) == 12 / 56
    assert disc_dist2.probability(("x", 2)) == 12 / 56
    assert disc_dist2.probability(("y", 1)) == 16 / 56
    assert disc_dist2.probability(("y", 2)) == 16 / 56

    disc_dist2 = disc_dist.marginal("X2")
    assert disc_dist2.total == disc_dist.total
    assert all(
        compare(disc_dist2.keys_as_list(), [("a", 1), ("a", 2), ("b", 1),
                                            ("b", 2)]))
    assert disc_dist2[("a", 1)] == 10
    assert disc_dist2[("a", 2)] == 10
    assert disc_dist2[("b", 1)] == 18
    assert disc_dist2[("b", 2)] == 18
    assert disc_dist2.probability(("a", 1)) == 10 / 56
    assert disc_dist2.probability(("a", 2)) == 10 / 56
    assert disc_dist2.probability(("b", 1)) == 18 / 56
    assert disc_dist2.probability(("b", 2)) == 18 / 56

    disc_dist2 = disc_dist.marginal("X3")
    assert disc_dist2.total == disc_dist.total
    assert all(
        compare(disc_dist2.keys_as_list(), [("a", "x"), ("a", "y"), ("b", "x"),
                                            ("b", "y")]))
    assert disc_dist2[("a", "x")] == 8
    assert disc_dist2[("a", "y")] == 12
    assert disc_dist2[("b", "x")] == 16
    assert disc_dist2[("b", "y")] == 20
    assert disc_dist2.probability(("a", "x")) == 8 / 56
    assert disc_dist2.probability(("a", "y")) == 12 / 56
    assert disc_dist2.probability(("b", "x")) == 16 / 56
    assert disc_dist2.probability(("b", "y")) == 20 / 56

    disc_dist2 = disc_dist.marginal("X1", "X2")
    assert disc_dist2.total == disc_dist.total
    assert all(compare(disc_dist2.keys_as_list(), [1, 2]))
    assert disc_dist2[1] == 28
    assert disc_dist2[2] == 28
    assert disc_dist2.probability(1) == 28 / 56
    assert disc_dist2.probability(2) == 28 / 56

    disc_dist2 = disc_dist.marginal("X1", "X3")
    assert disc_dist2.total == disc_dist.total
    assert all(compare(disc_dist2.keys_as_list(), ["x", "y"]))
    assert disc_dist2["x"] == 24
    assert disc_dist2["y"] == 32
    assert disc_dist2.probability("x") == 24 / 56
    assert disc_dist2.probability("y") == 32 / 56

    disc_dist2 = disc_dist.marginal("X2", "X3")
    assert disc_dist2.total == disc_dist.total
    assert all(compare(disc_dist2.keys_as_list(), ["a", "b"]))
    assert disc_dist2["a"] == 20
    assert disc_dist2["b"] == 36
    assert disc_dist2.probability("a") == 20 / 56
    assert disc_dist2.probability("b") == 36 / 56

    # Four levels dist.
    samples = {
        ("a", "x", 1, 33): 1,
        ("a", "x", 2, 33): 2,
        ("a", "x", 1, 44): 3,
        ("a", "x", 2, 44): 4,
        ("a", "y", 1, 33): 5,
        ("a", "y", 2, 33): 6,
        ("a", "y", 1, 44): 7,
        ("a", "y", 2, 44): 8,
        ("b", "x", 1, 33): 9,
        ("b", "x", 2, 33): 10,
        ("b", "x", 1, 44): 11,
        ("b", "x", 2, 44): 12,
        ("b", "y", 1, 33): 13,
        ("b", "y", 2, 33): 14,
        ("b", "y", 1, 44): 15,
        ("b", "y", 2, 44): 16,
    }
    disc_dist = DiscreteDistribution(samples)
    disc_dist2 = disc_dist.marginal("X3")
    assert disc_dist2.total == disc_dist.total
    assert all(
        compare(
            disc_dist2.keys_as_list(),
            [
                ("a", "x", 33),
                ("a", "x", 44),
                ("a", "y", 33),
                ("a", "y", 44),
                ("b", "x", 33),
                ("b", "x", 44),
                ("b", "y", 33),
                ("b", "y", 44),
            ],
        ))
    assert disc_dist2[("a", "x", 33)] == 3
    assert disc_dist2[("a", "x", 44)] == 7
    assert disc_dist2[("a", "y", 33)] == 11
    assert disc_dist2[("a", "y", 44)] == 15
    assert disc_dist2[("b", "x", 33)] == 19
    assert disc_dist2[("b", "x", 44)] == 23
    assert disc_dist2[("b", "y", 33)] == 27
    assert disc_dist2[("b", "y", 44)] == 31
    assert disc_dist2.probability(("a", "x", 33)) == 3 / 136
    assert disc_dist2.probability(("a", "x", 44)) == 7 / 136
    assert disc_dist2.probability(("a", "y", 33)) == 11 / 136
    assert disc_dist2.probability(("a", "y", 44)) == 15 / 136
    assert disc_dist2.probability(("b", "x", 33)) == 19 / 136
    assert disc_dist2.probability(("b", "x", 44)) == 23 / 136
    assert disc_dist2.probability(("b", "y", 33)) == 27 / 136
    assert disc_dist2.probability(("b", "y", 44)) == 31 / 136

    disc_dist2 = disc_dist.marginal("X4")
    assert disc_dist2.total == disc_dist.total
    assert all(
        compare(
            disc_dist2.keys_as_list(),
            [
                ("a", "x", 1),
                ("a", "x", 2),
                ("a", "y", 1),
                ("a", "y", 2),
                ("b", "x", 1),
                ("b", "x", 2),
                ("b", "y", 1),
                ("b", "y", 2),
            ],
        ))
    assert disc_dist2[("a", "x", 1)] == 4
    assert disc_dist2[("a", "x", 2)] == 6
    assert disc_dist2[("a", "y", 1)] == 12
    assert disc_dist2[("a", "y", 2)] == 14
    assert disc_dist2[("b", "x", 1)] == 20
    assert disc_dist2[("b", "x", 2)] == 22
    assert disc_dist2[("b", "y", 1)] == 28
    assert disc_dist2[("b", "y", 2)] == 30
    assert disc_dist2.probability(("a", "x", 1)) == 4 / 136
    assert disc_dist2.probability(("a", "x", 2)) == 6 / 136
    assert disc_dist2.probability(("a", "y", 1)) == 12 / 136
    assert disc_dist2.probability(("a", "y", 2)) == 14 / 136
    assert disc_dist2.probability(("b", "x", 1)) == 20 / 136
    assert disc_dist2.probability(("b", "x", 2)) == 22 / 136
    assert disc_dist2.probability(("b", "y", 1)) == 28 / 136
    assert disc_dist2.probability(("b", "y", 2)) == 30 / 136

    disc_dist2 = disc_dist.marginal("X1", "X4")
    assert disc_dist2.total == disc_dist.total
    assert all(
        compare(disc_dist2.keys_as_list(), [("x", 1), ("x", 2), ("y", 1),
                                            ("y", 2)]))
    assert disc_dist2[("x", 1)] == 24
    assert disc_dist2[("x", 2)] == 28
    assert disc_dist2[("y", 1)] == 40
    assert disc_dist2[("y", 2)] == 44
    assert disc_dist2.probability(("x", 1)) == 24 / 136
    assert disc_dist2.probability(("x", 2)) == 28 / 136
    assert disc_dist2.probability(("y", 1)) == 40 / 136
    assert disc_dist2.probability(("y", 2)) == 44 / 136

    disc_dist2 = disc_dist.marginal("X1", "X2", "X4")
    assert disc_dist2.total == disc_dist.total
    assert all(compare(disc_dist2.keys_as_list(), [1, 2]))
    assert disc_dist2[1] == 64
    assert disc_dist2[2] == 72
    assert disc_dist2.probability(1) == 64 / 136
    assert disc_dist2.probability(2) == 72 / 136

    # marginalize two times
    disc_dist2 = disc_dist.marginal("X1", "X4")
    disc_dist3 = disc_dist2.marginal("X2")
    assert disc_dist3.total == disc_dist.total
    assert all(compare(disc_dist3.keys_as_list(), [1, 2]))
    assert disc_dist3[1] == 64
    assert disc_dist3[2] == 72
    assert disc_dist3.probability(1) == 64 / 136
    assert disc_dist3.probability(2) == 72 / 136

    # marginalize three times
    disc_dist2 = disc_dist.marginal("X4")
    disc_dist3 = disc_dist2.marginal("X3")
    disc_dist4 = disc_dist3.marginal("X2")
    assert disc_dist4.total == disc_dist.total
    assert all(compare(disc_dist4.keys_as_list(), ["a", "b"]))
    assert disc_dist4["a"] == 36
    assert disc_dist4["b"] == 100
    assert disc_dist4.probability("a") == 36 / 136
    assert disc_dist4.probability("b") == 100 / 136
コード例 #31
0
def test_reduce_by_name_discrete_distribution():
    samples = {
        ("a", "x", 1, 33): 1,
        ("a", "x", 2, 33): 2,
        ("a", "x", 1, 44): 3,
        ("a", "x", 2, 44): 4,
        ("a", "y", 1, 33): 5,
        ("a", "y", 2, 33): 6,
        ("a", "y", 1, 44): 7,
        ("a", "y", 2, 44): 8,
        ("b", "x", 1, 33): 9,
        ("b", "x", 2, 33): 10,
        ("b", "x", 1, 44): 11,
        ("b", "x", 2, 44): 12,
        ("b", "y", 1, 33): 13,
        ("b", "y", 2, 33): 14,
        ("b", "y", 1, 44): 15,
        ("b", "y", 2, 44): 16,
    }
    disc_dist = DiscreteDistribution(samples)
    reduced_dist = disc_dist.reduce(X2="y")
    assert reduced_dist.rvs.size == 3
    assert all(compare(reduced_dist.rvs.names, ["X1", "X3", "X4"]))
    assert reduced_dist[("a", 1, 33)] == 5
    assert reduced_dist[("b", 2, 44)] == 16
    assert reduced_dist.frequency(("a", 1, 33)) == 5
    assert reduced_dist.frequency(("b", 2, 44)) == 16
    assert reduced_dist.probability(("a", 1, 33)) == 5 / 84
    assert reduced_dist.probability(("b", 2, 44)) == 16 / 84

    reduced_dist = disc_dist.reduce(X2="y", X3=1)
    assert reduced_dist.rvs.size == 2
    assert all(compare(reduced_dist.rvs.names, ["X1", "X4"]))
    assert reduced_dist[("a", 33)] == 5
    assert reduced_dist[("b", 44)] == 15
    assert reduced_dist.frequency(("a", 33)) == 5
    assert reduced_dist.frequency(("b", 44)) == 15
    assert reduced_dist.probability(("a", 33)) == 5 / 40
    assert reduced_dist.probability(("b", 44)) == 15 / 40

    reduced_dist = disc_dist.reduce(X1="b", X3=1, X4=44)
    assert reduced_dist.rvs.size == 1
    assert all(compare(reduced_dist.rvs.names, ["X2"]))
    assert reduced_dist["x"] == 11
    assert reduced_dist["y"] == 15
    assert reduced_dist.frequency("x") == 11
    assert reduced_dist.frequency("y") == 15
    assert reduced_dist.probability("x") == 11 / 26
    assert reduced_dist.probability("y") == 15 / 26

    disc_dist = DiscreteDistribution(samples, names=["Y", "Z", "W", "X"])

    reduced_dist = disc_dist.reduce(Z="y")
    assert reduced_dist.rvs.size == 3
    assert all(compare(reduced_dist.rvs.names, ["Y", "W", "X"]))
    assert reduced_dist[("a", 1, 33)] == 5
    assert reduced_dist[("b", 2, 44)] == 16
    assert reduced_dist.frequency(("a", 1, 33)) == 5
    assert reduced_dist.frequency(("b", 2, 44)) == 16
    assert reduced_dist.probability(("a", 1, 33)) == 5 / 84
    assert reduced_dist.probability(("b", 2, 44)) == 16 / 84

    reduced_dist = disc_dist.reduce(Z="y", W=1)
    assert reduced_dist.rvs.size == 2
    assert all(compare(reduced_dist.rvs.names, ["Y", "X"]))
    assert reduced_dist[("a", 33)] == 5
    assert reduced_dist[("b", 44)] == 15
    assert reduced_dist.frequency(("a", 33)) == 5
    assert reduced_dist.frequency(("b", 44)) == 15
    assert reduced_dist.probability(("a", 33)) == 5 / 40
    assert reduced_dist.probability(("b", 44)) == 15 / 40

    reduced_dist = disc_dist.reduce(Y="b", W=1, X=44)
    assert reduced_dist.rvs.size == 1
    assert all(compare(reduced_dist.rvs.names, ["Z"]))
    assert reduced_dist["x"] == 11
    assert reduced_dist["y"] == 15
    assert reduced_dist.frequency("x") == 11
    assert reduced_dist.frequency("y") == 15
    assert reduced_dist.probability("x") == 11 / 26
    assert reduced_dist.probability("y") == 15 / 26
コード例 #32
0
def test_three_levels_discrete_distribution():
    dist = DiscreteDistribution({("A", "y", 1): 2})
    both_levels = zip(dist.levels(), [["A"], ["y"], [1]])
    for levels_1, levels_2 in both_levels:
        assert all(compare(levels_1, levels_2))
    assert dist.rvs.size == 3
    assert dist[("A", "y", 1)] == 2
    assert dist[("A", "x", 2)] == 0
    assert all(compare(dist.frequencies(normalised=True), [1]))
    assert all(compare(dist.frequencies(normalised=False), [2]))
    assert dist.prob(X1="A", X2="y", X3=1) == 1
    assert dist.prob(X1="A", X2="y", X3=2) == 0

    dist = DiscreteDistribution({("A", "x", 1): 2, ("A", "y", 1): 2})
    both_levels = zip(dist.levels(), [["A"], ["x", "y"], [1]])
    for levels_1, levels_2 in both_levels:
        assert all(compare(levels_1, levels_2))
    assert dist.rvs.size == 3
    assert dist[("A", "x", 1)] == 2
    assert dist[("A", "y", 1)] == 2
    assert all(compare(dist.frequencies(normalised=True), [0.5, 0.5]))
    assert all(compare(dist.frequencies(normalised=False), [2, 2]))
    assert dist.prob(X1="A", X2="x", X3=1) == 0.5
    assert dist.prob(X1="A", X2="y", X3=1) == 0.5
    assert dist.prob(X1="A", X2="y", X3=2) == 0

    dist = DiscreteDistribution({("A", "x", 1): 2, ("B", "y", 2): 2})
    both_levels = zip(dist.levels(), [["A", "B"], ["x", "y"], [1, 2]])
    for levels_1, levels_2 in both_levels:
        assert all(compare(levels_1, levels_2))
    assert dist.rvs.size == 3
    assert dist[("A", "x", 1)] == 2
    assert dist[("B", "y", 2)] == 2
    assert dist[("B", "y", 3)] == 0
    assert all(compare(dist.frequencies(normalised=True), [0.5, 0.5]))
    assert all(compare(dist.frequencies(normalised=False), [2, 2]))
    assert dist.prob(X1="A", X2="x", X3=1) == 0.5
    assert dist.prob(X1="B", X2="y", X3=2) == 0.5

    dist = DiscreteDistribution({
        ("A", "x", 1): 1,
        ("A", "y", 2): 2,
        ("B", "x", 1): 3
    })
    both_levels = zip(dist.levels(), [["A", "B"], ["x", "y"], [1, 2]])
    for levels_1, levels_2 in both_levels:
        assert all(compare(levels_1, levels_2))
    assert dist.rvs.size == 3
    assert dist[("A", "x", 1)] == 1
    assert dist[("A", "y", 2)] == 2
    assert dist[("B", "x", 1)] == 3
    assert dist["B"] == 0
    assert all(
        compare(dist.frequencies(normalised=True), [1 / 6, 2 / 6, 3 / 6]))
    assert all(compare(dist.frequencies(normalised=False), [1, 2, 3]))
    assert dist.prob(X1="A", X2="x", X3=1) == 1 / 6
    assert dist.prob(X1="A", X2="y", X3=2) == 2 / 6
    assert dist.prob(X1="B", X2="x", X3=1) == 3 / 6
    assert dist.prob(X1="B", X2="y", X3=2) == 0

    dist = DiscreteDistribution({
        ("A", "x", 1): 1,
        ("A", "y", 2): 2,
        ("B", "x", 1): 3,
        ("B", "y", 2): 4
    })
    both_levels = zip(dist.levels(), [["A", "B"], ["x", "y"], [1, 2]])
    for levels_1, levels_2 in both_levels:
        assert all(compare(levels_1, levels_2))
    assert dist.rvs.size == 3
    assert dist[("A", "x", 1)] == 1
    assert dist[("A", "y", 2)] == 2
    assert dist[("B", "x", 1)] == 3
    assert dist[("B", "y", 2)] == 4
    assert all(compare(dist.frequencies(normalised=True),
                       [0.1, 0.2, 0.3, 0.4]))
    assert all(compare(dist.frequencies(normalised=False), [1, 2, 3, 4]))
    assert dist.prob(X1="A", X2="x", X3=1) == 1 / 10
    assert dist.prob(X1="A", X2="y", X3=2) == 2 / 10
    assert dist.prob(X1="B", X2="x", X3=1) == 3 / 10
    assert dist.prob(X1="B", X2="y", X3=2) == 4 / 10

    dist = DiscreteDistribution({
        ("A", "x", 1): 1,
        ("A", "y", 2): 2,
        ("B", "x", 1): 3,
        ("B", "y", 2): 4,
        ("C", "y", 3): 5,
    })
    both_levels = zip(dist.levels(), [["A", "B", "C"], ["x", "y"], [1, 2, 3]])
    for levels_1, levels_2 in both_levels:
        assert all(compare(levels_1, levels_2))
    assert dist.rvs.size == 3
    assert dist[("A", "x", 1)] == 1
    assert dist[("A", "y", 2)] == 2
    assert dist[("B", "x", 1)] == 3
    assert dist[("B", "y", 2)] == 4
    assert dist[("C", "y", 3)] == 5
    assert all(
        compare(dist.frequencies(normalised=True),
                [1 / 15, 2 / 15, 3 / 15, 4 / 15, 5 / 15]))
    assert all(compare(dist.frequencies(normalised=False), [1, 2, 3, 4, 5]))
    assert dist.prob(X1="A", X2="x", X3=1) == 1 / 15
    assert dist.prob(X1="A", X2="y", X3=2) == 2 / 15
    assert dist.prob(X1="B", X2="x", X3=1) == 3 / 15
    assert dist.prob(X1="B", X2="y", X3=2) == 4 / 15
    assert dist.prob(X1="C", X2="y", X3=3) == 5 / 15

    dist = DiscreteDistribution({
        ("A", "x", 1): 1,
        ("A", "y", 2): 2,
        ("B", "x", 3): 3,
        ("B", "y", 3): 4,
        ("C", "z", 4): 5,
    })
    both_levels = zip(dist.levels(),
                      [["A", "B", "C"], ["x", "y", "z"], [1, 2, 3, 4]])
    for levels_1, levels_2 in both_levels:
        assert all(compare(levels_1, levels_2))
    assert dist.rvs.size == 3
    assert dist[("A", "x", 1)] == 1
    assert dist[("A", "y", 2)] == 2
    assert dist[("B", "x", 3)] == 3
    assert dist[("B", "y", 3)] == 4
    assert dist[("C", "z", 4)] == 5
    assert all(
        compare(dist.frequencies(normalised=True),
                [1 / 15, 2 / 15, 3 / 15, 4 / 15, 5 / 15]))
    assert all(compare(dist.frequencies(normalised=False), [1, 2, 3, 4, 5]))
    assert dist.prob(X1="A", X2="x", X3=1) == 1 / 15
    assert dist.prob(X1="A", X2="y", X3=2) == 2 / 15
    assert dist.prob(X1="B", X2="x", X3=3) == 3 / 15
    assert dist.prob(X1="B", X2="y", X3=3) == 4 / 15
    assert dist.prob(X1="C", X2="z", X3=4) == 5 / 15