title stringclasses 1 value | text stringlengths 30 426k | id stringlengths 27 30 |
|---|---|---|
asv_bench/benchmarks/indexing.py/DataFrameStringIndexing/time_at_setitem
class DataFrameStringIndexing:
def time_at_setitem(self):
self.df.at[self.idx_scalar, self.col_scalar] = 0.0 | negative_train_query0_00698 | |
asv_bench/benchmarks/indexing.py/DataFrameStringIndexing/time_getitem_scalar
class DataFrameStringIndexing:
def time_getitem_scalar(self):
self.df[self.col_scalar][self.idx_scalar] | negative_train_query0_00699 | |
asv_bench/benchmarks/indexing.py/DataFrameStringIndexing/time_boolean_rows
class DataFrameStringIndexing:
def time_boolean_rows(self):
self.df[self.bool_indexer] | negative_train_query0_00700 | |
asv_bench/benchmarks/indexing.py/DataFrameStringIndexing/time_boolean_rows_object
class DataFrameStringIndexing:
def time_boolean_rows_object(self):
self.df[self.bool_obj_indexer] | negative_train_query0_00701 | |
asv_bench/benchmarks/indexing.py/DataFrameStringIndexing/time_boolean_rows_boolean
class DataFrameStringIndexing:
def time_boolean_rows_boolean(self):
self.df[self.boolean_indexer] | negative_train_query0_00702 | |
asv_bench/benchmarks/indexing.py/DataFrameNumericIndexing/setup
class DataFrameNumericIndexing:
def setup(self, dtype, index_structure):
N = 10**5
indices = {
"unique_monotonic_inc": Index(range(N), dtype=dtype),
"nonunique_monotonic_inc": Index(
list(range(55)) + [54] + list(range(55, N - 1)), dtype=dtype
),
}
self.idx_dupe = np.array(range(30)) * 99
self.df = DataFrame(np.random.randn(N, 5), index=indices[index_structure])
self.df_dup = concat([self.df, 2 * self.df, 3 * self.df])
self.bool_indexer = [True] * (N // 2) + [False] * (N - N // 2) | negative_train_query0_00703 | |
asv_bench/benchmarks/indexing.py/DataFrameNumericIndexing/time_iloc_dups
class DataFrameNumericIndexing:
def time_iloc_dups(self, index, index_structure):
self.df_dup.iloc[self.idx_dupe] | negative_train_query0_00704 | |
asv_bench/benchmarks/indexing.py/DataFrameNumericIndexing/time_loc_dups
class DataFrameNumericIndexing:
def time_loc_dups(self, index, index_structure):
self.df_dup.loc[self.idx_dupe] | negative_train_query0_00705 | |
asv_bench/benchmarks/indexing.py/DataFrameNumericIndexing/time_iloc
class DataFrameNumericIndexing:
def time_iloc(self, index, index_structure):
self.df.iloc[:100, 0] | negative_train_query0_00706 | |
asv_bench/benchmarks/indexing.py/DataFrameNumericIndexing/time_loc
class DataFrameNumericIndexing:
def time_loc(self, index, index_structure):
self.df.loc[:100, 0] | negative_train_query0_00707 | |
asv_bench/benchmarks/indexing.py/DataFrameNumericIndexing/time_bool_indexer
class DataFrameNumericIndexing:
def time_bool_indexer(self, index, index_structure):
self.df[self.bool_indexer] | negative_train_query0_00708 | |
asv_bench/benchmarks/indexing.py/Take/setup
class Take:
def setup(self, index):
N = 100000
indexes = {
"int": Index(np.arange(N), dtype=np.int64),
"datetime": date_range("2011-01-01", freq="s", periods=N),
}
index = indexes[index]
self.s = Series(np.random.rand(N), index=index)
self.indexer = np.random.randint(0, N, size=N) | negative_train_query0_00709 | |
asv_bench/benchmarks/indexing.py/Take/time_take
class Take:
def time_take(self, index):
self.s.take(self.indexer) | negative_train_query0_00710 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/setup
class MultiIndexing:
def setup(self, unique_levels):
self.nlevels = 2
if unique_levels:
mi = MultiIndex.from_arrays([range(1000000)] * self.nlevels)
else:
mi = MultiIndex.from_product([range(1000)] * self.nlevels)
self.df = DataFrame(np.random.randn(len(mi)), index=mi)
self.tgt_slice = slice(200, 800)
self.tgt_null_slice = slice(None)
self.tgt_list = list(range(0, 1000, 10))
self.tgt_scalar = 500
bool_indexer = np.zeros(len(mi), dtype=np.bool_)
bool_indexer[slice(0, len(mi), 100)] = True
self.tgt_bool_indexer = bool_indexer | negative_train_query0_00711 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_partial_key_slice
class MultiIndexing:
def time_loc_partial_key_slice(self, unique_levels):
self.df.loc[self.tgt_slice, :] | negative_train_query0_00712 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_partial_key_null_slice
class MultiIndexing:
def time_loc_partial_key_null_slice(self, unique_levels):
self.df.loc[self.tgt_null_slice, :] | negative_train_query0_00713 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_partial_key_list
class MultiIndexing:
def time_loc_partial_key_list(self, unique_levels):
self.df.loc[self.tgt_list, :] | negative_train_query0_00714 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_partial_key_scalar
class MultiIndexing:
def time_loc_partial_key_scalar(self, unique_levels):
self.df.loc[self.tgt_scalar, :] | negative_train_query0_00715 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_partial_key_bool_indexer
class MultiIndexing:
def time_loc_partial_key_bool_indexer(self, unique_levels):
self.df.loc[self.tgt_bool_indexer, :] | negative_train_query0_00716 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_all_slices
class MultiIndexing:
def time_loc_all_slices(self, unique_levels):
target = tuple([self.tgt_slice] * self.nlevels)
self.df.loc[target, :] | negative_train_query0_00717 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_all_null_slices
class MultiIndexing:
def time_loc_all_null_slices(self, unique_levels):
target = tuple([self.tgt_null_slice] * self.nlevels)
self.df.loc[target, :] | negative_train_query0_00718 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_all_lists
class MultiIndexing:
def time_loc_all_lists(self, unique_levels):
target = tuple([self.tgt_list] * self.nlevels)
self.df.loc[target, :] | negative_train_query0_00719 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_all_scalars
class MultiIndexing:
def time_loc_all_scalars(self, unique_levels):
target = tuple([self.tgt_scalar] * self.nlevels)
self.df.loc[target, :] | negative_train_query0_00720 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_all_bool_indexers
class MultiIndexing:
def time_loc_all_bool_indexers(self, unique_levels):
target = tuple([self.tgt_bool_indexer] * self.nlevels)
self.df.loc[target, :] | negative_train_query0_00721 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_slice_plus_null_slice
class MultiIndexing:
def time_loc_slice_plus_null_slice(self, unique_levels):
target = (self.tgt_slice, self.tgt_null_slice)
self.df.loc[target, :] | negative_train_query0_00722 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_null_slice_plus_slice
class MultiIndexing:
def time_loc_null_slice_plus_slice(self, unique_levels):
target = (self.tgt_null_slice, self.tgt_slice)
self.df.loc[target, :] | negative_train_query0_00723 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_loc_multiindex
class MultiIndexing:
def time_loc_multiindex(self, unique_levels):
target = self.df.index[::10]
self.df.loc[target] | negative_train_query0_00724 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_xs_level_0
class MultiIndexing:
def time_xs_level_0(self, unique_levels):
target = self.tgt_scalar
self.df.xs(target, level=0) | negative_train_query0_00725 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_xs_level_1
class MultiIndexing:
def time_xs_level_1(self, unique_levels):
target = self.tgt_scalar
self.df.xs(target, level=1) | negative_train_query0_00726 | |
asv_bench/benchmarks/indexing.py/MultiIndexing/time_xs_full_key
class MultiIndexing:
def time_xs_full_key(self, unique_levels):
target = tuple([self.tgt_scalar] * self.nlevels)
self.df.xs(target) | negative_train_query0_00727 | |
asv_bench/benchmarks/indexing.py/IntervalIndexing/setup_cache
class IntervalIndexing:
def setup_cache(self):
idx = IntervalIndex.from_breaks(np.arange(1000001))
monotonic = Series(np.arange(1000000), index=idx)
return monotonic | negative_train_query0_00728 | |
asv_bench/benchmarks/indexing.py/IntervalIndexing/time_getitem_scalar
class IntervalIndexing:
def time_getitem_scalar(self, monotonic):
monotonic[80000] | negative_train_query0_00729 | |
asv_bench/benchmarks/indexing.py/IntervalIndexing/time_loc_scalar
class IntervalIndexing:
def time_loc_scalar(self, monotonic):
monotonic.loc[80000] | negative_train_query0_00730 | |
asv_bench/benchmarks/indexing.py/IntervalIndexing/time_getitem_list
class IntervalIndexing:
def time_getitem_list(self, monotonic):
monotonic[80000:] | negative_train_query0_00731 | |
asv_bench/benchmarks/indexing.py/IntervalIndexing/time_loc_list
class IntervalIndexing:
def time_loc_list(self, monotonic):
monotonic.loc[80000:] | negative_train_query0_00732 | |
asv_bench/benchmarks/indexing.py/DatetimeIndexIndexing/setup
class DatetimeIndexIndexing:
def setup(self):
dti = date_range("2016-01-01", periods=10000, tz="US/Pacific")
dti2 = dti.tz_convert("UTC")
self.dti = dti
self.dti2 = dti2 | negative_train_query0_00733 | |
asv_bench/benchmarks/indexing.py/DatetimeIndexIndexing/time_get_indexer_mismatched_tz
class DatetimeIndexIndexing:
def time_get_indexer_mismatched_tz(self):
# reached via e.g.
# ser = Series(range(len(dti)), index=dti)
# ser[dti2]
self.dti.get_indexer(self.dti2) | negative_train_query0_00734 | |
asv_bench/benchmarks/indexing.py/SortedAndUnsortedDatetimeIndexLoc/setup
class SortedAndUnsortedDatetimeIndexLoc:
def setup(self):
dti = date_range("2016-01-01", periods=10000, tz="US/Pacific")
index = np.array(dti)
unsorted_index = index.copy()
unsorted_index[10] = unsorted_index[20]
self.df_unsorted = DataFrame(index=unsorted_index, data={"a": 1})
self.df_sort = DataFrame(index=index, data={"a": 1}) | negative_train_query0_00735 | |
asv_bench/benchmarks/indexing.py/SortedAndUnsortedDatetimeIndexLoc/time_loc_unsorted
class SortedAndUnsortedDatetimeIndexLoc:
def time_loc_unsorted(self):
self.df_unsorted.loc["2016-6-11"] | negative_train_query0_00736 | |
asv_bench/benchmarks/indexing.py/SortedAndUnsortedDatetimeIndexLoc/time_loc_sorted
class SortedAndUnsortedDatetimeIndexLoc:
def time_loc_sorted(self):
self.df_sort.loc["2016-6-11"] | negative_train_query0_00737 | |
asv_bench/benchmarks/indexing.py/CategoricalIndexIndexing/setup
class CategoricalIndexIndexing:
def setup(self, index):
N = 10**5
values = list("a" * N + "b" * N + "c" * N)
indices = {
"monotonic_incr": CategoricalIndex(values),
"monotonic_decr": CategoricalIndex(reversed(values)),
"non_monotonic": CategoricalIndex(list("abc" * N)),
}
self.data = indices[index]
self.data_unique = CategoricalIndex([str(i) for i in range(N * 3)])
self.int_scalar = 10000
self.int_list = list(range(10000))
self.cat_scalar = "b"
self.cat_list = ["1", "3"] | negative_train_query0_00738 | |
asv_bench/benchmarks/indexing.py/CategoricalIndexIndexing/time_getitem_scalar
class CategoricalIndexIndexing:
def time_getitem_scalar(self, index):
self.data[self.int_scalar] | negative_train_query0_00739 | |
asv_bench/benchmarks/indexing.py/CategoricalIndexIndexing/time_getitem_slice
class CategoricalIndexIndexing:
def time_getitem_slice(self, index):
self.data[: self.int_scalar] | negative_train_query0_00740 | |
asv_bench/benchmarks/indexing.py/CategoricalIndexIndexing/time_getitem_list_like
class CategoricalIndexIndexing:
def time_getitem_list_like(self, index):
self.data[[self.int_scalar]] | negative_train_query0_00741 | |
asv_bench/benchmarks/indexing.py/CategoricalIndexIndexing/time_getitem_list
class CategoricalIndexIndexing:
def time_getitem_list(self, index):
self.data[self.int_list] | negative_train_query0_00742 | |
asv_bench/benchmarks/indexing.py/CategoricalIndexIndexing/time_getitem_bool_array
class CategoricalIndexIndexing:
def time_getitem_bool_array(self, index):
self.data[self.data == self.cat_scalar] | negative_train_query0_00743 | |
asv_bench/benchmarks/indexing.py/CategoricalIndexIndexing/time_get_loc_scalar
class CategoricalIndexIndexing:
def time_get_loc_scalar(self, index):
self.data.get_loc(self.cat_scalar) | negative_train_query0_00744 | |
asv_bench/benchmarks/indexing.py/CategoricalIndexIndexing/time_get_indexer_list
class CategoricalIndexIndexing:
def time_get_indexer_list(self, index):
self.data_unique.get_indexer(self.cat_list) | negative_train_query0_00745 | |
asv_bench/benchmarks/indexing.py/MethodLookup/setup_cache
class MethodLookup:
def setup_cache(self):
s = Series()
return s | negative_train_query0_00746 | |
asv_bench/benchmarks/indexing.py/MethodLookup/time_lookup_iloc
class MethodLookup:
def time_lookup_iloc(self, s):
s.iloc | negative_train_query0_00747 | |
asv_bench/benchmarks/indexing.py/MethodLookup/time_lookup_loc
class MethodLookup:
def time_lookup_loc(self, s):
s.loc | negative_train_query0_00748 | |
asv_bench/benchmarks/indexing.py/GetItemSingleColumn/setup
class GetItemSingleColumn:
def setup(self):
self.df_string_col = DataFrame(np.random.randn(3000, 1), columns=["A"])
self.df_int_col = DataFrame(np.random.randn(3000, 1)) | negative_train_query0_00749 | |
asv_bench/benchmarks/indexing.py/GetItemSingleColumn/time_frame_getitem_single_column_label
class GetItemSingleColumn:
def time_frame_getitem_single_column_label(self):
self.df_string_col["A"] | negative_train_query0_00750 | |
asv_bench/benchmarks/indexing.py/GetItemSingleColumn/time_frame_getitem_single_column_int
class GetItemSingleColumn:
def time_frame_getitem_single_column_int(self):
self.df_int_col[0] | negative_train_query0_00751 | |
asv_bench/benchmarks/indexing.py/IndexSingleRow/setup
class IndexSingleRow:
def setup(self, unique_cols):
arr = np.arange(10**7).reshape(-1, 10)
df = DataFrame(arr)
dtypes = ["u1", "u2", "u4", "u8", "i1", "i2", "i4", "i8", "f8", "f4"]
for i, d in enumerate(dtypes):
df[i] = df[i].astype(d)
if not unique_cols:
# GH#33032 single-row lookups with non-unique columns were
# 15x slower than with unique columns
df.columns = ["A", "A"] + list(df.columns[2:])
self.df = df | negative_train_query0_00752 | |
asv_bench/benchmarks/indexing.py/IndexSingleRow/time_iloc_row
class IndexSingleRow:
def time_iloc_row(self, unique_cols):
self.df.iloc[10000] | negative_train_query0_00753 | |
asv_bench/benchmarks/indexing.py/IndexSingleRow/time_loc_row
class IndexSingleRow:
def time_loc_row(self, unique_cols):
self.df.loc[10000] | negative_train_query0_00754 | |
asv_bench/benchmarks/indexing.py/AssignTimeseriesIndex/setup
class AssignTimeseriesIndex:
def setup(self):
N = 100000
idx = date_range("1/1/2000", periods=N, freq="h")
self.df = DataFrame(np.random.randn(N, 1), columns=["A"], index=idx) | negative_train_query0_00755 | |
asv_bench/benchmarks/indexing.py/AssignTimeseriesIndex/time_frame_assign_timeseries_index
class AssignTimeseriesIndex:
def time_frame_assign_timeseries_index(self):
self.df["date"] = self.df.index | negative_train_query0_00756 | |
asv_bench/benchmarks/indexing.py/InsertColumns/setup
class InsertColumns:
def setup(self):
self.N = 10**3
self.df = DataFrame(index=range(self.N))
self.df2 = DataFrame(np.random.randn(self.N, 2)) | negative_train_query0_00757 | |
asv_bench/benchmarks/indexing.py/InsertColumns/time_insert
class InsertColumns:
def time_insert(self):
for i in range(100):
self.df.insert(0, i, np.random.randn(self.N), allow_duplicates=True) | negative_train_query0_00758 | |
asv_bench/benchmarks/indexing.py/InsertColumns/time_insert_middle
class InsertColumns:
def time_insert_middle(self):
# same as time_insert but inserting to a middle column rather than
# front or back (which have fast-paths)
for i in range(100):
self.df2.insert(
1, "colname", np.random.randn(self.N), allow_duplicates=True
) | negative_train_query0_00759 | |
asv_bench/benchmarks/indexing.py/InsertColumns/time_assign_with_setitem
class InsertColumns:
def time_assign_with_setitem(self):
for i in range(100):
self.df[i] = np.random.randn(self.N) | negative_train_query0_00760 | |
asv_bench/benchmarks/indexing.py/InsertColumns/time_assign_list_like_with_setitem
class InsertColumns:
def time_assign_list_like_with_setitem(self):
self.df[list(range(100))] = np.random.randn(self.N, 100) | negative_train_query0_00761 | |
asv_bench/benchmarks/indexing.py/InsertColumns/time_assign_list_of_columns_concat
class InsertColumns:
def time_assign_list_of_columns_concat(self):
df = DataFrame(np.random.randn(self.N, 100))
concat([self.df, df], axis=1) | negative_train_query0_00762 | |
asv_bench/benchmarks/indexing.py/Setitem/setup
class Setitem:
def setup(self):
N = 500_000
cols = 500
self.df = DataFrame(np.random.rand(N, cols)) | negative_train_query0_00763 | |
asv_bench/benchmarks/indexing.py/Setitem/time_setitem
class Setitem:
def time_setitem(self):
self.df[100] = 100 | negative_train_query0_00764 | |
asv_bench/benchmarks/indexing.py/Setitem/time_setitem_list
class Setitem:
def time_setitem_list(self):
self.df[[100, 200, 300]] = 100 | negative_train_query0_00765 | |
asv_bench/benchmarks/indexing.py/SetitemObjectDtype/setup
class SetitemObjectDtype:
def setup(self):
N = 1000
cols = 500
self.df = DataFrame(index=range(N), columns=range(cols), dtype=object) | negative_train_query0_00766 | |
asv_bench/benchmarks/indexing.py/SetitemObjectDtype/time_setitem_object_dtype
class SetitemObjectDtype:
def time_setitem_object_dtype(self):
self.df.loc[0, 1] = 1.0 | negative_train_query0_00767 | |
asv_bench/benchmarks/indexing.py/ChainIndexing/setup
class ChainIndexing:
def setup(self, mode):
self.N = 1000000
self.df = DataFrame({"A": np.arange(self.N), "B": "foo"}) | negative_train_query0_00768 | |
asv_bench/benchmarks/indexing.py/ChainIndexing/time_chained_indexing
class ChainIndexing:
def time_chained_indexing(self, mode):
df = self.df
N = self.N
with warnings.catch_warnings(record=True):
with option_context("mode.chained_assignment", mode):
df2 = df[df.A > N // 2]
df2["C"] = 1.0 | negative_train_query0_00769 | |
asv_bench/benchmarks/indexing.py/Block/setup
class Block:
def setup(self):
self.df = DataFrame(
False,
columns=np.arange(500).astype(str),
index=date_range("2010-01-01", "2011-01-01"),
) | negative_train_query0_00770 | |
asv_bench/benchmarks/indexing.py/Block/time_test
class Block:
def time_test(self):
start = datetime(2010, 5, 1)
end = datetime(2010, 9, 1)
self.df.loc[start:end, :] = True | negative_train_query0_00771 | |
asv_bench/benchmarks/sparse.py/make_array
def make_array(size, dense_proportion, fill_value, dtype):
dense_size = int(size * dense_proportion)
arr = np.full(size, fill_value, dtype)
indexer = np.random.choice(np.arange(size), dense_size, replace=False)
arr[indexer] = np.random.choice(np.arange(100, dtype=dtype), dense_size)
return arr | negative_train_query0_00772 | |
asv_bench/benchmarks/sparse.py/SparseSeriesToFrame/setup
class SparseSeriesToFrame:
def setup(self):
K = 50
N = 50001
rng = date_range("1/1/2000", periods=N, freq="min")
self.series = {}
for i in range(1, K):
data = np.random.randn(N)[:-i]
idx = rng[:-i]
data[100:] = np.nan
self.series[i] = Series(SparseArray(data), index=idx) | negative_train_query0_00773 | |
asv_bench/benchmarks/sparse.py/SparseSeriesToFrame/time_series_to_frame
class SparseSeriesToFrame:
def time_series_to_frame(self):
pd.DataFrame(self.series) | negative_train_query0_00774 | |
asv_bench/benchmarks/sparse.py/SparseArrayConstructor/setup
class SparseArrayConstructor:
def setup(self, dense_proportion, fill_value, dtype):
N = 10**6
self.array = make_array(N, dense_proportion, fill_value, dtype) | negative_train_query0_00775 | |
asv_bench/benchmarks/sparse.py/SparseArrayConstructor/time_sparse_array
class SparseArrayConstructor:
def time_sparse_array(self, dense_proportion, fill_value, dtype):
SparseArray(self.array, fill_value=fill_value, dtype=dtype) | negative_train_query0_00776 | |
asv_bench/benchmarks/sparse.py/SparseDataFrameConstructor/setup
class SparseDataFrameConstructor:
def setup(self):
N = 1000
self.sparse = scipy.sparse.rand(N, N, 0.005) | negative_train_query0_00777 | |
asv_bench/benchmarks/sparse.py/SparseDataFrameConstructor/time_from_scipy
class SparseDataFrameConstructor:
def time_from_scipy(self):
pd.DataFrame.sparse.from_spmatrix(self.sparse) | negative_train_query0_00778 | |
asv_bench/benchmarks/sparse.py/FromCoo/setup
class FromCoo:
def setup(self):
self.matrix = scipy.sparse.coo_matrix(
([3.0, 1.0, 2.0], ([1, 0, 0], [0, 2, 3])), shape=(100, 100)
) | negative_train_query0_00779 | |
asv_bench/benchmarks/sparse.py/FromCoo/time_sparse_series_from_coo
class FromCoo:
def time_sparse_series_from_coo(self):
Series.sparse.from_coo(self.matrix) | negative_train_query0_00780 | |
asv_bench/benchmarks/sparse.py/ToCoo/setup
class ToCoo:
def setup(self, sort_labels):
s = Series([np.nan] * 10000)
s[0] = 3.0
s[100] = -1.0
s[999] = 12.1
s_mult_lvl = s.set_axis(MultiIndex.from_product([range(10)] * 4))
self.ss_mult_lvl = s_mult_lvl.astype("Sparse")
s_two_lvl = s.set_axis(MultiIndex.from_product([range(100)] * 2))
self.ss_two_lvl = s_two_lvl.astype("Sparse") | negative_train_query0_00781 | |
asv_bench/benchmarks/sparse.py/ToCoo/time_sparse_series_to_coo
class ToCoo:
def time_sparse_series_to_coo(self, sort_labels):
self.ss_mult_lvl.sparse.to_coo(
row_levels=[0, 1], column_levels=[2, 3], sort_labels=sort_labels
) | negative_train_query0_00782 | |
asv_bench/benchmarks/sparse.py/ToCoo/time_sparse_series_to_coo_single_level
class ToCoo:
def time_sparse_series_to_coo_single_level(self, sort_labels):
self.ss_two_lvl.sparse.to_coo(sort_labels=sort_labels) | negative_train_query0_00783 | |
asv_bench/benchmarks/sparse.py/ToCooFrame/setup
class ToCooFrame:
def setup(self):
N = 10000
k = 10
arr = np.zeros((N, k), dtype=float)
arr[0, 0] = 3.0
arr[12, 7] = -1.0
arr[0, 9] = 11.2
self.df = pd.DataFrame(arr, dtype=pd.SparseDtype("float", fill_value=0.0)) | negative_train_query0_00784 | |
asv_bench/benchmarks/sparse.py/ToCooFrame/time_to_coo
class ToCooFrame:
def time_to_coo(self):
self.df.sparse.to_coo() | negative_train_query0_00785 | |
asv_bench/benchmarks/sparse.py/Arithmetic/setup
class Arithmetic:
def setup(self, dense_proportion, fill_value):
N = 10**6
arr1 = make_array(N, dense_proportion, fill_value, np.int64)
self.array1 = SparseArray(arr1, fill_value=fill_value)
arr2 = make_array(N, dense_proportion, fill_value, np.int64)
self.array2 = SparseArray(arr2, fill_value=fill_value) | negative_train_query0_00786 | |
asv_bench/benchmarks/sparse.py/Arithmetic/time_make_union
class Arithmetic:
def time_make_union(self, dense_proportion, fill_value):
self.array1.sp_index.make_union(self.array2.sp_index) | negative_train_query0_00787 | |
asv_bench/benchmarks/sparse.py/Arithmetic/time_intersect
class Arithmetic:
def time_intersect(self, dense_proportion, fill_value):
self.array1.sp_index.intersect(self.array2.sp_index) | negative_train_query0_00788 | |
asv_bench/benchmarks/sparse.py/Arithmetic/time_add
class Arithmetic:
def time_add(self, dense_proportion, fill_value):
self.array1 + self.array2 | negative_train_query0_00789 | |
asv_bench/benchmarks/sparse.py/Arithmetic/time_divide
class Arithmetic:
def time_divide(self, dense_proportion, fill_value):
self.array1 / self.array2 | negative_train_query0_00790 | |
asv_bench/benchmarks/sparse.py/ArithmeticBlock/setup
class ArithmeticBlock:
def setup(self, fill_value):
N = 10**6
self.arr1 = self.make_block_array(
length=N, num_blocks=1000, block_size=10, fill_value=fill_value
)
self.arr2 = self.make_block_array(
length=N, num_blocks=1000, block_size=10, fill_value=fill_value
) | negative_train_query0_00791 | |
asv_bench/benchmarks/sparse.py/ArithmeticBlock/make_block_array
class ArithmeticBlock:
def make_block_array(self, length, num_blocks, block_size, fill_value):
arr = np.full(length, fill_value)
indices = np.random.choice(
np.arange(0, length, block_size), num_blocks, replace=False
)
for ind in indices:
arr[ind : ind + block_size] = np.random.randint(0, 100, block_size)
return SparseArray(arr, fill_value=fill_value) | negative_train_query0_00792 | |
asv_bench/benchmarks/sparse.py/ArithmeticBlock/time_make_union
class ArithmeticBlock:
def time_make_union(self, fill_value):
self.arr1.sp_index.make_union(self.arr2.sp_index) | negative_train_query0_00793 | |
asv_bench/benchmarks/sparse.py/ArithmeticBlock/time_intersect
class ArithmeticBlock:
def time_intersect(self, fill_value):
self.arr2.sp_index.intersect(self.arr2.sp_index) | negative_train_query0_00794 | |
asv_bench/benchmarks/sparse.py/ArithmeticBlock/time_addition
class ArithmeticBlock:
def time_addition(self, fill_value):
self.arr1 + self.arr2 | negative_train_query0_00795 | |
asv_bench/benchmarks/sparse.py/ArithmeticBlock/time_division
class ArithmeticBlock:
def time_division(self, fill_value):
self.arr1 / self.arr2 | negative_train_query0_00796 | |
asv_bench/benchmarks/sparse.py/MinMax/setup
class MinMax:
def setup(self, func, fill_value):
N = 1_000_000
arr = make_array(N, 1e-5, fill_value, np.float64)
self.sp_arr = SparseArray(arr, fill_value=fill_value) | negative_train_query0_00797 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.