From d15b25ec43972cebec629a07f923987552bb0cd1 Mon Sep 17 00:00:00 2001 From: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com> Date: Mon, 28 Aug 2023 13:05:48 -0400 Subject: [PATCH 1/5] Initial cut at benchmarking Add some benchmark tests to compare PintArray performance against NumPy arrays of quantities. Over time we should be able to show specific patterns where PintArrays confer substantial performance advantages over naive use of Quantities with Pandas. Signed-off-by: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com> --- pint_pandas/testsuite/benchmarks/__init__.py | 0 pint_pandas/testsuite/benchmarks/conftest.py | 0 .../testsuite/benchmarks/test_30_numpy.py | 133 ++++++++++++++++++ pint_pandas/testsuite/conftest.py | 1 + pyproject.toml | 1 + 5 files changed, 135 insertions(+) create mode 100644 pint_pandas/testsuite/benchmarks/__init__.py create mode 100644 pint_pandas/testsuite/benchmarks/conftest.py create mode 100644 pint_pandas/testsuite/benchmarks/test_30_numpy.py create mode 100644 pint_pandas/testsuite/conftest.py diff --git a/pint_pandas/testsuite/benchmarks/__init__.py b/pint_pandas/testsuite/benchmarks/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/pint_pandas/testsuite/benchmarks/conftest.py b/pint_pandas/testsuite/benchmarks/conftest.py new file mode 100644 index 00000000..e69de29b diff --git a/pint_pandas/testsuite/benchmarks/test_30_numpy.py b/pint_pandas/testsuite/benchmarks/test_30_numpy.py new file mode 100644 index 00000000..93847766 --- /dev/null +++ b/pint_pandas/testsuite/benchmarks/test_30_numpy.py @@ -0,0 +1,133 @@ +from typing import Generator, Any +import itertools as it +import operator + +import pytest + +import pint +from pint.compat import np +from pint.testsuite.helpers import requires_numpy + +from pint_pandas import PintArray + + +SMALL_VEC_LEN = 3 +MID_VEC_LEN = 1_000 +LARGE_VEC_LEN = 1_000_000 + +LENGTHS = ("short", "mid") +ALL_VALUES = tuple( + f"{a}_{b}" for a, b in it.product(LENGTHS, ("list", "tuple", "array")) +) +ALL_ARRAYS = ("short_array", "mid_array") +ALL_PINTARRAYS = ("short_PintArray", "mid_PintArray") +UNITS = ("meter", "kilometer") + +OP1 = (operator.neg,) # operator.truth, +OP2_CMP = (operator.eq, operator.lt) +OP2_MATH = (operator.add, operator.sub, operator.mul, operator.truediv) + +if np is None: + NUMPY_OP1_MATH = NUMPY_OP2_CMP = NUMPY_OP2_MATH = () +else: + NUMPY_OP1_MATH = (np.sqrt, np.square) + NUMPY_OP2_CMP = (np.equal, np.less) + NUMPY_OP2_MATH = (np.add, np.subtract, np.multiply, np.true_divide) + + +def float_range(n: int) -> Generator[float, None, None]: + return (float(x) for x in range(1, n + 1)) + + +@pytest.fixture +def setup(registry_tiny) -> tuple[pint.UnitRegistry, dict[str, Any]]: + data = {} + short = list(float_range(3)) + mid = list(float_range(1_000)) + + data["short_list"] = short + data["short_tuple"] = tuple(short) + data["short_array"] = np.asarray(short) + data["mid_list"] = mid + data["mid_tuple"] = tuple(mid) + data["mid_array"] = np.asarray(mid) + + ureg = registry_tiny + + for key in ALL_ARRAYS: + data[key + "_meter"] = data[key] * ureg.meter + data[key + "_kilometer"] = data[key] * ureg.kilometer + + data["short_PintArray"] = data["short_array"] + data["mid_PintArray"] = data["mid_array"] + + for key in ALL_PINTARRAYS: + length, _ = key.split("_", 1) + data[key + "_meter"] = PintArray(data[f"{length}_array"], ureg.meter) + data[key + "_kilometer"] = PintArray(data[f"{length}_array"], ureg.kilometer) + + return ureg, data + + +@requires_numpy +def test_finding_meter_getattr(benchmark, setup): + ureg, _ = setup + benchmark(getattr, ureg, "meter") + + +# @requires_numpy +# def test_finding_meter_getitem(benchmark, setup): +# ureg, _ = setup +# benchmark(operator.getitem, ureg, "meter") + + +# @requires_numpy +# @pytest.mark.parametrize( +# "unit", ["meter", "angstrom", "meter/second", "angstrom/minute"] +# ) +# def test_base_units(benchmark, setup, unit): +# ureg, _ = setup +# benchmark(ureg.get_base_units, unit) + + +@requires_numpy +@pytest.mark.parametrize("key", ALL_ARRAYS) +def test_build_array_by_mul(benchmark, setup, key): + ureg, data = setup + benchmark(operator.mul, data[key], ureg.meter) + + +@requires_numpy +@pytest.mark.parametrize("key", ALL_PINTARRAYS) +def test_build_PintArray_by_mul(benchmark, setup, key): + ureg, data = setup + benchmark(operator.mul, data[key], ureg.meter) + + +@requires_numpy +@pytest.mark.parametrize( + "keys", + ( + ("short_array_meter", "short_array_meter"), + ("short_array_meter", "short_array_kilometer"), + ("short_array_kilometer", "short_array_meter"), + ("short_array_kilometer", "short_array_kilometer"), + ("mid_array_meter", "mid_array_meter"), + ("mid_array_meter", "mid_array_kilometer"), + ("mid_array_kilometer", "mid_array_meter"), + ("mid_array_kilometer", "mid_array_kilometer"), + ("short_PintArray_meter", "short_PintArray_meter"), + ("short_PintArray_meter", "short_PintArray_kilometer"), + ("short_PintArray_kilometer", "short_PintArray_meter"), + ("short_PintArray_kilometer", "short_PintArray_kilometer"), + ("mid_PintArray_meter", "mid_PintArray_meter"), + ("mid_PintArray_meter", "mid_PintArray_kilometer"), + ("mid_PintArray_kilometer", "mid_PintArray_meter"), + ("mid_PintArray_kilometer", "mid_PintArray_kilometer"), + ), +) +@pytest.mark.parametrize("op", OP2_MATH + OP2_CMP + NUMPY_OP2_MATH + NUMPY_OP2_CMP) +def test_op2(benchmark, setup, keys, op): + _, data = setup + key1, key2 = keys + benchmark(op, data[key1], data[key2]) diff --git a/pint_pandas/testsuite/conftest.py b/pint_pandas/testsuite/conftest.py new file mode 100644 index 00000000..23edefd6 --- /dev/null +++ b/pint_pandas/testsuite/conftest.py @@ -0,0 +1 @@ +# pytest fixtures diff --git a/pyproject.toml b/pyproject.toml index 07483c87..9cd809a4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -40,6 +40,7 @@ test = [ "pytest-mpl", "pytest-cov", "pytest-subtests", + "pytest-benchmark", "codecov", "coveralls", "nbval", From 0a1aad65cb5ef319dc7193ef425fc1c705ff2866 Mon Sep 17 00:00:00 2001 From: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com> Date: Mon, 28 Aug 2023 14:29:38 -0400 Subject: [PATCH 2/5] Update conftest.py Duplicate code from pint/pint/testsuite/conftest.py. Ruff and Black conspired to delete simple imports of relevant fixture definitions. Signed-off-by: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com> --- pint_pandas/testsuite/conftest.py | 62 +++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/pint_pandas/testsuite/conftest.py b/pint_pandas/testsuite/conftest.py index 23edefd6..b3524790 100644 --- a/pint_pandas/testsuite/conftest.py +++ b/pint_pandas/testsuite/conftest.py @@ -1 +1,63 @@ # pytest fixtures + +import pathlib + +import pytest + +import pint + + +_TINY = """ +yocto- = 1e-24 = y- +zepto- = 1e-21 = z- +atto- = 1e-18 = a- +femto- = 1e-15 = f- +pico- = 1e-12 = p- +nano- = 1e-9 = n- +micro- = 1e-6 = µ- = μ- = u- +milli- = 1e-3 = m- +centi- = 1e-2 = c- +deci- = 1e-1 = d- +deca- = 1e+1 = da- = deka- +hecto- = 1e2 = h- +kilo- = 1e3 = k- +mega- = 1e6 = M- +giga- = 1e9 = G- +tera- = 1e12 = T- +peta- = 1e15 = P- +exa- = 1e18 = E- +zetta- = 1e21 = Z- +yotta- = 1e24 = Y- + +meter = [length] = m = metre +second = [time] = s = sec + +angstrom = 1e-10 * meter = Å = ångström = Å +minute = 60 * second = min +""" + + +@pytest.fixture(scope="session") +def tmppath_factory(tmpdir_factory) -> pathlib.Path: + tmp = tmpdir_factory.mktemp("pint") + return pathlib.Path(tmp) + + +@pytest.fixture(scope="session") +def tiny_definition_file(tmppath_factory: pathlib.Path) -> pathlib.Path: + folder = tmppath_factory / "definitions" + folder.mkdir(exist_ok=True, parents=True) + path = folder / "tiny.txt" + if not path.exists(): + path.write_text(_TINY, encoding="utf-8") + return path + + +@pytest.fixture +def registry_empty(): + return pint.UnitRegistry(None) + + +@pytest.fixture +def registry_tiny(tiny_definition_file: pathlib.Path): + return pint.UnitRegistry(tiny_definition_file) From 2500c4e60eb1978ff4e6f2d6a0b6aff17409aac9 Mon Sep 17 00:00:00 2001 From: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com> Date: Mon, 4 Sep 2023 11:23:21 -0400 Subject: [PATCH 3/5] Update test_30_numpy.py Properly tease apart species of tests so we can compare Pint vs Numpy vs Pandas each in their own lanes. I still don't know how to get pytest-benchmark to properly install within the CI/CD system. Signed-off-by: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com> --- .../testsuite/benchmarks/test_30_numpy.py | 163 ++++++++++++++++-- 1 file changed, 144 insertions(+), 19 deletions(-) diff --git a/pint_pandas/testsuite/benchmarks/test_30_numpy.py b/pint_pandas/testsuite/benchmarks/test_30_numpy.py index 93847766..7e5b843b 100644 --- a/pint_pandas/testsuite/benchmarks/test_30_numpy.py +++ b/pint_pandas/testsuite/benchmarks/test_30_numpy.py @@ -6,6 +6,7 @@ import pint from pint.compat import np +from pint_pandas.pint_array import pd from pint.testsuite.helpers import requires_numpy from pint_pandas import PintArray @@ -19,20 +20,31 @@ ALL_VALUES = tuple( f"{a}_{b}" for a, b in it.product(LENGTHS, ("list", "tuple", "array")) ) -ALL_ARRAYS = ("short_array", "mid_array") +ALL_NDARRAYS = ("short_ndarray", "mid_ndarray") +ALL_QARRAYS = ("short_Qarray", "mid_Qarray") ALL_PINTARRAYS = ("short_PintArray", "mid_PintArray") +ALL_SERIES = ("short_Series", "mid_Series") +ALL_SERIES_PINTARRAYS = ("short_Series_PA", "mid_Series_PA") UNITS = ("meter", "kilometer") OP1 = (operator.neg,) # operator.truth, OP2_CMP = (operator.eq, operator.lt) -OP2_MATH = (operator.add, operator.sub, operator.mul, operator.truediv) +OP2_MATH = (operator.add, operator.mul, operator.truediv) if np is None: NUMPY_OP1_MATH = NUMPY_OP2_CMP = NUMPY_OP2_MATH = () else: NUMPY_OP1_MATH = (np.sqrt, np.square) NUMPY_OP2_CMP = (np.equal, np.less) - NUMPY_OP2_MATH = (np.add, np.subtract, np.multiply, np.true_divide) + NUMPY_OP2_MATH = (np.add, np.multiply, np.true_divide) + + +if pd is None: + PANDAS_OP1_MATH = PANDAS_OP2_CMP = PANDAS_OP2_MATH = () +else: + PANDAS_OP1_MATH = () + PANDAS_OP2_CMP = (pd.Series.eq, pd.Series.lt) + PANDAS_OP2_MATH = (pd.Series.add, pd.Series.multiply, pd.Series.truediv) def float_range(n: int) -> Generator[float, None, None]: @@ -54,18 +66,41 @@ def setup(registry_tiny) -> tuple[pint.UnitRegistry, dict[str, Any]]: ureg = registry_tiny - for key in ALL_ARRAYS: - data[key + "_meter"] = data[key] * ureg.meter - data[key + "_kilometer"] = data[key] * ureg.kilometer + data["short_ndarray"] = data["short_array"] + data["mid_ndarray"] = data["mid_array"] + for key in ALL_NDARRAYS: + length, _ = key.split("_", 1) + data[key + "_meter"] = np.array([x * ureg.meter for x in data[f"{length}_list"]], dtype="object") + data[key + "_kilometer"] = np.array([x * ureg.kilometer for x in data[f"{length}_list"]], dtype="object") + + data["short_Qarray"] = data["short_array"] + data["mid_Qarray"] = data["mid_array"] + for key in ALL_QARRAYS: + length, _ = key.split("_", 1) + data[key + "_meter"] = data[f"{length}_array"] * ureg.meter + data[key + "_kilometer"] = data[f"{length}_array"] * ureg.kilometer data["short_PintArray"] = data["short_array"] data["mid_PintArray"] = data["mid_array"] - for key in ALL_PINTARRAYS: length, _ = key.split("_", 1) data[key + "_meter"] = PintArray(data[f"{length}_array"], ureg.meter) data[key + "_kilometer"] = PintArray(data[f"{length}_array"], ureg.kilometer) + data["short_Series"] = data["short_array"] + data["mid_Series"] = data["mid_array"] + for key in ALL_SERIES: + length, _ = key.split("_", 1) + data[key + "_meter"] = pd.Series([x * ureg.meter for x in data[f"{length}_list"]]) + data[key + "_kilometer"] = pd.Series([x * ureg.kilometer for x in data[f"{length}_list"]]) + + data["short_Series_PA"] = data["short_array"] + data["mid_Series_PA"] = data["mid_array"] + for key in ALL_SERIES_PINTARRAYS: + length, _ = key.split("_", 1) + data[key + "_meter"] = pd.Series(data[f"{length}_PintArray_meter"]) + data[key + "_kilometer"] = pd.Series(data[f"{length}_PintArray_kilometer"]) + return ureg, data @@ -91,7 +126,14 @@ def test_finding_meter_getattr(benchmark, setup): @requires_numpy -@pytest.mark.parametrize("key", ALL_ARRAYS) +@pytest.mark.parametrize("key", ALL_NDARRAYS) +def test_build_array_by_mul(benchmark, setup, key): + ureg, data = setup + benchmark(operator.mul, data[key], ureg.meter) + + +@requires_numpy +@pytest.mark.parametrize("key", ALL_QARRAYS) def test_build_array_by_mul(benchmark, setup, key): ureg, data = setup benchmark(operator.mul, data[key], ureg.meter) @@ -104,18 +146,38 @@ def test_build_PintArray_by_mul(benchmark, setup, key): benchmark(operator.mul, data[key], ureg.meter) +@requires_numpy +@pytest.mark.parametrize("key", ALL_SERIES) +def test_build_PintArray_by_mul(benchmark, setup, key): + ureg, data = setup + benchmark(operator.mul, data[key], ureg.meter) + + @requires_numpy @pytest.mark.parametrize( "keys", ( - ("short_array_meter", "short_array_meter"), - ("short_array_meter", "short_array_kilometer"), - ("short_array_kilometer", "short_array_meter"), - ("short_array_kilometer", "short_array_kilometer"), - ("mid_array_meter", "mid_array_meter"), - ("mid_array_meter", "mid_array_kilometer"), - ("mid_array_kilometer", "mid_array_meter"), - ("mid_array_kilometer", "mid_array_kilometer"), + ("short_Qarray_meter", "short_Qarray_meter"), + ("short_Qarray_meter", "short_Qarray_kilometer"), + ("short_Qarray_kilometer", "short_Qarray_meter"), + ("short_Qarray_kilometer", "short_Qarray_kilometer"), + ("mid_Qarray_meter", "mid_Qarray_meter"), + ("mid_Qarray_meter", "mid_Qarray_kilometer"), + ("mid_Qarray_kilometer", "mid_Qarray_meter"), + ("mid_Qarray_kilometer", "mid_Qarray_kilometer"), + ), +) +@pytest.mark.parametrize("op", OP2_MATH + OP2_CMP) +def test_op2_pint(benchmark, setup, keys, op): + _, data = setup + key1, key2 = keys + benchmark(op, data[key1], data[key2]) + + +@requires_numpy +@pytest.mark.parametrize( + "pa_keys", + ( ("short_PintArray_meter", "short_PintArray_meter"), ("short_PintArray_meter", "short_PintArray_kilometer"), ("short_PintArray_kilometer", "short_PintArray_meter"), @@ -126,8 +188,71 @@ def test_build_PintArray_by_mul(benchmark, setup, key): ("mid_PintArray_kilometer", "mid_PintArray_kilometer"), ), ) -@pytest.mark.parametrize("op", OP2_MATH + OP2_CMP + NUMPY_OP2_MATH + NUMPY_OP2_CMP) -def test_op2(benchmark, setup, keys, op): +@pytest.mark.parametrize("op", OP2_MATH + OP2_CMP) +def test_op2_PintArray(benchmark, setup, pa_keys, op): _, data = setup - key1, key2 = keys + key1, key2 = pa_keys + benchmark(op, data[key1], data[key2]) + + +@requires_numpy +@pytest.mark.parametrize( + "np_keys", + ( + ("short_ndarray_meter", "short_ndarray_meter"), + ("short_ndarray_meter", "short_ndarray_kilometer"), + ("short_ndarray_kilometer", "short_ndarray_meter"), + ("short_ndarray_kilometer", "short_ndarray_kilometer"), + ("mid_ndarray_meter", "mid_ndarray_meter"), + ("mid_ndarray_meter", "mid_ndarray_kilometer"), + ("mid_ndarray_kilometer", "mid_ndarray_meter"), + ("mid_ndarray_kilometer", "mid_ndarray_kilometer"), + ), +) +@pytest.mark.parametrize("op", NUMPY_OP2_MATH + NUMPY_OP2_CMP) +def test_op2_numpy(benchmark, setup, np_keys, op): + _, data = setup + key1, key2 = np_keys + benchmark(op, data[key1], data[key2]) + + +@requires_numpy +@pytest.mark.parametrize( + "pd_keys", + ( + ("short_Series_meter", "short_Series_meter"), + ("short_Series_meter", "short_Series_kilometer"), + ("short_Series_kilometer", "short_Series_meter"), + ("short_Series_kilometer", "short_Series_kilometer"), + ("mid_Series_meter", "mid_Series_meter"), + ("mid_Series_meter", "mid_Series_kilometer"), + ("mid_Series_kilometer", "mid_Series_meter"), + ("mid_Series_kilometer", "mid_Series_kilometer"), + ), +) +@pytest.mark.parametrize("op", PANDAS_OP2_MATH + PANDAS_OP2_CMP) +def test_op2_pandas(benchmark, setup, pd_keys, op): + _, data = setup + key1, key2 = pd_keys benchmark(op, data[key1], data[key2]) + +@requires_numpy +@pytest.mark.parametrize( + "pd_pa_keys", + ( + ("short_Series_PA_meter", "short_Series_PA_meter"), + ("short_Series_PA_meter", "short_Series_PA_kilometer"), + ("short_Series_PA_kilometer", "short_Series_PA_meter"), + ("short_Series_PA_kilometer", "short_Series_PA_kilometer"), + ("mid_Series_PA_meter", "mid_Series_PA_meter"), + ("mid_Series_PA_meter", "mid_Series_PA_kilometer"), + ("mid_Series_PA_kilometer", "mid_Series_PA_meter"), + ("mid_Series_PA_kilometer", "mid_Series_PA_kilometer"), + ), +) +@pytest.mark.parametrize("op", PANDAS_OP2_MATH + PANDAS_OP2_CMP) +def test_op2_pint_pandas(benchmark, setup, pd_pa_keys, op): + _, data = setup + key1, key2 = pd_pa_keys + benchmark(op, data[key1], data[key2]) + From fa46bda638e5e7e610b818972a40a539e8ab64df Mon Sep 17 00:00:00 2001 From: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com> Date: Mon, 4 Sep 2023 11:26:41 -0400 Subject: [PATCH 4/5] Cleanup lint in test_30_numpy.py Signed-off-by: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com> --- .../testsuite/benchmarks/test_30_numpy.py | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/pint_pandas/testsuite/benchmarks/test_30_numpy.py b/pint_pandas/testsuite/benchmarks/test_30_numpy.py index 7e5b843b..48e2f652 100644 --- a/pint_pandas/testsuite/benchmarks/test_30_numpy.py +++ b/pint_pandas/testsuite/benchmarks/test_30_numpy.py @@ -70,8 +70,12 @@ def setup(registry_tiny) -> tuple[pint.UnitRegistry, dict[str, Any]]: data["mid_ndarray"] = data["mid_array"] for key in ALL_NDARRAYS: length, _ = key.split("_", 1) - data[key + "_meter"] = np.array([x * ureg.meter for x in data[f"{length}_list"]], dtype="object") - data[key + "_kilometer"] = np.array([x * ureg.kilometer for x in data[f"{length}_list"]], dtype="object") + data[key + "_meter"] = np.array( + [x * ureg.meter for x in data[f"{length}_list"]], dtype="object" + ) + data[key + "_kilometer"] = np.array( + [x * ureg.kilometer for x in data[f"{length}_list"]], dtype="object" + ) data["short_Qarray"] = data["short_array"] data["mid_Qarray"] = data["mid_array"] @@ -91,8 +95,12 @@ def setup(registry_tiny) -> tuple[pint.UnitRegistry, dict[str, Any]]: data["mid_Series"] = data["mid_array"] for key in ALL_SERIES: length, _ = key.split("_", 1) - data[key + "_meter"] = pd.Series([x * ureg.meter for x in data[f"{length}_list"]]) - data[key + "_kilometer"] = pd.Series([x * ureg.kilometer for x in data[f"{length}_list"]]) + data[key + "_meter"] = pd.Series( + [x * ureg.meter for x in data[f"{length}_list"]] + ) + data[key + "_kilometer"] = pd.Series( + [x * ureg.kilometer for x in data[f"{length}_list"]] + ) data["short_Series_PA"] = data["short_array"] data["mid_Series_PA"] = data["mid_array"] @@ -236,6 +244,7 @@ def test_op2_pandas(benchmark, setup, pd_keys, op): key1, key2 = pd_keys benchmark(op, data[key1], data[key2]) + @requires_numpy @pytest.mark.parametrize( "pd_pa_keys", @@ -255,4 +264,3 @@ def test_op2_pint_pandas(benchmark, setup, pd_pa_keys, op): _, data = setup key1, key2 = pd_pa_keys benchmark(op, data[key1], data[key2]) - From eed69b7e4acff94edbba42dca8522d9c73facc70 Mon Sep 17 00:00:00 2001 From: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com> Date: Mon, 4 Sep 2023 11:31:10 -0400 Subject: [PATCH 5/5] Make ruff happy with test_30_numpy.py Signed-off-by: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com> --- pint_pandas/testsuite/benchmarks/test_30_numpy.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/pint_pandas/testsuite/benchmarks/test_30_numpy.py b/pint_pandas/testsuite/benchmarks/test_30_numpy.py index 48e2f652..1ce342ab 100644 --- a/pint_pandas/testsuite/benchmarks/test_30_numpy.py +++ b/pint_pandas/testsuite/benchmarks/test_30_numpy.py @@ -135,14 +135,14 @@ def test_finding_meter_getattr(benchmark, setup): @requires_numpy @pytest.mark.parametrize("key", ALL_NDARRAYS) -def test_build_array_by_mul(benchmark, setup, key): +def test_build_ndarray_by_mul(benchmark, setup, key): ureg, data = setup benchmark(operator.mul, data[key], ureg.meter) @requires_numpy @pytest.mark.parametrize("key", ALL_QARRAYS) -def test_build_array_by_mul(benchmark, setup, key): +def test_build_Qarray_by_mul(benchmark, setup, key): ureg, data = setup benchmark(operator.mul, data[key], ureg.meter) @@ -156,7 +156,14 @@ def test_build_PintArray_by_mul(benchmark, setup, key): @requires_numpy @pytest.mark.parametrize("key", ALL_SERIES) -def test_build_PintArray_by_mul(benchmark, setup, key): +def test_build_Series_by_mul(benchmark, setup, key): + ureg, data = setup + benchmark(operator.mul, data[key], ureg.meter) + + +@requires_numpy +@pytest.mark.parametrize("key", ALL_SERIES_PINTARRAYS) +def test_build_Series_PA_by_mul(benchmark, setup, key): ureg, data = setup benchmark(operator.mul, data[key], ureg.meter)