Ticket #12068: trac_12068-numer_denom_ginac-fh.patch

sage/libs/ginac/decl.pxi

@@ -36 +36 @@
 
     object GSymbol_to_str "_to_PyString<symbol>"(GSymbol *s)
 
-    ctypedef struct GExPair "std::pair<ex, ex>"
+    ctypedef struct GExPair "std::pair<ex, ex>":
+        pass
     ctypedef struct GExMap "exmap":
         void insert(GExPair e)
 
@@ -69 +70 @@
         GEx subs_map "subs" (GExMap map) except +
         GEx coeff(GEx expr, int n)    except +
         GEx lcoeff(GEx expr)          except +
-        GEx tcoeff(GEx expr)          except +        
+        GEx tcoeff(GEx expr)          except +
+        GEx numer()                   except +
+        GEx denom()                   except +
+        GEx numer_denom()             except +
         int degree(GEx expr)          except +
         int ldegree(GEx expr)         except +
         GEx rhs()                     except +
@@ -143 +147 @@
     unsigned info_nonnegint     "GiNaC::info_flags::nonnegint"
     unsigned info_even          "GiNaC::info_flags::even"
     unsigned info_odd           "GiNaC::info_flags::odd"
+    unsigned info_rational_function "GiNaC::info_flags::rational_function"
 
     # Constants
     GEx g_Pi "Pi"
@@ -216 +221 @@
     bint is_a_function "is_a<function>" (GEx e)
     bint is_a_ncmul "is_a<ncmul>" (GEx e)
 
-
     # Arithmetic
     int ginac_error()
     GEx gadd "ADD_WRAP" (GEx left, GEx right) except +

sage/symbolic/expression.pyx

@@ -1867 +1867 @@
         assured that if True or False is returned (and proof is False) then 
         the answer is correct. 
 
-        INPUT::
+        INPUT:
         
            ntests -- (default 20) the number of iterations to run
            domain -- (optional) the domain from which to draw the random values
@@ -6415 +6415 @@
             ((x - 1)*x + y^2)/(x^2 - 7) + (b + c)/a + 1/(x + 1)
         """
         return self.parent()(self._maxima_().combine())
-    
-    def numerator(self):
-        """
-        Returns the numerator of this symbolic expression.  If the
-        expression is not a quotient, then this will return the
-        expression itself.
-        
-        EXAMPLES::
-        
+
+    def numerator(self, bint normalize = True):
+        """
+        Returns the numerator of this symbolic expression
+
+        INPUT:
+
+        - ``normalize`` -- (default: ``True``) a boolean.
+
+        If ``normalize`` is ``True``, the expression is first normalized to
+        have it as a fraction before getting the numerator.
+
+        If ``normalize`` is ``False``, the expression is kept and if it is not
+        a quotient, then this will return the expression itself.
+
+        EXAMPLES::
+
             sage: a, x, y = var('a,x,y')
             sage: f = x*(x-a)/((x^2 - y)*(x-a)); f
             x/(x^2 - y)
@@ -6431 +6439 @@
             x
             sage: f.denominator()
             x^2 - y
+            sage: f.numerator(normalize=False)
+            x
+            sage: f.denominator(normalize=False)
+            x^2 - y
 
             sage: y = var('y')
             sage: g = x + y/(x + 2); g
             x + y/(x + 2)
             sage: g.numerator()
+            x^2 + 2*x + y
+            sage: g.denominator()
+            x + 2
+            sage: g.numerator(normalize=False)
             x + y/(x + 2)
-            sage: g.denominator()
+            sage: g.denominator(normalize=False)
             1
 
-        """
-        return self.parent()(self._maxima_().num())
-
-    def denominator(self):
-        """
-        Returns the denominator of this symbolic expression.  If the
-        expression is not a quotient, then this will just return 1.
-        
-        EXAMPLES::
-        
+        TESTS::
+
+            sage: ((x+y)^2/(x-y)^3*x^3).numerator(normalize=False)
+            (x + y)^2*x^3
+            sage: ((x+y)^2*x^3).numerator(normalize=False)
+            (x + y)^2*x^3
+        """
+        cdef GExVector vec
+        cdef GEx oper, power
+        cdef int py_pow
+        if normalize:
+            return new_Expression_from_GEx(self._parent, self._gobj.numer())
+        elif is_a_mul(self._gobj):
+            for i from 0 <= i < self._gobj.nops():
+                oper = self._gobj.op(i)
+                if not is_a_power(oper):
+                    vec.push_back(oper)
+                else:
+                    power = oper.op(1)
+                    if not is_a_numeric(power):
+                        raise TypeError, "self is not a rational expression"
+                    elif py_object_from_numeric(power) >= 0:
+                        vec.push_back(oper)
+            return new_Expression_from_GEx(self._parent,
+                                           g_mul_construct(vec, True))
+        else:
+            return self
+
+    def denominator(self, bint normalize=True):
+        """
+        Returns the denominator of this symbolic expression
+
+        INPUT:
+
+        - ``normalize`` -- (default: ``True``) a boolean.
+
+        If ``normalize`` is ``True``, the expression is first normalized to
+        have it as a fraction before getting the denominator.
+
+        If ``normalize`` is ``False``, the expression is kept and if it is not
+        a quotient, then this will just return 1.
+
+        EXAMPLES::
+
             sage: x, y, z, theta = var('x, y, z, theta')
             sage: f = (sqrt(x) + sqrt(y) + sqrt(z))/(x^10 - y^10 - sqrt(theta))
+            sage: f.numerator()
+            sqrt(x) + sqrt(y) + sqrt(z)
             sage: f.denominator()
+            -sqrt(theta) + x^10 - y^10
+
+            sage: f.numerator(normalize=False)
+            -(sqrt(x) + sqrt(y) + sqrt(z))
+            sage: f.denominator(normalize=False)
             sqrt(theta) - x^10 + y^10
 
             sage: y = var('y')
             sage: g = x + y/(x + 2); g
             x + y/(x + 2)
-            sage: g.numerator()
+            sage: g.numerator(normalize=False)
             x + y/(x + 2)
-            sage: g.denominator()
+            sage: g.denominator(normalize=False)
             1
-        """
-        return self.parent()(self._maxima_().denom())
+
+        TESTS::
+
+            sage: ((x+y)^2/(x-y)^3*x^3).denominator(normalize=False)
+            (x - y)^3
+            sage: ((x+y)^2*x^3).denominator(normalize=False)
+            1
+
+        """
+        cdef GExVector vec
+        cdef GEx oper, ex, power
+        cdef int py_pow
+        if normalize:
+            return new_Expression_from_GEx(self._parent, self._gobj.denom())
+        elif is_a_mul(self._gobj):
+            for i from 0 <= i < self._gobj.nops():
+                oper = self._gobj.op(i)
+                if is_a_power(oper):
+                    ex = oper.op(0)
+                    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 == -1:
+                            vec.push_back(ex)
+                        elif py_pow < 0:
+                            vec.push_back(g_pow(ex, g_abs(power)))
+            return new_Expression_from_GEx(self._parent,
+                                           g_mul_construct(vec, False))
+        else:
+            return self._parent.one()
+
+    def numerator_denominator(self, bint normalize=True):
+        """
+        Returns the numerator and the denominator of this symbolic expression
+
+        INPUT:
+
+        - ``normalize`` -- (default: ``True``) a boolean.
+
+        If ``normalize`` is ``True``, the expression is first normalized to
+        have it as a fraction before getting the numerator and denominator.
+
+        If ``normalize`` is ``False``, the expression is kept and if it is not
+        a quotient, then this will return the expression itself together with
+        1.
+
+        EXAMPLE::
+
+            sage: x, y, a = var("x y a")
+            sage: ((x+y)^2/(x-y)^3*x^3).numerator_denominator()
+            ((x + y)^2*x^3, (x - y)^3)
+
+            sage: ((x+y)^2/(x-y)^3*x^3).numerator_denominator(False)
+            ((x + y)^2*x^3, (x - y)^3)
+
+            sage: g = x + y/(x + 2)
+            sage: g.numerator_denominator()
+            (x^2 + 2*x + y, x + 2)
+            sage: g.numerator_denominator(normalize=False)
+            (x + y/(x + 2), 1)
+
+            sage: g = x^2*(x + 2)
+            sage: g.numerator_denominator()
+            ((x + 2)*x^2, 1)
+            sage: g.numerator_denominator(normalize=False)
+            ((x + 2)*x^2, 1)
+        """
+        cdef GExVector vecnum, vecdenom
+        cdef GEx oper, ex, power
+        cdef int py_pow
+        if normalize:
+            ex = self._gobj.numer_denom()
+            return (new_Expression_from_GEx(self._parent, ex.op(0)),
+                    new_Expression_from_GEx(self._parent, ex.op(1)))
+        elif is_a_mul(self._gobj):
+            for i from 0 <= i < self._gobj.nops():
+                oper = self._gobj.op(i)
+                if is_a_power(oper):   # oper = ex^power
+                    ex = oper.op(0)
+                    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)
+                        else:
+                            vecdenom.push_back(g_pow(ex, g_abs(power)))
+                else:
+                    vecnum.push_back(oper)
+            return (new_Expression_from_GEx(self._parent,
+                                            g_mul_construct(vecnum, False)),
+                    new_Expression_from_GEx(self._parent,
+                                            g_mul_construct(vecdenom, False)))
+        else:
+            return (self, self._parent.one())
 
     def partial_fraction(self, var=None):
         r"""