numericalanalysisiiser 0.1.0__py3-none-any.whl

numericalanalysisiiser/simpson.py

@@ -0,0 +1,38 @@
+import numpy as np
+import pandas as pd
+
+
+def composite_simpson(f, a, b, n):
+    """Composite Simpson 1/3 rule with n (even) sub-intervals (a single number)."""
+    if n % 2 != 0:
+        raise ValueError("n must be even")
+    h = (b - a) / n
+    total = f(a) + f(b)
+    for k in range(1, n):
+        if k % 2 == 0:
+            total += 2 * f(a + k * h)
+        else:
+            total += 4 * f(a + k * h)
+    return (h / 3) * total
+
+
+def simpson(f, a, b, n=2, exact=None):
+    """Simpson's 1/3 rule for the integral of f over [a, b].
+
+    n     : number of sub-intervals (even), or a list of them (n = 2 is the basic rule)
+    exact : optional true value, adds error and order
+
+    Returns a DataFrame: n, h, value [, error, order]
+    """
+    n = np.atleast_1d(n)
+    h = (b - a) / n
+    table = pd.DataFrame({"n": n, "h": h, "value": [composite_simpson(f, a, b, int(k)) for k in n]})
+
+    if exact is not None:
+        error = np.abs(table["value"].to_numpy() - exact)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            order = np.log(error[:-1] / error[1:]) / np.log(h[:-1] / h[1:])
+        table["error"] = error
+        table["order"] = np.append(order, np.nan)
+
+    return table

numericalanalysisiiser/sor.py

@@ -0,0 +1,42 @@
+import numpy as np
+import pandas as pd
+
+
+def sor(A, b, omega, x0=None, tol=1e-6, max_iter=1000):
+    """Successive over-relaxation for A x = b; stops when max|x_k - x_(k-1)| < tol.
+
+    omega : relaxation parameter (omega = 1 is Gauss-Seidel)
+    x0    : starting vector (zeros by default)
+
+    Returns a DataFrame, one row per iteration (k = 0 is the starting vector):
+    k, omega, step, residual, q, x1, x2, ...
+    step = max|x_k - x_(k-1)|, residual = max|b - A x_k|, q = residual_k / residual_(k-1).
+    The solution is the last row of x1, x2, ...
+    """
+    A = np.array(A, dtype=float)
+    b = np.array(b, dtype=float)
+    n = len(b)
+    x = np.zeros(n) if x0 is None else np.array(x0, dtype=float)
+
+    xs = [x]
+    step = [np.nan]
+    residual = [np.max(np.abs(b - A @ x))]
+
+    for k in range(1, max_iter + 1):
+        x_new = x.copy()
+        for i in range(n):
+            sum1 = np.dot(A[i, :i], x_new[:i])
+            sum2 = np.dot(A[i, i + 1:], x[i + 1:])
+            x_gs = (b[i] - sum1 - sum2) / A[i, i]
+            x_new[i] = (1 - omega) * x[i] + omega * x_gs
+
+        step.append(np.max(np.abs(x_new - x)))
+        x = x_new
+        xs.append(x)
+        residual.append(np.max(np.abs(b - A @ x)))
+        if step[-1] < tol:
+            break
+
+    table = pd.DataFrame({"k": range(len(xs)), "omega": omega, "step": step, "residual": residual})
+    table["q"] = table["residual"] / table["residual"].shift(1)
+    return pd.concat([table, pd.DataFrame(xs, columns=[f"x{i + 1}" for i in range(n)])], axis=1)

numericalanalysisiiser/trapezoid.py

@@ -0,0 +1,33 @@
+import numpy as np
+import pandas as pd
+
+
+def composite_trapezoid(f, a, b, n):
+    """Composite trapezoidal rule with n sub-intervals (a single number)."""
+    h = (b - a) / n
+    total = f(a) + f(b)
+    for j in range(1, n):
+        total += 2 * f(a + j * h)
+    return (h / 2) * total
+
+
+def trapezoid(f, a, b, n=1, exact=None):
+    """Trapezoidal rule for the integral of f over [a, b].
+
+    n     : number of sub-intervals, or a list of them (n = 1 is the basic rule)
+    exact : optional true value, adds error and order
+
+    Returns a DataFrame: n, h, value [, error, order]
+    """
+    n = np.atleast_1d(n)
+    h = (b - a) / n
+    table = pd.DataFrame({"n": n, "h": h, "value": [composite_trapezoid(f, a, b, int(k)) for k in n]})
+
+    if exact is not None:
+        error = np.abs(table["value"].to_numpy() - exact)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            order = np.log(error[:-1] / error[1:]) / np.log(h[:-1] / h[1:])
+        table["error"] = error
+        table["order"] = np.append(order, np.nan)
+
+    return table

numericalanalysisiiser/tridiagonal_matrix.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+
+def tridiagonal_matrix(n, diag=4.0, off=-1.0):
+    """n x n matrix with diag on the main diagonal and off on the two neighbouring diagonals."""
+    A = np.zeros((n, n))
+    for i in range(n):
+        A[i, i] = diag
+        if i > 0:
+            A[i, i - 1] = off
+        if i < n - 1:
+            A[i, i + 1] = off
+    return A