numericalanalysisiiser 0.1.0__py3-none-any.whl

numericalanalysisiiser/__init__.py

@@ -0,0 +1,35 @@
+"""Numerical analysis methods that return pandas DataFrames.
+
+    from numericalanalysis import bisection, richardson, jacobi, lagrange
+"""
+
+__version__ = "0.1.0"
+
+from .lagrange import lagrange
+from .newton_interpolation import newton_interpolation, divided_differences
+from .hermite import hermite
+from .natural_cubic_spline import natural_cubic_spline
+from .finite_differences import finite_difference
+from .richardson import richardson, richardson_triangle
+from .trapezoid import trapezoid, composite_trapezoid
+from .simpson import simpson, composite_simpson
+from .romberg import romberg
+from .gauss_legendre import gauss_legendre
+from .bisection import bisection
+from .fixed_point import fixed_point
+from .newton import newton
+from .secant import secant
+from .jacobi import jacobi
+from .gauss_seidel import gauss_seidel
+from .sor import sor
+from .tridiagonal_matrix import tridiagonal_matrix
+from .euler import euler
+
+__all__ = [
+    "lagrange", "newton_interpolation", "divided_differences", "hermite", "natural_cubic_spline",
+    "finite_difference", "richardson", "richardson_triangle",
+    "trapezoid", "composite_trapezoid", "simpson", "composite_simpson", "romberg", "gauss_legendre",
+    "bisection", "fixed_point", "newton", "secant",
+    "jacobi", "gauss_seidel", "sor", "tridiagonal_matrix",
+    "euler",
+]

numericalanalysisiiser/bisection.py

@@ -0,0 +1,38 @@
+import numpy as np
+import pandas as pd
+
+
+def bisection(f, a, b, tol=1e-10, max_iter=1000, p_star=None):
+    """Bisection method for f(x) = 0 on [a, b]; stops when (b - a) / 2 < tol.
+
+    p_star : optional exact root, adds error
+
+    Returns a DataFrame, one row per iteration: n, a, b, p, f(p), b-a, bound, f_evals [, error]
+    bound = (b0 - a0) / 2^(n+1). The root is the last p.
+    """
+    fa = f(a)
+    if fa * f(b) >= 0:
+        raise ValueError("f(a) and f(b) must have opposite signs")
+
+    a0, b0 = a, b
+    evals = 2
+    rows = []
+
+    for n in range(max_iter):
+        p = (a + b) / 2
+        fp = f(p)
+        evals += 1
+        rows.append([n, a, b, p, fp, b - a, (b0 - a0) / 2 ** (n + 1), evals])
+
+        if fp == 0 or (b - a) / 2 < tol:
+            break
+        if fa * fp < 0:
+            b = p
+        else:
+            a = p
+            fa = fp
+
+    table = pd.DataFrame(rows, columns=["n", "a", "b", "p", "f(p)", "b-a", "bound", "f_evals"])
+    if p_star is not None:
+        table["error"] = np.abs(table["p"] - p_star)
+    return table

numericalanalysisiiser/euler.py

@@ -0,0 +1,39 @@
+import numpy as np
+import pandas as pd
+
+
+def euler(f, t0, T, y0, h, exact=None):
+    """Explicit Euler method for y' = f(t, y), y(t0) = y0 on [t0, T].
+
+    h     : step size, or a list of step sizes
+    exact : optional exact solution y(t), adds exact and error
+
+    Returns a DataFrame (the step sizes stacked): h, t, y, stable [, exact, error]
+    stable is False when |y| exceeds 1e10; y is then nan from that step on.
+    """
+    tables = []
+
+    for step in np.atleast_1d(h):
+        N = int(round((T - t0) / step))
+        if abs(N * step - (T - t0)) > 1e-9:
+            raise ValueError("T - t0 must be a multiple of h")
+
+        t = t0 + step * np.arange(N + 1)
+        y = np.full(N + 1, np.nan)
+        y[0] = y0
+        stable = True
+
+        for i in range(N):
+            y[i + 1] = y[i] + step * f(t[i], y[i])
+            if not abs(y[i + 1]) < 1e10:
+                stable = False
+                y[i + 1:] = np.nan
+                break
+
+        table = pd.DataFrame({"h": step, "t": t, "y": y, "stable": stable})
+        if exact is not None:
+            table["exact"] = [exact(ti) for ti in t]
+            table["error"] = (table["exact"] - table["y"]).abs()
+        tables.append(table)
+
+    return pd.concat(tables, ignore_index=True)

numericalanalysisiiser/finite_differences.py

@@ -0,0 +1,33 @@
+import numpy as np
+import pandas as pd
+
+FORMULAS = {
+    "forward": lambda f, x, h: (f(x + h) - f(x)) / h,
+    "backward": lambda f, x, h: (f(x) - f(x - h)) / h,
+    "central": lambda f, x, h: (f(x + h) - f(x - h)) / (2 * h),
+    "second": lambda f, x, h: (f(x + h) - 2 * f(x) + f(x - h)) / h**2,
+}
+
+
+def finite_difference(f, x, h, exact=None, methods=("forward", "backward", "central")):
+    """Finite difference approximation of f'(x) ("second": f''(x)).
+
+    h       : a step size or a list of step sizes
+    exact   : optional true derivative, adds <method>_error and <method>_order
+    methods : any of "forward", "backward", "central", "second"
+
+    Returns a DataFrame: h, <method> [, <method>_error, <method>_order]
+    """
+    h = np.atleast_1d(np.asarray(h, dtype=float))
+    table = pd.DataFrame({"h": h})
+
+    for method in methods:
+        table[method] = [FORMULAS[method](f, x, step) for step in h]
+        if exact is not None:
+            error = np.abs(table[method].to_numpy() - exact)
+            with np.errstate(divide="ignore", invalid="ignore"):
+                order = np.log(error[:-1] / error[1:]) / np.log(h[:-1] / h[1:])
+            table[method + "_error"] = error
+            table[method + "_order"] = np.append(order, np.nan)
+
+    return table

numericalanalysisiiser/fixed_point.py

@@ -0,0 +1,44 @@
+import numpy as np
+import pandas as pd
+
+
+def fixed_point(g, p0, tol=1e-10, max_iter=1000, f=None, p_star=None):
+    """Fixed point iteration p_(n+1) = g(p_n); stops when |p_(n+1) - p_n| < tol.
+
+    f      : optional function f(x) = 0, adds the residual f(p)
+    p_star : optional exact fixed point, adds error
+
+    Returns a DataFrame, one row per iterate: n, p, g(p), step, [f(p)], f_evals [, error]
+    The last row is the final iterate. The table stops early if g leaves the real numbers or
+    the values exceed 1e12.
+    """
+    p = p0
+    rows = []
+
+    for n in range(max_iter):
+        try:
+            p_next = g(p)
+            if isinstance(p_next, complex) or abs(p_next) > 1e12:
+                break
+        except (ValueError, OverflowError, ZeroDivisionError):
+            break
+
+        row = [n, p, p_next, abs(p_next - p)]
+        if f is not None:
+            row.append(f(p))
+        rows.append(row + [n + 1])
+
+        p = p_next
+        if rows[-1][3] < tol:
+            break
+
+    final = [len(rows), p, np.nan, np.nan]
+    if f is not None:
+        final.append(f(p))
+    rows.append(final + [len(rows)])
+
+    columns = ["n", "p", "g(p)", "step"] + (["f(p)"] if f is not None else []) + ["f_evals"]
+    table = pd.DataFrame(rows, columns=columns)
+    if p_star is not None:
+        table["error"] = np.abs(table["p"] - p_star)
+    return table

numericalanalysisiiser/gauss_legendre.py

@@ -0,0 +1,27 @@
+import numpy as np
+import pandas as pd
+
+
+def gauss_legendre(f, a, b, n=2, exact=None):
+    """Gauss-Legendre quadrature for the integral of f over [a, b].
+
+    n     : number of Gauss points, or a list of them
+    exact : optional true value, adds error
+
+    Returns a DataFrame: n, value [, error]
+    """
+    n = np.atleast_1d(n)
+    values = []
+
+    for k in n:
+        points, weights = np.polynomial.legendre.leggauss(int(k))
+        total = 0
+        for i in range(k):
+            x = (a + b) / 2 + ((b - a) / 2) * points[i]
+            total += weights[i] * f(x)
+        values.append(((b - a) / 2) * total)
+
+    table = pd.DataFrame({"n": n, "value": values})
+    if exact is not None:
+        table["error"] = np.abs(table["value"].to_numpy() - exact)
+    return table

numericalanalysisiiser/gauss_seidel.py

@@ -0,0 +1,42 @@
+import numpy as np
+import pandas as pd
+
+
+def gauss_seidel(A, b, x0=None, tol=1e-6, max_iter=100):
+    """Gauss-Seidel iteration for A x = b; stops when max|x_k - x_(k-1)| < tol.
+
+    x0 : starting vector (zeros by default)
+
+    Returns a DataFrame, one row per iteration (k = 0 is the starting vector):
+    k, 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):
+            sum_off_diag = 0.0
+            for j in range(n):
+                if i != j:
+                    sum_off_diag += A[i, j] * x_new[j]
+            x_new[i] = (b[i] - sum_off_diag) / A[i, i]
+
+        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)), "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/hermite.py

@@ -0,0 +1,39 @@
+import numpy as np
+import pandas as pd
+
+
+def hermite(x, y, dy, alpha, exact=None):
+    """Hermite polynomial matching the values y and slopes dy at the nodes x, evaluated at alpha.
+
+    alpha : a number or a list of points
+    exact : optional function f(x), adds the columns exact and error
+
+    Returns a DataFrame: alpha, p [, exact, error]
+    """
+    alpha = np.atleast_1d(np.asarray(alpha, dtype=float))
+    n = len(x)
+
+    a = np.repeat(x, 2)
+    M = np.zeros((2 * n, 2 * n))
+    M[:, 0] = np.repeat(y, 2)
+
+    for i in range(1, 2 * n):
+        if a[i] == a[i - 1]:
+            M[i, 1] = dy[i // 2]
+        else:
+            M[i, 1] = (M[i, 0] - M[i - 1, 0]) / (a[i] - a[i - 1])
+
+    for j in range(2, 2 * n):
+        for i in range(j, 2 * n):
+            M[i, j] = (M[i, j - 1] - M[i - 1, j - 1]) / (a[i] - a[i - j])
+
+    c = np.diag(M)
+    p = np.zeros(len(alpha))
+    for k in range(2 * n - 1, -1, -1):
+        p = c[k] + (alpha - a[k]) * p
+
+    table = pd.DataFrame({"alpha": alpha, "p": p})
+    if exact is not None:
+        table["exact"] = [exact(a) for a in alpha]
+        table["error"] = (table["exact"] - table["p"]).abs()
+    return table

numericalanalysisiiser/jacobi.py

@@ -0,0 +1,42 @@
+import numpy as np
+import pandas as pd
+
+
+def jacobi(A, b, x0=None, tol=1e-6, max_iter=100):
+    """Jacobi iteration for A x = b; stops when max|x_k - x_(k-1)| < tol.
+
+    x0 : starting vector (zeros by default)
+
+    Returns a DataFrame, one row per iteration (k = 0 is the starting vector):
+    k, 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 = np.zeros(n)
+        for i in range(n):
+            sum_off_diag = 0.0
+            for j in range(n):
+                if i != j:
+                    sum_off_diag += A[i, j] * x[j]
+            x_new[i] = (b[i] - sum_off_diag) / A[i, i]
+
+        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)), "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/lagrange.py

@@ -0,0 +1,28 @@
+import numpy as np
+import pandas as pd
+
+
+def lagrange(x, y, alpha, exact=None):
+    """Lagrange polynomial through the points (x, y), evaluated at alpha.
+
+    alpha : a number or a list of points
+    exact : optional function f(x), adds the columns exact and error
+
+    Returns a DataFrame: alpha, p [, exact, error]
+    """
+    alpha = np.atleast_1d(np.asarray(alpha, dtype=float))
+    n = len(x)
+    p = np.zeros(len(alpha))
+
+    for i in range(n):
+        l_i = np.ones(len(alpha))
+        for j in range(n):
+            if j != i:
+                l_i *= (alpha - x[j]) / (x[i] - x[j])
+        p += y[i] * l_i
+
+    table = pd.DataFrame({"alpha": alpha, "p": p})
+    if exact is not None:
+        table["exact"] = [exact(a) for a in alpha]
+        table["error"] = (table["exact"] - table["p"]).abs()
+    return table

numericalanalysisiiser/natural_cubic_spline.py

@@ -0,0 +1,48 @@
+import numpy as np
+import pandas as pd
+
+
+def natural_cubic_spline(x, y, alpha, exact=None):
+    """Natural cubic spline through the points (x, y), evaluated at alpha.
+
+    alpha : a number or a list of points
+    exact : optional function f(x), adds the columns exact and error
+
+    Returns a DataFrame: alpha, p [, exact, error]
+    """
+    x = np.array(x, dtype=float)
+    y = np.array(y, dtype=float)
+    alpha = np.atleast_1d(np.asarray(alpha, dtype=float))
+    n = len(x) - 1
+    h = np.diff(x)
+
+    A = np.zeros((n + 1, n + 1))
+    b = np.zeros(n + 1)
+    A[0, 0] = 1.0
+    A[n, n] = 1.0
+
+    for i in range(1, n):
+        A[i, i - 1] = h[i - 1]
+        A[i, i] = 2.0 * (h[i - 1] + h[i])
+        A[i, i + 1] = h[i]
+        b[i] = 6.0 * ((y[i + 1] - y[i]) / h[i] - (y[i] - y[i - 1]) / h[i - 1])
+
+    M = np.linalg.solve(A, b)
+
+    p = np.zeros(len(alpha))
+    for idx, t in enumerate(alpha):
+        i = int(np.clip(np.searchsorted(x, t) - 1, 0, n - 1))
+        dx_right = x[i + 1] - t
+        dx_left = t - x[i]
+        p[idx] = (
+            M[i] * dx_right**3 / (6.0 * h[i])
+            + M[i + 1] * dx_left**3 / (6.0 * h[i])
+            + (y[i] - M[i] * h[i]**2 / 6.0) * dx_right / h[i]
+            + (y[i + 1] - M[i + 1] * h[i]**2 / 6.0) * dx_left / h[i]
+        )
+
+    table = pd.DataFrame({"alpha": alpha, "p": p})
+    if exact is not None:
+        table["exact"] = [exact(a) for a in alpha]
+        table["error"] = (table["exact"] - table["p"]).abs()
+    return table

numericalanalysisiiser/newton.py

@@ -0,0 +1,36 @@
+import numpy as np
+import pandas as pd
+
+
+def newton(f, df, p0, tol=1e-12, max_iter=100, p_star=None):
+    """Newton's method; stops when |p_(n+1) - p_n| < tol.
+
+    df     : derivative f'(x)
+    p_star : optional exact root, adds error and q
+
+    Returns a DataFrame, one row per iterate: n, p, f(p), f'(p), step, f_evals, df_evals [, error, q]
+    The last row is the final iterate. q = log(e_(n+1)/e_n) / log(e_n/e_(n-1)) is the estimated order.
+    """
+    p = p0
+    rows = []
+
+    for n in range(max_iter):
+        fp, dfp = f(p), df(p)
+        p_next = p - fp / dfp
+        rows.append([n, p, fp, dfp, abs(p_next - p), n + 1, n + 1])
+        p = p_next
+        if rows[-1][4] < tol:
+            break
+
+    rows.append([len(rows), p, f(p), np.nan, np.nan, len(rows), len(rows)])
+    table = pd.DataFrame(rows, columns=["n", "p", "f(p)", "f'(p)", "step", "f_evals", "df_evals"])
+
+    if p_star is not None:
+        error = np.abs(table["p"].to_numpy() - p_star)
+        e = np.where(error < 1e-15, np.nan, error)        # round-off sized errors are ignored
+        q = np.full(len(e), np.nan)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            q[1:-1] = np.log(e[2:] / e[1:-1]) / np.log(e[1:-1] / e[:-2])
+        table["error"] = error
+        table["q"] = q
+    return table

numericalanalysisiiser/newton_interpolation.py

@@ -0,0 +1,51 @@
+import numpy as np
+import pandas as pd
+
+
+def divided_differences(x, y):
+    """Divided difference table of the points (x, y).
+
+    Returns a DataFrame: x, f[0], f[1], ...  (the first row holds the Newton coefficients)
+    """
+    n = len(x)
+    columns = [list(y)]
+
+    for j in range(1, n):
+        col = []
+        for i in range(n - j):
+            col.append((columns[j - 1][i + 1] - columns[j - 1][i]) / (x[i + j] - x[i]))
+        columns.append(col + [np.nan] * j)
+
+    table = pd.DataFrame({"x": list(x)})
+    for j in range(n):
+        table[f"f[{j}]"] = columns[j]
+    return table
+
+
+def newton_interpolation(x, y, alpha, exact=None):
+    """Newton form of the interpolation polynomial through the points (x, y), evaluated at alpha.
+
+    alpha : a number or a list of points
+    exact : optional function f(x), adds the columns exact and error
+
+    Returns a DataFrame: alpha, p [, exact, error]
+    """
+    alpha = np.atleast_1d(np.asarray(alpha, dtype=float))
+    n = len(x)
+
+    a = list(y)
+    for j in range(1, n):
+        for i in range(n - 1, j - 1, -1):
+            a[i] = (a[i] - a[i - 1]) / (x[i] - x[i - j])
+
+    p = a[0] * np.ones(len(alpha))
+    product = np.ones(len(alpha))
+    for i in range(1, n):
+        product = product * (alpha - x[i - 1])
+        p += a[i] * product
+
+    table = pd.DataFrame({"alpha": alpha, "p": p})
+    if exact is not None:
+        table["exact"] = [exact(a) for a in alpha]
+        table["error"] = (table["exact"] - table["p"]).abs()
+    return table

numericalanalysisiiser/richardson.py

@@ -0,0 +1,68 @@
+import numpy as np
+import pandas as pd
+
+from .finite_differences import FORMULAS
+
+
+def richardson_triangle(first_column, p=2):
+    """Richardson table as a list of rows: R[k][j] = R[k][j-1] + (R[k][j-1] - R[k-1][j-1]) / (2^(p*j) - 1).
+
+    first_column[k] is computed with step h / 2^k.
+    p = 2 for central differences and the trapezoidal rule, p = 1 for forward / backward differences.
+    """
+    R = []
+    for k in range(len(first_column)):
+        row = [first_column[k]]
+        for j in range(1, k + 1):
+            row.append(row[j - 1] + (row[j - 1] - R[k - 1][j - 1]) / (2 ** (p * j) - 1))
+        R.append(row)
+    return R
+
+
+def richardson(f, x, h, levels=1, method="central", exact=None, layout="by_h"):
+    """Richardson extrapolation of a finite difference formula at the point x.
+
+    method : "forward", "backward", "central" or "second"
+    exact  : optional true derivative, adds R<j>_error and R<j>_order
+    layout : "by_h"     h is a list of steps; R0 = D(h), R1 = (4 D(h/2) - D(h)) / 3, ...
+             "triangle" h is one step h0; row k uses h0 / 2^k and R[k][j] = R[k][j-1] + (R[k][j-1] - R[k-1][j-1]) / (4^j - 1)
+
+    Returns a DataFrame: h, R0, R1, ...  (triangle: k, h, R0, R1, ...)
+    """
+    D = lambda step: FORMULAS[method](f, x, step)
+    p = 1 if method in ("forward", "backward") else 2
+
+    if layout == "by_h":
+        h = np.atleast_1d(np.asarray(h, dtype=float))
+        rows = []
+        for step in h:
+            values = [D(step / 2**m) for m in range(levels + 1)]
+            row = [values[0]]
+            for j in range(1, levels + 1):
+                factor = 2 ** (p * j)
+                values = [(factor * values[m + 1] - values[m]) / (factor - 1) for m in range(len(values) - 1)]
+                row.append(values[0])
+            rows.append(row)
+        table = pd.DataFrame(rows, columns=[f"R{j}" for j in range(levels + 1)])
+        table.insert(0, "h", h)
+    elif layout == "triangle":
+        steps = [h / 2**k for k in range(levels + 1)]
+        table = pd.DataFrame(richardson_triangle([D(step) for step in steps], p))
+        table.columns = [f"R{j}" for j in range(levels + 1)]
+        table.insert(0, "h", steps)
+        table.insert(0, "k", range(levels + 1))
+    else:
+        raise ValueError("layout must be 'by_h' or 'triangle'")
+
+    if exact is not None:
+        for j in range(levels + 1):
+            error = np.abs(table[f"R{j}"].to_numpy() - exact)
+            with np.errstate(divide="ignore", invalid="ignore"):
+                if layout == "by_h":
+                    order = np.append(np.log(error[:-1] / error[1:]) / np.log(h[:-1] / h[1:]), np.nan)
+                else:
+                    order = np.append(np.nan, np.log2(error[:-1] / error[1:]))
+            table[f"R{j}_error"] = error
+            table[f"R{j}_order"] = order
+
+    return table

numericalanalysisiiser/romberg.py

@@ -0,0 +1,30 @@
+import pandas as pd
+
+from .richardson import richardson_triangle
+from .trapezoid import composite_trapezoid
+
+
+def romberg(f, a, b, levels=6, tol=None, exact=None):
+    """Romberg integration of f over [a, b].
+
+    levels : number of rows, row k uses n = 2^k sub-intervals
+    tol    : if given, rows are added until |R[k][k] - R[k-1][k-1]| < tol
+    exact  : optional true value, adds the error of the diagonal entries
+
+    Returns a DataFrame: n, R0, R1, ... [, error]. The last entry of the last row is the answer.
+    """
+    T = []
+    while True:
+        T.append(composite_trapezoid(f, a, b, 2 ** len(T)))
+        R = richardson_triangle(T)
+        if tol is None and len(T) >= levels:
+            break
+        if tol is not None and (len(T) >= 25 or (len(T) >= 2 and abs(R[-1][-1] - R[-2][-1]) < tol)):
+            break
+
+    table = pd.DataFrame(R)
+    table.columns = [f"R{j}" for j in range(len(R))]
+    table.insert(0, "n", [2**k for k in range(len(R))])
+    if exact is not None:
+        table["error"] = [abs(R[k][k] - exact) for k in range(len(R))]
+    return table

numericalanalysisiiser/secant.py

@@ -0,0 +1,42 @@
+import numpy as np
+import pandas as pd
+
+
+def secant(f, p0, p1, tol=1e-12, max_iter=100, p_star=None):
+    """Secant method; stops when |p_(n+1) - p_n| < tol.
+
+    p_star : optional exact root, adds error and q
+
+    Returns a DataFrame, one row per iterate: n, p_prev, p, f(p), p_next, step, f_evals [, error, q]
+    The last row is the final iterate. q = log(e_(n+1)/e_n) / log(e_n/e_(n-1)) is the estimated order.
+    """
+    p_prev, p_curr = p0, p1
+    f_prev, f_curr = f(p0), f(p1)
+    evals = 2
+    rows = []
+
+    for n in range(1, max_iter + 1):
+        if f_curr == f_prev:
+            break
+        p_next = p_curr - f_curr * (p_curr - p_prev) / (f_curr - f_prev)
+        f_next = f(p_next)
+        evals += 1
+        rows.append([n, p_prev, p_curr, f_curr, p_next, abs(p_next - p_curr), evals])
+
+        p_prev, f_prev = p_curr, f_curr
+        p_curr, f_curr = p_next, f_next
+        if rows[-1][5] < tol:
+            break
+
+    rows.append([len(rows) + 1, p_prev, p_curr, f_curr, np.nan, np.nan, evals])
+    table = pd.DataFrame(rows, columns=["n", "p_prev", "p", "f(p)", "p_next", "step", "f_evals"])
+
+    if p_star is not None:
+        e_prev, e_curr, e_next = (np.abs(table[c].to_numpy() - p_star) for c in ("p_prev", "p", "p_next"))
+        mask = np.minimum(np.minimum(e_prev, e_curr), e_next) < 1e-15          # round-off sized errors are ignored
+        with np.errstate(divide="ignore", invalid="ignore"):
+            q = np.log(e_next / e_curr) / np.log(e_curr / e_prev)
+        q[mask] = np.nan
+        table["error"] = e_curr
+        table["q"] = q
+    return table