pysolverkit 0.1.0__py3-none-any.whl

pysolverkit/ode/first_order.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+from fractions import Fraction
+
+from ..enums import ODEMethod
+from ..functions.base import Function
+from ..functions.multivariate import BivariateFunction, MultiVariableFunction
+from ..functions.elementary import Polynomial
+from ..linalg.vector import Vector
+from .base import LinearODE
+
+
+class FirstOrderLinearODE(LinearODE):
+    """Numerical solver for a first-order linear IVP :math:`y'(x) = f(x, y(x))`.
+
+    Parameters
+    ----------
+    f:
+        Right-hand side :math:`f(x, y)`, given as a :class:`BivariateFunction`
+        (or a :class:`~pysolverkit.linalg.Vector` of
+        :class:`~pysolverkit.functions.multivariate.MultiVariableFunction` objects
+        for systems of equations).
+    a, b:
+        Integration interval.
+    y0:
+        Initial condition :math:`y(a)`.
+    """
+
+    def __init__(
+        self,
+        f: BivariateFunction | Vector,
+        a: float,
+        b: float,
+        y0: float | Vector,
+    ) -> None:
+        self.f = f
+        self.a = a
+        self.b = b
+        self.y0 = y0
+
+    def solve(
+        self,
+        h: float = 0.1,
+        method: ODEMethod = ODEMethod.EULER,
+        n: int = 1,
+        step: int = 2,
+        points: list[float] | None = None,
+    ) -> Polynomial:
+        """Solve the IVP and return an interpolating :class:`Polynomial`.
+
+        Parameters
+        ----------
+        h:
+            Step size.
+        method:
+            Solver algorithm (:class:`ODEMethod`).
+        n:
+            Order parameter for Taylor / Runge-Kutta methods.
+        step:
+            Number of steps for Adams methods.
+        points:
+            Known function values at previous grid points for multistep methods.
+        """
+        if points is None:
+            points = []
+
+
+        if method is ODEMethod.EULER:
+            return self._solve_taylor(h, 1)
+        if method is ODEMethod.RUNGE_KUTTA:
+            return self._solve_runge_kutta(h, n)
+        if method is ODEMethod.TAYLOR:
+            return self._solve_taylor(h, n)
+        if method is ODEMethod.TRAPEZOIDAL:
+            return self._solve_trapezoidal(h)
+        if method is ODEMethod.ADAMS_BASHFORTH:
+            return self._solve_adams_bashforth(h, step, points)
+        if method is ODEMethod.ADAMS_MOULTON:
+            return self._solve_adams_moulton(h, step, points)
+        if method is ODEMethod.PREDICTOR_CORRECTOR:
+            return self._solve_predictor_corrector(h)
+
+        raise ValueError(f"Unknown ODE method: {method!r}")
+
+    # ------------------------------------------------------------------
+    # Private solvers
+    # ------------------------------------------------------------------
+
+    def _solve_runge_kutta(self, h: float, n: int) -> Polynomial:
+        w = [self.y0]
+        N = int((self.b - self.a) / h)
+
+        if n == 1:
+            return self.solve(h, method=ODEMethod.EULER)
+        elif n == 2:
+            for i in range(N):
+                xi = self.a + i * h
+                w.append(
+                    w[i]
+                    + (h / 2) * self.f(xi, w[i])
+                    + (h / 2) * self.f(xi + h, w[i] + h * self.f(xi, w[i]))
+                )
+        elif n == 3:
+            for i in range(N):
+                xi = self.a + i * h
+                k1 = self.f(xi, w[i])
+                k2 = self.f(xi + (h / 3), w[i] + (h / 3) * k1)
+                k3 = self.f(xi + (2 / 3) * h, w[i] + (2 / 3) * h * k2)
+                w.append(w[i] + (h / 4) * (k1 + 3 * k3))
+        elif n == 4:
+            for i in range(N):
+                xi = self.a + i * h
+                k1 = h * self.f(xi, w[i])
+                k2 = h * self.f(xi + h / 2, w[i] + 0.5 * k1)
+                k3 = h * self.f(xi + h / 2, w[i] + 0.5 * k2)
+                k4 = h * self.f(xi + h, w[i] + k3)
+                w.append(w[i] + (1 / 6) * (k1 + 2 * k2 + 2 * k3 + k4))
+        else:
+            raise NotImplementedError("Runge-Kutta is only implemented for orders 1–4.")
+
+        try:
+            return Polynomial.interpolate([(self.a + i * h, w[i]) for i in range(N + 1)])
+        except Exception:
+            return w  # fall back to list for vector-valued problems
+
+    def _solve_taylor(self, h: float, n: int) -> Polynomial:
+        w = [self.y0]
+        N = int((self.b - self.a) / h)
+
+        if n == 1:
+            for i in range(N):
+                xi = self.a + i * h
+                w.append(w[i] + h * self.f(xi, w[i]))
+        elif n == 2:
+            for i in range(N):
+                xi = self.a + i * h
+                g = (
+                    self.f(None, w[i]).differentiate()(xi)
+                    + self.f(xi, w[i]) * self.f(xi, None).differentiate()(w[i])
+                )
+                w.append(w[i] + h * self.f(xi, w[i]) + (h**2) * g / 2)
+        else:
+            raise NotImplementedError("Taylor method is only implemented for orders 1 and 2.")
+
+        try:
+            return Polynomial.interpolate([(self.a + i * h, w[i]) for i in range(N + 1)])
+        except Exception:
+            return w
+
+    def _solve_trapezoidal(self, h: float) -> Polynomial:
+        w = [self.y0]
+        N = int((self.b - self.a) / h)
+
+        for i in range(N):
+            xi = self.a + i * h
+            g = Function(
+                lambda x, _h=h, _xi=xi, _wi=w[i]: _wi
+                + (_h / 2) * (self.f(_xi, _wi) + self.f(_xi + _h, x))
+            )
+            w.append(g.fixed_point(w[i]))
+
+        try:
+            return Polynomial.interpolate([(self.a + i * h, w[i]) for i in range(N + 1)])
+        except Exception:
+            return w
+
+    @staticmethod
+    def _adams_bashforth_coefficients(k: int) -> list[Fraction]:
+        """Compute Adams-Bashforth *k*-step coefficients via Lagrange interpolation.
+
+        Returns ``[b_0, ..., b_{k-1}]`` (as :class:`~fractions.Fraction` objects) such
+        that :math:`w_{n+1} = w_n + h \\sum_{j=0}^{k-1} b_j f(t_{n-j}, w_{n-j})`.
+        """
+        nodes = [Fraction(-j) for j in range(k)]
+        coefficients = []
+        for m in range(k):
+            poly = [Fraction(1)]
+            for j in range(k):
+                if j != m:
+                    new_poly = [Fraction(0)] * (len(poly) + 1)
+                    for idx, c in enumerate(poly):
+                        new_poly[idx + 1] += c
+                        new_poly[idx] -= nodes[j] * c
+                    poly = new_poly
+            denom = Fraction(1)
+            for j in range(k):
+                if j != m:
+                    denom *= nodes[m] - nodes[j]
+            integral = sum(c / (i + 1) for i, c in enumerate(poly))
+            coefficients.append(integral / denom)
+        return coefficients
+
+    @staticmethod
+    def _adams_moulton_coefficients(k: int) -> list[Fraction]:
+        """Compute Adams-Moulton *k*-step coefficients via Lagrange interpolation.
+
+        Returns ``[b_0, ..., b_k]`` (as :class:`~fractions.Fraction` objects) such that
+        :math:`w_{n+1} = w_n + h(b_0 f(t_{n+1}, w_{n+1}) + \\sum_{j=1}^{k} b_j f(t_{n+1-j}, w_{n+1-j}))`.
+        """
+        nodes = [Fraction(1 - j) for j in range(k + 1)]
+        coefficients = []
+        for m in range(k + 1):
+            poly = [Fraction(1)]
+            for j in range(k + 1):
+                if j != m:
+                    new_poly = [Fraction(0)] * (len(poly) + 1)
+                    for idx, c in enumerate(poly):
+                        new_poly[idx + 1] += c
+                        new_poly[idx] -= nodes[j] * c
+                    poly = new_poly
+            denom = Fraction(1)
+            for j in range(k + 1):
+                if j != m:
+                    denom *= nodes[m] - nodes[j]
+            integral = sum(c / (i + 1) for i, c in enumerate(poly))
+            coefficients.append(integral / denom)
+        return coefficients
+
+    def _solve_adams_bashforth(
+        self, h: float, step: int, points: list[float]
+    ) -> Polynomial:
+        if step < 2:
+            raise ValueError("Adams-Bashforth requires at least 2 steps.")
+        w = [self.y0] + list(points)
+        N = int((self.b - self.a) / h)
+        coeffs = [float(c) for c in FirstOrderLinearODE._adams_bashforth_coefficients(step)]
+
+        for i in range(step - 1, N):
+            xi = self.a + i * h
+            w.append(
+                w[i]
+                + h * sum(coeffs[j] * self.f(xi - j * h, w[i - j]) for j in range(step))
+            )
+
+        try:
+            return Polynomial.interpolate([(self.a + i * h, w[i]) for i in range(N + 1)])
+        except Exception:
+            return w
+
+    def _solve_adams_moulton(
+        self, h: float, step: int, points: list[float]
+    ) -> Polynomial:
+        if step < 2:
+            raise ValueError("Adams-Moulton requires at least 2 steps.")
+        w = [self.y0] + list(points)
+        N = int((self.b - self.a) / h)
+        coeffs = [float(c) for c in FirstOrderLinearODE._adams_moulton_coefficients(step)]
+
+        for i in range(step - 1, N):
+            xi = self.a + i * h
+            explicit = sum(
+                coeffs[j] * self.f(xi - (j - 1) * h, w[i - j + 1]) for j in range(1, step + 1)
+            )
+            c0 = coeffs[0]
+            g = Function(
+                lambda x, _h=h, _xi=xi, _c0=c0, _explicit=explicit, _wi=w[i]: (
+                    _wi + _h * (_c0 * self.f(_xi + _h, x) + _explicit)
+                )
+            )
+            w.append(g.fixed_point(w[i]))
+
+        try:
+            return Polynomial.interpolate([(self.a + i * h, w[i]) for i in range(N + 1)])
+        except Exception:
+            return w
+
+    def _solve_predictor_corrector(self, h: float) -> Polynomial:
+        w = [self.y0]
+        N = int((self.b - self.a) / h)
+        alphas = [self.a + h * i for i in range(1, 4)]
+
+        # Starting values via RK4
+        ivp = FirstOrderLinearODE(self.f, self.a, self.a + 3 * h, self.y0)
+        rk_sol = ivp._solve_runge_kutta(h, 4)
+        for xi in alphas:
+            w.append(rk_sol(xi))
+
+        for i in range(3, N):
+            xi = self.a + i * h
+            prediction = w[i] + (h / 24) * (
+                55 * self.f(xi, w[i])
+                - 59 * self.f(xi - h, w[i - 1])
+                + 37 * self.f(xi - 2 * h, w[i - 2])
+                - 9 * self.f(xi - 3 * h, w[i - 3])
+            )
+            correction = w[i] + (h / 24) * (
+                9 * self.f(xi + h, prediction)
+                + 19 * self.f(xi, w[i])
+                - 5 * self.f(xi - h, w[i - 1])
+                + self.f(xi - 2 * h, w[i - 2])
+            )
+            w.append(correction)
+
+        try:
+            return Polynomial.interpolate([(self.a + i * h, w[i]) for i in range(N + 1)])
+        except Exception:
+            return w

pysolverkit/ode/second_order.py

@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+from ..enums import BVPMethod, NonlinearBVPMethod, ODEMethod
+from ..functions.base import Function
+from ..functions.elementary import Polynomial
+from ..functions.multivariate import MultiVariableFunction
+from ..linalg.vector import Vector
+from ..linalg.matrix import Matrix
+from ..linalg.linear_system import LinearSystem
+from .base import LinearODE, OrdinaryDifferentialEquation
+from .first_order import FirstOrderLinearODE
+
+
+class SecondOrderLinearODE_BVP(LinearODE):
+    """Solver for the second-order linear BVP
+
+    .. math::
+
+        y''(x) = p(x)\\,y'(x) + q(x)\\,y(x) + r(x),
+        \\quad y(a) = y_0,\\quad y(b) = y_1.
+
+    Parameters
+    ----------
+    p, q, r:
+        Coefficient functions.
+    a, b:
+        Boundary points.
+    y0, y1:
+        Boundary values :math:`y(a)` and :math:`y(b)`.
+    """
+
+    def __init__(
+        self,
+        p: Function,
+        q: Function,
+        r: Function,
+        a: float,
+        b: float,
+        y0: float,
+        y1: float,
+    ) -> None:
+        self.p = p
+        self.q = q
+        self.r = r
+        self.a = a
+        self.b = b
+        self.y0 = y0
+        self.y1 = y1
+
+    def solve(
+        self,
+        h: float = 0.1,
+        method: BVPMethod = BVPMethod.SHOOTING,
+    ) -> Polynomial:
+        """Solve the BVP and return an interpolating :class:`Polynomial`.
+
+        Parameters
+        ----------
+        h:
+            Step size / mesh width.
+        method:
+            Algorithm (:class:`BVPMethod`).
+        """
+
+        if method is BVPMethod.SHOOTING:
+            return self._solve_shooting(h)
+        if method is BVPMethod.FINITE_DIFFERENCE:
+            return self._solve_finite_difference(h)
+
+        raise ValueError(f"Unknown BVP method: {method!r}")
+
+    def _solve_shooting(self, h: float) -> Polynomial:
+        IVP1 = SecondOrderODE_IVP(
+            MultiVariableFunction(
+                lambda t, u1, u2: self.p(t) * u2 + self.q(t) * u1 + self.r(t)
+            ),
+            self.a, self.b, self.y0, 0,
+        )
+        IVP2 = SecondOrderODE_IVP(
+            MultiVariableFunction(lambda t, u1, u2: self.p(t) * u2 + self.q(t) * u1),
+            self.a, self.b, 0, 1,
+        )
+
+        sol1 = IVP1.solve(h)
+        sol2 = IVP2.solve(h)
+        c = (self.y1 - sol1(self.b)) / sol2(self.b)
+
+        return sol1 + c * sol2
+
+    def _solve_finite_difference(self, h: float) -> Polynomial:
+        N = int((self.b - self.a) / h) - 1
+        A = Matrix(*[Vector(*[0.0] * N) for _ in range(N)])
+        b = Vector(*[0.0] * N)
+
+        # First row
+        A[0][0] = -(2 + h**2 * self.q(self.a + h))
+        A[0][1] = 1 - (h / 2) * self.p(self.a + h)
+        b[0] = h**2 * self.r(self.a + h) - (1 + (h / 2) * self.p(self.a + h)) * self.y0
+
+        # Middle rows
+        for i in range(1, N - 1):
+            xi = self.a + (i + 1) * h
+            A[i][i - 1] = 1 + (h / 2) * self.p(xi)
+            A[i][i] = -(2 + h**2 * self.q(xi))
+            A[i][i + 1] = 1 - (h / 2) * self.p(xi)
+            b[i] = h**2 * self.r(xi)
+
+        # Last row
+        A[N - 1][N - 2] = 1 + (h / 2) * self.p(self.b - h)
+        A[N - 1][N - 1] = -(2 + h**2 * self.q(self.b - h))
+        b[N - 1] = (
+            h**2 * self.r(self.b - h)
+            - (1 - (h / 2) * self.p(self.b - h)) * self.y1
+        )
+
+        sol = LinearSystem(A, b).solve()
+        w = [self.y0] + sol.components + [self.y1]
+
+        return Polynomial.interpolate([(self.a + i * h, w[i]) for i in range(N + 2)])
+
+
+class SecondOrderODE_IVP(OrdinaryDifferentialEquation):
+    """Solver for the second-order nonlinear IVP
+
+    .. math::
+
+        y''(x) = f(x,\\,y(x),\\,y'(x)),
+        \\quad y(a) = y_0,\\quad y'(a) = y_1.
+
+    The equation is reduced to a first-order system before numerical integration.
+
+    Parameters
+    ----------
+    f:
+        Right-hand side :math:`f(x, y, y')`.
+    a, b:
+        Integration interval.
+    y0:
+        Initial value :math:`y(a)`.
+    y1:
+        Initial slope :math:`y'(a)`.
+    """
+
+    def __init__(
+        self,
+        f: MultiVariableFunction,
+        a: float,
+        b: float,
+        y0: float,
+        y1: float,
+    ) -> None:
+        self.f = f
+        self.a = a
+        self.b = b
+        self.y0 = y0
+        self.y1 = y1
+
+    def solve(
+        self,
+        h: float = 0.1,
+        method: ODEMethod = ODEMethod.EULER,
+        n: int = 1,
+        step: int = 2,
+        points: list[float] | None = None,
+    ) -> Polynomial:
+        """Solve the IVP via system reduction and return an interpolating :class:`Polynomial`.
+
+        Accepts the same *method*, *n*, *step*, and *points* parameters as
+        :meth:`FirstOrderLinearODE.solve`.
+        """
+        if points is None:
+            points = []
+
+        U0 = Vector(self.y0, self.y1)
+        F = Vector(
+            MultiVariableFunction(lambda t, u1, u2: u2),
+            MultiVariableFunction(lambda t, u1, u2: self.f(t, u1, u2)),
+        )
+        ivp = FirstOrderLinearODE(F, self.a, self.b, U0)
+        sol = ivp.solve(h, method, n, step, points)
+
+        w = [x[0] for x in sol]
+        N = int((self.b - self.a) / h)
+        return Polynomial.interpolate([(self.a + i * h, w[i]) for i in range(len(w))])
+
+
+class SecondOrderODE_BVP(OrdinaryDifferentialEquation):
+    """Solver for the second-order nonlinear BVP
+
+    .. math::
+
+        y''(x) = f(x,\\,y(x),\\,y'(x)),
+        \\quad y(a) = y_0,\\quad y(b) = y_1.
+
+    Parameters
+    ----------
+    f:
+        Right-hand side :math:`f(x, y, y')`.
+    a, b:
+        Boundary points.
+    y0, y1:
+        Boundary values :math:`y(a)` and :math:`y(b)`.
+    """
+
+    def __init__(
+        self,
+        f: MultiVariableFunction,
+        a: float,
+        b: float,
+        y0: float,
+        y1: float,
+    ) -> None:
+        self.f = f
+        self.a = a
+        self.b = b
+        self.y0 = y0
+        self.y1 = y1
+
+    def solve(
+        self,
+        h: float = 0.1,
+        method: NonlinearBVPMethod = NonlinearBVPMethod.SHOOTING_NEWTON,
+        M: int = 100,
+        tol: float = 1e-5,
+        initial_approximation=None,
+    ) -> Polynomial | None:
+        """Solve the nonlinear BVP and return an interpolating :class:`Polynomial`.
+
+        Parameters
+        ----------
+        h:
+            Step size / mesh width.
+        method:
+            Algorithm (:class:`NonlinearBVPMethod`).
+        M:
+            Maximum number of outer iterations.
+        tol:
+            Convergence tolerance.
+        initial_approximation:
+            Initial guess for :math:`y'(a)` (shooting) or interior node values
+            (finite difference).
+        """
+
+        if method is NonlinearBVPMethod.SHOOTING_NEWTON:
+            return self._solve_shooting_newton(h, M, tol, initial_approximation)
+        if method is NonlinearBVPMethod.FINITE_DIFFERENCE:
+            return self._solve_finite_difference(h, M, tol)
+
+        raise ValueError(f"Unknown nonlinear BVP method: {method!r}")
+
+    def _solve_shooting_newton(
+        self, h: float, M: int, tol: float, initial_approximation
+    ) -> Polynomial | None:
+        t = 1.0 if initial_approximation is None else initial_approximation
+        for _ in range(M):
+            IVP1 = SecondOrderODE_IVP(
+                MultiVariableFunction(lambda t_var, u1, u2: self.f(t_var, u1, u2)),
+                self.a, self.b, self.y0, t,
+            )
+            y = IVP1.solve(h)
+
+            p = Function(
+                lambda x: self.f(x, None, y.differentiate()(x)).differentiate()(y(x))
+            )
+            q = Function(
+                lambda x: self.f(x, y(x), None).differentiate()(y.differentiate()(x))
+            )
+            r = Function(lambda x: 0)
+
+            IVP2 = SecondOrderLinearODE_BVP(p, q, r, self.a, self.b, 0, 1)
+            z = IVP2.solve(h)
+
+            t_new = t - (y(self.b) - self.y1) / z(self.b)
+            if abs(t_new - t) < tol:
+                return y
+            t = t_new
+
+        return None
+
+    def _solve_finite_difference(
+        self, h: float, M: int, tol: float
+    ) -> Polynomial | None:
+        N = int(round((self.b - self.a) / h)) - 1
+        pd_step = 1e-5
+
+        def df_dy(x: float, y: float, z: float) -> float:
+            return (self.f(x, y + pd_step, z) - self.f(x, y - pd_step, z)) / (2 * pd_step)
+
+        def df_dz(x: float, y: float, z: float) -> float:
+            return (self.f(x, y, z + pd_step) - self.f(x, y, z - pd_step)) / (2 * pd_step)
+
+        # Linear interpolation as initial guess
+        u = [
+            self.y0 + (j + 1) * h * (self.y1 - self.y0) / (self.b - self.a)
+            for j in range(N)
+        ]
+
+        for _ in range(M):
+            A = Matrix(*[Vector(*[0.0] * N) for _ in range(N)])
+            F = [0.0] * N
+
+            for j in range(N):
+                xi = self.a + (j + 1) * h
+                wi = u[j]
+                wi_prev = u[j - 1] if j > 0 else self.y0
+                wi_next = u[j + 1] if j < N - 1 else self.y1
+                zprime = (wi_next - wi_prev) / (2 * h)
+
+                F[j] = wi_next - 2 * wi + wi_prev - h**2 * self.f(xi, wi, zprime)
+                A[j][j] = -2 - h**2 * df_dy(xi, wi, zprime)
+                if j > 0:
+                    A[j][j - 1] = 1 + (h / 2) * df_dz(xi, wi, zprime)
+                if j < N - 1:
+                    A[j][j + 1] = 1 - (h / 2) * df_dz(xi, wi, zprime)
+
+            delta = LinearSystem(A, Vector(*[-fi for fi in F])).solve()
+            u = [u[j] + delta[j] for j in range(N)]
+
+            if max(abs(delta[j]) for j in range(N)) < tol:
+                w = [self.y0] + u + [self.y1]
+                return Polynomial.interpolate([(self.a + i * h, w[i]) for i in range(N + 2)])
+
+        return None

pysolverkit/util.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import math
+
+from .functions.base import Function
+from .functions.elementary import Polynomial
+
+
+class Util:
+    """Utility helpers for interpolation arithmetic."""
+
+    @staticmethod
+    def choose(s: Function, k: int) -> Polynomial:
+        """Return the falling-factorial polynomial :math:`\\binom{s}{k}`.
+
+        Parameters
+        ----------
+        s:
+            A :class:`~pysolverkit.functions.base.Function` (typically a
+            linear polynomial in *x*).
+        k:
+            Non-negative integer.
+        """
+        res = Polynomial(1)
+        for i in range(k):
+            res = res * (-i + s)
+        return (1 / math.factorial(k)) * res
+
+    @staticmethod
+    def delta(k: int, i: int, data: list[tuple[float, float]]) -> float:
+        """Compute the *k*-th forward difference :math:`\\Delta^k y_i`.
+
+        Parameters
+        ----------
+        k:
+            Order of the forward difference.
+        i:
+            Starting index.
+        data:
+            Sequence of ``(x, y)`` pairs.
+        """
+        if k == 1:
+            return data[i + 1][1] - data[i][1]
+        return Util.delta(k - 1, i + 1, data) - Util.delta(k - 1, i, data)
+
+    @staticmethod
+    def downdelta(k: int, i: int, data: list[tuple[float, float]]) -> float:
+        """Compute the *k*-th backward difference :math:`\\nabla^k y_i`.
+
+        Parameters
+        ----------
+        k:
+            Order of the backward difference.
+        i:
+            Starting index.
+        data:
+            Sequence of ``(x, y)`` pairs.
+        """
+        if k == 1:
+            return data[i][1] - data[i - 1][1]
+        return Util.downdelta(k - 1, i, data) - Util.downdelta(k - 1, i - 1, data)
+