Ticket #12068: trac_12068-numer_denom_fix-fh.patch

sage/symbolic/expression.pyx

@@ -6616 +6616 @@
             ((x + 2)*x^2, 1)
             sage: g.numerator_denominator(normalize=False)
             ((x + 2)*x^2, 1)
-        """
-        cdef GExVector vecnum, vecdenom
+
+        TESTS::
+
+            sage: ((x+y)^2/(x-y)^3*x^3).numerator_denominator(normalize=False)
+            ((x + y)^2*x^3, (x - y)^3)
+            sage: ((x+y)^2*x^3).numerator_denominator(normalize=False)
+            ((x + y)^2*x^3, 1)
+            sage: (y/x^3).numerator_denominator(normalize=False)
+            (y, x^3)
+            sage: t = y/x^3/(x+y)^(1/2); t
+            y/(sqrt(x + y)*x^3)
+            sage: t.numerator_denominator(normalize=False)
+            (y, sqrt(x + y)*x^3)
+            sage: (1/x^3).numerator_denominator(normalize=False)
+            (1, x^3)
+            sage: (x^3).numerator_denominator(normalize=False)
+            (x^3, 1)
+            sage: (y*x^sin(x)).numerator_denominator(normalize=False)
+            Traceback (most recent call last):
+            ...
+            TypeError: self is not a rational expression
+        """
+        cdef GExVector vecnumer, vecdenom
         cdef GEx oper, ex, power
         cdef int py_pow
+        cdef GNumeric power_num
         if normalize:
             ex = self._gobj.numer_denom()
             return (new_Expression_from_GEx(self._parent, ex.op(0)),
@@ -6632 +6654 @@
                     power = oper.op(1)
                     if not is_a_numeric(power):
                         raise TypeError, "self is not a rational expression"
-                    else:
-                        py_pow = py_object_from_numeric(power)
-                        if py_pow >= 0:
-                            vecnum.push_back(oper)
-                        elif py_pow == -1:
-                            vecdenom.push_back(ex)
+                    elif is_a_numeric(power):
+                        power_num = ex_to_numeric(power)
+                        if power_num.is_positive():
+                            vecnumer.push_back(oper)
                         else:
                             vecdenom.push_back(g_pow(ex, g_abs(power)))
                 else:
-                    vecnum.push_back(oper)
+                    vecnumer.push_back(oper)
             return (new_Expression_from_GEx(self._parent,
-                                            g_mul_construct(vecnum, False)),
+                                            g_mul_construct(vecnumer, False)),
                     new_Expression_from_GEx(self._parent,
                                             g_mul_construct(vecdenom, False)))
+        elif is_a_power(self._gobj):
+            power = self._gobj.op(1)
+            if is_a_numeric(power) and ex_to_numeric(power).is_positive():
+                return (self, self._parent.one())
+            else:
+                return (self._parent.one(),
+                        new_Expression_from_GEx(self._parent,
+                               g_pow(self._gobj.op(0), g_abs(power))))
         else:
             return (self, self._parent.one())