Blatt 3 Aufgabe 2b) QR Zerlegung

Bachelor Algorithmik kontinuierlicher Systeme
1

Probleme mit Floating Point Arithmetik

Disclaimer: Dieser Thread wurde aus dem alten Forum importiert. Daher werden eventuell nicht alle Formatierungen richtig angezeigt. Der ursprüngliche Thread beginnt im zweiten Post dieses Threads.

2

Blatt 3 Aufgabe 2b) QR Zerlegung
Für meine Implementierung der 2b) bekomm ich folgende Ergebnisse raus:

=====================================
 Aufgabe 2b: QR-Zerlegung (2 Punkte)
=====================================
Der Aufruf qr_decompose
(array([[3.],
       [4.]])) liefert das Ergebnis
(array([[ 0.6,  0.8],
       [-0.8,  0.6]]),
 array([[ 5.0000000e+00],
       [-4.4408921e-16]])), richtig wäre aber
(array([[ 0.6, -0.8],
       [ 0.8,  0.6]]), array([[5.],
       [0.]])).
Der Aufruf qr_decompose
(array([[3., 1.],
       [4., 0.]])) liefert das Ergebnis
(array([[ 0.6,  0.8],
       [-0.8,  0.6]]),
 array([[ 5.0000000e+00,  6.0000000e-01],
       [-4.4408921e-16, -8.0000000e-01]])), richtig wäre aber
(array([[ 0.6, -0.8],
       [ 0.8,  0.6]]),
 array([[ 5. ,  0.6],
       [ 0. , -0.8]])).
Der Aufruf qr_decompose
(array([[3., 1.],
       [4., 0.]])) liefert das Ergebnis
(array([[ 0.6,  0.8],
       [-0.8,  0.6]]),
 array([[ 5.0000000e+00,  6.0000000e-01],
       [-4.4408921e-16, -8.0000000e-01]])), richtig wäre aber
(array([[ 0.6, -0.8],
       [ 0.8,  0.6]]),
 array([[ 5. ,  0.6],
       [ 0. , -0.8]])).
Der Aufruf qr_decompose
(array([[ 1.,  1.,  1.,  1.],
       [ 1.,  2.,  3.,  4.],
       [ 1.,  3.,  6., 10.],
       [ 1.,  4., 10., 20.]])) liefert das Ergebnis
(array([[ 0.5       ,  0.5       ,  0.5       ,  0.5       ],
       [-0.67082039, -0.2236068 ,  0.2236068 ,  0.67082039],
       [ 0.5       , -0.5       , -0.5       ,  0.5       ],
       [-0.2236068 ,  0.67082039, -0.67082039,  0.2236068 ]]),
 array([[ 2.00000000e+00,  5.00000000e+00,  1.00000000e+01,
         1.75000000e+01],
       [ 0.00000000e+00,  2.23606798e+00,  6.70820393e+00,
         1.40872283e+01],
       [ 0.00000000e+00, -8.96409458e-17,  1.00000000e+00,
         3.50000000e+00],
       [ 0.00000000e+00, -4.00886497e-17, -5.55111512e-17,
         2.23606798e-01]])), richtig wäre aber
(array([[ 0.5       , -0.67082039,  0.5       , -0.2236068 ],
       [ 0.5       , -0.2236068 , -0.5       ,  0.67082039],
       [ 0.5       ,  0.2236068 , -0.5       , -0.67082039],
       [ 0.5       ,  0.67082039,  0.5       ,  0.2236068 ]]),
 array([[ 2.        ,  5.        , 10.        , 17.5       ],
       [ 0.        ,  2.23606798,  6.70820393, 14.0872283 ],
       [ 0.        ,  0.        ,  1.        ,  3.5       ],
       [ 0.        ,  0.        ,  0.        ,  0.2236068 ]])).
Der Aufruf qr_decompose
(array([[9., 8., 0.],
       [8., 7., 6.],
       [5., 4., 3.],
       [2., 1., 0.]])) liefert das Ergebnis
(array([[ 6.82288239e-01,  6.06478435e-01,  3.79049022e-01,
         1.51619609e-01],
       [-2.90659179e-01, -1.24568220e-01,  3.73704659e-01,
         8.71977538e-01],
       [ 6.70820393e-01, -6.70820393e-01, -2.23606798e-01,
         2.23606798e-01],
       [ 8.32667268e-17,  4.08248290e-01, -8.16496581e-01,
         4.08248290e-01]]),
 array([[ 1.31909060e+01,  1.13714707e+01,  4.77601767e+00],
       [ 1.15542684e-16, -8.30454799e-01,  3.73704659e-01],
       [ 7.39949228e-16,  1.13305234e-17, -4.69574275e+00],
       [-6.52074505e-16,  2.06866108e-17, -2.22044605e-16]])), richtig wäre
aber
(array([[ 0.68228824, -0.29065918,  0.67082039,  0.        ],
       [ 0.60647843, -0.12456822, -0.67082039,  0.40824829],
       [ 0.37904902,  0.37370466, -0.2236068 , -0.81649658],
       [ 0.15161961,  0.87197754,  0.2236068 ,  0.40824829]]),
 array([[13.190906  , 11.3714707 ,  4.77601767],
       [ 0.        , -0.8304548 ,  0.37370466],
       [ 0.        ,  0.        , -4.69574275],
       [ 0.        ,  0.        ,  0.        ]])).
Diese Teilaufgabe enthält Fehler!

Da bei einigen Werten, die 0 sein sollten, die 16te Nachkommastelle ungleich 0 ist (wenn die 16te Nachkommastelle 0 wäre, würde mir das Programm 0. ausprinten, wenn ich es richtig verstanden habe), schließe ich daraus, dass entweder bei der Berechnung der Rotationsmatrizen (wobei keine Fehler bei den Testcases für die 2a) rauskommen) oder beim Rotieren der R Matrix etwas kaputt geht.
Die einzelnen Einträge zu floats zu casten brachte nichts und runden (falls wir das überhaupt runden dürfen) bringt natürlich auch nichts (da kommen Werte wie -0. raus). Jetzt weiß nicht, wie ich das in den Griff kriege.
Selbes Problem habe ich auch bei der LR - Zerlegungsaufgabe.
Oder liegt es vielleicht doch an etwas anderem?

3

Wenn du leere Matrizen anlegen willst, benutzt du da zufälligerweise np.empty?
np.empty legt dir nur den Speicher an, setzt die Werte jedoch nicht auf 0.

Grüße,
Michael

4

Hallo

ich hatte den selben Fehler.

Bei dir fällt mir erstmal auf, dass du dein Q noch transponieren musst.

Der Fehler war bei mir das ich die Jij mit der original Matrix A berechnet haben und habe quasi die Ergebnisse in ein separates R gespeichert.
Man muss allerdings gleich A mit verändern, bevor man das nächste J berechnet.

Vielleicht hängt es ja bei dir genau daran.

5

Es lag an der fehlenden Transposition :smiley:
Danke !