def convert_to_rational(str_value):
"""
-------------------------------------------------------
[function description]
-------------------------------------------------------
Preconditions:
[parameter name - parameter description (parameter type and constraints)]
Postconditions:
[returns: or prints:]
[return value name - return value description (return value type)]
-------------------------------------------------------
"""
if ("." in str_value):
rat_value = Rational.parse_number(str_value)
else:
rat_value = Rational.parse_string(str_value)
return rat_value
def test_1_0(self):
try:
r = Rational(1, 0)
except ZeroDivisionError:
pass
except Exception as e:
self.assertTrue(False, "unexpected exception: {}".format(e))
else:
self.assertTrue(False, "No exception occur!")
def test_values(self):
for p, q in [(1.0, 2), (1, 2.0), ("1", 2), ("1", "2"), (1, "2")]:
try:
r = Rational(p, q)
except TypeError:
pass
except Exception as e:
self.assertTrue(False, "unexpected exception: {}".format(e))
else:
self.assertTrue(False, "No exception occur!")
def get_poly(text):
if 'x' in text:
return Polynomial.from_string(text)
terms = re.findall(r'-?\d+\.?\d*|/', text)
if '/' in terms:
numerator, denominator = terms[:terms.index('/')], terms[terms.index('/') + 1:]
num_coefs, den_coefs = list(map(float, numerator)), list(map(float, denominator))
return Rational(num_coefs, den_coefs)
else:
coefs = map(float, terms)
return Polynomial(*coefs)
def div(self, oth):
'''Деление многочленов столбиком, Васильев Максим'''
a = Polynome(self.tostr())
b = Polynome(oth.tostr())
da = a.deg() - b.deg()
res = Polynome('0/1')
# Заводим многочлен под результат, степени разность двух + 1
res.coeffs = [Rational('0/1') for i in range(da + 1)]
i = 0
# Пока степень делимого больше степени делителя
while a.moreeqDeg(b):
res.coeffs[da - i] = a.coeffs[-1] / b.coeffs[-1]
# Вычитаем полином умноженный на коэфициент при старшем члене
if not a.coeffs[-1].isZero():
cur = b.mulM(res.coeffs[da - i], da - i)
a = a - cur
i += 1
# Выкидываем первый коэффициент, т.к. мы его вычли
a.coeffs.pop()
# Возвращаем целую часть и остаток от деления
# Возвращаем [<object Polynome>, <object Polynome>]
return [res, a]
class TestRational(TestCase):
def test___init__(self):
# testing 0
self.rat1 = Rational(0,1)
self.assertEqual(self.rat1.n, 0)
self.assertEqual(self.rat1.d, 1)
# testing 1
self.rat1 = Rational(1, 1)
self.assertEqual(self.rat1.n, 1)
self.assertEqual(self.rat1.d, 1)
# testing -1
self.rat1 = Rational(-1, 1)
self.assertEqual(self.rat1.n, -1)
self.assertEqual(self.rat1.d, 1)
# testing 1 million
self.rat1 = Rational(1000000, 1)
self.assertEqual(self.rat1.n, 1000000)
self.assertEqual(self.rat1.d, 1)
# testing 1 millionth
self.rat1 = Rational(1, 10000000)
self.assertEqual(self.rat1.n, 1)
self.assertEqual(self.rat1.d, 10000000)
# testing -1 million
self.rat1 = Rational(-1000000, 1)
self.assertEqual(self.rat1.n, 1)
self.assertEqual(self.rat1.d, 1)
# testing -1 millionth
self.rat1 = Rational(-1, 1000000)
self.assertEqual(self.rat1.n, 1)
self.assertEqual(self.rat1.d, 1)
# testing 0 denom
with self.assertRaises(ZeroDivisionError):
self.rat1 = Rational(1,0)
# test type error
with self.assertRaises(TypeError):
self.rat1 = Rational('bork', 'blork')
def test___add__(self):
# zero
self.rat1 = Rational(0, 1)
# one
self.rat2 = Rational(1, 1)
# neg one
self.rat3 = Rational(-1, 1)
# one million
self.rat4 = Rational(1000000, 1)
# one millionth
self.rat5 = Rational(1, 10000000)
# neg one million
self.rat6 = Rational(-1000000, 1)
# neg one millionth
self.rat7 = Rational(-1, 1000000)
# 0 + 1
self.assertEqual(self.rat1.__add__(self.rat2), Rational(1,1))
# 0 + -1
self.assertEqual(self.rat1.__add__(self.rat3), Rational(-1, 1))
# 0 + 1000000
self.assertEqual(self.rat1.__add__(self.rat4), Rational(1000000, 1))
# 0 + 1/1000000
self.assertEqual(self.rat1.__add__(self.rat5), Rational(1, 1000000))
# 0 + -1000000
self.assertEqual(self.rat1.__add__(self.rat6), Rational(-1000000, 1))
# 0 + - 1/1000000
self.assertEqual(self.rat1.__add__(self.rat7), Rational(-1, 1000000))
# add string
with self.assertRaises(TypeError):
self.rat1.__add__('bork')
def test___sub__(self):
self.rat0 = Rational(0, 1)
self.rat1 = Rational(2, 1)
self.rat2 = Rational(1, 2)
self.rat3 = Rational(1, 3)
self.rat4 = Rational(100000, 1)
self.rat5 = Rational(50000, 1)
self.assertEqual(self.rat1.__sub__(self.rat2), Rational(3, 2))
self.assertEqual(self.rat2.__sub__(self.rat2), Rational(0, 1))
self.assertEqual(self.rat2.__sub__(self.rat3), Rational(1, 6))
self.assertEqual(self.rat1.__sub__(self.rat0), Rational(2, 1))
self.assertEqual(self.rat3.__sub__(self.rat2), Rational(-1, 6))
self.assertEqual(self.rat2.__sub__(self.rat1), Rational(-3, 2))
self.assertEqual(self.rat4.__sub__(self.rat5), Rational(50000, 1))
def test___div__(self):
self.rat1 = Rational(1, 1)
self.rat2 = Rational(2, 1)
self.rat3 = Rational(1, 2)
self.rat4 = Rational(-2, 1)
self.rat5 = Rational(-1, 2)
self.assertEqual(self.rat1.__div__(self.rat2), Rational(1,2))
self.assertEqual(self.rat2.__div__(self.rat3), Rational(4,1))
self.assertEqual(self.rat3.__div__(self.rat2), Rational(1,4))
self.assertEqual(self.rat4.__div__(self.rat2), Rational(-1,1))
self.assertEqual(self.rat5.__div__(self.rat4), Rational(1,4))
def test___str__(self):
self.rat1 = Rational(1, 1)
self.rat2 = Rational(2, 1)
self.rat3 = Rational(1, 2)
self.rat4 = Rational(-2, 1)
self.rat5 = Rational(-1, 2)
self.assertEqual(self.rat1.__str__(), "1")
self.assertEqual(self.rat2.__str__(), "2")
self.assertEqual(self.rat3.__str__(), "1/2")
self.assertEqual(self.rat4.__str__(), "-2")
self.assertEqual(self.rat5.__str__(), "-1/2")
def test___float__(self):
self.ratFloat = Rational()
self.ratFloat1 = Rational(1, 100000)
self.ratFloat2 = Rational(10000, 10)
self.ratFloat3 = Rational(2341, 3980)
self.assertType(self.ratFloat.__float__(), float)
self.assertType(self.ratFloat1.__float__(), float)
self.assertType(self.ratFloat2.__float__(), float)
self.assertType(self.ratFloat3.__float__(), float)
def division(a, b):
a1 = Rational(str(a))
b1 = Rational(str(b))
text = a1, "-", b1, "=", (a1-b1).red()
return text
def division(a):
a1 = Rational(str(a))
text = a, "=", Rational.red(a1)
return text
def test_n1_n2(self):
r = Rational(-1, -2)
self.assertEqual(str(r), "1/2")
def test_3_7(self):
r = Rational(3, 7)
self.assertEqual(str(r), "3/7")
def test_2_1(self):
r = Rational(2, 1)
self.assertEqual(str(r), "2")
def test___sub__(self):
self.rat0 = Rational(0, 1)
self.rat1 = Rational(2, 1)
self.rat2 = Rational(1, 2)
self.rat3 = Rational(1, 3)
self.rat4 = Rational(100000, 1)
self.rat5 = Rational(50000, 1)
self.assertEqual(self.rat1.__sub__(self.rat2), Rational(3, 2))
self.assertEqual(self.rat2.__sub__(self.rat2), Rational(0, 1))
self.assertEqual(self.rat2.__sub__(self.rat3), Rational(1, 6))
self.assertEqual(self.rat1.__sub__(self.rat0), Rational(2, 1))
self.assertEqual(self.rat3.__sub__(self.rat2), Rational(-1, 6))
self.assertEqual(self.rat2.__sub__(self.rat1), Rational(-3, 2))
self.assertEqual(self.rat4.__sub__(self.rat5), Rational(50000, 1))
def testScalar(self):
"""Initialize a rational number using a scalar."""
r = Rational.as_rational(12)
self.assertEquals(r._numer, 12)
self.assertEquals(r._denom, 1)
def __init__(self, str):
coeffs = str.split()
self.coeffs = [Rational(i) for i in reversed(coeffs)]
from complex import Complex
import rational
import ordinary
import poly
import complex
from table import get, put
from basePackage import add, sub, mul, div, neg, rev
if __name__ == '__main__':
# At first, let's install numbers packages
rational.installPackage()
ordinary.installPackage()
poly.installPackage()
complex.installPackage()
r1 = Rational(1, 5)
r2 = Rational(2, 5)
o1 = Ordinary(3)
o2 = Ordinary(8)
r3 = rational.add(r1, r2)
print r3
o3 = ordinary.add(o1, o2)
print o3
print 'Neg :', neg(r1)
print 'Rev :', rev(r1)
print 'Ord :', add(3, 4)
p1 = Poly('x', (1, 1), (3, 3), (2, 2))
def test_string_one(self):
result = Rational().__str__()
self.assertEqual('0/1', result)
def test_float_one(self):
result = Rational().__float__()
self.assertEqual(0.0, result)
def test_string_two(self):
result = Rational().__str__()
self.assertEqual('0', result[0])
self.assertEqual('/', result[1])
self.assertEqual('1', result[2])
def test___add__(self):
# zero
self.rat1 = Rational(0, 1)
# one
self.rat2 = Rational(1, 1)
# neg one
self.rat3 = Rational(-1, 1)
# one million
self.rat4 = Rational(1000000, 1)
# one millionth
self.rat5 = Rational(1, 10000000)
# neg one million
self.rat6 = Rational(-1000000, 1)
# neg one millionth
self.rat7 = Rational(-1, 1000000)
# 0 + 1
self.assertEqual(self.rat1.__add__(self.rat2), Rational(1,1))
# 0 + -1
self.assertEqual(self.rat1.__add__(self.rat3), Rational(-1, 1))
# 0 + 1000000
self.assertEqual(self.rat1.__add__(self.rat4), Rational(1000000, 1))
# 0 + 1/1000000
self.assertEqual(self.rat1.__add__(self.rat5), Rational(1, 1000000))
# 0 + -1000000
self.assertEqual(self.rat1.__add__(self.rat6), Rational(-1000000, 1))
# 0 + - 1/1000000
self.assertEqual(self.rat1.__add__(self.rat7), Rational(-1, 1000000))
# add string
with self.assertRaises(TypeError):
self.rat1.__add__('bork')
def test___init__(self):
# testing 0
self.rat1 = Rational(0,1)
self.assertEqual(self.rat1.n, 0)
self.assertEqual(self.rat1.d, 1)
# testing 1
self.rat1 = Rational(1, 1)
self.assertEqual(self.rat1.n, 1)
self.assertEqual(self.rat1.d, 1)
# testing -1
self.rat1 = Rational(-1, 1)
self.assertEqual(self.rat1.n, -1)
self.assertEqual(self.rat1.d, 1)
# testing 1 million
self.rat1 = Rational(1000000, 1)
self.assertEqual(self.rat1.n, 1000000)
self.assertEqual(self.rat1.d, 1)
# testing 1 millionth
self.rat1 = Rational(1, 10000000)
self.assertEqual(self.rat1.n, 1)
self.assertEqual(self.rat1.d, 10000000)
# testing -1 million
self.rat1 = Rational(-1000000, 1)
self.assertEqual(self.rat1.n, 1)
self.assertEqual(self.rat1.d, 1)
# testing -1 millionth
self.rat1 = Rational(-1, 1000000)
self.assertEqual(self.rat1.n, 1)
self.assertEqual(self.rat1.d, 1)
# testing 0 denom
with self.assertRaises(ZeroDivisionError):
self.rat1 = Rational(1,0)
# test type error
with self.assertRaises(TypeError):
self.rat1 = Rational('bork', 'blork')
""" test_rational.py """
from rational import Rational
num = input("Please enter numerator: ")
den = input("Please enter the denominator: ")
num2 = input("Please enter numerator: ")
den2 = input("Please enter the denominator: ")
r1 = Rational(int(num), int(den))
r2 = Rational(int(num2), int(den2))
print(r1)
print(r2)
#r3 = Rational(r1 + r2)
print(r1 + r2)
from rational import Rational
# initialization
a = Rational(3, 2)
b = Rational(4, 5)
#operations
c = a + b
d = a - b
e = a * b
f = a / b
# displaying results
print('First rational number', a)
print('Second rational number', b)
print("addition", c)
print("substraction", d)
print("multiplication", e)
print('Division', f)
def compute_e(n):
answer = Rational(1)
for i in irange(1, n):
answer += Rational(1, math.factorial(i))
return answer
def test_3_9(self):
r = Rational(3, 9)
self.assertEqual(str(r), "1/3")
def test_1_2(self):
r = Rational(1, 2)
self.assertEqual(str(r), "1/2")
def test_1_n2(self):
r = Rational(1, -2)
self.assertEqual(str(r), "-1/2")
return self.numer != 0
# Note that the numerator and the denominator of the rational numbers
# must be reduced to their smallest possible values. It may be helpful
# to implement a function that computes the Greatest Common Divisor of
# two numbers. You can make this a nested function in the constructor
# for the Rational class.
if __name__ == '__main__':
from rational import Rational
first = Rational()
print ('first: ', first)
second = Rational(4)
print ('second: ', second)
third = Rational(25,10)
print ("third: {0}/{1}".format(third.numerator(), third.denominator()))
first += third
print ('first: ', first)
third *= 8
print ('third: ', third)
third /= first
print ('third: ', third)
fourth = Rational(18,158)
print ('fourth: ', fourth)
third -= fourth
print ('third: ', third)
fourth = first + second
print ('fourth: ', fourth)
def test_n4_2(self):
r = Rational(-4, 2)
self.assertEqual(str(r), "-2")
def test___div__(self):
self.rat1 = Rational(1, 1)
self.rat2 = Rational(2, 1)
self.rat3 = Rational(1, 2)
self.rat4 = Rational(-2, 1)
self.rat5 = Rational(-1, 2)
self.assertEqual(self.rat1.__div__(self.rat2), Rational(1,2))
self.assertEqual(self.rat2.__div__(self.rat3), Rational(4,1))
self.assertEqual(self.rat3.__div__(self.rat2), Rational(1,4))
self.assertEqual(self.rat4.__div__(self.rat2), Rational(-1,1))
self.assertEqual(self.rat5.__div__(self.rat4), Rational(1,4))
def test_init2(self):
r = Rational(1, -2)
self.assertTrue(r.d != -2)
def division(a):
a1 = Rational(str(a))
text = a + "=" + str(Rational.toContinued(a1))
return text
def test_values(self):
for p, expect in [(1, "1"), (-2, "-2")]:
r = Rational(p)
self.assertEqual(str(r), expect)
def test_init1(self):
r = Rational(1, 2)
self.assertIs(r.n, 1)
self.assertIs(r.d, 2)