Clean-up inference/miscellaneous benchmarks

Author: jorisvandenbossche

asv_bench/benchmarks/algorithms.py

@@ -23,6 +23,10 @@ def setup(self):
         self.arrneg = np.arange(-1000000, 0)
         self.arrmixed = np.array([1, -1]).repeat(500000)
 
+        # match
+        self.uniques = tm.makeStringIndex(1000).values
+        self.all = self.uniques.repeat(10)
+
     def time_factorize_int(self):
         self.int.factorize()
 
@@ -55,3 +59,7 @@ def time_add_overflow_neg_arr(self):
 
     def time_add_overflow_mixed_arr(self):
         self.checked_add(self.arr, self.arrmixed)
+
+    def time_match_strings(self):
+        pd.match(self.all, self.uniques)
+

asv_bench/benchmarks/attrs_caching.py

@@ -1,4 +1,5 @@
 from .pandas_vb_common import *
+from pandas.util.decorators import cache_readonly
 
 
 class DataFrameAttributes(object):
@@ -13,3 +14,19 @@ def time_get_index(self):
 
     def time_set_index(self):
         self.df.index = self.cur_index
+
+
+class CacheReadonly(object):
+    goal_time = 0.2
+
+    def setup(self):
+
+        class Foo:
+
+            @cache_readonly
+            def prop(self):
+                return 5
+        self.obj = Foo()
+
+    def time_cache_readonly(self):
+        self.obj.prop

asv_bench/benchmarks/inference.py

@@ -2,143 +2,76 @@
 import pandas as pd
 
 
-class dtype_infer_datetime64(object):
+class DtypeInfer(object):
     goal_time = 0.2
 
-    def setup(self):
-        self.N = 500000
-        self.df_int64 = DataFrame(dict(A=np.arange(self.N, dtype='int64'), B=np.arange(self.N, dtype='int64')))
-        self.df_int32 = DataFrame(dict(A=np.arange(self.N, dtype='int32'), B=np.arange(self.N, dtype='int32')))
-        self.df_uint32 = DataFrame(dict(A=np.arange(self.N, dtype='uint32'), B=np.arange(self.N, dtype='uint32')))
-        self.df_float64 = DataFrame(dict(A=np.arange(self.N, dtype='float64'), B=np.arange(self.N, dtype='float64')))
-        self.df_float32 = DataFrame(dict(A=np.arange(self.N, dtype='float32'), B=np.arange(self.N, dtype='float32')))
-        self.df_datetime64 = DataFrame(dict(A=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms'), B=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms')))
-        self.df_timedelta64 = DataFrame(dict(A=(self.df_datetime64['A'] - self.df_datetime64['B']), B=self.df_datetime64['B']))
-
-    def time_dtype_infer_datetime64(self):
-        (self.df_datetime64['A'] - self.df_datetime64['B'])
-
-
-class dtype_infer_float32(object):
-    goal_time = 0.2
+    # from GH 7332
 
     def setup(self):
         self.N = 500000
-        self.df_int64 = DataFrame(dict(A=np.arange(self.N, dtype='int64'), B=np.arange(self.N, dtype='int64')))
-        self.df_int32 = DataFrame(dict(A=np.arange(self.N, dtype='int32'), B=np.arange(self.N, dtype='int32')))
-        self.df_uint32 = DataFrame(dict(A=np.arange(self.N, dtype='uint32'), B=np.arange(self.N, dtype='uint32')))
-        self.df_float64 = DataFrame(dict(A=np.arange(self.N, dtype='float64'), B=np.arange(self.N, dtype='float64')))
-        self.df_float32 = DataFrame(dict(A=np.arange(self.N, dtype='float32'), B=np.arange(self.N, dtype='float32')))
-        self.df_datetime64 = DataFrame(dict(A=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms'), B=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms')))
-        self.df_timedelta64 = DataFrame(dict(A=(self.df_datetime64['A'] - self.df_datetime64['B']), B=self.df_datetime64['B']))
-
-    def time_dtype_infer_float32(self):
-        (self.df_float32['A'] + self.df_float32['B'])
+        self.df_int64 = DataFrame(dict(A=np.arange(self.N, dtype='int64'),
+                                       B=np.arange(self.N, dtype='int64')))
+        self.df_int32 = DataFrame(dict(A=np.arange(self.N, dtype='int32'),
+                                       B=np.arange(self.N, dtype='int32')))
+        self.df_uint32 = DataFrame(dict(A=np.arange(self.N, dtype='uint32'),
+                                        B=np.arange(self.N, dtype='uint32')))
+        self.df_float64 = DataFrame(dict(A=np.arange(self.N, dtype='float64'),
+                                         B=np.arange(self.N, dtype='float64')))
+        self.df_float32 = DataFrame(dict(A=np.arange(self.N, dtype='float32'),
+                                         B=np.arange(self.N, dtype='float32')))
+        self.df_datetime64 = DataFrame(dict(A=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms'),
+                                            B=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms')))
+        self.df_timedelta64 = DataFrame(dict(A=(self.df_datetime64['A'] - self.df_datetime64['B']),
+                                             B=self.df_datetime64['B']))
+
+    def time_int64(self):
+        (self.df_int64['A'] + self.df_int64['B'])
 
+    def time_int32(self):
+        (self.df_int32['A'] + self.df_int32['B'])
 
-class dtype_infer_float64(object):
-    goal_time = 0.2
+    def time_uint32(self):
+        (self.df_uint32['A'] + self.df_uint32['B'])
 
-    def setup(self):
-        self.N = 500000
-        self.df_int64 = DataFrame(dict(A=np.arange(self.N, dtype='int64'), B=np.arange(self.N, dtype='int64')))
-        self.df_int32 = DataFrame(dict(A=np.arange(self.N, dtype='int32'), B=np.arange(self.N, dtype='int32')))
-        self.df_uint32 = DataFrame(dict(A=np.arange(self.N, dtype='uint32'), B=np.arange(self.N, dtype='uint32')))
-        self.df_float64 = DataFrame(dict(A=np.arange(self.N, dtype='float64'), B=np.arange(self.N, dtype='float64')))
-        self.df_float32 = DataFrame(dict(A=np.arange(self.N, dtype='float32'), B=np.arange(self.N, dtype='float32')))
-        self.df_datetime64 = DataFrame(dict(A=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms'), B=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms')))
-        self.df_timedelta64 = DataFrame(dict(A=(self.df_datetime64['A'] - self.df_datetime64['B']), B=self.df_datetime64['B']))
-
-    def time_dtype_infer_float64(self):
+    def time_float64(self):
         (self.df_float64['A'] + self.df_float64['B'])
 
+    def time_float32(self):
+        (self.df_float32['A'] + self.df_float32['B'])
 
-class dtype_infer_int32(object):
-    goal_time = 0.2
-
-    def setup(self):
-        self.N = 500000
-        self.df_int64 = DataFrame(dict(A=np.arange(self.N, dtype='int64'), B=np.arange(self.N, dtype='int64')))
-        self.df_int32 = DataFrame(dict(A=np.arange(self.N, dtype='int32'), B=np.arange(self.N, dtype='int32')))
-        self.df_uint32 = DataFrame(dict(A=np.arange(self.N, dtype='uint32'), B=np.arange(self.N, dtype='uint32')))
-        self.df_float64 = DataFrame(dict(A=np.arange(self.N, dtype='float64'), B=np.arange(self.N, dtype='float64')))
-        self.df_float32 = DataFrame(dict(A=np.arange(self.N, dtype='float32'), B=np.arange(self.N, dtype='float32')))
-        self.df_datetime64 = DataFrame(dict(A=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms'), B=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms')))
-        self.df_timedelta64 = DataFrame(dict(A=(self.df_datetime64['A'] - self.df_datetime64['B']), B=self.df_datetime64['B']))
-
-    def time_dtype_infer_int32(self):
-        (self.df_int32['A'] + self.df_int32['B'])
-
+    def time_datetime64(self):
+        (self.df_datetime64['A'] - self.df_datetime64['B'])
 
-class dtype_infer_int64(object):
-    goal_time = 0.2
+    def time_timedelta64_1(self):
+        (self.df_timedelta64['A'] + self.df_timedelta64['B'])
 
-    def setup(self):
-        self.N = 500000
-        self.df_int64 = DataFrame(dict(A=np.arange(self.N, dtype='int64'), B=np.arange(self.N, dtype='int64')))
-        self.df_int32 = DataFrame(dict(A=np.arange(self.N, dtype='int32'), B=np.arange(self.N, dtype='int32')))
-        self.df_uint32 = DataFrame(dict(A=np.arange(self.N, dtype='uint32'), B=np.arange(self.N, dtype='uint32')))
-        self.df_float64 = DataFrame(dict(A=np.arange(self.N, dtype='float64'), B=np.arange(self.N, dtype='float64')))
-        self.df_float32 = DataFrame(dict(A=np.arange(self.N, dtype='float32'), B=np.arange(self.N, dtype='float32')))
-        self.df_datetime64 = DataFrame(dict(A=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms'), B=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms')))
-        self.df_timedelta64 = DataFrame(dict(A=(self.df_datetime64['A'] - self.df_datetime64['B']), B=self.df_datetime64['B']))
-
-    def time_dtype_infer_int64(self):
-        (self.df_int64['A'] + self.df_int64['B'])
+    def time_timedelta64_2(self):
+        (self.df_timedelta64['A'] + self.df_timedelta64['A'])
 
 
-class dtype_infer_timedelta64_1(object):
+class to_numeric(object):
     goal_time = 0.2
 
     def setup(self):
-        self.N = 500000
-        self.df_int64 = DataFrame(dict(A=np.arange(self.N, dtype='int64'), B=np.arange(self.N, dtype='int64')))
-        self.df_int32 = DataFrame(dict(A=np.arange(self.N, dtype='int32'), B=np.arange(self.N, dtype='int32')))
-        self.df_uint32 = DataFrame(dict(A=np.arange(self.N, dtype='uint32'), B=np.arange(self.N, dtype='uint32')))
-        self.df_float64 = DataFrame(dict(A=np.arange(self.N, dtype='float64'), B=np.arange(self.N, dtype='float64')))
-        self.df_float32 = DataFrame(dict(A=np.arange(self.N, dtype='float32'), B=np.arange(self.N, dtype='float32')))
-        self.df_datetime64 = DataFrame(dict(A=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms'), B=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms')))
-        self.df_timedelta64 = DataFrame(dict(A=(self.df_datetime64['A'] - self.df_datetime64['B']), B=self.df_datetime64['B']))
-
-    def time_dtype_infer_timedelta64_1(self):
-        (self.df_timedelta64['A'] + self.df_timedelta64['B'])
-
+        self.n = 10000
+        self.float = Series(np.random.randn(self.n * 100))
+        self.numstr = self.float.astype('str')
+        self.str = Series(tm.makeStringIndex(self.n))
 
-class dtype_infer_timedelta64_2(object):
-    goal_time = 0.2
-
-    def setup(self):
-        self.N = 500000
-        self.df_int64 = DataFrame(dict(A=np.arange(self.N, dtype='int64'), B=np.arange(self.N, dtype='int64')))
-        self.df_int32 = DataFrame(dict(A=np.arange(self.N, dtype='int32'), B=np.arange(self.N, dtype='int32')))
-        self.df_uint32 = DataFrame(dict(A=np.arange(self.N, dtype='uint32'), B=np.arange(self.N, dtype='uint32')))
-        self.df_float64 = DataFrame(dict(A=np.arange(self.N, dtype='float64'), B=np.arange(self.N, dtype='float64')))
-        self.df_float32 = DataFrame(dict(A=np.arange(self.N, dtype='float32'), B=np.arange(self.N, dtype='float32')))
-        self.df_datetime64 = DataFrame(dict(A=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms'), B=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms')))
-        self.df_timedelta64 = DataFrame(dict(A=(self.df_datetime64['A'] - self.df_datetime64['B']), B=self.df_datetime64['B']))
-
-    def time_dtype_infer_timedelta64_2(self):
-        (self.df_timedelta64['A'] + self.df_timedelta64['A'])
+    def time_from_float(self):
+        pd.to_numeric(self.float)
 
+    def time_from_numeric_str(self):
+        pd.to_numeric(self.numstr)
 
-class dtype_infer_uint32(object):
-    goal_time = 0.2
+    def time_from_str_ignore(self):
+        pd.to_numeric(self.str, errors='ignore')
 
-    def setup(self):
-        self.N = 500000
-        self.df_int64 = DataFrame(dict(A=np.arange(self.N, dtype='int64'), B=np.arange(self.N, dtype='int64')))
-        self.df_int32 = DataFrame(dict(A=np.arange(self.N, dtype='int32'), B=np.arange(self.N, dtype='int32')))
-        self.df_uint32 = DataFrame(dict(A=np.arange(self.N, dtype='uint32'), B=np.arange(self.N, dtype='uint32')))
-        self.df_float64 = DataFrame(dict(A=np.arange(self.N, dtype='float64'), B=np.arange(self.N, dtype='float64')))
-        self.df_float32 = DataFrame(dict(A=np.arange(self.N, dtype='float32'), B=np.arange(self.N, dtype='float32')))
-        self.df_datetime64 = DataFrame(dict(A=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms'), B=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms')))
-        self.df_timedelta64 = DataFrame(dict(A=(self.df_datetime64['A'] - self.df_datetime64['B']), B=self.df_datetime64['B']))
-
-    def time_dtype_infer_uint32(self):
-        (self.df_uint32['A'] + self.df_uint32['B'])
+    def time_from_str_coerce(self):
+        pd.to_numeric(self.str, errors='coerce')
 
 
-class to_numeric(object):
+class to_numeric_downcast(object):
 
     param_names = ['dtype', 'downcast']
     params = [['string-float', 'string-int', 'string-nint', 'datetime64',
@@ -162,4 +95,4 @@ def setup(self, dtype, downcast):
         self.data = self.data_dict[dtype]
 
     def time_downcast(self, dtype, downcast):
-        pd.to_numeric(self.data, downcast=downcast)
+        pd.to_numeric(self.data, downcast=downcast)