Python Advanced Calculus & Analysis Toolkit

A comprehensive collection of 30 Python programs implementing numerical methods for advanced calculus and mathematical analysis. Each program is self-contained, educational, and demonstrates step-by-step computation with clear output.

No external dependencies beyond NumPy — every algorithm is implemented from scratch.

---

Table of Contents

• Categories
  • 01 — Root Finding Methods
  • 02 — Linear Algebra
  • 03 — Interpolation & Approximation
  • 04 — Numerical Integration
  • 05 — Numerical Differentiation
  • 06 — ODE Solvers
  • 07 — Eigenvalue Problems
  • 08 — Advanced Analysis
• Quick Start
• Running All Programs
• Requirements
• Project Structure

---

Categories

01 — Root Finding Methods

#	Program	Method	Example Problem	Convergence
1	bisection.py	Bisection Method	x³ − x − 2 = 0 on [1, 2]	Linear (½)
2	newton_raphson.py	Newton-Raphson Method	cos(x) − x = 0, x₀ = 0.5	Quadratic
3	secant.py	Secant Method	x³ − 2x − 5 = 0 on [2, 3]	Superlinear (≈1.618)
4	fixed_point.py	Fixed-Point Iteration	x³ + x − 1 = 0	Linear

02 — Linear Algebra

#	Program	Method	Example Problem	Features
5	gaussian_elimination.py	Gaussian Elimination	3×3 system, partial pivoting	Step-by-step elimination
6	lu_decomposition.py	LU Decomposition	4×4 system (Doolittle)	L, U, P matrices
7	jacobi.py	Jacobi Iterative Method	Diagonally dominant 3×3	Convergence tracking
8	gauss_seidel.py	Gauss-Seidel Method	Same 3×3 system	Speed comparison vs Jacobi

03 — Interpolation & Approximation

#	Program	Method	Example Problem	Key Output
9	lagrange.py	Lagrange Interpolation	f(x) = x³ at 5 points	Basis polynomial values
10	newton_divided_diff.py	Newton Divided Difference	eˣ at 4 points	Full DD table
11	cubic_spline.py	Natural Cubic Spline	5 data points	Coefficients per interval

04 — Numerical Integration

#	Program	Method	Example Problem	Accuracy
12	trapezoidal.py	Composite Trapezoidal	∫sin(x)dx, [0, π]	O(h²) convergence
13	simpson.py	Simpson's 1/3 Rule	∫eˣdx, [0, 1]	O(h⁴) convergence
14	romberg.py	Romberg Integration	∫4/(1+x²)dx, [0, 1] → π	Richardson extrapolation
15	gaussian_quadrature.py	Gauss-Legendre (1–5 pt)	∫e^(−x²)dx, [−1, 1]	Nodes & weights

05 — Numerical Differentiation

#	Program	Method	Example Problem	Demonstrates
16	finite_differences.py	Forward/Backward/Central	f(x) = x³ at x = 2	O(h) vs O(h²) error
17	richardson_extrapolation.py	Richardson Extrapolation	f(x) = eˣ at x = 1	1st & 2nd derivatives
18	higher_order_derivatives.py	1st–4th derivatives	f(x) = sin(x) at π/4	Round-off tradeoffs

06 — ODE Solvers

#	Program	Method	Example Problem	Order
19	euler.py	Forward Euler	y' = x + y, y(0) = 1	1st
20	runge_kutta4.py	Classical RK4	y' = −2xy, y(0) = 1	4th
21	adams_bashforth.py	Adams-Bashforth (2 & 4 step)	y' = x² + y	2nd & 4th
22	shooting_method.py	Shooting Method (BVP)	y'' = −y, BCs at 0 and π/2	BVP solver

07 — Eigenvalue Problems

#	Program	Method	Example Problem	Finds
23	power_method.py	Power Method	3×3 symmetric matrix	Dominant eigenvalue
24	qr_algorithm.py	QR Algorithm (Gram-Schmidt)	3×3 tridiagonal	All eigenvalues
25	jacobi_eigenvalue.py	Jacobi Rotation	3×3 symmetric	Eigenvalues + eigenvectors

08 — Advanced Analysis

#	Program	Method	Example Problem	Topics
26	fourier_series.py	Fourier Series	Square wave	Gibbs phenomenon
27	gradient_descent.py	Gradient Descent	Rosenbrock function	Learning rate effects
28	newton_optimization.py	Newton's Optimization	Quadratic minimization	Hessian-based search
29	polynomial_curve_fitting.py	Least Squares Fitting	Noisy sin(x) data	Under/overfitting
30	heat_equation_1d.py	1D Heat Equation (FTCS)	u_t = α·u_xx	PDE solver

---

Quick Start

# Clone the repository
git clone https://github.com/yourusername/python-calculus-analysis.git
cd python-calculus-analysis
# Install dependencies
pip install -r requirements.txt
# Run any single program
python src/01_root_finding/bisection.py
python src/06_ode_solvers/runge_kutta4.py
python src/08_advanced_analysis/heat_equation_1d.py

Output Example

Every program prints a formatted, step-by-step output. For example, bisection.py:

Bisection Method for f(x) = x^3 - x - 2
Searching on interval [1.000, 2.000]
Iter | a | b | f(a) | f(b) | c | f(c) | Error
-----|---------|---------|---------|---------|---------|----------|----------
1 | 1.00000 | 2.00000 | -2.0000 | 4.0000 | 1.50000 | -0.12500 | 0.50000
2 | 1.50000 | 2.00000 | -0.1250 | 4.0000 | 1.75000 | 1.35938 | 0.25000
...
Result: Root = 1.521379706799053 in 33 iterations

---

Running All Programs

# Run all 30 programs
python run_all.py
# Run only a specific category
python run_all.py 01 # Root Finding
python run_all.py 04 # Integration
python run_all.py 08 # Advanced Analysis

---

Requirements

Package	Version	Purpose
NumPy	>= 1.21.0	Array operations, linear algebra (verification only)
Python	>= 3.8	f-strings, type hints

Note: All numerical algorithms are implemented from scratch using only NumPy for array operations. No SciPy dependency is required.

---

Project Structure

python-calculus-analysis/
├── README.md # This file
├── LICENSE # MIT License
├── requirements.txt # Python dependencies
├── run_all.py # Run all programs at once
├── src/
│ ├── 01_root_finding/
│ │ ├── bisection.py
│ │ ├── newton_raphson.py
│ │ ├── secant.py
│ │ └── fixed_point.py
│ ├── 02_linear_algebra/
│ │ ├── gaussian_elimination.py
│ │ ├── lu_decomposition.py
│ │ ├── jacobi.py
│ │ └── gauss_seidel.py
│ ├── 03_interpolation/
│ │ ├── lagrange.py
│ │ ├── newton_divided_diff.py
│ │ └── cubic_spline.py
│ ├── 04_integration/
│ │ ├── trapezoidal.py
│ │ ├── simpson.py
│ │ ├── romberg.py
│ │ └── gaussian_quadrature.py
│ ├── 05_differentiation/
│ │ ├── finite_differences.py
│ │ ├── richardson_extrapolation.py
│ │ └── higher_order_derivatives.py
│ ├── 06_ode_solvers/
│ │ ├── euler.py
│ │ ├── runge_kutta4.py
│ │ ├── adams_bashforth.py
│ │ └── shooting_method.py
│ ├── 07_eigenvalues/
│ │ ├── power_method.py
│ │ ├── qr_algorithm.py
│ │ └── jacobi_eigenvalue.py
│ └── 08_advanced_analysis/
│ ├── fourier_series.py
│ ├── gradient_descent.py
│ ├── newton_optimization.py
│ ├── polynomial_curve_fitting.py
│ └── heat_equation_1d.py
├── examples/
│ └── ... # Example usage and tutorials
└── tests/
└── ... # Unit tests (optional)

---

Design Principles

1. Self-Contained: Each program is a standalone script — run it directly with python script.py
2. Educational: Step-by-step output shows every iteration and intermediate computation
3. No Black Boxes: All algorithms implemented from scratch; NumPy only used for array ops and verification
4. Verified: Every program compares its numerical result against known analytical solutions
5. Documented: Comprehensive docstrings with mathematical formulas, complexity analysis, and references

---

License

This project is licensed under the MIT License — see the LICENSE file for details.