class TestFitnessTruncationRanking(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
def test_classinit_(self):
fit = FitnessTruncationRanking(self.fitness_list, 0.5)
self.assertAlmostEqual(0.5, fit._trunc_rate)
def test_set_trunc_rate(self):
fit = FitnessTruncationRanking(self.fitness_list, 0.5)
self.assertRaises(ValueError, fit.set_trunc_rate, 5)
self.assertRaises(ValueError, fit.set_trunc_rate, 5.0)
self.assertRaises(ValueError, fit.set_trunc_rate, -5)
self.assertRaises(ValueError, fit.set_trunc_rate, -5.0)
self.assertRaises(ValueError, fit.set_trunc_rate, 1.0)
fit.set_trunc_rate(0.4)
self.assertAlmostEqual(0.4, fit._trunc_rate)
def test_calc_prob(self):
fit = FitnessTruncationRanking(self.fitness_list, 0.5)
self.assertAlmostEqual(0.125, fit._calc_prob(10, 2))
def test_select(self):
fit = FitnessTruncationRanking(self.fitness_list, 0.5)
count = len([i for i in fit.select()])
self.assertEqual(3, count)
class TestFitnessTruncationRanking(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
def test_classinit_(self):
fit = FitnessTruncationRanking(self.fitness_list, .5)
self.assertAlmostEqual(.5, fit._trunc_rate)
def test_set_trunc_rate(self):
fit = FitnessTruncationRanking(self.fitness_list, .5)
self.assertRaises(ValueError, fit.set_trunc_rate, 5)
self.assertRaises(ValueError, fit.set_trunc_rate, 5.0)
self.assertRaises(ValueError, fit.set_trunc_rate, -5)
self.assertRaises(ValueError, fit.set_trunc_rate, -5.0)
self.assertRaises(ValueError, fit.set_trunc_rate, 1.0)
fit.set_trunc_rate(.4)
self.assertAlmostEqual(.4, fit._trunc_rate)
def test_calc_prob(self):
fit = FitnessTruncationRanking(self.fitness_list, .5)
self.assertAlmostEqual(.125, fit._calc_prob(10, 2))
def test_select(self):
fit = FitnessTruncationRanking(self.fitness_list, .5)
count = len([i for i in fit.select()])
self.assertEqual(3, count)
class TestFitnessElites(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
def test_classinit_(self):
self.assertRaises(ValueError,
FitnessElites,
self.fitness_list,
rate=1.1)
self.assertRaises(ValueError,
FitnessElites,
self.fitness_list,
rate=-1.1)
self.assertRaises(ValueError,
FitnessElites,
self.fitness_list,
rate=0.0)
fit = FitnessElites(self.fitness_list, rate=0.1)
self.assertAlmostEqual(0.1, fit._rate)
self.assertAlmostEqual(MIN, fit._selection_type)
def test_set_rate(self):
fit = FitnessElites(self.fitness_list, rate=0.1)
self.assertAlmostEqual(0.1, fit._rate)
def test_select(self):
fit = FitnessElites(self.fitness_list, rate=0.3333)
count = len([i for i in fit.select()])
self.assertEqual(1, count)
class TestReplacement(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
self.repl = Replacement(self.fitness_list)
def test_classinit_(self):
self.assertEqual(0, self.repl._replacement_count)
class TestReplacement(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
self.repl = Replacement(self.fitness_list)
def test_classinit_(self):
self.assertEqual(0, self.repl._replacement_count)
class TestReplacementTournament(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
self.repl = ReplacementTournament(self.fitness_list, tournament_size=1)
def test_classinit_(self):
self.assertEqual(1, self.repl._tournament_size)
class TestReplacementTournament(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
self.repl = ReplacementTournament(self.fitness_list, tournament_size=1)
def test_classinit_(self):
self.assertEqual(1, self.repl._tournament_size)
def test_classinit_(self):
fitness_list = FitnessList(MAX)
fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
fit = FitnessTournament(fitness_list)
self.assertEqual(2, fit._tournament_size)
fit = FitnessTournament(fitness_list, tournament_size=3)
self.assertEqual(3, fit._tournament_size)
self.assertRaises(ValueError, FitnessTournament, fitness_list, tournament_size=4)
class TestReplacementDeleteWorst(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
self.repl = ReplacementDeleteWorst(self.fitness_list,
replacement_count=1)
def test_classinit_(self):
self.assertEqual(1, self.repl._replacement_count)
self.assertEqual(MIN, self.repl._selection_type)
def test_set_replacement_count(self):
self.repl.set_replacement_count(2)
self.assertEqual(2, self.repl._replacement_count)
self.repl.set_replacement_count(3)
self.assertEqual(3, self.repl._replacement_count)
self.assertRaises(ValueError, self.repl.set_replacement_count, 4)
def test_select(self):
# attempting to maximize remove worst 3
self.repl.set_replacement_count(3)
values = [i for i in self.repl.select()]
self.assertLessEqual(
self.repl._fitness_list[values[0]][0],
self.repl._fitness_list[values[1]][0],
)
self.assertLessEqual(
self.repl._fitness_list[values[1]][0],
self.repl._fitness_list[values[2]][0],
)
# attempting to minimize remove worst 3
self.fitness_list = FitnessList(MIN)
values = [i for i in self.repl.select()]
self.assertGreaterEqual(
self.repl._fitness_list[values[0]][0],
self.repl._fitness_list[values[1]][0],
)
self.assertGreaterEqual(
self.repl._fitness_list[values[1]][0],
self.repl._fitness_list[values[2]][0],
)
def test_classinit_(self):
fitness_list = FitnessList(MAX)
fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
fit = FitnessTournament(fitness_list)
self.assertEqual(2, fit._tournament_size)
fit = FitnessTournament(fitness_list, tournament_size=3)
self.assertEqual(3, fit._tournament_size)
self.assertRaises(ValueError,
FitnessTournament,
fitness_list,
tournament_size=4)
class TestFitnessLinearRanking(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
def test_classinit_(self):
fit = FitnessLinearRanking(self.fitness_list, .6)
self.assertAlmostEqual(0.6, fit._worstfactor)
def test_set_worstfactor(self):
fit = FitnessLinearRanking(self.fitness_list, .6)
self.assertAlmostEqual(0.6, fit._worstfactor)
fit.set_worstfactor(.7)
self.assertAlmostEqual(.7, fit._worstfactor)
self.assertRaises(ValueError, fit.set_worstfactor, -.1)
self.assertRaises(ValueError, fit.set_worstfactor, 2.1)
def test_select(self):
fit = FitnessLinearRanking(self.fitness_list, .6)
count = len([i for i in fit.select()])
self.assertEqual(3, count)
def test_linear_ranking(self):
pass
fit = FitnessLinearRanking(self.fitness_list, .6)
prob_list = fit._linear_ranking(3, .6)
self.assertAlmostEqual(0.199999999, prob_list[0])
self.assertAlmostEqual(0.333333333, prob_list[1])
self.assertAlmostEqual(0.466666666, prob_list[2])
self.assertLessEqual(prob_list[0], prob_list[1])
self.assertLessEqual(prob_list[1], prob_list[2])
self.assertAlmostEqual(1.0, sum(prob_list))
prob_list = fit._linear_ranking(3, .2)
self.assertAlmostEqual(0.06666667, prob_list[0])
self.assertAlmostEqual(0.33333333, prob_list[1])
self.assertAlmostEqual(0.6, prob_list[2])
self.assertLessEqual(prob_list[0], prob_list[1])
self.assertLessEqual(prob_list[1], prob_list[2])
self.assertAlmostEqual(1.0, sum(prob_list))
class TestFitnessLinearRanking(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
def test_classinit_(self):
fit = FitnessLinearRanking(self.fitness_list, 0.6)
self.assertAlmostEqual(0.6, fit._worstfactor)
def test_set_worstfactor(self):
fit = FitnessLinearRanking(self.fitness_list, 0.6)
self.assertAlmostEqual(0.6, fit._worstfactor)
fit.set_worstfactor(0.7)
self.assertAlmostEqual(0.7, fit._worstfactor)
self.assertRaises(ValueError, fit.set_worstfactor, -0.1)
self.assertRaises(ValueError, fit.set_worstfactor, 2.1)
def test_select(self):
fit = FitnessLinearRanking(self.fitness_list, 0.6)
count = len([i for i in fit.select()])
self.assertEqual(3, count)
def test_linear_ranking(self):
pass
fit = FitnessLinearRanking(self.fitness_list, 0.6)
prob_list = fit._linear_ranking(3, 0.6)
self.assertAlmostEqual(0.199999999, prob_list[0])
self.assertAlmostEqual(0.333333333, prob_list[1])
self.assertAlmostEqual(0.466666666, prob_list[2])
self.assertLessEqual(prob_list[0], prob_list[1])
self.assertLessEqual(prob_list[1], prob_list[2])
self.assertAlmostEqual(1.0, sum(prob_list))
prob_list = fit._linear_ranking(3, 0.2)
self.assertAlmostEqual(0.06666667, prob_list[0])
self.assertAlmostEqual(0.33333333, prob_list[1])
self.assertAlmostEqual(0.6, prob_list[2])
self.assertLessEqual(prob_list[0], prob_list[1])
self.assertLessEqual(prob_list[1], prob_list[2])
self.assertAlmostEqual(1.0, sum(prob_list))
class TestFitnessElites(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
def test_classinit_(self):
self.assertRaises(ValueError, FitnessElites, self.fitness_list, rate=1.1)
self.assertRaises(ValueError, FitnessElites, self.fitness_list, rate=-1.1)
self.assertRaises(ValueError, FitnessElites, self.fitness_list, rate=0.0)
fit = FitnessElites(self.fitness_list, rate=0.1)
self.assertAlmostEqual(0.1, fit._rate)
self.assertAlmostEqual(MIN, fit._selection_type)
def test_set_rate(self):
fit = FitnessElites(self.fitness_list, rate=0.1)
self.assertAlmostEqual(0.1, fit._rate)
def test_select(self):
fit = FitnessElites(self.fitness_list, rate=0.3333)
count = len([i for i in fit.select()])
self.assertEqual(1, count)
class TestReplacementDeleteWorst(unittest.TestCase):
def setUp(self):
self.fitness_list = FitnessList(MAX)
self.fitness_list.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
self.repl = ReplacementDeleteWorst(self.fitness_list, replacement_count=1)
def test_classinit_(self):
self.assertEqual(1, self.repl._replacement_count)
self.assertEqual(MIN, self.repl._selection_type)
def test_set_replacement_count(self):
self.repl.set_replacement_count(2)
self.assertEqual(2, self.repl._replacement_count)
self.repl.set_replacement_count(3)
self.assertEqual(3, self.repl._replacement_count)
self.assertRaises(ValueError, self.repl.set_replacement_count, 4)
def test_select(self):
# attempting to maximize remove worst 3
self.repl.set_replacement_count(3)
values = [i for i in self.repl.select()]
self.assertLessEqual(self.repl._fitness_list[values[0]][0], self.repl._fitness_list[values[1]][0])
self.assertLessEqual(self.repl._fitness_list[values[1]][0], self.repl._fitness_list[values[2]][0])
# attempting to minimize remove worst 3
self.fitness_list = FitnessList(MIN)
values = [i for i in self.repl.select()]
self.assertGreaterEqual(self.repl._fitness_list[values[0]][0], self.repl._fitness_list[values[1]][0])
self.assertGreaterEqual(self.repl._fitness_list[values[1]][0], self.repl._fitness_list[values[2]][0])
class TestFitnessProportionate(unittest.TestCase):
def setUp(self):
# Check truncation
self.fitness = FitnessList(MAX)
self.fitness.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
def test_class_init_(self):
# is the scaling type set
# does it check the number range
fit = FitnessProportionate(self.fitness, SCALING_LINEAR)
self.assertNotEqual(None, fit._scaling_type)
# add some negative numbers
self.fitness.extend([[-.5, 3], [-.25, 4], [2.5, 2]])
self.assertRaises(ValueError, FitnessProportionate, self.fitness,
SCALING_LINEAR)
def test_set_scaling_type(self):
fit = FitnessProportionate(self.fitness, SCALING_LINEAR)
self.assertEqual(SCALING_LINEAR, fit._scaling_type)
def test_check_minmax(self):
self.fitness.extend([[.5, 3], [.25, 1], [-2.5, 2]])
self.assertRaises(ValueError, FitnessProportionate, self.fitness,
SCALING_LINEAR)
def test_select(self):
fit = FitnessProportionate(self.fitness, SCALING_LINEAR)
self.assertEqual(3, len([i for i in fit.select()]))
def test_apply_prop_scaling(self):
# This scales the list according to the scaling type
param = None
# Check linear
fit = FitnessProportionate(self.fitness, SCALING_LINEAR)
scaling_list = fit._apply_prop_scaling(param)
self.assertAlmostEqual(1.0, sum(scaling_list))
self.assertAlmostEqual(0.09375, scaling_list[0])
self.assertAlmostEqual(0.15625, scaling_list[1])
self.assertAlmostEqual(0.75, scaling_list[2])
# Check exponential
fit = FitnessProportionate(self.fitness, SCALING_EXPONENTIAL)
scaling_list = fit._apply_prop_scaling(param)
self.assertAlmostEqual(1.0, sum(scaling_list))
self.assertAlmostEqual(0.014754098360655738, scaling_list[0])
self.assertAlmostEqual(0.040983606557377046, scaling_list[1])
self.assertAlmostEqual(0.94426229508196724, scaling_list[2])
fit = FitnessProportionate(self.fitness, SCALING_EXPONENTIAL)
scaling_list = fit._apply_prop_scaling(param=1.5)
self.assertAlmostEqual(1.0, sum(scaling_list))
self.assertAlmostEqual(0.038791152234464166, scaling_list[0])
self.assertAlmostEqual(0.083465270324597968, scaling_list[1])
self.assertAlmostEqual(0.87774357744093778, scaling_list[2])
# Check log
fit = FitnessProportionate(self.fitness, SCALING_LOG)
scaling_list = fit._apply_prop_scaling(param)
self.assertAlmostEqual(1.0, sum(scaling_list))
self.assertAlmostEqual(0.10651459360996007, scaling_list[0])
self.assertAlmostEqual(0.24070711137026513, scaling_list[1])
self.assertAlmostEqual(0.6527782950197748, scaling_list[2])
# Check truncation
fit = FitnessProportionate(self.fitness, SCALING_TRUNC)
scaling_list = fit._apply_prop_scaling(param=2.0)
self.assertAlmostEqual(1.0, sum(scaling_list))
self.assertAlmostEqual(0.0, scaling_list[0])
self.assertAlmostEqual(0.17241379310344829, scaling_list[1])
self.assertAlmostEqual(0.82758620689655171, scaling_list[2])
class TestFitnessProportionate(unittest.TestCase):
def setUp(self):
# Check truncation
self.fitness = FitnessList(MAX)
self.fitness.extend([[1.5, 0], [2.5, 1], [12.0, 2]])
def test_class_init_(self):
# is the scaling type set
# does it check the number range
fit = FitnessProportionate(self.fitness, SCALING_LINEAR)
self.assertNotEqual(None, fit._scaling_type)
# add some negative numbers
self.fitness.extend([[-0.5, 3], [-0.25, 4], [2.5, 2]])
self.assertRaises(ValueError, FitnessProportionate, self.fitness, SCALING_LINEAR)
def test_set_scaling_type(self):
fit = FitnessProportionate(self.fitness, SCALING_LINEAR)
self.assertEqual(SCALING_LINEAR, fit._scaling_type)
def test_check_minmax(self):
self.fitness.extend([[0.5, 3], [0.25, 1], [-2.5, 2]])
self.assertRaises(ValueError, FitnessProportionate, self.fitness, SCALING_LINEAR)
def test_select(self):
fit = FitnessProportionate(self.fitness, SCALING_LINEAR)
self.assertEqual(3, len([i for i in fit.select()]))
def test_apply_prop_scaling(self):
# This scales the list according to the scaling type
param = None
# Check linear
fit = FitnessProportionate(self.fitness, SCALING_LINEAR)
scaling_list = fit._apply_prop_scaling(param)
self.assertAlmostEqual(1.0, sum(scaling_list))
self.assertAlmostEqual(0.09375, scaling_list[0])
self.assertAlmostEqual(0.15625, scaling_list[1])
self.assertAlmostEqual(0.75, scaling_list[2])
# Check exponential
fit = FitnessProportionate(self.fitness, SCALING_EXPONENTIAL)
scaling_list = fit._apply_prop_scaling(param)
self.assertAlmostEqual(1.0, sum(scaling_list))
self.assertAlmostEqual(0.014754098360655738, scaling_list[0])
self.assertAlmostEqual(0.040983606557377046, scaling_list[1])
self.assertAlmostEqual(0.94426229508196724, scaling_list[2])
fit = FitnessProportionate(self.fitness, SCALING_EXPONENTIAL)
scaling_list = fit._apply_prop_scaling(param=1.5)
self.assertAlmostEqual(1.0, sum(scaling_list))
self.assertAlmostEqual(0.038791152234464166, scaling_list[0])
self.assertAlmostEqual(0.083465270324597968, scaling_list[1])
self.assertAlmostEqual(0.87774357744093778, scaling_list[2])
# Check log
fit = FitnessProportionate(self.fitness, SCALING_LOG)
scaling_list = fit._apply_prop_scaling(param)
self.assertAlmostEqual(1.0, sum(scaling_list))
self.assertAlmostEqual(0.10651459360996007, scaling_list[0])
self.assertAlmostEqual(0.24070711137026513, scaling_list[1])
self.assertAlmostEqual(0.6527782950197748, scaling_list[2])
# Check truncation
fit = FitnessProportionate(self.fitness, SCALING_TRUNC)
scaling_list = fit._apply_prop_scaling(param=2.0)
self.assertAlmostEqual(1.0, sum(scaling_list))
self.assertAlmostEqual(0.0, scaling_list[0])
self.assertAlmostEqual(0.17241379310344829, scaling_list[1])
self.assertAlmostEqual(0.82758620689655171, scaling_list[2])
def test_scale_list(self):
#
# fitness type MAX, test select type MAX
#
fitness = FitnessList(MAX)
fitness.extend([[.5, 0], [.25, 1], [2.5, 2]])
fit = Fitness(fitness)
fit.set_selection_type(MAX)
fit._scale_list()
# not inverted
self.assertAlmostEqual(.5, fit._selection_list[0])
self.assertAlmostEqual(.25, fit._selection_list[1])
self.assertAlmostEqual(2.5, fit._selection_list[2])
#
# fitness type MAX, test select type MIN
#
fit.set_fitness_list(fitness)
fit.set_selection_type(MIN)
fit._scale_list()
# inverted
self.assertAlmostEqual(2.0, fit._selection_list[0])
self.assertAlmostEqual(4.0, fit._selection_list[1])
self.assertAlmostEqual(0.4, fit._selection_list[2])
#
# fitness type MIN, test select type MAX
#
fitness.set_fitness_type(MIN)
fit.set_fitness_list(fitness)
fit.set_selection_type(MAX)
fit._scale_list()
# inverted
self.assertAlmostEqual(2.0, fit._selection_list[0])
self.assertAlmostEqual(4.0, fit._selection_list[1])
self.assertAlmostEqual(0.4, fit._selection_list[2])
#
# fitness type MIN, test select type MIN
#
fit.set_fitness_list(fitness)
fit.set_selection_type(MIN)
fit._scale_list()
# not inverted
self.assertAlmostEqual(.5, fit._selection_list[0])
self.assertAlmostEqual(.25, fit._selection_list[1])
self.assertAlmostEqual(2.5, fit._selection_list[2])
#
# fitness type CENTER, test select type MAX
#
fitness.set_fitness_type(CENTER)
fitness.set_target_value(.75)
fit.set_fitness_list(fitness)
fit.set_selection_type(MAX)
fit._scale_list()
# inverted
self.assertAlmostEqual(4.0, fit._selection_list[0])
self.assertAlmostEqual(2.0, fit._selection_list[1])
self.assertAlmostEqual(0.5714285714, fit._selection_list[2])
#
# fitness type CENTER, test select type MIN
#
fit.set_fitness_list(fitness)
fit.set_selection_type(MIN)
fit._scale_list()
# not inverted
self.assertAlmostEqual(.25, fit._selection_list[0])
self.assertAlmostEqual(.5, fit._selection_list[1])
self.assertAlmostEqual(1.75, fit._selection_list[2])
def test_scale_list(self):
#
# fitness type MAX, test select type MAX
#
fitness = FitnessList(MAX)
fitness.extend([[0.5, 0], [0.25, 1], [2.5, 2]])
fit = Fitness(fitness)
fit.set_selection_type(MAX)
fit._scale_list()
# not inverted
self.assertAlmostEqual(0.5, fit._selection_list[0])
self.assertAlmostEqual(0.25, fit._selection_list[1])
self.assertAlmostEqual(2.5, fit._selection_list[2])
#
# fitness type MAX, test select type MIN
#
fit.set_fitness_list(fitness)
fit.set_selection_type(MIN)
fit._scale_list()
# inverted
self.assertAlmostEqual(2.0, fit._selection_list[0])
self.assertAlmostEqual(4.0, fit._selection_list[1])
self.assertAlmostEqual(0.4, fit._selection_list[2])
#
# fitness type MIN, test select type MAX
#
fitness.set_fitness_type(MIN)
fit.set_fitness_list(fitness)
fit.set_selection_type(MAX)
fit._scale_list()
# inverted
self.assertAlmostEqual(2.0, fit._selection_list[0])
self.assertAlmostEqual(4.0, fit._selection_list[1])
self.assertAlmostEqual(0.4, fit._selection_list[2])
#
# fitness type MIN, test select type MIN
#
fit.set_fitness_list(fitness)
fit.set_selection_type(MIN)
fit._scale_list()
# not inverted
self.assertAlmostEqual(0.5, fit._selection_list[0])
self.assertAlmostEqual(0.25, fit._selection_list[1])
self.assertAlmostEqual(2.5, fit._selection_list[2])
#
# fitness type CENTER, test select type MAX
#
fitness.set_fitness_type(CENTER)
fitness.set_target_value(0.75)
fit.set_fitness_list(fitness)
fit.set_selection_type(MAX)
fit._scale_list()
# inverted
self.assertAlmostEqual(4.0, fit._selection_list[0])
self.assertAlmostEqual(2.0, fit._selection_list[1])
self.assertAlmostEqual(0.5714285714, fit._selection_list[2])
#
# fitness type CENTER, test select type MIN
#
fit.set_fitness_list(fitness)
fit.set_selection_type(MIN)
fit._scale_list()
# not inverted
self.assertAlmostEqual(0.25, fit._selection_list[0])
self.assertAlmostEqual(0.5, fit._selection_list[1])
self.assertAlmostEqual(1.75, fit._selection_list[2])
