Ticket #11309: trac_11309-equate-flipped-comparisons.patch

File trac_11309-equate-flipped-comparisons.patch, 4.4 KB (added by kini, 7 years ago)

apply to $SAGE_ROOT/devel/sage

  • sage/symbolic/expression.pyx

    # HG changeset patch
    # User Keshav Kini <keshav.kini@gmail.com>
    # Date 1337021296 -28800
    # Node ID 88cb27f05332abb16feaebad100a9a29f711e319
    # Parent  b25b68b18bc3c9a7b0a7aa4caa105cb40cd965e0
    Equate flipped comparisons: (x>y)==(y<x)
    
    diff --git a/sage/symbolic/expression.pyx b/sage/symbolic/expression.pyx
    a b  
    11801180
    11811181            sage: (-x + y < 0) in [x - y < 0]
    11821182            False
     1183            sage: (x - 1 < 0) in [x - 2 < 0]
     1184            False
    11831185            sage: Set([-x + y < 0, x - y < 0])
    11841186            {-x + y < 0, x - y < 0}
    11851187            sage: (x < y) == (x > y)
     
    11871189            sage: (x < 0) < (x < 1)
    11881190            False
    11891191            sage: (x < y) != (y > x)
     1192            False
     1193            sage: (x >= y) == (y <= x)
    11901194            True
     1195            sage: (x > y) == (y <= x)
     1196            False
    11911197            sage: (x < x) == (x < x)
    11921198            True
    11931199            sage: (y > y) != (y > y)
    11941200            False
    11951201            sage: (x < y) != x
    11961202            True
     1203            sage: (x == y) == (y == x)
     1204            True
     1205            sage: (x != y) != (y != x)
     1206            False
     1207            sage: (x == y) != (x != y)
     1208            True
     1209            sage: (x == y) == (y != x)
     1210            False
    11971211            sage: x == (x == x)
    11981212            False
    11991213        """
     
    12051219        l = left
    12061220        r = right
    12071221
    1208         # resolve relation immediately if lhs or rhs is already a relation
     1222        # If lhs or rhs is a relation, resolve the big relation
     1223        # immediately UNLESS the lhs and rhs are flipped versions of
     1224        # the same relation.
    12091225        if is_a_relational(l._gobj):
     1226            if (op != Py_EQ and op != Py_NE):
     1227                # relations aren't <, >, <=, or >= to other things
     1228                return False
    12101229            if is_a_relational(r._gobj):
     1230                # both lhs and rhs are relations, so we can get to work
    12111231                if l.operator() == r.operator():
    1212                     e2 = ( l._gobj.lhs().is_equal(r._gobj.lhs()) and
    1213                           l._gobj.rhs().is_equal(r._gobj.rhs()) )
     1232                    e2 = ( # case: (x _ y) ?= (x _ y)
     1233                           ( l._gobj.lhs().is_equal(r._gobj.lhs()) and
     1234                             l._gobj.rhs().is_equal(r._gobj.rhs()) ) or
     1235
     1236                           # case: (x == y) ?= (y == x)
     1237                           #       (x != y) ?= (y != x)
     1238                           ( ( l.operator() == operator.eq or
     1239                               l.operator() == operator.ne ) and
     1240                             l._gobj.lhs().is_equal(r._gobj.rhs()) and
     1241                             l._gobj.rhs().is_equal(r._gobj.lhs()) ))
    12141242                else:
    1215                     e2 = False          # l and r are different relations
     1243                    e2 = ( # case: (x < y)  ?= (y > x)  (or vice versa)
     1244                           #       (x <= y) ?= (y >= x) (or vice versa)
     1245                           ( ( l.operator() == operator.lt and
     1246                               r.operator() == operator.gt ) or
     1247                             ( l.operator() == operator.gt and
     1248                               r.operator() == operator.lt ) or
     1249                             ( l.operator() == operator.le and
     1250                               r.operator() == operator.ge ) or
     1251                             ( l.operator() == operator.ge and
     1252                               r.operator() == operator.le ) ) and
     1253                           l._gobj.lhs().is_equal(r._gobj.rhs()) and
     1254                           l._gobj.rhs().is_equal(r._gobj.lhs()) )
     1255
    12161256            else:
    12171257                e2 = False              # l is relational but r isn't.
    12181258
    12191259            if op == Py_EQ:
    12201260                return e2
    1221             elif op == Py_NE:
     1261            else:                       # op == Py_NE, checked earlier.
    12221262                return not e2
    1223             else:
    1224                 return False
     1263
    12251264        elif is_a_relational(r._gobj):  # l isn't relational but r is.
    1226             if op == Py_EQ:
    1227                 return False
    1228             elif op == Py_NE:
    1229                 return True
    1230             else:
    1231                 return False
     1265            # things aren't <, >, <=, >=, or == to relations; they
     1266            # are, however, != to relations
     1267            return op == Py_NE
    12321268
    12331269        # neither was relational, so we can create a symbolic relation
    12341270        cdef GEx e