⚡️ Speed up function _highlight_value by 46%

[codeflash-ai]

📄 46% (0.46x) speedup for _highlight_value in pandas/io/formats/style.py

⏱️ Runtime : 33.7 milliseconds → 23.1 milliseconds (best of 68 runs)

📝 Explanation and details

The optimized code achieves a 45% speedup through targeted improvements in pandas' core data manipulation functions:

Key Optimizations:

1. where Method Micro-optimization: Localized global variable lookups (PYPY, REF_COUNT) to avoid repeated attribute access overhead. While minor, this reduces overhead in the reference counting check path.

2. notna Function Enhancement: Added an optimized path for NumPy arrays using np.logical_not(res) instead of the generic ~res operator. NumPy's logical_not is more efficient for boolean arrays as it avoids some of the overhead associated with pandas' generic bitwise negation.

3. _highlight_value Function - Major Performance Win: This is where the biggest gains occur (55% time reduction in the critical path). The optimization replaces:

   cond = cond.where(pd.notna(cond), False)  # Original - expensive

   with:

   notna_mask = pd.notna(cond)
   cond = np.where(notna_mask, cond, False)  # Optimized - direct NumPy operation

Why This Works:

• The original .where() method creates intermediate pandas objects and involves complex indexing logic
• The optimized version uses NumPy's where() directly, which is much faster for element-wise conditional operations
• This avoids pandas' overhead while maintaining identical functionality

Test Results Show Consistent Gains:

• Series operations: 60-80% faster (e.g., test_series_min_basic: 304μs → 182μs)
• DataFrame operations: 30-35% faster (e.g., test_dataframe_min_basic: 596μs → 446μs)
• Edge cases with NaN/None values show similar improvements
• Large-scale tests maintain performance gains

The optimization is particularly effective for styling operations that frequently call _highlight_value, making conditional formatting significantly faster while preserving all existing behavior and edge case handling.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 73 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import numpy as np
import pandas as pd

# imports
from pandas.io.formats.style import _highlight_value

# -------------------- BASIC TEST CASES --------------------


def test_series_min_basic():
    # Test highlighting min value in a simple Series
    s = pd.Series([1, 2, 3])
    codeflash_output = _highlight_value(s, "min", "color: red")
    result = codeflash_output  # 304μs -> 182μs (67.2% faster)
    expected = np.array(["color: red", "", ""])


def test_series_max_basic():
    # Test highlighting max value in a simple Series
    s = pd.Series([1, 2, 3])
    codeflash_output = _highlight_value(s, "max", "font-weight: bold")
    result = codeflash_output  # 298μs -> 180μs (65.5% faster)
    expected = np.array(["", "", "font-weight: bold"])


def test_dataframe_min_basic():
    # Test highlighting min value in a simple DataFrame
    df = pd.DataFrame([[1, 2], [3, 0]])
    codeflash_output = _highlight_value(df, "min", "background: yellow")
    result = codeflash_output  # 596μs -> 446μs (33.6% faster)
    expected = np.array([["", ""], ["", "background: yellow"]])


def test_dataframe_max_basic():
    # Test highlighting max value in a simple DataFrame
    df = pd.DataFrame([[1, 2], [3, 0]])
    codeflash_output = _highlight_value(df, "max", "background: green")
    result = codeflash_output  # 569μs -> 429μs (32.4% faster)
    expected = np.array([["", ""], ["background: green", ""]])


def test_series_all_equal():
    # All values are the same, all should be highlighted
    s = pd.Series([5, 5, 5])
    codeflash_output = _highlight_value(s, "min", "color: red")
    result = codeflash_output  # 306μs -> 181μs (68.8% faster)
    expected = np.array(["color: red", "color: red", "color: red"])


def test_dataframe_all_equal():
    # All values are the same, all should be highlighted
    df = pd.DataFrame([[7, 7], [7, 7]])
    codeflash_output = _highlight_value(df, "max", "font-weight: bold")
    result = codeflash_output  # 589μs -> 442μs (33.2% faster)
    expected = np.array(
        [
            ["font-weight: bold", "font-weight: bold"],
            ["font-weight: bold", "font-weight: bold"],
        ]
    )


def test_series_with_nan():
    # NaN should not be highlighted, min/max should skipna
    s = pd.Series([np.nan, 2, 1])
    codeflash_output = _highlight_value(s, "min", "color: blue")
    result = codeflash_output  # 303μs -> 182μs (66.0% faster)
    expected = np.array(["", "", "color: blue"])


def test_dataframe_with_nan():
    # NaN should not be highlighted, min/max should skipna
    df = pd.DataFrame([[np.nan, 3], [2, 1]])
    codeflash_output = _highlight_value(df, "min", "color: orange")
    result = codeflash_output  # 706μs -> 429μs (64.3% faster)
    expected = np.array([["", ""], ["", "color: orange"]])


def test_series_with_none():
    # None should be treated as NaN and not highlighted
    s = pd.Series([None, 4, 2])
    codeflash_output = _highlight_value(s, "min", "color: purple")
    result = codeflash_output  # 305μs -> 181μs (68.6% faster)
    expected = np.array(["", "", "color: purple"])


def test_dataframe_with_none():
    # None should be treated as NaN and not highlighted
    df = pd.DataFrame([[None, 5], [4, 2]])
    codeflash_output = _highlight_value(df, "min", "color: pink")
    result = codeflash_output  # 693μs -> 424μs (63.6% faster)
    expected = np.array([["", ""], ["", "color: pink"]])


# -------------------- EDGE TEST CASES --------------------


def test_series_empty():
    # Empty Series should return empty array
    s = pd.Series([], dtype=float)
    codeflash_output = _highlight_value(s, "min", "color: red")
    result = codeflash_output  # 318μs -> 145μs (119% faster)
    expected = np.array([])


def test_dataframe_empty():
    # Empty DataFrame should return empty 2D array
    df = pd.DataFrame([], columns=["A", "B"])
    codeflash_output = _highlight_value(df, "max", "color: green")
    result = codeflash_output  # 612μs -> 495μs (23.5% faster)
    expected = np.empty((0, 2), dtype="<U12")


def test_series_all_nan():
    # All NaN: no highlights
    s = pd.Series([np.nan, np.nan, np.nan])
    codeflash_output = _highlight_value(s, "min", "color: red")
    result = codeflash_output  # 281μs -> 159μs (77.0% faster)
    expected = np.array(["", "", ""])


def test_dataframe_all_nan():
    # All NaN: no highlights
    df = pd.DataFrame([[np.nan, np.nan], [np.nan, np.nan]])
    codeflash_output = _highlight_value(df, "max", "color: blue")
    result = codeflash_output  # 564μs -> 416μs (35.6% faster)
    expected = np.array([["", ""], ["", ""]])


def test_series_with_inf():
    # Test Series with inf values
    s = pd.Series([1, np.inf, 3])
    codeflash_output = _highlight_value(s, "max", "color: gold")
    result = codeflash_output  # 328μs -> 209μs (56.9% faster)
    expected = np.array(["", "color: gold", ""])


def test_dataframe_with_inf():
    # Test DataFrame with inf values
    df = pd.DataFrame([[1, 2], [np.inf, 3]])
    codeflash_output = _highlight_value(df, "max", "color: silver")
    result = codeflash_output  # 759μs -> 475μs (59.7% faster)
    expected = np.array([["", ""], ["color: silver", ""]])


def test_series_with_negative_inf():
    # Test Series with -inf values
    s = pd.Series([-np.inf, 0, 1])
    codeflash_output = _highlight_value(s, "min", "color: black")
    result = codeflash_output  # 330μs -> 206μs (60.0% faster)
    expected = np.array(["color: black", "", ""])


def test_dataframe_with_negative_inf():
    # Test DataFrame with -inf values
    df = pd.DataFrame([[1, -np.inf], [0, 2]])
    codeflash_output = _highlight_value(df, "min", "color: grey")
    result = codeflash_output  # 754μs -> 473μs (59.1% faster)
    expected = np.array([["", "color: grey"], ["", ""]])


def test_series_with_multiple_min():
    # Multiple min values, all should be highlighted
    s = pd.Series([1, 2, 1, 3])
    codeflash_output = _highlight_value(s, "min", "color: brown")
    result = codeflash_output  # 306μs -> 184μs (65.8% faster)
    expected = np.array(["color: brown", "", "color: brown", ""])


def test_dataframe_with_multiple_max():
    # Multiple max values, all should be highlighted
    df = pd.DataFrame([[5, 1], [5, 3]])
    codeflash_output = _highlight_value(df, "max", "color: teal")
    result = codeflash_output  # 593μs -> 442μs (34.2% faster)
    expected = np.array([["color: teal", ""], ["color: teal", ""]])


def test_series_object_with_numbers_and_nan():
    # Series with dtype=object, numbers and NaN
    s = pd.Series([1, 2, np.nan], dtype=object)
    codeflash_output = _highlight_value(s, "min", "color: red")
    result = codeflash_output  # 341μs -> 213μs (60.0% faster)
    expected = np.array(["color: red", "", ""])


def test_dataframe_object_with_numbers_and_nan():
    # DataFrame with dtype=object, numbers and NaN
    df = pd.DataFrame([[1, np.nan], [2, 3]], dtype=object)
    codeflash_output = _highlight_value(df, "max", "color: blue")
    result = codeflash_output  # 675μs -> 529μs (27.5% faster)
    expected = np.array([["", ""], ["", "color: blue"]])


def test_series_with_int_and_float():
    # Series with int and float values
    s = pd.Series([1, 2.0, 3])
    codeflash_output = _highlight_value(s, "max", "color: green")
    result = codeflash_output  # 303μs -> 184μs (64.6% faster)
    expected = np.array(["", "", "color: green"])


def test_dataframe_with_int_and_float():
    # DataFrame with int and float values
    df = pd.DataFrame([[1, 2.0], [3, 4]])
    codeflash_output = _highlight_value(df, "min", "color: magenta")
    result = codeflash_output  # 712μs -> 432μs (64.8% faster)
    expected = np.array([["color: magenta", ""], ["", ""]])


# -------------------- LARGE SCALE TEST CASES --------------------


def test_large_series():
    # Large Series, highlight min
    s = pd.Series(np.arange(1000, 0, -1))
    codeflash_output = _highlight_value(s, "min", "color: navy")
    result = codeflash_output  # 316μs -> 197μs (60.1% faster)
    expected = np.array(["color: navy"] + [""] * 999)


def test_large_dataframe_min():
    # Large DataFrame, highlight min
    df = pd.DataFrame(np.arange(1000).reshape(100, 10))
    codeflash_output = _highlight_value(df, "min", "color: olive")
    result = codeflash_output  # 616μs -> 470μs (31.0% faster)
    # Only the first cell (0,0) should be highlighted
    expected = np.full((100, 10), "", dtype="<U11")
    expected[0, 0] = "color: olive"


def test_large_dataframe_max():
    # Large DataFrame, highlight max
    df = pd.DataFrame(np.arange(1000).reshape(100, 10))
    codeflash_output = _highlight_value(df, "max", "color: maroon")
    result = codeflash_output  # 605μs -> 455μs (32.8% faster)
    # Only the last cell (99,9) should be highlighted
    expected = np.full((100, 10), "", dtype="<U13")
    expected[99, 9] = "color: maroon"


def test_large_series_with_nan():
    # Large Series with NaN at random positions, highlight min
    arr = np.arange(1000, 0, -1).astype(float)
    arr[100] = np.nan
    arr[500] = np.nan
    s = pd.Series(arr)
    codeflash_output = _highlight_value(s, "min", "color: cyan")
    result = codeflash_output  # 317μs -> 196μs (61.6% faster)
    expected = np.array(["color: cyan"] + [""] * 999)


def test_large_dataframe_with_nan():
    # Large DataFrame with NaN at random positions, highlight min
    arr = np.arange(1000).reshape(100, 10).astype(float)
    arr[10, 2] = np.nan
    arr[50, 7] = np.nan
    df = pd.DataFrame(arr)
    codeflash_output = _highlight_value(df, "min", "color: violet")
    result = codeflash_output  # 621μs -> 472μs (31.5% faster)
    expected = np.full((100, 10), "", dtype="<U13")
    expected[0, 0] = "color: violet"


def test_large_dataframe_all_nan():
    # Large DataFrame all NaN, should be all empty
    df = pd.DataFrame(np.full((100, 10), np.nan))
    codeflash_output = _highlight_value(df, "max", "color: salmon")
    result = codeflash_output  # 577μs -> 423μs (36.2% faster)
    expected = np.full((100, 10), "", dtype="<U13")


# -------------------- ADDITIONAL EDGE CASES --------------------


def test_series_with_duplicate_min():
    # Series with duplicate min values at different positions
    s = pd.Series([0, 1, 2, 0, 3])
    codeflash_output = _highlight_value(s, "min", "color: red")
    result = codeflash_output  # 309μs -> 183μs (68.3% faster)
    expected = np.array(["color: red", "", "", "color: red", ""])


def test_dataframe_with_duplicate_max():
    # DataFrame with duplicate max values
    df = pd.DataFrame([[5, 7], [7, 3]])
    codeflash_output = _highlight_value(df, "max", "color: blue")
    result = codeflash_output  # 589μs -> 442μs (33.2% faster)
    expected = np.array([["", "color: blue"], ["color: blue", ""]])


def test_series_with_all_none():
    # Series with all None values
    s = pd.Series([None, None, None])
    codeflash_output = _highlight_value(s, "min", "color: red")
    result = codeflash_output  # 301μs -> 182μs (65.4% faster)
    expected = np.array(["", "", ""])


def test_dataframe_with_all_none():
    # DataFrame with all None values
    df = pd.DataFrame([[None, None], [None, None]])
    codeflash_output = _highlight_value(df, "max", "color: blue")
    result = codeflash_output  # 666μs -> 518μs (28.5% faster)
    expected = np.array([["", ""], ["", ""]])


def test_series_with_nan_and_none():
    # Series with both NaN and None
    s = pd.Series([np.nan, None, 2])
    codeflash_output = _highlight_value(s, "min", "color: red")
    result = codeflash_output  # 305μs -> 184μs (65.9% faster)
    expected = np.array(["", "", "color: red"])


def test_dataframe_with_nan_and_none():
    # DataFrame with both NaN and None
    df = pd.DataFrame([[np.nan, None], [2, 1]])
    codeflash_output = _highlight_value(df, "min", "color: green")
    result = codeflash_output  # 586μs -> 443μs (32.2% faster)
    expected = np.array([["", ""], ["", "color: green"]])


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import numpy as np
import pandas as pd

# imports
from pandas.io.formats.style import _highlight_value

# -------------------------------
# BASIC TEST CASES
# -------------------------------


def test_series_min_basic():
    # Test highlighting minimum in a simple Series
    s = pd.Series([1, 2, 3])
    codeflash_output = _highlight_value(s, "min", "background: yellow")
    result = codeflash_output  # 323μs -> 195μs (65.0% faster)


def test_series_max_basic():
    # Test highlighting maximum in a simple Series
    s = pd.Series([1, 2, 3])
    codeflash_output = _highlight_value(s, "max", "background: green")
    result = codeflash_output  # 299μs -> 180μs (65.7% faster)


def test_dataframe_min_basic():
    # Test highlighting minimum in a simple DataFrame
    df = pd.DataFrame([[2, 1], [3, 4]])
    codeflash_output = _highlight_value(df, "min", "color: red")
    result = codeflash_output  # 596μs -> 455μs (31.1% faster)
    expected = np.array([["", "color: red"], ["", ""]])


def test_dataframe_max_basic():
    # Test highlighting maximum in a simple DataFrame
    df = pd.DataFrame([[2, 1], [3, 4]])
    codeflash_output = _highlight_value(df, "max", "color: blue")
    result = codeflash_output  # 576μs -> 427μs (34.7% faster)
    expected = np.array([["", ""], ["", "color: blue"]])


def test_series_multiple_min():
    # Test highlighting when multiple values are equal to the min
    s = pd.Series([2, 1, 1, 3])
    codeflash_output = _highlight_value(s, "min", "font-weight: bold")
    result = codeflash_output  # 308μs -> 181μs (69.7% faster)


def test_dataframe_multiple_max():
    # Test highlighting when multiple values are equal to the max in DataFrame
    df = pd.DataFrame([[5, 2], [5, 1]])
    codeflash_output = _highlight_value(df, "max", "font-style: italic")
    result = codeflash_output  # 591μs -> 448μs (32.0% faster)
    expected = np.array([["font-style: italic", ""], ["font-style: italic", ""]])


# -------------------------------
# EDGE TEST CASES
# -------------------------------


def test_series_with_nan():
    # Test Series with NaN values
    s = pd.Series([np.nan, 2, 2, np.nan])
    codeflash_output = _highlight_value(s, "min", "border: 1px solid")
    result = codeflash_output  # 306μs -> 183μs (67.2% faster)


def test_dataframe_with_nan():
    # Test DataFrame with NaN values
    df = pd.DataFrame([[np.nan, 1], [2, np.nan]])
    codeflash_output = _highlight_value(df, "min", "text-decoration: underline")
    result = codeflash_output  # 593μs -> 447μs (32.7% faster)
    expected = np.array([["", "text-decoration: underline"], ["", ""]])


def test_series_all_nan():
    # Test Series with all NaN values
    s = pd.Series([np.nan, np.nan])
    codeflash_output = _highlight_value(s, "min", "background: pink")
    result = codeflash_output  # 277μs -> 158μs (75.4% faster)


def test_dataframe_all_nan():
    # Test DataFrame with all NaN values
    df = pd.DataFrame([[np.nan, np.nan], [np.nan, np.nan]])
    codeflash_output = _highlight_value(df, "max", "background: pink")
    result = codeflash_output  # 567μs -> 421μs (34.7% faster)
    expected = np.array([["", ""], ["", ""]])


def test_series_single_element():
    # Test Series with a single element
    s = pd.Series([42])
    codeflash_output = _highlight_value(s, "min", "background: orange")
    result = codeflash_output  # 305μs -> 184μs (66.1% faster)


def test_dataframe_single_element():
    # Test DataFrame with a single element
    df = pd.DataFrame([[7]])
    codeflash_output = _highlight_value(df, "max", "background: purple")
    result = codeflash_output  # 586μs -> 446μs (31.4% faster)
    expected = np.array([["background: purple"]])


def test_series_with_inf():
    # Test Series with inf values
    s = pd.Series([1, np.inf, -np.inf, 3])
    codeflash_output = _highlight_value(s, "min", "font-size: 20px")
    result = codeflash_output  # 331μs -> 210μs (57.5% faster)


def test_dataframe_with_inf():
    # Test DataFrame with inf values
    df = pd.DataFrame([[1, np.inf], [3, -np.inf]])
    codeflash_output = _highlight_value(df, "min", "font-size: 10px")
    result = codeflash_output  # 762μs -> 484μs (57.3% faster)
    expected = np.array([["", ""], ["", "font-size: 10px"]])


def test_series_with_none():
    # Test Series with None values
    s = pd.Series([None, 4, 2])
    codeflash_output = _highlight_value(s, "min", "border: 2px dashed")
    result = codeflash_output  # 305μs -> 184μs (66.1% faster)


def test_dataframe_with_none():
    # Test DataFrame with None values
    df = pd.DataFrame([[None, 2], [3, None]])
    codeflash_output = _highlight_value(df, "max", "border: 2px solid")
    result = codeflash_output  # 594μs -> 450μs (31.8% faster)
    expected = np.array([["", ""], ["border: 2px solid", ""]])


def test_series_all_equal():
    # Test Series where all values are equal
    s = pd.Series([7, 7, 7])
    codeflash_output = _highlight_value(s, "max", "background: cyan")
    result = codeflash_output  # 309μs -> 182μs (69.6% faster)


def test_dataframe_all_equal():
    # Test DataFrame where all values are equal
    df = pd.DataFrame([[5, 5], [5, 5]])
    codeflash_output = _highlight_value(df, "min", "background: magenta")
    result = codeflash_output  # 589μs -> 446μs (32.0% faster)
    expected = np.array(
        [
            ["background: magenta", "background: magenta"],
            ["background: magenta", "background: magenta"],
        ]
    )


def test_series_object_dtype():
    # Test Series with object dtype (e.g., strings that can be compared)
    s = pd.Series(["b", "a", "c"])
    codeflash_output = _highlight_value(s, "min", "background: brown")
    result = codeflash_output  # 314μs -> 196μs (60.1% faster)


def test_dataframe_object_dtype():
    # Test DataFrame with object dtype
    df = pd.DataFrame([["b", "c"], ["a", "d"]])
    codeflash_output = _highlight_value(df, "min", "background: black")
    result = codeflash_output  # 659μs -> 511μs (28.9% faster)
    expected = np.array([["", ""], ["background: black", ""]])


def test_series_with_boolean():
    # Test Series with boolean values
    s = pd.Series([True, False, True])
    codeflash_output = _highlight_value(s, "min", "background: gray")
    result = codeflash_output  # 321μs -> 201μs (59.5% faster)


def test_dataframe_with_boolean():
    # Test DataFrame with boolean values
    df = pd.DataFrame([[True, False], [False, True]])
    codeflash_output = _highlight_value(df, "max", "background: gold")
    result = codeflash_output  # 622μs -> 463μs (34.2% faster)
    expected = np.array([["background: gold", ""], ["", "background: gold"]])


def test_series_with_custom_props():
    # Test with a custom CSS property string
    s = pd.Series([1, 2, 3])
    codeflash_output = _highlight_value(s, "max", "box-shadow: 0 0 5px red")
    result = codeflash_output  # 304μs -> 184μs (64.7% faster)


def test_dataframe_with_custom_props():
    # Test with a custom CSS property string in DataFrame
    df = pd.DataFrame([[1, 2], [3, 4]])
    codeflash_output = _highlight_value(df, "max", "outline: 2px solid blue")
    result = codeflash_output  # 586μs -> 443μs (32.2% faster)
    expected = np.array([["", ""], ["", "outline: 2px solid blue"]])


# -------------------------------
# LARGE SCALE TEST CASES
# -------------------------------


def test_large_series_min():
    # Test with a large Series
    arr = np.arange(1000)
    s = pd.Series(arr)
    codeflash_output = _highlight_value(s, "min", "background: large")
    result = codeflash_output  # 314μs -> 198μs (58.9% faster)
    expected = np.array(["background: large"] + [""] * 999)


def test_large_series_multiple_min():
    # Test with a large Series with multiple minimums
    arr = np.ones(1000)
    arr[0] = arr[500] = 0
    s = pd.Series(arr)
    codeflash_output = _highlight_value(s, "min", "background: large")
    result = codeflash_output  # 311μs -> 193μs (60.9% faster)
    expected = np.array(
        ["background: large"] + [""] * 499 + ["background: large"] + [""] * 499
    )


def test_large_dataframe_max():
    # Test with a large DataFrame
    arr = np.arange(1000).reshape(500, 2)
    df = pd.DataFrame(arr)
    codeflash_output = _highlight_value(df, "max", "background: large-df")
    result = codeflash_output  # 631μs -> 475μs (32.8% faster)
    expected = np.full((500, 2), "", dtype=object)
    expected[499, 1] = "background: large-df"


def test_large_dataframe_multiple_max():
    # Test with a large DataFrame with multiple maximums
    arr = np.full((500, 2), 7)
    arr[0, 0] = arr[499, 1] = 100
    df = pd.DataFrame(arr)
    codeflash_output = _highlight_value(df, "max", "background: multi-max")
    result = codeflash_output  # 606μs -> 454μs (33.3% faster)
    expected = np.full((500, 2), "", dtype=object)
    expected[0, 0] = "background: multi-max"
    expected[499, 1] = "background: multi-max"


def test_large_dataframe_all_equal():
    # Test with a large DataFrame where all values are equal
    arr = np.full((100, 10), 42)
    df = pd.DataFrame(arr)
    codeflash_output = _highlight_value(df, "min", "background: all-equal")
    result = codeflash_output  # 601μs -> 448μs (34.0% faster)
    expected = np.full((100, 10), "background: all-equal", dtype=object)


# -------------------------------
# ERROR CASES (should not raise)
# -------------------------------


def test_empty_series():
    # Test with an empty Series
    s = pd.Series([], dtype=float)
    codeflash_output = _highlight_value(s, "min", "background: empty")
    result = codeflash_output  # 315μs -> 149μs (111% faster)


def test_empty_dataframe():
    # Test with an empty DataFrame
    df = pd.DataFrame([], columns=["A", "B"])
    codeflash_output = _highlight_value(df, "max", "background: empty")
    result = codeflash_output  # 622μs -> 494μs (25.9% faster)


# -------------------------------
# FUNCTIONALITY - MUTATION TESTS
# -------------------------------


def test_different_ops():
    # Test that min and max produce different results
    s = pd.Series([1, 2, 3])
    codeflash_output = _highlight_value(s, "min", "min-prop")
    min_result = codeflash_output  # 309μs -> 185μs (66.8% faster)
    codeflash_output = _highlight_value(s, "max", "max-prop")
    max_result = codeflash_output  # 229μs -> 125μs (82.5% faster)


def test_different_props():
    # Test that different props produce different results
    s = pd.Series([1, 2, 3])
    codeflash_output = _highlight_value(s, "max", "prop1")
    result1 = codeflash_output  # 288μs -> 169μs (70.7% faster)
    codeflash_output = _highlight_value(s, "max", "prop2")
    result2 = codeflash_output  # 222μs -> 120μs (84.3% faster)


def test_return_type_series():
    # Ensure return type is np.ndarray for Series
    s = pd.Series([1, 2, 3])
    codeflash_output = _highlight_value(s, "min", "prop")
    result = codeflash_output  # 288μs -> 170μs (69.6% faster)


def test_return_type_dataframe():
    # Ensure return type is np.ndarray for DataFrame
    df = pd.DataFrame([[1, 2], [3, 4]])
    codeflash_output = _highlight_value(df, "max", "prop")
    result = codeflash_output  # 596μs -> 443μs (34.6% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-_highlight_value-mja24afb and push.