def helper(input_filename, expected_filename, R, M_threshold, B_threshold, max_num_steps, expected_num_relocations): ''' Do one simulation with the specified parameters (R, threshold, max_num_steps) starting from the specified input file. Match actual grid generated with the expected grid and match expected steps and actual steps. Inputs: input_filename: (string) name of the input grid file expected_filename: (string) name of the expected grid file. R: (int) radius for the neighborhood M_threshold: lower bound for similarity score for maroon homeowners B_threshold: lower bound for similarity score for blue homeowners max_steps: (int) maximum number of steps to do expected_num_relocations: (int) expected number of relocations performed during the simulation ''' input_filename = os.path.join(BASE_DIR, input_filename) actual_grid = utility.read_grid(input_filename) expected_num_homeowners = count_homeowners(actual_grid) opens = utility.find_opens(actual_grid) actual_num_relocations = do_simulation(actual_grid, R, M_threshold, B_threshold, max_num_steps, opens) actual_num_homeowners = count_homeowners(actual_grid) expected_filename = os.path.join(BASE_DIR, expected_filename) expected_grid = utility.read_grid(expected_filename) if actual_num_relocations != expected_num_relocations: s = ("actual and expected values number of relocations do not match\n" " got {:d}, expected {:d}") s = s.format(actual_num_relocations, expected_num_relocations) pytest.fail(s) if actual_num_homeowners != expected_num_homeowners: if actual_num_homeowners <= expected_num_homeowners: s = "Homeowners are fleeing the city!\n" else: s = ("The city is gaining homeowners.\n") s += (" Actual number of homeowners: {:d}\n" " Expected number of homeowners: {:d}\n") s = s.format(actual_num_homeowners, expected_num_homeowners) pytest.fail(s) mismatch = utility.find_mismatch(actual_grid, expected_grid) if mismatch: (i, j) = mismatch s = ("actual and expected grid values do not match " "at location ({:d}, {:d})\n") s = s.format(i, j) s = s + " got {}, expected {}".format(actual_grid[i][j], expected_grid[i][j]) pytest.fail(s)
def empty_homes(grid): ''' Based on the provided grid, create a list of tuples with the empty homes. Inputs: grid: the grid Returns: list of tuples with coordinates of empty homes ''' # utilize read_grid function from utility module to import grid grid = read_grid(grid) # Define an empty list of homes empty_homes_list = [] # procedure to obtain a list of empty homes from the grid # iterate through every element of the rows for i in range(len(grid)): # iterate through each of the columns for j in range(len(grid[0])): # if the element is if grid[i][j] == 'O': #store the index empty_homes_list.append((i,j)) return empty_homes_list
def go(grid_file, r, threshold, max_steps): ''' Put it all together: do the simulation and process the results. ''' if grid_file is None: print("No parameters specified: just loading the code.") return grid = utility.read_grid(grid_file) if len(grid) < 20: print("Initial state of city:") for row in grid: print(row) print() num_relocations = do_simulation(grid, r, threshold, max_steps) print("Number of relocations done: " + str(num_relocations)) if len(grid) < 20: print() print("Final state of the city:") for row in grid: print(row)
def helper(filename, R, i, j, num_homes, same, empty, expected): # set threshold to be just a bit below (when expected is true) or # above (when expected is false) the ratio of the satisfaction # score and the number of homes. threshold = (same + 0.5*empty)/num_homes + (-0.01 if expected else 0.01) grid = utility.read_grid(TEST_DIR + filename) actual = is_satisfied(grid, R, threshold, (i, j)) assert(actual == expected)
def helper_check_steps(input_filename, R, threshold, max_num_steps, expected_num_steps): ''' Do one simulation with the specified parameters (R, threshold, max_num_steps) starting from the specified input file. Compare the actual number of steps taken to the expected number of steps. ''' grid = utility.read_grid(TEST_DIR + input_filename) actual = do_simulation(grid, R, threshold, max_num_steps) assert(actual == expected_num_steps)
def helper(input_filename, expected_filename, R, threshold, max_num_steps, expected_num_steps): ''' Do one simulation with the specified parameters (R, threshold, max_num_steps) starting from the specified input file. Match actual grid generated with the expected grid and match expected steps and actual steps. ''' input_filename = os.path.join(BASE_DIR, input_filename) actual_grid = utility.read_grid(input_filename) actual_num_steps = do_simulation(actual_grid, R, threshold, max_num_steps) actual_num_homeowners = count_homeowners(actual_grid) expected_filename = os.path.join(BASE_DIR, expected_filename) expected_grid = utility.read_grid(expected_filename) expected_num_homeowners = count_homeowners(expected_grid) if actual_num_homeowners != expected_num_homeowners: if actual_num_homeowners <= expected_num_homeowners: s = "Homeowners are fleeing the city!\n" else: s = "City is gaining homeowners.\n" s += " Actual number of homeowners: {:d}\n".format(actual_num_homeowners) s += " Expected number of homeowners: {:d}\n".format(expected_num_homeowners) pytest.fail(s) mismatch = utility.find_mismatch(actual_grid, expected_grid) if mismatch: s = "actual and expected grid values do not match at location ({:d}, {:d})\n" s = s.format(mismatch[0], mismatch[1]) actual = actual_grid[mismatch[0]][mismatch[1]] expected = expected_grid[mismatch[0]][mismatch[1]] s += " got {}, expected {}".format(actual, expected) pytest.fail(s) # check steps only when expected steps >= 0 if expected_num_steps >= 0 and actual_num_steps != expected_num_steps: s = "actual and expected values number of steps do not match\n" s = s + " got {:d}, expected {:d}".format(actual_num_steps, expected_num_steps) pytest.fail(s)
def go(args): ''' Put it all together: parse the arguments, do the simulation and process the results. Inputs: args: (list of strings) the command-line arguments ''' usage = "usage: python schelling.py <grid file name> <R > 0> <0 < threshold <= 1.0> <max steps >= 0>\n" grid = None threshold = 0.0 R = 0 max_steps = 0 MAX_SMALL_GRID = 20 if (len(args) != 5): print(usage) sys.exit(0) # parse and check the arguments try: grid = utility.read_grid(args[1]) R = int(args[2]) if R <= 0: print("R must be greater than zero") sys.exit(0) threshold = float(args[3]) if (threshold <= 0.0 or threshold > 1.0): print("threshold must satisfy: 0 < threshold <= 1.0") sys.exit(0) max_steps = int(args[4]) if max_steps <= 0: print("max_steps must be greater than or equal to zero") sys.exit(0) except: print(usage) sys.exit(0) num_steps = do_simulation(grid, R, threshold, max_steps) if len(grid) < MAX_SMALL_GRID: for row in grid: print(row) else: print("Result grid too large to print") print("Number of steps simulated: " + str(num_steps))
def helper_check_relocations(input_filename, expected_filename, R, threshold, max_num_steps): ''' Do one simulation with the specified parameters (R, threshold, max_num_steps) starting from the specified input file. Match actual grid generated with the expected grid. ''' grid = utility.read_grid(TEST_DIR + input_filename) do_simulation(grid, R, threshold, max_num_steps) expected_grid = utility.read_grid(TEST_DIR + expected_filename) # compare the actual state of the city against the expected state for i in range(len(grid)): for j in range(len(grid[0])): expected = expected_grid[i][j] # strip unsatisfied indicator from the expected file, # if necessary expected = expected if "U" not in expected else expected[1] if grid[i][j] != expected: s = "actual and expected values do not match at location ({:d}, {:d})\n".format(i, j) s = s + "got {}, expected {}".format(grid[i][j], expected) pytest.fail(s)
def go(args): usage = "usage: python schelling.py <grid file name> <R > 0> <0 < threshold <= 1.0> <max steps >= 0>\n" grid = None threshold = 0.0 R = 0 max_steps = 0 MAX_SMALL_GRID = 20 if (len(args) != 5): print(usage) sys.exit(0) # parse and check the arguments try: grid = utility.read_grid(args[1]) R = int(args[2]) if R <= 0: print("R must be greater than zero") sys.exit(0) threshold = float(args[3]) if (threshold <= 0.0 or threshold > 1.0): print("threshold must be between 0.0 and 1.0 not inclusive") sys.exit(0) max_steps = int(args[4]) if max_steps <= 0: print("max_steps must be greater than or equal to zero") sys.exit(0) except: print(usage) sys.exit(0) num_steps = do_simulation(grid, R, threshold, max_steps) if len(grid) < MAX_SMALL_GRID: for row in grid: print(row) else: print("Result grid too large to print") print("Number of steps simulated: " + str(num_steps))
def helper_test_is_satisfied(filename, R, location, threshold, expected): ''' Check result of calling is_satisfied on the specified location with in an R-neighborhood with the specified threshold. Inputs: filename: (string) name of the input grid file R: (integer) neighborhood parameter location: (pair of integers) location in the grid to be tested threshold: (float) satisfaction threshold expected: (boolean) expected result. ''' grid = utility.read_grid(filename) actual = schelling.is_satisfied(grid, R, threshold, location) if actual != expected: s = "Actual value ({}) is not equal to the expected value ({}).\n" s = s + " @ location {} with R={:d} and threshold={:.2f}.\n" pytest.fail(s.format(actual, expected, location, R, threshold))
def helper_test_compute_similarity_score(filename, R, location, expected): ''' Check result of calling compute_similarity_score on the specified location with in an R-neighborhood with the specified threshold. Inputs: filename: (string) name of the input grid file R: (integer) neighborhood parameter location: (pair of integers) location in the grid to be tested expected: (float) expected result. ''' grid = utility.read_grid(filename) actual = schelling.compute_similarity_score(grid, R, location) if abs(actual - expected) > EPS or \ (math.isnan(actual) and not math.isnan(expected)) or \ (not math.isnan(actual) and math.isnan(expected)): s = "Actual value ({}) is not equal to the expected value ({}).\n" s = s + " @ location {} with R-{:d} neighborhoods.\n" pytest.fail(s.format(actual, expected, location, R))
def helper_test_is_satisfied(filename, R, location, M_threshold, B_threshold, expected): ''' Check result of calling is_satisfied on the specified location with in an R-neighborhood with the specified threshold. Inputs: filename: (string) name of the input grid file R: (integer) neighborhood parameter location: (pair of integers) location in the grid to be tested M_threshold: lower bound for similarity score for maroon homeowners B_threshold: lower bound for similarity score for blue homeowners expected: (float) expected result. ''' grid = utility.read_grid(filename) actual = schelling.is_satisfied(grid, R, location, M_threshold, B_threshold) if actual != expected: s = "Actual value ({}) is not equal to the expected value ({}).\n" s = s + " @ location {} with R-{:d} neighborhoods.\n" pytest.fail(s.format(actual, expected, location, R))
import os import sys import utility # Define lists empty_homes = [] R = 2 grid2 = utility.read_grid("grid4.txt", strip_Us=True) grid = [['R', 'R', 'O', 'R', 'R', 'R'], ['O', 'B', 'B', 'B', 'B', 'R'], ['R', 'R', 'R', 'R', 'R', 'R'], ['B', 'B', 'B', 'O', 'B', 'R'], ['R', 'O', 'R', 'R', 'O', 'R'], ['R', 'O', 'R', 'R', 'O', 'R']] print(grid) # obtain a list of empty homes # iterate through each element of a row for i in range(len(grid)): # iterate through each of the columns for j in range(len(grid[0])): # if the element is if grid[i][j] == 'O': #store the index empty_homes.append((i,j)) #print(empty_homes) location = (2, 2)