def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) test case: avg = runSimulation(10, 1.0, 15, 20, 0.8, 30, Robot, False) """ # TODO: Your code goes here trialsCollection = [] # list to hold lists of date from each trial for m in range(num_trials): # for each trial # print "Trial %i:" % m, if visualize: anim = ps11_visualize.RobotVisualization(num_robots, width, height, .02) # create the room testRoom = RectangularRoom(width, height) # create robots and put them in a list robotList = [] for i in range(num_robots): robotList.append(robot_type(testRoom, speed)) # initialize for this trial percentClean = 0.0000000 progressList = [] while percentClean < min_coverage: # clean until percent clean >= min coverage if visualize: anim.update(testRoom, robotList) for eachRobot in robotList: # for each time-step make each robot clean eachRobot.updatePositionAndClean() percentClean = float(testRoom.getNumCleanedTiles()) / float(testRoom.getNumTiles()) progressList.append(percentClean) if visualize: anim.done() trialsCollection.append(progressList) # print "%i robot(s) took %i clock-ticks to clean %i %% of a %ix%i room." %(num_robots, len(progressList), int(min_coverage * 100), width, height) averageOfTrials = calcAvgLengthList(trialsCollection) # print "On average, the %i robot(s) took %i clock ticks to %f clean a %i x %i room." %(num_robots, int(averageOfTrials), min_coverage, width, height) return trialsCollection
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. um_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ trialsList = [] for trial in range(num_trials): if visualize: anim = ps11_visualize.RobotVisualization(num_robots, width, height) trialsList.append([]) #append a list to hold the results of this trial currentRoom = RectangularRoom(width, height) #make a new room for each trial roboList = [] for botNum in range(num_robots): #make the right number of robots roboList.append(robot_type( currentRoom, speed)) #all of the bots clean the same room # print "making Robot: ", botNum time = 0 while float(currentRoom.getNumCleanedTiles()) / float( currentRoom.getNumTiles( )) < min_coverage: #true if the min coverage is not clean if visualize: anim.update(currentRoom, roboList) #print "in the while loop and clean portion is: ", float(currentRoom.getNumCleanedTiles())/float(currentRoom.getNumTiles()) trialsList[trial].append( float(currentRoom.getNumCleanedTiles()) / float(currentRoom.getNumTiles())) for bot in roboList: #hey all you robots... #get hungrier... bot.setRobotHunger(-1) # if bot.getRobotHunger < 1: bot.updatePositionAndClean( ) #... clean the floor, stupid minions! if visualize: anim.done() return trialsList
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ anim = 0 if visualize: anim = ps11_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom(width, height) robots = [] for robo in xrange(num_robots): robot = robot_type(room, speed) robots.append(robot) result_code = [] for time in xrange(num_trials): for robot in robots: robot.updatePositionAndClean() if visualize: anim.update(room, robots) totalTile = room.getNumTiles() cleanedTile = room.getNumCleanedTiles() percent = cleanedTile / 1.0 / totalTile result_code.append(percent) if percent > min_coverage: break if visualize: anim.done() return result_code
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ # TODO: Your code goes here cleanList = [] for trial in range(num_trials): if visualize: anim = ps11_visualize.RobotVisualization(num_robots, width, height) cleanListPerBot = [] robots = [] #create a room room = RectangularRoom(width, height) #create a list of robots for robotNum in range(num_robots): robots.append(robot_type(room, speed)) percentClean = 0.0 #for each trial, compute list of percentage of room it cleans at each clock tick while percentClean <= min_coverage: if visualize: anim.update(room, robots) for robot in robots: robot.updatePositionAndClean() percentClean = float(room.getNumCleanedTiles()) / float(room.getNumTiles()) if percentClean > min_coverage: break; cleanListPerBot.append(percentClean) cleanList.append(cleanListPerBot) if visualize: anim.done() return cleanList
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ for test in range(num_trials): if visualize: anim = ps11_visualize.RobotVisualization(num_robots, width, height) trial_list = [] trial = [] room = RectangularRoom(width, height) robot_list = [robot_type(room, speed) for i in range(num_robots)] cleaned_percentage = 0.0 while cleaned_percentage < min_coverage: for robot in robot_list: robot.updatePositionAndClean() if visualize: anim.update(room, robot_list) cleaned_percentage = float(room.getNumCleanedTiles())/float(room.getNumTiles()) trial.append(cleaned_percentage) if visualize: anim.done() trial_list.append(trial) return trial_list
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ trial_list = [] for trial in range(1, num_trials + 1): percentage_cleaned = 0 room = RectangularRoom(width, height) robots = [] time_step_list = [(0,0)] time_step = 0 for robot_id in range(0,num_robots): # Initialize robots robots.append(robot_type(room, speed)) robots[robot_id].pos = room.getRandomPosition() if visualize: anim = ps11_visualize.RobotVisualization(num_robots, width, height) while percentage_cleaned < min_coverage: time_step = time_step + 1 for robot_id in range(0,num_robots): robots[robot_id].updatePositionAndClean() percentage_cleaned = room.getNumCleanedTiles()/room.getNumTiles() time_step_list.append((time_step, percentage_cleaned)) if visualize: anim.update(room, robots) trial_list.append(time_step_list) if visualize: anim.done() return trial_list
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ # TODO: Your code goes here result = list() for trial in range(num_trials): if visualize: anim = ps11_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom(width, height) coverage = list() list_of_robots = list() for each in range(num_robots): list_of_robots.append(robot_type(room, speed)) while room.getCoverage() < min_coverage: if visualize: anim.update(room, list_of_robots) coverage.append(room.getCoverage()) for each in list_of_robots: each.updatePositionAndClean() result.append(coverage) if visualize: anim.done() return result
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ lol = [] for i in range(num_trials): lol.append([]) #;print lol room = RectangularRoom(width, height) bots = [robot_type(room, speed) for k in range(num_robots)] percentage_cleaned = 0 if visualize == True: anim = viz.RobotVisualization(num_robots, width, height) while (percentage_cleaned < min_coverage): for j in range(num_robots): bots[j].updatePositionAndClean() percentage_cleaned = float( room.getNumCleanedTiles()) / room.getNumTiles() lol[i].append(percentage_cleaned) if visualize == True: anim.update(room, bots) if visualize == True: anim.done() return lol
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ listToBeReturned = [] listForEachTrial = [] robots = [] room = RectangularRoom(width,height) cleanedRatio = 0 for i in range(num_robots): a = robot_type(room,speed) robots.append(a) for i in range(num_trials): if visualize: anim = ps11_visualize.RobotVisualization(num_robots,width, height,0.01) epsilon = 0.01 while abs(cleanedRatio-min_coverage) > epsilon: for i in range(num_robots): robots[i].updatePositionAndClean() cleanedRatio = room.getNumCleanedTiles() / room.getNumTiles() print 'amount of room cleaned till now:',cleanedRatio*100,'%' listForEachTrial.append(cleanedRatio * 100) if visualize: anim.update(room, robots) if visualize: anim.done() listToBeReturned.append(listForEachTrial) return listToBeReturned
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ listForAllTrials = [] if visualize: anim = ps11_visualize.RobotVisualization(num_robots, width, height) for i in range(num_trials): ##intiating the room and the robots room = RectangularRoom(width, height) robots = [] ##The list that contains all the robots for i in range(num_robots): robots.append(robot_type(room, speed)) ##runs num_trials trials of the simulation listForThisTrial = [] areaCovered = 0 epsilon = 0.001 while areaCovered < min_coverage: for i in range(len(robots)): robots[i].updatePositionAndClean() if visualize: anim.update(room, robots) areaCovered = room.getNumCleanedTiles() / float(room.getNumTiles()) listForThisTrial.append(areaCovered) if visualize: anim.done() listForAllTrials.append(listForThisTrial) return listForAllTrials
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize=False): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ result = [] for y in range(num_trials): switch = True the_room = RectangularRoom(width, height) robot_list = [] ticks = 0 for t in range(num_robots): robot_list.append(robot_type(the_room, speed)) if visualize == True: anim = ps11_visualize.RobotVisualization(num_robots, width, height) while switch == True: ticks += 1 if visualize == True: anim.update(the_room, robot_list) if min_coverage <= the_room.get_coverage(): if visualize == True: anim.done() result.append([ticks]) switch = False else: for i in robot_list: i.updatePositionAndClean() return result
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, go): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ # TODO: Your code goes here total_steps=0 AcceptedInput=False if go==True: AcceptedInput=True visualize=True if go==False: AcceptedInput=True visualize=False else: print("Do you want visualization?") while AcceptedInput==False: input1=input("Y/N: ") print(input1) if str(input1)=="N" or str(input1)=="n": visualize=False AcceptedInput=True if str(input1)=="Y" or str(input1)=="y": visualize=True AcceptedInput=True else: print("Invalid output") # if not 0<=min_coverage<=1.00000000000: # raise ValueError min_coverage=float(min_coverage) trialscollection=[] for m in range(num_trials): if visualize: anim=ps11_visualize.RobotVisualization(num_robots, width, height,) testRoom=RectangularRoom(width, height) robotList=[] for i in range(num_robots): robotList.append(robot_type(testRoom, speed)) percentClean=0.0000000000 progressList=[] # print("First percentClean", percentClean) while float(percentClean)<float(min_coverage): if visualize: anim.update(testRoom, robotList) for each in robotList: each.updatePositionAndClean() # print("cleantiles", testRoom.cleanTiles) percentClean=testRoom.getNumCleanedTiles()/testRoom.getNumTiles() # print("getNumCleanedTiles", testRoom.getNumCleanedTiles()) # print("percentClean", percentClean, "MIN_COVERAGE", min_coverage) progressList.append(percentClean) total_steps+=speed # print("Coverage", percentClean) # print("are all tiles clean?") # for i in range(testRoom.width): # for j in range(testRoom.height): # print((i,j), testRoom.isTileCleaned(i,j)) if visualize: anim.done() trialscollection.append(progressList) # averageOfTrials = calcAvgLengthList(trialscollection) # print("Total steps", total_steps) # print("min_coverage", min_coverage) # print("trialscollection", trialscollection) return trialscollection
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize): """ Runs NUM_TRIALS trials of the simulation and returns a list of lists, one per trial. The list for a trial has an element for each timestep of that trial, the value of which is the percentage of the room that is clean after that timestep. Each trial stops when MIN_COVERAGE of the room is clean. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. Visualization is turned on when boolean VISUALIZE is set to True. num_robots: an int (num_robots > 0) speed: a float (speed > 0) width: an int (width > 0) height: an int (height > 0) min_coverage: a float (0 <= min_coverage <= 1.0) num_trials: an int (num_trials > 0) robot_type: class of robot to be instantiated (e.g. Robot or RandomWalkRobot) visualize: a boolean (True to turn on visualization) """ # TODO: Your code goes here # for robot in listofrobots: # robot.setRobotPosition(theroom.getRandomPosition()) # for robots in listofrobots: # assert type(robots) == Robot # robots.updatePositionAndClean() # anim.update(theroom, listofrobots) count =0 while num_trials > count: listoflists = [] theroom = RectangularRoom(width,height) listofrobots=[] for i in range(num_robots): listofrobots.append(robot_type(theroom,speed)) lists = [] coverage = 0 if visualize == True: anim = ps11_visualize.RobotVisualization(num_robots, width, height) for robot in listofrobots: robot.setRobotPosition(theroom.getRandomPosition()) while coverage < min_coverage: for robots in listofrobots: robots.updatePositionAndClean() if visualize == True: anim.update(theroom, listofrobots) coverage = float(theroom.getNumCleanedTiles())/theroom.getNumTiles() lists.append(coverage) count += 1 listoflists.append(lists) if visualize == True: anim.done() return listoflists