def find_rational_roots(self): # it returns list of rational roots
for x in self.coeffs:
if len(x.expressions) == 1 and x.expressions[0].number ** x.expressions[0].degree == 1 \
and x.expressions[0].coefficient.denominator == 1:
pass
else:
raise InvalidCoefficientNumber
# d_nww = self.coeffs[0].expressions[0].coefficient.denominator
# for k in self.coeffs:
# d_nww = nww(d_nww, k.expressions[0].coefficient.denominator)
# print(d_nww)
d = int(self.coeffs[-1].expressions[0])
a = int(self.coeffs[0].expressions[0])
divs_d = divisors(d)
divs_a = divisors(a)
sols = []
for i in divs_d:
for j in divs_a:
if j != 0:
p = number.Number(str(i)) / number.Number(str(j))
if self.get_value(p) == number.Number(
"0") and p not in sols:
sols.append(p)
if len(sols) == self.get_degree_of_polynomial():
break
return sols
def delta_metod(
self,
only_solution=False
): # it solves step by step: self = 0 using the delta method,
if not self.get_degree_of_polynomial(
) == 2: # degree of polynomial must be 2
raise InvalidPolynomialDegree("delta")
step0 = str(self)
step0 = step0[step0.find("=") + 2:] + " = 0"
step1 = "a =" + str(self.coeffs[0]) + " " + "b =" + str(
self.coeffs[1]) + " " + "c =" + str(self.coeffs[2])
x_0 = "xyz"
x_1 = "xyz"
x_2 = "xyz"
delta = self.coeffs[1] * self.coeffs[1] - number.Number(
"4") * self.coeffs[0] * self.coeffs[2]
if delta.decimal(15) == 0:
step2 = '\u0394' + " = b^2 - 4ac = " + str(delta)
else:
step2 = '\u0394' + " = b^2 - 4ac =" + str(delta)
if delta.decimal(15) < 0:
step3 = "(" + '\u0394' + " < 0) ==> 0 solutions"
step4 = ""
elif delta.decimal(15) == 0:
step3 = "(" + '\u0394' + " = 0) ==> 1 solution"
x_0 = -self.coeffs[1] / number.Number("2") / self.coeffs[0]
step4 = "x_0 = -b/2a =" + str(x_0)
else:
step3 = "(" + '\u0394' + " > 0) ==> 2 solutions"
power = number.Number("1/2")
x_1 = (-self.coeffs[1] +
delta**power) / number.Number("2") / self.coeffs[0]
x_2 = (-self.coeffs[1] -
delta**power) / number.Number("2") / self.coeffs[0]
step4 = "x_1 = [-b+" + '\u0394' + "^(1/2)]/2a ="
if x_1.decimal(15) == 0:
step4 += " "
step4 += str(x_1) + "\n" + "x_2 = [-b-" + '\u0394' + "^(1/2)]/2a ="
if x_2.decimal(15) == 0:
step4 += " "
step4 += str(x_2)
if only_solution:
if isinstance(x_1, number.Number):
return [x_1, x_2]
elif isinstance(x_0, number.Number):
return [x_0]
else:
return []
else:
return [step0, step1, step2, step3, step4]
def __truediv__(self, other): # self / other; it return tuple( S(x),R(x) )
if other == Polynomial("P(x)", ["1"]):
return self, Polynomial("R(x)", [])
zero = Polynomial("Z(x)", [""])
if zero == other:
raise ZeroDivisionError()
s_x = Polynomial("S(x)", [])
a = Polynomial("A(x)", [])
b = Polynomial("B(x)", [])
for x in self.coeffs:
a.coeffs.append(x)
for x in other.coeffs:
b.coeffs.append(x)
while a.get_degree_of_polynomial() >= b.get_degree_of_polynomial():
m = a.coeffs[0] / b.coeffs[0]
n = a.get_degree_of_polynomial() - b.get_degree_of_polynomial()
poly = Polynomial("P(x)", [])
for i in range(n):
poly.coeffs.append(number.Number("0"))
poly.coeffs[0] = m
s_x += poly
a_poly = b * poly
a -= a_poly
s_x.change_name("S(" + self.name[-2] + ")")
a.change_name("R(" + self.name[-2] + ")")
res = (s_x, a)
return res
def simplify(self): # simplifying polynomial
val = 0
for x in self.coeffs:
if x.decimal(15) != 0:
val += 1
if val == 0:
self.coeffs = [number.Number("0")]
while self.coeffs[0].decimal(15) == 0 and len(self.coeffs) != 1:
self.coeffs.remove(self.coeffs[0])
def __gt__(
self, other
): # self > other; it solves inequality; return a list with intervals
poly = self - other
divs = poly.break_down_to_factor(False)
unique_d = divs[0]
result = []
if divs[2]:
for i in range(len(unique_d)):
if i == 0:
if poly.get_value(unique_d[i] + number.Number("-1")
) > number.Number("0"):
result.append("(-Inf," + str(unique_d[i]) + ")")
if i == len(unique_d) - 1:
if poly.get_value(unique_d[i] +
number.Number("1")) > number.Number("0"):
result.append("(" + str(unique_d[i]) + ", Inf)")
continue
if poly.get_value((unique_d[i] + unique_d[i + 1]) /
number.Number("2")) > number.Number("0"):
result.append("(" + str(unique_d[i]) + ", " +
str(unique_d[i + 1]) + ")")
return result, False
else:
raise InvalidRoots()
def find_integer_roots(self): # it returns list of integer roots
for x in self.coeffs:
if len(x.expressions) == 1 and x.expressions[0].number ** x.expressions[0].degree == 1 \
and x.expressions[0].coefficient.denominator == 1:
pass
else:
raise InvalidCoefficientNumber
# d_nww = self.coeffs[0].expressions[0].coefficient.denominator
# for k in self.coeffs:
# d_nww = nww(d_nww, k.expressions[0].coefficient.denominator)
# print(d_nww)
d = int(self.coeffs[-1].expressions[0])
divs = divisors(d)
sols = []
for x in divs:
if self.get_value(number.Number(str(x))) == number.Number("0"):
sols.append(number.Number(str(x)))
if len(sols) == self.get_degree_of_polynomial():
break
return sols
def __mul__(self, other): # multiplication: self * other
self.simplify()
other.simplify()
p = []
n = self.get_degree_of_polynomial() + other.get_degree_of_polynomial()
for i in range(n + 1):
p.append(number.Number("0"))
for i in range(len(self.coeffs)):
for j in range(len(other.coeffs)):
p[i + j] += self.coeffs[i] * other.coeffs[j]
result = Polynomial("Multiplied(" + self.name[-2] + ")", [""])
result.coeffs = p
return result
def __pow__(self, power): # exponentiation: self**power
result = Polynomial("Poly", [])
if power == 0:
result.coeffs.append(number.Number("1"))
result.simplify()
result.name = "RaisedTo{}Power(".format(
power) + self.name[-2] + ")"
return result
for x in self.coeffs:
result.coeffs.append(x)
for i in range(power - 1):
result *= self
result.simplify()
result.name = "RaisedTo{}Power".format(
power) + "(" + self.name[-2] + ")"
return result
def __ge__(
self, other
): # self >= other; it solves inequality; return a list with intervals
poly = self - other
divs = poly.break_down_to_factor(False)
unique_d = divs[0]
result = []
if divs[2]:
for i in range(len(unique_d)):
if i == 0:
if poly.get_value(unique_d[i] + number.Number("-1")
) >= number.Number("0"):
result.append(["-Inf", str(unique_d[i])])
else:
result.append([str(unique_d[i]), str(unique_d[i])])
if i == len(unique_d) - 1:
if poly.get_value(unique_d[i] + number.Number("1")
) >= number.Number("0"):
result.append([str(unique_d[i]), "Inf"])
else:
result.append([str(unique_d[i]), str(unique_d[i])])
continue
if poly.get_value((unique_d[i] + unique_d[i + 1]) /
number.Number("2")) >= number.Number("0"):
result.append([str(unique_d[i]), str(unique_d[i + 1])])
else:
result.append([str(unique_d[i]), str(unique_d[i])])
n = len(result)
for k in range(n):
for i in range(len(result) - 1):
if result[i][1] == result[i + 1][0]:
result[i][1] = result[i + 1][1]
del result[i + 1]
break
for i in range(len(result)):
if result[i][0] == result[i][1]:
del result[i][0]
return result, True
else:
raise InvalidRoots()
def break_down_to_factor(self,
only_resultat=True
): # it returns a polynomial broken down
roots = [] # to the lowest possible real factors
if len(self.coeffs) == 1 and self.coeffs[0] == number.Number("0"):
return self.name + " = 0"
poly = Polynomial("P(x)", [])
for x in self.coeffs:
poly.coeffs.append(x)
poly.simplify()
for x in poly.coeffs:
if len(
x.expressions
) == 1 and x.expressions[0].number**x.expressions[0].degree == 1:
pass
else:
raise InvalidCoefficientNumber
nww_d = poly.coeffs[0].expressions[0].coefficient.denominator
for x in poly.coeffs:
nww_d = nww(nww_d, x.expressions[0].coefficient.denominator)
nww_d = number.Number(str(nww_d))
for i in range(len(poly.coeffs)):
poly.coeffs[i] *= nww_d
divs = poly.find_rational_roots()
while divs:
for d in divs:
roots.append(d)
p = Polynomial("P(x)", ["1"])
p.coeffs = [number.Number("1"), -d]
poly //= p
divs = poly.find_rational_roots()
if poly.coeffs[0] == number.Number("-1"):
a = number.Number("-1") / nww_d
poly = -poly
elif poly.coeffs[0] != number.Number("1"):
a = poly.coeffs[0]
for k in poly.coeffs:
a = nwd(int(a), int(k))
a = number.Number(str(a))
for i in range(len(poly.coeffs)):
poly.coeffs[i] /= a
else:
a = number.Number("1") / nww_d
if poly.get_degree_of_polynomial() == 2:
roots += poly.delta_metod(True)
if a == number.Number("1"):
a = ""
elif a == number.Number("-1"):
a = "-"
else:
a = str(a)
result = self.name + " = " + a
unique_roots = []
for x in roots:
if x not in unique_roots:
unique_roots.append(x)
if number.Number("0") in roots:
unique_roots.remove(number.Number("0"))
unique_roots.insert(0, number.Number("0"))
unique_roots = sorted(unique_roots, reverse=True)
for x in unique_roots:
if x.decimal(15) > 0:
result += "(x" + str(-x) + ")"
elif x.decimal(15) < 0:
result += "(x +" + str(-x) + ")"
else:
result += "x"
if roots.count(x) != 1:
result += "^" + str(roots.count(x))
if poly != Polynomial("P(x)", "1"):
s = str(poly)
result += "(" + s[s.find("=") + 2:] + ")"
if only_resultat:
return result
else:
return [
sorted(unique_roots), roots,
poly.get_degree_of_polynomial() < 3
]
def __init__(self, name, coefficents):
self.name = name
self.coeffs = []
for x in coefficents:
self.coeffs.append(number.Number(x))
self.simplify()
def cardano_metod(
self
): # it solves step by step: self = 0 using Cardano's way, degree of polynomial must be 3
self.simplify()
if not self.get_degree_of_polynomial() == 3:
raise InvalidPolynomialDegree("Cardano")
poly = Polynomial("P(x)", [])
for x in self.coeffs:
poly.coeffs.append(x)
poly.simplify()
a = poly.coeffs[0]
# b = poly.coeffs[1]
# c = poly.coeffs[2]
# d = poly.coeffs[3]
step0 = str(poly)
step0 = step0[step0.find("=") + 2:] + " = 0"
step1 = " "
if a != number.Number("1"):
step1 = step0 + " / :" + str(a)
for i in range(len(poly.coeffs)):
poly.coeffs[i] /= a
s = str(poly)
s = s[s.find("=") + 2:] + " = 0"
step1 += "\n" + s
a = poly.coeffs[0]
b = poly.coeffs[1]
c = poly.coeffs[2]
d = poly.coeffs[3]
p = 1
q = 1
step2 = ""
if b != number.Number("0"):
step2 = "for x substitute (y-" + str(
b / number.Number("3")) + "):\n"
s = str(poly).replace("x",
"(y-" + str(b / number.Number("3")) + ")")
step2 += s[s.find("=") + 2:] + " = 0\n"
p = c / a - (b**2) / number.Number("3")
q = number.Number("2") * (
b**3) / number.Number("27") - b * c / number.Number("3") + d
step2 += "y^3"
if p < number.Number("0"):
step2 += str(p)
else:
step2 += " +" + str(p)
step2 += "y"
if q < number.Number("0"):
step2 += str(q)
else:
step2 += " +" + str(q)
step2 += " = 0"
elif b == number.Number("0"):
step2 = " "
p = c
q = d
delta = (p / number.Number("3"))**3 + (q / number.Number("2"))**2
if delta.decimal(15) == 0:
step3 = '\u0394' + " = (p/3)^3 + (q/2)^2 = " + str(delta)
else:
step3 = '\u0394' + " = (p/3)^3 + (q/2)^2 =" + str(delta)
if delta > number.Number("0"):
step4 = "1 real solution"
elif delta < number.Number("0"):
step4 = "2 real solution"
else:
step4 = "3 real solution"
return [step0, step1, step2, step3, step4]
