Ing Mathematik: Numerisches Lösen von Eigenwertproblemen

• 
• 
• 

Insbesondere bei Schwingungen sind Eigenwerte und -vektoren von Bedeutung (siehe z.B. Vorlage:W oder Hagedorn, Hochlenert: Technische Schwingungslehre. Harri Deutsch, 2012, ISBN 978-3-8171-1890-8). Aber auch die Hauptspannungen in der Festigkeitslehre können als Eigenwertproblem behandelt werden (siehe z.B. Vorlage:W und Hagedorn, Wallaschek: Technische Mechanik Bd.2, Festigkeitslehre. Europa, 5.Aufl., 2015, ISBN 978-3-8085-5691-7).

Eigenwerte und Eigenvektoren - Allgemeines

Es sei

$Ax=\lambda x$ mit $A\in {ℝ}^{n\times n},x\in {ℝ}^n,\lambda \in ℝ$.

$Ax-\lambda Ix=0$ mit $I$ als nxn-Einheitsmatrix.

$(A-\lambda I)x=0$

Für nicht triviale Lösungen ($x\ne 0$) muss gelten:

$\det (A-\lambda I)=0$ (charakteristische Gleichung oder Säkulargleichung).

${\lambda }^n+{\alpha }_{n-1}\cdot {\lambda }^{n-1}+\cdots +{\alpha }_1\cdot \lambda +{\alpha }_0=0$. Die Lösungen dieses Polynoms heißen Eigenwerte.

${\alpha }_0=\det A;{\alpha }_{n-1}=\text{Spur}A;{\alpha }_n=1$

Ein Polynom vom Grad n hat maximal n Nullstellen. D.h. es gibt auch höchstens n Eigenwerte. Die zu ${\lambda }_i$ gehörenden Vektoren $x_i\ne 0$ heißen Eigenvektoren.

Siehe auch Vorlage:W.

Ein Beispiel mit Python und SciPy:

import numpy as np
import scipy.linalg as la

A = np.array([[ 24,  54, -38,  -8],
              [-11, -27,  20,  -2],
              [  0,  -2,   3,  -6],
              [  6,  14,  -10, -1]])

w, v = la.eig(A)

# Eigenwerte
print(w)
# Eigenvektoren
print(v)

Ausgabe:

[-3.+0.j  2.+0.j  1.+0.j -1.+0.j]
[[-9.05821627e-01  4.08248290e-01 -9.25820100e-01  9.17662935e-01]
 [ 3.39683110e-01  4.08248290e-01  1.54303350e-01 -2.29415734e-01]
 [-1.13227703e-01  8.16496581e-01 -3.08606700e-01  2.29415734e-01]
 [-2.26455407e-01  1.93235474e-14 -1.54303350e-01  2.29415734e-01]]
 

Siehe auch [1]

Spektrum einer Matrix

Die Menge der Eigenwerte nennt man das Spektrum $\sigma (A)$. Der Spektralradius ist $\rho =max(|{\lambda }_i|)$.

Vielfachheiten

• Algebraische Vielfachheit: ${\kappa }_i$ (k-facher Eigenwert von $A$)

$\text{Spur}A={\kappa }_1{\lambda }_1+\dots {\kappa }_r{\gamma }_r$

$\det A={\lambda }_1^{{\kappa }_1}\dots {\lambda }_r^{{\gamma }_r}$

• Geometrische Vielfachheit: ${\gamma }_i=\text{dim Kern}(A-{\lambda }_{i}I)=n-\text{Rang}(A-{\lambda }_{i}I)$

Mehrfache Nullstellen werden entsprechend ihrer Vielfachheit gezählt.

Symmetrische Matrizen

Für reelle, symmetrische Matrizen gilt:

• Eigenwerte sind reell
• Eigenvektoren stehen senkrecht aufeinander
• geometrische und algebraische Vielfachheit stimmen bei jedem Eigenwert überein.

Seien

• p ... Anzahl der positiven Eigenwerte der symmetrischen Matrix $S$
• q ... Anzahl der negativen Eigenwerte der symmetrischen Matrix $S$
• d ... Anzahl der Eigenwerte die Null sind.

Dann sind

• (p, q) ... Signatur von $S$
• p-q ... Trägheitsindex von $S$
• d ... Defekt von $S$.

Eine symmetrische Matrix ist positiv definit, wenn alle ihre Eigenwerte > 0 sind.

Siehe auch Vorlage:W.

Diagonalisierbarkeit

Eine Matrix $A$ lässt sich diagonalisieren, wenn sie n linear unabhängige Eigenvektoren $x_1,\dots ,x_n$ aufweist.

$C=(x_1,\dots ,x_n)$

$C^{-1}AC=\text{diag}({\lambda }_1,\dots ,{\lambda }_n)$

Jordansche Normalform

Marie Ennemond Camille Jordan (französischer Mathematiker, 1838-1922)

Nicht jede Matrix ist diagonalisierbar. Aber jede quadratisch komplexe Matrix $A$ lässt sich auf die jordansche Normalform $J$ bringen.

$T^{-1}AT=J=\left(\begin{array}{ccc}{J}_1& & 0\\ & \ddots & \\ 0& & J_k\end{array}\right)$

mit $T$ regulär komplex, $J_j=\left(\begin{array}{ccccc}{\lambda }_j& 1& & & 0\\ & {\lambda }_j& 1& & \\ & & \ddots & \ddots \\ & & & {\lambda }_j& 1\\ 0& & & & {\lambda }_j\end{array}\right)\in {ℂ}^{s_j\times s_j}$

Wie man die Transformation auf die jordansche Normalform durchführt (Berechnung von $J,T$ aus gegebenen $A$), siehe z.B. Burg, Haf, Wille, Meister: Seite 237ff. Dies ist einigermaßen aufwendig. Umgekehrt ist das natürlich sehr einfach.

Shift - Verschieben von Eigenwerten

Sind ${\lambda }_i$ die Eigenwerte der nxn-Matrix $A$, so hat die Matrix $A_{ϵ}=A+ϵI$ die Eigenwerte ${\mu }_i={\lambda }_i+ϵ$. ${\lambda }_i$ und die ${\mu }_i$ haben gleiche algebraische Vielfachheit.

Hessenbergmatrix

Eine (obere) Hessenbergmatrix ist eine quadratische Matrix $H\in {ℂ}^{n\times n}$, deren Einträge unterhalb der ersten Nebendiagonalen gleich Null sind, also $h_{ij}=0$ für alle $i>j+1$.

$H=\left(\begin{array}{ccccc}{h}_{11}& h_{12}& h_{13}& \cdots & h_{1n}\\ h_{21}& h_{22}& h_{23}& \cdots & h_{2n}\\ 0& h_{32}& h_{33}& \cdots & h_{3n}\\ ⋮& \ddots & \ddots & \ddots & ⋮\\ 0& \cdots & 0& h_{nn-1}& h_{nn}\end{array}\right)$

Siehe auch Vorlage:W.

Krylov-Verfahren

Das Krylov-Verfahren eignet sich nur für kleine Matrizen ($n\le 8$) (Quelle: Burg, Haf, Wille, Meister: Seite 249). Die Matrix $A$ habe nur unterschiedliche Eigenwerte. Das Verfahren ist ziemlich instabil. Es wird deshalb in der Praxis nur selten eingesetzt.

Gegeben sei eine 4x4-Matrix $A$. Startvektor sei $z_0=[1,1,1,1]$. Funktioniert das nicht, fährt man mit $z_0=[-1,1,1,1]$ fort usw. Funktioniert das alles nicht, so lässt sich das Problem mit dem Krylov-Verfahren nicht lösen.

Python-Code (rudimentär):

import numpy as np
import scipy.linalg as la
import scipy.optimize as opt
import matplotlib.pyplot as plt

# 4x4-Matrix
A = np.array([[3, 1, -10, 5],
              [1, -7, 1, 2],
              [-10, 1, 3, -6],
              [5, 2,  -6, -1]])

n = A.shape[0]
z = np.zeros((n,n))
zn = np.zeros(n)

# Koeffizientenmatrix für lin. GS erstellen
z[:,0] = [ 1, 1, 1, 1]

for k in np.arange(1, n):
    z[:,k] = A @ z[:,k-1]

zn = A @ z[:,3]

# Löse lin. GS
x = la.solve(z, -(-1)**4 * zn)

# Polynom erstellen
p = np.poly1d([1, x[3], x[2], x[1], x[0]])

# Nullwerte ermitteln
eigenwert = np.zeros(n)

for k in np.arange(0, n):
    if k == n-1:
        i = 15
    else:
        i = -10 + k*4
    eigenwert[k] = opt.newton(p, i) 

# Konsolenausgabe
for k in np.arange(0, n):
    print(eigenwert[k])

# Grafik
x = np.arange(-12, 20, .1)
y = p(x)
x1 = np.arange(-10, 0, .1)
y1 = p(x1)

plt.plot(x, y)
for k in np.arange(0, n):
    plt.plot(eigenwert[k], 0, "o")

plt.axes([0.3, 0.5, 0.25, 0.25])
plt.plot(x1, y1)
for k in np.arange(0, n-1):
    plt.plot(eigenwert[k], 0, "o") 

plt.grid()
plt.show()

Konsolenausgabe:

-9.125090927816691
-5.8570090791499965
-3.5129666875859895
16.49506669455273

Grafik:

Das charakteristische Polynom für dieses Beispiel lautet: $\chi (x)=x^4+2x^3-199x^2-1562x-3097=0$

Jacobi-Verfahren

Dieses Verfahren eignet sich für kleine reelle symmetrische Matrizen. Es arbeitet mit Givens-Rotationen:

$A^{(0)}=A$

$R_k=\left[\begin{array}{ccccccc}1& \cdots & 0& \cdots & 0& \cdots & 0\\ ⋮& \ddots & ⋮& & ⋮& & ⋮\\ 0& \cdots & \cos \phi & \cdots & \sin \phi & \cdots & 0\\ ⋮& & ⋮& \ddots & ⋮& & ⋮\\ 0& \cdots & -\sin \phi & \cdots & \cos \phi & \cdots & 0\\ ⋮& & ⋮& & ⋮& \ddots & ⋮\\ 0& \cdots & 0& \cdots & 0& \cdots & 1\end{array}\right],$

Damit folgt wieder die symmetrische Matrix $A^{(1)}=R_k^{T}A{R}_k$. Führt man dies immer weiter durch, so ergibt sich eine Diagonalmatrix.

$A^{(k+1)}=R_k^T{A}^{(k)}{R}_k=\underset{T_k^T}{\underbrace{R_k^T{R}_{k-1}^T\dots R_0^T}}{A}^{(0)}\underset{T_k}{\underbrace{R_0\dots R_{k-1}{R}_k}}=\text{diag}({\lambda }_1,\dots ,{\lambda }_n)$

Siehe auch Vorlage:W, Burg, Haf, Wille, Meister: Seite 251ff, Hanke-Bourgeois: Seite 238ff oder [2].

Potenzmethode nach von Mises

Richard von Mises (österreichisch-US-amerikanischer Mathematiker, 1883-1953)

Sie wird auch Vektoriteration oder Von-Mises-Iteration genannt und berechnet den betragsgrößten Eigenwert. Sie eignet sich besonders für dünnbesetzte Matrizen. Das Verfahren lässt sich den Krylow-Unterraum-Verfahren zuordnen.

Python-Code:

import numpy as np

A = np.array([[3, 1, -10, 5],
              [1, -7, 1, 2],
              [-10, 1, 3, -6],
              [5, 2,  -6, -1]]) 

r = [1,1,1,1]

for k in np.arange(0,50):
    r = A@r
    lam = np.max(np.absolute(r))
    r = r/lam

print(lam)

Ausgabe:

16.495066694547337

Siehe auch Vorlage:W, Burg, Haf, Wille, Meister: Seite 254ff, Hanke-Bourgeois: Seite 218ff

Deflation

Siehe vorerst Vorlage:W und Burg, Haf, Wille, Meister: Seite 257f.

Wielandt-Iteration

Helmut Wielandt (deutscher Mathematiker, 1910-2001)

Siehe vorerst Vorlage:W und Burg, Haf, Wille, Meister: Seite 258f.

Lanczos-Verfahren

Siehe vorerst Vorlage:W und Hanke-Bourgeois: Seite 259ff

Weitere Verfahren

• QR-Verfahren basierend auf der Hessenberg-Matrix (siehe auch Vorlage:W, und Hanke-Bourgeois: Seite 227ff)
• Hyman-Verfahren

Eigenwerte und -vektoren mit SciPy

Mit SciPy und Python lassen sich die Eigenwerte und -vektoren sehr einfach berechnen. Dazu gibt es eine Reihe von SciPy-Funktionen. Nachfolgend wird die Verwendung einiger dieser Funktionen gezeigt. Siehe dazu auch die SciPy-Dokumentation [3].

Python-Code (gegeben sei eine symmetrische Matrix):

import numpy as np
from scipy import linalg

a = np.array([[3, 1, -10, 5],
              [1, -7, 1, 2],
              [-10, 1, 3, -6],
              [5, 2,  -6, -1]])

ev1 = linalg.eigvals(a)   # Eigenwerte für allgemeine Matrizen
ev2 = linalg.eigvalsh(a)  # Eigenwerte für symmetrische/hermitesche Matrizen
w, vl = linalg.eig(a)     # Eigenwerte und Eigenvektoren

print(ev1)
print("-"*75)
print(ev2)
print("-"*75)
print(w)
print("-"*75)
print(vl)

Ausgabe:

[16.49506669+0.j -9.12509093+0.j -5.85700908+0.j -3.51296669+0.j]
---------------------------------------------------------------------------
[-9.12509093 -5.85700908 -3.51296669 16.49506669]
---------------------------------------------------------------------------
[16.49506669+0.j -9.12509093+0.j -5.85700908+0.j -3.51296669+0.j]
---------------------------------------------------------------------------
[ 0.63731292  0.33339446  0.64983438 -0.24575529]
[ 0.03424931 -0.71822344  0.51243339  0.4694615 ]
[-0.65183109  0.5045163   0.48861626  0.28606588]
[ 0.40960403  0.34418968 -0.27637196  0.79835866]]

Gedruckte Werke (auszugsweise)

• Burg, Haf, Wille, Meister: Höhere Mathematik für Ingenieure, Band II: Lineare Algebra. 7. Auflage, Springer Vieweg, 2012, ISBN 978-3-8348-1853-9
• Hanke-Bourgeois: Grundlagen der Numerischen Mathematik und des Wissenschaftlichen Rechnens. 3. Aufl., Vieweg+Teubner, 2009, ISBN 978-3-8348-0708-3

Vorlage:Navigation zurückhochvor buch