def main(): """Main function to test Poly class. """ coeff = Poly([2, 0, 4, -1, 0, 6]) coeff2 = Poly([-1, -3, 0, 4.5]) print('P_a: ', coeff, ' Order = ', Poly.order(coeff)) print('P_b: ', coeff2, ' Order = ', Poly.order(coeff2)) print('P_a + P_b: ', coeff + coeff2) print('Diff P_a: ', Poly.deriv(coeff)) print('Diff P_b: ', Poly.deriv(coeff2)) print('Integral P_a: ', Poly.anti_deriv(coeff)) print('Integral P_b: ', Poly.anti_deriv(coeff2))
def poly_reduce(f, g, *symbols): """Removes common content from a pair of polynomials. >>> from sympy import * >>> x = Symbol('x') >>> f = Poly(2930944*x**6 + 2198208*x**4 + 549552*x**2 + 45796, x) >>> g = Poly(17585664*x**5 + 8792832*x**3 + 1099104*x, x) >>> F, G = poly_reduce(f, g) >>> F Poly(64*x**6 + 48*x**4 + 12*x**2 + 1, x) >>> G Poly(384*x**5 + 192*x**3 + 24*x, x) """ if not isinstance(f, Poly): f = Poly(f, *symbols) elif symbols: raise SymbolsError("Redundant symbols were given") f, g = f.unify_with(g) fc = int(f.content) gc = int(g.content) cont = igcd(fc, gc) if cont != 1: f = f.div_term(cont) g = g.div_term(cont) return f, g
def test_derivative(self): field = FF(p=3) polyring = Poly(field=field) f = [field.uni(1) for i in range(11)] self.assertEqual(polyring.derivative(f), [field.uni(i + 1) for i in range(10)])
def right_factor(f, s): n, lc = f.degree, f.LC f = f.as_uv_dict() q = {s: S.One} r = n // s for k in xrange(1, s): coeff = S.Zero for j in xrange(0, k): if not n + j - k in f: continue if not s - j in q: continue fc, qc = f[n + j - k], q[s - j] coeff += (k - r * j) * fc * qc if coeff is not S.Zero: q[s - k] = coeff / (k * r * lc) return Poly(q, *symbols, **flags)
def test_add(self): field = FF(p=5) polyring = Poly(field=field) f = [[0], [1]] g = [[], [], [2]] self.assertEqual(polyring.add(f, g), [[], [1], [2]])
def test_gcd(self): field = FF(p=3) polyring = Poly(field=field) f = [[0], [1]] g = [[], [], [2]] self.assertEqual(polyring.gcd(f, g), f)
def test_div_mod(self): field = FF(p=3) polyring = Poly(field=field) f = [[0], [1]] g = [[], [], [2]] self.assertEqual(polyring.div_mod(g, f), ([[], [2]], []))
def poly_pdiv(f, g, *symbols): """Univariate polynomial pseudo-division with remainder. Given univariate polynomials f and g over an integral domain D[x] applying classical division algorithm to LC(g)**(d + 1) * f and g where d = max(-1, deg(f) - deg(g)), compute polynomials q and r such that LC(g)**(d + 1)*f = g*q + r and r = 0 or deg(r) < deg(g). Polynomials q and r are called the pseudo-quotient of f by g and the pseudo-remainder of f modulo g respectively. For more information on the implemented algorithm refer to: [1] M. Bronstein, Symbolic Integration I: Transcendental Functions, Second Edition, Springer-Verlang, 2005 """ if not isinstance(f, Poly): f = Poly(f, *symbols) elif symbols: raise SymbolsError("Redundant symbols were given") f, g = f.unify_with(g) if f.is_multivariate: raise MultivariatePolyError(f) symbols, flags = f.symbols, f.flags q, r = Poly((), *symbols, **flags), f coeff, N = g.LC, f.degree - g.degree + 1 while not r.is_zero: M = r.degree - g.degree if M < 0: break else: T, N = (r.LC, (M, )), N - 1 q = q.mul_term(coeff).add_term(*T) r = r.mul_term(coeff) - g.mul_term(*T) return (q.mul_term(coeff**N), r.mul_term(coeff**N))
def poly_half_gcdex(f, g, *symbols): """Half extended Euclidean algorithm. Efficiently computes gcd(f, g) and one of the coefficients in extended Euclidean algorithm. Formally, given univariate polynomials f and g over an Euclidean domain, computes s and h, such that h = gcd(f, g) and s*f = h (mod g). For more information on the implemented algorithm refer to: [1] M. Bronstein, Symbolic Integration I: Transcendental Functions, Second Edition, Springer-Verlang, 2005 """ if not isinstance(f, Poly): f = Poly(f, *symbols) elif symbols: raise SymbolsError("Redundant symbols were given") f, g = f.unify_with(g) if f.is_multivariate: raise MultivariatePolyError(f) symbols, flags = f.symbols, f.flags a = Poly(S.One, *symbols, **flags) b = Poly((), *symbols, **flags) while not g.is_zero: q, r = poly_div(f, g) f, g = g, r c = a - q * b a, b = b, c return a.div_term(f.LC), f.as_monic()
def left_factor(f, h): g, i = {}, 0 while not f.is_zero: q, r = poly_div(f, h) if not r.is_constant: return None else: if r.LC is not S.Zero: g[i] = r.LC f, i = q, i + 1 return Poly(g, *symbols, **flags)
def main(): p = Poly("-312*x^2 +13x^3") print("p =", p) print("p(10) =", p.application(10)) print("2p =", p * 2) print() q = Poly("9x^20 + 5 - 5x^3 + 1x") print("q =", q) print("-q =", -q) print("q coefficients:", q.power_series()) print() r = Poly("7 - 3*x^5 + 10*x - 5") print("r =", r) print() s = Poly("1 - 1x + 1x^2 - 1x^3 + 1x^4") print("s =", s) print() s_ = Poly( "1 - 1x + 1x^2 - 1x^3 + 1x^4 - 1x^5 + 1x^6 - 1x^7 + 1x^8 - 1x^9 + 1x^10" ) print("s_ =", s_) print() t = Poly([1, -2, 3, 4, -5, 6]) print("t =", t) print() u = Poly.optimal_fit([1, 8, 27, 64]) print("u =", u) print() print("p == q:", p == q) print("p + q =", p + q) print("p - q =", p - q) print("p * q =", p * q) print() target = Poly( "1 - 1x + 1x^2 - 1x^3 + 1x^4 - 1x^5 + 1x^6 - 1x^7 + 1x^8 - 1x^9 + 1x^10" ) print(target) print(target.derivative()) print()
def on_click(self): errormsg = "" # Message to append to in case of bad behaviour. # Ensure poly_to_factor parses correctly. p = 1 to_factor = None pivot = None try: str = self.polynomialInput.toPlainText() to_factor = parse_unbracketed(str) except: errormsg += "Error, cannot parse polynomial to factor.\n" # Ensure p pares correctly. try: p = int(self.charpInput.toPlainText()) except: errormsg += "Error, p is not a valid integer.\n" # Ensure p is prime. if not (prime(p)): errormsg += "Error, p is not prime.\n" # Ensure pivot parses correctly. try: pivot = parse_unbracketed(self.minPolyEntry.toPlainText(), as_integer=True) except: errormsg += "Error, cannot parse minimal polynomial." # Ensure pivot is irreducible. if errormsg == "": try: field = FF(p, pivot=pivot) polyring = Poly(field) msg = factorise(to_factor, polyring) self.outputDisplay.setText(msg) except: self.outputDisplay.setText( "An error occured during factoring, please try again.") else: self.outputDisplay.setText(errormsg)
def test_method_iadd_different_coeffs_num_1(self): self.pm = Poly([1, 2, 3, 4]) self.pm1 = Poly([1, 2, 3, 4, 5]) self.pm += self.pm1 self.assertEqual(self.pm.__str__(), "x^4+3x^3+5x^2+7x+9")
def test_method_iadd_single_val(self): self.pm = Poly([1]) self.pm1 = Poly("1") self.pm += self.pm1 self.assertEqual(self.pm.__str__(), "2")
def test_method_ne_list_str(self): self.pm1 = Poly("1, 2, 3, 5") self.assertTrue(self.pm1 != self.pm, "Error! Polynomials are equal")
def test_method_ne_list_tupl(self): self.pm1 = Poly((1, 2, 3, 5)) self.assertTrue(self.pm1 != self.pm, "Error! Polynomials are equal")
def test_method_ne_long_true(self): self.pm = Poly(range(100)) self.pm1 = Poly(range(100)) self.assertFalse(self.pm != self.pm1, "Error! Polynomials aren't equal")
def setUp(self): self.pm = Poly([1, 2, 3, 4]) pass
def test_method_mul_single_val(self): self.pm = Poly([1]) self.pm1 = self.pm * Poly("1") self.assertEqual(self.pm1.__str__(), "1")
def test_method_equal_list_range(self): self.pm1 = Poly(range(1,5)) self.assertTrue(self.pm1 == self.pm, "Error! Polynomials are equal")
def test_method_sub_different_coeffs_num_2(self): self.pm = Poly([1, 2, 3, 4, 5, 6]) self.pm1 = Poly("1, 2, 3, 4") self.pm2 = self.pm - self.pm1 self.assertEqual(self.pm2.__str__(), "x^5+2x^4+2x^3+2x^2+2x+2")
def test_method_sub_pm_and_float(self): self.pm = Poly([1, 2, 3, 4, 5, 6]) self.pm1 = self.pm - 2 self.assertEqual(self.pm1.__str__(), "x^5+2x^4+3x^3+4x^2+5x+4")
def test_method_str_list_float(self): self.pm = Poly([17.5, 1.3, -1.746, 8]) self.assertEqual(self.pm.__str__(), "17.5x^3+1.3x^2-1.75x+8")
def test_method_mul_pm_and_float(self): self.pm = Poly([1, 2, 3, 4, 5, 6]) self.pm1 = self.pm * 2 self.assertEqual(self.pm1.__str__(), "2x^5+4x^4+6x^3+8x^2+10x+12")
def test_method_mul_different_coeffs_num_2(self): self.pm = Poly((3, 2, 0, -1)) self.pm1 = self.pm * (-1, 0, 1) self.assertEqual(self.pm1.__str__(), "-3x^5-2x^4+3x^3+3x^2-1")
def test_method_equal_single_val(self): self.pm = Poly([1]) self.pm1 = Poly(1) self.assertTrue(self.pm == self.pm1, "Error! Polynomials aren't equal")
def test_method_equal_long_false(self): self.pm = Poly(range(100)) self.pm1 = Poly(range(101)) self.assertFalse(self.pm1 == self.pm, "Error! Polynomials are equal")
def test_method_str_single_val(self): self.pm = Poly(76543) self.assertEqual(self.pm.__str__(), "76543")
def test_method_str_tuple(self): self.pm = Poly((1, 2, 3, 4)) self.assertEqual(self.pm.__str__(), "x^3+2x^2+3x+4")
def test_method_equal_list_list(self): self.pm1 = Poly([1, 2, 3, 4]) self.assertTrue(self.pm1 == self.pm, "Error! Polynomials are equal")