MCS 275 Spring 2023 Worksheet 3 Solutions¶

v = Vector2(1,5)
v*10  # test out Vector2.__mul__

5*v  # test out Vector2.__rmul__

-v  # negates all components

+v  # same as v

abs(v)

# Distance from (1,2) to (4,6) should be 5
abs(Point2(1,2) - Point2(4,6))

v-v  # subtraction doesn't work yet

if v:
    print("Not the zero vector")
else:
    print("Zero Vector")

print(v[0])
print(v[1])
print(v[2])

class Point2:
    "Point in the plane"
    # Note: Base code (without additions) obtained from MCS 275 Spring 2023 Lecture 4 (plane.py)
    def __init__(self, x, y):
        "Initialize new point from x and y coordinates"
        self.x = x
        self.y = y

    def __eq__(self, other):
        "points are equal if and only if they have same coordinates"
        if isinstance(other, Point2):
            return (self.x == other.x) and (self.y == other.y)
        else:
            return False

    def __add__(self, other):
        "point+vector addition"
        if isinstance(other, Vector2):
            # we have been asked to add this Point2 to another Vector2
            return Point2(self.x + other.x, self.y + other.y)
        else:
            # we have been asked to add this Point2 to some other object
            # we don't want to allow this
            return NotImplemented  # return this to forbid the requested operation
    
    def __sub__(self, other):
        "point+vector subtraction"
        if isinstance(other, Vector2):
            # we have been asked to add this Point2 to another Vector2
            return Point2(self.x - other.x, self.y - other.y)
        else:
            # we have been asked to add this Point2 to some other object
            # we don't want to allow this
            return NotImplemented  # return this to forbid the requested operation        

    def __getitem__(self, index):
        "obtain the x and y coordinates in list access format"
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            raise IndexError('list index out of range')
            
    def __str__(self):
        "human-readable string representation"
        return "Point2({},{})".format(self.x, self.y)

    def __repr__(self):
        "unambiguous string representation"
        return str(self)

    def distance_to(self, other):
        "get distance between two points"
        if isinstance(other, Point2):
            return abs(self - other)
        else:
            raise TypeError("distance_to requires argument of type Point2")
    
    def __getitem__(self, index):
        "obtain the  x and y coordinates in list access format"
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            raise IndexError('list index out of range')
            
class Vector2:
    "Displacement vector in the plane"

    def __init__(self, x, y):
        "Initialize new vector from x and y components"
        self.x = x
        self.y = y

    def __eq__(self, other):
        "vectors are equal if and only if they have same components"
        if isinstance(other, Vector2):
            return (self.x == other.x) and (self.y == other.y)
        else:
            return False

    def __add__(self, other):
        "vector addition"
        if isinstance(other, Vector2):
            # vector+vector = vector
            return Vector2(self.x + other.x, self.y + other.y)
        elif isinstance(other, Point2):
            # vector + point = point
            return Point2(self.x + other.x, self.y + other.y)
        else:
            # vector + anything else = nonsense
            return NotImplemented  # return this to forbid the requested operation
        
    def __sub__(self, other):
        "vector subtraction"
        if isinstance(other, Vector2):
            # vector-vector = vector
            return Vector2(self.x - other.x, self.y - other.y)
        else:
            # vector - anything else = nonsense
            return NotImplemented  # return this to forbid the requested operation

    def __mul__(self, other):
        "vector-scalar multiplication"
        if isinstance(other, (float, int)):  # isinstance allows a tuple of types
            # vector*scalar is vector
            return Vector2(self.x * other, self.y * other)
        else:
            return NotImplemented

    def __rmul__(self, other):
        "scalar-vector multiplication"
        # Called if other*self already attempted but failed
        # for example if other is an int or float and self is a Vector2
        # This "second chance" reflected version of multiplication lets the
        # right hand operand decide what to do.  In this case, we just decide
        # that other*self is the same as self*other (handled by Vector2.__mul__ above)
        return self * other

    def __neg__(self):
        "unary minus"
        return Vector2(-self.x, -self.y)

    def __pos__(self):
        "unary plus: return a copy of the object"
        return self

    def __bool__(self):
        "vector is not the zero vector"
        return not(self.x == 0 and self.y == 0)

    def __abs__(self):
        "abs means length of a vector"
        return (self.x * self.x + self.y * self.y) ** 0.5  # sqrt( deltax^2 + deltay^2 )

    def __str__(self):
        "human-readable string representation"
        return "Vector2({},{})".format(self.x, self.y)

    def __repr__(self):
        "unambiguous string representation"
        return str(self)
    
    def __getitem__(self, index):
        "obtain the vector x and y coordinates in list access format"
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            raise IndexError('list index out of range')

"van" + "illa"

Antistr("quail") + "quail"  # prints a message about energy release, then returns empty str

Antistr("quail") + "quail"  # prints a message about energy release, then returns empty str

"shark" + Antistr("shark")

"carpet" + Antistr("pet")  # anti-pet annihilates pet, leaving just car

Antistr("un") + "uninspired"

# time and anti-time annihilate, but antistring " for a snack" is left 
# and that is an error
"extensive downtime" + Antistr("time for a snack")

class Antistr:
    "Antistr class models behavior of an antistring"
    def __init__(self,s):
        "Initialize a new antistring with a string attribute"
        self.s = s
    def __add__(self,other):
        "antistring addition/annihilation operation"
        if isinstance(other,str):
            if other.startswith(self.s):
                print("BOOM!")
                return other[len(self.s):]
            else:
                raise ValueError("Operation results in dangerous unshielded antistring")
    def __radd__(self,other):
        "antistring right operand addition/annihilation operation"
        if isinstance(other,str):
            if other.endswith(self.s):
                print("BOOM!")
                return other[:-len(self.s)]
            else:
                raise ValueError("Operation results in dangerous unshielded antistring")

    def __repr__(self):
        "unambiguous string representation"
        return str(self)

T = Thermostat()
print(T) # Shows initial state

T.press("up") # In "off" mode, pressing up does nothing.  Still set to 68
print(T)

T.press("mode") # Cycle from "off" to "heat" mode
# Room still at desired temp, so heater and AC are both off
print(T)

T.room_temp(67) # Temp now too low, so the heater will turn on
print(T)

T.press("down") # Desired temp goes down, now equal to room temp, so heater off
print(T)

T.press("mode") # Cycle from "heat" to "cool" mode.  Heater and AC off.
print(T)

T.press("mode") # Cycle from "cool" to "auto" mode.  Heater and AC off.
print(T)

T.room_temp(72) # Room temp is now too high, AC will turn on.
print(T)

T.room_temp(59) # Room temp is now too low, heater will turn on.
print(T)

# Repeatedly lower the desired temp while in auto mode
# For a while, heat will stay on.
# Then the room temp and desired temp will be equal, and both heat and AC will be off
# Then the room temp will be higher than the desired temp, and the AC will turn on
for i in range(10):
    T.press("down")
    print(T)

class Thermostat:
    "Thermostat module class models thermostat status and state transitions"
    def __init__(self):
        "Initialize a new thermostat object with default settings"
        self.next_mode = {
            "off": "heat",
            "heat": "cool",
            "cool": "auto",
            "auto": "off",
        }
        self.mode = "off"
        self.room = 68
        self.desired = 68
        self.ac_is_on = False
        self.heat_is_on = False
        
    def room_temp(self,x):
        "set the room temperature and update state status"
        self.room = x
        self.update()
    
    def ac_is_on(self):
        "is the ac on?"
        return self.ac_is_on
    
    def heat_is_on(self):
        "is the heat on?"
        return self.heat_is_on
        
    def get_display(self):
        "retrieves the control panel text"
        if self.mode == "off":
            numstr = "--"
        else:
            numstr = str(self.desired)
        return numstr + "/" + self.mode
    
    def press(self,btn):
        "pressing a button on panel and adjusting temperature settings"
        if btn == "mode":
            self.mode = self.next_mode[self.mode]
        else:
            if self.mode == "off":
                return
            elif btn == "up":
                self.desired += 1
            elif btn == "down":
                self.desired -= 1
        self.update()
            
    def update(self):
        "adjusts heat/ac control based on desired temp and room temp"
        self.heat_is_on = (self.mode in ["heat","auto"]) and (self.room < self.desired)
        self.ac_is_on = (self.mode in ["ac","auto"]) and (self.room > self.desired)
    
    def __str__(self):
        "readable display of thermostat status data"
        return "Thermostat(mode=\"{}\",display=\"{}\",room={},desired={},ac_is_on={},heat_is_on={})".format(
        self.mode,
        self.get_display(),
        self.room,
        self.desired,
        self.ac_is_on,
        self.heat_is_on)
    def __repr__(self):
        "readable display of thermostat status data"
        return str(self)