def main(): #Nolan put everyones methods together and made main. stdout = "Please pick from the following options to determine the board size:" stdout += "\n a) 4\n b) 8\n c) 16\n>: " response = "" while response not in ["a", "A", "b", "B", "c", "C"]: response = raw_input(stdout) if response not in ["a", "A", "b", "B", "c", "C"]: print "*Incorrect input. Please enter the letter that corresponds to your choice\n" if response in ["a", "A"]: board = nqueens.Board(4) elif response in ["b", "B"]: board = nqueens.Board(8) else: board = nqueens.Board(16) board.rand() stay_in_loop = True while stay_in_loop: try: T = float(raw_input("Enter a value for T: ")) min_T = float( raw_input("Enter a value for threshold of termination: ")) decay = float(raw_input("Enter a value for the rate of decay: ")) print "" stay_in_loop = False except: print "Invalid value entered. Try again.\n" schedule = Simulated_Annealing(T, board, min_T, decay) print "##############################" print "decay rate is: " + str(decay) print "##############################" print " " print " " print " " schedule.annealing()
def ConsoleMain( ): #This main method is primarily for testing. The one that outputs to a file is below. stdout = "Please pick from the following options to determine the board size:" stdout += "\n a) 4\n b) 8\n c) 16\n>: " response = "" while response not in ["a", "A", "b", "B", "c", "C"]: response = raw_input(stdout) if response not in ["a", "A", "b", "B", "c", "C"]: print "*Incorrect input. Please enter the letter that corresponds to your choice\n" if response in ["a", "A"]: board = nqueens.Board(4) elif response in ["b", "B"]: board = nqueens.Board(8) else: board = nqueens.Board(16) board.rand() stay_in_loop = True while stay_in_loop: try: T = float(raw_input("Enter a value for T: ")) min_T = float( raw_input("Enter a value for threshold of termination: ")) decay = float(raw_input("Enter a value for the rate of decay: ")) print "" stay_in_loop = False except: print "Invalid value entered. Try again.\n" schedule = Simulated_Annealing(T, board, min_T, decay) print decay schedule.annealing(True)
def main(): board_sizes = [4, 8, 16] thresh_values = [.000001, .0000001, .00000001] decay_rate = [0.9, 0.75, 0.5] for x in board_sizes: print("**********************************") print("Board Size: ", x) print("**********************************") for j in range(len(decay_rate)): print("decayRate: %s ThresHold: %e" % (decay_rate[j], thresh_values[j])) print("######################################") count_h_value = 0 for i in range(10): print('Run', i) print('Initial: ') board = nqueens.Board(x) board.rand() board.printBoard() print("h-value: ", nqueens.numAttackingQueens(board)) answer = simulated_annealing(decay_rate[j], board, thresh_values[j]) print("Final h_value: ", answer.h) answer.printBoard() count_h_value += answer.h print("--------------------------------------") print("Average h value: ", count_h_value / 10) print("--------------------------------------")
def test_correct_size4(self): test = nqueens.Board(4) test.place_queen(0, 2) test.place_queen(1, 0) test.place_queen(2, 3) test.place_queen(3, 1) self.assertEqual(test.verify_board(), 0, 'Board should pass')
def main(): print('in main') pairs = [[0.9, 0.000001], [0.75, 0.0000001], [0.5, 0.00000001]] board_size = [4, 8, 16] for i in pairs: print("#############################################\n", "Decay Rate: ", i[0], " T Threshold: ", i[1], "\n" "#############################################") for n in board_size: print("*********************\n", " Board Size: ", n, "\n" "*********************") average_h = 0.0 for g in range(0, 10): startingBoard = nqueens.Board(n) startingBoard.rand() final_board = simulatedAnnealing(startingBoard, i[0], i[1]) print("*********************\n", " Run ", g + 1, "\n" "*********************") print("Initial Board: ") startingBoard.printBoard() print("Initial Board h-value ", startingBoard.h) print("Final Board: ") final_board.printBoard() print("Final Board h-value: ", final_board.h) average_h += final_board.h average_h = average_h / 10 print("Average h-cost of final solutions: ", average_h)
def Main(): for i in range(2, 5): print("********************\n", "Board Size: ", 2**i, "\n********************\n", "######################################\n", "Decay Rate: 0.9 T Threshold: 0.000001\n", "######################################") b = nqueens.Board(2**i) bhAvg = 0 for j in range(1, 11): print("Run ", j) b.rand() print("Initial Board:") b.printBoard() b.h = nqueens.numAttackingQueens(b) print("Initial h-value: ", b.h) b = simulatedAnnealing(b, 0.9, 0.000001) print("Final Board:") b.printBoard() print("Final h-value: ", b.h, "\n") bhAvg = bhAvg + b.h bhAvg = bhAvg/10 print("********************\n", "Average H-Value: ", bhAvg, "\n********************\n") print("######################################\n", "Decay Rate: 0.75 T Threshold: 0.0000001\n", "######################################") bhAvg = 0 for j in range(1, 11): print("Run ", j) b.rand() print("Initial Board:") b.printBoard() b.h = nqueens.numAttackingQueens(b) print("Initial h-value: ", b.h) b = simulatedAnnealing(b, 0.75, 0.0000001) print("Final Board:") b.printBoard() print("Final h-value: ", b.h, "\n") bhAvg = bhAvg + b.h bhAvg = bhAvg/10 print("********************\n", "Average H-Value: ", bhAvg, "\n********************\n") print("######################################\n", "Decay Rate: 0.5 T Threshold: 0.00000001\n", "######################################") bhAvg = 0 for j in range(1, 11): print("Run ", j) b.rand() print("Initial Board:") b.printBoard() b.h = nqueens.numAttackingQueens(b) print("Initial h-value: ", b.h) b = simulatedAnnealing(b, 0.5, 0.00000001) print("Final Board:") b.printBoard() print("Final h-value: ", b.h, "\n") bhAvg = bhAvg + b.h bhAvg = bhAvg/10 print("********************\n", "Average H-Value: ", bhAvg, "\n********************\n")
def test_x_out_of_scope(self): test = nqueens.Board(4) test.place_queen(0, 0) test.place_queen(5, 3) self.assertEqual( test.verify_board(), 0, 'ERROR:root:Error placing queen 5,3: list index out of range', )
def test_initialize(self): """Procedure: 1. initialize the board ------------ Verification: 2. check board size """ test = nqueens.Board(4) self.assertEqual(test.n, 4, 'Incorrect Board Size')
def main(): print('In main') run_count = 0 for size in board_size: print("Board size:", size) for each in simulation_pairs: h_values = [] print("Decay Rate =", each[0], "T Threshold =", each[1]) print("\n") for x in range(0, 10): print("Run", x) startingBoard = nq.Board(size) startingBoard.rand() print("Initial Board:") startingBoard.printBoard() print_initial_h(startingBoard) temp = simulatedAnnealing(startingBoard, each[1], each[0]) h_values.append(temp) print("Average h-value =", (sum(h_values) / len(h_values)))
def test_diagonal_fail_size1000(self): test = nqueens.Board(1000) test.place_queen(0, 0) test.place_queen(999, 999) self.assertEqual(test.verify_board(), 2, 'Looking for 2 Queen misplaced')
def test_vertical_fail_size1000(self): test = nqueens.Board(1000) test.place_queen(0, 1) test.place_queen(850, 1) self.assertEqual(test.verify_board(), 2, 'Looking for 2 Queen misplaced')
def test_horizontal_fail_size1000(self): test = nqueens.Board(1000) test.place_queen(0, 0) test.place_queen(0, 962) self.assertEqual(test.verify_board(), 2, 'Looking for 2 Queen misplaced')
def test_diagonal_fail(self): test = nqueens.Board(4) test.place_queen(0, 0) test.place_queen(3, 3) self.assertEqual(test.verify_board(), 2, 'Looking for 2 Queen misplaced')
def main(): T = 100 #Board size of 4, and the subsequent output loops bSize = 4 b = nqueens.Board(bSize) b.rand() decayRate = 0.9 tHold = 0.000001 print("Board Size: " + str(bSize)) x = 0 while (x < 10): print( "\n#####################################################\n\nRun " + str(x + 1)) print("Initial Board State: ") b.printBoard() print("\nh value: " + str(b.h)) print("Decay Rate: " + str(decayRate) + " " + "T Threshold: " + str(tHold)) d = annealing(b, T, decayRate, tHold) print("") print("Final board: ") d.printBoard() print("Final h value: " + str(d.h)) x += 1 decayRate = 0.75 tHold = 0.0000001 x = 0 while (x < 10): print( "\n#####################################################\n\nRun " + str(x + 1)) print("Initial Board State: ") b.printBoard() print("\nh value: " + str(b.h)) print("Decay Rate: " + str(decayRate) + " " + "T Threshold: " + str(tHold)) d = annealing(b, T, decayRate, tHold) print("") print("Final board: ") d.printBoard() print("Final h value: " + str(d.h)) x += 1 decayRate = .5 tHold = 0.00000001 x = 0 while (x < 10): print( "\n#####################################################\n\nRun " + str(x + 1)) print("Initial Board State: ") b.printBoard() print("\nh value: " + str(b.h)) print("Decay Rate: " + str(decayRate) + " " + "T Threshold: " + str(tHold)) d = annealing(b, T, decayRate, tHold) print("") print("Final board: ") d.printBoard() print("Final h value: " + str(d.h)) x += 1 ############################################################################################################## #Boardsize of 8, and the subsequent output loops bSize = 8 b = nqueens.Board(bSize) b.rand() decayRate = 0.9 tHold = 0.000001 print("Board Size: " + str(bSize)) x = 0 while (x < 10): print( "\n#####################################################\n\nRun " + str(x + 1)) print("Initial Board State: ") b.printBoard() print("\nh value: " + str(b.h)) print("Decay Rate: " + str(decayRate) + " " + "T Threshold: " + str(tHold)) d = annealing(b, T, decayRate, tHold) print("") print("Final board: ") d.printBoard() print("Final h value: " + str(d.h)) x += 1 decayRate = 0.75 tHold = 0.0000001 x = 0 while (x < 10): print( "\n#####################################################\n\nRun " + str(x + 1)) print("Initial Board State: ") b.printBoard() print("\nh value: " + str(b.h)) print("Decay Rate: " + str(decayRate) + " " + "T Threshold: " + str(tHold)) d = annealing(b, T, decayRate, tHold) print("") print("Final board: ") d.printBoard() print("Final h value: " + str(d.h)) x += 1 decayRate = .5 tHold = 0.00000001 x = 0 while (x < 10): print( "\n#####################################################\n\nRun " + str(x + 1)) print("Initial Board State: ") b.printBoard() print("\nh value: " + str(b.h)) print("Decay Rate: " + str(decayRate) + " " + "T Threshold: " + str(tHold)) d = annealing(b, T, decayRate, tHold) print("") print("Final board: ") d.printBoard() print("Final h value: " + str(d.h)) x += 1 ############################################################################################################################### #Board size of 16, and the subsequent output loops bSize = 16 b = nqueens.Board(bSize) b.rand() decayRate = 0.9 tHold = 0.000001 print("Board Size: " + str(bSize)) x = 0 while (x < 10): print( "\n#####################################################\n\nRun " + str(x + 1)) print("Initial Board State: ") b.printBoard() print("\nh value: " + str(b.h)) print("Decay Rate: " + str(decayRate) + " " + "T Threshold: " + str(tHold)) d = annealing(b, T, decayRate, tHold) print("") print("Final board: ") d.printBoard() print("Final h value: " + str(d.h)) x += 1 decayRate = 0.75 tHold = 0.0000001 x = 0 while (x < 10): print( "\n#####################################################\n\nRun " + str(x + 1)) print("Initial Board State: ") b.printBoard() print("\nh value: " + str(b.h)) print("Decay Rate: " + str(decayRate) + " " + "T Threshold: " + str(tHold)) d = annealing(b, T, decayRate, tHold) print("") print("Final board: ") d.printBoard() print("Final h value: " + str(d.h)) x += 1 decayRate = .5 tHold = 0.00000001 x = 0 while (x < 10): print( "\n#####################################################\n\nRun " + str(x + 1)) print("Initial Board State: ") b.printBoard() print("\nh value: " + str(b.h)) print("Decay Rate: " + str(decayRate) + " " + "T Threshold: " + str(tHold)) d = annealing(b, T, decayRate, tHold) print("") print("Final board: ") d.printBoard() print("Final h value: " + str(d.h)) x += 1
def acceptance_probability(delta_e, T): return decimal.Decimal(decimal.Decimal(math.e)**(decimal.Decimal(delta_e) / decimal.Decimal(T))) print("######################################") print("Decay rate 0.9 T Threshold 0.000001" ) print("######################################") for i in range(0, 3): if i == 0: print("*************") print("Board Size: 4") print("*************") average_h = 0 for j in range(0, 10): b = nqueens.Board(4) b.rand() print "Initial board:" b.printBoard() print "Initial h value: ", b.numAttackingQueens() average_h = average_h + anneal(b, .000001, .9) print "Average h-cost of final solutions: ", average_h / 10 elif i == 1: print("*************") print("Board Size: 8") print("*************") average_h = 0 for j in range(0, 10): b = nqueens.Board(8) b.rand() print "Initial board:"
def main(): print('**********************************') print('BOARD SIZE: 4 DECAY RATE 0.9 TRHESHOLD: 0.000001') print('**********************************') hAvg = 0 for x in range(10): print('RUN', x) startingBoard = nqueens.Board(4) startingBoard.rand() startingBoard.printBoard() print('INITIAL h VALUE', nqueens.numAttackingQueens(startingBoard)) print('') hAvg = simulatedAnnealing(startingBoard, 0.9, 0.000001) print('AVERAGE h VALUE: ', hAvg / 10) print('**********************************') print('BOARD SIZE: 8 DECAY RATE 0.9 TRHESHOLD: 0.000001') print('**********************************') hAvg = 0 for x in range(10): print('RUN', x) startingBoard = nqueens.Board(8) startingBoard.rand() startingBoard.printBoard() print('INITIAL h VALUE', nqueens.numAttackingQueens(startingBoard)) print('') hAvg = hAvg + simulatedAnnealing(startingBoard, 0.9, 0.000001) print('AVERAGE h VALUE: ', hAvg / 10) print('**********************************') print('BOARD SIZE: 16 DECAY RATE 0.9 TRHESHOLD: 0.000001') print('**********************************') hAvg = 0 for x in range(10): print('RUN', x) startingBoard = nqueens.Board(16) startingBoard.rand() startingBoard.printBoard() print('INITIAL h VALUE', nqueens.numAttackingQueens(startingBoard)) print('') hAvg = hAvg + simulatedAnnealing(startingBoard, 0.9, 0.000001) print('') print('AVERAGE h VALUE: ', hAvg / 10) print('**********************************') print('BOARD SIZE: 4 DECAY RATE 0.75 TRHESHOLD: 0.0000001') print('**********************************') hAvg = 0 for x in range(10): print('RUN', x) startingBoard = nqueens.Board(4) startingBoard.rand() startingBoard.printBoard() print('INITIAL h VALUE', nqueens.numAttackingQueens(startingBoard)) print('') hAvg = hAvg + simulatedAnnealing(startingBoard, 0.75, 0.0000001) print('AVERAGE h VALUE: ', hAvg / 10) #FINISH THE h VAL PRINTING print('**********************************') print('BOARD SIZE: 8 DECAY RATE 0.75 TRHESHOLD: 0.0000001') print('**********************************') hAvg = 0 for x in range(10): print('RUN', x) startingBoard = nqueens.Board(8) startingBoard.rand() startingBoard.printBoard() print('INITIAL h VALUE', nqueens.numAttackingQueens(startingBoard)) print('') hAvg = hAvg + simulatedAnnealing(startingBoard, 0.75, 0.0000001) print('AVERAGE h VALUE: ', hAvg / 10) print('**********************************') print('BOARD SIZE: 16 DECAY RATE 0.75 TRHESHOLD: 0.0000001') print('**********************************') hAvg = 0 for x in range(10): print('RUN', x) startingBoard = nqueens.Board(16) startingBoard.rand() startingBoard.printBoard() print('INITIAL h VALUE', nqueens.numAttackingQueens(startingBoard)) print('') hAvg = hAvg + simulatedAnnealing(startingBoard, 0.75, 0.0000001) print('AVERAGE h VALUE: ', hAvg / 10) print('**********************************') print('BOARD SIZE: 4 DECAY RATE 0.5 TRHESHOLD: 0.00000001') print('**********************************') hAvg = 0 for x in range(10): print('RUN', x) startingBoard = nqueens.Board(4) startingBoard.rand() startingBoard.printBoard() print('INITIAL h VALUE', nqueens.numAttackingQueens(startingBoard)) print('') hAvg = hAvg + simulatedAnnealing(startingBoard, 0.5, 0.00000001) print('AVERAGE h VALUE: ', hAvg / 10) print('**********************************') print('BOARD SIZE: 8 DECAY RATE 0.75 TRHESHOLD: 0.0000001') print('**********************************') hAvg = 0 for x in range(10): print('RUN', x) startingBoard = nqueens.Board(8) startingBoard.rand() startingBoard.printBoard() print('INITIAL h VALUE', nqueens.numAttackingQueens(startingBoard)) print('') hAvg = hAvg + simulatedAnnealing(startingBoard, 0.5, 0.00000001) print('AVERAGE h VALUE: ', hAvg / 10) print('**********************************') print('BOARD SIZE: 16 DECAY RATE 0.75 TRHESHOLD: 0.0000001') print('**********************************') hAvg = 0 for x in range(10): print('RUN', x) startingBoard = nqueens.Board(16) startingBoard.rand() startingBoard.printBoard() print('INITIAL h VALUE', nqueens.numAttackingQueens(startingBoard)) print('') hAvg = hAvg + simulatedAnnealing(startingBoard, 0.5, 0.00000001) print('AVERAGE h VALUE: ', hAvg / 10)
def main(): T = INITIAL_T # temperature variable is set to it's initial value decay_rate = [ .9, .75, .5 ] #test values for decay rate. values #provided by Sterling McLeod threshold = [ 0.000001, 0.0000001, 0.00000001 ] #test values for threshold T must reach to terminate the loop. values #provided by Sterling McLeod board_size = [4, 8, 16] # testor board sizes #provided by instructor time = 0 #todo: do we actualy need this variable? board = None waittime = 0 sum_fin_h_vals = 0 #will hold the sum of all final h values num_iterations = 10 #the number of times each threshold-decay-rate pairing is tested suc_states = None h_vals = [] #temp testor variable holder fin_board = None for x in range(len(board_size)): print("_" * 51, "\n\nFor board size ", board_size[x], "\n_", "_" * 50, "\n") for y in range(len(threshold)): testVals = [threshold[y], decay_rate[y]] #stores this iteration's testing values print("_" * 21, "\n\nThreshold: ", testVals[0], "\nDecay Rate: ", testVals[1], "\n_", "_" * 20, "\n") sum_fin_h_vals = 0 #resets the sum of final h values variable for z in range(num_iterations): if z == 2: print( "Please keep in mind this may take a momment to execute" ) #print("i looped. ", x, ", ", y, ", " , z)#temp: testor #note: this loop has been proven to work the correct number of times print("run #: ", z) T = INITIAL_T # temperature variable is set to it's initial value time = 0 #resets time board = nqueens.Board(board_size[x]) board.rand() board.h = nqueens.numAttackingQueens(board) print("intitial state: ", "\t\t\t\t\t\t\t\tintial h-value: ", board.h) print(board.printBoard()) #print("h-val after printboard ", board.h)#temp testor while (T >= testVals[0] and board.h != 0): suc_states = nqueens.getSuccessorStates(board) #print("suc states", suc_states)#temp testor for i in suc_states: temp_h = nqueens.numAttackingQueens(i) if (temp_h < board.h): board.h = temp_h fin_board = i # h_vals.append(board.h)#temp testing mechanism # print("h-val during suc_states loop ", h_vals)#temp testor # print("h after the sucstates loop", board.h) T = get_ft(T, testVals[1]) #decrements T time += 1 #increments time # print("\t\t T = ", T, "at time ", time, "h val is ", board.h)#temp testor # while(input("************************************please Press enter to continue***************************************************") != "" ): # waittime += 1 sum_fin_h_vals += board.h print("final state: ", "\t\t\t\t\t\t\t\tfinal h-value: ", board.h) print(fin_board.printBoard()) while (input( "**************************please Press enter to continue****************************" ) != ""): waittime += 1 #just a placeholder so the syntax will work avg_time = (sum_fin_h_vals / num_iterations) print( "_" * 21, "\n\nAverage h-value for decay rate", testVals[1], " and threshold ", testVals[0], " is : ", avg_time, "\n_", "_" * 20, "\n\n", "*" * 20 ) #todo: make this display the threshold and decay rate info too while (input( "**********************please Press enter to continue*****************************" ) != ""): waittime += 1 #just a placeholder so the syntax will work print("done") #temp testor
def test_diagonal_fail3(self): test = nqueens.Board(6) test.place_queen(2, 2) test.place_queen(4, 0) self.assertEqual(test.verify_board(), 2, 'Looking for 2 Queen misplaced')