Description
You should already know how to do Vector addition, Vector subtraction, Dot products, Matrix
addition, Matrix subtraction, and Matrix multiplication. If you do not know how to do this,
please re-watch the lectures.
The other topic that you need to know is how to override class operators in Python. So, let’s do a
quick Python class/object review:
Defining a Class in Python:
Our goal is to make a class called Point. (x, y)
To define a class, use the keyword “class”
class Point:
pass
This creates a class called Point. There is more that needs to be done though.
Constructors in Python:
A constructor is the function that is called whenever a new object is initialized.
** Note that class functions that begin and end with a double underscore are special functions
class Point:
# default values of (0, 0)
def __init__(self, x = 0, y = 0):
self.x = x
self.y = y
The self parameter should be the first argument for all class functions. This is because self is
used to represent the object. Let’s dissect what is happening here:
• Line 3: def __init__(self, x = 0, y = 0):
o x and y are given default values. If no arguments are given for the constructor,
then they default to zero since x=0 and y=0
• Line 4: self.x = x
o self.x is a variable that belongs to the class
o x is a local variable that is passed as an argument to the constructor
o self.x = x will take the value that was passed as a function input and set it is
the object’s variable
o Thus, there is a difference between self.x and x. This is why self is an
important parameter to be passed
To create a new object
P1 = Point()
P2 = Point(-1, 3)
P3 = Point(y = 4)
print(P1)
print(P2)
print(P3)
In this example, we make three instances of Point:
• P1: takes advantage of default values. Should be (0, 0)
• P2: should be (-1, 3)
• P3: keeps default value of x = 0. should be (0, 4)
What is printed though, is the object address instead of the values that we saved.
Creating str function for debugging purposes:
class Point:
# default values of (0, 0)
def __init__(self, x = 0, y = 0):
self.x = x
self.y = y
def __str__(self):
string = ‘(‘ + str(self.x) + ‘, ‘ + str(self.y) + ‘)’
return string
P1 = Point()
P2 = Point(-1, 3)
P3 = Point(y = 4)
print(P1)
print(P2)
print(P3)
• In the __str__ function
o self is passed as a parameter because we want to access the object’s x and y
values. Not some local one. If we replace self.x and self.y with x and
y respectively, then we’ll get an error
o We return the string that we want to see when we print the object
• Now we get the actual point because we have overridden the default __str__ function that
just returns the object’s address
•
Making object functions in Python:
You can make functions that are specific to the object.
class Point:
# default values of (0, 0)
def __init__(self, x = 0, y = 0):
self.x = x
self.y = y
def distance(self):
dist = (self.x**2 + self.y**2) ** (1/2)
return dist
def __str__(self):
string = ‘(‘ + str(self.x) + ‘, ‘ + str(self.y) + ‘)\n’
string += ‘Distance: ‘ + str(self.distance())
return string
P1 = Point()
P2 = Point(-1, 3)
P3 = Point(y = 4)
print(P1)
print(P2)
print(P3)
print(‘P1:’, P1.distance())
print(‘P2:’, P2.distance())
print(‘P3:’, P3.distance())
Notice…
• In distance()
o self parameter is still passed as an input
• In __str__()
o To call the distance() function, we use self.distance() because this
function is specific to the object
• In main
o To call the function, we use object_name.function_name()
o Note that we call this function differently (without self) because it is not
within the function
Function overloading in Python:
Let’s say that you have the following
class Point:
# default values of (0, 0)
def __init__(self, x = 0, y = 0):
self.x = x
self.y = y
def distance(self):
dist = (self.x**2 + self.y**2) ** (1/2)
return dist
def __str__(self):
string = ‘(‘ + str(self.x) + ‘, ‘ + str(self.y) + ‘)’
# string += ‘Distance: ‘ + str(self.distance())
return string
P1 = Point()
P2 = Point(-1, 3)
P3 = Point(y = 4)
print(P1, ‘+’, P2, ‘=’, P1 + P2)
You would get an error because Python is unable to decipher how “+” should work when it
has the two Point objects as arguments.
We must overload the operator by implementing __add__() in the class.
To overload other operators:
Operator Expression Function
Addition self + other __add__(self, other)
Subtraction self – other __sub__(self, other)
Multiplication self * other __mul__(self, other)
class Point:
# default values of (0, 0)
def __init__(self, x = 0, y = 0):
self.x = x
self.y = y
def distance(self):
dist = (self.x**2 + self.y**2) ** (1/2)
return dist
# This would work with the case: self + other (in this order)
# This adds to the x/y attributes of self and other
# Returns a new Point
def __add__(self, other):
x = self.x + other.x
y = self.y + other.y
return Point(x, y)
def __str__(self):
string = ‘(‘ + str(self.x) + ‘, ‘ + str(self.y) + ‘)’
# string += ‘Distance: ‘ + str(self.distance())
return string
P1 = Point()
P2 = Point(-1, 3)
P3 = Point(y = 4)
print(P1, ‘+’, P2, ‘=’, P1 + P2)
No more error J
Instructions:
1. Take a close look at the Vector.py and Matrix.py files. There are some
functions that have already been implemented. In addition, there are two operators
that you need to overload: __sub__ and __mul__. Read through both of their
descriptions carefully.
File name Functions completed Functions to be completed
Vector.py Constructor
get_ith_element
__str__
__add__
__sub__
__mul__
Matrix.py Constructor
get_element
__str__
__add__
__sub__
__mul__
READ THE DESCRIPTIONS CAREFULLY! You will lose points if you do not follow the
instructions. We are using a grading script.
****Do NOT alter the already implemented functions in ANY significant way.
2. Your job is to implement the five highlighted functions/operators so that it passes
any test case. There are four and six sample test cases provided for you in Vector.py
and Matrix.py respectively, but these are not the only cases that we will test. We will
be testing other test cases in the same way the test cases are presented. DO NOT
USE NUMPY FOR THE IMPLEMENTATION. If you do, then you will get a zero on this
assignment!!!! The goal of the assignment is to implement the algorithms for each
operation while proving your ability to use Python.
3. After completing these functions, comment out the test cases (or delete them) or
else the grading script will pick it up and mark your program as incorrect. Also,
MAKE SURE THAT YOUR PROGRAM DOES NOT PRINT ANYTHING!!! The grading
script may pick up any printed text and misinterpret it as a test case or input
causing you to lose points.
4. Convert your Vector.py AND Matrix.py file to .txt files. Submit your
Vector.py, Matrix.py, and your .txt files on BeachBoard. Do NOT submit it
in compressed folder.
5. Do not email us your code asking us to verify it. We will answer general questions,
but we will not debug your code over email.
Grading rubric
To achieve any points, your submission must have the following. Anything missing from
this list will result in an automatic zero. NO EXCEPTIONS!
• Submit both py and txt files
• Files named correctly
• Program has no errors (infinite loops, syntax errors, logical errors, etc.) that
terminates the program
Please note that if you change the function headers or if you do not return the proper
outputs according to the function requirements, you risk losing all points for those test
cases.
Points Requirement
5 Submitted the correct 4 files: Vector.py, Matrix.py, Vector.txt, Matrix.txt
5 Passes 10 (4 from Vector and 6 from Matrix) original test cases. Also
commented out or deleted the test cases
5 Implemented __sub__ in Vector correctly (Part 1)- 5 cases
5 Implemented __mul__ in Vector correctly (Part 2)- 5 cases
10 Implemented __add__ in Matrix correctly (Part 3)- 10 cases
10 Implemented __sub__ in Matrix correctly (Part 4) 10 cases
15 Implemented __mul__ in Matrix correctly (Part 5) – 10 cases
*** If you use numpy in this lab, you will get an automatic zero!