Пример #1
0
 def test_eq(self):
     """
     Ensures that only the chromosome is used for equality.
     """
     x = Genome([1, 2, 3])
     y = Genome([1, 2, 3])
     z = Genome([3, 2, 1])
     self.assertEqual(x, y)
     self.assertNotEqual(x, z)
Пример #2
0
 def test_return_parents_if_same(self):
     """
     If both parents have the same chromosome then just return the parents.
     """
     mum = Genome([1, 2, 3])
     dad = Genome([1, 2, 3])
     result = crossover(mum, dad, Genome)
     self.assertEqual(mum, result[0],
                      "Child expected to be the same as parent.")
     self.assertEqual(mum, result[0],
                      "Child expected to be the same as parent.")
Пример #3
0
 def test_generate_function_returns_list(self):
     """
     Ensures the new population is a list.
     """
     generate_function = make_generate_function(7, 0.2, CANTUS_FIRMUS)
     g1 = Genome([1, 2, 3])
     g1.fitness = 1
     g2 = Genome([1, 2, 3])
     g2.fitness = 2
     seed_population = [g1, g2]
     result = generate_function(seed_population)
     self.assertTrue(list, type(result))
Пример #4
0
 def test_init(self):
     """
     Ensures the chromosome and fitness are initialised correctly.
     """
     x = Genome([1, 2, 3])
     self.assertEqual(None, x.fitness)
     self.assertEqual([1, 2, 3], x.chromosome)
Пример #5
0
 def test_creates_two_babies(self):
     """
     If the parents are different ensures that the children are the result
     of an expected crossover.
     """
     mum = Genome([1, 2, 3, 4])
     dad = Genome(['a', 'b', 'c', 'd'])
     result = crossover(mum, dad, Genome)
     # There must be two children.
     self.assertEqual(2, len(result))
     # The randint call in crossover will choose 2 given random.seed(5).
     expected1 = Genome([1, 2, 'c', 'd'])
     expected2 = Genome(['a', 'b', 3, 4])
     self.assertEqual(expected1, result[0],
                      "Expected: %r Got: %r" % (expected1, result[0]))
     self.assertEqual(expected2, result[1],
                      "Expected: %r Got: %r" % (expected2, result[1]))
Пример #6
0
 def test_generate_function_returns_list_of_correct_length(self):
     """
     Ensure the new population is the correct length.
     """
     generate_function = make_generate_function(7, 0.2, CANTUS_FIRMUS)
     g1 = Genome([1, 2, 3])
     g1.fitness = 1
     g2 = Genome([1, 2, 3])
     g2.fitness = 2
     g3 = Genome([1, 2, 3])
     g3.fitness = 3
     seed_population = [g1, g2, g3]
     result = generate_function(seed_population)
     self.assertTrue(3, len(result))
Пример #7
0
 def test_getitem(self):
     """
     The __getitem__ function returns the corresponding result from the
     chromosome.
     """
     x = Genome([1, 2, 3])
     self.assertEqual(1, x[0])
     self.assertEqual(2, x[1])
     self.assertEqual(3, x[2])
Пример #8
0
    def test_returns_genome(self):
        """
        Ensures that the roulette wheel returns a selected genome.
        """
        class Genome(object):
            """
            A simple representation of a genome.
            """
            def __init__(self, fitness):
                self.fitness = fitness

        population = [Genome(random.uniform(0.1, 10.0)) for i in range(4)]
        result = roulette_wheel_selection(population)
        self.assertIsInstance(
            result, Genome,
            "Expected result of roulette_wheel_selection is not a Genome")
Пример #9
0
    def test_returns_genome_with_unfit_population(self):
        """
        Ensures that the roulette wheel returns a randomly selected genome if
        none of them have a positive fitness score.
        """
        class Genome(object):
            """
            A simple representation of a genome.
            """
            def __init__(self, fitness):
                self.fitness = fitness

        population = [Genome(0.0) for i in range(4)]
        result = roulette_wheel_selection(population)
        self.assertIsInstance(
            result, Genome,
            "Expected result of roulette_wheel_selection is not a Genome")
Пример #10
0
 def test_generate_function_returns_list(self):
     """
     Ensures the new population is a list.
     """
     generate_function = make_generate_function(7, 0.2, CANTUS_FIRMUS)
     g1 = Genome([1, 2, 3])
     g1.fitness = 1
     g2 = Genome([1, 2, 3])
     g2.fitness = 2
     seed_population = [g1, g2]
     result = generate_function(seed_population)
     self.assertTrue(list, type(result))
Пример #11
0
    def test_breed(self):
        """
        Ensures that the crossover function is called as a result of calling
        the breed method.
        """
        x = Genome([1, 2, 3, 4])
        mate = Genome(['a', 'b', 'c', 'd'])
        mock_crossover = MagicMock(return_value=(Genome([1, 2, 'a', 'b']),
                                                 Genome(['a', 'b', 3, 4])))

        with patch('foox.ga.crossover', mock_crossover):
            x.breed(mate)
        self.assertEqual(
            1, mock_crossover.call_count,
            "Breed does not call crossover function expected number of times.")
        mock_crossover.assert_called_with(x, mate, Genome)
Пример #12
0
 def test_generate_function_returns_list_of_correct_length(self):
     """
     Ensure the new population is the correct length.
     """
     generate_function = make_generate_function(7, 0.2, CANTUS_FIRMUS)
     g1 = Genome([1, 2, 3])
     g1.fitness = 1
     g2 = Genome([1, 2, 3])
     g2.fitness = 2
     g3 = Genome([1, 2, 3])
     g3.fitness = 3
     seed_population = [g1, g2, g3]
     result = generate_function(seed_population)
     self.assertTrue(3, len(result))
Пример #13
0
 def test_repr(self):
     """
     The __repr__ of the Genome is that of the chromosome.
     """
     x = Genome([1, 2, 3])
     self.assertEqual(repr([1, 2, 3]), repr(x))
Пример #14
0
 def test_len(self):
     """
     The __len__ function returns the length of the chromosome.
     """
     x = Genome([1, 2, 3])
     self.assertEqual(3, len(x))
Пример #15
0
 def test_mutate(self):
     """
     Ensurs the mutate method returns NotImplemented.
     """
     x = Genome([1, 2, 3])
     self.assertEqual(NotImplemented, x.mutate(1, 2, [1, 2, 3]))