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 dicts, optional
The list of kwargs to update original
function kwargs on different threads.
Notes
-----
This decorator does not pass the return value of the decorated function.
Original from scikit-image:
https://github.com/scikit-image/scikit-image/pull/1519
"""
assert num_threads > 0
has_kwargs_list = kwargs_list is not None
if has_kwargs_list:
assert len(kwargs_list) == num_threads
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
threads = []
for i in range(num_threads):
updated_kwargs = update_kwargs(i)
thread = threading.Thread(target=func, args=args, kwargs=updated_kwargs)
threads.append(thread)
for thread in threads:
thread.start()
for thread in threads:
thread.join()
return inner
return wrapper
|
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
threads = []
for i in range(num_threads):
updated_kwargs = update_kwargs(i)
thread = threading.Thread(target=func, args=args, kwargs=updated_kwargs)
threads.append(thread)
for thread in threads:
thread.start()
for thread in threads:
thread.join()
return inner
|
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 in range(num_threads):
updated_kwargs = update_kwargs(i)
thread = threading.Thread(target=func, args=args, kwargs=updated_kwargs)
threads.append(thread)
for thread in threads:
thread.start()
for thread in threads:
thread.join()
|
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=threads)
def parallel():
getattr(df.groupby("key")["data"], method)()
self.parallel = parallel
def loop():
getattr(df.groupby("key")["data"], method)()
self.loop = loop
|
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
self.get_groups = get_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"].values, indexer)
self.parallel_take1d = parallel_take1d
|
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):
algos.kth_smallest(arr, k)
self.parallel_kth_smallest = parallel_kth_smallest
|
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():
getattr(df, method)()
self.parallel_rolling = parallel_rolling
elif have_rolling_methods:
rolling = {
"median": rolling_median,
"mean": rolling_mean,
"min": rolling_min,
"max": rolling_max,
"var": rolling_var,
"skew": rolling_skew,
"kurt": rolling_kurt,
"std": rolling_std,
}
@test_parallel(num_threads=2)
def parallel_rolling():
rolling[method](arr, win)
self.parallel_rolling = parallel_rolling
else:
raise NotImplementedError
|
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, cols), index=date_range("1/1/2000", periods=rows)
)
elif dtype == "object":
df = DataFrame(
"foo", index=range(rows), columns=["object%03d" for _ in range(5)]
)
else:
raise NotImplementedError
self.fname = f"__test_{dtype}__.csv"
df.to_csv(self.fname)
@test_parallel(num_threads=2)
def parallel_read_csv():
read_csv(self.fname)
self.parallel_read_csv = parallel_read_csv
|
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
def loop():
factorize(strings)
self.loop = loop
|
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.df2 = DataFrame(
index=range(10000), data=np.random.rand(10000, 30), columns=range(30)
)
N = 5000
K = 200
level1 = Index([f"i-{i}" for i in range(N)], dtype=object).values.repeat(K)
level2 = np.tile(Index([f"i-{i}" for i in range(K)], dtype=object).values, N)
index = MultiIndex.from_arrays([level1, level2])
self.s = Series(np.random.randn(N * K), index=index)
self.s_subset = self.s[::2]
self.s_subset_no_cache = self.s[::2].copy()
mi = MultiIndex.from_product([rng, range(100)])
self.s2 = Series(np.random.randn(len(mi)), index=mi)
self.s2_subset = self.s2[::2].copy()
|
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),
np.tile(np.tile(np.arange(100), 100), 10),
],
)
self.df = DataFrame(np.random.randn(len(self.index), 4), index=self.index)
self.df_level = DataFrame(np.random.randn(100, 4), index=self.index.levels[1])
|
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 = DataFrame(
{"key1": key1, "key2": key2, "value": np.random.randn(N * K)}
)
self.df_nan = self.df.copy()
self.df_nan.iloc[:10000, :] = np.nan
self.s = Series(np.random.randint(0, 1000, size=10000))
self.s_str = Series(
np.tile(Index([f"i-{i}" for i in range(1000)], dtype=object).values, 10)
)
N = 1000000
K = 10000
key1 = np.random.randint(0, K, size=N)
self.df_int = DataFrame({"key1": key1})
self.df_bool = DataFrame(np.random.randint(0, 2, size=(K, 10), dtype=bool))
|
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),
index=np.random.choice(indices, subsample_size, replace=False),
)
|
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)(**kwargs)
|
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.random.random(shape)).astype(dtype)
data = getattr(pd, constructor)(arr)
# Warm the cache
with warnings.catch_warnings(record=True):
# Catch parallel=True not being applicable e.g. 1D data
self.window = getattr(data, window)(**kwargs)
getattr(self.window, method)(
engine="numba", engine_kwargs={"parallel": parallel}
)
|
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": 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.random.random(shape)).astype(dtype)
data = getattr(pd, constructor)(arr)
# Warm the cache
with warnings.catch_warnings(record=True):
# Catch parallel=True not being applicable e.g. 1D data
self.window = getattr(data, window)(**kwargs)
self.window.apply(
function, raw=True, engine="numba", engine_kwargs={"parallel": parallel}
)
|
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={"parallel": parallel}
)
|
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(**kwargs)
|
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, constructor)(arr, index=index).rolling(window)
|
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 = pd.DataFrame(arr)
self.window = getattr(self.df, window)(**kwargs)
self.window_group = getattr(
pd.DataFrame({"A": groups, "B": arr}).groupby("A"), window
)(**kwargs)
|
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 = getattr(pd, constructor)(arr).rolling(window=indexer)
|
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,
}
)
if isinstance(kwargs.get("window", None), str):
df.index = pd.date_range(start="1900-01-01", freq="1min", periods=N * 10)
self.groupby_window = getattr(df.groupby("A"), window)(**kwargs)
|
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.