def plot_kond(plotber, m_max, matr_type):
"""
Plottet die Kondition der Bandmatrizen bzw. der Hilbert-Matrix in Abhaengigkeit von der
Matrixgroesse m.
Input:
plotber (axis-Objekt):
Plotbereich, in den geplottet werden soll
m_max (int):
Maximale Matrixgroesse.
matr_type (string):
Bestimmt die Matrixart, die untersucht wird.
Moeglichkeiten: Hilbertmatrix ("hil") oder
Bandmatrix fuer d=1,2,3 ("a").
"""
# Array aus m-Werten:
m_arr = 1 + np.arange(m_max)
if matr_type == "hil":
kond_hil_arr = np.zeros(m_max)
for m_wert in m_arr:
hil_matr = Hilbert(m_wert)
kond_hil_arr[m_wert - 1] = hil_matr.kond_hil_zs()
plotber.semilogy(m_arr,
kond_hil_arr,
"o",
markerfacecolor="None",
label="$H_m$",
color="violet")
elif matr_type == "a":
for dim in [1, 2, 3]:
# Diskretisierung muss aus Matrixgroesse berechnet werden. Dabei soll
# nur n >= 3 betrachtet werden:
n_arr = np.unique((m_arr**(1 / dim) + 1).astype(int))
n_arr = n_arr[np.where(n_arr >= 3)]
# Zurueckgewinnung der passenden m-Werte und Berechnen der Kondition.
m_arr_a = (n_arr - 1)**dim
kond_a_matr = np.zeros(len(n_arr))
for ind, n_wert in enumerate(n_arr):
a_matr = Sparse(dim, n_wert)
kond_a_matr[ind] = a_matr.kond_a_d_zs()
plotber.semilogy(m_arr_a,
kond_a_matr,
"o",
markerfacecolor="None",
label=r"$A^{{({})}}$".format(dim))
else:
# Falls eine inkorrekte Eingabe fuer matr_type erfolgte:
raise ValueError(
"Bitte uebergeben Sie einen gueltigen Matrixtyp (\"hil\" " +
"fuer Hilbert-Matrizen und" + " \"a\" fuer die Bandmatrizen)!")
def plot_fehl(plotber, r_s_arr, ex_lsg_arr, matr_type, dim=1):
"""
Plottet den Fehler der numerischen Loesung im Vergleich zur exakten Loesung.
Input:
plotber (axis-Objekt):
Plotbereich, in den geplottet werden soll
r_s_arr (list oder array aus numpy.ndarrays):
Liste aus rechten Seiten.
ex_lsg_arr (list oder array aus numpy.ndarrays):
Liste aus entsprechenden exakten Loesungen.
matr_type (string):
Bestimmt die Matrixart, die untersucht wird.
Moeglichkeiten: Hilbertmatrix ("hil") oder
Bandmatrix fuer d=1,2,3 ("a").
dim (int, Standard: 1):
Wird nur fuer die Bandmatrizen benoetigt und gibt deren Dimension an.
"""
# Die Matrixgroesse ergibt sich direkt aus den Vektoren:
m_arr = np.vectorize(len)(r_s_arr)
if matr_type == "hil":
# Berechnung und Plotten des Fehlers:
fehl_hil_arr = np.zeros(len(r_s_arr))
for ind, r_s in enumerate(r_s_arr):
hil_matr = Hilbert(len(r_s))
lsg = hil_matr.lgs_lsg(r_s)
fehl_hil_arr[ind] = lina.norm(lsg - ex_lsg_arr[ind], ord=np.inf)
plotber.loglog(m_arr,
fehl_hil_arr,
"o",
markerfacecolor="None",
markersize=groess)
elif matr_type == "a":
# Berechnung und Plotten des Fehlers:
fehl_a_matr = np.zeros(len(r_s_arr))
for ind, r_s in enumerate(r_s_arr):
# Berechnung von n und des Fehlers:
n_wert = len(r_s_arr[ind])**(1 / dim) + 1
a_matr = Sparse(dim, n_wert)
lsg = a_matr.lgs_lsg(r_s)
fehl_a_matr[ind] = lina.norm(lsg - ex_lsg_arr[ind], ord=np.inf)
plotber.loglog(m_arr, fehl_a_matr, "o", markerfacecolor="None")
else:
# Falls eine inkorrekte Eingabe fuer matr_type erfolgte:
raise ValueError(
"Bitte uebergeben Sie einen gueltigen Matrixtyp (\"hil\" " +
"fuer Hilbert-Matrizen und" + " \"a\" fuer die Bandmatrizen)!")
def plot_res(plotber, r_s_arr, matr_type, dim=1):
"""
Plottet das Resiuduum.
Input:
plotber (axis-Objekt):
Plotbereich, in den geplottet werden soll
r_s_arr (list oder array aus numpy.ndarrays):
Liste aus rechten Seiten.
matr_type (string):
Bestimmt die Matrixart, die untersucht wird.
Moeglichkeiten: Hilbertmatrix ("hil") oder
Bandmatrix fuer d=1,2,3 ("a").
dim (int, Standard: 1):
Wird nur fuer die Bandmatrizen benoetigt und gibt deren Dimension an.
"""
# Matrixgroesse ergibt sich direkt aus den Vektoren:
m_arr = np.vectorize(len)(r_s_arr)
if matr_type == "hil":
# Berechnung und Plotten des Residuums:
res_hil_arr = np.zeros(len(r_s_arr))
for ind, r_s in enumerate(r_s_arr):
hil_matr = Hilbert(len(r_s))
matr = hil_matr.return_hil_matr()
lsg = hil_matr.lgs_lsg(r_s)
res_hil_arr[ind] = lina.norm(matr * lsg - r_s, ord=np.inf)
plotber.loglog(m_arr, res_hil_arr, "o", markerfacecolor="None")
elif matr_type == "a":
# Berechnung und Plotten des Residuums:
res_a_matr = np.zeros(len(r_s_arr))
for ind, r_s in enumerate(r_s_arr):
n_wert = len(r_s_arr[ind])**(1 / dim) + 1
a_matr = Sparse(dim, n_wert)
lsg = a_matr.lgs_lsg(r_s)
matr = a_matr.return_mat_d_csc()
res_a_matr[ind] = lina.norm(matr * lsg - r_s, ord=np.inf)
plotber.loglog(m_arr, res_a_matr, "o", markerfacecolor="None")
else:
# Falls eine inkorrekte Eingabe fuer matr_type erfolgte:
raise ValueError(
"Bitte uebergeben Sie einen gueltigen Matrixtyp (\"hil\" " +
"fuer Hilbert-Matrizen und" + " \"a\" fuer die Bandmatrizen)!")
def plot_nn(plotber, m_max):
"""
Plottet die (absolute) Anzahl der Nichtnulleintraege der Koeffizientenmatrix A^(d)
Input:
plotber (axis-Objekt):
Plotbereich, in den geplottet werden soll
m_max (int):
Maximale Matrixgroesse.
"""
m_arr = 1 + np.arange(m_max)
colors = ["r", "g", "b"]
for dim in [1, 2, 3]:
# Berechnung von n wie in der vorherigen Funktion:
n_arr = np.unique((m_arr**(1 / dim) + 1).astype(int))
n_arr = n_arr[np.where(n_arr >= 3)]
m_arr_a = (n_arr - 1)**dim
nn_a_matr = np.zeros(len(n_arr))
nn_a_matr_lu = np.zeros(len(n_arr))
for ind, n_wert in enumerate(n_arr):
a_matr = Sparse(dim, n_wert)
nn_a_matr[ind] = a_matr.anz_nn_abs()
nn_a_matr_lu[ind] = np.sum(a_matr.anz_nn_lu_abs())
# Doppelt-logarithmischer Plot:
plotber.loglog(m_arr_a,
nn_a_matr,
"o",
markerfacecolor="None",
label=r"Koeffizientenmatrix $A^{{({})}}$".format(dim),
color=colors[dim - 1])
plotber.loglog(m_arr_a,
nn_a_matr_lu,
"^",
markerfacecolor="None",
label=r"Dreieckszerlegung von $A^{{({})}}$".format(dim),
color=colors[dim - 1])
def loesg(numb, dims, fkt, ulsg=fntn):
"""
Diese Methode dient zur Lösung der Differentialgleichung und zum Vergleichen der exakten
und approximierten Lösungen.
Input:
numb (int):
Feinheit der Diskretisierung.
dims (int):
Dimension der Diskretisierung.
fkt (Funktion):
Die gegebene Funktion f aus der Aufgabestellung.
ulsg (Funktion):
Die exakte Lösung der Differentialgleichung.
Return:
(float):
Der absolute Fehler in der approximierten Lösung der Differentialgleichung.
"""
# Erstellung des Vektors b
arra = gitter(numb, dims)
arrb = np.zeros((numb - 1)**dims)
for i in range((numb - 1)**dims):
arrb[i] = fkt(arra[i]) / (numb**2)
# Erstellung und Lösen der Bandmatrix
mata = Sparse(dims, numb)
lsg = mata.lgs_lsg(arrb)
# Erstellung des Vektors der exakten Lösung
arrex = np.zeros((numb - 1)**dims)
for i in range((numb - 1)**dims):
arrex[i] = ulsg(arra[i])
# Erstellung des Vektors des Fehlers in der berechneten Lösung
arrf = np.zeros((numb - 1)**dims)
for i in range((numb - 1)**dims):
arrf[i] = np.abs(arrex[i] - lsg[i])
# Graphische Ausgabe:
if dims == 2:
# Plot der berechneten Lösung
plot_disc_fct(
lsg, numb,
"Berechnete Lösung mit Feinheit der Diskretisierung " + str(numb))
# Plot der Referenzlösung
grd1 = np.linspace(0, 1, 1000)
grd2 = np.linspace(0, 1, 1000)
grd1, grd2 = np.meshgrid(grd1, grd2)
arra2 = gitter(1001, 2)
arrex2 = np.zeros(1000000)
for i in range(1000000):
arrex2[i] = ulsg(arra2[i])
grd3 = arrex2.reshape(1000, 1000)
fig = plt.figure()
fig.suptitle("Die Referenzlösung")
axis = Axes3D(fig)
axis.plot_surface(grd1, grd2, grd3, cmap=cm.coolwarm)
axis.view_init(20, -105)
# Plot des Fehlers
plot_disc_fct(
arrf, numb, "Fehler bezüglich der Referenzlösung mit" +
" Feinheit der Diskretisierung " + str(numb))
print("Der maximale Fehler ist " + str(np.amax(arrf)))
plt.show()
def loesg(dims, fkt, ulsg):
"""
Diese Methode dient zur Lösung der Differentialgleichung und zum Vergleichen der exakten
und approxmierten Lösungen.
Input:
dims (int):
Dimension der Diskretisierung
fkt (Funktion):
Die gegebene Funktion f aus der Aufgabestellung
ulsg (Funktion):
Die exakte Lösung der Differentialgleichung
Return:
(float):
Der absolute Fehler in der approximierten Lösung der Differentialgleichung
"""
#Plotten von dem Konvergenzverfahren, Dimension 1
if dims == 1:
arrn = np.arange(4, 1004, 20)
arrfa = np.zeros(len(arrn))
refe = 0
for k in arrn:
#Erstellung des Vektors b
arra = gitter(k, dims)
arrb = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrb[i] = fkt(arra[i])/(k**2)
#Erstellung und Lösen der Bandmatrix
mata = Sparse(dims, k)
lsg = mata.lgs_lsg(arrb)
#Erstellung des Vektors der exakten Lösung
arrex = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Lösung
arrf = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrf[i] = np.abs(arrex[i]-lsg[i])
arrfa[refe] = np.amax(arrf)
refe = refe + 1
plt.plot(arrn, arrfa)
plt.title("Konvergenzverhalten der numerischen Loesung in Dimension 1")
plt.xlabel("Feinheit der Diskretisierung")
plt.ylabel("Absoluter Fehler")
#Plotten von dem Konvergenzverfahren, Dimension 2
if dims == 2:
arrn = np.arange(5, 95, 5)
arrfa = np.zeros(len(arrn))
refe = 0
for k in arrn:
#Erstellung des Vektors b
arra = gitter(k, dims)
arrb = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrb[i] = fkt(arra[i])/(k**2)
#Erstellung und Lösen der Bandmatrix
mata = Sparse(dims, k)
lsg = mata.lgs_lsg(arrb)
#Erstellung des Vektors der exakten Lösung
arrex = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Lösung
arrf = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrf[i] = np.abs(arrex[i]-lsg[i])
arrfa[refe] = np.amax(arrf)
refe = refe + 1
plt.plot(arrn, arrfa)
plt.title("Konvergenzverhalten der numerischen Loesung in Dimension 2")
plt.xlabel("Feinheit der Diskretisierung")
plt.ylabel("Absoluter Fehler")
#Plotten von dem Konvergenzverfahren, Dimension 3
if dims == 3:
arrn = np.arange(3, 23, 2)
arrfa = np.zeros(len(arrn))
refe = 0
for k in arrn:
#Erstellung des Vektors b
arra = gitter(k, dims)
arrb = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrb[i] = fkt(arra[i])/(k**2)
#Erstellung und Lösen der Bandmatrix
mata = Sparse(dims, k)
lsg = mata.lgs_lsg(arrb)
#Erstellung des Vektors der exakten Lösung
arrex = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Lösung
arrf = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrf[i] = np.abs(arrex[i]-lsg[i])
arrfa[refe] = np.amax(arrf)
refe = refe + 1
plt.plot(arrn, arrfa)
plt.title("Konvergenzverhalten der numerischen Loesung in Dimension 3")
plt.xlabel("Feinheit der Diskretisierung")
plt.ylabel("Absoluter Fehler")
#Grafische Ausgabe
if dims == 2:
for k in [7, 27]:
#Erstellung des Vektors b
arra = gitter(k, dims)
arrb = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrb[i] = fkt(arra[i])/(k**2)
#Erstellung und Lösen der Bandmatrix
mata = Sparse(dims, k)
lsg = mata.lgs_lsg(arrb)
#Erstellung des Vektors der exakten Lösung
arrex = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Lösung
arrf = np.zeros((k-1)**dims)
for i in range((k-1)**dims):
arrf[i] = np.abs(arrex[i]-lsg[i])
#Plot der berechneten Lösung
plot_disc_fct(lsg, k, "Berechnete Loesung mit Feinheit der Diskretisierung "+str(k))
#Plot des Fehlers
plot_disc_fct(arrf, k, "Fehler bezueglich der Referenzloesung mit"
+" Feinheit der Diskretisierung "+str(k))
#Plot der Referenzlösung
grd1 = np.linspace(0, 1, 1000)
grd2 = np.linspace(0, 1, 1000)
grd1, grd2 = np.meshgrid(grd1, grd2)
arra2 = gitter(1001, 2)
arrex2 = np.zeros(1000000)
for i in range(1000000):
arrex2[i] = ulsg(arra2[i])
grd3 = arrex2.reshape(1000, 1000)
fig = plt.figure()
fig.suptitle("Die Referenzloesung")
axis = Axes3D(fig)
axis.plot_surface(grd1, grd2, grd3, cmap=cm.coolwarm)
axis.view_init(20, -105)
plt.show()
return np.amax(arrf)
def loesg(dims, numb, fkt, ulsg):
"""
Diese Methode dient zur Loesung der Differentialgleichung und zum Vergleichen der exakten
und approxmierten Loesungen.
Input:
dims (int):
Dimension der Diskretisierung
numb (int):
Feinheit der DiskretisierungS
fkt (Funktion):
Die gegebene Funktion f aus der Aufgabestellung
ulsg (Funktion):
Die exakte Loesung der Differentialgleichung
Return:
(float):
Der absolute Fehler in der approximierten Loesung der Differentialgleichung
"""
#Grafik des Fehlers bezueglich des Iterationsschritts
#CG Methode Loesung, Dimension 1
los0 = 0.001 * np.ones((numb - 1)**dims)
#Erstellung des Vektors b
arra = gitter(numb, dims)
arrb = np.zeros((numb - 1)**dims)
for i in range((numb - 1)**dims):
arrb[i] = fkt(arra[i]) / (numb**2)
#Erstellung und Loesen der Bandmatrix durch die CG-Methode
eps = 10**-14
mata = Sparse(dims, numb)
los = mata.cg_meth(los0, arrb, eps)
laeng = len(los)
#Erstellung des Vektors der exakten Loesung
arrex = np.zeros((numb - 1)**dims)
for i in range((numb - 1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Loesung mit C-G-Verfahren
maxfeh = np.zeros(laeng)
for k in range(laeng):
arrf = np.zeros((numb - 1)**dims)
for i in range((numb - 1)**dims):
arrf[i] = np.abs(arrex[i] - los[k][i])
maxfeh[k] = np.amax(arrf)
if k == laeng - 1:
print(np.amax(arrf))
plt.semilogy(range(laeng), maxfeh)
plt.title(
"Konvergenzverhalten der Loesung mit der CG-Methode in Dimension " +
str(dims) + " mit Feinheit der Diskretisierung " + str(numb) +
" und mit Schranke " + str(eps))
plt.xlabel("Iterationsschritt")
plt.ylabel("Absoluter Fehler")
#plt.savefig("./Bericht/Bilder/IterDim"+str(dims), dpi=300)
plt.show()
#Erstellung und Loesen der Bandmatrix durch die L-U-Zerlegung
mata = Sparse(dims, numb)
lsg_lu = mata.lgs_lsg(arrb)
#Erstellung des Vektors des Fehlers in der berechneten Loesung mit L-U-Zerlegung
arrf = np.zeros((numb - 1)**dims)
for i in range((numb - 1)**dims):
arrf[i] = np.abs(arrex[i] - lsg_lu[i])
print(np.amax(arrf))
#Grafik des Fehlers bezueglich Epsilon
fehl = np.zeros(5)
ind = 0
for k in [-2, 0, 2, 4, 6]:
eps = numb**(-k)
los0 = 0.001 * np.ones((numb - 1)**dims)
mata = Sparse(dims, numb)
los = mata.cg_meth(los0, arrb, eps)
laeng = len(los)
lsg = los[laeng - 1]
arrf = np.zeros((numb - 1)**dims)
for i in range((numb - 1)**dims):
arrf[i] = np.abs(arrex[i] - lsg[i])
fehl[ind] = np.amax(arrf)
ind = ind + 1
plt.loglog([numb**2, 1, numb**-2, numb**-4, numb**-6], fehl)
plt.title(
"Konvergenzverhalten der numerischen Loesung mit der CG-Methode in Dimension "
+ str(dims) + " und Feinheit der Diskretisierung " + str(numb))
plt.xlabel("Schranke (abhaengig von der Feinheit der Diskretisierung)")
plt.ylabel("Absoluter Fehler")
plt.show()
#Grafik des Fehlers bezüglch der Fehlerschranke
eps = np.logspace(-15, 1, 30)
los0 = 0.001 * np.ones((numb - 1)**dims)
graf = np.zeros(30)
abbr = 0
for i in eps:
mata = Sparse(dims, numb)
los = mata.cg_meth(los0, arrb, i)
laeng = len(los)
arrf = np.zeros((numb - 1)**dims)
for k in range((numb - 1)**dims):
arrf[k] = np.abs(arrex[k] - los[laeng - 1][k])
graf[abbr] = np.amax(arrf)
abbr = abbr + 1
plt.loglog(eps, graf)
plt.title(
"Konvergenzverhalten der numerischen Loesung mit der CG-Methode in Dimension "
+ str(dims) + " und Feinheit der Diskretisierung " + str(numb))
plt.xlabel("Schranke")
plt.ylabel("Absoluter Fehler")
plt.show()
#Grafik des Fehlers bezüglich der Feinheit der Disretisierung
if dims == 1:
arrn = np.arange(4, 1004, 40)
arrfa = np.zeros(len(arrn))
refe = 0
for k in arrn:
#Erstellung des Vektors b
arra = gitter(k, dims)
arrb = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrb[i] = fkt(arra[i]) / (k**2)
#Erstellung und Loesen der Bandmatrix mit C-G-Verfahren
los0 = 0.001 * np.ones((k - 1)**dims)
eps = 10**-14
mata = Sparse(dims, k)
los = mata.cg_meth(los0, arrb, eps)
laeng = len(los)
lsg = los[laeng - 1]
#Erstellung des Vektors der exakten Loesung
arrex = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Loesung
arrf = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrf[i] = np.abs(arrex[i] - lsg[i])
arrfa[refe] = np.amax(arrf)
refe = refe + 1
plt.semilogy(arrn, arrfa, 'b', label="Mit C-G-Verfahren")
if dims == 2:
arrn = np.arange(5, 95, 10)
arrfa = np.zeros(len(arrn))
refe = 0
for k in arrn:
#Erstellung des Vektors b
arra = gitter(k, dims)
arrb = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrb[i] = fkt(arra[i]) / (k**2)
#Erstellung und Lösen der Bandmatrix mit C-G-Verfahren
los0 = 0.001 * np.ones((k - 1)**dims)
eps = 10**-14
mata = Sparse(dims, k)
los = mata.cg_meth(los0, arrb, eps)
laeng = len(los)
lsg = los[laeng - 1]
#Erstellung des Vektors der exakten Lösung
arrex = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Lösung
arrf = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrf[i] = np.abs(arrex[i] - lsg[i])
arrfa[refe] = np.amax(arrf)
refe = refe + 1
plt.semilogy(arrn, arrfa, 'b', label="Mit C-G-Verfahren")
if dims == 3:
arrn = np.arange(3, 23, 4)
arrfa = np.zeros(len(arrn))
refe = 0
for k in arrn:
#Erstellung des Vektors b
arra = gitter(k, dims)
arrb = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrb[i] = fkt(arra[i]) / (k**2)
#Erstellung und Lösen der Bandmatrix mit C-G-Verfahren
los0 = 0.001 * np.ones((k - 1)**dims)
eps = 10**-14
mata = Sparse(dims, k)
los = mata.cg_meth(los0, arrb, eps)
laeng = len(los)
lsg = los[laeng - 1]
#Erstellung des Vektors der exakten Lösung
arrex = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Lösung
arrf = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrf[i] = np.abs(arrex[i] - lsg[i])
arrfa[refe] = np.amax(arrf)
refe = refe + 1
plt.semilogy(arrn, arrfa, 'b', label="Mit C-G-Verfahren")
#Plotten von dem Konvergenzverfahren, Dimension 1
if dims == 1:
arrn = np.arange(4, 1004, 20)
arrfa = np.zeros(len(arrn))
refe = 0
for k in arrn:
#Erstellung des Vektors b
arra = gitter(k, dims)
arrb = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrb[i] = fkt(arra[i]) / (k**2)
#Erstellung und Loesen der Bandmatrix
mata = Sparse(dims, k)
lsg = mata.lgs_lsg(arrb)
#Erstellung des Vektors der exakten Loesung
arrex = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Loesung
arrf = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrf[i] = np.abs(arrex[i] - lsg[i])
arrfa[refe] = np.amax(arrf)
refe = refe + 1
plt.semilogy(arrn, arrfa, 'r', label="Mit L-U-Zerlegung")
plt.title("Konvergenzverhalten in Dimension 1")
plt.xlabel("Feinheit der Diskretisierung")
plt.ylabel("Absoluter Fehler")
#Plotten von dem Konvergenzverfahren, Dimension 2
if dims == 2:
arrn = np.arange(5, 95, 5)
arrfa = np.zeros(len(arrn))
refe = 0
for k in arrn:
#Erstellung des Vektors b
arra = gitter(k, dims)
arrb = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrb[i] = fkt(arra[i]) / (k**2)
#Erstellung und Loesen der Bandmatrix
mata = Sparse(dims, k)
lsg = mata.lgs_lsg(arrb)
#Erstellung des Vektors der exakten Loesung
arrex = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Loesung
arrf = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrf[i] = np.abs(arrex[i] - lsg[i])
arrfa[refe] = np.amax(arrf)
refe = refe + 1
plt.plot(arrn, arrfa, 'r', label="Mit L-U-Zerlegung")
plt.title("Konvergenzverhalten in Dimension 2")
plt.xlabel("Feinheit der Diskretisierung")
plt.ylabel("Absoluter Fehler")
#Plotten von dem Konvergenzverfahren, Dimension 3
if dims == 3:
arrn = np.arange(3, 23, 2)
arrfa = np.zeros(len(arrn))
refe = 0
for k in arrn:
#Erstellung des Vektors b
arra = gitter(k, dims)
arrb = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrb[i] = fkt(arra[i]) / (k**2)
#Erstellung und Loesen der Bandmatrix
mata = Sparse(dims, k)
lsg = mata.lgs_lsg(arrb)
#Erstellung des Vektors der exakten Loesung
arrex = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrex[i] = ulsg(arra[i])
#Erstellung des Vektors des Fehlers in der berechneten Loesung
arrf = np.zeros((k - 1)**dims)
for i in range((k - 1)**dims):
arrf[i] = np.abs(arrex[i] - lsg[i])
arrfa[refe] = np.amax(arrf)
refe = refe + 1
plt.plot(arrn, arrfa, 'r', label="Mit L-U-Zerlegung")
plt.title("Konvergenzverhalten in Dimension 3")
plt.xlabel("Feinheit der Diskretisierung")
plt.ylabel("Absoluter Fehler")
plt.legend()
plt.show()
return np.amax(arrf)