MICHAELIS_MENTEN

=MICHAELIS_MENTEN(s_initial, e_initial, k_cat, k_m, t_start, t_end, [method])

=MICHAELIS_MENTEN(10.0, 1.0, 2.0, 1.0, 0.0, 5.0)

=MICHAELIS_MENTEN(5.0, 0.5, 1.5, 0.5, 0.0, 2.0, "RK23")

=MICHAELIS_MENTEN(8.0, 2.0, 3.0, 2.0, 0.0, 3.0, "RK45")

=MICHAELIS_MENTEN(2.0, 0.2, 1.0, 0.2, 0.0, 0.5)

from scipy.integrate import solve_ivp
from typing import List, Union
 
def michaelis_menten(s_initial: float, e_initial: float, k_cat: float, k_m: float, t_start: float, t_end: float, method: str = 'RK45') -> Union[List[List[float]], str]:
    """
    Numerically solves the Michaelis-Menten system of ordinary differential equations for enzyme kinetics.
 
    Args:
        s_initial: Initial substrate concentration.
        e_initial: Initial enzyme concentration.
        k_cat: Turnover number.
        k_m: Michaelis constant.
        t_start: Start time of integration.
        t_end: End time of integration.
        method: Integration method ('RK45', 'RK23', 'DOP853', 'Radau', 'BDF', 'LSODA'). Default is 'RK45'.
 
    Returns:
        2D list with header row: t, S, E. Each row contains time and concentration values, or an error message (str) if input is invalid.
 
    This example function is provided as-is without any representation of accuracy.
    """
    # Validate inputs
    try:
        s0 = float(s_initial)
        e0 = float(e_initial)
        kcat = float(k_cat)
        km = float(k_m)
        t0 = float(t_start)
        t1 = float(t_end)
    except Exception:
        return "Invalid input: all initial values and parameters must be numbers."
    if t1 <= t0:
        return "Invalid input: t_end must be greater than t_start."
    if s0 < 0 or e0 < 0 or kcat < 0 or km < 0:
        return "Invalid input: concentrations and rate constants must be non-negative."
    allowed_methods = ['RK45', 'RK23', 'DOP853', 'Radau', 'BDF', 'LSODA']
    if method not in allowed_methods:
        return f"Invalid input: method must be one of {allowed_methods}."
    # Michaelis-Menten ODE system: dS/dt = -v, dE/dt = 0
    def mm_ode(t, y):
        S, E = y
        v = (kcat * E * S) / (km + S) if (km + S) != 0 else 0.0
        dSdt = -v
        dEdt = 0.0
        return [dSdt, dEdt]
    try:
        sol = solve_ivp(
            mm_ode,
            [t0, t1],
            [s0, e0],
            method=method,
            dense_output=False,
            rtol=1e-6,
            atol=1e-8
        )
    except Exception as e:
        return f"ODE integration error: {e}"
    if not sol.success:
        return f"ODE integration failed: {sol.message}"
    # Prepare output: header row then data rows
    result = [["t", "S", "E"]]
    for i in range(len(sol.t)):
        t_val = float(sol.t[i])
        s_val = float(sol.y[0][i])
        e_val = float(sol.y[1][i])
        # Disallow nan/inf
        if any([
            not isinstance(t_val, float) or not isinstance(s_val, float) or not isinstance(e_val, float),
            t_val != t_val or s_val != s_val or e_val != e_val,
            abs(t_val) == float('inf') or abs(s_val) == float('inf') or abs(e_val) == float('inf')
        ]):
            return "Invalid output: nan or inf detected."
        result.append([t_val, s_val, e_val])
    return result