Description
Objectives:
1. Apply vector operations to translate, scale, and rotate a set of points representing an
image.
2. Perform various operations with or on vectors: addition, subtraction, dot product, norm.
NOTES:
1. Unless otherwise stated in the FIXME comment, you may not change the outline of the
algorithm provided by introducing new loops or conditionals, or by calling any built-in
functions that perform the entire algorithm or replaces a part of the algorithm.
2. You may import and use the Python math module to obtain the value for and to
calculate sine, cosine, and tangent functions, if needed.
Problem 1:
Create a function translate(S, z0) that translates the points in the input set by
. The function should satisfy the following:
1. INPUT:
S – set S
z0 – complex number
2. OUT:
T – set T consisting of points in S translated by
e
S
z0 = a0 + b0i
z0
In [ ]:
def translate(S, z0):
“””
translates the complex numbers of set S by z0
:param S: set type; a set of complex numbers
:param z0: complex type; a complex number
Problem 2:
Create a function scale(S, k) that scales the points in the input set by a factor of :
1. INPUT:
S – set S
k – positive float, raises ValueError if k 0.
2. OUTPUT:
a set consisting of points in S scaled by .
Problem 3:
Create a function rotate(S, tau) that rotates the points in the input set by radians:
1. INPUT:
S – set S
tau – float. If negative, the rotation is clockwise. If positive the rotation is
counterclockwise. If zero, no rotation.
2. OUT:
a set consisting of points in S rotated by
:return: set type; a set consisting of points in S translated by z0
“””
# FIXME: Implement this function
# FIXME: Return correct output
return None
S k
≤
k
In [ ]:
def scale(S, k):
“””
scales the complex numbers of set S by k.
:param S: set type; a set of complex numbers
:param k: float type; positive real number
:return: set type; a set consisting of points in S scaled by k
:raise: raises ValueError if k <= 0
“””
# FIXME: Implement this function.
# FIXME: Return correct output
return None
S τ
τ
In [ ]:
def rotate(S, tau):
“””
rotates the complex numbers of set S by tau radians.
:param S: set type; – set of complex numbers
:param tau: float type; radian measure of the rotation value. If negative, the rot
If positive the rotation is counterclockwise. If zero, no rotation.
:returns: set type; a set consisting of points in S rotated by tau radians
“””
# FIXME: Implement this function.
# FIXME: Return correct output
return None
Problem 4:
Finish the implementation of class Vec which instantiates row-vector objects with defined
operations of addition, subtraction, scalar multiplication, and dot product. In addition, Vec
class overloads the Python built-in function abs() so that when it is called on a Vec object, it
returns the Euclidean norm of the vector.
In [ ]:
class Vec:
def __init__(self, contents = []):
“””
Constructor defaults to empty vector
INPUT: list of elements to initialize a vector object, defaults to empty list
“””
self.elements = contents
return
def __abs__(self):
“””
Overloads the built-in function abs(v)
:returns: float type; the Euclidean norm of vector v
“””
# FIXME: Implement this method
# FIXME: Return correct output
return None
def __add__(self, other):
“””
overloads the + operator to support Vec + Vec
:raises: ValueError if vectors are not same length
:returns: Vec type; a Vec object that is the sum vector of this Vec and ‘other
“””
# FIXME: Finish the implementation
# FIXME: Return correct output
return None
def __sub__(self, other):
“””
overloads the – operator to support Vec – Vec
:raises: ValueError if vectors are not same length
:returns: Vec type; a Vec object that is the difference vector of this Vec and
“””
# FIXME: Finish the implementation
# FIXME: Return correct output
return None
def __mul__(self, other):
“””
Overloads the * operator to support
– Vec * Vec (dot product) raises ValueError if vectors are not
same length in the case of dot product; returns scalar
– Vec * float (component-wise product); returns Vec object
– Vec * int (component-wise product); returns Vec object
“””
if type(other) == Vec: #define dot product
# FIXME: Complete the implementation
# FIXME: Return the correct output
return None
elif type(other) == float or type(other) == int: #scalar-vector multiplication
# FIXME: Complete the implementation
# FIXME: Return the correct output
return None
def __rmul__(self, other):
“””Overloads the * operation to support
– float * Vec; returns Vec object
– int * Vec; returns Vec object
“””
# FIXME: Complete the implementation
# FIXME: Return the correct output
return None
def __str__(self):
“””returns string representation of this Vec object”””
return str(self.elements) # does NOT need further implementation
