⚡️ Speed up function strip_math by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for strip_math in lib/matplotlib/cbook.py

⏱️ Runtime : 383 microseconds → 362 microseconds (best of 85 runs)

📝 Explanation and details

The optimization replaces a loop-based approach with chained .replace() calls, eliminating the overhead of iterating through a list of tuples and repeatedly calling .replace() in separate statements.

Key changes:

• Eliminates list iteration: The original code creates a list of 9 tuples and iterates through them 594 times (66 function calls × 9 replacements each), consuming 55.1% of total runtime
• Chains string replacements: All .replace() calls are now executed in a single chained expression, reducing Python bytecode dispatch overhead
• Reduces temporary object creation: Avoids creating the tuple list on each function call

Performance impact:
The line profiler shows the optimization reduces total runtime from 831μs to 569μs (31% faster in profiler, 5% in benchmarks). The chained replacements now consume 61.4% of runtime but complete faster overall due to eliminated loop overhead.

Workload benefits:
Based on function references, strip_math is called in matplotlib's wx backend for text rendering operations (get_text_width_height_descent and draw_text). These are likely called frequently during plot rendering, making this optimization valuable for:

• Text-heavy plots: Charts with many mathematical labels benefit most (10-22% speedup for math strings)
• Interactive applications: Reduced latency during dynamic text updates
• Large-scale plotting: Cumulative gains when processing many text elements

The test results show consistent 8-22% improvements for math strings while having minimal impact on non-math strings, making this a low-risk optimization with clear benefits for mathematical text rendering.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from matplotlib.cbook import strip_math

# unit tests

# --- BASIC TEST CASES ---


def test_basic_non_math_string():
    # Should return input unchanged if not math
    codeflash_output = strip_math("hello world")  # 858ns -> 883ns (2.83% slower)


def test_basic_empty_string():
    # Empty string should return empty
    codeflash_output = strip_math("")  # 575ns -> 570ns (0.877% faster)


def test_basic_simple_math_string():
    # Simple math string with $ delimiters
    codeflash_output = strip_math("$x$")  # 2.06μs -> 1.73μs (19.6% faster)


def test_basic_math_with_tex_command():
    # Math string with \times replaced by x
    codeflash_output = strip_math("$a \\times b$")  # 2.68μs -> 2.36μs (13.8% faster)


def test_basic_math_with_multiple_commands():
    # Math string with several latex commands
    codeflash_output = strip_math(
        "$\\mathdefault{A} + \\rm{B}$"
    )  # 3.29μs -> 3.00μs (9.63% faster)


def test_basic_math_with_nested_braces():
    # Math string with nested braces
    codeflash_output = strip_math(
        "$\\mathdefault{{C}}$"
    )  # 2.92μs -> 2.64μs (10.7% faster)


def test_basic_math_with_multiple_replacements():
    # Multiple commands and braces
    codeflash_output = strip_math(
        "$\\cal{D} \\times \\tt{E}$"
    )  # 3.50μs -> 3.19μs (9.66% faster)


def test_basic_math_with_it_and_rm():
    # Math string with \it and \rm
    codeflash_output = strip_math(
        "$\\it{italic} + \\rm{roman}$"
    )  # 3.33μs -> 2.94μs (13.6% faster)


# --- EDGE TEST CASES ---


def test_edge_single_dollar():
    # Single $ is not a valid math string
    codeflash_output = strip_math("$")  # 528ns -> 551ns (4.17% slower)


def test_edge_double_dollar():
    # Double $ is not a valid math string for this function
    codeflash_output = strip_math("$")  # 1.94μs -> 1.62μs (19.7% faster)


def test_edge_math_with_no_content():
    # Math string with no content
    codeflash_output = strip_math("$")  # 1.88μs -> 1.61μs (16.7% faster)


def test_edge_math_with_only_commands():
    # Math string with only latex commands
    codeflash_output = strip_math("$\\mathdefault$")  # 2.46μs -> 2.03μs (20.8% faster)


def test_edge_math_with_unmatched_braces():
    # Unmatched braces should be stripped anyway
    codeflash_output = strip_math(
        "$\\mathdefault{A$"
    )  # 2.89μs -> 2.41μs (19.9% faster)


def test_edge_math_with_multiple_backslashes():
    # Multiple backslashes should be stripped
    codeflash_output = strip_math(
        "$\\\\mathdefault{A}$"
    )  # 2.99μs -> 2.72μs (9.69% faster)


def test_edge_non_math_with_latex_commands():
    # Non-math string with latex commands should not be stripped
    codeflash_output = strip_math("\\mathdefault{A}")  # 869ns -> 888ns (2.14% slower)


def test_edge_math_with_spaces_and_commands():
    # Math string with spaces and latex commands
    codeflash_output = strip_math(
        "$ \\rm{A} \\times \\cal{B} $"
    )  # 3.51μs -> 3.23μs (8.58% faster)


def test_edge_math_with_no_latex_commands():
    # Math string with no latex commands
    codeflash_output = strip_math("$ABC$")  # 2.12μs -> 1.83μs (16.0% faster)


def test_edge_math_with_braces_only():
    # Math string with only braces
    codeflash_output = strip_math("${A}$")  # 2.70μs -> 2.23μs (21.0% faster)


def test_edge_math_with_special_characters():
    # Math string with special characters
    codeflash_output = strip_math("$\\rm{A!@#}$")  # 2.85μs -> 2.48μs (15.1% faster)


def test_edge_math_with_multiple_nested_commands():
    # Math string with nested commands
    codeflash_output = strip_math(
        "$\\mathdefault{\\rm{A}}$"
    )  # 3.20μs -> 2.88μs (11.0% faster)


def test_edge_math_with_multiple_same_command():
    # Math string with repeated latex commands
    codeflash_output = strip_math("$\\rm{A}\\rm{B}$")  # 3.05μs -> 2.73μs (11.8% faster)


def test_edge_math_with_command_and_no_braces():
    # Math string with command and no braces
    codeflash_output = strip_math("$\\rmA$")  # 2.47μs -> 2.07μs (19.4% faster)


def test_edge_math_with_command_and_braces_and_spaces():
    # Math string with command, braces, and spaces
    codeflash_output = strip_math("$\\rm{A B}$")  # 2.82μs -> 2.50μs (12.6% faster)


def test_edge_math_with_empty_braces():
    # Math string with empty braces
    codeflash_output = strip_math("$\\rm{}$")  # 2.71μs -> 2.32μs (16.6% faster)


def test_edge_math_with_command_and_numbers():
    # Math string with command and numbers
    codeflash_output = strip_math("$\\rm{123}$")  # 2.88μs -> 2.38μs (20.8% faster)


def test_edge_math_with_command_and_underscore():
    # Math string with command and underscore
    codeflash_output = strip_math("$\\rm{A_B}$")  # 2.83μs -> 2.38μs (18.9% faster)


def test_edge_math_with_command_and_multiple_symbols():
    # Math string with command and multiple symbols
    codeflash_output = strip_math("$\\rm{A+B=C}$")  # 2.84μs -> 2.42μs (17.6% faster)


def test_edge_math_with_multiple_types_of_commands():
    # Math string with several types of commands
    codeflash_output = strip_math(
        "$\\cal{A} + \\it{B} + \\tt{C}$"
    )  # 3.63μs -> 3.25μs (11.7% faster)


# --- LARGE SCALE TEST CASES ---


def test_large_scale_long_math_string():
    # Large math string with many latex commands
    s = (
        "$"
        + " ".join(
            [
                f"\\rm{{A{i}}} \\cal{{B{i}}} \\tt{{C{i}}} \\it{{D{i}}} \\mathdefault{{E{i}}} \\times"
                for i in range(100)
            ]
        )
        + "$"
    )
    expected = " ".join([f"A{i} B{i} C{i} D{i} E{i} x" for i in range(100)])
    codeflash_output = strip_math(s)  # 42.3μs -> 42.0μs (0.636% faster)


def test_large_scale_long_non_math_string():
    # Large non-math string should remain unchanged
    s = " ".join(
        [
            f"\\rm{{A{i}}} \\cal{{B{i}}} \\tt{{C{i}}} \\it{{D{i}}} \\mathdefault{{E{i}}} \\times"
            for i in range(100)
        ]
    )
    codeflash_output = strip_math(s)  # 932ns -> 922ns (1.08% faster)


def test_large_scale_math_string_with_no_commands():
    # Large math string with no latex commands
    s = "$" + " ".join([f"X{i}" for i in range(1000)]) + "$"
    expected = " ".join([f"X{i}" for i in range(1000)])
    codeflash_output = strip_math(s)  # 13.7μs -> 13.4μs (2.50% faster)


def test_large_scale_math_string_with_mixed_commands():
    # Large math string with mixed commands and plain text
    s = "$" + " ".join([f"\\rm{{A{i}}} B{i} \\times" for i in range(500)]) + "$"
    expected = " ".join([f"A{i} B{i} x" for i in range(500)])
    codeflash_output = strip_math(s)  # 51.3μs -> 50.3μs (1.99% faster)


def test_large_scale_math_string_with_nested_braces():
    # Large math string with nested braces
    s = "$" + " ".join([f"\\mathdefault{{{{A{i}}}}}" for i in range(300)]) + "$"
    expected = " ".join([f"A{i}" for i in range(300)])
    codeflash_output = strip_math(s)  # 29.8μs -> 29.4μs (1.37% faster)


def test_large_scale_math_string_with_special_characters():
    # Large math string with special characters
    s = "$" + " ".join([f"\\rm{{!@#{i}}}" for i in range(200)]) + "$"
    expected = " ".join([f"!@#{i}" for i in range(200)])
    codeflash_output = strip_math(s)  # 14.9μs -> 14.4μs (3.18% faster)


def test_large_scale_math_string_with_spaces():
    # Large math string with spaces and commands
    s = "$" + " ".join([f" \\rm{{A{i}}} " for i in range(400)]) + "$"
    expected = " ".join([f" A{i} " for i in range(400)])
    codeflash_output = strip_math(s)  # 25.1μs -> 24.8μs (1.25% faster)


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

from matplotlib.cbook import strip_math

# unit tests

# ----------------------------
# 1. Basic Test Cases
# ----------------------------


def test_non_math_string():
    # Should return unchanged if not math
    codeflash_output = strip_math("hello world")  # 877ns -> 907ns (3.31% slower)
    codeflash_output = strip_math("12345")  # 316ns -> 355ns (11.0% slower)
    codeflash_output = strip_math("")  # 226ns -> 237ns (4.64% slower)


def test_simple_math_delimiters():
    # Should strip $ delimiters
    codeflash_output = strip_math("$x$")  # 2.04μs -> 1.67μs (22.3% faster)
    codeflash_output = strip_math("$123$")  # 1.06μs -> 885ns (19.8% faster)


def test_math_with_latex_commands():
    # Should replace \times with x
    codeflash_output = strip_math("$2 \\times 2$")  # 2.74μs -> 2.39μs (14.8% faster)
    # Should remove \mathdefault
    codeflash_output = strip_math(
        "$\\mathdefault{A}$"
    )  # 1.57μs -> 1.43μs (10.4% faster)
    # Should remove \rm, \cal, \tt, \it
    codeflash_output = strip_math("$\\rm{foo}$")  # 1.24μs -> 1.01μs (22.4% faster)
    codeflash_output = strip_math("$\\cal{bar}$")  # 955ns -> 809ns (18.0% faster)
    codeflash_output = strip_math("$\\tt{baz}$")  # 830ns -> 687ns (20.8% faster)
    codeflash_output = strip_math("$\\it{qux}$")  # 805ns -> 687ns (17.2% faster)


def test_multiple_latex_commands():
    # Should handle multiple commands in one string
    codeflash_output = strip_math(
        "$\\rm{A} + \\cal{B}$"
    )  # 3.22μs -> 2.87μs (11.9% faster)
    codeflash_output = strip_math(
        "$\\mathdefault{A} \\times \\mathdefault{B}$"
    )  # 1.96μs -> 1.84μs (6.75% faster)


def test_nested_braces_and_backslashes():
    # Should remove all braces and backslashes
    codeflash_output = strip_math("$\\rm{\\cal{A}}$")  # 3.03μs -> 2.67μs (13.4% faster)
    codeflash_output = strip_math(
        "$\\mathdefault{\\rm{A}}$"
    )  # 1.59μs -> 1.47μs (8.50% faster)
    codeflash_output = strip_math(
        "$\\it{\\tt{\\cal{foo}}}$"
    )  # 1.61μs -> 1.54μs (4.49% faster)


def test_only_braces_and_backslashes():
    # Should remove braces and backslashes
    codeflash_output = strip_math("${foo}$")  # 2.51μs -> 2.25μs (11.5% faster)
    codeflash_output = strip_math("$\\foo$")  # 1.09μs -> 883ns (23.4% faster)
    codeflash_output = strip_math("$\\{foo\\}$")  # 1.09μs -> 961ns (13.3% faster)


# ----------------------------
# 2. Edge Test Cases
# ----------------------------


def test_empty_string():
    # Should return empty string
    codeflash_output = strip_math("")  # 543ns -> 615ns (11.7% slower)


def test_single_character():
    # Should not strip anything
    codeflash_output = strip_math("a")  # 522ns -> 600ns (13.0% slower)
    codeflash_output = strip_math("$")  # 198ns -> 195ns (1.54% faster)


def test_two_dollar_signs():
    # Should not strip if not math (e.g. "$")
    codeflash_output = strip_math("$")  # 1.92μs -> 1.64μs (17.0% faster)


def test_string_with_only_delimiters():
    # Should return empty string
    codeflash_output = strip_math(
        "$\\mathdefault{}$"
    )  # 2.93μs -> 2.56μs (14.6% faster)


def test_unmatched_delimiters():
    # Should not strip if delimiters are not both present
    codeflash_output = strip_math("$foo")  # 810ns -> 895ns (9.50% slower)
    codeflash_output = strip_math("foo$")  # 285ns -> 303ns (5.94% slower)


def test_math_with_no_latex_commands():
    # Just strip $ if no commands
    codeflash_output = strip_math("$foobar$")  # 2.28μs -> 1.93μs (18.6% faster)


def test_math_with_escaped_characters():
    # Should remove all backslashes
    codeflash_output = strip_math("$foo\\bar$")  # 2.61μs -> 2.17μs (20.1% faster)
    codeflash_output = strip_math("$foo\\\\bar$")  # 1.15μs -> 1.01μs (14.3% faster)


def test_math_with_nested_braces():
    # Should remove all braces
    codeflash_output = strip_math("$foo{{bar}}$")  # 2.72μs -> 2.41μs (12.7% faster)


def test_math_with_all_commands():
    # Should remove all known commands and braces/backslashes
    codeflash_output = strip_math(
        "$\\mathdefault{\\rm{\\cal{\\tt{\\it{Z}}}}}$"
    )  # 3.81μs -> 3.48μs (9.24% faster)


def test_math_with_unknown_command():
    # Should remove leading backslash but not unknown command
    codeflash_output = strip_math("$\\unknown{foo}$")  # 2.81μs -> 2.40μs (17.3% faster)


def test_math_with_numbers_and_commands():
    # Should process numbers and commands together
    codeflash_output = strip_math(
        "$1 + 2 \\times 3$"
    )  # 2.70μs -> 2.42μs (11.4% faster)


def test_math_with_special_characters():
    # Should preserve special characters not in the replacement list
    codeflash_output = strip_math(
        "$\\mathdefault{A}_1$"
    )  # 3.00μs -> 2.57μs (16.5% faster)
    codeflash_output = strip_math("$\\cal{B}^2$")  # 1.32μs -> 1.21μs (9.69% faster)


def test_math_with_spaces():
    # Should preserve spaces
    codeflash_output = strip_math(
        "$ \\mathdefault{A} + \\mathdefault{B} $"
    )  # 3.28μs -> 2.96μs (10.7% faster)


def test_string_with_dollar_inside():
    # Should not strip if not at both ends
    codeflash_output = strip_math("foo$bar$baz")  # 857ns -> 911ns (5.93% slower)
    codeflash_output = strip_math("foo$bar")  # 260ns -> 292ns (11.0% slower)


# ----------------------------
# 3. Large Scale Test Cases
# ----------------------------


def test_large_non_math_string():
    # Should handle large non-math string efficiently
    s = "a" * 1000
    codeflash_output = strip_math(s)  # 935ns -> 975ns (4.10% slower)


def test_large_math_string_no_commands():
    # Should strip only $ from large math string
    s = "$" + "a" * 998 + "$"
    expected = "a" * 998
    codeflash_output = strip_math(s)  # 6.20μs -> 5.80μs (6.99% faster)


def test_large_math_string_with_commands():
    # Should replace all commands and remove braces/backslashes in large input
    s = "$" + "\\mathdefault{" * 10 + "A" * 980 + "}" * 10 + "$"
    expected = "A" * 980
    codeflash_output = strip_math(s)  # 6.71μs -> 6.30μs (6.46% faster)


def test_large_math_string_with_many_times():
    # Should replace all \times with x in a large string
    s = "$" + " \\times ".join(["A"] * 100) + "$"
    expected = " x ".join(["A"] * 100)
    codeflash_output = strip_math(s)  # 5.92μs -> 5.49μs (7.87% faster)


def test_large_math_string_with_mixed_commands():
    # Mix of all commands and braces
    s = "$" + "\\rm{A}" * 200 + "$"
    expected = "A" * 200
    codeflash_output = strip_math(s)  # 11.9μs -> 11.4μs (4.29% faster)


def test_large_math_string_with_nested_commands():
    # Deeply nested commands/braces
    s = "$" + "\\mathdefault{\\rm{\\cal{\\tt{\\it{" + "Z" * 900 + "}}}}}$"
    expected = "Z" * 900
    codeflash_output = strip_math(s)  # 6.03μs -> 5.80μs (3.93% faster)


def test_large_math_string_with_numbers_and_times():
    # Many numbers and \times
    s = "$" + " \\times ".join(str(i) for i in range(100)) + "$"
    expected = " x ".join(str(i) for i in range(100))
    codeflash_output = strip_math(s)  # 6.62μs -> 6.04μs (9.67% faster)


def test_large_math_string_with_unknown_commands():
    # Should remove backslashes but not unknown command names
    s = "$" + "\\foo{" * 50 + "BAR" + "}" * 50 + "$"
    expected = "foo" * 50 + "BAR"
    codeflash_output = strip_math(s)  # 5.54μs -> 5.21μs (6.37% faster)


def test_large_math_string_with_all_features():
    # Combine all features in a large string
    s = (
        "$"
        + "\\mathdefault{A} + \\rm{B} + \\cal{C} + \\tt{D} + \\it{E} + F \\times G" * 50
        + "$"
    )
    expected_piece = "A + B + C + D + E + F x G"
    expected = expected_piece * 50
    codeflash_output = strip_math(s)  # 22.3μs -> 22.0μs (1.56% 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-strip_math-misbglmu and push.