First commit

tests/test_brute_force.py

@@ -0,0 +1,26 @@
+from unittest import TestCase
+from network.brute_force import (get_all_possible_network,
+                                 estimate_number_of_activated_antenna)
+from random import Random
+
+
+class TestBruteForce(TestCase):
+
+    def test_get_all_possible_network(self):
+        self.assertEqual(list(get_all_possible_network(0)), [])
+
+        self.assertEqual(list(get_all_possible_network(1)), [0, 1])
+
+        expt = [0, 1, 2, 4, 6, 8, 9]
+        self.assertEqual(list(get_all_possible_network(2)), expt)
+
+    def test_estimate_number_of_activated_antenna(self):
+        random = Random(666)
+        est = estimate_number_of_activated_antenna(7, 2, random)
+        self.assertEqual(est, (0 + 1 + 1 + 1 + 1 + 2 + 2) / 7)
+
+        est = estimate_number_of_activated_antenna(100, 2, random)
+        self.assertEqual(est, (0 + 1 + 1 + 1 + 1 + 2 + 2) / 7)
+
+        est = estimate_number_of_activated_antenna(3, 2, random)
+        self.assertEqual(est, 1)

tests/test_gibbs.py

@@ -0,0 +1,35 @@
+from unittest import TestCase
+from random import Random
+from math import sqrt
+from collections import defaultdict
+from network.gibbs import get_random_networks, estimate_number_of_activated_antenna
+
+
+def standard_deviation(lst):
+    sum_x = 0
+    sum_x_2 = 0
+    for elm in lst:
+        sum_x += elm
+        sum_x_2 += elm * elm
+
+    n = len(lst)
+    return sqrt(sum_x_2 / n - (sum_x / n)**2)
+
+
+class TestGibbs(TestCase):
+
+    def test_get_random_networks(self):
+        counter = defaultdict(int)
+        random, n = Random(555), 1000
+        for _, network in zip(range(n), get_random_networks(2, random)):
+            counter[network] += 1
+
+        self.assertSetEqual(set(counter.keys()), {0, 1, 2, 4, 6, 8, 9})
+        self.assertLess(standard_deviation(counter.values()) / n, 0.1)
+
+    def test_estimate_number_of_activated_antenna(self):
+        random = Random(666)
+
+        est = estimate_number_of_activated_antenna(100, 2, random)
+        real = (0 + 1 + 1 + 1 + 1 + 2 + 2) / 7
+        assert abs(est - real) < 0.1

tests/test_importance_sampling.py

@@ -0,0 +1,121 @@
+from unittest import TestCase
+from random import Random
+from network.importance_sampling import (AntennaGenerator,
+                                         SuccesiveAntennaGenerator,
+                                         BadAntennaGenerator,
+                                         BetterSuccesiveAntennaGenerator,
+                                         estimate_number_of_activated_antenna)
+
+
+class TestSuccesiveAntennaGenerator(TestCase):
+    def test_get_random_antenna(self):
+        self.antenna_genetator = SuccesiveAntennaGenerator(5, Random(678))
+
+        ant, _ = self.antenna_genetator.get_random_antenna()
+        self.assertEqual(ant, 2)
+        expt = [4,5,6,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]
+        self.assertListEqual(self.antenna_genetator._antennas, expt)
+
+        ant, _ = self.antenna_genetator.get_random_antenna()
+        self.assertEqual(ant, 14)
+        expt = [15,16,17,18,20,21,22,23,24]
+        self.assertListEqual(self.antenna_genetator._antennas, expt)
+
+        ant, _ = self.antenna_genetator.get_random_antenna()
+        self.assertEqual(ant, -1)
+        expt = []
+        self.assertListEqual(self.antenna_genetator._antennas, expt)
+
+    def test_get_random_antenna_bottom_line(self):
+        self.antenna_genetator = SuccesiveAntennaGenerator(5, Random(607))
+        ant, _ = self.antenna_genetator.get_random_antenna()
+        self.assertEqual(ant, 21)
+        expt = [23, 24, ]
+        self.assertListEqual(self.antenna_genetator._antennas, expt)
+
+    def test_get_random_antenna_right_line(self):
+        self.antenna_genetator = SuccesiveAntennaGenerator(5, Random(637))
+        ant, _ = self.antenna_genetator.get_random_antenna()
+        self.assertEqual(ant, 14)
+        expt = [15, 16, 17, 18, 20, 21, 22, 23, 24]
+        self.assertListEqual(self.antenna_genetator._antennas, expt)
+
+    def test_get_random_antenna_last_box(self):
+        self.antenna_genetator = SuccesiveAntennaGenerator(5, Random(631))
+        ant, _ = self.antenna_genetator.get_random_antenna()
+        self.assertEqual(24, ant)
+        expt = []
+        self.assertListEqual(self.antenna_genetator._antennas, expt)
+
+    def test_probability(self):
+        self.antenna_genetator = SuccesiveAntennaGenerator(5, Random(678))
+        ant, prob = self.antenna_genetator.get_random_antenna()
+        self.assertAlmostEqual(prob, 26**-1)
+        self.assertEqual(ant, 2)
+
+        _, prob = self.antenna_genetator.get_random_antenna()
+        self.assertAlmostEqual(prob, 21**-1)
+
+class TestImportanceSampling(TestCase):
+
+    def test_SuccesiveAntennaGenerator(self):
+        random = Random(666)
+
+        est = estimate_number_of_activated_antenna(150, 2, random, SuccesiveAntennaGenerator)
+        real = (0 + 1 + 1 + 1 + 1 + 2 + 2) / 7
+        print(real)
+        print(est)
+        assert abs(est - real) > 0.1
+
+    def test_BadAntennaGenerator(self):
+        random = Random(666)
+
+        est = estimate_number_of_activated_antenna(2500, 2, random, BadAntennaGenerator)
+        real = (0 + 1 + 1 + 1 + 1 + 2 + 2) / 7
+        assert abs(est - real) > 0.1
+
+    def test_BetterSuccesiveAntennaGenerator(self):
+        random = Random(666)
+
+        est = estimate_number_of_activated_antenna(150, 2, random, BetterSuccesiveAntennaGenerator)
+        real = (0 + 1 + 1 + 1 + 1 + 2 + 2) / 7
+        print(real)
+        print(est)
+        assert abs(est - real) > 0.1
+
+
+class TestBadAntennaGenerator(TestCase):
+    def test_remove_antenna_easy(self):
+        gen = BadAntennaGenerator(3, Random(666))
+        gen._remove_antenna(2)
+        expt = [0,3,4,6,7,8]
+        self.assertListEqual(gen._antennas, expt)
+
+        gen = BadAntennaGenerator(3, Random(666))
+        gen._remove_antenna(3)
+        expt = [1, 2, 5, 7, 8]
+        self.assertListEqual(gen._antennas, expt)
+
+        gen = BadAntennaGenerator(3, Random(666))
+        gen._remove_antenna(4)
+        expt = [0,2,6,8]
+        self.assertListEqual(gen._antennas, expt)
+
+        gen = BadAntennaGenerator(3, Random(666))
+        gen._remove_antenna(7)
+        expt = [0,1,2,3,5]
+        self.assertListEqual(gen._antennas, expt)
+
+    def test_remove_antenna(self):
+        gen = BadAntennaGenerator(3, Random(666))
+        gen._remove_antenna(gen._antennas.index(2))
+        expt = [0,3,4,6,7,8]
+        self.assertListEqual(gen._antennas, expt)
+
+        gen._remove_antenna(gen._antennas.index(0))
+        expt = [4,6,7,8]
+        self.assertListEqual(gen._antennas, expt)
+
+        gen._remove_antenna(gen._antennas.index(7))
+        expt = []
+        self.assertListEqual(gen._antennas, expt)

tests/test_network.py

@@ -0,0 +1,89 @@
+from unittest import TestCase
+from network.network import (get_activated_antennas,
+                             create_network,
+                             pp_network,
+                             _are_two_consicutive_horizontaly_antennas_activated,
+                             _are_two_consicutive_verticaly_antennas_activated,
+                             turn_on_antenna,
+                             turn_off_antenna,
+                             can_antenna_be_turned_on,
+                             has_antenna)
+
+
+class TestFunctions(TestCase):
+    def test_create_network(self):
+        assert create_network([]) == 0
+        assert create_network([0,2,3,7,8,9]) == 909
+
+    def test_pp_network(self):
+        a = 111
+        expt = """\
+■-■-■-■
+□-■-■-□
+□-□-□-□
+□-□-□-□
+"""
+        self.assertEqual( pp_network(a, 4), expt)
+
+
+    def test_get_activated_antennas(self):
+        self.assertListEqual(list(get_activated_antennas(0)), [])
+        self.assertListEqual(list(get_activated_antennas(1)), [0])
+        self.assertListEqual(list(get_activated_antennas(2)), [1])
+        self.assertListEqual(list(get_activated_antennas(2)), [1])
+
+        # 909 is written as 1110001101 in binary
+        expt = [0,2,3,7,8,9]
+        self.assertListEqual(list(get_activated_antennas(909)), expt)
+
+    def test_are_two_consicutive_horizontaly_antennas_activated(self):
+        assert _are_two_consicutive_horizontaly_antennas_activated(160, 4) == False
+        assert _are_two_consicutive_horizontaly_antennas_activated(24, 4) == False
+        assert _are_two_consicutive_horizontaly_antennas_activated(96, 4) == True
+
+    def test_are_two_consicutive_verticaly_antennas_activated(self):
+        assert _are_two_consicutive_verticaly_antennas_activated(24, 4) == False
+        assert _are_two_consicutive_verticaly_antennas_activated(16384, 4) == False
+        assert _are_two_consicutive_verticaly_antennas_activated(17408, 4) == True
+        assert _are_two_consicutive_verticaly_antennas_activated(136, 4) == True
+        assert _are_two_consicutive_verticaly_antennas_activated(1104, 4) == True
+
+    def test_turn_on_antenna(self):
+        self.assertEqual(turn_on_antenna(5, 111), 111)
+        self.assertEqual(turn_on_antenna(4, 111), 111+2**4)
+
+    def test_has_antenna(self):
+        network = create_network([0,2,3,7,8,9])
+        assert has_antenna(0, network)
+        assert has_antenna(3, network)
+        assert has_antenna(9, network)
+
+        assert not has_antenna(4, network)
+        assert not has_antenna(10, network)
+
+    def test_turn_off_antenna(self):
+        network = create_network([0,2,3,7,8,9])
+        assert turn_off_antenna(2, network) == 905
+        assert turn_off_antenna(7, network) == 781
+        assert turn_off_antenna(10, network) == 909
+        assert turn_off_antenna(4, network) == 909
+
+
+    def test_can_antenna_be_turned_on(self):
+        # □-□-□-□-■
+        # □-□-□-□-□
+        # □-□-■-□-□
+        # □-□-□-□-■
+        # □-□-□-□-□
+
+        network = create_network([4, 12, 20])
+        assert can_antenna_be_turned_on(0, network, 5)
+        assert can_antenna_be_turned_on(1, network, 5)
+        assert can_antenna_be_turned_on(5, network, 5)
+        assert can_antenna_be_turned_on(19, network, 5)
+
+        assert not can_antenna_be_turned_on(3, network, 5)
+        assert not can_antenna_be_turned_on(7, network, 5)
+        assert not can_antenna_be_turned_on(11, network, 5)
+        assert not can_antenna_be_turned_on(13, network, 5)
+        assert not can_antenna_be_turned_on(17, network, 5)