class TestMonomial(unittest.TestCase):
def setUp(self):
self.mon_1 = Monomial(5, 2, 'x')
self.mon_2 = Monomial(3, 4, 'x')
def test_str(self):
self.assertEqual(str(self.mon_1), "5*x^2")
self.assertNotEqual(str(self.mon_1), str(self.mon_2))
def test_add(self):
mon_3 = Monomial(12, 2, 'x')
self.assertEqual(str(self.mon_1 + mon_3), "17*x^2")
def test_eq(self):
self.assertFalse(self.mon_1 == self.mon_2)
self.assertTrue(self.mon_1 == Monomial(5, 2, 'x'))
def test_lt(self):
self.assertTrue(self.mon_1 < self.mon_2)
self.assertFalse(self.mon_2 < self.mon_1)
def test_gt(self):
self.assertFalse(self.mon_1 > self.mon_2)
self.assertTrue(self.mon_2 > self.mon_1)
def test_hash(self):
self.assertEqual(self.mon_1.__hash__(), Monomial(5, 2, 'x').__hash__())
self.assertNotEqual(self.mon_1.__hash__(), self.mon_2.__hash__())
def test_derivative(self):
dev = Monomial(10, 1, 'x')
self.assertEqual(self.mon_1.derivative(), dev)
self.assertNotEqual(self.mon_2.derivative(), dev)
def test_when_power_equals_one_then_return_the_same_coeff_and_power_0(
self):
monomial = Monomial(5, 1)
expected = Monomial(5, 0)
self.assertEqual(monomial.find_derivative(), expected)
def __call__(self, element):
"""
>>> from polynomial import *
>>> R = PolynomialRing(QQ, 'xyz')
>>> x, y, z = R.variables()
>>> R(2)
2*1
>>> R(Monomial(R, (4, 3, 2))) # this fails since monomial is not imported at the top-level in PolynomialRing
x^4*y^3*z^2
"""
from polynomial import Polynomial
from mod import Mod
from rational import Rational
from monomial import Monomial
if isinstance(element, Polynomial):
if element.ring is self:
return element
else:
for i in range(len(element.monomials)):
element.monomials[i].ring = self
return Polynomial(self, element.monomials,
[self(coeff) for coeff in element.coeffs])
elif isinstance(element, Monomial):
return Polynomial(self, [element], [self.coeff_ring(1)])
elif isinstance(element, Mod) or isinstance(
element, Rational) or isinstance(element, int):
return Polynomial(
self, [Monomial(self, tuple([0 for var in self.var_list]))],
[self.coeff_ring(element)])
def __pow__(self, power):
"""
>>> from polynomial import *
>>> R = PolynomialRing(QQ, 'xyz')
>>> x, y, z = R.variables()
>>> x**2
x^2
>>>
x^4*z^2 + 2*x^4*z + x^4
>>> Polynomial(R, [Monomial(R, (2, 0, 0)), Monomial(R, (2, 0, 1))], [1, 1])**0
1
>>> Polynomial(R, [Monomial(R, (2, 0, 0)), Monomial(R, (2, 0, 1))], [1, 1])**1
x^2*z + x^2
>>> Polynomial(R, [Monomial(R, (0, 1, 0)), Monomial(R, (1, 0, 0))], [1, 1])**3
x^3 + 3*x^2*y + 3*x*y^2 + y^3
>>> Polynomial(R, [Monomial(R, (1, 1, 1))], [1])**5
x^5*y^5*z^5
"""
i = 0
x = Polynomial(self.ring, self.monomials, self.coeffs)
if power == 0:
return Polynomial(self.ring, [Monomial(self.ring, (0, 0, 0))], [1])
elif power == 1:
return self
else:
for i in range(power-1):
x = x * self
return x
def cast_value(self):
if self.ttype is TokenType.number:
self.value = Monomial(Variables(''), Numbers(int(self.value)))
self.ttype = TokenType.monomial
elif self.ttype is TokenType.results:
if self.value == '[last]':
if not helpers.history:
raise InvalidHistoryCallException
self.value = len(helpers.history) - 1
return
self.value = int(self.value[1:-1])
if self.value >= len(helpers.history):
raise InvalidHistoryCallException
elif self.ttype is TokenType.symbol:
self.value = Monomial(Variables(self.value), Numbers(1))
self.ttype = TokenType.monomial
def __add_monomials(self, monomials):
for monomial in monomials:
monomial = monomial.split('x^')
if monomial[0] != '0':
self.__polynomial.append(
Monomial(int(monomial[0]), int(monomial[1])))
self.__polynomial.sort(reverse=True)
def random_monomial(self, degree):
"""
Returns a random monomial of degree <= 'degree'
"""
from monomial import Monomial
while True:
m = [randint(0, degree) for i in range(self._num_vars)]
if sum(m) <= degree:
return Monomial(self, tuple(m))
def __split_token(token: str) -> list:
found = False
results = []
for i in range(len(token)):
try:
if token[i] == '/' and \
parse_type(token[:i]) is TokenType.number and \
parse_type(token[i + 1:]) is TokenType.number:
results.append(Token(
item=Monomial(Variables(''),
Numbers(int(token[:i]),
int(token[i + 1:])),
),
ttype=TokenType.monomial,
))
found = True
except InvalidTypeException:
pass
try:
if parse_type(token[:i]) is TokenType.symbol and \
parse_type(token[i:]) is TokenType.number:
results.append(Token(
item=Monomial(Variables(token[:i]),
Numbers(int(token[i:]))),
ttype=TokenType.monomial,
))
found = True
elif parse_type(token[:i]) is TokenType.number and \
parse_type(token[i:]) is TokenType.symbol:
results.append(Token(
item=Monomial(Variables(token[i:]),
Numbers(int(token[:i]))),
ttype=TokenType.monomial,
))
found = True
except InvalidTypeException:
continue
if found:
return results
results.append(Token(token))
return results
def variables(self):
"""
Creates pointers to polynomial variables
>>> R = PolynomialRing(QQ, 'xyz')
>>> x, y, z = R.variables()
>>> x**2 + y**2
x^2 + y^2
>>> R = PolynomialRing(QQ, 'x')
>>> x = R.variables()
>>> x
x
"""
from polynomial import Polynomial
from monomial import Monomial
variables = []
if self.num_vars() == 1:
return Polynomial(self, [Monomial(self, (1, ))], [1])
for i in range(len(self.var_list)):
degree = [0 for j in range(self.num_vars())]
degree[i] = 1
variables.append(
Polynomial(self, [Monomial(self, tuple(degree))], [1]))
return tuple(variables)
def createMonomials():
'''
Função que cria todos os monômios até grau 2
Os monômios são criados levando em conta o número do atributo
e o sinal de menos para indicar barrado
Ex:
Para o monômio ~X2 tem-se o vetor [-2]
Para o monômio ~X1X3 tem-se o vetor [-1, 3]
'''
for i in range(1, nAttributes + 1):
hypothesis.append(Monomial([i]))
hypothesis.append(Monomial([-i]))
for i in range(1, nAttributes):
for j in range(i + 1, nAttributes + 1):
hypothesis.append(Monomial([i, j]))
hypothesis.append(Monomial([-i, j]))
hypothesis.append(Monomial([i, -j]))
hypothesis.append(Monomial([-i, -j]))
def test_when_negative_coeff_and_power_then_return_derivative(self):
monomial = Monomial(-3, -2)
expected = Monomial(6, -3)
self.assertEqual(monomial.find_derivative(), expected)
def test_when_coeff_equals_negative_1_then_print_only_minus(self):
monomial = Monomial(-1, 5)
expected = '-x^5'
self.assertEqual(str(monomial), expected)
def test_when_coeff_equals_0_then_return_empty_string(self):
monomial = Monomial(0, 5)
expected = ''
self.assertEqual(str(monomial), expected)
def test_when_power_is_one_then_print_only_x(self):
monomial = Monomial(5, 1)
expected = '5x'
self.assertEqual(str(monomial), expected)
def test_derivative(self):
dev = Monomial(10, 1, 'x')
self.assertEqual(self.mon_1.derivative(), dev)
self.assertNotEqual(self.mon_2.derivative(), dev)
def test_eq(self):
self.assertFalse(self.mon_1 == self.mon_2)
self.assertTrue(self.mon_1 == Monomial(5, 2, 'x'))
def test_create_polynomial(self):
polynomial = Polynomial('5x^2-x-7')
expected_monomials = [Monomial(5, 2), Monomial(-1, 1), Monomial(-7, 0)]
self.assertEqual(polynomial.get_polynomial(), expected_monomials)
def test_when_power_equals_zero_then_return_empty_monomial(self):
monomial = Monomial(5, 0)
expected = Monomial(0, 0)
self.assertEqual(monomial.find_derivative(), expected)
def test_when_coeff_is_less_than_negative_one_then_print_it(self):
monomial = Monomial(-5, 10)
expected = '-5x^10'
self.assertEqual(str(monomial), expected)
def test_when_power_is_less_than_zero_then_print_it(self):
monomial = Monomial(5, -5)
expected = '5x^-5'
self.assertEqual(str(monomial), expected)
def test_when_power_is_greater_than_one_then_print_it(self):
monomial = Monomial(5, 5)
expected = '5x^5'
self.assertEqual(str(monomial), expected)
def test_when_coeff_equals_1_then_dont_print_it(self):
monomial = Monomial(1, 5)
expected = 'x^5'
self.assertEqual(str(monomial), expected)
def setUp(self):
self.mon_1 = Monomial(5, 2, 'x')
self.mon_2 = Monomial(3, 4, 'x')
print(Monomial(91, 5))
test_monomial_string_representation()
print('This program allows to perform basic arithmetic with two')
print('monomials, assuming that conditions are complied.')
print('')
print('*** MONOMIAL 1 ***')
print('Write the coefficient 1: ', end='')
c1 = float(input())
print('Write the exponent 1: ', end='')
e1 = int(input())
print('')
M1 = Monomial(c1, e1)
print('*** MONOMIAL 2 ***')
print('Write the coefficient 2: ', end='')
c2 = float(input())
print('Write the exponent 2: ', end='')
e2 = int(input())
print('')
M2 = Monomial(c2, e2)
monomial_sum = None
monomial_difference = None
monomial_product = None
monomial_quotient = None
# Monomial addition: M1 + M2
def test_add(self):
mon_3 = Monomial(12, 2, 'x')
self.assertEqual(str(self.mon_1 + mon_3), "17*x^2")
def test_monomial_string_representation():
"""Prints monomials to test __str__ method."""
print(Monomial(0, 0))
print(Monomial(0, 1))
print(Monomial(0, 5))
print(Monomial(1, 0))
print(Monomial(1, 1))
print(Monomial(1, 5))
print(Monomial(7.5, 0))
print(Monomial(7.5, 1))
print(Monomial(7.5, 5))
print(Monomial(-0, 0))
print(Monomial(-0, 1))
print(Monomial(-0, 5))
print(Monomial(-1, 0))
print(Monomial(-1, 1))
print(Monomial(-1, 5))
print(Monomial(-7.5, 0))
print(Monomial(-7.5, 1))
print(Monomial(-7.5, 5))
print(Monomial(91, 0))
print(Monomial(91, 1))
print(Monomial(91, 5))
def test_hash(self):
self.assertEqual(self.mon_1.__hash__(), Monomial(5, 2, 'x').__hash__())
self.assertNotEqual(self.mon_1.__hash__(), self.mon_2.__hash__())
def test_when_coeff_is_greater_than_one_then_print_it(self):
monomial = Monomial(5, 10)
expected = '5x^10'
self.assertEqual(str(monomial), expected)
def test_when_positive_coeff_and_power_then_return_derivative(self):
monomial = Monomial(3, 2)
expected = Monomial(6, 1)
self.assertEqual(monomial.find_derivative(), expected)
def test_when_power_is_zero_then_print_only_coeff(self):
monomial = Monomial(5, 0)
expected = '5'
self.assertEqual(str(monomial), expected)
