mirror of
https://github.com/janishutz/eth-summaries.git
synced 2026-03-14 23:10:03 +01:00
73 lines
2.5 KiB
TeX
73 lines
2.5 KiB
TeX
% ┌ ┐
|
|
% │ AUTHOR: Janis Hutz<info@janishutz.com> │
|
|
% └ ┘
|
|
|
|
\newsectionNoPB
|
|
\subsection{Quadratur in $\R^d$ und dünne Gitter}
|
|
Eine einfache Option wäre natürlich, zwei eindimensionale Quadraturformeln aneinander zu hängen.
|
|
Für zweidimensionale Funktionen sieht dies so aus:
|
|
\rmvspace
|
|
\begin{align*}
|
|
I = \int_{j_1}^{n_1} \sum_{j_2}^{n_2} \omega_{j_1}^1 \omega_{j_2}^2 f(c_{j_1}^1, c_{j_2}^2)
|
|
\end{align*}
|
|
|
|
\drmvspace
|
|
und für beliebige $d$ haben wir
|
|
\rmvspace
|
|
\begin{align*}
|
|
\left( w_{j_k}^k, c_{j_k}^k \right)_{1 \leq j_k \leq n_k} \smallhspace k = 1, \ldots, d
|
|
\end{align*}
|
|
|
|
\drmvspace
|
|
Was dasselbe ist, wie oben, aber mit $d$ Summen und $d$-mal ein $w_{j_k}$ und eine $d$-dimensionale Funktion $f$
|
|
|
|
% https://www.slingacademy.com/article/scipy-integrate-simpson-function-4-examples/ explains scipy's n-d integration well
|
|
|
|
\innumpy Lassen sich so die bekannten Verfahren wie die Trapez-Regel oder Simpson-Regel leicht auf höhere Dimensionen anwenden
|
|
|
|
\begin{code}{python}
|
|
def trapezoid_2d_mesh(f, a: float, b: float, Nx: int, c: float, d: float, Ny: int):
|
|
""" Trapezoidal rule on a 2d function via np.meshgrid """
|
|
x, hx = np.linspace(a, b, Nx+1, retstep=True)
|
|
y, hy = np.linspace(c, d, Ny+1, retstep=True)
|
|
|
|
X, Y = np.meshgrid(x, y)
|
|
F = f(X, Y)
|
|
|
|
# Apply once along x-axis, once along y-axis
|
|
Q_x = hx/2 * ( 2.0 * np.sum(F[:, 1:-1], axis=1) + F[:, 0] + F[:, -1] )
|
|
Q_y = hy/2 * ( 2.0 * np.sum( Q_x[1:-1] ) + Q_x[0] + Q_x[-1] )
|
|
|
|
return Q_y
|
|
|
|
def simpson_2d_weights(N: int):
|
|
""" Generate weights for simpson rule """
|
|
w = np.zeros(N+1)
|
|
w[0] = 1.0; w[-1] = 1.0
|
|
for i in range(1, N): w[i] = 2.0 if i % 2 == 0 else 4.0
|
|
return w
|
|
|
|
def simpson_2d_mesh(f, a: float, b: float, Nx: int, c: float, d: float, Ny: int):
|
|
""" Simpson rule on a 2d function via np.meshrgdi """
|
|
x, hx = np.linspace(a, b, Nx+1, retstep=True)
|
|
y, hy = np.linspace(c, d, Ny+1, retstep=True)
|
|
|
|
X, Y = np.meshgrid(x, y)
|
|
F = f(X, Y)
|
|
wx, wy = simpson_2d_weights(Nx), simpson_2d_weights(Ny)
|
|
W = np.outer(wx, wy)
|
|
|
|
scale = hx*hy / 3**2
|
|
Q = scale * np.sum( W * F )
|
|
return Q
|
|
\end{code}
|
|
|
|
\newpage
|
|
|
|
\begin{recall}[]{Tensor-Produkt}
|
|
\TODO Write this section
|
|
\end{recall}
|
|
|
|
Die wichtigste Erkenntnis aus diesem Abschnitt ist die Idee, ein \bi{Sparse-Grid} zu verwenden, um die Rechenarbeit zu reduzieren.
|
|
|
|
\innumpy Gibt es die Möglichkeit Sparse-Grid arrays mit \texttt{scipy.sparse} zu erstellen. |