title stringclasses 1
value | text stringlengths 30 426k | id stringlengths 27 30 |
|---|---|---|
asv_bench/benchmarks/boolean.py/TimeLogicalOps/time_and_scalar
class TimeLogicalOps:
def time_and_scalar(self):
self.left & True
self.left & False | negative_train_query0_00198 | |
asv_bench/benchmarks/boolean.py/TimeLogicalOps/time_and_array
class TimeLogicalOps:
def time_and_array(self):
self.left & self.right | negative_train_query0_00199 | |
asv_bench/benchmarks/boolean.py/TimeLogicalOps/time_xor_scalar
class TimeLogicalOps:
def time_xor_scalar(self):
self.left ^ True
self.left ^ False | negative_train_query0_00200 | |
asv_bench/benchmarks/boolean.py/TimeLogicalOps/time_xor_array
class TimeLogicalOps:
def time_xor_array(self):
self.left ^ self.right | negative_train_query0_00201 | |
asv_bench/benchmarks/gil.py/test_parallel
def test_parallel(num_threads=2, kwargs_list=None):
"""
Decorator to run the same function multiple times in parallel.
Parameters
----------
num_threads : int, optional
The number of times the function is run in parallel.
kwargs_list : list of d... | negative_train_query0_00202 | |
asv_bench/benchmarks/gil.py/test_parallel/wrapper
class test_parallel:
def wrapper(func):
@wraps(func)
def inner(*args, **kwargs):
if has_kwargs_list:
update_kwargs = lambda i: dict(kwargs, **kwargs_list[i])
else:
update_kwargs = lambda i: kwargs
... | negative_train_query0_00203 | |
asv_bench/benchmarks/gil.py/test_parallel/wrapper/inner
class test_parallel:
def inner(*args, **kwargs):
if has_kwargs_list:
update_kwargs = lambda i: dict(kwargs, **kwargs_list[i])
else:
update_kwargs = lambda i: kwargs
threads = []
for i ... | negative_train_query0_00204 | |
asv_bench/benchmarks/gil.py/ParallelGroupbyMethods/setup
class ParallelGroupbyMethods:
def setup(self, threads, method):
N = 10**6
ngroups = 10**3
df = DataFrame(
{"key": np.random.randint(0, ngroups, size=N), "data": np.random.randn(N)}
)
@test_parallel(num_threads=... | negative_train_query0_00205 | |
asv_bench/benchmarks/gil.py/ParallelGroupbyMethods/setup/parallel
class ParallelGroupbyMethods:
def parallel():
getattr(df.groupby("key")["data"], method)() | negative_train_query0_00206 | |
asv_bench/benchmarks/gil.py/ParallelGroupbyMethods/setup/loop
class ParallelGroupbyMethods:
def loop():
getattr(df.groupby("key")["data"], method)() | negative_train_query0_00207 | |
asv_bench/benchmarks/gil.py/ParallelGroupbyMethods/time_parallel
class ParallelGroupbyMethods:
def time_parallel(self, threads, method):
self.parallel() | negative_train_query0_00208 | |
asv_bench/benchmarks/gil.py/ParallelGroupbyMethods/time_loop
class ParallelGroupbyMethods:
def time_loop(self, threads, method):
for i in range(threads):
self.loop() | negative_train_query0_00209 | |
asv_bench/benchmarks/gil.py/ParallelGroups/setup
class ParallelGroups:
def setup(self, threads):
size = 2**22
ngroups = 10**3
data = Series(np.random.randint(0, ngroups, size=size))
@test_parallel(num_threads=threads)
def get_groups():
data.groupby(data).groups
... | negative_train_query0_00210 | |
asv_bench/benchmarks/gil.py/ParallelGroups/setup/get_groups
class ParallelGroups:
def get_groups():
data.groupby(data).groups | negative_train_query0_00211 | |
asv_bench/benchmarks/gil.py/ParallelGroups/time_get_groups
class ParallelGroups:
def time_get_groups(self, threads):
self.get_groups() | negative_train_query0_00212 | |
asv_bench/benchmarks/gil.py/ParallelTake1D/setup
class ParallelTake1D:
def setup(self, dtype):
N = 10**6
df = DataFrame({"col": np.arange(N, dtype=dtype)})
indexer = np.arange(100, len(df) - 100)
@test_parallel(num_threads=2)
def parallel_take1d():
take_nd(df["col"].... | negative_train_query0_00213 | |
asv_bench/benchmarks/gil.py/ParallelTake1D/setup/parallel_take1d
class ParallelTake1D:
def parallel_take1d():
take_nd(df["col"].values, indexer) | negative_train_query0_00214 | |
asv_bench/benchmarks/gil.py/ParallelTake1D/time_take1d
class ParallelTake1D:
def time_take1d(self, dtype):
self.parallel_take1d() | negative_train_query0_00215 | |
asv_bench/benchmarks/gil.py/ParallelKth/setup
class ParallelKth:
def setup(self):
N = 10**7
k = 5 * 10**5
kwargs_list = [{"arr": np.random.randn(N)}, {"arr": np.random.randn(N)}]
@test_parallel(num_threads=2, kwargs_list=kwargs_list)
def parallel_kth_smallest(arr):
a... | negative_train_query0_00216 | |
asv_bench/benchmarks/gil.py/ParallelKth/setup/parallel_kth_smallest
class ParallelKth:
def parallel_kth_smallest(arr):
algos.kth_smallest(arr, k) | negative_train_query0_00217 | |
asv_bench/benchmarks/gil.py/ParallelKth/time_kth_smallest
class ParallelKth:
def time_kth_smallest(self):
self.parallel_kth_smallest() | negative_train_query0_00218 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/setup
class ParallelDatetimeFields:
def setup(self):
N = 10**6
self.dti = date_range("1900-01-01", periods=N, freq="min")
self.period = self.dti.to_period("D") | negative_train_query0_00219 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_datetime_field_year
class ParallelDatetimeFields:
def time_datetime_field_year(self):
@test_parallel(num_threads=2)
def run(dti):
dti.year
run(self.dti) | negative_train_query0_00220 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_datetime_field_year/run
class ParallelDatetimeFields:
def run(dti):
dti.year | negative_train_query0_00221 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_datetime_field_day
class ParallelDatetimeFields:
def time_datetime_field_day(self):
@test_parallel(num_threads=2)
def run(dti):
dti.day
run(self.dti) | negative_train_query0_00222 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_datetime_field_day/run
class ParallelDatetimeFields:
def run(dti):
dti.day | negative_train_query0_00223 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_datetime_field_daysinmonth
class ParallelDatetimeFields:
def time_datetime_field_daysinmonth(self):
@test_parallel(num_threads=2)
def run(dti):
dti.days_in_month
run(self.dti) | negative_train_query0_00224 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_datetime_field_daysinmonth/run
class ParallelDatetimeFields:
def run(dti):
dti.days_in_month | negative_train_query0_00225 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_datetime_field_normalize
class ParallelDatetimeFields:
def time_datetime_field_normalize(self):
@test_parallel(num_threads=2)
def run(dti):
dti.normalize()
run(self.dti) | negative_train_query0_00226 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_datetime_field_normalize/run
class ParallelDatetimeFields:
def run(dti):
dti.normalize() | negative_train_query0_00227 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_datetime_to_period
class ParallelDatetimeFields:
def time_datetime_to_period(self):
@test_parallel(num_threads=2)
def run(dti):
dti.to_period("s")
run(self.dti) | negative_train_query0_00228 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_datetime_to_period/run
class ParallelDatetimeFields:
def run(dti):
dti.to_period("s") | negative_train_query0_00229 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_period_to_datetime
class ParallelDatetimeFields:
def time_period_to_datetime(self):
@test_parallel(num_threads=2)
def run(period):
period.to_timestamp()
run(self.period) | negative_train_query0_00230 | |
asv_bench/benchmarks/gil.py/ParallelDatetimeFields/time_period_to_datetime/run
class ParallelDatetimeFields:
def run(period):
period.to_timestamp() | negative_train_query0_00231 | |
asv_bench/benchmarks/gil.py/ParallelRolling/setup
class ParallelRolling:
def setup(self, method):
win = 100
arr = np.random.rand(100000)
if hasattr(DataFrame, "rolling"):
df = DataFrame(arr).rolling(win)
@test_parallel(num_threads=2)
def parallel_rolling():
... | negative_train_query0_00232 | |
asv_bench/benchmarks/gil.py/ParallelRolling/setup/parallel_rolling
class ParallelRolling:
def parallel_rolling():
rolling[method](arr, win) | negative_train_query0_00233 | |
asv_bench/benchmarks/gil.py/ParallelRolling/time_rolling
class ParallelRolling:
def time_rolling(self, method):
self.parallel_rolling() | negative_train_query0_00234 | |
asv_bench/benchmarks/gil.py/ParallelReadCSV/setup
class ParallelReadCSV:
def setup(self, dtype):
rows = 10000
cols = 50
if dtype == "float":
df = DataFrame(np.random.randn(rows, cols))
elif dtype == "datetime":
df = DataFrame(
np.random.randn(rows,... | negative_train_query0_00235 | |
asv_bench/benchmarks/gil.py/ParallelReadCSV/setup/parallel_read_csv
class ParallelReadCSV:
def parallel_read_csv():
read_csv(self.fname) | negative_train_query0_00236 | |
asv_bench/benchmarks/gil.py/ParallelReadCSV/time_read_csv
class ParallelReadCSV:
def time_read_csv(self, dtype):
self.parallel_read_csv() | negative_train_query0_00237 | |
asv_bench/benchmarks/gil.py/ParallelFactorize/setup
class ParallelFactorize:
def setup(self, threads):
strings = Index([f"i-{i}" for i in range(100000)], dtype=object)
@test_parallel(num_threads=threads)
def parallel():
factorize(strings)
self.parallel = parallel
d... | negative_train_query0_00238 | |
asv_bench/benchmarks/gil.py/ParallelFactorize/setup/parallel
class ParallelFactorize:
def parallel():
factorize(strings) | negative_train_query0_00239 | |
asv_bench/benchmarks/gil.py/ParallelFactorize/setup/loop
class ParallelFactorize:
def loop():
factorize(strings) | negative_train_query0_00240 | |
asv_bench/benchmarks/gil.py/ParallelFactorize/time_parallel
class ParallelFactorize:
def time_parallel(self, threads):
self.parallel() | negative_train_query0_00241 | |
asv_bench/benchmarks/gil.py/ParallelFactorize/time_loop
class ParallelFactorize:
def time_loop(self, threads):
for i in range(threads):
self.loop() | negative_train_query0_00242 | |
asv_bench/benchmarks/reindex.py/Reindex/setup
class Reindex:
def setup(self):
rng = date_range(start="1/1/1970", periods=10000, freq="1min")
self.df = DataFrame(np.random.rand(10000, 10), index=rng, columns=range(10))
self.df["foo"] = "bar"
self.rng_subset = Index(rng[::2])
self.... | negative_train_query0_00243 | |
asv_bench/benchmarks/reindex.py/Reindex/time_reindex_dates
class Reindex:
def time_reindex_dates(self):
self.df.reindex(self.rng_subset) | negative_train_query0_00244 | |
asv_bench/benchmarks/reindex.py/Reindex/time_reindex_columns
class Reindex:
def time_reindex_columns(self):
self.df2.reindex(columns=self.df.columns[1:5]) | negative_train_query0_00245 | |
asv_bench/benchmarks/reindex.py/Reindex/time_reindex_multiindex_with_cache
class Reindex:
def time_reindex_multiindex_with_cache(self):
# MultiIndex._values gets cached
self.s.reindex(self.s_subset.index) | negative_train_query0_00246 | |
asv_bench/benchmarks/reindex.py/Reindex/time_reindex_multiindex_no_cache
class Reindex:
def time_reindex_multiindex_no_cache(self):
# Copy to avoid MultiIndex._values getting cached
self.s.reindex(self.s_subset_no_cache.index.copy()) | negative_train_query0_00247 | |
asv_bench/benchmarks/reindex.py/Reindex/time_reindex_multiindex_no_cache_dates
class Reindex:
def time_reindex_multiindex_no_cache_dates(self):
# Copy to avoid MultiIndex._values getting cached
self.s2_subset.reindex(self.s2.index.copy()) | negative_train_query0_00248 | |
asv_bench/benchmarks/reindex.py/ReindexMethod/setup
class ReindexMethod:
def setup(self, method, constructor):
N = 100000
self.idx = constructor("1/1/2000", periods=N, freq="1min")
self.ts = Series(np.random.randn(N), index=self.idx)[::2] | negative_train_query0_00249 | |
asv_bench/benchmarks/reindex.py/ReindexMethod/time_reindex_method
class ReindexMethod:
def time_reindex_method(self, method, constructor):
self.ts.reindex(self.idx, method=method) | negative_train_query0_00250 | |
asv_bench/benchmarks/reindex.py/LevelAlign/setup
class LevelAlign:
def setup(self):
self.index = MultiIndex(
levels=[np.arange(10), np.arange(100), np.arange(100)],
codes=[
np.arange(10).repeat(10000),
np.tile(np.arange(100).repeat(100), 10),
... | negative_train_query0_00251 | |
asv_bench/benchmarks/reindex.py/LevelAlign/time_align_level
class LevelAlign:
def time_align_level(self):
self.df.align(self.df_level, level=1, copy=False) | negative_train_query0_00252 | |
asv_bench/benchmarks/reindex.py/LevelAlign/time_reindex_level
class LevelAlign:
def time_reindex_level(self):
self.df_level.reindex(self.index, level=1) | negative_train_query0_00253 | |
asv_bench/benchmarks/reindex.py/DropDuplicates/setup
class DropDuplicates:
def setup(self, inplace):
N = 10000
K = 10
key1 = Index([f"i-{i}" for i in range(N)], dtype=object).values.repeat(K)
key2 = Index([f"i-{i}" for i in range(N)], dtype=object).values.repeat(K)
self.df = Data... | negative_train_query0_00254 | |
asv_bench/benchmarks/reindex.py/DropDuplicates/time_frame_drop_dups
class DropDuplicates:
def time_frame_drop_dups(self, inplace):
self.df.drop_duplicates(["key1", "key2"], inplace=inplace) | negative_train_query0_00255 | |
asv_bench/benchmarks/reindex.py/DropDuplicates/time_frame_drop_dups_na
class DropDuplicates:
def time_frame_drop_dups_na(self, inplace):
self.df_nan.drop_duplicates(["key1", "key2"], inplace=inplace) | negative_train_query0_00256 | |
asv_bench/benchmarks/reindex.py/DropDuplicates/time_series_drop_dups_int
class DropDuplicates:
def time_series_drop_dups_int(self, inplace):
self.s.drop_duplicates(inplace=inplace) | negative_train_query0_00257 | |
asv_bench/benchmarks/reindex.py/DropDuplicates/time_series_drop_dups_string
class DropDuplicates:
def time_series_drop_dups_string(self, inplace):
self.s_str.drop_duplicates(inplace=inplace) | negative_train_query0_00258 | |
asv_bench/benchmarks/reindex.py/DropDuplicates/time_frame_drop_dups_int
class DropDuplicates:
def time_frame_drop_dups_int(self, inplace):
self.df_int.drop_duplicates(inplace=inplace) | negative_train_query0_00259 | |
asv_bench/benchmarks/reindex.py/DropDuplicates/time_frame_drop_dups_bool
class DropDuplicates:
def time_frame_drop_dups_bool(self, inplace):
self.df_bool.drop_duplicates(inplace=inplace) | negative_train_query0_00260 | |
asv_bench/benchmarks/reindex.py/Align/setup
class Align:
def setup(self):
n = 50000
indices = Index([f"i-{i}" for i in range(n)], dtype=object)
subsample_size = 40000
self.x = Series(np.random.randn(n), indices)
self.y = Series(
np.random.randn(subsample_size),
... | negative_train_query0_00261 | |
asv_bench/benchmarks/reindex.py/Align/time_align_series_irregular_string
class Align:
def time_align_series_irregular_string(self):
self.x + self.y | negative_train_query0_00262 | |
asv_bench/benchmarks/rolling.py/Methods/setup
class Methods:
def setup(self, constructor, window_kwargs, dtype, method):
N = 10**5
window, kwargs = window_kwargs
arr = (100 * np.random.random(N)).astype(dtype)
obj = getattr(pd, constructor)(arr)
self.window = getattr(obj, window)... | negative_train_query0_00263 | |
asv_bench/benchmarks/rolling.py/Methods/time_method
class Methods:
def time_method(self, constructor, window_kwargs, dtype, method):
getattr(self.window, method)() | negative_train_query0_00264 | |
asv_bench/benchmarks/rolling.py/Methods/peakmem_method
class Methods:
def peakmem_method(self, constructor, window_kwargs, dtype, method):
getattr(self.window, method)() | negative_train_query0_00265 | |
asv_bench/benchmarks/rolling.py/Apply/setup
class Apply:
def setup(self, constructor, window, dtype, function, raw):
N = 10**3
arr = (100 * np.random.random(N)).astype(dtype)
self.roll = getattr(pd, constructor)(arr).rolling(window) | negative_train_query0_00266 | |
asv_bench/benchmarks/rolling.py/Apply/time_rolling
class Apply:
def time_rolling(self, constructor, window, dtype, function, raw):
self.roll.apply(function, raw=raw) | negative_train_query0_00267 | |
asv_bench/benchmarks/rolling.py/NumbaEngineMethods/setup
class NumbaEngineMethods:
def setup(self, constructor, dtype, window_kwargs, method, parallel, cols):
N = 10**3
window, kwargs = window_kwargs
shape = (N, cols) if cols is not None and constructor != "Series" else N
arr = (100 * np... | negative_train_query0_00268 | |
asv_bench/benchmarks/rolling.py/NumbaEngineMethods/test_method
class NumbaEngineMethods:
def test_method(self, constructor, dtype, window_kwargs, method, parallel, cols):
with warnings.catch_warnings(record=True):
getattr(self.window, method)(
engine="numba", engine_kwargs={"parallel... | negative_train_query0_00269 | |
asv_bench/benchmarks/rolling.py/NumbaEngineApply/setup
class NumbaEngineApply:
def setup(self, constructor, dtype, window_kwargs, function, parallel, cols):
N = 10**3
window, kwargs = window_kwargs
shape = (N, cols) if cols is not None and constructor != "Series" else N
arr = (100 * np.r... | negative_train_query0_00270 | |
asv_bench/benchmarks/rolling.py/NumbaEngineApply/test_method
class NumbaEngineApply:
def test_method(self, constructor, dtype, window_kwargs, function, parallel, cols):
with warnings.catch_warnings(record=True):
self.window.apply(
function, raw=True, engine="numba", engine_kwargs={"p... | negative_train_query0_00271 | |
asv_bench/benchmarks/rolling.py/EWMMethods/setup
class EWMMethods:
def setup(self, constructor, kwargs_method, dtype):
N = 10**5
kwargs, method = kwargs_method
arr = (100 * np.random.random(N)).astype(dtype)
self.method = method
self.ewm = getattr(pd, constructor)(arr).ewm(**kwar... | negative_train_query0_00272 | |
asv_bench/benchmarks/rolling.py/EWMMethods/time_ewm
class EWMMethods:
def time_ewm(self, constructor, kwargs_method, dtype):
getattr(self.ewm, self.method)() | negative_train_query0_00273 | |
asv_bench/benchmarks/rolling.py/VariableWindowMethods/setup
class VariableWindowMethods:
def setup(self, constructor, window, dtype, method):
N = 10**5
arr = (100 * np.random.random(N)).astype(dtype)
index = pd.date_range("2017-01-01", periods=N, freq="5s")
self.window = getattr(pd, cons... | negative_train_query0_00274 | |
asv_bench/benchmarks/rolling.py/Pairwise/setup
class Pairwise:
def setup(self, kwargs_window, method, pairwise):
N = 10**4
n_groups = 20
kwargs, window = kwargs_window
groups = [i for _ in range(N // n_groups) for i in range(n_groups)]
arr = np.random.random(N)
self.df = ... | negative_train_query0_00275 | |
asv_bench/benchmarks/rolling.py/Pairwise/time_pairwise
class Pairwise:
def time_pairwise(self, kwargs_window, method, pairwise):
getattr(self.window, method)(self.df, pairwise=pairwise) | negative_train_query0_00276 | |
asv_bench/benchmarks/rolling.py/Pairwise/time_groupby
class Pairwise:
def time_groupby(self, kwargs_window, method, pairwise):
getattr(self.window_group, method)(self.df, pairwise=pairwise) | negative_train_query0_00277 | |
asv_bench/benchmarks/rolling.py/Quantile/setup
class Quantile:
def setup(self, constructor, window, dtype, percentile, interpolation):
N = 10**5
arr = np.random.random(N).astype(dtype)
self.roll = getattr(pd, constructor)(arr).rolling(window) | negative_train_query0_00278 | |
asv_bench/benchmarks/rolling.py/Quantile/time_quantile
class Quantile:
def time_quantile(self, constructor, window, dtype, percentile, interpolation):
self.roll.quantile(percentile, interpolation=interpolation) | negative_train_query0_00279 | |
asv_bench/benchmarks/rolling.py/Rank/setup
class Rank:
def setup(self, constructor, window, dtype, percentile, ascending, method):
N = 10**5
arr = np.random.random(N).astype(dtype)
self.roll = getattr(pd, constructor)(arr).rolling(window) | negative_train_query0_00280 | |
asv_bench/benchmarks/rolling.py/Rank/time_rank
class Rank:
def time_rank(self, constructor, window, dtype, percentile, ascending, method):
self.roll.rank(pct=percentile, ascending=ascending, method=method) | negative_train_query0_00281 | |
asv_bench/benchmarks/rolling.py/PeakMemFixedWindowMinMax/setup
class PeakMemFixedWindowMinMax:
def setup(self, operation):
N = 10**6
arr = np.random.random(N)
self.roll = pd.Series(arr).rolling(2) | negative_train_query0_00282 | |
asv_bench/benchmarks/rolling.py/PeakMemFixedWindowMinMax/peakmem_fixed
class PeakMemFixedWindowMinMax:
def peakmem_fixed(self, operation):
for x in range(5):
getattr(self.roll, operation)() | negative_train_query0_00283 | |
asv_bench/benchmarks/rolling.py/ForwardWindowMethods/setup
class ForwardWindowMethods:
def setup(self, constructor, window_size, dtype, method):
N = 10**5
arr = np.random.random(N).astype(dtype)
indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=window_size)
self.roll = geta... | negative_train_query0_00284 | |
asv_bench/benchmarks/rolling.py/ForwardWindowMethods/time_rolling
class ForwardWindowMethods:
def time_rolling(self, constructor, window_size, dtype, method):
getattr(self.roll, method)() | negative_train_query0_00285 | |
asv_bench/benchmarks/rolling.py/ForwardWindowMethods/peakmem_rolling
class ForwardWindowMethods:
def peakmem_rolling(self, constructor, window_size, dtype, method):
getattr(self.roll, method)() | negative_train_query0_00286 | |
asv_bench/benchmarks/rolling.py/Groupby/setup
class Groupby:
def setup(self, method, window_kwargs):
N = 1000
window, kwargs = window_kwargs
df = pd.DataFrame(
{
"A": [str(i) for i in range(N)] * 10,
"B": list(range(N)) * 10,
}
)
... | negative_train_query0_00287 | |
asv_bench/benchmarks/rolling.py/Groupby/time_method
class Groupby:
def time_method(self, method, window_kwargs):
getattr(self.groupby_window, method)() | negative_train_query0_00288 | |
asv_bench/benchmarks/rolling.py/GroupbyLargeGroups/setup
class GroupbyLargeGroups:
def setup(self):
N = 100000
self.df = pd.DataFrame({"A": [1, 2] * (N // 2), "B": np.random.randn(N)}) | negative_train_query0_00289 | |
asv_bench/benchmarks/rolling.py/GroupbyLargeGroups/time_rolling_multiindex_creation
class GroupbyLargeGroups:
def time_rolling_multiindex_creation(self):
self.df.groupby("A").rolling(3).mean() | negative_train_query0_00290 | |
asv_bench/benchmarks/rolling.py/GroupbyEWM/setup
class GroupbyEWM:
def setup(self, method):
df = pd.DataFrame({"A": range(50), "B": range(50)})
self.gb_ewm = df.groupby("A").ewm(com=1.0) | negative_train_query0_00291 | |
asv_bench/benchmarks/rolling.py/GroupbyEWM/time_groupby_method
class GroupbyEWM:
def time_groupby_method(self, method):
getattr(self.gb_ewm, method)() | negative_train_query0_00292 | |
asv_bench/benchmarks/rolling.py/GroupbyEWMEngine/setup
class GroupbyEWMEngine:
def setup(self, engine):
df = pd.DataFrame({"A": range(50), "B": range(50)})
self.gb_ewm = df.groupby("A").ewm(com=1.0) | negative_train_query0_00293 | |
asv_bench/benchmarks/rolling.py/GroupbyEWMEngine/time_groupby_mean
class GroupbyEWMEngine:
def time_groupby_mean(self, engine):
self.gb_ewm.mean(engine=engine) | negative_train_query0_00294 | |
asv_bench/benchmarks/rolling.py/table_method_func
def table_method_func(x):
return np.sum(x, axis=0) + 1 | negative_train_query0_00295 | |
asv_bench/benchmarks/rolling.py/TableMethod/setup
class TableMethod:
def setup(self, method):
self.df = pd.DataFrame(np.random.randn(10, 1000)) | negative_train_query0_00296 | |
asv_bench/benchmarks/rolling.py/TableMethod/time_apply
class TableMethod:
def time_apply(self, method):
self.df.rolling(2, method=method).apply(
table_method_func, raw=True, engine="numba"
) | negative_train_query0_00297 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.