post merge with master

Author: bobhaffner

asv_bench/benchmarks/binary_ops.py

@@ -1,17 +1,20 @@
-from .pandas_vb_common import *
+import numpy as np
+from pandas import DataFrame, Series, date_range
 try:
     import pandas.core.computation.expressions as expr
 except ImportError:
     import pandas.computation.expressions as expr
 
 
 class Ops(object):
+
     goal_time = 0.2
 
     params = [[True, False], ['default', 1]]
     param_names = ['use_numexpr', 'threads']
 
     def setup(self, use_numexpr, threads):
+        np.random.seed(1234)
         self.df = DataFrame(np.random.randn(20000, 100))
         self.df2 = DataFrame(np.random.randn(20000, 100))
 
@@ -20,94 +23,88 @@ def setup(self, use_numexpr, threads):
         if not use_numexpr:
             expr.set_use_numexpr(False)
 
-
     def time_frame_add(self, use_numexpr, threads):
-        (self.df + self.df2)
+        self.df + self.df2
 
     def time_frame_mult(self, use_numexpr, threads):
-        (self.df * self.df2)
+        self.df * self.df2
 
     def time_frame_multi_and(self, use_numexpr, threads):
-        self.df[((self.df > 0) & (self.df2 > 0))]
+        self.df[(self.df > 0) & (self.df2 > 0)]
 
     def time_frame_comparison(self, use_numexpr, threads):
-        (self.df > self.df2)
+        self.df > self.df2
 
     def teardown(self, use_numexpr, threads):
         expr.set_use_numexpr(True)
         expr.set_numexpr_threads()
 
 
 class Ops2(object):
+
     goal_time = 0.2
 
     def setup(self):
-        self.df = DataFrame(np.random.randn(1000, 1000))
-        self.df2 = DataFrame(np.random.randn(1000, 1000))
+        N = 10**3
+        np.random.seed(1234)
+        self.df = DataFrame(np.random.randn(N, N))
+        self.df2 = DataFrame(np.random.randn(N, N))
 
-        self.df_int = DataFrame(
-            np.random.random_integers(np.iinfo(np.int16).min,
-                                      np.iinfo(np.int16).max,
-                                      size=(1000, 1000)))
-        self.df2_int = DataFrame(
-            np.random.random_integers(np.iinfo(np.int16).min,
-                                      np.iinfo(np.int16).max,
-                                      size=(1000, 1000)))
+        self.df_int = DataFrame(np.random.randint(np.iinfo(np.int16).min,
+                                                  np.iinfo(np.int16).max,
+                                                  size=(N, N)))
+        self.df2_int = DataFrame(np.random.randint(np.iinfo(np.int16).min,
+                                                   np.iinfo(np.int16).max,
+                                                   size=(N, N)))
 
-    ## Division
+    # Division
 
     def time_frame_float_div(self):
-        (self.df // self.df2)
+        self.df // self.df2
 
     def time_frame_float_div_by_zero(self):
-        (self.df / 0)
+        self.df / 0
 
     def time_frame_float_floor_by_zero(self):
-        (self.df // 0)
+        self.df // 0
 
     def time_frame_int_div_by_zero(self):
-        (self.df_int / 0)
+        self.df_int / 0
 
-    ## Modulo
+    # Modulo
 
     def time_frame_int_mod(self):
-        (self.df / self.df2)
+        self.df_int % self.df2_int
 
     def time_frame_float_mod(self):
-        (self.df / self.df2)
+        self.df % self.df2
 
 
 class Timeseries(object):
+
     goal_time = 0.2
 
-    def setup(self):
-        self.N = 1000000
+    params = [None, 'US/Eastern']
+    param_names = ['tz']
+
+    def setup(self, tz):
+        self.N = 10**6
         self.halfway = ((self.N // 2) - 1)
-        self.s = Series(date_range('20010101', periods=self.N, freq='T'))
+        self.s = Series(date_range('20010101', periods=self.N, freq='T',
+                                   tz=tz))
         self.ts = self.s[self.halfway]
 
-        self.s2 = Series(date_range('20010101', periods=self.N, freq='s'))
+        self.s2 = Series(date_range('20010101', periods=self.N, freq='s',
+                                    tz=tz))
 
-    def time_series_timestamp_compare(self):
-        (self.s <= self.ts)
+    def time_series_timestamp_compare(self, tz):
+        self.s <= self.ts
 
-    def time_timestamp_series_compare(self):
-        (self.ts >= self.s)
+    def time_timestamp_series_compare(self, tz):
+        self.ts >= self.s
 
-    def time_timestamp_ops_diff1(self):
+    def time_timestamp_ops_diff(self, tz):
         self.s2.diff()
 
-    def time_timestamp_ops_diff2(self):
-        (self.s - self.s.shift())
-
-
-
-class TimeseriesTZ(Timeseries):
-
-    def setup(self):
-        self.N = 1000000
-        self.halfway = ((self.N // 2) - 1)
-        self.s = Series(date_range('20010101', periods=self.N, freq='T', tz='US/Eastern'))
-        self.ts = self.s[self.halfway]
-
-        self.s2 = Series(date_range('20010101', periods=self.N, freq='s',  tz='US/Eastern'))
+    def time_timestamp_ops_diff_with_shift(self, tz):
+        self.s - self.s.shift()

asv_bench/benchmarks/categoricals.py

@@ -1,4 +1,6 @@
-from .pandas_vb_common import *
+import numpy as np
+import pandas as pd
+import pandas.util.testing as tm
 try:
     from pandas.api.types import union_categoricals
 except ImportError:
@@ -8,107 +10,136 @@
         pass
 
 
-class Categoricals(object):
+class Concat(object):
+
     goal_time = 0.2
 
     def setup(self):
-        N = 100000
-        self.s = pd.Series((list('aabbcd') * N)).astype('category')
+        N = 10**5
+        self.s = pd.Series(list('aabbcd') * N).astype('category')
+
+        self.a = pd.Categorical(list('aabbcd') * N)
+        self.b = pd.Categorical(list('bbcdjk') * N)
+
+    def time_concat(self):
+        pd.concat([self.s, self.s])
+
+    def time_union(self):
+        union_categoricals([self.a, self.b])
+
 
-        self.a = pd.Categorical((list('aabbcd') * N))
-        self.b = pd.Categorical((list('bbcdjk') * N))
+class Constructor(object):
 
+    goal_time = 0.2
+
+    def setup(self):
+        N = 10**5
         self.categories = list('abcde')
-        self.cat_idx = Index(self.categories)
+        self.cat_idx = pd.Index(self.categories)
         self.values = np.tile(self.categories, N)
         self.codes = np.tile(range(len(self.categories)), N)
 
-        self.datetimes = pd.Series(pd.date_range(
-            '1995-01-01 00:00:00', periods=10000, freq='s'))
+        self.datetimes = pd.Series(pd.date_range('1995-01-01 00:00:00',
+                                                 periods=N / 10,
+                                                 freq='s'))
+        self.datetimes_with_nat = self.datetimes.copy()
+        self.datetimes_with_nat.iloc[-1] = pd.NaT
 
         self.values_some_nan = list(np.tile(self.categories + [np.nan], N))
         self.values_all_nan = [np.nan] * len(self.values)
 
-    def time_concat(self):
-        concat([self.s, self.s])
-
-    def time_union(self):
-        union_categoricals([self.a, self.b])
+    def time_regular(self):
+        pd.Categorical(self.values, self.categories)
 
-    def time_constructor_regular(self):
-        Categorical(self.values, self.categories)
+    def time_fastpath(self):
+        pd.Categorical(self.codes, self.cat_idx, fastpath=True)
 
-    def time_constructor_fastpath(self):
-        Categorical(self.codes, self.cat_idx, fastpath=True)
+    def time_datetimes(self):
+        pd.Categorical(self.datetimes)
 
-    def time_constructor_datetimes(self):
-        Categorical(self.datetimes)
+    def time_datetimes_with_nat(self):
+        pd.Categorical(self.datetimes_with_nat)
 
-    def time_constructor_datetimes_with_nat(self):
-        t = self.datetimes
-        t.iloc[-1] = pd.NaT
-        Categorical(t)
+    def time_with_nan(self):
+        pd.Categorical(self.values_some_nan)
 
-    def time_constructor_with_nan(self):
-        Categorical(self.values_some_nan)
+    def time_all_nan(self):
+        pd.Categorical(self.values_all_nan)
 
-    def time_constructor_all_nan(self):
-        Categorical(self.values_all_nan)
 
+class ValueCounts(object):
 
-class Categoricals2(object):
     goal_time = 0.2
 
-    def setup(self):
-        n = 500000
+    params = [True, False]
+    param_names = ['dropna']
+
+    def setup(self, dropna):
+        n = 5 * 10**5
         np.random.seed(2718281)
         arr = ['s%04d' % i for i in np.random.randint(0, n // 10, size=n)]
-        self.ts = Series(arr).astype('category')
+        self.ts = pd.Series(arr).astype('category')
+
+    def time_value_counts(self, dropna):
+        self.ts.value_counts(dropna=dropna)
+
 
-        self.sel = self.ts.loc[[0]]
+class Repr(object):
 
-    def time_value_counts(self):
-        self.ts.value_counts(dropna=False)
+    goal_time = 0.2
 
-    def time_value_counts_dropna(self):
-        self.ts.value_counts(dropna=True)
+    def setup(self):
+        self.sel = pd.Series(['s1234']).astype('category')
 
     def time_rendering(self):
         str(self.sel)
 
+
+class SetCategories(object):
+
+    goal_time = 0.2
+
+    def setup(self):
+        n = 5 * 10**5
+        np.random.seed(2718281)
+        arr = ['s%04d' % i for i in np.random.randint(0, n // 10, size=n)]
+        self.ts = pd.Series(arr).astype('category')
+
     def time_set_categories(self):
         self.ts.cat.set_categories(self.ts.cat.categories[::2])
 
 
-class Categoricals3(object):
+class Rank(object):
+
     goal_time = 0.2
 
     def setup(self):
-        N = 100000
+        N = 10**5
         ncats = 100
+        np.random.seed(1234)
 
-        self.s1 = Series(np.array(tm.makeCategoricalIndex(N, ncats)))
-        self.s1_cat = self.s1.astype('category')
-        self.s1_cat_ordered = self.s1.astype('category', ordered=True)
+        self.s_str = pd.Series(tm.makeCategoricalIndex(N, ncats)).astype(str)
+        self.s_str_cat = self.s_str.astype('category')
+        self.s_str_cat_ordered = self.s_str.astype('category', ordered=True)
 
-        self.s2 = Series(np.random.randint(0, ncats, size=N))
-        self.s2_cat = self.s2.astype('category')
-        self.s2_cat_ordered = self.s2.astype('category', ordered=True)
+        self.s_int = pd.Series(np.random.randint(0, ncats, size=N))
+        self.s_int_cat = self.s_int.astype('category')
+        self.s_int_cat_ordered = self.s_int.astype('category', ordered=True)
 
     def time_rank_string(self):
-        self.s1.rank()
+        self.s_str.rank()
 
     def time_rank_string_cat(self):
-        self.s1_cat.rank()
+        self.s_str_cat.rank()
 
     def time_rank_string_cat_ordered(self):
-        self.s1_cat_ordered.rank()
+        self.s_str_cat_ordered.rank()
 
     def time_rank_int(self):
-        self.s2.rank()
+        self.s_int.rank()
 
     def time_rank_int_cat(self):
-        self.s2_cat.rank()
+        self.s_int_cat.rank()
 
     def time_rank_int_cat_ordered(self):
-        self.s2_cat_ordered.rank()
+        self.s_int_cat_ordered.rank()

asv_bench/benchmarks/ctors.py

@@ -1,30 +1,34 @@
-from .pandas_vb_common import *
+import numpy as np
+from pandas import DataFrame, Series, Index, DatetimeIndex, Timestamp
 
 
 class Constructors(object):
+
     goal_time = 0.2
 
     def setup(self):
-        self.arr = np.random.randn(100, 100)
+        N = 10**2
+        np.random.seed(1234)
+        self.arr = np.random.randn(N, N)
         self.arr_str = np.array(['foo', 'bar', 'baz'], dtype=object)
 
-        self.data = np.random.randn(100)
-        self.index = Index(np.arange(100))
+        self.data = np.random.randn(N)
+        self.index = Index(np.arange(N))
 
-        self.s = Series(([Timestamp('20110101'), Timestamp('20120101'),
-                          Timestamp('20130101')] * 1000))
+        self.s = Series([Timestamp('20110101'), Timestamp('20120101'),
+                         Timestamp('20130101')] * N * 10)
 
     def time_frame_from_ndarray(self):
         DataFrame(self.arr)
 
     def time_series_from_ndarray(self):
-        pd.Series(self.data, index=self.index)
+        Series(self.data, index=self.index)
 
     def time_index_from_array_string(self):
         Index(self.arr_str)
 
     def time_dtindex_from_series(self):
         DatetimeIndex(self.s)
 
-    def time_dtindex_from_series2(self):
+    def time_dtindex_from_index_with_series(self):
         Index(self.s)