SciPy — overview of submodules — Hinglish notes

5.4.8 · Coding › Scientific Computing (Python)

SciPy KYA hai?

Submodules KYU? Sab kuch load karna slow aur memory-heavy hoga. SciPy deliberately split kiya gaya hai taaki tum sirf usi mathematics ke corner ka cost uthao jo tum actually use karte ho. Yeh 80/20 rule hai jo design mein baka hua hai: 20% submodules (stats, optimize, integrate, linalg, interpolate) ~80% real scientific work cover karte hain.

Submodules ka map

Formula Core submodules ki "cheat sheet"

Submodule	Domain	Ek-line kaam
`scipy.linalg`	Linear algebra	$A x = b$ solve karo, eigenvalues, decompositions (`numpy.linalg` se zyada rich)
`scipy.optimize`	Optimization & roots	$f (x)$ minimize karo, roots dhundo, curve fitting karo
`scipy.integrate`	Integration & ODEs	$\int f d x$ , $\overset{y}{˙} = f (t, y)$ solve karo
`scipy.interpolate`	Interpolation	data points ke through smooth curves fit karo
`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	huge mostly-zero matrices store/solve karo
`scipy.spatial`	Spatial data	KD-trees, distances, Delaunay triangulation
`scipy.ndimage`	n-D image processing	arrays par filtering, morphology
`scipy.special`	Special functions	Bessel, gamma, erf, etc.
`scipy.constants`	Physical constants	$c$ , $h$ , $π$ , unit conversions

Split yaad karne ka TARIKA: har submodule ek verb ka jawab deta hai — solve, optimize, integrate, interpolate, test, filter, transform.

Pehle principles KYU? SciPy use karke do mini-derivations

Tumhe SciPy par trust nahi karna — tum scratch se derive kar sakte ho ki har routine kya karti hai aur check kar sakte ho ki yeh agree karti hai.

1. `scipy.integrate.quad` — yeh asal mein kya kar raha hai?

Ek baseline (trapezoid rule) derive karo taaki samjho ki quad kya improve karta hai:

Points $x_{i}, x_{i + 1}$ ke beech width $h$ ki ek strip ki approximate area ek trapezoid se: $A_{i} = h \cdot \frac{f ( x _{i} ) + f ( x _{i + 1} )}{2}$ Sab strips jodo: $\int_{a}^{b} f d x \approx \sum_{i} A_{i} = h (\frac{f _{0}}{2} + f_{1} + \dots + f_{n - 1} + \frac{f _{n}}{2})$ quad bahut zyada smart hai (adaptive, high order) lekin usi same true value par converge karta hai.

Worked example Verify karo

$\int_{0}^{1} x^{2} d x = \frac{1}{3}$

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

Yeh step KYU? quad do numbers return karta hai: estimate aur ek error bound — dono hamesha padho taaki pata rahe kitna trust karna hai.

2. `scipy.optimize.minimize` — "minimize" ka matlab kya hai?

Optimum haath se derive karo answer predict karne ke liye: $\frac{d}{d x} (x - 3)^{2} = 2 (x - 3) = 0 \Rightarrow x = 3, f (3) = 0$

Worked example

Forecast-then-Verify Forecast: minimizer ko $x = 3$ par land karna chahiye, 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]

x0 KYU? Iterative optimizers ko ek starting guess chahiye; woh wahan se downhill chalte hain. Kyun match karta hai: SciPy ka gradient-based search us analytic minimum par converge karta hai jo humne derive kiya.

3. `scipy.linalg.solve` — $A x = b$ solve karna

Worked example

${3 x + y = 9 x + 2 y = 8$ solve karo Haath se: pehle se, $y = 9 - 3 x$ ; substitute karo: $x + 2 (9 - 3 x) = 8 \Rightarrow x + 18 - 6 x = 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.]

$A$ ko invert KYU nahi karte? solve LU decomposition use karta hai — $A^{- 1}$ compute karke phir multiply karne se faster aur numerically zyada stable.

Common mistakes

Flashcards

SciPy kis cheez ke upar bana hai?

NumPy — yeh numerical algorithms provide karta hai jo NumPy arrays par operate karte hain.

SciPy ko submodules mein kyun split kiya gaya hai?

Taaki tum sirf wahi domain import karo jo chahiye (speed/memory); 80/20 idea ko mirror karta hai.

Kaun sa submodule

A x = b

solve karta hai aur decompositions karta hai?

scipy.linalg.

Kaun sa submodule functions minimize karta hai aur roots / curve fits dhundta hai?

scipy.optimize.

Kaun sa submodule numerical integration aur ODE solving karta hai?

scipy.integrate.

Kaun sa submodule mein probability distributions aur statistical tests hain?

scipy.stats.

Kaun sa submodule huge mostly-zero matrices handle karta hai?

scipy.sparse.

Kaun sa submodule mein Fourier transforms hain?

scipy.fft.

integrate.quad kaun si do values return karta hai?

Estimate aur ek absolute error bound (value, abserr).

numpy.linalg ke upar scipy.linalg kyun prefer karein?

Zyada routines, hamesha LAPACK-backed, often faster/more stable.

Modern SciPy mein, kya import scipy; scipy.stats bina explicitly submodule import kiye kaam karta hai?

Haan — modern SciPy (≥1.8) __getattr__ ke zariye submodules lazily load karta hai; explicit import phir bhi good style hai.

optimize.minimize ko function ke alawa aur kya chahiye?

Ek starting guess x0 (woh wahan se descend karta hai).

Kaun sa submodule mein interpolation routines hain?

scipy.interpolate.

Kaun sa submodule mein Bessel aur gamma jaise special functions hain?

scipy.special.

Kaun sa submodule

c

aur

h

jaise physical constants deta hai?

scipy.constants.

Recall Feynman: ek 12-saal ke bacche ko explain karo

NumPy LEGO bricks (numbers) ka ek giant box hai. SciPy instruction-booklet folder hai: ek booklet tumhe bridge banana sikhati hai (linear algebra), doosri roller-coaster (optimization), teesri ek area-measuring machine (integration). Tum saare booklets ek saath nahi nikaalo — tum sirf woh ek uthao jo aaj tum kya bana rahe ho uske liye. Isliye tum likhte ho "mujhe statistics booklet do" → from scipy import stats.