pysolverkit 0.1.0__py3-none-any.whl

pysolverkit/functions/elementary.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING
+
+from ..enums import InterpolationMethod, InterpolationForm
+from .base import Function
+
+if TYPE_CHECKING:
+    pass
+
+
+class Polynomial(Function):
+    """A polynomial function :math:`p(x) = a_0 + a_1 x + \\cdots + a_n x^n`.
+
+    Parameters
+    ----------
+    *coefficients:
+        Coefficients in **ascending** degree order: ``a_0, a_1, ..., a_n``.
+    """
+
+    def __init__(self, *coefficients: float) -> None:
+        self.coefficients = coefficients
+        self.function = lambda x: sum(a * x**i for i, a in enumerate(coefficients))
+
+    @staticmethod
+    def interpolate(
+        data: list[tuple[float, float]] | list[float],
+        method: InterpolationMethod = InterpolationMethod.NEWTON,
+        f: Function | None = None,
+        form: InterpolationForm = InterpolationForm.STANDARD,
+    ) -> Polynomial:
+        """Construct an interpolating polynomial.
+
+        Parameters
+        ----------
+        data:
+            Either a list of ``(x, y)`` tuples, **or** a list of *x* values
+            when *f* is provided.
+        method:
+            Interpolation algorithm (:class:`InterpolationMethod`).
+        f:
+            If provided, evaluates *f* at each *x* in *data* to build the
+            ``(x, y)`` pairs.
+        form:
+            Newton form variant (:class:`InterpolationForm`): ``STANDARD``
+            (divided differences), ``FORWARD_DIFF``, or ``BACKWARD_DIFF``.
+        """
+        if f is not None:
+            data = [(x, f(x)) for x in data]
+
+        if method is InterpolationMethod.LAGRANGE:
+            return Polynomial._interpolate_lagrange(data)
+        if method is InterpolationMethod.NEWTON:
+            if form is InterpolationForm.STANDARD:
+                return Polynomial._interpolate_newton(data)
+            if form is InterpolationForm.FORWARD_DIFF:
+                return Polynomial._interpolate_newton_forward_diff(data)
+            if form is InterpolationForm.BACKWARD_DIFF:
+                return Polynomial._interpolate_newton_backward_diff(data)
+
+        raise ValueError(f"Unknown interpolation method/form combination: {method!r}/{form!r}")
+
+    @staticmethod
+    def _interpolate_lagrange(data: list[tuple[float, float]]) -> Polynomial:
+        n = len(data)
+        x = [d[0] for d in data]
+        y = [d[1] for d in data]
+        p = Polynomial(0)
+
+        for i in range(n):
+            L = Polynomial(1)
+            for j in range(n):
+                if i != j:
+                    L = L * Polynomial(-x[j], 1) / Polynomial(x[i] - x[j])
+            p = p + y[i] * L
+
+        return p
+
+    @staticmethod
+    def _interpolate_newton(data: list[tuple[float, float]]) -> Polynomial:
+        n = len(data)
+        x = [d[0] for d in data]
+        y = [d[1] for d in data]
+
+        def divided_difference(i: int, j: int) -> float:
+            if i == j:
+                return y[i]
+            return (divided_difference(i + 1, j) - divided_difference(i, j - 1)) / (x[j] - x[i])
+
+        def factor_product(roots: list[float]) -> Polynomial:
+            if not roots:
+                return Polynomial(1)
+            return Polynomial(-roots[0], 1) * factor_product(roots[1:])
+
+        coefficients = [divided_difference(0, i) for i in range(n)]
+        p = Polynomial(coefficients[0])
+        for i in range(1, n):
+            p = p + coefficients[i] * factor_product(x[:i])
+
+        return p
+
+    @staticmethod
+    def _interpolate_newton_forward_diff(data: list[tuple[float, float]]) -> Polynomial:
+        from ..util import Util
+
+        data = sorted(data, key=lambda d: d[0])
+        diffs = sorted([data[i + 1][0] - data[i][0] for i in range(len(data) - 1)])
+        for j in range(len(diffs) - 1):
+            if abs(diffs[j + 1] - diffs[j]) >= 1e-6:
+                raise ValueError("x values must be equally spaced for Newton forward-difference.")
+
+        h = abs(diffs[0])
+        n = len(data) - 1
+
+        p = Polynomial(data[0][1])
+        for k in range(1, n + 1):
+            p = p + Util.delta(k, 0, data) * Util.choose(Polynomial(-data[0][0] / h, 1 / h), k)
+
+        return p
+
+    @staticmethod
+    def _interpolate_newton_backward_diff(data: list[tuple[float, float]]) -> Polynomial:
+        from ..util import Util
+
+        data = sorted(data, key=lambda d: d[0])
+        diffs = sorted([data[i + 1][0] - data[i][0] for i in range(len(data) - 1)])
+        for j in range(len(diffs) - 1):
+            if abs(diffs[j + 1] - diffs[j]) >= 1e-6:
+                raise ValueError("x values must be equally spaced for Newton backward-difference.")
+
+        h = abs(diffs[0])
+        n = len(data) - 1
+
+        p = Polynomial(data[n][1])
+        for k in range(1, n + 1):
+            p = p + ((-1) ** k * Util.downdelta(k, n, data)) * Util.choose(
+                Polynomial(data[n][0] / h, -1 / h), k
+            )
+
+        return p
+
+
+class Exponent(Function):
+    """The exponential function :math:`b^{f(x)}`.
+
+    Parameters
+    ----------
+    f:
+        Exponent function.
+    base:
+        Base of the exponential (defaults to :math:`e`).
+    """
+
+    def __init__(self, f: Function, base: float = math.e) -> None:
+        self.function = lambda x: base ** f(x)
+
+
+class Sin(Function):
+    """The sine function :math:`\\sin(f(x))`."""
+
+    def __init__(self, f: Function) -> None:
+        self.function = lambda x: math.sin(f(x))
+
+
+class Cos(Function):
+    """The cosine function :math:`\\cos(f(x))`."""
+
+    def __init__(self, f: Function) -> None:
+        self.function = lambda x: math.cos(f(x))
+
+
+class Tan(Function):
+    """The tangent function :math:`\\tan(f(x))`."""
+
+    def __init__(self, f: Function) -> None:
+        self.function = lambda x: math.tan(f(x))
+
+
+class Log(Function):
+    """The logarithm :math:`\\log_b(f(x))`.
+
+    Parameters
+    ----------
+    f:
+        Argument function.
+    base:
+        Logarithm base (defaults to :math:`e`, i.e. natural logarithm).
+    """
+
+    def __init__(self, f: Function, base: float = math.e) -> None:
+        self.function = lambda x: math.log(f(x), base)

pysolverkit/functions/fem2d.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from ..linalg.linear_system import LinearSystem
+from ..linalg.matrix import Matrix
+from ..linalg.vector import Vector
+from ..enums import LinearSolverMethod
+from .multivariate import BivariateFunction
+
+
+class FEM2D:
+    r"""Solve 2D Poisson problems on rectangles with linear triangular FEM.
+
+    Solves
+
+    .. math::
+        -\Delta u(x,y) = f(x,y)\ 	ext{in}\ \Omega=[x_a,x_b]	imes[y_a,y_b],
+        \quad u=g\ 	ext{on}\ \partial\Omega.
+
+    Parameters
+    ----------
+    f:
+        Source term :math:`f(x,y)`.
+    g:
+        Dirichlet boundary condition :math:`g(x,y)`.
+    xa, xb, ya, yb:
+        Rectangle bounds.
+    """
+
+    def __init__(self, f: BivariateFunction, g: BivariateFunction, xa: float, xb: float, ya: float, yb: float) -> None:
+        self.f = f
+        self.g = g
+        self.xa = xa
+        self.xb = xb
+        self.ya = ya
+        self.yb = yb
+
+    def solve(self, nx: int = 4, ny: int = 4) -> BivariateFunction:
+        """Return a :class:`BivariateFunction` FEM approximation on an ``nx x ny`` mesh."""
+        hx = (self.xb - self.xa) / nx
+        hy = (self.yb - self.ya) / ny
+        n_total = (nx + 1) * (ny + 1)
+
+        def nidx(i: int, j: int) -> int:
+            return i * (ny + 1) + j
+
+        def ncoords(i: int, j: int) -> tuple[float, float]:
+            return self.xa + i * hx, self.ya + j * hy
+
+        K = [[0.0] * n_total for _ in range(n_total)]
+        F = [0.0] * n_total
+
+        for i in range(nx):
+            for j in range(ny):
+                x00, y00 = ncoords(i, j)
+                x10, y10 = ncoords(i + 1, j)
+                x01, y01 = ncoords(i, j + 1)
+                x11, y11 = ncoords(i + 1, j + 1)
+
+                self._add_element(
+                    K,
+                    F,
+                    [(x00, y00), (x10, y10), (x01, y01)],
+                    [nidx(i, j), nidx(i + 1, j), nidx(i, j + 1)],
+                )
+                self._add_element(
+                    K,
+                    F,
+                    [(x10, y10), (x11, y11), (x01, y01)],
+                    [nidx(i + 1, j), nidx(i + 1, j + 1), nidx(i, j + 1)],
+                )
+
+        boundary: dict[int, float] = {}
+        for i in range(nx + 1):
+            for j in range(ny + 1):
+                if i == 0 or i == nx or j == 0 or j == ny:
+                    k = nidx(i, j)
+                    xk, yk = ncoords(i, j)
+                    boundary[k] = self.g(xk, yk)
+
+        for k, gk in boundary.items():
+            for m in range(n_total):
+                if m not in boundary:
+                    F[m] -= K[m][k] * gk
+
+        for k, gk in boundary.items():
+            for m in range(n_total):
+                K[k][m] = 0.0
+                K[m][k] = 0.0
+            K[k][k] = 1.0
+            F[k] = gk
+
+        A_mat = Matrix(*[Vector(*K[r]) for r in range(n_total)])
+        b_vec = Vector(*F)
+        sol = LinearSystem(A_mat, b_vec).solve(method=LinearSolverMethod.GAUSS_ELIMINATION)
+        u = sol.components
+
+        xa_ = self.xa
+        ya_ = self.ya
+
+        def eval_u(x: float, y: float) -> float:
+            ix = max(0, min(nx - 1, int((x - xa_) / hx)))
+            jy = max(0, min(ny - 1, int((y - ya_) / hy)))
+            lx = max(0.0, min(1.0, (x - (xa_ + ix * hx)) / hx))
+            ly = max(0.0, min(1.0, (y - (ya_ + jy * hy)) / hy))
+            u00 = u[nidx(ix, jy)]
+            u10 = u[nidx(ix + 1, jy)]
+            u01 = u[nidx(ix, jy + 1)]
+            u11 = u[nidx(ix + 1, jy + 1)]
+            return (1 - lx) * (1 - ly) * u00 + lx * (1 - ly) * u10 + (1 - lx) * ly * u01 + lx * ly * u11
+
+        return BivariateFunction(eval_u)
+
+    def _add_element(self, K: list[list[float]], F: list[float], verts: list[tuple[float, float]], idxs: list[int]) -> None:
+        x1, y1 = verts[0]
+        x2, y2 = verts[1]
+        x3, y3 = verts[2]
+
+        area = 0.5 * abs((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1))
+        if area == 0:
+            return
+
+        b = [y2 - y3, y3 - y1, y1 - y2]
+        c = [x3 - x2, x1 - x3, x2 - x1]
+
+        for i in range(3):
+            for j in range(3):
+                K[idxs[i]][idxs[j]] += (b[i] * b[j] + c[i] * c[j]) / (4 * area)
+            F[idxs[i]] += (area / 3) * self.f(verts[i][0], verts[i][1])

pysolverkit/functions/multivariate.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from .base import Function
+from ..linalg.vector import Vector
+
+
+class MultiVariableFunction:
+    """A function of two or more scalar (or :class:`~pysolverkit.linalg.Vector`) arguments.
+
+    Supports **partial application**: pass ``None`` for any argument to defer it,
+    returning a new :class:`~pysolverkit.functions.base.Function` (for a single
+    free argument) or a new :class:`MultiVariableFunction` (for multiple free arguments).
+
+    Parameters
+    ----------
+    function:
+        A callable that accepts all positional scalar arguments.
+    """
+
+    def __init__(self, function) -> None:
+        self.function = function
+
+    def __call__(self, *args):
+        # Unpack any Vector arguments into their scalar components
+        unwrapped: list = []
+        for arg in args:
+            if isinstance(arg, Vector):
+                unwrapped.extend(arg.components)
+            else:
+                unwrapped.append(arg)
+        args = tuple(unwrapped)
+
+        if all(arg is not None for arg in args):
+            return self.function(*args)
+        if all(arg is None for arg in args):
+            raise ValueError("At least one argument must be non-None.")
+
+        # Build a partially-applied function
+        original = list(args)
+
+        def partial(*z):
+            filled = list(z)
+            arguments = [filled.pop(0) if arg is None else arg for arg in original]
+            return self(*arguments)
+
+        n_free = sum(arg is None for arg in args)
+        if n_free == 1:
+            return Function(partial)
+        return MultiVariableFunction(partial)
+
+
+class BivariateFunction(MultiVariableFunction):
+    """A :class:`MultiVariableFunction` specialised for exactly two arguments.
+
+    This is a convenience alias — no additional behaviour beyond
+    :class:`MultiVariableFunction`.
+    """

pysolverkit/linalg/__init__.py

@@ -0,0 +1,5 @@
+from .vector import Vector
+from .matrix import Matrix
+from .linear_system import LinearSystem
+
+__all__ = ["Vector", "Matrix", "LinearSystem"]

pysolverkit/linalg/linear_system.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from ..enums import LinearSolverMethod
+from .vector import Vector
+from .matrix import Matrix
+
+
+class LinearSystem:
+    """A system of linear equations :math:`Ax = b`.
+
+    Parameters
+    ----------
+    A:
+        The coefficient :class:`Matrix`.
+    b:
+        The right-hand-side :class:`Vector`.
+    """
+
+    def __init__(self, A: Matrix, b: Vector) -> None:
+        self.A = A
+        self.b = b
+        self.N = len(A)
+
+        if len(b) != self.N:
+            raise ValueError("A and b must have the same number of rows.")
+
+    def solve(
+        self,
+        method: LinearSolverMethod = LinearSolverMethod.GAUSS_ELIMINATION,
+        tol: float = 1e-5,
+        initial_approximation: Vector | None = None,
+        max_iterations: int = 100,
+    ) -> Vector:
+        """Solve the linear system and return the solution :class:`Vector`.
+
+        Parameters
+        ----------
+        method:
+            Solver algorithm to use (:class:`LinearSolverMethod`).
+        tol:
+            Convergence tolerance for iterative solvers.
+        initial_approximation:
+            Starting guess for iterative solvers.
+        max_iterations:
+            Maximum number of iterations for iterative solvers.
+        """
+        if method is LinearSolverMethod.GAUSS_ELIMINATION:
+            return self._gauss_elimination()
+        if method is LinearSolverMethod.GAUSS_JACOBI:
+            return self._gauss_jacobi(tol, initial_approximation, max_iterations)
+        if method is LinearSolverMethod.GAUSS_SEIDEL:
+            return self._gauss_seidel(tol, initial_approximation, max_iterations)
+
+        raise ValueError(f"Unknown method: {method!r}")
+
+    # ------------------------------------------------------------------
+    # Private solvers
+    # ------------------------------------------------------------------
+
+    def _gauss_elimination(self) -> Vector:
+        for i in range(self.N - 1):
+            p = next((j for j in range(i, self.N) if abs(self.A[j][i]) != 0), None)
+            if p is None:
+                raise ValueError("No unique solution exists.")
+
+            if p != i:
+                self.A[i], self.A[p] = self.A[p], self.A[i]
+                self.b[i], self.b[p] = self.b[p], self.b[i]
+
+            for j in range(i + 1, self.N):
+                m = self.A[j][i] / self.A[i][i]
+                self.A[j] = self.A[j] - m * self.A[i]
+                self.b[j] = self.b[j] - m * self.b[i]
+
+        if abs(self.A[self.N - 1][self.N - 1]) == 0:
+            raise ValueError("No unique solution exists.")
+
+        x: list[float] = [0.0] * self.N
+        x[self.N - 1] = self.b[self.N - 1] / self.A[self.N - 1][self.N - 1]
+        for i in range(self.N - 2, -1, -1):
+            x[i] = (
+                self.b[i] - sum(self.A[i][j] * x[j] for j in range(i + 1, self.N))
+            ) / self.A[i][i]
+
+        return Vector(*x)
+
+    def _gauss_jacobi(
+        self, tol: float, initial_approximation: Vector | None, max_iterations: int
+    ) -> Vector | None:
+        if initial_approximation is None:
+            raise ValueError("initial_approximation must be provided for iterative solvers.")
+
+        x0 = initial_approximation
+        for _ in range(max_iterations):
+            x1 = [
+                (self.b[i] - sum(self.A[i][j] * x0[j] for j in range(self.N) if j != i))
+                / self.A[i][i]
+                for i in range(self.N)
+            ]
+            if (
+                max(abs(x1[i] - x0[i]) for i in range(self.N))
+                / max(abs(x1[i]) for i in range(self.N))
+                < tol
+            ):
+                return Vector(*x1)
+            x0 = x1
+
+        return None
+
+    def _gauss_seidel(
+        self, tol: float, initial_approximation: Vector | None, max_iterations: int
+    ) -> Vector | None:
+        if initial_approximation is None:
+            raise ValueError("initial_approximation must be provided for iterative solvers.")
+
+        x0 = initial_approximation
+        for _ in range(max_iterations):
+            x1 = [0.0] * self.N
+            for i in range(self.N):
+                x1[i] = (
+                    self.b[i]
+                    - sum(self.A[i][j] * x1[j] for j in range(i))
+                    - sum(self.A[i][j] * x0[j] for j in range(i + 1, self.N))
+                ) / self.A[i][i]
+
+            if (
+                max(abs(x1[i] - x0[i]) for i in range(self.N))
+                / max(abs(x1[i]) for i in range(self.N))
+                < tol
+            ):
+                return Vector(*x1)
+            x0 = x1
+
+        return None

pysolverkit/linalg/matrix.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from .vector import Vector
+
+
+class Matrix:
+    """A rectangular array of scalars stored as a sequence of row :class:`Vector` objects."""
+
+    def __init__(self, *rows: Vector) -> None:
+        self.rows: list[Vector] = list(rows)
+
+    # ------------------------------------------------------------------
+    # Arithmetic
+    # ------------------------------------------------------------------
+
+    def __add__(self, other: Matrix) -> Matrix:
+        return Matrix(*[self.rows[i] + other.rows[i] for i in range(len(self))])
+
+    def __sub__(self, other: Matrix) -> Matrix:
+        return Matrix(*[self.rows[i] - other.rows[i] for i in range(len(self))])
+
+    def __rmul__(self, scalar: float) -> Matrix:
+        return Matrix(*[scalar * self.rows[i] for i in range(len(self))])
+
+    # ------------------------------------------------------------------
+    # Container interface
+    # ------------------------------------------------------------------
+
+    def __getitem__(self, i: int) -> Vector:
+        return self.rows[i]
+
+    def __setitem__(self, i: int, value: Vector) -> None:
+        self.rows[i] = value
+
+    def __len__(self) -> int:
+        return len(self.rows)
+
+    def __iter__(self):
+        return iter(self.rows)
+
+    def __repr__(self) -> str:
+        return f"Matrix({', '.join(repr(r) for r in self.rows)})"

pysolverkit/linalg/vector.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+
+class Vector:
+    """An ordered sequence of scalar components with element-wise arithmetic."""
+
+    def __init__(self, *components: float) -> None:
+        self.components: list[float] = list(components)
+
+    # ------------------------------------------------------------------
+    # Arithmetic
+    # ------------------------------------------------------------------
+
+    def __add__(self, other: Vector) -> Vector:
+        return Vector(*[self.components[i] + other.components[i] for i in range(len(self))])
+
+    def __sub__(self, other: Vector) -> Vector:
+        return Vector(*[self.components[i] - other.components[i] for i in range(len(self))])
+
+    def __rmul__(self, scalar: float) -> Vector:
+        return Vector(*[scalar * self.components[i] for i in range(len(self))])
+
+    def __call__(self, *args) -> Vector:
+        return Vector(*[self.components[i](*args) for i in range(len(self))])
+
+    # ------------------------------------------------------------------
+    # Container interface
+    # ------------------------------------------------------------------
+
+    def __getitem__(self, i: int) -> float:
+        return self.components[i]
+
+    def __setitem__(self, i: int, value: float) -> None:
+        self.components[i] = value
+
+    def __len__(self) -> int:
+        return len(self.components)
+
+    def __iter__(self):
+        return iter(self.components)
+
+    def __str__(self) -> str:
+        return "<" + ", ".join(str(c) for c in self.components) + ">"
+
+    def __repr__(self) -> str:
+        return f"Vector({', '.join(repr(c) for c in self.components)})"

pysolverkit/ode/__init__.py

@@ -0,0 +1,12 @@
+from .base import OrdinaryDifferentialEquation, LinearODE
+from .first_order import FirstOrderLinearODE
+from .second_order import SecondOrderLinearODE_BVP, SecondOrderODE_IVP, SecondOrderODE_BVP
+
+__all__ = [
+    "OrdinaryDifferentialEquation",
+    "LinearODE",
+    "FirstOrderLinearODE",
+    "SecondOrderLinearODE_BVP",
+    "SecondOrderODE_IVP",
+    "SecondOrderODE_BVP",
+]

pysolverkit/ode/base.py

@@ -0,0 +1,6 @@
+class OrdinaryDifferentialEquation:
+    """Abstract base class for ordinary differential equations."""
+
+
+class LinearODE(OrdinaryDifferentialEquation):
+    """Abstract base class for linear ordinary differential equations."""