⚡️ Speed up function levenshtein_distance by 12% in PR #924 (small-fixes)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #924

If you approve this dependent PR, these changes will be merged into the original PR branch small-fixes.

This PR will be automatically closed if the original PR is merged.

---

📄 12% (0.12x) speedup for levenshtein_distance in codeflash/discovery/functions_to_optimize.py

⏱️ Runtime : 1.91 seconds → 1.71 seconds (best of 6 runs)

📝 Explanation and details

The optimized version achieves an 11% speedup through several key memory and algorithmic optimizations:

Primary Optimizations:

1. Pre-allocated buffer reuse: Instead of creating a new newDistances list on every iteration (16,721 allocations in the profiler), the optimized version uses two pre-allocated lists (previous and current) that are swapped via reference assignment. This eliminates ~16K list allocations per call.

2. Eliminated tuple construction in min(): The original code creates a 3-element tuple for min((a, b, c)) 8+ million times. The optimized version uses inline comparisons (a if a < b else b), avoiding tuple overhead entirely.

3. Direct indexing over enumerate: Replaced enumerate(s1) and enumerate(s2) with range(len1) and direct indexing, eliminating tuple unpacking overhead in the inner loops.

4. Cached string lengths: Pre-computing len1 and len2 avoids repeated len() calls.

Performance Impact by Test Case:

• Medium-length strings (6-10 chars): 20-30% faster - best case for the optimizations
• Large identical/similar strings (1000+ chars): 20-25% faster for different strings, but slower for identical strings due to overhead
• Very short strings (1-2 chars): Often 10-20% slower due to setup overhead outweighing benefits
• Empty string cases: Consistently slower due to initialization costs

Context Impact:
The function is used in closest_matching_file_function_name() for fuzzy matching function names. Since this involves comparing many short-to-medium function names, the optimization should provide measurable benefits in code discovery workflows where hundreds of function name comparisons occur.

The optimization is most effective for the common case of comparing function names (typically 5-20 characters), where memory allocation savings outweigh setup costs.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
import pytest  # used for our unit tests

from codeflash.discovery.functions_to_optimize import levenshtein_distance

# unit tests

# ------------------------
# 1. BASIC TEST CASES
# ------------------------


def test_identical_strings():
    # Identical strings should have distance 0
    codeflash_output = levenshtein_distance("kitten", "kitten")  # 11.9μs -> 9.96μs (19.9% faster)
    codeflash_output = levenshtein_distance("", "")  # 1.10μs -> 1.27μs (13.4% slower)
    codeflash_output = levenshtein_distance("a", "a")  # 1.15μs -> 1.41μs (18.4% slower)


def test_single_insertion():
    # One insertion required
    codeflash_output = levenshtein_distance("kitten", "kittens")  # 13.3μs -> 10.7μs (23.6% faster)
    codeflash_output = levenshtein_distance("abc", "abac")  # 4.30μs -> 3.75μs (14.7% faster)
    codeflash_output = levenshtein_distance("", "a")  # 952ns -> 1.40μs (32.1% slower)


def test_single_deletion():
    # One deletion required
    codeflash_output = levenshtein_distance("kittens", "kitten")  # 13.2μs -> 10.6μs (24.4% faster)
    codeflash_output = levenshtein_distance("abac", "abc")  # 4.49μs -> 3.71μs (21.1% faster)
    codeflash_output = levenshtein_distance("a", "")  # 932ns -> 1.39μs (33.0% slower)


def test_single_substitution():
    # One substitution required
    codeflash_output = levenshtein_distance("kitten", "sitten")  # 12.0μs -> 9.64μs (24.0% faster)
    codeflash_output = levenshtein_distance("abc", "adc")  # 3.94μs -> 3.25μs (21.3% faster)
    codeflash_output = levenshtein_distance("a", "b")  # 1.37μs -> 1.46μs (6.22% slower)


def test_mixed_operations():
    # Multiple operations required
    codeflash_output = levenshtein_distance("kitten", "sitting")  # 13.4μs -> 10.5μs (28.0% faster)
    codeflash_output = levenshtein_distance("flaw", "lawn")  # 5.00μs -> 4.32μs (15.8% faster)
    codeflash_output = levenshtein_distance("intention", "execution")  # 18.4μs -> 13.9μs (32.3% faster)


# ------------------------
# 2. EDGE TEST CASES
# ------------------------


def test_empty_and_nonempty():
    # Empty and non-empty string
    codeflash_output = levenshtein_distance("", "abc")  # 2.84μs -> 3.29μs (13.7% slower)
    codeflash_output = levenshtein_distance("abc", "")  # 1.47μs -> 1.78μs (17.4% slower)
    codeflash_output = levenshtein_distance("", "")  # 861ns -> 891ns (3.37% slower)


def test_case_sensitivity():
    # Function is case-sensitive
    codeflash_output = levenshtein_distance("abc", "ABC")  # 6.80μs -> 5.48μs (24.1% faster)
    codeflash_output = levenshtein_distance("Kitten", "kitten")  # 9.53μs -> 7.37μs (29.2% faster)


def test_unicode_characters():
    # Unicode and multi-byte characters
    codeflash_output = levenshtein_distance("café", "cafe")  # 8.16μs -> 6.68μs (22.2% faster)
    codeflash_output = levenshtein_distance("你好", "您好")  # 3.21μs -> 2.99μs (7.37% faster)
    codeflash_output = levenshtein_distance("😀", "😃")  # 1.58μs -> 1.78μs (11.2% slower)
    codeflash_output = levenshtein_distance("😀😃", "😀")  # 1.79μs -> 1.97μs (9.17% slower)


def test_whitespace_and_special_chars():
    # Whitespace and special characters
    codeflash_output = levenshtein_distance("a b", "ab")  # 5.22μs -> 4.70μs (11.1% faster)
    codeflash_output = levenshtein_distance("a_b", "ab")  # 3.03μs -> 2.56μs (18.0% faster)
    codeflash_output = levenshtein_distance("a\nb", "ab")  # 2.42μs -> 2.12μs (14.2% faster)
    codeflash_output = levenshtein_distance("a\tb", "a b")  # 3.47μs -> 2.79μs (24.0% faster)


def test_completely_different_strings():
    # No characters in common
    codeflash_output = levenshtein_distance("abc", "def")  # 6.54μs -> 5.50μs (18.9% faster)
    codeflash_output = levenshtein_distance("123", "abc")  # 3.83μs -> 3.24μs (18.3% faster)


def test_substring_cases():
    # One string is a substring of the other
    codeflash_output = levenshtein_distance("abc", "a")  # 4.13μs -> 4.34μs (4.84% slower)
    codeflash_output = levenshtein_distance("a", "abc")  # 2.16μs -> 2.40μs (9.98% slower)


def test_long_repeated_characters():
    # Strings with repeated characters
    codeflash_output = levenshtein_distance("aaaaa", "aaa")  # 4.71μs -> 4.86μs (3.09% slower)
    codeflash_output = levenshtein_distance("abcabcabc", "abc")  # 7.97μs -> 6.72μs (18.6% faster)


def test_swap_adjacent_characters():
    # Swapping adjacent characters counts as two operations
    codeflash_output = levenshtein_distance("ab", "ba")  # 4.39μs -> 4.16μs (5.53% faster)
    codeflash_output = levenshtein_distance("converse", "convesre")  # 15.3μs -> 11.8μs (30.0% faster)


def test_numeric_strings():
    # Numeric strings
    codeflash_output = levenshtein_distance("12345", "12354")  # 9.52μs -> 8.10μs (17.6% faster)


# ------------------------
# 3. LARGE SCALE TEST CASES
# ------------------------


def test_large_identical_strings():
    # Large identical strings should have distance 0
    s = "a" * 1000
    codeflash_output = levenshtein_distance(s, s)  # 49.4ms -> 71.9ms (31.3% slower)


def test_large_single_insertion():
    # Single insertion in a large string
    s1 = "a" * 999
    s2 = "a" * 500 + "b" + "a" * 499
    codeflash_output = levenshtein_distance(s1, s2)  # 49.1ms -> 69.5ms (29.4% slower)


def test_large_completely_different_strings():
    # Large strings with no characters in common
    s1 = "a" * 1000
    s2 = "b" * 1000
    codeflash_output = levenshtein_distance(s1, s2)  # 199ms -> 161ms (23.7% faster)


def test_large_partial_overlap():
    # Large strings with partial overlap
    s1 = "abc" * 333 + "x"
    s2 = "abc" * 333 + "y"
    codeflash_output = levenshtein_distance(s1, s2)  # 150ms -> 129ms (16.0% faster)


def test_large_prefix_suffix_difference():
    # Large strings differing only at the start and end
    s1 = "x" + "a" * 998 + "y"
    s2 = "z" + "a" * 998 + "w"
    # x->z, y->w: 2 substitutions
    codeflash_output = levenshtein_distance(s1, s2)  # 48.9ms -> 68.4ms (28.4% slower)


def test_large_one_empty():
    # One large, one empty string
    s1 = "a" * 1000
    s2 = ""
    codeflash_output = levenshtein_distance(s1, s2)  # 151μs -> 129μs (17.1% faster)
    codeflash_output = levenshtein_distance(s2, s1)  # 149μs -> 128μs (16.0% faster)


# ------------------------
# 4. ADDITIONAL EDGE CASES
# ------------------------


def test_non_ascii_and_emojis():
    # Mix of unicode, emojis, and ascii
    codeflash_output = levenshtein_distance("hello😀", "hello😃")  # 13.4μs -> 10.8μs (23.6% faster)
    codeflash_output = levenshtein_distance("mañana", "manana")  # 9.15μs -> 7.45μs (22.7% faster)
    codeflash_output = levenshtein_distance("💩", "💩")  # 1.23μs -> 1.53μs (19.6% slower)


def test_long_strings_with_small_difference():
    # Large strings with a single difference in the middle
    s1 = "a" * 499 + "b" + "a" * 500
    s2 = "a" * 1000
    codeflash_output = levenshtein_distance(s1, s2)  # 50.7ms -> 71.3ms (28.9% slower)


def test_strings_with_numbers_and_letters():
    # Mix of numbers and letters
    codeflash_output = levenshtein_distance("abc123", "abc124")  # 12.6μs -> 10.2μs (24.3% faster)
    codeflash_output = levenshtein_distance("abc123", "abx123")  # 9.65μs -> 7.33μs (31.6% faster)


def test_strings_with_symbols():
    # Special symbols
    codeflash_output = levenshtein_distance("hello!", "hello?")  # 12.1μs -> 9.65μs (25.5% faster)
    codeflash_output = levenshtein_distance("!@#$", "!@#")  # 4.51μs -> 3.84μs (17.5% faster)


# ------------------------
# 5. PYTEST PARAMETRIZATION FOR BASIC CASES
# ------------------------


@pytest.mark.parametrize(
    "s1,s2,expected",
    [
        ("", "", 0),
        ("a", "", 1),
        ("", "a", 1),
        ("abc", "abc", 0),
        ("abc", "ab", 1),
        ("abc", "a", 2),
        ("abc", "xbc", 1),
        ("kitten", "sitting", 3),
        ("flaw", "lawn", 2),
        ("gumbo", "gambol", 2),
    ],
)
def test_parametrized_basic_cases(s1, s2, expected):
    # Parametrized basic cases for coverage
    codeflash_output = levenshtein_distance(s1, s2)  # 61.8μs -> 54.7μs (12.9% faster)


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

from __future__ import annotations

# imports
import pytest  # used for our unit tests

from codeflash.discovery.functions_to_optimize import levenshtein_distance

# unit tests

# --- Basic Test Cases ---


def test_identical_strings():
    # Test case: Both strings are identical
    codeflash_output = levenshtein_distance("kitten", "kitten")  # 11.7μs -> 9.27μs (26.2% faster)
    codeflash_output = levenshtein_distance("", "")  # 1.07μs -> 1.40μs (23.6% slower)
    codeflash_output = levenshtein_distance("a", "a")  # 1.12μs -> 1.40μs (20.0% slower)


def test_simple_insertions():
    # Test case: One string is a single insertion away from the other
    codeflash_output = levenshtein_distance("kitten", "kittena")  # 13.6μs -> 10.5μs (29.4% faster)
    codeflash_output = levenshtein_distance("abc", "abcd")  # 4.50μs -> 3.45μs (30.5% faster)
    codeflash_output = levenshtein_distance("a", "ab")  # 1.37μs -> 1.79μs (23.5% slower)


def test_simple_deletions():
    # Test case: One string is a single deletion away from the other
    codeflash_output = levenshtein_distance("kitten", "kittn")  # 10.4μs -> 8.82μs (18.2% faster)
    codeflash_output = levenshtein_distance("abcd", "abc")  # 4.33μs -> 3.65μs (18.7% faster)
    codeflash_output = levenshtein_distance("ab", "a")  # 1.48μs -> 1.70μs (12.9% slower)


def test_simple_substitutions():
    # Test case: One string is a single substitution away from the other
    codeflash_output = levenshtein_distance("kitten", "kittan")  # 11.7μs -> 9.40μs (24.4% faster)
    codeflash_output = levenshtein_distance("abc", "abd")  # 3.81μs -> 3.00μs (27.1% faster)
    codeflash_output = levenshtein_distance("a", "b")  # 1.33μs -> 1.46μs (8.95% slower)


def test_multiple_edits():
    # Test case: Multiple edits required
    codeflash_output = levenshtein_distance("kitten", "sitting")  # 13.2μs -> 10.5μs (25.8% faster)
    codeflash_output = levenshtein_distance("flaw", "lawn")  # 5.44μs -> 4.27μs (27.5% faster)
    codeflash_output = levenshtein_distance("gumbo", "gambol")  # 7.71μs -> 6.20μs (24.4% faster)


def test_empty_and_nonempty():
    # Test case: One string is empty, the other is not
    codeflash_output = levenshtein_distance("", "abc")  # 2.75μs -> 3.36μs (18.2% slower)
    codeflash_output = levenshtein_distance("abc", "")  # 1.33μs -> 1.77μs (24.9% slower)
    codeflash_output = levenshtein_distance("", "a")  # 791ns -> 992ns (20.3% slower)
    codeflash_output = levenshtein_distance("a", "")  # 702ns -> 831ns (15.5% slower)


def test_case_sensitivity():
    # Test case: Case sensitivity
    codeflash_output = levenshtein_distance("abc", "ABC")  # 6.66μs -> 5.42μs (22.9% faster)
    codeflash_output = levenshtein_distance("aBc", "AbC")  # 4.21μs -> 3.19μs (32.0% faster)


def test_unicode_characters():
    # Test case: Unicode characters
    codeflash_output = levenshtein_distance("café", "cafe")  # 8.29μs -> 6.55μs (26.4% faster)
    codeflash_output = levenshtein_distance("naïve", "naive")  # 7.47μs -> 5.72μs (30.7% faster)
    codeflash_output = levenshtein_distance("😀", "😃")  # 1.78μs -> 1.78μs (0.056% faster)


def test_special_characters():
    # Test case: Special characters
    codeflash_output = levenshtein_distance("hello!", "hello?")  # 11.7μs -> 9.30μs (26.1% faster)
    codeflash_output = levenshtein_distance("!@#", "!@#")  # 3.59μs -> 3.07μs (17.0% faster)
    codeflash_output = levenshtein_distance("!@#", "#@!")  # 3.51μs -> 2.75μs (27.8% faster)


# --- Edge Test Cases ---


def test_one_empty_one_long():
    # Test case: One string is empty, the other is long
    long_str = "a" * 100
    codeflash_output = levenshtein_distance("", long_str)  # 16.9μs -> 15.2μs (11.1% faster)
    codeflash_output = levenshtein_distance(long_str, "")  # 15.2μs -> 13.6μs (11.8% faster)


def test_both_empty():
    # Test case: Both strings are empty
    codeflash_output = levenshtein_distance("", "")  # 2.10μs -> 2.42μs (13.2% slower)


def test_single_character_strings():
    # Test case: Single character strings, different and same
    codeflash_output = levenshtein_distance("a", "b")  # 3.47μs -> 3.40μs (2.09% faster)
    codeflash_output = levenshtein_distance("a", "a")  # 1.24μs -> 1.60μs (22.5% slower)


def test_reversed_strings():
    # Test case: Strings that are reverses of each other
    codeflash_output = levenshtein_distance("abcd", "dcba")  # 8.35μs -> 6.88μs (21.2% faster)


def test_completely_different_strings():
    # Test case: Completely different strings of same length
    codeflash_output = levenshtein_distance("aaaa", "bbbb")  # 8.31μs -> 6.68μs (24.3% faster)


def test_long_repeated_characters():
    # Test case: Long strings with repeated characters
    codeflash_output = levenshtein_distance("aaaaaaaaaa", "aaaaaaaaab")  # 12.4μs -> 12.4μs (0.323% slower)
    codeflash_output = levenshtein_distance("aaaaaaaaaa", "bbbbbbbbbb")  # 23.5μs -> 17.0μs (38.0% faster)


def test_no_common_characters():
    # Test case: No common characters
    codeflash_output = levenshtein_distance("xyz", "abc")  # 6.56μs -> 5.34μs (22.9% faster)


def test_whitespace_handling():
    # Test case: Whitespace differences
    codeflash_output = levenshtein_distance("abc", "a bc")  # 7.02μs -> 5.79μs (21.3% faster)
    codeflash_output = levenshtein_distance("abc ", "abc")  # 4.61μs -> 3.79μs (21.7% faster)
    codeflash_output = levenshtein_distance("abc", " a b c ")  # 6.48μs -> 5.15μs (25.9% faster)


def test_mixed_types():
    # Test case: Numeric and alphabetic
    codeflash_output = levenshtein_distance("123", "abc")  # 6.24μs -> 5.36μs (16.5% faster)
    codeflash_output = levenshtein_distance("1a2b3c", "abc")  # 6.32μs -> 4.91μs (28.8% faster)


def test_long_non_overlapping():
    # Test case: Long strings, no overlap
    codeflash_output = levenshtein_distance("a" * 50, "b" * 50)  # 485μs -> 357μs (36.0% faster)


# --- Large Scale Test Cases ---


def test_large_identical_strings():
    # Test case: Large identical strings
    s = "abcdefghij" * 100  # length 1000
    codeflash_output = levenshtein_distance(s, s)  # 183ms -> 146ms (24.7% faster)


def test_large_single_insertion():
    # Test case: Large string with a single insertion
    s1 = "abcdefghij" * 99 + "abcdefghij"  # length 1000
    s2 = s1 + "x"
    codeflash_output = levenshtein_distance(s1, s2)  # 182ms -> 147ms (24.2% faster)


def test_large_single_substitution():
    # Test case: Large string with a single substitution at the end
    s1 = "abcdefghij" * 99 + "abcdefghij"  # length 1000
    s2 = s1[:-1] + "x"
    codeflash_output = levenshtein_distance(s1, s2)  # 182ms -> 147ms (23.8% faster)


def test_large_completely_different():
    # Test case: Large strings, no overlap
    s1 = "a" * 1000
    s2 = "b" * 1000
    codeflash_output = levenshtein_distance(s1, s2)  # 199ms -> 162ms (23.2% faster)


def test_large_partial_overlap():
    # Test case: Large strings, partial overlap
    s1 = "a" * 500 + "b" * 500
    s2 = "a" * 400 + "b" * 600
    # 100 a's removed, 100 b's added
    codeflash_output = levenshtein_distance(s1, s2)  # 123ms -> 114ms (8.10% faster)


def test_large_insertions_deletions():
    # Test case: Large strings, insertions and deletions
    s1 = "abcde" * 200  # length 1000
    s2 = "abcde" * 199 + "xyz"  # length 998
    # Remove 5, add 3
    codeflash_output = levenshtein_distance(s1, s2)  # 167ms -> 141ms (18.5% faster)


def test_large_unicode_strings():
    # Test case: Large strings with unicode characters
    s1 = "😀" * 500 + "😃" * 500
    s2 = "😀" * 500 + "😄" * 500
    # 500 substitutions (😃 -> 😄)
    codeflash_output = levenshtein_distance(s1, s2)  # 172ms -> 147ms (17.3% faster)


def test_large_strings_with_spaces():
    # Test case: Large strings with spaces
    s1 = "a b " * 250  # length 1000
    s2 = ("ab " * 333) + "a"  # length 1000
    # The minimum edit distance can be calculated by hand:
    # Each "a b " vs "ab " is one deletion (space after 'a')
    # 250 deletions, and the last "a" is an insertion
    codeflash_output = levenshtein_distance(s1, s2)  # 151ms -> 131ms (15.0% faster)


# --- Deterministic and Mutation-Resistant Properties ---


def test_mutation_resistance():
    # Test case: Changing any character should affect the distance
    codeflash_output = levenshtein_distance("abcdef", "abcdeg")  # 12.7μs -> 10.3μs (23.0% faster)
    codeflash_output = levenshtein_distance("abcdef", "abczef")  # 9.70μs -> 7.46μs (29.9% faster)
    codeflash_output = levenshtein_distance("abcdef", "abczeg")  # 9.48μs -> 6.89μs (37.5% faster)
    # Changing order should affect the distance
    codeflash_output = levenshtein_distance("abcdef", "fedcba")  # 8.96μs -> 7.11μs (25.9% faster)
    # Adding a character should increase the distance by 1
    codeflash_output = levenshtein_distance("abcdef", "abcdefg")  # 9.79μs -> 7.57μs (29.2% faster)


# --- Parameterized Tests for Broad Coverage ---


@pytest.mark.parametrize(
    "s1, s2, expected",
    [
        ("", "", 0),
        ("a", "", 1),
        ("", "a", 1),
        ("abc", "abc", 0),
        ("abc", "ab", 1),
        ("abc", "a", 2),
        ("abc", "", 3),
        ("abc", "def", 3),
        ("kitten", "sitting", 3),
        ("flaw", "lawn", 2),
        ("gumbo", "gambol", 2),
        ("", "a" * 10, 10),
        ("a" * 10, "", 10),
        ("a" * 10, "a" * 10, 0),
        ("a" * 10, "b" * 10, 10),
        ("abc", "acb", 2),
        ("abc", "bac", 2),
        ("abc", "cab", 2),
    ],
)
def test_parameterized_cases(s1, s2, expected):
    # Parameterized test cases for broad coverage
    codeflash_output = levenshtein_distance(s1, s2)  # 128μs -> 113μs (12.7% 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-pr924-2025-11-17T17.24.40 and push.