Ticket #6111: 6111-expression-referee.patch

File 6111-expression-referee.patch, 7.2 KB (added by robertwb, 10 years ago)
  • sage/symbolic/expression.pyx

    # HG changeset patch
    # User Robert Bradshaw <robertwb@math.washington.edu>
    # Date 1242959643 25200
    # Node ID 72f3a4e2180d3e2f10a02b8d7a9f45a413d9ee22
    # Parent  c9e8cd4071ea2c6a9d798969aee539f1eb1ef78b
    Pynac symbolics referee
    
    diff -r c9e8cd4071ea -r 72f3a4e2180d sage/symbolic/expression.pyx
    a b  
    198198        if not is_a_numeric(self._gobj):
    199199            raise TypeError, "self must be a numeric expression"
    200200        return py_object_from_numeric(self._gobj)
    201        
     201
     202    def __init__(self, SR, x=0):
     203        """
     204        Nearly all expressions are created by calling new_Expression_from_*,
     205        but we need to make sure this at least doesn't leave self._gobj
     206        uninitalized and segfault.
     207
     208        TESTS::
     209
     210            sage: sage.symbolic.expression.Expression(SR)
     211            0
     212            sage: sage.symbolic.expression.Expression(SR, 5)
     213            5
     214        """
     215        cdef GEx exp
     216        GEx_construct_pyobject(exp, x)
     217        GEx_construct_ex(&self._gobj, exp)
     218        self._parent = SR
     219
    202220    def __dealloc__(self):
    203221        """
    204222        Delete memory occupied by this expression.
     
    592610            3
    593611        """
    594612        try:
    595             return int(repr(self))
     613            return int(self.pyobject())
    596614        except (ValueError, TypeError):
    597615            #FIXME:  This should be fixed so that it does something
    598616            #smarter to handle the log(8)/log(2) case
     
    14391457            sage: SR(0).is_unit()
    14401458            False
    14411459        """
    1442         if self.__nonzero__():
     1460        if not not self:
    14431461            return True
    14441462        if self == 0:
    14451463            return False
     
    14841502            ...
    14851503            TypeError: incompatible relations
    14861504
     1505            sage: (x < 1) + (y <= 2)
     1506            x + y < 3
     1507
    14871508            sage: x + oo
    14881509            +Infinity
    14891510            sage: x - oo
     
    15321553        """
    15331554        cdef GEx x
    15341555        cdef Expression _right = <Expression>right
     1556        cdef operators op
    15351557        if is_a_relational(left._gobj):
    15361558            if is_a_relational(_right._gobj):
    1537                 if relational_operator(left._gobj) != relational_operator(_right._gobj):
    1538                     raise TypeError, "incompatible relations"
     1559                op = compatible_relation(relational_operator(left._gobj),
     1560                                         relational_operator(_right._gobj))
    15391561                x = relational(gadd(left._gobj.lhs(), _right._gobj.lhs()),
    15401562                               gadd(left._gobj.rhs(), _right._gobj.rhs()),
    1541                                relational_operator(left._gobj))
     1563                               op)
    15421564            else:
    15431565                x = relational(gadd(left._gobj.lhs(), _right._gobj),
    15441566                               gadd(left._gobj.rhs(), _right._gobj),
     
    15861608        cdef Expression _right = <Expression>right
    15871609        if is_a_relational(left._gobj):
    15881610            if is_a_relational(_right._gobj):
    1589                 if relational_operator(left._gobj) != relational_operator(_right._gobj):
    1590                     raise TypeError, "incompatible relations"
     1611                op = compatible_relation(relational_operator(left._gobj),
     1612                                         relational_operator(_right._gobj))
    15911613                x = relational(gsub(left._gobj.lhs(), _right._gobj.lhs()),
    15921614                               gsub(left._gobj.rhs(), _right._gobj.rhs()),
    1593                                relational_operator(left._gobj))
     1615                               op)
    15941616            else:
    15951617                x = relational(gsub(left._gobj.lhs(), _right._gobj),
    15961618                               gsub(left._gobj.rhs(), _right._gobj),
     
    16731695        cdef operators o
    16741696        if is_a_relational(left._gobj):
    16751697            if is_a_relational(_right._gobj):
    1676                 if relational_operator(left._gobj) != relational_operator(_right._gobj):
    1677                     raise TypeError, "incompatible relations"
     1698                op = compatible_relation(relational_operator(left._gobj),
     1699                                         relational_operator(_right._gobj))
    16781700                x = relational(gmul(left._gobj.lhs(), _right._gobj.lhs()),
    16791701                               gmul(left._gobj.rhs(), _right._gobj.rhs()),
    1680                                relational_operator(left._gobj))
     1702                               op)
    16811703            else:
    16821704                o = relational_operator(left._gobj)
    16831705                x = relational(gmul(left._gobj.lhs(), _right._gobj),
     
    17691791        try:
    17701792            if is_a_relational(left._gobj):
    17711793                if is_a_relational(_right._gobj):
    1772                     if relational_operator(left._gobj) != relational_operator(_right._gobj):
    1773                         raise TypeError, "incompatible relations"
     1794                    op = compatible_relation(relational_operator(left._gobj),
     1795                                             relational_operator(_right._gobj))
    17741796                    x = relational(gdiv(left._gobj.lhs(), _right._gobj.lhs()),
    17751797                                   gdiv(left._gobj.rhs(), _right._gobj.rhs()),
    1776                                    relational_operator(left._gobj))
     1798                                   op)
    17771799                else:
    17781800                    o = relational_operator(left._gobj)
    17791801                    x = relational(gdiv(left._gobj.lhs(), _right._gobj),
     
    25882610            sage: t.subs(5)
    25892611            Traceback (most recent call last):
    25902612            ...
    2591             TypeError: subs takes either a single keyword argument, or a dictionary, or a symbolic relational expression
     2613            TypeError: subs takes either a set of keyword arguments, a dictionary, or a symbolic relational expression
    25922614
    25932615            # substitutions with infinity
    25942616            sage: (x/y).subs(y=oo)
     
    26192641            if isinstance(in_dict, Expression):
    26202642                return self._subs_expr(in_dict)
    26212643            if not isinstance(in_dict, dict):
    2622                 raise TypeError, "subs takes either a single keyword argument, or a dictionary, or a symbolic relational expression"
     2644                raise TypeError, "subs takes either a set of keyword arguments, a dictionary, or a symbolic relational expression"
    26232645            sdict = in_dict
    26242646
    26252647        if kwds:
     
    59265948    m._ind = 0
    59275949    m._len  = ex._gobj.nops()
    59285950    return m
     5951
     5952
     5953cdef operators compatible_relation(operators lop, operators rop) except <operators>-1:
     5954    """
     5955    TESTS::
     5956
     5957        sage: var('a,b,x,y')
     5958        (a, b, x, y)
     5959        sage: (x < a) + (y <= b)     # indirect doctest
     5960        x + y < a + b
     5961        sage: (x >= 4) * (y > 7)
     5962        x*y > 28
     5963    """
     5964    if lop == rop:
     5965        return lop
     5966    elif lop == not_equal or rop == not_equal:
     5967        raise TypeError, "incompatible relations"
     5968    elif lop == equal:
     5969       return rop
     5970    elif rop == equal:
     5971       return lop
     5972    elif (lop in [less, less_or_equal] and rop in [less, less_or_equal]):
     5973       return less
     5974    elif (lop in [greater, greater_or_equal] and rop in [greater, greater_or_equal]):
     5975       return greater
     5976    else:
     5977        raise TypeError, "incompatible relations"