SciPy — overview of submodules — Coding notes

WHAT is SciPy?

WHY submodules? Loading everything would be slow and memory-heavy. SciPy is deliberately split so you pay only for the corner of mathematics you actually use. This is the 80/20 rule baked into the design: 20% of submodules (stats, optimize, integrate, linalg, interpolate) cover ~80% of real scientific work.

The map of submodules

Formula The "cheat sheet" of core submodules

Submodule	Domain	One-line job
`scipy.linalg`	Linear algebra	solve $Ax=b$ , eigenvalues, decompositions (richer than `numpy.linalg`)
`scipy.optimize`	Optimization & roots	minimize $f(x)$ , find roots, curve fitting
`scipy.integrate`	Integration & ODEs	$\int f\,dx$ , solve $\dot y = f(t,y)$
`scipy.interpolate`	Interpolation	fit smooth curves through data points
`scipy.stats`	Statistics	distributions, tests, descriptive stats
`scipy.signal`	Signal processing	filters, convolution, spectral analysis
`scipy.fft`	Fast Fourier Transform	frequency-domain analysis
`scipy.sparse`	Sparse matrices	store/solve huge mostly-zero matrices
`scipy.spatial`	Spatial data	KD-trees, distances, Delaunay triangulation
`scipy.ndimage`	n-D image processing	filtering, morphology on arrays
`scipy.special`	Special functions	Bessel, gamma, erf, etc.
`scipy.constants`	Physical constants	$c$ , $h$ , $\pi$ , unit conversions

HOW to remember the split: every submodule answers a verb — solve, optimize, integrate, interpolate, test, filter, transform.

WHY first principles? Two mini-derivations using SciPy

You don't have to trust SciPy — you can derive-from-scratch what each routine does and check it agrees.

1. `scipy.integrate.quad` — what is it really doing?

Derive a baseline (trapezoid rule) to understand what quad improves on:

Approximate area of one strip of width $h$ between points $x_i, x_{i+1}$ by a trapezoid: $A_i = h\cdot\frac{f(x_i)+f(x_{i+1})}{2}$ Sum all strips: $\int_a^b f\,dx \approx \sum_i A_i = h\Big(\tfrac{f_0}{2} + f_1 + \dots + f_{n-1} + \tfrac{f_n}{2}\Big)$ quad is far smarter (adaptive, high order) but converges to the same true value.

Worked example Verify

$\int_0^1 x^2\,dx = \tfrac13$

from scipy import integrate
val, err = integrate.quad(lambda x: x**2, 0, 1)
print(val, err)   # 0.3333333333333333  ~1e-15

Why this step? quad returns two numbers: the estimate and an error bound — always read both so you know how much to trust it.

2. `scipy.optimize.minimize` — what does "minimize" mean?

Derive the optimum by hand to predict the answer: $\frac{d}{dx}(x-3)^2 = 2(x-3) = 0 \;\Rightarrow\; x=3,\quad f(3)=0$

Worked example

Forecast-then-Verify Forecast: the minimizer should land at $x=3$ , value $0$ .

from scipy import optimize
res = optimize.minimize(lambda x: (x-3)**2, x0=0.0)
print(res.x, res.fun)   # [3.0000...] [~0]

Why x0? Iterative optimizers need a starting guess; they walk downhill from there. Why it matches: SciPy's gradient-based search converges to the analytic minimum we derived.

3. `scipy.linalg.solve` — solving $Ax=b$

Worked example Solve

$\begin{cases}3x+y=9\\ x+2y=8\end{cases}$ By hand: from the first, $y=9-3x$ ; substitute: $x+2(9-3x)=8 \Rightarrow x+18-6x=8 \Rightarrow x=2,\ y=3$ .

from scipy import linalg
import numpy as np
A = np.array([[3,1],[1,2]]); b = np.array([9,8])
print(linalg.solve(A, b))   # [2. 3.]

Why not invert $A$ ? solve uses LU decomposition — faster and numerically more stable than computing $A^{-1}$ then multiplying.

Common mistakes

Flashcards

What is SciPy built on top of?

NumPy — it provides numerical algorithms that operate on NumPy arrays.

Why is SciPy split into submodules?

So you import only the domain you need (speed/memory); mirrors the 80/20 idea.

Which submodule solves

Ax=b

and does decompositions?

scipy.linalg.

Which submodule minimizes functions and finds roots / curve fits?

scipy.optimize.

Which submodule does numerical integration and ODE solving?

scipy.integrate.

Which submodule has probability distributions and statistical tests?

scipy.stats.

Which submodule handles huge mostly-zero matrices?

scipy.sparse.

Which submodule has Fourier transforms?

scipy.fft.

What two values does integrate.quad return?

The estimate and an absolute error bound (value, abserr).

Why prefer scipy.linalg over numpy.linalg?

More routines, always LAPACK-backed, often faster/more stable.

In modern SciPy, does import scipy; scipy.stats work without explicitly importing the submodule?

Yes — modern SciPy (≥1.8) lazily loads submodules via __getattr__; explicit import is still good style though.

What does optimize.minimize need besides the function?

A starting guess x0 (it descends from there).

Which submodule has interpolation routines?

scipy.interpolate.

Which submodule has special functions like Bessel and gamma?

scipy.special.

Which submodule gives physical constants like

c

and

h

scipy.constants.

Recall Feynman: explain to a 12-year-old

NumPy is like a giant box of LEGO bricks (numbers). SciPy is the instruction-booklet folder: one booklet teaches you to build a bridge (linear algebra), another a roller-coaster (optimization), another a measuring-area machine (integration). You don't dump out every booklet at once — you grab just the one for what you're building today. That's why you write "give me the statistics booklet" → from scipy import stats.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, NumPy tumhe deta hai fast arrays — yaani numbers ka dabba. Lekin un numbers par actual kaam karne ke liye — jaise integration, equation solve karna, optimization, statistics — uske liye aata hai SciPy. SciPy NumPy ke upar bana hua hai, aur ye chhote-chhote submodules mein divided hai. Har submodule ek alag mathematics ka kaam karta hai: linalg matrix solve karta hai, optimize function ka minimum dhoondta hai, integrate area/ODE nikalta hai, stats mein probability distributions hain, sparse se bade khaali-khaali matrices handle hote hain.

Ek important point: modern SciPy (1.8 ke baad) mein submodules lazily load hote hain, isliye import scipy; scipy.stats.norm ab bina explicit import ke bhi chal jaata hai. Phir bhi achhi style yahi hai ki tum explicitly from scipy import optimize, stats likho — clear rehta hai aur purani versions par bhi safe hai. 80/20 rule yaad rakho: paanch submodules (stats, optimize, integrate, linalg, interpolate) hi 80% kaam cover kar dete hain.

Sabse achhi cheez — tumhe SciPy par "andhe bharose" nahi karna. Jaise note mein dikhaya, pehle haath se derive karo (jaise $(x-3)^2$ ka minimum $x=3$ par), phir SciPy se verify karo. Isko bolte hain Forecast-then-Verify: pehle answer predict, phir check. Aur dhyaan rakho quad do cheezein deta hai — value aur error bound — dono ko unpack karo. Yehi habit tumhe ek strong scientific programmer banayegi.

SciPy — overview of submodules