⚡️ Speed up function _rank_population by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for _rank_population in optuna/samplers/nsgaii/_elite_population_selection_strategy.py

⏱️ Runtime : 12.2 milliseconds → 11.6 milliseconds (best of 8 runs)

📝 Explanation and details

The optimized code achieves a 5% speedup through several key optimizations:

1. List Comprehension in _evaluate_penalty

• Replaced explicit for-loop with list comprehension using walrus operator: (constraints := trial.system_attrs.get(_CONSTRAINTS_KEY))
• This eliminates repeated function calls and reduces Python bytecode overhead
• Line profiler shows the penalty calculation time decreased from 9.88ms to 7.70ms (22% faster)

2. Bitwise Operations in _fast_non_domination_rank

• Changed np.logical_and to bitwise operators: (~is_penalty_nan) & (penalty <= 0)
• Bitwise operations are faster for boolean NumPy arrays as they bypass function call overhead

3. Conditional Execution Guards

• Added if feasible_count:, if infeasible_count:, and if penalty_nan_count: checks
• Prevents unnecessary calls to _calculate_nondomination_rank when no trials exist in a category
• Reduces function call overhead and array allocation for empty segments

4. Optimized Array Size Calculation

• Replaced max(domination_ranks) + 1 with domination_ranks.max() + 1 in _rank_population
• NumPy's .max() method is faster than Python's built-in max() function for arrays

Performance Impact by Test Case:

• Large populations benefit most: 21.8% faster for 1000 single-objective trials, 15.2% faster for constrained populations
• Constrained optimization scenarios: 6.79-20.3% improvements when handling feasible/infeasible trials
• Small populations: Minimal overhead, some tests show slight slowdown due to additional conditional checks

The optimizations are particularly effective for scenarios with large populations and constrained optimization problems, where the reduced function call overhead and vectorized operations provide the most benefit.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
samplers_tests/test_nsgaii.py::test_rank_population_empty	4.91μs	4.69μs	4.78%✅
samplers_tests/test_nsgaii.py::test_rank_population_missing_constraint_values	976μs	978μs	-0.179%⚠️
samplers_tests/test_nsgaii.py::test_rank_population_no_constraints	885μs	886μs	-0.085%⚠️
samplers_tests/test_nsgaii.py::test_rank_population_with_constraints	2.39ms	2.29ms	4.58%✅

🌀 Generated Regression Tests and Runtime

from enum import Enum
from typing import Any

# imports
import pytest
from optuna.samplers.nsgaii._elite_population_selection_strategy import \
    _rank_population


# Minimal StudyDirection enum for testing
class StudyDirection(Enum):
    MINIMIZE = "minimize"
    MAXIMIZE = "maximize"

# Minimal FrozenTrial class for testing
class FrozenTrial:
    def __init__(self, values, system_attrs=None):
        self.values = values
        self.system_attrs = system_attrs or {}

# Constraints key used in system_attrs
_CONSTRAINTS_KEY = "constraints"
from optuna.samplers.nsgaii._elite_population_selection_strategy import \
    _rank_population

# -------------------------
# Unit Tests
# -------------------------

# Basic Test Cases

def test_empty_population_returns_empty():
    # Test that an empty population returns an empty list
    codeflash_output = _rank_population([], [StudyDirection.MINIMIZE]) # 1.82μs -> 1.49μs (22.0% faster)

def test_single_trial_single_objective_minimize():
    # Single trial, single objective, minimize direction
    t = FrozenTrial([1.0])
    codeflash_output = _rank_population([t], [StudyDirection.MINIMIZE]); result = codeflash_output # 141μs -> 148μs (4.57% slower)

def test_single_trial_single_objective_maximize():
    # Single trial, single objective, maximize direction
    t = FrozenTrial([1.0])
    codeflash_output = _rank_population([t], [StudyDirection.MAXIMIZE]); result = codeflash_output # 51.2μs -> 54.8μs (6.51% slower)

def test_two_trials_single_objective_minimize():
    # Two trials, single objective, minimize direction
    t1 = FrozenTrial([1.0])
    t2 = FrozenTrial([2.0])
    codeflash_output = _rank_population([t1, t2], [StudyDirection.MINIMIZE]); result = codeflash_output # 57.6μs -> 59.0μs (2.49% slower)

def test_two_trials_single_objective_maximize():
    # Two trials, single objective, maximize direction
    t1 = FrozenTrial([1.0])
    t2 = FrozenTrial([2.0])
    codeflash_output = _rank_population([t1, t2], [StudyDirection.MAXIMIZE]); result = codeflash_output # 50.3μs -> 52.0μs (3.24% slower)

def test_two_trials_two_objectives_minimize():
    # Two trials, two objectives, both minimize
    t1 = FrozenTrial([1.0, 2.0])
    t2 = FrozenTrial([2.0, 1.0])
    codeflash_output = _rank_population([t1, t2], [StudyDirection.MINIMIZE, StudyDirection.MINIMIZE]); result = codeflash_output # 176μs -> 170μs (3.44% faster)

def test_three_trials_two_objectives_minimize():
    # Three trials, two objectives, both minimize
    t1 = FrozenTrial([1.0, 2.0])
    t2 = FrozenTrial([2.0, 1.0])
    t3 = FrozenTrial([3.0, 3.0])
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE, StudyDirection.MINIMIZE]); result = codeflash_output # 138μs -> 137μs (0.802% faster)

def test_three_trials_two_objectives_maximize():
    # Three trials, two objectives, both maximize
    t1 = FrozenTrial([1.0, 2.0])
    t2 = FrozenTrial([2.0, 1.0])
    t3 = FrozenTrial([0.0, 0.0])
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MAXIMIZE, StudyDirection.MAXIMIZE]); result = codeflash_output # 119μs -> 123μs (3.40% slower)

def test_mixed_directions():
    # Two objectives, one minimize, one maximize
    t1 = FrozenTrial([1.0, 2.0])
    t2 = FrozenTrial([2.0, 1.0])
    t3 = FrozenTrial([0.0, 3.0])
    codeflash_output = _rank_population(
        [t1, t2, t3], [StudyDirection.MINIMIZE, StudyDirection.MAXIMIZE]
    ); result = codeflash_output # 109μs -> 114μs (4.90% slower)

# Edge Test Cases

def test_identical_trials():
    # All trials have identical objectives
    t1 = FrozenTrial([1.0, 2.0])
    t2 = FrozenTrial([1.0, 2.0])
    t3 = FrozenTrial([1.0, 2.0])
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE, StudyDirection.MINIMIZE]); result = codeflash_output # 112μs -> 113μs (1.29% slower)

def test_trials_with_nan_objectives():
    # Trials with NaN objectives should be handled gracefully
    import math
    t1 = FrozenTrial([1.0, 2.0])
    t2 = FrozenTrial([math.nan, 2.0])
    t3 = FrozenTrial([1.0, math.nan])
    t4 = FrozenTrial([math.nan, math.nan])
    # Should not crash, but all NaN trials are not better than any other
    codeflash_output = _rank_population([t1, t2, t3, t4], [StudyDirection.MINIMIZE, StudyDirection.MINIMIZE]); result = codeflash_output # 138μs -> 140μs (1.76% slower)


def test_constrained_feasible_and_infeasible():
    # Constrained: one feasible, one infeasible
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [0.0]})  # feasible
    t2 = FrozenTrial([2.0], system_attrs={_CONSTRAINTS_KEY: [1.0]})  # infeasible
    codeflash_output = _rank_population([t1, t2], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 185μs -> 174μs (6.79% faster)

def test_constrained_penalty_none():
    # Constrained: one trial with no penalty info
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [0.0]})  # feasible
    t2 = FrozenTrial([2.0], system_attrs={})  # no penalty info
    codeflash_output = _rank_population([t1, t2], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 107μs -> 103μs (3.27% faster)

def test_constrained_multiple_penalties():
    # Constrained: multiple constraints per trial
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [0.0, -1.0]})  # feasible
    t2 = FrozenTrial([2.0], system_attrs={_CONSTRAINTS_KEY: [2.0, 1.0]})   # infeasible (sum > 0)
    t3 = FrozenTrial([3.0], system_attrs={_CONSTRAINTS_KEY: [-1.0, -2.0]}) # feasible
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 109μs -> 105μs (3.71% faster)

def test_constrained_all_infeasible():
    # Constrained: all trials infeasible
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [1.0]})
    t2 = FrozenTrial([2.0], system_attrs={_CONSTRAINTS_KEY: [2.0]})
    t3 = FrozenTrial([3.0], system_attrs={_CONSTRAINTS_KEY: [3.0]})
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 90.9μs -> 79.7μs (14.0% faster)

def test_constrained_mixed_penalty_and_none():
    # Constrained: mix of feasible, infeasible, and none
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [0.0]})  # feasible
    t2 = FrozenTrial([2.0], system_attrs={_CONSTRAINTS_KEY: [1.0]})  # infeasible
    t3 = FrozenTrial([3.0], system_attrs={})                         # no penalty info
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 112μs -> 111μs (0.778% faster)

def test_constrained_nan_penalty():
    # Constrained: penalty is nan
    import math
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [math.nan]})
    t2 = FrozenTrial([2.0], system_attrs={_CONSTRAINTS_KEY: [0.0]})
    codeflash_output = _rank_population([t1, t2], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 91.9μs -> 76.4μs (20.3% faster)

# Large Scale Test Cases

def test_large_population_single_objective_minimize():
    # Large population, single objective, minimize
    trials = [FrozenTrial([float(i)]) for i in range(1000)]
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE]); result = codeflash_output # 457μs -> 375μs (21.8% faster)

def test_large_population_two_objectives_minimize():
    # Large population, two objectives, minimize
    trials = [FrozenTrial([i, 1000-i]) for i in range(1000)]
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE, StudyDirection.MINIMIZE]); result = codeflash_output # 673μs -> 626μs (7.36% faster)

def test_large_population_constrained_mixed():
    # Large population, mix of feasible/infeasible/none
    trials = []
    for i in range(333):
        trials.append(FrozenTrial([float(i)], system_attrs={_CONSTRAINTS_KEY: [0.0]}))  # feasible
    for i in range(333, 666):
        trials.append(FrozenTrial([float(i)], system_attrs={_CONSTRAINTS_KEY: [1.0]}))  # infeasible
    for i in range(666, 1000):
        trials.append(FrozenTrial([float(i)], system_attrs={}))                         # no penalty info
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 744μs -> 667μs (11.5% faster)

def test_large_population_identical_objectives():
    # Large population, all identical objectives
    trials = [FrozenTrial([1.0, 2.0]) for _ in range(1000)]
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE, StudyDirection.MINIMIZE]); result = codeflash_output # 720μs -> 682μs (5.57% faster)

def test_large_population_constrained_all_infeasible():
    # Large population, all infeasible with increasing penalties
    trials = [FrozenTrial([float(i)], system_attrs={_CONSTRAINTS_KEY: [float(i)]}) for i in range(1000)]
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 816μs -> 746μs (9.47% faster)
    # Each trial should have its own front, sorted by penalty
    for i, trial in enumerate(trials):
        pass

def test_large_population_constrained_all_none():
    # Large population, all trials have no penalty info
    trials = [FrozenTrial([float(i)], system_attrs={}) for i in range(1000)]
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 575μs -> 509μs (13.1% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from enum import Enum
from typing import List, Optional, Sequence

# imports
import pytest
from optuna.samplers.nsgaii._elite_population_selection_strategy import \
    _rank_population


# Minimal stand-ins for Optuna classes/enums
class StudyDirection(Enum):
    MINIMIZE = "minimize"
    MAXIMIZE = "maximize"

class FrozenTrial:
    def __init__(self, values: Sequence[float], system_attrs: Optional[dict] = None):
        self.values = values
        self.system_attrs = system_attrs or {}

# Stand-in for Optuna's _CONSTRAINTS_KEY
_CONSTRAINTS_KEY = "constraints"
from optuna.samplers.nsgaii._elite_population_selection_strategy import \
    _rank_population

# ------------------- UNIT TESTS -------------------

# 1. Basic Test Cases

def test_empty_population_returns_empty():
    # Should return empty list for empty population
    codeflash_output = _rank_population([], [StudyDirection.MINIMIZE]) # 678ns -> 668ns (1.50% faster)

def test_single_trial_population():
    # Should return [[trial]] for single trial
    t = FrozenTrial([1.0])
    codeflash_output = _rank_population([t], [StudyDirection.MINIMIZE]); result = codeflash_output # 70.4μs -> 70.6μs (0.241% slower)

def test_two_trials_single_objective_minimize():
    # Lower value is better, so rank 0 for lower, rank 1 for higher
    t1 = FrozenTrial([1.0])
    t2 = FrozenTrial([2.0])
    codeflash_output = _rank_population([t1, t2], [StudyDirection.MINIMIZE]); result = codeflash_output # 53.9μs -> 55.6μs (3.05% slower)

def test_two_trials_single_objective_maximize():
    # Higher value is better, so rank 0 for higher, rank 1 for lower
    t1 = FrozenTrial([1.0])
    t2 = FrozenTrial([2.0])
    codeflash_output = _rank_population([t1, t2], [StudyDirection.MAXIMIZE]); result = codeflash_output # 48.2μs -> 49.4μs (2.45% slower)

def test_three_trials_multi_objective_minimize():
    # Pareto front: t1 ([1,2]) and t2 ([2,1]) are non-dominated, t3 ([3,3]) is dominated
    t1 = FrozenTrial([1.0, 2.0])
    t2 = FrozenTrial([2.0, 1.0])
    t3 = FrozenTrial([3.0, 3.0])
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE, StudyDirection.MINIMIZE]); result = codeflash_output # 151μs -> 148μs (1.99% faster)

def test_three_trials_multi_objective_maximize():
    # Pareto front: t1 ([2,1]) and t2 ([1,2]) are non-dominated, t3 ([0,0]) is dominated
    t1 = FrozenTrial([2.0, 1.0])
    t2 = FrozenTrial([1.0, 2.0])
    t3 = FrozenTrial([0.0, 0.0])
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MAXIMIZE, StudyDirection.MAXIMIZE]); result = codeflash_output # 126μs -> 130μs (3.39% slower)

def test_direction_mixed_minimize_maximize():
    # First objective is minimize, second is maximize
    t1 = FrozenTrial([1.0, 2.0])
    t2 = FrozenTrial([2.0, 1.0])
    t3 = FrozenTrial([3.0, 3.0])
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE, StudyDirection.MAXIMIZE]); result = codeflash_output # 122μs -> 122μs (0.265% slower)

# 2. Edge Test Cases

def test_trials_with_identical_objective_values():
    # All trials have same values, should be rank 0
    t1 = FrozenTrial([1.0])
    t2 = FrozenTrial([1.0])
    t3 = FrozenTrial([1.0])
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE]); result = codeflash_output # 53.5μs -> 52.2μs (2.57% faster)

def test_trials_with_nan_penalty():
    # Trials with None constraints get penalty nan, should be ranked after feasible/infeasible
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [0.0]})  # feasible
    t2 = FrozenTrial([2.0], system_attrs={_CONSTRAINTS_KEY: [1.0]})  # infeasible
    t3 = FrozenTrial([3.0])  # no constraints, penalty nan
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 127μs -> 133μs (4.82% slower)

def test_trials_with_multiple_constraints():
    # Penalty is sum of positive constraint violations
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [0.0, -1.0]})  # feasible
    t2 = FrozenTrial([2.0], system_attrs={_CONSTRAINTS_KEY: [1.0, 2.0]})   # infeasible, penalty=3
    t3 = FrozenTrial([3.0], system_attrs={_CONSTRAINTS_KEY: [0.0, 1.0]})   # infeasible, penalty=1
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 108μs -> 97.6μs (11.6% faster)

def test_trials_with_negative_and_zero_constraints():
    # Only positive constraint values count as penalty
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [-1.0, 0.0]})  # feasible
    t2 = FrozenTrial([2.0], system_attrs={_CONSTRAINTS_KEY: [0.0, 0.0]})   # feasible
    t3 = FrozenTrial([3.0], system_attrs={_CONSTRAINTS_KEY: [0.0, 1.0]})   # infeasible
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 105μs -> 102μs (3.45% faster)

def test_trials_with_mixed_penalty_and_objective():
    # Feasible trial with worse objective should still be rank 0
    t1 = FrozenTrial([5.0], system_attrs={_CONSTRAINTS_KEY: [0.0]})  # feasible
    t2 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [1.0]})  # infeasible
    t3 = FrozenTrial([2.0])  # unknown penalty
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 109μs -> 110μs (1.42% slower)

def test_trials_with_all_infeasible():
    # All trials infeasible, ranked by penalty
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [2.0]})  # penalty=2
    t2 = FrozenTrial([2.0], system_attrs={_CONSTRAINTS_KEY: [1.0]})  # penalty=1
    t3 = FrozenTrial([3.0], system_attrs={_CONSTRAINTS_KEY: [3.0]})  # penalty=3
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 88.7μs -> 79.5μs (11.6% faster)

def test_trials_with_all_unknown_penalty():
    # All trials have no constraints, ranked by objective only
    t1 = FrozenTrial([1.0])
    t2 = FrozenTrial([2.0])
    t3 = FrozenTrial([3.0])
    codeflash_output = _rank_population([t1, t2, t3], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 89.0μs -> 79.0μs (12.6% faster)

def test_trials_with_zero_penalty_are_feasible():
    t1 = FrozenTrial([1.0], system_attrs={_CONSTRAINTS_KEY: [0.0]})
    t2 = FrozenTrial([2.0], system_attrs={_CONSTRAINTS_KEY: [0.0]})
    codeflash_output = _rank_population([t1, t2], [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 91.0μs -> 76.3μs (19.3% faster)

# 3. Large Scale Test Cases

def test_large_population_single_objective_minimize():
    # 100 trials, values 0..99, should be sorted by value
    trials = [FrozenTrial([float(i)]) for i in range(100)]
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE]); result = codeflash_output # 88.0μs -> 86.9μs (1.35% faster)
    # Each trial should be in its own rank (since all values are unique)
    for i in range(100):
        pass

def test_large_population_single_objective_maximize():
    # 100 trials, values 0..99, maximize, so highest value is rank 0
    trials = [FrozenTrial([float(i)]) for i in range(100)]
    codeflash_output = _rank_population(trials, [StudyDirection.MAXIMIZE]); result = codeflash_output # 84.7μs -> 81.9μs (3.53% faster)
    for i in range(100):
        pass

def test_large_population_multi_objective():
    # 50 trials, 2 objectives, values are (i, 50-i), so all are on Pareto front
    trials = [FrozenTrial([float(i), float(50 - i)]) for i in range(50)]
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE, StudyDirection.MINIMIZE]); result = codeflash_output # 158μs -> 155μs (1.86% faster)

def test_large_population_with_constraints():
    # 100 trials, half feasible, half infeasible, infeasible penalty increases
    trials = []
    for i in range(50):
        trials.append(FrozenTrial([float(i)], system_attrs={_CONSTRAINTS_KEY: [0.0]}))  # feasible
    for i in range(50):
        trials.append(FrozenTrial([float(i + 50)], system_attrs={_CONSTRAINTS_KEY: [float(i + 1)]}))  # infeasible
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 191μs -> 166μs (15.2% faster)
    for i in range(50):
        pass

def test_large_population_with_unknown_penalty():
    # 100 trials, all unknown penalty, ranked by objective
    trials = [FrozenTrial([float(i)]) for i in range(100)]
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 137μs -> 130μs (5.53% faster)
    for i in range(100):
        pass

def test_large_population_mixed_feasible_infeasible_unknown():
    # 30 feasible, 30 infeasible, 30 unknown
    trials = []
    for i in range(30):
        trials.append(FrozenTrial([float(i)], system_attrs={_CONSTRAINTS_KEY: [0.0]}))  # feasible
    for i in range(30):
        trials.append(FrozenTrial([float(i + 30)], system_attrs={_CONSTRAINTS_KEY: [float(i + 1)]}))  # infeasible
    for i in range(30):
        trials.append(FrozenTrial([float(i + 60)]))  # unknown
    codeflash_output = _rank_population(trials, [StudyDirection.MINIMIZE], is_constrained=True); result = codeflash_output # 173μs -> 169μs (2.70% faster)
    # Infeasible sorted by penalty
    for i in range(30):
        pass
    # Unknown sorted by objective
    for i in range(30):
        pass
# 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-_rank_population-mhaypqbb and push.