Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- # Problem Set 6: Simulating robots
- # Name:
- # Collaborators:
- # Time:
- import math
- import random
- import ps6_visualize
- import pylab
- # === Provided classes
- class Position(object):
- """
- A Position represents a location in a two-dimensional room.
- """
- def __init__(self, x, y):
- """
- Initializes a position with coordinates (x, y).
- """
- self.x = x
- self.y = y
- def getX(self):
- return self.x
- def getY(self):
- return self.y
- def getNewPosition(self, angle, speed):
- """
- Computes and returns the new Position after a single clock-tick has
- passed, with this object as the current position, and with the
- specified angle and speed.
- Does NOT test whether the returned position fits inside the room.
- angle: float representing angle in degrees, 0 <= angle < 360
- speed: positive float representing speed
- Returns: a Position object representing the new position.
- """
- old_x, old_y = self.getX(), self.getY()
- # Compute the change in position
- delta_y = speed * math.cos(math.radians(angle))
- delta_x = speed * math.sin(math.radians(angle))
- # Add that to the existing position
- new_x = old_x + delta_x
- new_y = old_y + delta_y
- return Position(new_x, new_y)
- # === Problems 1
- class RectangularRoom(object):
- """
- A RectangularRoom represents a rectangular region containing clean or dirty
- tiles.
- A room has a width and a height and contains (width * height) tiles. At any
- particular time, each of these tiles is either clean or dirty.
- """
- def __init__(self, width, height):
- """
- Initializes a rectangular room with the specified width and height.
- Initially, no tiles in the room have been cleaned.
- width: an integer > 0
- height: an integer > 0
- """
- if width < 1 or height < 1:
- raise "width or height must be > 0"
- if type(width) is not int and type(height) is not int :
- raise "width and height must be integers"
- self.width = width
- self.height = height
- self.cleaned = []
- return None
- def cleanTileAtPosition(self, pos):
- """
- Mark the tile under the position POS as cleaned.
- Assumes that POS represents a valid position inside this room.
- pos: a Position
- """
- self.position_int = math.floor(pos.getX()), math.floor(pos.getY())
- if not self.isTileCleaned(self,self.position_int):
- self.cleaned.append(self.position_int)
- pass
- def isTileCleaned(self, m, n):
- """
- Return True if the tile (m, n) has been cleaned.
- Assumes that (m, n) represents a valid tile inside the room.
- m: an integer
- n: an integer
- returns: True if (m, n) is cleaned, False otherwise
- """
- self.tile = m,n
- if self.tile in self.cleaned:
- return True
- else:
- return False
- raise NotImplementedError
- def getNumTiles(self):
- """
- Return the total number of tiles in the room.
- returns: an integer
- """
- return (self.width )* (self.height )
- raise NotImplementedError
- def getNumCleanedTiles(self):
- """
- Return the total number of clean tiles in the room.
- returns: an integer
- """
- return len(self.cleaned)
- raise NotImplementedError
- def getRandomPosition(self):
- """
- Return a random position inside the room.
- returns: a Position object.
- """
- return Position(random.uniform(0,self.width), random.uniform(0,self.height))
- raise NotImplementedError
- def isPositionInRoom(self, pos):
- """
- Return True if pos is inside the room.
- pos: a Position object.
- returns: True if pos is in the room, False otherwise.
- """
- if 0 <= pos.getX() <= self.width and 0 <= pos.getY() <= self.height:
- return True
- else:
- return False
- raise NotImplementedError
- class Robot(object):
- """
- Represents a robot cleaning a particular room.
- At all times the robot has a particular position and direction in the room.
- The robot also has a fixed speed.
- Subclasses of Robot should provide movement strategies by implementing
- updatePositionAndClean(), which simulates a single time-step.
- """
- def __init__(self, room, speed):
- """
- Initializes a Robot with the given speed in the specified room. The
- robot initially has a random direction and a random position in the
- room. The robot cleans the tile it is on.
- room: a RectangularRoom object.
- speed: a float (speed > 0)
- """
- self.setRobotPosition(room.getRandomPosition())
- self.speed = speed
- self.room = room
- self.setRobotDirection(self.getRandomDirection())
- self.room.cleanTileAtPosition(self.position)
- print "initialised"
- pass
- def getRandomDirection(self):
- return random.uniform(0,360)
- def getRobotPosition(self):
- """
- Return the position of the robot.
- returns: a Position object giving the robot's position.
- """
- return self.position
- raise NotImplementedError
- def getRobotDirection(self):
- """
- Return the direction of the robot.
- returns: an integer d giving the direction of the robot as an angle in
- degrees, 0 <= d < 360.
- """
- return self.direction
- raise NotImplementedError
- def setRobotPosition(self, position):
- """
- Set the position of the robot to POSITION.
- position: a Position object.
- """
- self.position = position
- print position.getX(),position.getY()
- pass
- def setRobotDirection(self, direction):
- """
- Set the direction of the robot to DIRECTION.
- direction: integer representing an angle in degrees
- """
- self.direction = direction
- pass
- def updatePositionAndClean(self):
- """
- Simulate the raise passage of a single time-step.
- Move the robot to a new position and mark the tile it is on as having
- been cleaned.
- """
- print "default updateclean called"
- self.setRobotPosition(self.position.getNewPosition(self.getRobotDirection(),self.speed))
- self.room.cleanTileAtPosition(getRobotDirection())
- pass
- # === Problem 2
- class StandardRobot(Robot):
- """
- A StandardRobot is a Robot with the standard movement strategy.
- At each time-step, a StandardRobot attempts to move in its current direction; when
- it hits a wall, it chooses a new direction randomly.
- """
- def updatePositionAndClean(self):
- """
- Simulate the passage of a single time-step.
- Move the robot to a new position and mark the tile it is on as having
- been cleaned.
- """
- self.potential_move = self.position.getNewPosition(self.direction,self.speed)
- if self.room.isPositionInRoom(self.potential_move):
- self.setRobotPosition(self.potential_move)
- self.room.cleanTileAtPosition(self.position)
- else:
- self.setRobotDirection(self.getRandomDirection())
- print "new direction", self.direction
- pass
- # === Problem 3
- 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. Robot or
- RandomWalkRobot)
- """
- bots = []
- timestep = 0
- times = []
- time_sum = 0
- for i in range(0,num_trials):
- room = RectangularRoom( width, height )
- NumTiles = room.getNumTiles()
- bots = []
- timestep = 1
- for bot in range(0,num_robots):
- bots.append(StandardRobot( room, speed))
- while ( room.getNumCleanedTiles() / NumTiles ) < min_coverage :
- print "cleaned tiles", room.getNumCleanedTiles()
- for bot in range(0,(num_robots)):
- bots[bot].updatePositionAndClean()
- timestep = timestep + 1
- times.append(timestep)
- for i in times:
- time_sum = time_sum + i
- time_av = time_sum / len(times)
- return time_av
- # === Problem 4
- #
- # 1) How long does it take to clean 80% of a 20×20 room with each of 1-10 robots?
- #
- # 2) How long does it take two robots to clean 80% of rooms with dimensions
- # 20×20, 25×16, 40×10, 50×8, 80×5, and 100×4?
- def showPlot1():
- """
- Produces a plot showing dependence of cleaning time on number of robots.
- """
- raise NotImplementedError
- def showPlot2():
- """
- Produces a plot showing dependence of cleaning time on room shape.
- """
- raise NotImplementedError
- # === Problem 5
- class RandomWalkRobot(Robot):
- """
- A RandomWalkRobot is a robot with the "random walk" movement strategy: it
- chooses a new direction at random after each time-step.
- """
- raise NotImplementedError
- # === Problem 6
- # For the parameters tested below (cleaning 80% of a 20x20 square room),
- # RandomWalkRobots take approximately twice as long to clean the same room as
- # StandardRobots do.
- def showPlot3():
- """
- Produces a plot comparing the two robot strategies.
- """
- raise NotImplementedError
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement