Your instructor may assign one or more of the following problems. Don’t feel that you must do all the problems; for the homeworks, you are only required to do those that are explicitly assigned via Moodle.

1. Extend the Fraction class by adding these methods:

   • Three more arithmetic operations (+, -, and /).
   • Six relational operations (==, !=, <, >, <=, and >=).
   • A conversion method that returns a reciprocal version of the fraction (i.e., the reciprocal of n/d is d/n).
   • A conversion method that returns the float equivalent of the fraction.

   Extend the console testing application that you started in the lab to include appropriate test cases for these new features.

2. Create a python program named war.py that simulates a simplified version of the card game War. Use the following approach:

   • Create a class Card that models a standard playing card. Objects of this type will have a number between 1 and 13 (inclusive) and a suit (Spade, Heart, Club or Diamond). You should not include Jokers. This class must include:
     • A constructor: receives two values as parameters: a suit (one of "S", "D", "H", "C") and a number (a value between 1 and 13 inclusive). The constructor stores these values in instance variables, just like we did with the Fraction class.
     • Accessors for the number and suit.
     • A __str__ method to allow printing of Card objects. For example, a card representing the 9 of spades will print as 9S, and a card representing the 12 (i.e., Queen) of hearts will print as QH. A card with a number of 1 should be represented with A (for Ace). The code to implement this will probably look like this:
       • Figure out which digit or letter (J, Q, K, or A) will be printed and store that in a string variable. This will take a if-elif-elif... statement.
       • Append to that variable the suit string.
       • return the result.
     • Overload the comparison operators <, == and > to allow comparison of cards based on their number (suit does not matter). Note: An Ace should be considered higher than a King. Note that these methods return a boolean value -- True or False.
     • Two cards are equal if their numbers are equal.
     • A card is less than another if its number is less than the other, *unless* the first card's number is 1 (Ace), in which case it is never less than the other.
     • Similarly for >.
   • Now, write a bunch of test cases in the file after your Card class definition (just like we did for our Fraction class). You'll want to create different Card objects and print them to make sure your __str__ is correct. You'll want to compare different Card objects with <, >, and == to make sure those functions return the correct boolean values. The more testing you do of your code now, the less testing you'll have to do later, so it is definitely to your benefit to test *everything* you can now.
   • Now, use the following algorithm for the main code section of your program:
     1. Generate two lists of 5 random cards each. If you are doing the course for honors, your code must make sure you do not create any duplicate cards. Otherwise, don't worry about it. (Note: you can random.randint() to get a random integer and random.choice() to get a random value from a list -- useful for getting a random suit.)
     2. Print out the hand (list) of each player.
     3. Compare one card from each hand one-by-one, and keep track of whose card wins. If there is a tie, no one wins.
     4. Display which player wins more tricks.

3. Create a program called circle.py that implements a class that represents circle objects. Each circle has a center (modeled as an x-y coordinate tuple), a radius, color (modeled as a Python turtle color string, e.g., ‘black’) and a Boolean flag indicating whether it is to be drawn as filled or or just outlined. Circles cannot have negative radii.

   Implement the following features.

   • Constructor - Include a constructor that sets default values for the instance variables. Let the “default” circle be centered at (0,0), of radius 100, of color black and unfilled.
   • Printing - Include a __str__() method that produces a properly formatted string for printing the circle’s internal state.
   • Accessors - Include accessors that compute the circle’s area (get_area()), its circumference (get_circumference()) and any additional accessors needed by other methods.
   • Mutator - Include a mutator (modify_radius()) that receives a “delta” value from the calling program and adds this value to the circle’s radius.
   • Overlaps - Include a comparator (overlaps()) that receives another circle object from its calling program and determines if that other circle overlaps with itself. Return true if the circles overlap in any way. (Cf. homework 4.1, which also distinguishes overlap from containment.)
   • Render - Include a method (render()) that receives a turtle object from its calling program and uses that object to draw itself on the canvas.

   Add code at the bottom of the module to exercise this class by creating a default circle, an invalid circle, circles that do and do not overlap, and generally testing the features provided by the class.

4. Create a program called rectangle.py that implements a class that represents rectangle objects. Each rectangle has an upper left point (modeled as an x-y coordinate tuple), a width, a height and a color (modeled as a Python turtle color string, e.g., ‘black’). Rectangles cannot have negative widths or heights.

   Implement the following features.

   • Constructor - Include a constructor that sets default values for the instance variables. Let the “default” rectangle be placed at (0,0), of width and height 50, and of color black.
   • Printing - Include a __str__() method that produces a properly formatted string for printing the rectangle’s internal state.
   • Accessors - Include accessors that compute the rectangle’s area (get_area()), its perimeter (get_perimeter()) and any additional accessors needed by other methods.
   • Mutators - Include mutators (modify_width() and modify_height()) that receive a “delta” value from the calling program and adds this value to the rectangle’s width or height as appropriate.
   • Overlaps - Include a comparator (overlaps()) that receives another rectangle object from its calling program and determines if that other rectangle overlaps with itself. Return true if the rectangles overlap in any way. (Cf. homework 4.2.)
   • Render - Include a method (render()) that receives a turtle object from its calling program and uses that object to draw itself on the canvas.

   Add code at the bottom of the module to exercise this class by creating a default rectangle, an invalid rectangle, rectangles that do and do not overlap, and generally testing the features provided by the class.

Checking In

Submit all appropriate files for grading, including code files, screen captures, supplemental files (e.g., image files), and text files. We will grade this exercise according to the following criteria:

• Correctness:
  • 50% - Basic functionality - Include the basic class definition with the appropriate instance variables, constructor, accessors, mutators and object-interaction methods.
  • 35% - Main code section works as specified.
• Understandability:
  • 5% - Code Documentation - Separate the logical blocks of your program with useful comments and white space.
  • 5% - Header Documentation - Document the code’s basic purpose, authors and assignment number.
  • 5% - Documentation strings - Include appropriate documentation strings for any methods