--- Final Solver (used for performance test) ---
import numpy as np
import numba
from numba import njit


@njit(cache=True, fastmath=True)
def _outer_f64(vec1, vec2):
    n = vec1.shape[0]
    out = np.empty((n, n))
    for i in range(n):
        v = vec1[i]
        for j in range(n):
            out[i, j] = v * vec2[j]
    return out


@njit(cache=True, fastmath=True)
def _outer_f32(vec1, vec2):
    n = vec1.shape[0]
    out = np.empty((n, n))
    for i in range(n):
        v = vec1[i]
        for j in range(n):
            out[i, j] = v * vec2[j]
    return out


@njit(cache=True, fastmath=True)
def _outer_i64(vec1, vec2):
    n = vec1.shape[0]
    out = np.empty((n, n))
    for i in range(n):
        v = vec1[i]
        for j in range(n):
            out[i, j] = v * vec2[j]
    return out


@njit(cache=True, fastmath=True)
def _outer_i32(vec1, vec2):
    n = vec1.shape[0]
    out = np.empty((n, n))
    for i in range(n):
        v = vec1[i]
        for j in range(n):
            out[i, j] = v * vec2[j]
    return out


class Solver:
    def __init__(self):
        # Warm up JIT compilation - doesn't count toward runtime
        v1_64 = np.zeros(1, dtype=np.float64)
        v2_64 = np.zeros(1, dtype=np.float64)
        _outer_f64(v1_64, v2_64)
        
        v1_32 = np.zeros(1, dtype=np.float32)
        v2_32 = np.zeros(1, dtype=np.float32)
        _outer_f32(v1_32, v2_32)
        
        v1_i64 = np.zeros(1, dtype=np.int64)
        v2_i64 = np.zeros(1, dtype=np.int64)
        _outer_i64(v1_i64, v2_i64)
        
        v1_i32 = np.zeros(1, dtype=np.int32)
        v2_i32 = np.zeros(1, dtype=np.int32)
        _outer_i32(v1_i32, v2_i32)
    
    def solve(self, problem, **kwargs):
        vec1, vec2 = problem
        dtype1 = vec1.dtype
        
        if dtype1 is np.float64 and vec2.dtype is np.float64:
            return _outer_f64(vec1, vec2)
        elif dtype1 is np.float32 and vec2.dtype is np.float32:
            return _outer_f32(vec1, vec2)
        elif dtype1 is np.int64 and vec2.dtype is np.int64:
            return _outer_i64(vec1, vec2)
        elif dtype1 is np.int32 and vec2.dtype is np.int32:
            return _outer_i32(vec1, vec2)
        
        # Fallback for mixed or other dtypes
        return np.outer(vec1, vec2)
--- End Solver ---
Running performance test...
============================= test session starts ==============================
platform linux -- Python 3.12.13, pytest-9.0.2, pluggy-1.6.0
rootdir: /tests
plugins: anyio-4.13.0, jaxtyping-0.3.9
collected 3 items

../tests/test_outputs.py .
--- Performance Summary ---
Validity: True
Total Baseline Time: 6.5181s
Total Solver Time:   6.9456s
Raw Speedup:         0.9385 x
Final Reward (Score): 1.0000
---------------------------
.F

=================================== FAILURES ===================================
_____________________________ test_solver_speedup ______________________________

performance_results = {'raw_speedup': 0.9384531547171615, 'speedup': 1.0, 'validity': True}

    def test_solver_speedup(performance_results):
        """Checks if the solver effectively optimized the code."""
>       assert performance_results["raw_speedup"] > 1.0, \
            f"Solver was not faster than baseline (Speedup: {performance_results['raw_speedup']:.2f}x)"
E       AssertionError: Solver was not faster than baseline (Speedup: 0.94x)
E       assert 0.9384531547171615 > 1.0

/tests/test_outputs.py:205: AssertionError
==================================== PASSES ====================================
=========================== short test summary info ============================
PASSED ../tests/test_outputs.py::test_solver_exists
PASSED ../tests/test_outputs.py::test_solver_validity
FAILED ../tests/test_outputs.py::test_solver_speedup - AssertionError: Solver...
=================== 1 failed, 2 passed in 231.93s (0:03:51) ====================
