Index: Objects/complexobject.c
===================================================================
--- Objects/complexobject.c	(revision 78325)
+++ Objects/complexobject.c	(working copy)
@@ -625,10 +625,8 @@
 	TO_COMPLEX(w, j);
 
 	if (op != Py_EQ && op != Py_NE) {
-		/* XXX Should eventually return NotImplemented */
-		PyErr_SetString(PyExc_TypeError,
-			"no ordering relation is defined for complex numbers");
-		return NULL;
+		Py_INCREF(Py_NotImplemented);
+		return Py_NotImplemented;
 	}
 
 	if ((i.real == j.real && i.imag == j.imag) == (op == Py_EQ))
Index: Doc/library/stdtypes.rst
===================================================================
--- Doc/library/stdtypes.rst	(revision 78325)
+++ Doc/library/stdtypes.rst	(working copy)
@@ -168,8 +168,9 @@
 Furthermore, some types (for example, function objects) support only a degenerate
 notion of comparison where any two objects of that type are unequal.  The ``<``,
 ``<=``, ``>`` and ``>=`` operators will raise a :exc:`TypeError` exception when
-any operand is a complex number, the objects are of different types that cannot
-be compared, or other cases where there is no defined ordering.
+comparing a complex number with another built-in numeric type, when the objects
+are of different types that cannot be compared, or in other cases where there is
+no defined ordering.
 
 .. index::
    single: __eq__() (instance method)
Index: Lib/test/test_complex.py
===================================================================
--- Lib/test/test_complex.py	(revision 78325)
+++ Lib/test/test_complex.py	(working copy)
@@ -3,6 +3,7 @@
 
 from random import random
 from math import atan2, isnan, copysign
+import operator
 
 INF = float("inf")
 NAN = float("nan")
@@ -110,15 +111,23 @@
 
     def test_richcompare(self):
         self.assertRaises(OverflowError, complex.__eq__, 1+1j, 1<<10000)
-        self.assertEqual(complex.__lt__(1+1j, None), NotImplemented)
+        self.assertIs(complex.__lt__(1+1j, None), NotImplemented)
         self.assertIs(complex.__eq__(1+1j, 1+1j), True)
         self.assertIs(complex.__eq__(1+1j, 2+2j), False)
         self.assertIs(complex.__ne__(1+1j, 1+1j), False)
         self.assertIs(complex.__ne__(1+1j, 2+2j), True)
-        self.assertRaises(TypeError, complex.__lt__, 1+1j, 2+2j)
-        self.assertRaises(TypeError, complex.__le__, 1+1j, 2+2j)
-        self.assertRaises(TypeError, complex.__gt__, 1+1j, 2+2j)
-        self.assertRaises(TypeError, complex.__ge__, 1+1j, 2+2j)
+        self.assertIs(complex.__lt__(1+1j, 2+2j), NotImplemented)
+        self.assertIs(complex.__le__(1+1j, 2+2j), NotImplemented)
+        self.assertIs(complex.__gt__(1+1j, 2+2j), NotImplemented)
+        self.assertIs(complex.__ge__(1+1j, 2+2j), NotImplemented)
+        self.assertRaises(TypeError, operator.lt, 1+1j, 2+2j)
+        self.assertRaises(TypeError, operator.le, 1+1j, 2+2j)
+        self.assertRaises(TypeError, operator.gt, 1+1j, 2+2j)
+        self.assertRaises(TypeError, operator.ge, 1+1j, 2+2j)
+        self.assertIs(operator.eq(1+1j, 1+1j), True)
+        self.assertIs(operator.eq(1+1j, 2+2j), False)
+        self.assertIs(operator.ne(1+1j, 1+1j), False)
+        self.assertIs(operator.ne(1+1j, 2+2j), True)
 
     def test_mod(self):
         # % is no longer supported on complex numbers