initial version

Author: Sebastian Oehms

src/sage/rings/polynomial/laurent_polynomial_ring.py

@@ -706,11 +706,23 @@ def _ideal_class_(self, n=0):
         # One may eventually want ideals in these guys.
         raise NotImplementedError
 
-    def ideal(self):
+    def ideal(self, *args, **kwds):
         """
         EXAMPLES::
 
-            sage: LaurentPolynomialRing(QQ,2,'x').ideal()
+            sage: LaurentPolynomialRing(QQ,2,'x').ideal([1])
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+
+        TESTS:
+ 
+        check that trac:`26421` is fixed:
+
+            sage: R.<t> = LaurentPolynomialRing(ZZ)
+            sage: P.<x> = PolynomialRing(R)
+            sage: p = x-t
+            sage: p.content_ideal()    # indirect doctest
             Traceback (most recent call last):
             ...
             NotImplementedError

src/sage/rings/polynomial/polynomial_element.pyx

@@ -28,6 +28,9 @@ AUTHORS:
 
 -  David Zureick-Brown (2017-09): Added is_weil_polynomial.
 
+-  Sebastian Oehms (2018-10): made :meth:`roots` and  :meth:`factor` work over more 
+   cases of proper integral domains (see :trac:`26421`)
+
 TESTS::
 
     sage: R.<x> = ZZ[]
@@ -4195,6 +4198,14 @@ cdef class Polynomial(CommutativeAlgebraElement):
             sage: x2 = ZZ['x']['x'].gen()
             sage: (x1 - x2).factor()
             -x + x
+
+        Check that :trac:`26421' is fixed::
+
+            sage: R.<t> = LaurentPolynomialRing(ZZ)
+            sage: P.<x> = R[]
+            sage: p = x**3 -(t**3+t**(-3))*x**2 -t**2*x + ~t +t**5
+            sage: p.factor()
+            (t^-3) * (t^3*x - 1 - t^6) * (x - t) * (x + t)
         """
         # PERFORMANCE NOTE:
         #     In many tests with SMALL degree PARI is substantially
@@ -4341,6 +4352,16 @@ cdef class Polynomial(CommutativeAlgebraElement):
                 F.sort()
                 return F
             except (TypeError, AttributeError):
+                if R.is_integral_domain() and not R.is_field():
+                    from sage.rings.fraction_field import FractionField_generic
+                    try:
+                        F = FractionField_generic(R)
+                        PF = F[self.variable_name()]
+                        pol_frac = PF(self) 
+                        return pol_frac.factor(**kwargs).base_change(self.parent())
+                    except:
+                        pass
+                    
                 raise NotImplementedError
 
         return self._factor_pari_helper(G, n)
@@ -7605,9 +7626,19 @@ cdef class Polynomial(CommutativeAlgebraElement):
             sage: eq = x^6+x-17
             sage: eq.roots(multiplicities=False)
             [3109038, 17207405]
+
+        Check that :trac:`26421' is fixed::
+
+            sage: R.<t> = LaurentPolynomialRing(ZZ)
+            sage: P.<x> = R[]
+            sage: p = x**3 -(t**3+t**(-3))*x**2 -t**2*x + ~t +t**5
+            sage: p.roots()
+            [(t^-3 + t^3, 1), (t, 1), (-t, 1)]
         """
         from sage.rings.finite_rings.finite_field_constructor import GF
         K = self._parent.base_ring()
+
+
         # If the base ring has a method _roots_univariate_polynomial,
         # try to use it. An exception is raised if the method does not
         # handle the current parameters
@@ -7818,10 +7849,14 @@ cdef class Polynomial(CommutativeAlgebraElement):
                         # get rid of the content of self since we don't need it
                         # and we really don't want to factor it if it's a huge
                         # integer
-                        c = self.content()
+                        c = self.content_ideal().gen()
                         self = self//c
-                    except AttributeError:
-                        pass
+                    except (AttributeError, NotImplementedError):
+                        try:
+                            c = lcm(self.coefficients())
+                            self = self/c
+                        except:
+                            pass
                 return self._roots_from_factorization(self.factor(), multiplicities)
             else:
                 raise NotImplementedError
@@ -9076,7 +9111,7 @@ cdef class Polynomial(CommutativeAlgebraElement):
                 # Be careful with the content: return the
                 # radical of the content times the radical of
                 # (self/content)
-                content = self.content()
+                content = self.content_ideal().gen()
                 self_1 = (self//content)
                 return (self_1 // self_1.gcd(self_1.derivative())) * content.radical()
         else:  # The above method is not always correct (see Trac 8736)
@@ -10156,6 +10191,7 @@ cdef class Polynomial(CommutativeAlgebraElement):
             phi = SpecializationMorphism(self._parent,D)
         return phi(self)
 
+
     def _log_series(self, long n):
         r"""
         Return the power series expansion of logarithm of this polynomial,