def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ total_steps = 0 for t in range(num_trials): anim = ps2_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom(width, height) robots = [] for i in range(num_robots): robots.append(robot_type(room, speed)) while room.getNumCleanedTiles() / room.getNumTiles() < min_coverage: anim.update(room, robots) for robot in robots: robot.updatePositionAndClean() total_steps += 1 #why not inside for loop. if thr r 2 robots, update these 2, and step is counted as 1. anim.done() return total_steps / num_trials
def clean_room(): # place room inside clean room in order to reset if animate: anim = ps2_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom(width, height) min_coverage_tiles = int(min_coverage * room.getNumTiles()) # init robot list robots = [] for i in range(num_robots): robots.append(i) for i in range(len(robots)): robots[i] = robot_type(room, speed) if len(robots) == 1: clock_ticks = 1 else: clock_ticks = 0 while room.getNumCleanedTiles() < min_coverage_tiles: for robot in robots: robot.updatePositionAndClean() clock_ticks += 1 if animate: anim.update(room, robots) if animate: anim.done() return clock_ticks
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ robot_counter = [] for j in range(num_trials): anim = ps2_visualize.RobotVisualization(num_robots, width, height) rect = RectangularRoom(width, height) robots = [] for i in range(num_robots): robot = robot_type(rect, speed) robots.append(robot) counter = 0 while rect.getNumCleanedTiles() / rect.getNumTiles() < min_coverage: anim.update(rect, robots) for i in robots: i.updatePositionAndClean() counter += 1 robot_counter.append(counter) anim.done() return sum(robot_counter) / num_trials
def runSimulationAnimation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, animate=False): total_steps = 0 for __ in range(num_trials): if animate: anim = ps2_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom(width, height) robots = [] for r in range(num_robots): robots.append(robot_type(room, speed)) while room.getNumCleanedTiles() / float( room.getNumTiles()) < min_coverage: if animate: anim.update(room, robots) for robot in robots: robot.updatePositionAndClean() total_steps += 1 if animate: anim.update(room, robots) anim.done() return total_steps / float(num_trials)
def oneSimulation(): testedRoom = RectangularRoom(width, height) listOfRobots = [] for i in range(num_robots): listOfRobots.append(robot_type(testedRoom, speed)) numOfTimeSteps = 0 #visualisation of simulation if visualizeSimulation: anim = ps2_visualize.RobotVisualization(num_robots, width, height, delay = 0.1) anim.update(testedRoom, listOfRobots) while True: cleanT = testedRoom.getNumCleanedTiles() totalT = testedRoom.getNumTiles() if cleanT / totalT >= min_coverage: #visualisation of the simulation if visualizeSimulation: anim.done() return numOfTimeSteps for i in range(num_robots): listOfRobots[i].updatePositionAndClean() #visualisation of the simulation if visualizeSimulation: anim.update(testedRoom, listOfRobots) numOfTimeSteps += 1
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): WorkDoneList = numpy.zeros(shape=(num_trials)) anim = ps2_visualize.RobotVisualization(num_robots, width, height) for i in range(num_trials): cycle = 0 # for only one robot # robot = StandardRobot(RectangularRoom(width,height), speed) room = RectangularRoom(width, height) robots = [robot_type(room, speed) for r in range(num_robots)] while robots[0].room.getNumCleanedTiles() / room.getNumTiles( ) < min_coverage: anim.update(room, robots) for j in range(num_robots): robots[j].updatePositionAndClean() # Just for testing # print(j) # print(robots[j].room.getNumCleanedTiles()) cycle += 1 WorkDoneList[i] = cycle anim.done() # print(WorkDoneList) # print(numpy.mean(WorkDoneList)) return numpy.mean(WorkDoneList)
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ time_taken_all = [] for attempt_num in range(num_trials): anim = ps2_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom(width, height) robots = [robot_type(room, speed) for robot in range(num_robots)] time_taken = 0 while (room.getNumCleanedTiles() / room.getNumTiles()) < min_coverage: time_taken += 1 for robot in robots: anim.update(room, robots) robot.updatePositionAndClean() time_taken_all.append(time_taken) anim.done() #print(time_taken_all) return (sum(time_taken_all) / len(time_taken_all))
def testRobotMovement(robot_type, room_type, delay=0.4): """ Runs a simulation of a single robot of type robot_type in a 5x5 room. """ room = room_type(5, 5) robot = robot_type(room, 1) anim = ps2_visualize.RobotVisualization(1, 5, 5, delay) while room.getNumCleanedTiles() / room.getNumTiles() < 1: robot.updatePositionAndClean() anim.update(room, [robot]) anim.done()
def testRobotMovement(robot_type, room_type, delay=0.4): """ Runs a simulation of a single robot of type robot_type in a 5x5 room. """ import ps2_visualize room = room_type(5, 5) robot = robot_type(room, 1) anim = ps2_visualize.RobotVisualization(1, 5, 5, delay) while ## the room is not cleaned ## ## move the robot ## anim.update(room, [robot]) anim.done()
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ #raise NotImplementedError #1. define Room steps = [0] * num_trials viz=False for trial in range(num_trials): #Inserting for visualisation if viz: anim = ps2_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom(width, height) robots = [] #Initialise robots for i in range(num_robots): robots.append(robot_type(room, speed)) if not room.getNumCleanedTiles()/room.getNumCleanedTiles() < min_coverage: #Make first move for each robot for robot in robots: robot.updatePositionAndClean() steps[trial]+=1 #Inserting before making first move while room.getNumCleanedTiles()/room.getNumTiles() < min_coverage: if viz: anim.update(room, robots) for robot in robots: robot.updatePositionAndClean() steps[trial] += 1 #completion of trial if viz: anim.done() return sum(steps)/num_trials
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean numxber of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, ni a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ trial_durations = [] sum = 0 for trial in range(num_trials): # animation code anim = ps2_visualize.RobotVisualization(num_robots, width, height) # prepare for a fresh simulation robot_list = [] simulationRoom = RectangularRoom(width, height) total_tiles = float(width * height) cleaned_tiles = 0 cleaned_fraction = 0.0 time_trial_took = 0 for makerobots in range(num_robots): robot_list.append(robot_type(simulationRoom,speed)) cleaned_tiles += 1 #for i in range(num_robots): # print "Robot ", i+1 # actually start the simulation while (cleaned_fraction < min_coverage): time_trial_took += 1 anim.update(simulationRoom, robot_list) for eachrobot in robot_list: eachrobot.updatePositionAndClean() # check if it's time to end the simulation cleaned_fraction = float(simulationRoom.getNumCleanedTiles())/total_tiles if (cleaned_fraction >= min_coverage): trial_durations.append(time_trial_took) else: continue anim.done() for time_taken in trial_durations: sum += time_taken average = float(sum)/float(len(trial_durations)) return average
def runTrial(num_robots, speed, width, height, min_coverage, robot_type): anim = ps2_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom(width, height) robots = [robot_type(room, speed) for _ in range(num_robots)] steps = 0 tileCount = float(room.getNumTiles()) while room.getNumCleanedTiles() / tileCount < min_coverage: steps = steps + 1 for robot in robots: anim.update(room, robots) robot.updatePositionAndClean() anim.done() return steps
def testRobotMovement(robot_type, room_type, delay=0.4): """ Runs a simulation of a single robot of type robot_type in a 5x5 room. """ angular_speed = 30 / 180.0 * math.pi room = room_type(20, 20) robot = robot_type(room, 1.0, angular_speed) anim = ps2_visualize.RobotVisualization(1, 10, 10, delay) while room.getNumCleanedTiles() < room.getNumTiles(): robot.updatePositionAndClean() anim.update(room, [robot]) anim.done()
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, animation=False): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) animation: a boolean to indicate animation of robots is enabled """ totalTimeStep = 0 # Variable to accumulate no. of time stamps for i in range(num_trials): # To enable animation of robot movements if animation: roboMoves = ps2_visualize.RobotVisualization( num_robots, width, height, 0.01) # Initialize room for a given trial targetRoom = RectangularRoom(width, height) # Create robots based on type of it testRobots = [robot_type(targetRoom, speed) for i in range(num_robots)] # Run the simulations till minimum coverage criteria is met while (min_coverage * targetRoom.getNumTiles() > targetRoom.getNumCleanedTiles()): # Change position of all robots for robot in testRobots: robot.updatePositionAndClean() # Increment total time step counter totalTimeStep += 1 # To provide movements of robots in animation when enabled if animation: roboMoves.update(targetRoom, testRobots) # Close the animation for given trial if animation: roboMoves.done() # Return mean value of steps in given experiment return float(totalTimeStep / num_trials)
def visualization(): width = 10 height = 20 room = RectangularRoom(width,height) robots = [RandomWalkRobot(room, 1.0), RandomWalkRobot(room, 1.0), StandardRobot(room, 1.0), StandardRobot(room, 1.0)] num_robots = len(robots) anim = ps2_visualize.RobotVisualization(num_robots, width, height) #anim.update(room, robots) while room.getNumTiles() != room.getNumCleanedTiles(): for robot in robots: robot.updatePositionAndClean() anim.update(room, robots) anim.done()
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, animated=False): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ assert int(num_robots) > 0, "機器人最少一隻" assert float(speed) > 0, "速度要大於零" assert int(width) > 0, "長寬要大於零" assert int(height) > 0, "長寬要大於零" assert 0 <= float(min_coverage) <= 1, "掃地覆蓋面積大於等於0, 小於等於1" assert num_trials > 0, "嘗試次數要大於零" if animated: anim = ps2_visualize.RobotVisualization(num_robots, width, height) total_steps = 0 for trial in range(num_trials): room = RectangularRoom(width, height) Robots = [] for num in range(num_robots): Robots.append(robot_type(room, speed)) while room.getNumCleanedTiles() / float( room.getNumTiles()) < min_coverage: if animated: anim.update(room, Robots) for robot in Robots: robot.updatePositionAndClean() total_steps += 1 if animated: anim.update(room, Robots) anim.done() return total_steps / int(num_trials)
def RunRobots(robot_list, room, min_coverage, num_robots, width, height): anim = ps2_visualize.RobotVisualization(num_robots, width, height) count_steps = 0 temp_robots = robot_list.copy() while room.getNumCleanedTiles() / room.getNumTiles() < min_coverage: for i in range(len(temp_robots)): anim.update(room, temp_robots) temp_robots[i].updatePositionAndClean() count_steps += 1 anim.done() return count_steps
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ # Create total steps counter totalSteps = 0 # Run all trials for i in range(num_trials): # Create num_amount of robots LoR = [] recRoom = RectangularRoom(width, height) for i in range(num_robots): LoR.append(robot_type(recRoom, speed)) isMin = False # Run each trial anim = ps2_visualize.RobotVisualization(num_robots, width, height) while not isMin: totalSteps += 1 for i in range(num_robots): # Have each robot clean anim.update(recRoom, LoR) LoR[i].updatePositionAndClean() # Check if min_coverage has been reached if (recRoom.getNumCleanedTiles() / recRoom.getNumTiles()) >= min_coverage: isMin = True break anim.done() return totalSteps / num_trials
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type, visualize=False): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ total_time = 0 for i in range(num_trials): # Initialize the space room = RectangularRoom(width=width, height=height) robots = [] for i in range(num_robots): robots.append(robot_type(room, speed)) if visualize: anim = ps2_visualize.RobotVisualization(num_robots, width, height) # Clean it while (room.getNumCleanedTiles() / room.getNumTiles()) < min_coverage: if visualize: anim.update(room, robots) total_time += 1 for r in range(num_robots): robots[r].updatePositionAndClean() if visualize: anim.done() return total_time / num_trials
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ trial_results = [] for trial in range(num_trials): room = RectangularRoom(width, height) # Create a list of robots robots = [] for robot in range(num_robots): robots.append(robot_type(room, speed)) percentage_cleaned = 0 clock_tick = 0 # remove--- anim = ps2_visualize.RobotVisualization(num_robots, width, height) #---------- while True: percentage_cleaned = (room.getNumCleanedTiles() / room.getNumTiles()) if percentage_cleaned >= min_coverage: break else: anim.update(room, robots) # remove clock_tick += 1 for robot in robots: robot.updatePositionAndClean() trial_results.append(clock_tick) anim.done() # remove mean_cleaning_time = round(sum(trial_results) / num_trials, 2) return mean_cleaning_time
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ anim = ps2_visualize.RobotVisualization(num_robots, width, height) clocklist = [] # a list used to store the clock for different trials for i in range( num_trials): #perform num times trials and get the average clock room = RectangularRoom(width, height) #initialize the room need to clean targetCoverage = math.ceil( min_coverage * room.getNumTiles()) #target of percentage to be cleaned robotlist = [ robot_type(room, speed) for _ in enumerate(range(num_robots)) ] #make a list to store the robots j = 0 #count for clock # room.tilecleaned=[]#reset the room to dirty while room.getNumCleanedTiles() < targetCoverage: anim.update(room, robotlist) for robot in robotlist: robot.updatePositionAndClean( ) #robots clean the room at the same time for once j += 1 #clock increase by one clocklist.append( j) #end cleaning up the room and store the clock to clcok list # print(clocklist) anim.done() mean = sum(clocklist) / num_trials #calculate the mean return mean
def testRobotMovement(robot_types, room, speed, delay): """ Runs a simulation of a single robot of type robot_type in a RectangularRoom. robot_types: a dict, mapping a robot class to the number of that kind of robot to be tested """ robots = [] for robot_type in robot_types: for i in range(0, robot_types[robot_type]): robots.append(robot_type(room, speed)) anim = ps2_visualize.RobotVisualization(len(robots), room.width, room.height, delay) while room.getNumCleanedTiles() < room.getNumTiles(): for robot in robots: robot.updatePositionAndClean() anim.update(room, robots) anim.done()
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ anim = ps2_visualize.RobotVisualization(num_robots, width, height, 0.1) result = 0 if math.ceil(width * height * min_coverage) == 0: return 0 for i in range(num_trials): room = RectangularRoom(width, height) area = room.getNumTiles() goal = math.ceil(area * min_coverage) robots = [] for j in range(num_robots): robots.append(robot_type(room, speed)) steps = 0 x = 0 if room.getNumCleanedTiles() >= goal: return 0 while x == 0: for k in robots: k.updatePositionAndClean() if room.getNumCleanedTiles() >= goal: result += steps x = 1 break anim.update(room, robots) steps += 1 anim.done() return (result / num_trials) + 1
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ anim = ps2_visualize.RobotVisualization(num_robots, width, height) results = [] for trial in range(num_trials): num_steps = 0 #since we invoke methods from the RectangularRoom method later in this func, #we need to instantiate the room with that class and call the class through the instance for the rest of the func room = RectangularRoom(width, height) #must instantiate the robots robots = [robot_type(room, speed) for j in range(num_robots)] #this while loop runs for the num of trials passed as param #one while to completion = 1 trial #adds a step to counter and cleans a square for each robot then checks if #enough squares are clean #continues until there are enough clean squares while (room.getNumCleanedTiles() / room.getNumTiles()) < min_coverage: num_steps += 1 anim.update(room, robots) for k in robots: k.updatePositionAndClean() if (room.getNumCleanedTiles() / room.getNumTiles()) >= min_coverage: results.append(num_steps) anim.done return sum(results) / len(results)
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ timeSteps = [] for j in range(num_trials): anim = ps2_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom(width, height) robotList = [] for i in range(num_robots): robotList.append(robot_type(room, speed)) for i in range(num_robots): room.cleanTileAtPosition(robotList[i].getRobotPosition()) tempTime = 0 while float( room.getNumCleanedTiles()) / room.getNumTiles() < min_coverage: for i in range(num_robots): anim.update(room, robotList) robotList[i].updatePositionAndClean() room.cleanTileAtPosition(robotList[i].getRobotPosition()) tempTime += 1 timeSteps.append(tempTime) anim.done() mean = float(sum(timeSteps)) / len(timeSteps) return mean
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ #raise NotImplementedError # do this in a while loop, but has to be in for loop of num_trials: # and instantiate a container to store the results results = [] for i in range(num_trials): anim = ps2_visualize.RobotVisualization(num_robots, width, height) num_steps = 0 # Instantiate a new room room = RectangularRoom(width, height) # Instantiate the robots robots = [robot_type(room, speed) for j in range(num_robots)] while (room.getNumCleanedTiles() / room.getNumTiles()) < min_coverage: num_steps += 1 anim.update(room, robots) for k in robots: k.updatePositionAndClean() if (room.getNumCleanedTiles() / room.getNumTiles()) >= min_coverage: results.append(num_steps) anim.done() else: continue # return mean return sum(results) / len(results)
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ robots, trials = [], [] for i in range(num_trials): anim = ps2_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom(width, height) count, status = 0, 0 for n in range(1, num_robots + 1): robots.append(robot_type(room, speed)) while True: anim.update(room, robots) for robot in robots: robot.updatePositionAndClean() status = room.getNumCleanedTiles() / room.getNumTiles() count += 1 if status >= min_coverage: break trials.append(count) anim.done() average, summe, items = 0, 0, 0 for x in trials: items += 1 summe += x average = summe / items return average
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ #raise NotImplementedError trials = [] #run num_trials for each test for trial in range(num_trials): anim = ps2_visualize.RobotVisualization(num_robots, width, height, .01) #create room room = RectangularRoom(width, height) robots = [] for i in range(num_robots): robots.append(robot_type(room, speed)) timestep = 0 while room.getNumCleanedTiles() / room.getNumTiles() <= min_coverage: for robot in robots: anim.update(room, robots) robot.updatePositionAndClean() timestep += 1 trials.append(timestep) anim.done() return sum(trials) / len(trials)
def aminate( num_robots, speed, width, height, min_coverage, robot_type): anim = ps2_visualize.RobotVisualization(num_robots, width, height) room = RectangularRoom( width, height ); robots = [ robot_type(room, speed) for r in range(num_robots) ] curr_coverage = 0.0; num = 0 while curr_coverage < min_coverage: [ robot.updatePositionAndClean() for robot in robots ] anim.update(room, robots) curr_coverage = room.getNumCleanedTiles() / room.getNumTiles() num += 1; if num > 10000: # de inffinite loop protection. print("f**k"); break; anim.done()
def runSimulation(num_robots, speed, width, height, min_coverage, num_trials, robot_type): """ Runs NUM_TRIALS trials of the simulation and returns the mean number of time-steps needed to clean the fraction MIN_COVERAGE of the room. The simulation is run with NUM_ROBOTS robots of type ROBOT_TYPE, each with speed SPEED, in a room of dimensions WIDTH x HEIGHT. 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. StandardRobot or RandomWalkRobot) """ anim = ps2_visualize.RobotVisualization(num_robots, width, height) # Start animation sumtime = 0 for y in range(num_trials): room = RectangularRoom(width, height) rc = [] for x in range(num_robots): rc.append(robot_type(room, speed)) time = 0 pc = 0.01 while pc < min_coverage: pcl = [] for r in rc: r.updatePositionAndClean() pcl.append(r.room.getNumCleanedTiles() / r.room.getNumTiles()) time += 1 pc = max(pcl) anim.update(room, rc) # Animate robot movement sumtime += time anim.done() # End of animation return sumtime / num_trials