# add you name up here # modify the fraction shown below # NOTE, you should inde
ID: 3677669 • Letter: #
Question
# add you name up here
# modify the fraction shown below
# NOTE, you should indent by using 4 spaces for each indent, and not tab
# and the gcd is different below than in the book you will need to call it as in the __add__ method
# we have made the gcd method part of the class so it is now called as self.gcd(n1,n2)
class Fraction:
def __init__(self,n,d):
self.num = n
self.den = d
def __repr__(self):
return str(self.num) + "/" + str(self.den)
def gcd(self,m,n):
while m % n != 0:
oldm = m
oldn = n
m = oldn
n = oldm % oldn
return n
def __add__(self,otherfraction):
newnum = self.num*otherfraction.den + self.den*otherfraction.num
newden = self.den * otherfraction.den
cd = self.gcd(newnum,newden) #### when you use gcd in __init__ you need to use self.gcd like here
return Fraction(newnum//cd,newden//cd)
def __eq__(self,otherFraction):
# note this only works if fractions are in lowest terms
return( self.num==otherFraction.num and self.den==otherFraction.den)
# note you can cut out all the test code below and move to a TestFraction.py file
# which will allow you to add your own tests to Fraction.py and still run the automated
# from the other file
# The code below will test each feature using unit testing
# the name of each test tells you what it is testing
# if a test fails you should se a trace dump. You will need to
# use the debugger or write print statements to debug you code.
#
# if everything passes you should see this printout
# .............
# ----------------------------------------------------------------------
# Ran 13 tests in 0.001s
#
# OK
import unittest
class TestFraction(unittest.TestCase):
def setUp(self):
self.f1123 = Fraction(11, 23)
self.f_43 = Fraction(-4, 3)
self.x = Fraction(1,2)
self.y = Fraction(3,4)
def test_eq_add_repr(self):
sum = self.f1123+self.f_43
self.assertTrue( str(sum) == "-59/69", "expected '-59/69' after add 11/23 + 4/3, found " + str(sum))
self.assertTrue( self.f1123 == Fraction(11, 23), "__eq__ failed here")
def test_get_num_den(self):
z = Fraction(1,3) # 1/3
self.assertTrue( z.getNum() == 1,"expected 1, found " + str(z.getNum()) )
self.assertTrue( z.getDen() == 3, "expected 3, found " + str(z.getDen()) )
def test_repr_works(self):
self.assertTrue( str(self.f1123) == "11/23", "expected 11/23 __repr__ returned " + str(self.f1123) )
self.assertTrue( str(self.f_43) == "-4/3", "expected -4/3 __repr__ returned " + str(self.f_43) )
def test_getNum(self):
self.assertTrue( self.f1123.getNum() == 11,"expected 11, found " + str(self.f1123.getNum()))
self.assertTrue( self.f_43.getNum() == -4, "expected -4, found "+ str(self.f1123.getNum()))
def test_getDen(self):
self.assertTrue( self.f1123.getDen() == 23, "expected 23, found " + str(self.f1123.getDen()))
self.assertTrue( self.f_43.getDen() == 3, "expected 3, found " + str(self.f_43.getDen()))
def test_mul(self):
x = str(Fraction(1,3) * Fraction(1,4))
self.assertTrue( x == "1/12","expected 1/12 result was " + x)
def test_sub(self):
x1 = str(Fraction(1,2) - Fraction(1,4))
self.assertTrue(x1 == "1/4", "expected 1/4 result was " + x1)
x2 = str(Fraction(5,16) - Fraction(2,16))
self.assertTrue(str(Fraction(5,16) - Fraction(2,16)) == "3/16", "expected 3/16 result was " + x2)
def test_div(self):
x1 = str(Fraction(1,2) / Fraction(1,2))
self.assertTrue(x1 == "1/1", "expected 1/1 result was " + x1)
x2 = str(Fraction(1,3) / Fraction(1,2))
self.assertTrue(x2 == "2/3", "expected 2/3 result was " + x2)
x3 = str(Fraction(4,15) / Fraction(4,1))
self.assertTrue(x3 == "1/15", "expected 1/15 result was " + x3)
def test_gt(self):
self.assertFalse(self.x > self.y, "x > y x: %s y: %s returned False:" % (str(self.x),str(self.y)))
self.assertTrue(self.y > self.x, "y > x x: %s y: %s returned False:" % (str(self.x),str(self.y)))
def test_ge(self):
self.assertTrue(self.x >= self.x, "x >= x x: %s returned False:" % (str(self.x)))
self.assertFalse(self.x >= self.y, "x >= y x: %s y: %s returned False:" % (str(self.x),str(self.y)))
self.assertTrue(self.y >= self.x, "y >= x x: %s y: %s returned False:" % (str(self.x),str(self.y)))
def test_le(self):
self.assertTrue(self.x <= self.y, "x <= y x: %s y: %s returned False:" % (str(self.x),str(self.y)))
self.assertTrue(self.x <= self.x, "x <= x x: %s returned False:" % (str(self.x)))
self.assertFalse(self.y <= self.x, "x <= y x: %s y: %s returned False:" % (str(self.x),str(self.y)))
def test_ne(self):
self.assertFalse(self.x != Fraction(1,2), " x != x x: %s returned False:" % (str(self.x)))
self.assertTrue(self.y != Fraction(3,4), "x != y x: %s y: %s returned False:" % (str(self.x),str(self.y)))
def test_init_gcd(self):
z1 = Fraction(10,20)
self.assertTrue(str(z1) == "1/2", "expected 1/2 returned " + str(z1))
z2 = Fraction(1,4)
z3 = Fraction(3,4)
self.assertTrue(str(z2+z3) == "1/1", "expected 1/1 returned " + str(z2+z3))
def test_raise_non_int(self):
with self.assertRaises(Exception):
Fraction(1.1,0)
with self.assertRaises(Exception):
Fraction(0,23.4)
if __name__ == '__main__':
unittest.main()
Explanation / Answer
class Fraction:
def __init__(self,top,bottom):
self.num = top
self.den = bottom
def getNum(self): Q1. getNum and getDen
return self.num
def getDen(self):
return self.den
def gcd(m,n): Q2. GCD
while m%n != 0:
prev_m = m
prev_n = n
m = prev_n
n = prev_m%prev_n
return n
def __add__(self,twoFraction):
newnum = self.num*twoFraction.den + self.den*twoFraction.num
newden = self.den * twoFraction.den
return Fraction(newnum,newden)
def __sub__(self,twoFraction): Q3. sub,mul,div
newnum = self.num*twoFraction.den - self.den*twoFraction.num
newden = self.den * twoFraction.den
return Fraction(newnum,newden)
def __mul__(self,twoFraction): // This is not in the lowest form.
newnum = self.num*twoFraction.num
newden = self.den * twoFraction.den
return Fraction(newnum,newden)
def __div__(self,twoFraction): // This is not in the lowest form.
newnum = self.num*twoFraction.den
newden = self.den * twoFraction.num
return Fraction(newnum,newden)
def __div__(self,twoFraction): // This is not in the lowest form.
newnum = self.num*twoFraction.den
newden = self.den * twoFraction.num
return Fraction(newnum,newden)
def __gt__(self,twoFraction):
newden = self.den * twoFraction.den
newnum1 = self.num*twoFraction.den
newnum2 = twoFraction.num*self.den
if(newnum1>newnum2)
return Fraction(newnum,newden)
else return null
def __lt__(self,twoFraction):
newden = self.den * twoFraction.den
newnum1 = self.num*twoFraction.den
newnum2 = twoFraction.num*self.den
if(newnum1<newnum2)
return Fraction(newnum,newden)
else return null
def __ne__(self,twoFraction):
newden = self.den * twoFraction.den
newnum1 = self.num*twoFraction.den
newnum2 = twoFraction.num*self.den
if(newnum1 != newnum2)
return Fraction(newnum,newden)
else return null
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.