def test_yields_starting_population(self):
"""
Ensures that the first item yielded *is* the starting population.
"""
start_pop = [3, 2, 1]
ga = genetic_algorithm(start_pop, None, None, None)
self.assertEqual(ga.next(), start_pop,
"Starting population not yielded as first result.")
def test_fitness_called_for_starting_population(self):
"""
Ensures the fitness function is called on each initial genome before
yielding the starting population.
"""
start_pop = [1, 2, 3]
mock_fitness = MagicMock(return_value=None)
ga = genetic_algorithm(start_pop, mock_fitness, None, None)
result = ga.next()
self.assertEqual(len(start_pop), mock_fitness.call_count,
"Fitness function not called for each genome.")
def test_generate(self):
"""
Ensures that the generate iterable is used to create new generations.
"""
start_pop = [1, 2, 3]
def fitness(genome):
"""
For illustrative purposes.
"""
return genome
def halt(population, generation_count):
"""
Halts the algorithm after ten populations.
"""
return generation_count == 10
class Generate(object):
"""
An iterable for producing new offspring.
"""
def __init__(self, parent_population):
"""
@param parent_population: the parent genomes.
"""
self.counter = 0
self.size = len(parent_population)
self.parents = parent_population
def __iter__(self):
return self
def __next__(self):
"""
For testing purposes only.
"""
if self.counter < self.size:
pos, self.counter = self.counter, self.counter + 1
return self.parents[pos] + 1
else:
raise StopIteration()
ga = genetic_algorithm(start_pop, fitness, Generate, halt)
actual = [p for p in ga]
expected = [[3 + i, 2 + i, 1 + i] for i in range(10)]
self.assertEqual(actual, expected,
"Actual: %r Expected: %r" % (actual, expected))
def test_starting_population_fitness_ordered(self):
"""
Ensures that the starting population as returned by the GA is ordered
according to the fitness function.
"""
start_pop = [1, 2, 3]
def fitness(genome):
"""
For illustrative purposes.
"""
return genome * genome
ga = genetic_algorithm(start_pop, fitness, None, None)
expected = [3, 2, 1]
actual = next(ga)
self.assertEqual(actual, expected,
"Actual: %r Expected: %r" % (actual, expected))
def test_halt_function(self):
"""
Ensures that the halt function is called for all subsequent yields
after yielding the starting population.
"""
start_pop = [1, 2, 3]
def fitness(genome):
"""
For illustrative purposes.
"""
return genome
def halt(population, generation_count):
"""
Halts the algorithm after ten populations.
"""
return generation_count == 10
class Generate(object):
"""
As simple as possible. See generate related test below.
"""
def __init__(self, parents):
pass
def __iter__(self):
return self
def __next__(self):
raise StopIteration()
ga = genetic_algorithm(start_pop, fitness, Generate, halt)
result = [p for p in ga]
actual = len(result)
expected = 10
self.assertEqual(actual, expected,
"Actual: %r Expected: %r" % (actual, expected))
mutation_range = third.DEFAULT_MUTATION_RANGE
mutation_rate = third.DEFAULT_MUTATION_RATE
start_population = third.create_population(population_size, cf)
fitness_function = third.make_fitness_function(cf)
generate_function = third.make_generate_function(mutation_range,
mutation_rate, cf)
halt_function = third.make_halt_function(cf)
elif species == 4:
population_size = fourth.DEFAULT_POPULATION_SIZE
mutation_range = fourth.DEFAULT_MUTATION_RANGE
mutation_rate = fourth.DEFAULT_MUTATION_RATE
start_population = fourth.create_population(population_size, cf)
fitness_function = fourth.make_fitness_function(cf)
generate_function = fourth.make_generate_function(mutation_range,
mutation_rate, cf)
halt_function = fourth.make_halt_function(cf)
ga = ga.genetic_algorithm(start_population, fitness_function,
generate_function, halt_function)
fitness = 0.0
counter = 0
for generation in ga:
counter += 1
fitness = generation[0].fitness
print "--- Generation %d ---" % counter
print generation[0]
print fitness
with open('%s.ly' % output, 'w') as output:
output.write(lilypond.render(species, cf, generation[0].chromosome))
