CSSE 120 -- Intro. to Software Development

Homework 8

Please note: Due to the exam on Tuesday evening (and cancelled class session 9) , all of this assignment is due at the beginning of class session 10, which is a day later than the programming part would normally be due.

  1. Complete the assigned reading for the next session (Zelle sections 7.5-7.6, 8.1-8.2).
  2. (9 pts) Complete the Angel quiz over this reading. You'll find this on the course Angel page, under Lessons → Homework → Homework 8 → Loops
  3. (15 pts) In your Session08Robotics project, finish the individual-programming exercise you started in class: countPassFail.py, and commit it to your SVN repository.
  4. (40 pts) Mutable Parameters. This exercise deals with the concepts in section 6.5 of Zelle. You may wish to re-read that section before doing this exercise.

    Background

    In class we saw that functions can assign to their formal parameters:

    def nextSquare(x):
        x = x + 1
        return x * x
    

    But we also saw that the calling code cannot see the effect of this assignment:

    y = 8
    next = nextSquare(y)
    print "y = %d, next = %d" % (y, next)
    # prints:
    # y = 8, next = 81
    

    This is because the assignment to x in nextSquare() only changes the value referred to by x. Informally, it just moves the post-it note for x onto the number 9, but the post-it note for y remains stuck to 8.

    We've also seen that we can modify lists without using assignment:

    squares = []
    for n in range(10):
        squares.append(n**2)
    print squares
    # prints:
    # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    

    Here the append() method tells the squares list to add the given square to its "tail". Informally, the squares post-it note remains stuck to the same list throughout the code, but the list is being mutated by the append() method.

    We can also mutate a list by assigning to its individual elements:

    numbers = [2,3,5,7,11]
    for i in range(len(numbers)):
        numbers[i] = numbers[i] ** 2
    print numbers
    # prints:
    # [4, 9, 25, 49, 121]
    

    In this example the numbers post-it note never moves once it is stuck to the original list. The assignment to numbers[i] in the body of the loop mutates the list by changing elements inside it. It might help to think of the list like an egg carton. We put the numbers 2, 3, 5, 7, and 11 into the first five pockets of the egg carton, then we affix the numbers post-it note to the carton. In the loop we take out each number and replace it with its square, one pocket at a time. The carton and the post-it note never change.

    We can use this idea of mutating a list to create a function that changes its parameters. Here's a function that does just that:

    def factEach(nums):
        """Replaces each element of nums with its factorial."""
        for i in range(len(nums)):
            nums[i] = factorial(nums[i])  # factorial defined as in class
    

    And some code demonstrating the function:

    numbers = [2,3,5,7,11]
    factEach(numbers)
    print numbers
    # prints:
    # [2, 6, 120, 5040, 39916800]
    

    To be turned in

    Open the mutantFunctions.py file in your Session08Robotics project. 

    Within it, write and test functions that meet each of the following specifications:

    1. (10 Points) squareEach(nums), where nums is a list of numbers. Modifies the list by squaring each entry.
    2. (10 Points) sumList(nums), where nums is a list of numbers. Returns the sum of the numbers in the list.
    3. (20 Points) toNumbers(strList), where strList is a list of strings, each of which represents a number. Modifies each entry in the list by converting it to a number. Here's an example use:
      numList = [10,20,30]
      print "sum = ", sumList(numList)
      squareEach(numList)
      print "squared: ", numList
      print "sum = ", sumList(numList)
      strList = ["17", "1.5", "2.718"]
      print "As strings: ", strList
      toNumbers(strList)
      print "As numbers: ", strList
      
      #prints the following output:
      #sum = 60
      #squared: [100, 400, 900]
      #sum = 1400
      #As strings: ['17', '1.5', '2.718']
      #As numbers: [17, 1.5, 2.718]
      

    Commit your code to your SVN repository.

  5. (30 pts) Robot Functions. Open robotFunctions.py  and add the definition of the following functions:

    1. (20 pts) Create a function called wander() that drives the robot in a random motion to explore an environment. The wander() function has three parameters, the robot, and linear and angular velocity. The parameters should be in the following order:
      1. robot
      2. [optional] Linear Velocity in cm/s, default = 15
      3. [optional] Angular Velocity in deg/s, default = 20
      To implement this function, select a random angle between or including -180 and 180 degrees (via randrange), turn the robot that much, select a random distance between 10 and 30 cm, and move the robot forward that much. Be sure that the sign on your velocities and distances are the same. Also make sure that when you calculate how long to sleep, you allow the answer to be a float. Repeat this random sequence of turn+drive 5 times or until its cliff sensor is triggered (i.e. pick it up): see WanderVideo.wmv for an example. You should use the go() method; driveDirect() is much harder to use here.
    2. (10 pts) Create a function kittLights() that takes two parameters: the robot and numRepeats, and turns on the robot’s power, play and advance lights using the 12-step sequence given here. The 12-step sequence shown should repeat numRepeats times (see LightsVideo.wmv). Look up the setLEDs() function in the pycreate library documentation for details on how to turn on Create’s LEDs. For example:
      		r.setLEDs(0,0,0,0) #turn off all of the robot's LEDS 
      		r.setLEDs(0,255,0,0)#turn on only the robot's power LED to green (see documentation)
      		r.setLEDs(0,0,1,0)#turn on only the robot's play LED