scientific-computing-system 1.6.2__py3-none-any.whl

cds/diffeq/_implicit.py

@@ -0,0 +1,349 @@
+"""Implicit / A-stable ODE solvers for stiff problems.
+
+Implements backward Euler (θ = 1) and the trapezoidal / Crank–Nicolson method
+(θ = 1/2) as one unified θ-method core. Every implicit step solves the stage
+equation ``x = y + h·[(1−θ)·f(t,y) + θ·f(t+h,x)]`` with damped-free Newton
+iteration, using :func:`cds.math_utils.linalg.solve_linear` for the linear
+subsystems (partial-pivoted LU) and an analytic or central-difference
+Jacobian.
+
+References:
+    - Hairer, E. & Wanner, G. (1996). Solving ODEs II: Stiff and
+      Differential-Algebraic Problems (2nd ed.), §IV.3.
+    - Crank, J. & Nicolson, P. (1947). Proc. Camb. Phil. Soc. 43(1).
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable
+
+from cds.core._numeric import LOOP_EPSILON, RK45_DEFAULT_DT
+from cds.diffeq.solvers import ODESolution
+from cds.math_utils.linalg import solve_linear
+
+SystemRHS = Callable[[float, list[float]], list[float]]
+Jacobian = Callable[[float, list[float]], list[list[float]]]
+
+DEFAULT_NEWTON_TOL = 1e-10
+DEFAULT_NEWTON_MAX_ITER = 50
+_FD_RELATIVE_H = 1e-7
+
+
+def _finite_difference_jacobian(
+    f: SystemRHS,
+    t: float,
+    y: list[float],
+) -> list[list[float]]:
+    """Central-difference approximation of ∂f/∂y at ``(t, y)``."""
+    n = len(y)
+    jac = [[0.0] * n for _ in range(n)]
+    for j in range(n):
+        h = _FD_RELATIVE_H * max(1.0, abs(y[j]))
+        y_plus = list(y)
+        y_minus = list(y)
+        y_plus[j] += h
+        y_minus[j] -= h
+        f_plus = f(t, y_plus)
+        f_minus = f(t, y_minus)
+        for i in range(n):
+            jac[i][j] = (f_plus[i] - f_minus[i]) / (2.0 * h)
+    return jac
+
+
+def _newton_solve(
+    residual: Callable[[list[float]], list[float]],
+    jac: Callable[[list[float]], list[list[float]]],
+    x0: list[float],
+    *,
+    tol: float,
+    max_iter: int,
+) -> list[float]:
+    """Solve ``residual(x) = 0`` with plain Newton iteration.
+
+    Raises:
+        ValueError: when the linearized Jacobian is singular or the iteration
+            budget is exhausted without meeting ``tol``.
+    """
+    x = list(x0)
+    for _ in range(max_iter):
+        r = residual(x)
+        if max(abs(v) for v in r) <= tol:
+            return x
+        try:
+            delta = solve_linear(jac(x), [-v for v in r])
+        except ValueError as exc:
+            raise ValueError("implicit step failed: singular Jacobian") from exc
+        x = [xi + d for xi, d in zip(x, delta)]
+    raise ValueError("implicit solve did not converge within max_iter")
+
+
+def _integrate_system(
+    f: SystemRHS,
+    t0: float,
+    y0: list[float],
+    t_end: float,
+    dt: float,
+    *,
+    theta: float,
+    jac: Jacobian | None,
+    tol: float,
+    max_iter: int,
+) -> tuple[list[float], list[list[float]]]:
+    """Fixed-step θ-method driver shared by every public implicit solver."""
+    if not y0:
+        raise ValueError("y0 must be non-empty")
+    if dt <= 0:
+        raise ValueError("dt must be positive")
+    if tol <= 0:
+        raise ValueError("tol must be positive")
+    if max_iter < 1:
+        raise ValueError("max_iter must be >= 1")
+
+    # Same direction rule as the explicit solvers (see euler_method): the sign
+    # of ``t_end - t0`` decides forward/backward integration; ``dt`` is a
+    # magnitude. copysign(1, 0) is +1, so t_end == t0 skips the loop cleanly.
+    direction = math.copysign(1.0, t_end - t0)
+    t_vals = [t0]
+    y_vals = [list(y0)]
+    t = t0
+    y = list(y0)
+
+    while (t_end - t) * direction > LOOP_EPSILON:
+        h = direction * min(dt, abs(t_end - t))
+        t_new = t + h
+        f_old = f(t, y)
+
+        def residual(x: list[float], t_new: float = t_new) -> list[float]:
+            f_new = f(t_new, x)
+            return [
+                xv - yv - h * ((1.0 - theta) * fv + theta * fnv)
+                for xv, yv, fv, fnv in zip(x, y, f_old, f_new)
+            ]
+
+        def system_jac(x: list[float], t_new: float = t_new) -> list[list[float]]:
+            # Newton needs the Jacobian of the *residual*, not of f:
+            # d/dx [x - y - h((1-θ)f(t,y) + θ f(t+h,x))] = I - hθ·∂f/∂y.
+            jf = jac(t_new, x) if jac is not None else _finite_difference_jacobian(f, t_new, x)
+            n = len(x)
+            return [
+                [(1.0 if i == j else 0.0) - h * theta * jf[i][j] for j in range(n)]
+                for i in range(n)
+            ]
+
+        y = _newton_solve(residual, system_jac, y, tol=tol, max_iter=max_iter)
+        t = t_new
+        t_vals.append(t)
+        y_vals.append(list(y))
+
+    return t_vals, y_vals
+
+
+def _wrap_scalar_jac(jac: Callable[[float, float], float] | None) -> Jacobian | None:
+    """Lift a scalar Jacobian ``df/dy`` into 1×1-matrix form."""
+    if jac is None:
+        return None
+
+    def wrapped(t: float, y: list[float]) -> list[list[float]]:
+        return [[jac(t, y[0])]]
+
+    return wrapped
+
+
+def backward_euler(
+    f: Callable[[float, float], float],
+    t0: float,
+    y0: float,
+    t_end: float,
+    dt: float = RK45_DEFAULT_DT,
+    *,
+    jac: Callable[[float, float], float] | None = None,
+    tol: float = DEFAULT_NEWTON_TOL,
+    max_iter: int = DEFAULT_NEWTON_MAX_ITER,
+) -> ODESolution:
+    """Backward Euler for dy/dt = f(t, y): unconditionally stable, O(dt) accurate.
+
+    The method of choice for stiff decay problems where explicit methods
+    require absurdly small steps. [Hairer & Wanner 1996, §IV.3]
+
+    Args:
+        f: right-hand side function f(t, y)
+        t0: initial time
+        y0: initial value y(t0)
+        t_end: end time (may be less than ``t0`` for backward integration)
+        dt: time step magnitude (direction follows sign of ``t_end - t0``)
+        jac: optional analytic df/dy(t, y); central differences otherwise
+        tol: Newton convergence tolerance on the residual (∞-norm)
+        max_iter: Newton iteration budget per step
+
+    Returns:
+        An :class:`ODESolution` with ``method == "backward-euler"``.
+
+    Raises:
+        ValueError: on invalid parameters or Newton failure (singular
+            Jacobian / exhausted budget).
+    """
+
+    def f_sys(t: float, y: list[float]) -> list[float]:
+        return [f(t, y[0])]
+
+    t_vals, y_vals = _integrate_system(
+        f_sys,
+        t0,
+        [y0],
+        t_end,
+        dt,
+        theta=1.0,
+        jac=_wrap_scalar_jac(jac),
+        tol=tol,
+        max_iter=max_iter,
+    )
+    return ODESolution(
+        t=t_vals,
+        y=[v[0] for v in y_vals],
+        method="backward-euler",
+        steps=len(t_vals) - 1,
+    )
+
+
+def trapezoid_method(
+    f: Callable[[float, float], float],
+    t0: float,
+    y0: float,
+    t_end: float,
+    dt: float = RK45_DEFAULT_DT,
+    *,
+    jac: Callable[[float, float], float] | None = None,
+    tol: float = DEFAULT_NEWTON_TOL,
+    max_iter: int = DEFAULT_NEWTON_MAX_ITER,
+) -> ODESolution:
+    """Trapezoidal (Crank–Nicolson) method: A-stable, second order.
+
+    Averages the explicit and implicit slopes, giving O(dt²) global error —
+    strictly more accurate than backward Euler on smooth problems while
+    remaining stable on stiff ones. [Crank & Nicolson 1947]
+
+    Args:
+        f: right-hand side function f(t, y)
+        t0: initial time
+        y0: initial value y(t0)
+        t_end: end time (may be less than ``t0`` for backward integration)
+        dt: time step magnitude (direction follows sign of ``t_end - t0``)
+        jac: optional analytic df/dy(t, y); central differences otherwise
+        tol: Newton convergence tolerance on the residual (∞-norm)
+        max_iter: Newton iteration budget per step
+
+    Returns:
+        An :class:`ODESolution` with ``method == "trapezoid"``.
+
+    Raises:
+        ValueError: on invalid parameters or Newton failure (singular
+            Jacobian / exhausted budget).
+    """
+
+    def f_sys(t: float, y: list[float]) -> list[float]:
+        return [f(t, y[0])]
+
+    t_vals, y_vals = _integrate_system(
+        f_sys,
+        t0,
+        [y0],
+        t_end,
+        dt,
+        theta=0.5,
+        jac=_wrap_scalar_jac(jac),
+        tol=tol,
+        max_iter=max_iter,
+    )
+    return ODESolution(
+        t=t_vals,
+        y=[v[0] for v in y_vals],
+        method="trapezoid",
+        steps=len(t_vals) - 1,
+    )
+
+
+def backward_euler_system(
+    f: SystemRHS,
+    t0: float,
+    y0: list[float],
+    t_end: float,
+    dt: float = RK45_DEFAULT_DT,
+    *,
+    jac: Jacobian | None = None,
+    tol: float = DEFAULT_NEWTON_TOL,
+    max_iter: int = DEFAULT_NEWTON_MAX_ITER,
+) -> tuple[list[float], list[list[float]]]:
+    """Backward Euler for coupled systems dy/dt = f(t, y).
+
+    Args:
+        f: right-hand side f(t, y) returning derivative vectors
+        t0: initial time
+        y0: initial state vector (non-empty)
+        t_end: end time (may be less than ``t0`` for backward integration)
+        dt: time step magnitude (direction follows sign of ``t_end - t0``)
+        jac: optional analytic Jacobian matrix df_i/dy_j(t, y)
+        tol: Newton convergence tolerance on the residual (∞-norm)
+        max_iter: Newton iteration budget per step
+
+    Returns:
+        ``(t_values, y_values)`` with ``y_values[i]`` the state at
+        ``t_values[i]`` — the same shape as :func:`cds.diffeq.solve_system`.
+
+    Raises:
+        ValueError: on invalid parameters or Newton failure.
+    """
+    return _integrate_system(
+        f,
+        t0,
+        y0,
+        t_end,
+        dt,
+        theta=1.0,
+        jac=jac,
+        tol=tol,
+        max_iter=max_iter,
+    )
+
+
+def trapezoid_method_system(
+    f: SystemRHS,
+    t0: float,
+    y0: list[float],
+    t_end: float,
+    dt: float = RK45_DEFAULT_DT,
+    *,
+    jac: Jacobian | None = None,
+    tol: float = DEFAULT_NEWTON_TOL,
+    max_iter: int = DEFAULT_NEWTON_MAX_ITER,
+) -> tuple[list[float], list[list[float]]]:
+    """Trapezoidal (Crank–Nicolson) method for coupled systems dy/dt = f(t, y).
+
+    Args:
+        f: right-hand side f(t, y) returning derivative vectors
+        t0: initial time
+        y0: initial state vector (non-empty)
+        t_end: end time (may be less than ``t0`` for backward integration)
+        dt: time step magnitude (direction follows sign of ``t_end - t0``)
+        jac: optional analytic Jacobian matrix df_i/dy_j(t, y)
+        tol: Newton convergence tolerance on the residual (∞-norm)
+        max_iter: Newton iteration budget per step
+
+    Returns:
+        ``(t_values, y_values)`` with ``y_values[i]`` the state at
+        ``t_values[i]`` — the same shape as :func:`cds.diffeq.solve_system`.
+
+    Raises:
+        ValueError: on invalid parameters or Newton failure.
+    """
+    return _integrate_system(
+        f,
+        t0,
+        y0,
+        t_end,
+        dt,
+        theta=0.5,
+        jac=jac,
+        tol=tol,
+        max_iter=max_iter,
+    )

cds/diffeq/solvers.py

@@ -0,0 +1,312 @@
+"""Numerical ODE solvers.
+
+References:
+    - Euler, L. (1768). Institutionum calculi integralis.
+    - Runge, C. (1895). Über die numerische Auflösung von Differentialgleichungen.
+    - Kutta, M.W. (1901). Beitrag zur näherungsweisen Integration totaler DGL.
+    - Butcher, J.C. Numerical Methods for Ordinary Differential Equations (3rd ed.)
+"""
+
+from __future__ import annotations
+
+import math
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from cds.core._numeric import (
+    LOOP_EPSILON,
+    RK45_DEFAULT_ATOL,
+    RK45_DEFAULT_DT,
+    RK45_DEFAULT_RTOL,
+    RK45_STEP_GROW,
+    RK45_STEP_SAFETY,
+    RK45_STEP_SHRINK,
+)
+
+
+@dataclass
+class ODESolution:
+    """Result of an ODE integration."""
+
+    t: list[float]
+    y: list[float]
+    method: str
+    steps: int
+
+
+def euler_method(
+    f: Callable[[float, float], float],
+    t0: float,
+    y0: float,
+    t_end: float,
+    dt: float = RK45_DEFAULT_DT,
+) -> ODESolution:
+    """Euler's method for dy/dt = f(t, y).
+
+    First-order explicit method. Local truncation error O(dt²),
+    global error O(dt). [Euler 1768]
+
+    Args:
+        f: right-hand side function f(t, y)
+        t0: initial time
+        y0: initial value y(t0)
+        t_end: end time (may be less than ``t0`` for backward integration)
+        dt: time step (always positive; direction follows the sign of ``t_end - t0``)
+    """
+    # Direction of integration: +1 forward, -1 backward. ``copysign(1, 0)``
+    # is +1, so a zero-length span (``t_end == t0``) still skips the loop and
+    # returns just the initial condition. Without this, ``t_end < t0`` made the
+    # ``while t < t_end`` guard immediately False and the solver silently
+    # returned the initial value instead of integrating backward.
+    direction = math.copysign(1.0, t_end - t0)
+    t_vals = [t0]
+    y_vals = [y0]
+    t, y = t0, y0
+    steps = 0
+
+    while (t_end - t) * direction > LOOP_EPSILON:
+        h = direction * min(dt, abs(t_end - t))
+        y = y + h * f(t, y)
+        t = t + h
+        t_vals.append(t)
+        y_vals.append(y)
+        steps += 1
+
+    return ODESolution(t=t_vals, y=y_vals, method="euler", steps=steps)
+
+
+def rk4(
+    f: Callable[[float, float], float],
+    t0: float,
+    y0: float,
+    t_end: float,
+    dt: float = RK45_DEFAULT_DT,
+) -> ODESolution:
+    """Classical 4th-order Runge-Kutta method.
+
+    Local truncation error O(dt⁵), global error O(dt⁴). [Runge 1895, Kutta 1901]
+
+    The standard Butcher tableau:
+        0   |
+        1/2 | 1/2
+        1/2 | 0   1/2
+        1   | 0   0   1
+        ----|----------------
+            | 1/6 1/3 1/3 1/6
+
+    Args:
+        f: right-hand side function f(t, y)
+        t0: initial time
+        y0: initial value y(t0)
+        t_end: end time (may be less than ``t0`` for backward integration)
+        dt: time step (always positive; direction follows the sign of ``t_end - t0``)
+    """
+    # See ``euler_method`` for why direction is derived from the sign of
+    # ``t_end - t0`` rather than reading ``dt``'s sign: it keeps ``dt`` an
+    # unambiguous magnitude and makes backward integration actually progress.
+    direction = math.copysign(1.0, t_end - t0)
+    t_vals = [t0]
+    y_vals = [y0]
+    t, y = t0, y0
+    steps = 0
+
+    while (t_end - t) * direction > LOOP_EPSILON:
+        h = direction * min(dt, abs(t_end - t))
+        k1 = f(t, y)
+        k2 = f(t + h / 2, y + h * k1 / 2)
+        k3 = f(t + h / 2, y + h * k2 / 2)
+        k4 = f(t + h, y + h * k3)
+        y = y + (h / 6) * (k1 + 2 * k2 + 2 * k3 + k4)
+        t = t + h
+        t_vals.append(t)
+        y_vals.append(y)
+        steps += 1
+
+    return ODESolution(t=t_vals, y=y_vals, method="rk4", steps=steps)
+
+
+def midpoint_method(
+    f: Callable[[float, float], float],
+    t0: float,
+    y0: float,
+    t_end: float,
+    dt: float = RK45_DEFAULT_DT,
+) -> ODESolution:
+    """Explicit midpoint method (2nd-order Runge-Kutta).
+
+    Local truncation error O(dt³), global error O(dt²).
+
+    Args:
+        f: right-hand side function f(t, y)
+        t0: initial time
+        y0: initial value y(t0)
+        t_end: end time (may be less than ``t0`` for backward integration)
+        dt: time step (always positive; direction follows the sign of ``t_end - t0``)
+    """
+    direction = math.copysign(1.0, t_end - t0)
+    t_vals = [t0]
+    y_vals = [y0]
+    t, y = t0, y0
+    steps = 0
+
+    while (t_end - t) * direction > LOOP_EPSILON:
+        h = direction * min(dt, abs(t_end - t))
+        k1 = f(t, y)
+        k2 = f(t + h / 2, y + h * k1 / 2)
+        y = y + h * k2
+        t = t + h
+        t_vals.append(t)
+        y_vals.append(y)
+        steps += 1
+
+    return ODESolution(t=t_vals, y=y_vals, method="midpoint", steps=steps)
+
+
+def rk45(
+    f: Callable[[float, float], float],
+    t0: float,
+    y0: float,
+    t_end: float,
+    dt: float = RK45_DEFAULT_DT,
+    atol: float = RK45_DEFAULT_ATOL,
+    rtol: float = RK45_DEFAULT_RTOL,
+) -> ODESolution:
+    """Dormand-Prince (RK45) adaptive step-size method.
+
+    Computes 4th and 5th order estimates to approximate local error
+    and adjust the step size automatically. [Dormand & Prince 1980]
+
+    Args:
+        f: right-hand side f(t, y)
+        t0: initial time
+        y0: initial value
+        t_end: end time (may be less than ``t0`` for backward integration)
+        dt: initial time step (always positive; direction follows the sign of ``t_end - t0``)
+        atol: absolute tolerance
+        rtol: relative tolerance
+    """
+    # Dormand-Prince Butcher Tableau coefficients
+    a = [0, 1 / 5, 3 / 10, 4 / 5, 8 / 9, 1, 1]
+    b = [
+        [],
+        [1 / 5],
+        [3 / 40, 9 / 40],
+        [44 / 45, -56 / 15, 32 / 9],
+        [19372 / 6561, -25360 / 2187, 64448 / 6561, -212 / 729],
+        [9017 / 3168, -355 / 33, 46732 / 5247, 49 / 176, -5103 / 18656],
+        [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84],
+    ]
+    c5 = [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84, 0]
+    c4 = [5179 / 57600, 0, 7571 / 16695, 393 / 640, -92097 / 339200, 187 / 2100, 1 / 40]
+
+    # Direction of integration (+1 forward, -1 backward). The step size is
+    # tracked as an always-positive magnitude ``h_mag`` and applied as
+    # ``direction * h_mag`` so the min/max shrink/grow logic below keeps its
+    # forward semantics regardless of integration direction.
+    direction = math.copysign(1.0, t_end - t0)
+    t, y = t0, y0
+    t_vals = [t]
+    y_vals = [y]
+    h_mag = dt
+    steps = 0
+
+    # Absolute step-size floor, scaled to the integration span, below which no
+    # further progress can be made (a "machine precision floor"). Prevents the
+    # adaptive loop from spinning forever on stiff/diverging problems.
+    span = abs(t_end - t0) if t_end != t0 else 1.0
+    eps_floor = 16 * sys.float_info.epsilon * max(abs(t), span)
+
+    while (t_end - t) * direction > LOOP_EPSILON:
+        # Signed step for the RK stages and time advancement. Snap the last
+        # step to land exactly on t_end when the remaining span is smaller
+        # than the proposed magnitude (avoids overshooting the endpoint).
+        if abs(t_end - t) < h_mag:
+            h = t_end - t
+            h_mag = abs(h)
+        else:
+            h = direction * h_mag
+
+        k = [0.0] * 7
+        k[0] = f(t, y)
+        for i in range(1, 7):
+            y_next = y + h * sum(b[i][j] * k[j] for j in range(i))
+            k[i] = f(t + a[i] * h, y_next)
+
+        # Estimate 5th and 4th order solutions
+        y5 = y + h * sum(c5[i] * k[i] for i in range(7))
+        y4 = y + h * sum(c4[i] * k[i] for i in range(7))
+
+        # Local error estimate
+        error = abs(y5 - y4)
+        tolerance = atol + rtol * abs(y)
+
+        if error <= tolerance:
+            # Step accepted
+            t += h
+            y = y5
+            t_vals.append(t)
+            y_vals.append(y)
+            steps += 1
+
+        # Adjust step size (operates on the magnitude only, preserving direction)
+        if error > 0:
+            h_opt = h_mag * (tolerance / error) ** 0.2
+            h_mag = min(
+                max(RK45_STEP_SHRINK * h_mag, RK45_STEP_SAFETY * h_opt), RK45_STEP_GROW * h_mag
+            )
+        else:
+            h_mag *= 10.0  # Error is zero, aggressively increase step up to max scale
+
+        # Precision floor to prevent infinite loop: either the step size has
+        # shrunk below the span-scaled epsilon floor, or it has become so small
+        # that adding it to t makes no progress (t + h == t).
+        if h_mag < eps_floor or t + direction * h_mag == t:
+            raise RuntimeError("Step size h reached machine precision floor.")
+
+    return ODESolution(t=t_vals, y=y_vals, method="rk45", steps=steps)
+
+
+def solve_system(
+    f: Callable[[float, list[float]], list[float]],
+    t0: float,
+    y0: list[float],
+    t_end: float,
+    dt: float = RK45_DEFAULT_DT,
+) -> tuple[list[float], list[list[float]]]:
+    """RK4 for systems of ODEs: dy/dt = f(t, y) where y is a vector.
+
+    Args:
+        f: right-hand side f(t, y) returning a list of derivatives
+        t0: initial time
+        y0: initial state vector
+        t_end: end time (may be less than ``t0`` for backward integration)
+        dt: time step (always positive; direction follows the sign of ``t_end - t0``)
+
+    Returns:
+        (t_values, y_values) where y_values[i] is the state vector at t_values[i]
+    """
+    direction = math.copysign(1.0, t_end - t0)
+    n = len(y0)
+    t_vals = [t0]
+    y_vals = [list(y0)]
+    t = t0
+    y = list(y0)
+
+    while (t_end - t) * direction > LOOP_EPSILON:
+        h = direction * min(dt, abs(t_end - t))
+
+        k1 = f(t, y)
+        y_tmp = [y[i] + h * k1[i] / 2 for i in range(n)]
+        k2 = f(t + h / 2, y_tmp)
+        y_tmp = [y[i] + h * k2[i] / 2 for i in range(n)]
+        k3 = f(t + h / 2, y_tmp)
+        y_tmp = [y[i] + h * k3[i] for i in range(n)]
+        k4 = f(t + h, y_tmp)
+
+        y = [y[i] + (h / 6) * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i]) for i in range(n)]
+        t = t + h
+        t_vals.append(t)
+        y_vals.append(list(y))
+
+    return t_vals, y_vals

cds/graph/__init__.py

@@ -0,0 +1,31 @@
+"""Graph theory algorithms — BFS, DFS, Dijkstra, Kruskal MST."""
+
+from cds.graph.algorithms import (
+    Graph,
+    bellman_ford,
+    bfs,
+    connected_components,
+    degree,
+    dfs,
+    dijkstra,
+    floyd_warshall,
+    has_cycle,
+    kruskal_mst,
+    prim_mst,
+    topological_sort,
+)
+
+__all__ = [
+    "Graph",
+    "bfs",
+    "dfs",
+    "dijkstra",
+    "kruskal_mst",
+    "topological_sort",
+    "has_cycle",
+    "degree",
+    "connected_components",
+    "bellman_ford",
+    "floyd_warshall",
+    "prim_mst",
+]