math-computation

# Mathematical Computation Symbolic and numerical mathematics. Venv: `source /Users/zhangmingda/clawd/.venv/bin/activate` ## Symbolic Math (SymPy) ```python from sympy import * x, y, z, t = symbols('x y z t') a, b, c = symbols('a b c', real=True) n, k = symbols('n k', integer=True, positive=True) # Solve equations solve(x**2 - 5*x + 6, x) # [2, 3] solve([x + y - 5, x - y - 1], [x, y]) # {x: 3, y: 2} # Calculus diff(sin(x)*exp(x), x) # derivative integrate(x**2 * exp(-x), (x, 0, oo)) # definite integral limit(sin(x)/x, x, 0) # limit series(exp(x), x, 0, 5) # Taylor series # Linear algebra M = Matrix([[1, 2], [3, 4]]) M.eigenvals() # eigenvalues M.eigenvects() # eigenvectors M.det() # determinant M.inv() # inverse # Differential equations f = Function('f') dsolve(f(x).diff(x, 2) + f(x), f(x)) # y'' + y = 0 # Simplification simplify(sin(x)**2 + cos(x)**2) # 1 trigsimp(expr) factor(expr) expand(expr) # LaTeX output latex(expr) # for paper-ready equations ``` ## Numerical Methods (SciPy) ```python from scipy import optimize, integrate, linalg, interpolate import numpy as np # Root finding root = optimize.brentq(lambda x: x**3 - 2*x - 5, 2, 3) # Optimization result = optimize.minimize(lambda x: (x[0]-1)**2 + (x[1]-2.5)**2, x0=[0, 0], method='Nelder-Mead') # Constrained optimization from scipy.optimize import linprog, minimize result = minimize(objective, x0, constraints=constraints, bounds=bounds) # Numerical integration val, err = integrate.quad(lambda x: np.exp(-x**2), -np.inf, np.inf) # √π # ODE solving from scipy.integrate import solve_ivp def lorenz(t, state, sigma=10, rho=28, beta=8/3): x, y, z = state return [sigma*(y-x), x*(rho-z)-y, x*y-beta*z] sol = solve_ivp(lorenz, [0, 50], [1, 1, 1], dense_output=True, max_step=0.01) # Interpolation f_interp = interpolate.interp1d(x_data, y_data, kind='cubic') # FFT from scipy.fft import fft, fftfreq yf = fft(signal) xf = fftfreq(N, 1/sample_rate) ``` ## Linear Algebra ```python # NumPy A = np.array([[1, 2], [3, 4]]) np.linalg.eig(A) # eigendecomposition np.linalg.svd(A) # SVD np.linalg.solve(A, b) # solve Ax = b np.linalg.norm(A) # matrix norm np.linalg.matrix_rank(A) # Sparse matrices (SciPy) from scipy.sparse import csr_matrix, linalg as sparse_linalg ``` ## Mathematical Modeling Workflow 1. **Define** the system and variables 2. **Formulate** equations (conservation laws, constitutive relations) 3. **Non-dimensionalize** if appropriate 4. **Solve** analytically (SymPy) or numerically (SciPy) 5. **Validate** against known solutions or data 6. **Sensitivity analysis** on parameters 7. **Visualize** results ## Common Models - **Population dynamics**: Lotka-Volterra, SIR/SEIR epidemiological - **Diffusion**: Heat equation, Fick's law - **Mechanics**: Newton's laws, Lagrangian/Hamiltonian - **Economics**: Supply-demand, game theory, optimal control - **Networks**: Graph theory, flow optimization ## Tips - Use SymPy for exact solutions, SciPy for numerical - Always verify numerical solutions against analytical when possible - Check units and dimensional consistency - Use `latex()` to generate paper-ready equations - For large systems, consider sparse matrix methods