nummeth 0.1.0__tar.gz

nummeth-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Numerical Methods Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nummeth-0.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: nummeth
+Version: 0.1.0
+Summary: A practical, educational Numerical Methods library with iteration tables for laboratories and engineering.
+Author: Numerical Methods Lab
+License-Expression: MIT
+Keywords: numerical-methods,bisection,newton-raphson,gauss-elimination,interpolation,splines,runge-kutta,heat-equation,wave-equation,laplace-equation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.5.0; extra == "plot"
+Provides-Extra: symbolic
+Requires-Dist: sympy>=1.10.0; extra == "symbolic"
+Provides-Extra: all
+Requires-Dist: matplotlib>=3.5.0; extra == "all"
+Requires-Dist: sympy>=1.10.0; extra == "all"
+Requires-Dist: numpy>=1.20.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# NumMeth (`nummeth`)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Versions](https://img.shields.io/badge/python-3.8+-blue.svg)](https://pypi.org/project/nummeth/)
+
+A practical, educational Numerical Methods library designed specifically for **university and engineering laboratories**. 
+
+Unlike generic scientific computing libraries that only return final values, `nummeth` is built for students and instructors:
+- **Clean, intuitive APIs** mirroring standard textbooks.
+- **Pre-formatted ASCII iteration tables** ready for copy-pasting into lab observation sheets and reports (`show_table=True` or `result.print_table()`).
+- **Zero core dependencies** for effortless setup in lab computer networks.
+
+---
+
+## Installation
+
+```bash
+pip install nummeth
+```
+
+For optional plotting and symbolic mathematics support:
+```bash
+pip install nummeth[all]
+```
+
+---
+
+## Features & Modules
+
+### 1. Roots of Algebraic & Transcendental Equations
+- **Bisection Method**: `nm.bisection(f, a, b, tol=1e-5, show_table=True)`
+- **Regula-Falsi (False Position)**: `nm.false_position(f, a, b, tol=1e-5, show_table=True)`
+- **Newton-Raphson Method**: `nm.newton_raphson(f, x0, df=None, tol=1e-5, show_table=True)`
+- **Secant Method**: `nm.secant(f, x0, x1, tol=1e-5, show_table=True)`
+- **Fixed-Point Iteration**: `nm.fixed_point(g, x0, tol=1e-5, show_table=True)`
+
+```python
+import nummeth as nm
+
+f = lambda x: x**3 - x - 2
+res = nm.bisection(f, a=1.0, b=2.0, tol=1e-4, show_table=True)
+print(f"Computed root: {res.root}")
+```
+
+### 2. Systems of Linear Equations & Eigenvalues
+- **Gaussian Elimination** (with or without partial pivoting): `nm.gauss_elimination(A, b, pivoting=True)`
+- **Gauss-Jacobi Iteration**: `nm.gauss_jacobi(A, b, show_table=True)`
+- **Gauss-Seidel Iteration**: `nm.gauss_seidel(A, b, show_table=True)`
+- **Matrix Inversion (Gauss-Jordan)**: `nm.matrix_inverse(A)`
+- **Power Method (Dominant Eigenvalue & Eigenvector)**: `nm.power_method(A, show_table=True)`
+
+```python
+A = [[10, -1, 2],
+     [-1, 11, -1],
+     [2, -1, 10]]
+b = [6, 25, -11]
+
+res = nm.gauss_seidel(A, b, show_table=True)
+print("Solution:", res.solution)
+```
+
+### 3. Interpolation & Splines
+- **Lagrange Interpolation**: `nm.lagrange_interpolate(x, y, x_eval=6.5, symbolic=True)`
+- **Newton's Divided Difference Table & Interpolation**: `nm.divided_difference_interp(x, y, x_eval=3.5, show_table=True)`
+- **Newton Forward Difference Table & Interpolation**: `nm.newton_forward_interp(x, y, x_eval=0.2, show_table=True)`
+- **Newton Backward Difference Table & Interpolation**: `nm.newton_backward_interp(x, y, x_eval=0.8, show_table=True)`
+- **Natural Cubic Spline**: `nm.natural_cubic_spline(x, y, x_eval=2.5, plot=True)`
+
+### 4. Least-Squares Curve Fitting
+- **Polynomial Regression**: `nm.polynomial_fit(x, y, degree=1, plot=True)`
+
+### 5. Numerical Calculus (Differentiation & Integration)
+- **Finite Difference Derivatives**: `nm.derivative_central(f, x)`
+- **Trapezoidal Rule**: `nm.trapezoidal(f, a, b, n)`
+- **Simpson's 1/3 Rule**: `nm.simpson_13(f, a, b, n)`
+- **Simpson's 3/8 Rule**: `nm.simpson_38(f, a, b, n)`
+- **Boole's Rule**: `nm.boole(f, a, b, n)`
+- **Weddle's Rule**: `nm.weddle(f, a, b, n)`
+
+```python
+f = lambda x: 1.0 / (1.0 + x**2)
+res = nm.simpson_13(f, a=0, b=1, n=6)
+print(f"Integral = {res.value} (Approximating π/4)")
+```
+
+### 6. Ordinary Differential Equations (Initial Value Problems)
+- **Euler's Method**: `nm.euler(f, x0, y0, x_end, h, show_table=True)`
+- **Modified Euler / Heun's Method**: `nm.modified_euler(f, x0, y0, x_end, h, show_table=True)`
+- **Runge-Kutta 2nd Order (RK2)**: `nm.rk2(f, x0, y0, x_end, h, show_table=True)`
+- **Runge-Kutta 4th Order (RK4)**: `nm.rk4(f, x0, y0, x_end, h, show_table=True)`
+- **Milne's Predictor-Corrector**: `nm.milne_predictor_corrector(f, x0, y0, x_end, h, show_table=True)`
+
+### 7. Finite Difference Methods for PDEs
+- **Elliptic (Laplace / Poisson 2D)**: `nm.solve_laplace_2d(nx=4, ny=4, top=100, bottom=0, left=50, right=50)`
+- **Parabolic (1D Heat Equation)**:
+  - Bender-Schmidt Explicit Scheme: `nm.heat_1d_bender_schmidt(...)`
+  - Crank-Nicolson Implicit Scheme: `nm.heat_1d_crank_nicolson(...)`
+- **Hyperbolic (1D Wave Equation)**: `nm.wave_1d_explicit(...)`
+
+### 8. Laboratory Applications
+- **Circuit Nodal Voltage Solver**: `nm.solve_circuit_nodal(known_voltages, unknown_nodes, resistors)`
+
+---
+
+## Lab Source Preservation
+The original lab reference scripts are preserved in the [`sources/`](sources/) directory.
+
+## License
+MIT License. Free for educational and commercial use.

nummeth-0.1.0/README.md

@@ -0,0 +1,109 @@
+# NumMeth (`nummeth`)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Versions](https://img.shields.io/badge/python-3.8+-blue.svg)](https://pypi.org/project/nummeth/)
+
+A practical, educational Numerical Methods library designed specifically for **university and engineering laboratories**. 
+
+Unlike generic scientific computing libraries that only return final values, `nummeth` is built for students and instructors:
+- **Clean, intuitive APIs** mirroring standard textbooks.
+- **Pre-formatted ASCII iteration tables** ready for copy-pasting into lab observation sheets and reports (`show_table=True` or `result.print_table()`).
+- **Zero core dependencies** for effortless setup in lab computer networks.
+
+---
+
+## Installation
+
+```bash
+pip install nummeth
+```
+
+For optional plotting and symbolic mathematics support:
+```bash
+pip install nummeth[all]
+```
+
+---
+
+## Features & Modules
+
+### 1. Roots of Algebraic & Transcendental Equations
+- **Bisection Method**: `nm.bisection(f, a, b, tol=1e-5, show_table=True)`
+- **Regula-Falsi (False Position)**: `nm.false_position(f, a, b, tol=1e-5, show_table=True)`
+- **Newton-Raphson Method**: `nm.newton_raphson(f, x0, df=None, tol=1e-5, show_table=True)`
+- **Secant Method**: `nm.secant(f, x0, x1, tol=1e-5, show_table=True)`
+- **Fixed-Point Iteration**: `nm.fixed_point(g, x0, tol=1e-5, show_table=True)`
+
+```python
+import nummeth as nm
+
+f = lambda x: x**3 - x - 2
+res = nm.bisection(f, a=1.0, b=2.0, tol=1e-4, show_table=True)
+print(f"Computed root: {res.root}")
+```
+
+### 2. Systems of Linear Equations & Eigenvalues
+- **Gaussian Elimination** (with or without partial pivoting): `nm.gauss_elimination(A, b, pivoting=True)`
+- **Gauss-Jacobi Iteration**: `nm.gauss_jacobi(A, b, show_table=True)`
+- **Gauss-Seidel Iteration**: `nm.gauss_seidel(A, b, show_table=True)`
+- **Matrix Inversion (Gauss-Jordan)**: `nm.matrix_inverse(A)`
+- **Power Method (Dominant Eigenvalue & Eigenvector)**: `nm.power_method(A, show_table=True)`
+
+```python
+A = [[10, -1, 2],
+     [-1, 11, -1],
+     [2, -1, 10]]
+b = [6, 25, -11]
+
+res = nm.gauss_seidel(A, b, show_table=True)
+print("Solution:", res.solution)
+```
+
+### 3. Interpolation & Splines
+- **Lagrange Interpolation**: `nm.lagrange_interpolate(x, y, x_eval=6.5, symbolic=True)`
+- **Newton's Divided Difference Table & Interpolation**: `nm.divided_difference_interp(x, y, x_eval=3.5, show_table=True)`
+- **Newton Forward Difference Table & Interpolation**: `nm.newton_forward_interp(x, y, x_eval=0.2, show_table=True)`
+- **Newton Backward Difference Table & Interpolation**: `nm.newton_backward_interp(x, y, x_eval=0.8, show_table=True)`
+- **Natural Cubic Spline**: `nm.natural_cubic_spline(x, y, x_eval=2.5, plot=True)`
+
+### 4. Least-Squares Curve Fitting
+- **Polynomial Regression**: `nm.polynomial_fit(x, y, degree=1, plot=True)`
+
+### 5. Numerical Calculus (Differentiation & Integration)
+- **Finite Difference Derivatives**: `nm.derivative_central(f, x)`
+- **Trapezoidal Rule**: `nm.trapezoidal(f, a, b, n)`
+- **Simpson's 1/3 Rule**: `nm.simpson_13(f, a, b, n)`
+- **Simpson's 3/8 Rule**: `nm.simpson_38(f, a, b, n)`
+- **Boole's Rule**: `nm.boole(f, a, b, n)`
+- **Weddle's Rule**: `nm.weddle(f, a, b, n)`
+
+```python
+f = lambda x: 1.0 / (1.0 + x**2)
+res = nm.simpson_13(f, a=0, b=1, n=6)
+print(f"Integral = {res.value} (Approximating π/4)")
+```
+
+### 6. Ordinary Differential Equations (Initial Value Problems)
+- **Euler's Method**: `nm.euler(f, x0, y0, x_end, h, show_table=True)`
+- **Modified Euler / Heun's Method**: `nm.modified_euler(f, x0, y0, x_end, h, show_table=True)`
+- **Runge-Kutta 2nd Order (RK2)**: `nm.rk2(f, x0, y0, x_end, h, show_table=True)`
+- **Runge-Kutta 4th Order (RK4)**: `nm.rk4(f, x0, y0, x_end, h, show_table=True)`
+- **Milne's Predictor-Corrector**: `nm.milne_predictor_corrector(f, x0, y0, x_end, h, show_table=True)`
+
+### 7. Finite Difference Methods for PDEs
+- **Elliptic (Laplace / Poisson 2D)**: `nm.solve_laplace_2d(nx=4, ny=4, top=100, bottom=0, left=50, right=50)`
+- **Parabolic (1D Heat Equation)**:
+  - Bender-Schmidt Explicit Scheme: `nm.heat_1d_bender_schmidt(...)`
+  - Crank-Nicolson Implicit Scheme: `nm.heat_1d_crank_nicolson(...)`
+- **Hyperbolic (1D Wave Equation)**: `nm.wave_1d_explicit(...)`
+
+### 8. Laboratory Applications
+- **Circuit Nodal Voltage Solver**: `nm.solve_circuit_nodal(known_voltages, unknown_nodes, resistors)`
+
+---
+
+## Lab Source Preservation
+The original lab reference scripts are preserved in the [`sources/`](sources/) directory.
+
+## License
+MIT License. Free for educational and commercial use.

nummeth-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nummeth"
+version = "0.1.0"
+description = "A practical, educational Numerical Methods library with iteration tables for laboratories and engineering."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [
+    { name = "Numerical Methods Lab" }
+]
+keywords = [
+    "numerical-methods",
+    "bisection",
+    "newton-raphson",
+    "gauss-elimination",
+    "interpolation",
+    "splines",
+    "runge-kutta",
+    "heat-equation",
+    "wave-equation",
+    "laplace-equation",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Education",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = []
+
+[project.optional-dependencies]
+plot = ["matplotlib>=3.5.0"]
+symbolic = ["sympy>=1.10.0"]
+all = [
+    "matplotlib>=3.5.0",
+    "sympy>=1.10.0",
+    "numpy>=1.20.0",
+]
+dev = [
+    "pytest>=7.0",
+    "build",
+    "twine",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

nummeth-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nummeth-0.1.0/src/nummeth/__init__.py

@@ -0,0 +1,132 @@
+"""
+NumMeth: A Practical, Educational Numerical Methods Library for Laboratories & Engineering.
+"""
+
+__version__ = "0.1.0"
+
+# Core structures
+from nummeth.core.results import IterationResult, TableFormatter
+
+# 1. Algebraic & Transcendental Roots
+from nummeth.roots import (
+    bisection,
+    false_position,
+    newton_raphson,
+    secant,
+    fixed_point,
+)
+
+# 2. Linear Systems & Eigenvalues
+from nummeth.linear_systems import (
+    gauss_elimination,
+    gauss_jacobi,
+    gauss_seidel,
+    matrix_inverse,
+    power_method,
+)
+
+# 3. Interpolation & Splines
+from nummeth.interpolation import (
+    lagrange_interpolate,
+    divided_difference_table,
+    divided_difference_interp,
+    newton_forward_table,
+    newton_forward_interp,
+    newton_backward_table,
+    newton_backward_interp,
+    natural_cubic_spline,
+)
+
+# 4. Curve Fitting & Regression
+from nummeth.fitting import (
+    polynomial_fit,
+)
+
+# 5. Numerical Calculus
+from nummeth.calculus import (
+    derivative_forward,
+    derivative_backward,
+    derivative_central,
+    derivative_second,
+    trapezoidal,
+    simpson_13,
+    simpson_38,
+    boole,
+    weddle,
+)
+
+# 6. Ordinary Differential Equations (IVP)
+from nummeth.ode import (
+    euler,
+    modified_euler,
+    rk2,
+    rk4,
+    milne_predictor_corrector,
+)
+
+# 7. Partial Differential Equations (Finite Differences)
+from nummeth.pde import (
+    solve_laplace_2d,
+    solve_poisson_2d,
+    heat_1d_bender_schmidt,
+    heat_1d_crank_nicolson,
+    wave_1d_explicit,
+)
+
+# 8. Applications
+from nummeth.applications import (
+    solve_circuit_nodal,
+)
+
+__all__ = [
+    "__version__",
+    "IterationResult",
+    "TableFormatter",
+    # Roots
+    "bisection",
+    "false_position",
+    "newton_raphson",
+    "secant",
+    "fixed_point",
+    # Linear
+    "gauss_elimination",
+    "gauss_jacobi",
+    "gauss_seidel",
+    "matrix_inverse",
+    "power_method",
+    # Interpolation
+    "lagrange_interpolate",
+    "divided_difference_table",
+    "divided_difference_interp",
+    "newton_forward_table",
+    "newton_forward_interp",
+    "newton_backward_table",
+    "newton_backward_interp",
+    "natural_cubic_spline",
+    # Fitting
+    "polynomial_fit",
+    # Calculus
+    "derivative_forward",
+    "derivative_backward",
+    "derivative_central",
+    "derivative_second",
+    "trapezoidal",
+    "simpson_13",
+    "simpson_38",
+    "boole",
+    "weddle",
+    # ODE
+    "euler",
+    "modified_euler",
+    "rk2",
+    "rk4",
+    "milne_predictor_corrector",
+    # PDE
+    "solve_laplace_2d",
+    "solve_poisson_2d",
+    "heat_1d_bender_schmidt",
+    "heat_1d_crank_nicolson",
+    "wave_1d_explicit",
+    # Applications
+    "solve_circuit_nodal",
+]

nummeth-0.1.0/src/nummeth/applications/__init__.py

@@ -0,0 +1,4 @@
+"""Real-world numerical applications."""
+from .circuit import solve_circuit_nodal
+
+__all__ = ["solve_circuit_nodal"]

nummeth-0.1.0/src/nummeth/applications/circuit.py

@@ -0,0 +1,78 @@
+"""
+Electrical circuit nodal analysis application using systems of linear equations.
+Ported from laboratory circuit solver exercise.
+"""
+
+from typing import Dict, List, Tuple
+from nummeth.core.results import IterationResult
+from nummeth.linear_systems.elimination import gauss_elimination
+
+def solve_circuit_nodal(
+    known_voltages: Dict[int, float],
+    unknown_nodes: List[int],
+    resistors: List[Tuple[int, int, float]],
+    method: str = "elimination"
+) -> IterationResult:
+    """
+    Solves for unknown node voltages and branch currents in a resistor network
+    using Kirchhoff's Current Law (Nodal Analysis).
+
+    Parameters:
+        known_voltages: Dict mapping node number -> known voltage (e.g. {1: 10.0, 6: 0.0}).
+        unknown_nodes: List of unknown node indices (e.g. [2, 3, 4, 5]).
+        resistors: List of tuples (node1, node2, resistance_in_ohms).
+        method: "elimination" or "seidel".
+
+    Returns:
+        IterationResult where value is dict of all node voltages, and extra['branch_currents']
+        contains branch currents.
+    """
+    n = len(unknown_nodes)
+    index = {node: i for i, node in enumerate(unknown_nodes)}
+
+    A = [[0.0 for _ in range(n)] for _ in range(n)]
+    b = [0.0 for _ in range(n)]
+
+    for node in unknown_nodes:
+        row = index[node]
+        for u, v, r in resistors:
+            if r <= 0:
+                raise ValueError("Resistance must be positive.")
+            if node == u:
+                other = v
+            elif node == v:
+                other = u
+            else:
+                continue
+
+            g = 1.0 / r
+            A[row][row] += g
+
+            if other in index:
+                A[row][index[other]] -= g
+            elif other in known_voltages:
+                b[row] += g * known_voltages[other]
+
+    # Solve linear system
+    sol_res = gauss_elimination(A, b, pivoting=True)
+    voltages = dict(known_voltages)
+    for i, node in enumerate(unknown_nodes):
+        voltages[node] = sol_res.value[i]
+
+    # Calculate branch currents
+    branch_currents = []
+    for u, v, r in resistors:
+        cur = (voltages[u] - voltages[v]) / r
+        branch_currents.append({"from": u, "to": v, "resistance": r, "current": cur})
+
+    return IterationResult(
+        value=voltages,
+        converged=True,
+        message="Circuit nodal voltages and currents resolved successfully.",
+        extra={
+            "voltages": voltages,
+            "branch_currents": branch_currents,
+            "conductance_matrix": A,
+            "rhs_vector": b
+        }
+    )

nummeth-0.1.0/src/nummeth/calculus/__init__.py

@@ -0,0 +1,26 @@
+"""Numerical calculus: differentiation and integration."""
+from .differentiation import (
+    derivative_forward,
+    derivative_backward,
+    derivative_central,
+    derivative_second,
+)
+from .integration import (
+    trapezoidal,
+    simpson_13,
+    simpson_38,
+    boole,
+    weddle,
+)
+
+__all__ = [
+    "derivative_forward",
+    "derivative_backward",
+    "derivative_central",
+    "derivative_second",
+    "trapezoidal",
+    "simpson_13",
+    "simpson_38",
+    "boole",
+    "weddle",
+]

nummeth-0.1.0/src/nummeth/calculus/differentiation.py

@@ -0,0 +1,21 @@
+"""
+Numerical Differentiation using finite difference formulas.
+"""
+
+from typing import Callable, Union, List
+
+def derivative_forward(f: Callable[[float], float], x: float, h: float = 1e-5) -> float:
+    """First derivative via 2-point forward difference: f'(x) ≈ (f(x + h) - f(x)) / h"""
+    return (f(x + h) - f(x)) / h
+
+def derivative_backward(f: Callable[[float], float], x: float, h: float = 1e-5) -> float:
+    """First derivative via 2-point backward difference: f'(x) ≈ (f(x) - f(x - h)) / h"""
+    return (f(x) - f(x - h)) / h
+
+def derivative_central(f: Callable[[float], float], x: float, h: float = 1e-5) -> float:
+    """First derivative via 2-point central difference (O(h^2)): f'(x) ≈ (f(x + h) - f(x - h)) / (2h)"""
+    return (f(x + h) - f(x - h)) / (2.0 * h)
+
+def derivative_second(f: Callable[[float], float], x: float, h: float = 1e-4) -> float:
+    """Second derivative via central difference: f''(x) ≈ (f(x + h) - 2f(x) + f(x - h)) / h^2"""
+    return (f(x + h) - 2.0 * f(x) + f(x - h)) / (h ** 2)