def test_grow_exogenous_regions_queen(self):
"""Number of regions is exogenous, aka given (Wqueen)"""
am = AreaManager(self.Wqueen, self.Y)
for regions in xrange(1, max_num_regions):
rm = RegionMaker(am, pRegions=regions)
self.assertEqual(regions, len(rm.region2Area))
self.assertTrue(am.checkFeasibility(rm.returnRegions()))
def test_grow_exogenous_regions_queen(self):
"""Number of regions is exogenous, aka given (Wqueen)"""
am = AreaManager(self.Wqueen, self.Y)
for regions in xrange(1, max_num_regions):
rm = RegionMaker(am, pRegions=regions)
self.assertEqual(regions, len(rm.region2Area))
self.assertTrue(am.checkFeasibility(rm.returnRegions()))
def test_impossible_solution_configuration_on_rook(self):
"""
Using the Wrook, test for a impossible region assignment.
"""
"""
Possible solution:
0011
0101
"""
possible_solution = [0, 0, 1, 1, 0, 1, 0, 1]
am = AreaManager(self.Wrook, self.Y)
result = am.checkFeasibility(possible_solution)
self.assertFalse(result)
def test_possible_solution_configuration_on_rook(self):
"""
Using the Wrook, test for a possible region assignment
"""
"""
Possible solution:
0112
0002
"""
possible_solution = [0, 1, 1, 2, 0, 0, 0, 2]
am = AreaManager(self.Wrook, self.Y)
result = am.checkFeasibility(possible_solution)
self.assertTrue(result)
def test_impossible_solution_configuration_on_queen(self):
"""
Using the Wqueen, test for an impossible region assignment
"""
"""
Impossible solution:
0110
1010
"""
possible_solution = [0, 1, 1, 0, 1, 0, 1, 0]
am = AreaManager(self.Wqueen, self.Y)
result = am.checkFeasibility(possible_solution)
self.assertFalse(result)
def test_randomness_on_same_process(self):
"""This tests that running multiple instances of the region maker
on the same script (process) will """
am = AreaManager(self.Wrook, self.Y)
regions = []
for _reg in xrange(1, max_num_regions):
rm = RegionMaker(am, pRegions=max_num_regions)
self.assertEqual(max_num_regions, len(rm.region2Area))
self.assertTrue(am.checkFeasibility(rm.returnRegions()))
regions.append(rm.returnRegions())
for regioni in xrange(len(regions) - 1):
for regionj in xrange(regioni + 1, len(regions)):
self.assertNotEqual(regions[regioni], regions[regionj])
def test_randomness_on_same_process(self):
"""This tests that running multiple instances of the region maker
on the same script (process) will """
am = AreaManager(self.Wrook, self.Y)
regions = []
for _reg in xrange(1, max_num_regions):
rm = RegionMaker(am, pRegions=max_num_regions)
self.assertEqual(max_num_regions, len(rm.region2Area))
self.assertTrue(am.checkFeasibility(rm.returnRegions()))
regions.append(rm.returnRegions())
for regioni in xrange(len(regions) - 1):
for regionj in xrange(regioni + 1, len(regions)):
self.assertNotEqual(regions[regioni], regions[regionj])
def test_possible_solution_configuration_on_rook_w_empty_region(self):
"""
Using the Wrook, test for a impossible region assignment where one
area is missing.
"""
"""
Possible solution:
0022
0202
"""
possible_solution = [0, 0, 2, 2, 0, 2, 0, 2]
am = AreaManager(self.Wrook, self.Y)
result = am.checkFeasibility(possible_solution)
self.assertFalse(result)
def test_possible_solution_configuration_on_rook_w_one_region(self):
"""
Using the Wrook, test for a possible region assignment where only
one region exists.
"""
"""
Possible solution:
0000
0000
"""
possible_solution = [0, 0, 0, 0, 0, 0, 0, 0]
am = AreaManager(self.Wrook, self.Y)
result = am.checkFeasibility(possible_solution)
self.assertTrue(result)
def _final_regions_are_contiguous_in_instance(instance):
exp_name = instance.fieldNames[-1]
clustering_results = instance.outputCluster[exp_name]
final_region_assignment = clustering_results['r2a']
am = AreaManager(instance.Wrook, instance.Y)
return am.checkFeasibility(final_region_assignment)
def _final_regions_are_contiguous_in_instance(instance):
exp_name = instance.fieldNames[-1]
clustering_results = instance.outputCluster[exp_name]
final_region_assignment = clustering_results['r2a']
am = AreaManager(instance.Wrook, instance.Y)
return am.checkFeasibility(final_region_assignment)
