title
stringclasses 1
value | text
stringlengths 30
426k
| id
stringlengths 27
30
|
|---|---|---|
asv_bench/benchmarks/groupby.py/Size/setup
class Size:
def setup(self):
n = 10**5
offsets = np.random.randint(n, size=n).astype("timedelta64[ns]")
dates = np.datetime64("now") + offsets
self.df = DataFrame(
{
"key1": np.random.randint(0, 500, size=n),
"key2": np.random.randint(0, 100, size=n),
"value1": np.random.randn(n),
"value2": np.random.randn(n),
"value3": np.random.randn(n),
"dates": dates,
}
)
self.draws = Series(np.random.randn(n))
labels = Series(["foo", "bar", "baz", "qux"] * (n // 4))
self.cats = labels.astype("category")
|
negative_train_query0_00398
|
|
asv_bench/benchmarks/groupby.py/Size/time_multi_size
class Size:
def time_multi_size(self):
self.df.groupby(["key1", "key2"]).size()
|
negative_train_query0_00399
|
|
asv_bench/benchmarks/groupby.py/Size/time_category_size
class Size:
def time_category_size(self):
self.draws.groupby(self.cats, observed=True).size()
|
negative_train_query0_00400
|
|
asv_bench/benchmarks/groupby.py/Shift/setup
class Shift:
def setup(self):
N = 18
self.df = DataFrame({"g": ["a", "b"] * 9, "v": list(range(N))})
|
negative_train_query0_00401
|
|
asv_bench/benchmarks/groupby.py/Shift/time_defaults
class Shift:
def time_defaults(self):
self.df.groupby("g").shift()
|
negative_train_query0_00402
|
|
asv_bench/benchmarks/groupby.py/Shift/time_fill_value
class Shift:
def time_fill_value(self):
self.df.groupby("g").shift(fill_value=99)
|
negative_train_query0_00403
|
|
asv_bench/benchmarks/groupby.py/Fillna/setup
class Fillna:
def setup(self):
N = 100
self.df = DataFrame(
{"group": [1] * N + [2] * N, "value": [np.nan, 1.0] * N}
).set_index("group")
|
negative_train_query0_00404
|
|
asv_bench/benchmarks/groupby.py/Fillna/time_df_ffill
class Fillna:
def time_df_ffill(self):
self.df.groupby("group").ffill()
|
negative_train_query0_00405
|
|
asv_bench/benchmarks/groupby.py/Fillna/time_df_bfill
class Fillna:
def time_df_bfill(self):
self.df.groupby("group").bfill()
|
negative_train_query0_00406
|
|
asv_bench/benchmarks/groupby.py/Fillna/time_srs_ffill
class Fillna:
def time_srs_ffill(self):
self.df.groupby("group")["value"].ffill()
|
negative_train_query0_00407
|
|
asv_bench/benchmarks/groupby.py/Fillna/time_srs_bfill
class Fillna:
def time_srs_bfill(self):
self.df.groupby("group")["value"].bfill()
|
negative_train_query0_00408
|
|
asv_bench/benchmarks/groupby.py/GroupByMethods/setup
class GroupByMethods:
def setup(self, dtype, method, application, ncols, engine):
if method in method_blocklist.get(dtype, {}):
raise NotImplementedError # skip benchmark
if ncols != 1 and method in ["value_counts", "unique"]:
# DataFrameGroupBy doesn't have these methods
raise NotImplementedError
if application == "transformation" and method in [
"describe",
"head",
"tail",
"unique",
"value_counts",
"size",
]:
# DataFrameGroupBy doesn't have these methods
raise NotImplementedError
# Numba currently doesn't support
# multiple transform functions or strs for transform,
# grouping on multiple columns
# and we lack kernels for a bunch of methods
if (
(engine == "numba" and method in _numba_unsupported_methods)
or ncols > 1
or application == "transformation"
or dtype == "datetime"
):
raise NotImplementedError
if method == "describe":
ngroups = 20
elif method == "skew":
ngroups = 100
else:
ngroups = 1000
size = ngroups * 2
rng = np.arange(ngroups).reshape(-1, 1)
rng = np.broadcast_to(rng, (len(rng), ncols))
taker = np.random.randint(0, ngroups, size=size)
values = rng.take(taker, axis=0)
if dtype == "int":
key = np.random.randint(0, size, size=size)
elif dtype in ("int16", "uint"):
key = np.random.randint(0, size, size=size, dtype=dtype)
elif dtype == "float":
key = np.concatenate(
[np.random.random(ngroups) * 0.1, np.random.random(ngroups) * 10.0]
)
elif dtype == "object":
key = ["foo"] * size
elif dtype == "datetime":
key = date_range("1/1/2011", periods=size, freq="s")
cols = [f"values{n}" for n in range(ncols)]
df = DataFrame(values, columns=cols)
df["key"] = key
if len(cols) == 1:
cols = cols[0]
# Not everything supports the engine keyword yet
kwargs = {}
if engine == "numba":
kwargs["engine"] = engine
if application == "transformation":
self.as_group_method = lambda: df.groupby("key")[cols].transform(
method, **kwargs
)
self.as_field_method = lambda: df.groupby(cols)["key"].transform(
method, **kwargs
)
else:
self.as_group_method = partial(
getattr(df.groupby("key")[cols], method), **kwargs
)
self.as_field_method = partial(
getattr(df.groupby(cols)["key"], method), **kwargs
)
|
negative_train_query0_00409
|
|
asv_bench/benchmarks/groupby.py/GroupByMethods/time_dtype_as_group
class GroupByMethods:
def time_dtype_as_group(self, dtype, method, application, ncols, engine):
self.as_group_method()
|
negative_train_query0_00410
|
|
asv_bench/benchmarks/groupby.py/GroupByMethods/time_dtype_as_field
class GroupByMethods:
def time_dtype_as_field(self, dtype, method, application, ncols, engine):
self.as_field_method()
|
negative_train_query0_00411
|
|
asv_bench/benchmarks/groupby.py/GroupByCythonAgg/setup
class GroupByCythonAgg:
def setup(self, dtype, method):
N = 1_000_000
df = DataFrame(np.random.randn(N, 10), columns=list("abcdefghij"))
df["key"] = np.random.randint(0, 100, size=N)
self.df = df
|
negative_train_query0_00412
|
|
asv_bench/benchmarks/groupby.py/GroupByCythonAgg/time_frame_agg
class GroupByCythonAgg:
def time_frame_agg(self, dtype, method):
self.df.groupby("key").agg(method)
|
negative_train_query0_00413
|
|
asv_bench/benchmarks/groupby.py/GroupByNumbaAgg/setup
class GroupByNumbaAgg:
def setup(self, dtype, method):
if method in _numba_unsupported_methods:
raise NotImplementedError
super().setup(dtype, method)
|
negative_train_query0_00414
|
|
asv_bench/benchmarks/groupby.py/GroupByNumbaAgg/time_frame_agg
class GroupByNumbaAgg:
def time_frame_agg(self, dtype, method):
self.df.groupby("key").agg(method, engine="numba")
|
negative_train_query0_00415
|
|
asv_bench/benchmarks/groupby.py/GroupByCythonAggEaDtypes/setup
class GroupByCythonAggEaDtypes:
def setup(self, dtype, method):
N = 1_000_000
df = DataFrame(
np.random.randint(0, high=100, size=(N, 10)),
columns=list("abcdefghij"),
dtype=dtype,
)
df.loc[list(range(1, N, 5)), list("abcdefghij")] = NA
df["key"] = np.random.randint(0, 100, size=N)
self.df = df
|
negative_train_query0_00416
|
|
asv_bench/benchmarks/groupby.py/GroupByCythonAggEaDtypes/time_frame_agg
class GroupByCythonAggEaDtypes:
def time_frame_agg(self, dtype, method):
self.df.groupby("key").agg(method)
|
negative_train_query0_00417
|
|
asv_bench/benchmarks/groupby.py/Cumulative/setup
class Cumulative:
def setup(self, dtype, method, with_nans):
if with_nans and dtype == "int64":
raise NotImplementedError("Construction of df would raise")
N = 500_000
keys = np.random.randint(0, 100, size=N)
vals = np.random.randint(-10, 10, (N, 5))
if with_nans:
null_vals = vals.astype(float, copy=True)
null_vals[::2, :] = np.nan
null_vals[::3, :] = np.nan
df = DataFrame(null_vals, columns=list("abcde"), dtype=dtype)
df["key"] = keys
self.df = df
else:
df = DataFrame(vals, columns=list("abcde")).astype(dtype, copy=False)
df["key"] = keys
self.df = df
|
negative_train_query0_00418
|
|
asv_bench/benchmarks/groupby.py/Cumulative/time_frame_transform
class Cumulative:
def time_frame_transform(self, dtype, method, with_nans):
self.df.groupby("key").transform(method)
|
negative_train_query0_00419
|
|
asv_bench/benchmarks/groupby.py/RankWithTies/setup
class RankWithTies:
def setup(self, dtype, tie_method):
N = 10**4
if dtype == "datetime64":
data = np.array([Timestamp("2011/01/01")] * N, dtype=dtype)
else:
data = np.ones(N, dtype=dtype)
self.df = DataFrame({"values": data, "key": ["foo"] * N})
|
negative_train_query0_00420
|
|
asv_bench/benchmarks/groupby.py/RankWithTies/time_rank_ties
class RankWithTies:
def time_rank_ties(self, dtype, tie_method):
self.df.groupby("key").rank(method=tie_method)
|
negative_train_query0_00421
|
|
asv_bench/benchmarks/groupby.py/Float32/setup
class Float32:
def setup(self):
tmp1 = (np.random.random(10000) * 0.1).astype(np.float32)
tmp2 = (np.random.random(10000) * 10.0).astype(np.float32)
tmp = np.concatenate((tmp1, tmp2))
arr = np.repeat(tmp, 10)
self.df = DataFrame({"a": arr, "b": arr})
|
negative_train_query0_00422
|
|
asv_bench/benchmarks/groupby.py/Float32/time_sum
class Float32:
def time_sum(self):
self.df.groupby(["a"])["b"].sum()
|
negative_train_query0_00423
|
|
asv_bench/benchmarks/groupby.py/String/setup
class String:
def setup(self, dtype, method):
cols = list("abcdefghjkl")
self.df = DataFrame(
np.random.randint(0, 100, size=(10_000, len(cols))),
columns=cols,
dtype=dtype,
)
|
negative_train_query0_00424
|
|
asv_bench/benchmarks/groupby.py/String/time_str_func
class String:
def time_str_func(self, dtype, method):
self.df.groupby("a")[self.df.columns[1:]].agg(method)
|
negative_train_query0_00425
|
|
asv_bench/benchmarks/groupby.py/Categories/setup
class Categories:
def setup(self, observed):
N = 10**5
arr = np.random.random(N)
data = {"a": Categorical(np.random.randint(10000, size=N)), "b": arr}
self.df = DataFrame(data)
data = {
"a": Categorical(np.random.randint(10000, size=N), ordered=True),
"b": arr,
}
self.df_ordered = DataFrame(data)
data = {
"a": Categorical(
np.random.randint(100, size=N), categories=np.arange(10000)
),
"b": arr,
}
self.df_extra_cat = DataFrame(data)
|
negative_train_query0_00426
|
|
asv_bench/benchmarks/groupby.py/Categories/time_groupby_sort
class Categories:
def time_groupby_sort(self, observed):
self.df.groupby("a", observed=observed)["b"].count()
|
negative_train_query0_00427
|
|
asv_bench/benchmarks/groupby.py/Categories/time_groupby_nosort
class Categories:
def time_groupby_nosort(self, observed):
self.df.groupby("a", observed=observed, sort=False)["b"].count()
|
negative_train_query0_00428
|
|
asv_bench/benchmarks/groupby.py/Categories/time_groupby_ordered_sort
class Categories:
def time_groupby_ordered_sort(self, observed):
self.df_ordered.groupby("a", observed=observed)["b"].count()
|
negative_train_query0_00429
|
|
asv_bench/benchmarks/groupby.py/Categories/time_groupby_ordered_nosort
class Categories:
def time_groupby_ordered_nosort(self, observed):
self.df_ordered.groupby("a", observed=observed, sort=False)["b"].count()
|
negative_train_query0_00430
|
|
asv_bench/benchmarks/groupby.py/Categories/time_groupby_extra_cat_sort
class Categories:
def time_groupby_extra_cat_sort(self, observed):
self.df_extra_cat.groupby("a", observed=observed)["b"].count()
|
negative_train_query0_00431
|
|
asv_bench/benchmarks/groupby.py/Categories/time_groupby_extra_cat_nosort
class Categories:
def time_groupby_extra_cat_nosort(self, observed):
self.df_extra_cat.groupby("a", observed=observed, sort=False)["b"].count()
|
negative_train_query0_00432
|
|
asv_bench/benchmarks/groupby.py/MultipleCategories/setup
class MultipleCategories:
def setup(self):
N = 10**3
arr = np.random.random(N)
data = {
"a1": Categorical(np.random.randint(10000, size=N)),
"a2": Categorical(np.random.randint(10000, size=N)),
"b": arr,
}
self.df = DataFrame(data)
data = {
"a1": Categorical(np.random.randint(10000, size=N), ordered=True),
"a2": Categorical(np.random.randint(10000, size=N), ordered=True),
"b": arr,
}
self.df_ordered = DataFrame(data)
data = {
"a1": Categorical(np.random.randint(100, size=N), categories=np.arange(N)),
"a2": Categorical(np.random.randint(100, size=N), categories=np.arange(N)),
"b": arr,
}
self.df_extra_cat = DataFrame(data)
|
negative_train_query0_00433
|
|
asv_bench/benchmarks/groupby.py/MultipleCategories/time_groupby_sort
class MultipleCategories:
def time_groupby_sort(self):
self.df.groupby(["a1", "a2"], observed=False)["b"].count()
|
negative_train_query0_00434
|
|
asv_bench/benchmarks/groupby.py/MultipleCategories/time_groupby_nosort
class MultipleCategories:
def time_groupby_nosort(self):
self.df.groupby(["a1", "a2"], observed=False, sort=False)["b"].count()
|
negative_train_query0_00435
|
|
asv_bench/benchmarks/groupby.py/MultipleCategories/time_groupby_ordered_sort
class MultipleCategories:
def time_groupby_ordered_sort(self):
self.df_ordered.groupby(["a1", "a2"], observed=False)["b"].count()
|
negative_train_query0_00436
|
|
asv_bench/benchmarks/groupby.py/MultipleCategories/time_groupby_ordered_nosort
class MultipleCategories:
def time_groupby_ordered_nosort(self):
self.df_ordered.groupby(["a1", "a2"], observed=False, sort=False)["b"].count()
|
negative_train_query0_00437
|
|
asv_bench/benchmarks/groupby.py/MultipleCategories/time_groupby_extra_cat_sort
class MultipleCategories:
def time_groupby_extra_cat_sort(self):
self.df_extra_cat.groupby(["a1", "a2"], observed=False)["b"].count()
|
negative_train_query0_00438
|
|
asv_bench/benchmarks/groupby.py/MultipleCategories/time_groupby_extra_cat_nosort
class MultipleCategories:
def time_groupby_extra_cat_nosort(self):
self.df_extra_cat.groupby(["a1", "a2"], observed=False, sort=False)["b"].count()
|
negative_train_query0_00439
|
|
asv_bench/benchmarks/groupby.py/MultipleCategories/time_groupby_transform
class MultipleCategories:
def time_groupby_transform(self):
self.df_extra_cat.groupby(["a1", "a2"], observed=False)["b"].cumsum()
|
negative_train_query0_00440
|
|
asv_bench/benchmarks/groupby.py/Datelike/setup
class Datelike:
def setup(self, grouper):
N = 10**4
rng_map = {
"period_range": period_range,
"date_range": date_range,
"date_range_tz": partial(date_range, tz="US/Central"),
}
self.grouper = rng_map[grouper]("1900-01-01", freq="D", periods=N)
self.df = DataFrame(np.random.randn(10**4, 2))
|
negative_train_query0_00441
|
|
asv_bench/benchmarks/groupby.py/Datelike/time_sum
class Datelike:
def time_sum(self, grouper):
self.df.groupby(self.grouper).sum()
|
negative_train_query0_00442
|
|
asv_bench/benchmarks/groupby.py/SumBools/setup
class SumBools:
def setup(self):
N = 500
self.df = DataFrame({"ii": range(N), "bb": [True] * N})
|
negative_train_query0_00443
|
|
asv_bench/benchmarks/groupby.py/SumBools/time_groupby_sum_booleans
class SumBools:
def time_groupby_sum_booleans(self):
self.df.groupby("ii").sum()
|
negative_train_query0_00444
|
|
asv_bench/benchmarks/groupby.py/SumMultiLevel/setup
class SumMultiLevel:
def setup(self):
N = 50
self.df = DataFrame(
{"A": list(range(N)) * 2, "B": range(N * 2), "C": 1}
).set_index(["A", "B"])
|
negative_train_query0_00445
|
|
asv_bench/benchmarks/groupby.py/SumMultiLevel/time_groupby_sum_multiindex
class SumMultiLevel:
def time_groupby_sum_multiindex(self):
self.df.groupby(level=[0, 1]).sum()
|
negative_train_query0_00446
|
|
asv_bench/benchmarks/groupby.py/SumTimeDelta/setup
class SumTimeDelta:
def setup(self):
N = 10**4
self.df = DataFrame(
np.random.randint(1000, 100000, (N, 100)),
index=np.random.randint(200, size=(N,)),
).astype("timedelta64[ns]")
self.df_int = self.df.copy().astype("int64")
|
negative_train_query0_00447
|
|
asv_bench/benchmarks/groupby.py/SumTimeDelta/time_groupby_sum_timedelta
class SumTimeDelta:
def time_groupby_sum_timedelta(self):
self.df.groupby(lambda x: x).sum()
|
negative_train_query0_00448
|
|
asv_bench/benchmarks/groupby.py/SumTimeDelta/time_groupby_sum_int
class SumTimeDelta:
def time_groupby_sum_int(self):
self.df_int.groupby(lambda x: x).sum()
|
negative_train_query0_00449
|
|
asv_bench/benchmarks/groupby.py/Transform/setup
class Transform:
def setup(self):
n1 = 400
n2 = 250
index = MultiIndex(
levels=[np.arange(n1), Index([f"i-{i}" for i in range(n2)], dtype=object)],
codes=[np.repeat(range(n1), n2).tolist(), list(range(n2)) * n1],
names=["lev1", "lev2"],
)
arr = np.random.randn(n1 * n2, 3)
arr[::10000, 0] = np.nan
arr[1::10000, 1] = np.nan
arr[2::10000, 2] = np.nan
data = DataFrame(arr, index=index, columns=["col1", "col20", "col3"])
self.df = data
n = 1000
self.df_wide = DataFrame(
np.random.randn(n, n),
index=np.random.choice(range(10), n),
)
n = 1_000_000
self.df_tall = DataFrame(
np.random.randn(n, 3),
index=np.random.randint(0, 5, n),
)
n = 20000
self.df1 = DataFrame(
np.random.randint(1, n, (n, 3)), columns=["jim", "joe", "jolie"]
)
self.df2 = self.df1.copy()
self.df2["jim"] = self.df2["joe"]
self.df3 = DataFrame(
np.random.randint(1, (n / 10), (n, 3)), columns=["jim", "joe", "jolie"]
)
self.df4 = self.df3.copy()
self.df4["jim"] = self.df4["joe"]
|
negative_train_query0_00450
|
|
asv_bench/benchmarks/groupby.py/Transform/time_transform_lambda_max
class Transform:
def time_transform_lambda_max(self):
self.df.groupby(level="lev1").transform(lambda x: max(x))
|
negative_train_query0_00451
|
|
asv_bench/benchmarks/groupby.py/Transform/time_transform_str_max
class Transform:
def time_transform_str_max(self):
self.df.groupby(level="lev1").transform("max")
|
negative_train_query0_00452
|
|
asv_bench/benchmarks/groupby.py/Transform/time_transform_lambda_max_tall
class Transform:
def time_transform_lambda_max_tall(self):
self.df_tall.groupby(level=0).transform(lambda x: np.max(x, axis=0))
|
negative_train_query0_00453
|
|
asv_bench/benchmarks/groupby.py/Transform/time_transform_lambda_max_wide
class Transform:
def time_transform_lambda_max_wide(self):
self.df_wide.groupby(level=0).transform(lambda x: np.max(x, axis=0))
|
negative_train_query0_00454
|
|
asv_bench/benchmarks/groupby.py/Transform/time_transform_multi_key1
class Transform:
def time_transform_multi_key1(self):
self.df1.groupby(["jim", "joe"])["jolie"].transform("max")
|
negative_train_query0_00455
|
|
asv_bench/benchmarks/groupby.py/Transform/time_transform_multi_key2
class Transform:
def time_transform_multi_key2(self):
self.df2.groupby(["jim", "joe"])["jolie"].transform("max")
|
negative_train_query0_00456
|
|
asv_bench/benchmarks/groupby.py/Transform/time_transform_multi_key3
class Transform:
def time_transform_multi_key3(self):
self.df3.groupby(["jim", "joe"])["jolie"].transform("max")
|
negative_train_query0_00457
|
|
asv_bench/benchmarks/groupby.py/Transform/time_transform_multi_key4
class Transform:
def time_transform_multi_key4(self):
self.df4.groupby(["jim", "joe"])["jolie"].transform("max")
|
negative_train_query0_00458
|
|
asv_bench/benchmarks/groupby.py/TransformBools/setup
class TransformBools:
def setup(self):
N = 120000
transition_points = np.sort(np.random.choice(np.arange(N), 1400))
transitions = np.zeros(N, dtype=np.bool_)
transitions[transition_points] = True
self.g = transitions.cumsum()
self.df = DataFrame({"signal": np.random.rand(N)})
|
negative_train_query0_00459
|
|
asv_bench/benchmarks/groupby.py/TransformBools/time_transform_mean
class TransformBools:
def time_transform_mean(self):
self.df["signal"].groupby(self.g).transform("mean")
|
negative_train_query0_00460
|
|
asv_bench/benchmarks/groupby.py/TransformNaN/setup
class TransformNaN:
def setup(self):
self.df_nans = DataFrame(
{"key": np.repeat(np.arange(1000), 10), "B": np.nan, "C": np.nan}
)
self.df_nans.loc[4::10, "B":"C"] = 5
|
negative_train_query0_00461
|
|
asv_bench/benchmarks/groupby.py/TransformNaN/time_first
class TransformNaN:
def time_first(self):
self.df_nans.groupby("key").transform("first")
|
negative_train_query0_00462
|
|
asv_bench/benchmarks/groupby.py/TransformEngine/setup
class TransformEngine:
def setup(self, parallel):
N = 10**3
data = DataFrame(
{0: [str(i) for i in range(100)] * N, 1: list(range(100)) * N},
columns=[0, 1],
)
self.parallel = parallel
self.grouper = data.groupby(0)
|
negative_train_query0_00463
|
|
asv_bench/benchmarks/groupby.py/TransformEngine/time_series_numba
class TransformEngine:
def time_series_numba(self, parallel):
def function(values, index):
return values * 5
self.grouper[1].transform(
function, engine="numba", engine_kwargs={"parallel": self.parallel}
)
|
negative_train_query0_00464
|
|
asv_bench/benchmarks/groupby.py/TransformEngine/time_series_numba/function
class TransformEngine:
def function(values, index):
return values * 5
|
negative_train_query0_00465
|
|
asv_bench/benchmarks/groupby.py/TransformEngine/time_series_cython
class TransformEngine:
def time_series_cython(self, parallel):
def function(values):
return values * 5
self.grouper[1].transform(function, engine="cython")
|
negative_train_query0_00466
|
|
asv_bench/benchmarks/groupby.py/TransformEngine/time_series_cython/function
class TransformEngine:
def function(values):
return values * 5
|
negative_train_query0_00467
|
|
asv_bench/benchmarks/groupby.py/TransformEngine/time_dataframe_numba
class TransformEngine:
def time_dataframe_numba(self, parallel):
def function(values, index):
return values * 5
self.grouper.transform(
function, engine="numba", engine_kwargs={"parallel": self.parallel}
)
|
negative_train_query0_00468
|
|
asv_bench/benchmarks/groupby.py/TransformEngine/time_dataframe_numba/function
class TransformEngine:
def function(values, index):
return values * 5
|
negative_train_query0_00469
|
|
asv_bench/benchmarks/groupby.py/TransformEngine/time_dataframe_cython
class TransformEngine:
def time_dataframe_cython(self, parallel):
def function(values):
return values * 5
self.grouper.transform(function, engine="cython")
|
negative_train_query0_00470
|
|
asv_bench/benchmarks/groupby.py/TransformEngine/time_dataframe_cython/function
class TransformEngine:
def function(values):
return values * 5
|
negative_train_query0_00471
|
|
asv_bench/benchmarks/groupby.py/AggEngine/setup
class AggEngine:
def setup(self, parallel):
N = 10**3
data = DataFrame(
{0: [str(i) for i in range(100)] * N, 1: list(range(100)) * N},
columns=[0, 1],
)
self.parallel = parallel
self.grouper = data.groupby(0)
|
negative_train_query0_00472
|
|
asv_bench/benchmarks/groupby.py/AggEngine/time_series_numba
class AggEngine:
def time_series_numba(self, parallel):
def function(values, index):
total = 0
for i, value in enumerate(values):
if i % 2:
total += value + 5
else:
total += value * 2
return total
self.grouper[1].agg(
function, engine="numba", engine_kwargs={"parallel": self.parallel}
)
|
negative_train_query0_00473
|
|
asv_bench/benchmarks/groupby.py/AggEngine/time_series_numba/function
class AggEngine:
def function(values, index):
total = 0
for i, value in enumerate(values):
if i % 2:
total += value + 5
else:
total += value * 2
return total
|
negative_train_query0_00474
|
|
asv_bench/benchmarks/groupby.py/AggEngine/time_series_cython
class AggEngine:
def time_series_cython(self, parallel):
def function(values):
total = 0
for i, value in enumerate(values):
if i % 2:
total += value + 5
else:
total += value * 2
return total
self.grouper[1].agg(function, engine="cython")
|
negative_train_query0_00475
|
|
asv_bench/benchmarks/groupby.py/AggEngine/time_series_cython/function
class AggEngine:
def function(values):
total = 0
for i, value in enumerate(values):
if i % 2:
total += value + 5
else:
total += value * 2
return total
|
negative_train_query0_00476
|
|
asv_bench/benchmarks/groupby.py/AggEngine/time_dataframe_numba
class AggEngine:
def time_dataframe_numba(self, parallel):
def function(values, index):
total = 0
for i, value in enumerate(values):
if i % 2:
total += value + 5
else:
total += value * 2
return total
self.grouper.agg(
function, engine="numba", engine_kwargs={"parallel": self.parallel}
)
|
negative_train_query0_00477
|
|
asv_bench/benchmarks/groupby.py/AggEngine/time_dataframe_numba/function
class AggEngine:
def function(values, index):
total = 0
for i, value in enumerate(values):
if i % 2:
total += value + 5
else:
total += value * 2
return total
|
negative_train_query0_00478
|
|
asv_bench/benchmarks/groupby.py/AggEngine/time_dataframe_cython
class AggEngine:
def time_dataframe_cython(self, parallel):
def function(values):
total = 0
for i, value in enumerate(values):
if i % 2:
total += value + 5
else:
total += value * 2
return total
self.grouper.agg(function, engine="cython")
|
negative_train_query0_00479
|
|
asv_bench/benchmarks/groupby.py/AggEngine/time_dataframe_cython/function
class AggEngine:
def function(values):
total = 0
for i, value in enumerate(values):
if i % 2:
total += value + 5
else:
total += value * 2
return total
|
negative_train_query0_00480
|
|
asv_bench/benchmarks/groupby.py/Sample/setup
class Sample:
def setup(self):
N = 10**3
self.df = DataFrame({"a": np.zeros(N)})
self.groups = np.arange(0, N)
self.weights = np.ones(N)
|
negative_train_query0_00481
|
|
asv_bench/benchmarks/groupby.py/Sample/time_sample
class Sample:
def time_sample(self):
self.df.groupby(self.groups).sample(n=1)
|
negative_train_query0_00482
|
|
asv_bench/benchmarks/groupby.py/Sample/time_sample_weights
class Sample:
def time_sample_weights(self):
self.df.groupby(self.groups).sample(n=1, weights=self.weights)
|
negative_train_query0_00483
|
|
asv_bench/benchmarks/groupby.py/Resample/setup
class Resample:
def setup(self):
num_timedeltas = 20_000
num_groups = 3
index = MultiIndex.from_product(
[
np.arange(num_groups),
to_timedelta(np.arange(num_timedeltas), unit="s"),
],
names=["groups", "timedeltas"],
)
data = np.random.randint(0, 1000, size=(len(index)))
self.df = DataFrame(data, index=index).reset_index("timedeltas")
self.df_multiindex = DataFrame(data, index=index)
|
negative_train_query0_00484
|
|
asv_bench/benchmarks/groupby.py/Resample/time_resample
class Resample:
def time_resample(self):
self.df.groupby(level="groups").resample("10s", on="timedeltas").mean()
|
negative_train_query0_00485
|
|
asv_bench/benchmarks/groupby.py/Resample/time_resample_multiindex
class Resample:
def time_resample_multiindex(self):
self.df_multiindex.groupby(level="groups").resample(
"10s", level="timedeltas"
).mean()
|
negative_train_query0_00486
|
|
asv_bench/benchmarks/ctors.py/no_change
def no_change(arr):
return arr
|
negative_train_query0_00487
|
|
asv_bench/benchmarks/ctors.py/list_of_str
def list_of_str(arr):
return list(arr.astype(str))
|
negative_train_query0_00488
|
|
asv_bench/benchmarks/ctors.py/gen_of_str
def gen_of_str(arr):
return (x for x in arr.astype(str))
|
negative_train_query0_00489
|
|
asv_bench/benchmarks/ctors.py/arr_dict
def arr_dict(arr):
return dict(zip(range(len(arr)), arr))
|
negative_train_query0_00490
|
|
asv_bench/benchmarks/ctors.py/list_of_tuples
def list_of_tuples(arr):
return [(i, -i) for i in arr]
|
negative_train_query0_00491
|
|
asv_bench/benchmarks/ctors.py/gen_of_tuples
def gen_of_tuples(arr):
return ((i, -i) for i in arr)
|
negative_train_query0_00492
|
|
asv_bench/benchmarks/ctors.py/list_of_lists
def list_of_lists(arr):
return [[i, -i] for i in arr]
|
negative_train_query0_00493
|
|
asv_bench/benchmarks/ctors.py/list_of_tuples_with_none
def list_of_tuples_with_none(arr):
return [(i, -i) for i in arr][:-1] + [None]
|
negative_train_query0_00494
|
|
asv_bench/benchmarks/ctors.py/list_of_lists_with_none
def list_of_lists_with_none(arr):
return [[i, -i] for i in arr][:-1] + [None]
|
negative_train_query0_00495
|
|
asv_bench/benchmarks/ctors.py/SeriesConstructors/setup
class SeriesConstructors:
def setup(self, data_fmt, with_index, dtype):
if data_fmt in (gen_of_str, gen_of_tuples) and with_index:
raise NotImplementedError(
"Series constructors do not support using generators with indexes"
)
N = 10**4
if dtype == "float":
arr = np.random.randn(N)
else:
arr = np.arange(N)
self.data = data_fmt(arr)
self.index = np.arange(N) if with_index else None
|
negative_train_query0_00496
|
|
asv_bench/benchmarks/ctors.py/SeriesConstructors/time_series_constructor
class SeriesConstructors:
def time_series_constructor(self, data_fmt, with_index, dtype):
Series(self.data, index=self.index)
|
negative_train_query0_00497
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.