PERF: add Timestamp <-> Series comparison vbench

Author: cpcloud

pandas/tests/test_series.py

@@ -2059,42 +2059,6 @@ def check_comparators(series, other):
         check_comparators(self.ts, 5)
         check_comparators(self.ts, self.ts + 1)
 
-    def test_timestamp_compare(self):
-        # make sure we can compare Timestamps on the right AND left hand side
-        # GH4982
-        df = DataFrame({'dates': date_range('20010101', periods=10)})
-        s = df.dates.copy()
-
-        s[0] = pd.Timestamp('nat')
-        s[3] = pd.Timestamp('nat')
-
-        ops = {'lt': 'gt', 'le': 'ge', 'eq': 'eq', 'ne': 'ne'}
-
-        for left, right in ops.items():
-            left_f = getattr(operator, left)
-            right_f = getattr(operator, right)
-
-            # no nats
-            expected = left_f(df.dates, Timestamp('20010109'))
-            result = right_f(Timestamp('20010109'), df.dates)
-            tm.assert_series_equal(result, expected)
-
-            # nats
-            expected = left_f(df.dates, Timestamp('nat'))
-            result = right_f(Timestamp('nat'), df.dates)
-            tm.assert_series_equal(result, expected)
-
-            # compare to timestamp with series containing nats
-            expected = left_f(s, Timestamp('20010109'))
-            result = right_f(Timestamp('20010109'), s)
-            tm.assert_series_equal(result, expected)
-
-            # compare to nat with series containing nats
-            expected = left_f(s, Timestamp('nat'))
-            result = right_f(Timestamp('nat'), s)
-            tm.assert_series_equal(result, expected)
-
-
     def test_operators_empty_int_corner(self):
         s1 = Series([], [], dtype=np.int32)
         s2 = Series({'x': 0.})
@@ -5026,39 +4990,6 @@ def test_numpy_unique(self):
         result = np.unique(self.ts)
 
 
-def test_timestamp_compare_scalars():
-    # case where ndim == 0
-    lhs = np.datetime64(datetime(2013, 12, 6))
-    rhs = Timestamp('now')
-    nat = Timestamp('nat')
-
-    ops = {'gt': 'lt', 'lt': 'gt', 'ge': 'le', 'le': 'ge', 'eq': 'eq',
-           'ne': 'ne'}
-
-    for left, right in ops.items():
-        left_f = getattr(operator, left)
-        right_f = getattr(operator, right)
-
-        if pd._np_version_under1p7:
-            # you have to convert to timestamp for this to work with numpy
-            # scalars
-            expected = left_f(Timestamp(lhs), rhs)
-
-            # otherwise a TypeError is thrown
-            if left not in ('eq', 'ne'):
-                with tm.assertRaises(TypeError):
-                    left_f(lhs, rhs)
-        else:
-            expected = left_f(lhs, rhs)
-
-        result = right_f(rhs, lhs)
-        tm.assert_equal(result, expected)
-
-        expected = left_f(rhs, nat)
-        result = right_f(nat, rhs)
-        tm.assert_equal(result, expected)
-
-
 class TestSeriesNonUnique(unittest.TestCase):
 
     _multiprocess_can_split_ = True

pandas/tseries/tests/test_timeseries.py

@@ -3,6 +3,7 @@
 import sys
 import os
 import unittest
+import operator
 
 import nose
 
@@ -2010,6 +2011,7 @@ def test_join_self(self):
             joined = index.join(index, how=kind)
             self.assert_(index is joined)
 
+
 class TestDatetime64(unittest.TestCase):
     """
     Also test supoprt for datetime64[ns] in Series / DataFrame
@@ -2507,6 +2509,74 @@ def test_hash_equivalent(self):
         stamp = Timestamp(datetime(2011, 1, 1))
         self.assertEquals(d[stamp], 5)
 
+    def test_timestamp_compare_scalars(self):
+        # case where ndim == 0
+        lhs = np.datetime64(datetime(2013, 12, 6))
+        rhs = Timestamp('now')
+        nat = Timestamp('nat')
+
+        ops = {'gt': 'lt', 'lt': 'gt', 'ge': 'le', 'le': 'ge', 'eq': 'eq',
+            'ne': 'ne'}
+
+        for left, right in ops.items():
+            left_f = getattr(operator, left)
+            right_f = getattr(operator, right)
+
+            if pd._np_version_under1p7:
+                # you have to convert to timestamp for this to work with numpy
+                # scalars
+                expected = left_f(Timestamp(lhs), rhs)
+
+                # otherwise a TypeError is thrown
+                if left not in ('eq', 'ne'):
+                    with tm.assertRaises(TypeError):
+                        left_f(lhs, rhs)
+            else:
+                expected = left_f(lhs, rhs)
+
+            result = right_f(rhs, lhs)
+            self.assertEqual(result, expected)
+
+            expected = left_f(rhs, nat)
+            result = right_f(nat, rhs)
+            self.assertEqual(result, expected)
+
+    def test_timestamp_compare_series(self):
+        # make sure we can compare Timestamps on the right AND left hand side
+        # GH4982
+        s = Series(date_range('20010101', periods=10), name='dates')
+        s_nat = s.copy(deep=True)
+
+        s[0] = pd.Timestamp('nat')
+        s[3] = pd.Timestamp('nat')
+
+        ops = {'lt': 'gt', 'le': 'ge', 'eq': 'eq', 'ne': 'ne'}
+
+        for left, right in ops.items():
+            left_f = getattr(operator, left)
+            right_f = getattr(operator, right)
+
+            # no nats
+            expected = left_f(s, Timestamp('20010109'))
+            result = right_f(Timestamp('20010109'), s)
+            tm.assert_series_equal(result, expected)
+
+            # nats
+            expected = left_f(s, Timestamp('nat'))
+            result = right_f(Timestamp('nat'), s)
+            tm.assert_series_equal(result, expected)
+
+            # compare to timestamp with series containing nats
+            expected = left_f(s_nat, Timestamp('20010109'))
+            result = right_f(Timestamp('20010109'), s_nat)
+            tm.assert_series_equal(result, expected)
+
+            # compare to nat with series containing nats
+            expected = left_f(s_nat, Timestamp('nat'))
+            result = right_f(Timestamp('nat'), s_nat)
+            tm.assert_series_equal(result, expected)
+
+
 class TestSlicing(unittest.TestCase):
 
     def test_slice_year(self):
@@ -2775,6 +2845,7 @@ def test_frame_apply_dont_convert_datetime64(self):
 
         self.assertTrue(df.x1.dtype == 'M8[ns]')
 
+
 if __name__ == '__main__':
     nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
                    exit=False)

pandas/tslib.pyx

@@ -350,6 +350,11 @@ NaT = NaTType()
 
 iNaT = util.get_nat()
 
+
+cdef inline bint _cmp_nat_dt(_NaT lhs, _Timestamp rhs, int op) except -1:
+    return _nat_scalar_rules[op]
+
+
 cdef _tz_format(object obj, object zone):
     try:
         return obj.strftime(' %%Z, tz=%s' % zone)
@@ -464,7 +469,7 @@ _reverse_ops[Py_GT] = Py_LT
 _reverse_ops[Py_GE] = Py_LE
 
 
-cdef char* _NDIM_STRING = "ndim"
+cdef str _NDIM_STRING = "ndim"
 
 # This is PITA. Because we inherit from datetime, which has very specific
 # construction requirements, we need to do object instantiation in python
@@ -483,11 +488,11 @@ cdef class _Timestamp(datetime):
     def __richcmp__(_Timestamp self, object other, int op):
         cdef:
             _Timestamp ots
-            int ndim = getattr(other, _NDIM_STRING, -1)
+            int ndim
 
         if isinstance(other, _Timestamp):
-            if isinstance(other, NaTType):
-                return PyObject_RichCompare(other, self, _reverse_ops[op])
+            if isinstance(other, _NaT):
+                return _cmp_nat_dt(other, self, _reverse_ops[op])
             ots = other
         elif isinstance(other, datetime):
             if self.nanosecond == 0:
@@ -499,6 +504,8 @@ cdef class _Timestamp(datetime):
             except ValueError:
                 return self._compare_outside_nanorange(other, op)
         else:
+            ndim = getattr(other, _NDIM_STRING, -1)
+
             if ndim != -1:
                 if ndim == 0:
                     if isinstance(other, np.datetime64):
@@ -541,7 +548,8 @@ cdef class _Timestamp(datetime):
             elif op == Py_GE:
                 return dtval >= other
 
-    cdef void _assert_tzawareness_compat(_Timestamp self, object other):
+    cdef int _assert_tzawareness_compat(_Timestamp self,
+                                        object other) except -1:
         if self.tzinfo is None:
             if other.tzinfo is not None:
                 raise ValueError('Cannot compare tz-naive and tz-aware '
@@ -622,7 +630,8 @@ cdef class _NaT(_Timestamp):
             if isinstance(other, np.datetime64):
                 other = Timestamp(other)
             else:
-                raise TypeError("asdf")
+                raise TypeError('Cannot compare type %r with type %r' %
+                                (type(self).__name__, type(other).__name__))
         return PyObject_RichCompare(other, self, _reverse_ops[op])
 
 

vb_suite/binary_ops.py

@@ -102,3 +102,15 @@
 frame_multi_and_no_ne = \
     Benchmark("df[(df>0) & (df2>0)]", setup, name='frame_multi_and_no_ne',cleanup="expr.set_use_numexpr(True)",
               start_date=datetime(2013, 2, 26))
+
+setup = common_setup + """
+N = 1000000
+halfway = N // 2 - 1
+s  = Series(date_range('20010101', periods=N, freq='D'))
+ts = s[halfway]
+"""
+
+timestamp_series_compare = Benchmark("ts >= s", setup,
+                                     start_date=datetime(2013, 9, 27))
+series_timestamp_compare = Benchmark("s <= ts", setup,
+                                     start_date=datetime(2012, 2, 21))