Ticket #12068: trac_12068-numer_denom_ginac-folded-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 +
@@ -85 +89 @@
 
     GExPair make_pair "std::make_pair" (GEx, GEx)
 
+    ctypedef struct GNumeric "numeric":
+        bint is_positive() except +
+        bint is_negative() except +
+
     # Numericals
     bint is_a_numeric "is_a<numeric>" (GEx e)
+    GNumeric ex_to_numeric "ex_to<numeric>" (GEx e)
     # given a GEx that is known to be a numeric, return reference to
     # the underlying PyObject*.
     object py_object_from_numeric(GEx e)     except +
@@ -143 +152 @@
     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 +226 @@
     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
+            sage: (y/x^3).numerator(normalize=False)
+            y
+            sage: t = y/x^3/(x+y)^(1/2); t
+            y/(sqrt(x + y)*x^3)
+            sage: t.numerator(normalize=False)
+            y
+            sage: (1/x^3).numerator(normalize=False)
+            1
+            sage: (x^3).numerator(normalize=False)
+            x^3
+            sage: (y*x^sin(x)).numerator(normalize=False)
+            Traceback (most recent call last):
+            ...
+            TypeError: self is not a rational expression
+        """
+        cdef GExVector vec
+        cdef GEx oper, power
+        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 ex_to_numeric(power).is_positive():
+                        vec.push_back(oper)
+            return new_Expression_from_GEx(self._parent,
+                                           g_mul_construct(vec, True))
+        elif is_a_power(self._gobj):
+            power = self._gobj.op(1)
+            if is_a_numeric(power) and ex_to_numeric(power).is_negative():
+                return self._parent.one()
+        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
+            sage: (y/x^3).denominator(normalize=False)
+            x^3
+            sage: t = y/x^3/(x+y)^(1/2); t
+            y/(sqrt(x + y)*x^3)
+            sage: t.denominator(normalize=False)
+            sqrt(x + y)*x^3
+            sage: (1/x^3).denominator(normalize=False)
+            x^3
+            sage: (x^3).denominator(normalize=False)
+            1
+            sage: (y*x^sin(x)).denominator(normalize=False)
+            Traceback (most recent call last):
+            ...
+            TypeError: self is not a rational expression
+        """
+        cdef GExVector vec
+        cdef GEx oper, ex, power
+        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"
+                    elif ex_to_numeric(power).is_negative():
+                        vec.push_back(g_pow(ex, g_abs(power)))
+            return new_Expression_from_GEx(self._parent,
+                                           g_mul_construct(vec, False))
+        elif is_a_power(self._gobj):
+            power = self._gobj.op(1)
+            if is_a_numeric(power) and ex_to_numeric(power).is_negative():
+                return new_Expression_from_GEx(self._parent,
+                        g_pow(self._gobj.op(0), g_abs(power)))
+
+        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)
+
+        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)),
+                    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"
+                    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:
+                    vecnumer.push_back(oper)
+            return (new_Expression_from_GEx(self._parent,
+                                            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())
 
     def partial_fraction(self, var=None):
         r"""