Lösungsskizzen zum Buch Mathematik für Informatiker Kapitel 8 Peter Hartmann

Transkript

1 1. Bestimmen Sie jeweils den Rang der folgenden Matrizen: ,,, Die Ränge der Matrizen sind der Reihe nach:, 2,, Bestimmen Sie die Inversen der folgenden Matrizen, falls sie existieren: , 6 0 2, A -1 = 1/2 1/2 0 2/ , B -1 existiert nicht (Rang B = 2), C -1 = 1/10 1/2 0 1/2 /2 0 /10 1/6 1/. Welche Unterräume des R werden durch die Lösungen der folgenden linearen homogenen Gleichungssysteme bestimmt? a) 2x1 2x2 + x x1+ x2 + x c) x1+ x 2x1 2x2 + x b) 2x1+ x2 + 2x x + x 2 Es sei jeweil A die zugehörige Koeffizientenmatrix uns L der Lösungsraum. Dann gilt: a) Rang A = 1 dim L = 2. Eine Basis ist zum Beispiel (0,0,1), (1,1,0). b) Rang A = 2 dim L = 1. Die Umwandlung mit dem Gauß'schen Algorithmus liefert die 1 0,5 Matrix: und damit als Basisvektor zum Beispiel (,5, 0, 1). 0 1 c) Rang A = 2, dim L = 1. Ein Basisvektor ist zum Beispiel (1,0, 1). 4. Stellen Sie fest, ob das folgende lineare Gleichungssystem lösbar ist und bestimmen Sie gegebenenfalls die Lösungsmenge: x 1 + 2x 2 + x = 1 4x 1 + 5x 2 + 6x = 2 7x 1 + 8x 2 + 9x = 5x 1 + 7x 2 + 9x = 4 1

2 / Das System hat keine Lösung, da der Gauß'sche Algorithmus liefert:, d.h Rang (A,b) > Rang A. 5. Lösen Sie das folgende lineare Gleichungssystem: 2x 1 + x 2 + x = a 1 5x 1 + 4x 2 5x = a 2 x 1 + 2x 2 x = a wobei einmal a 1 = 5, a 2 = 1, a =, und einmal a 1 = 1, a 2 = 1, a = 1 zu wählen sind. 1 1/2 1/2 5/2 1 1/2 1/2 1/2 Der Gauß'sche Algorithmus ergibt , bzw /. Damit existiert im zweiten Fall keine Lösung, im ersten Fall lautet die Gauß-Jordan-Form: , woraus sich als Lösung für das homogene System ergibt: { λ 5 λ R. Eine spezielle Lösung lautet Schreiben Sie ein Programm zur Lösung linearer Gleichungssysteme. Dabei soll der Gauß'sche Algorithmus rekursiv implementiert werden und Zeilenpivotsuche durchgeführt werden. Am Ende finden Sie eine Implementierung in C++: 7. Welche Ordnung hat der Gauß'sche Algorithmus, wenn Sie die folgende "tridiagonale" Matrix in Gauß-Jordan-Form bringen? a11 a a21 a22 a a2 a a a4 a44 a a a a ann, 1 ann n 1, n 2 n 1, n 1 n 1, n 2

3 Besser sollte die Aufgabe so lauten: Bestimmen Sie die Ordnung für die Lösung des folgenden Gleichungssystems: a11 a x1 b1 a21 a22 a x2 b2 0 a2 a a4 0 0 x b 0 0 a4 a44 a45 = a a a n 1, n 2 n 1, n 1 n 1, n ann, 1 a nn x n b n Zusätzlich sollte man z.b. voraussetzen dass die Matrix "spaltendiagonaldominant" ist, das heißt, dass für alle i gilt aii > ai 1, i + ai+ 1, i. Dann kann man nämlich die folgenden Umformungen vornehmen, ohne dass irgendwann die 0 im Nenner auftritt (warum?). Beginnen Sie mit der zweiten Zeile und ziehen Sie für k = 2 bis k = n jeweils von der k-ten akk, 1 Zeile das fache der (k 1)-ten Zeile ab. Danach hat die erweiterte Matrix die ak 1, k 1 Form: a11 a b1 0 a22 a b a a4 0 0 b a an 1, n 1 an 1, n ann b n Dabei wurden n 1 elementare Zeilenoperationen durchgeführt. In der zweiten Runde müssen ak 1, k Sie k = n bis k = 2 von der (k 1)-ten Zeile das fache der k-ten Zeile abziehen. Das a Ergebnis ist die Gauß-Jordan Form. Eine elementare Zeilenoperation besteht in dieser einfachen Matrix aus höchstens 1 Division, Multiplikationen und Subtraktionen, hat also konstante Laufzeit. 2(n 1) solche Operationen ergeben eine lineare Laufzeit: die Ordnung des Algorithmus ist n. kk,

4 Implementierung des Gauß'schen Algorithmus #include <iostream> using namespace std; class Gauss{ public: Gauss(); // Konstruktor, liest m,n,a ein void zeilenstufenform(); // Zeilenstufenform aus Matrix A void gaussjordan(); // Gauss-Jordan Form void ausgabe(); // Matrix am Bildschirm ausgeben private: void vertausche(int i, int k); // vertausche Zeilen i und j void addiere (double la, int i,int j); // addiere la*zeile i zu Zeile j void multipliziere(double la, int i); // multipliziere Ziele i mit la void zst_rek(int i,int j); // rekursive Implementierung int pivotsuche(int i, int j); // sucht Pivotelement A(piv,j) unter A(i,j) double A[100][100]; // die Matrix int n; // Zeilenzahl int m; // Spaltenzahl ; void Gauss::zeilenstufenform(){ int i, j ; zst_rek(i,j); void Gauss::zst_rek(int i,int j){ if(i == n-1 j >= m) // vergleiche Seite 145 im Buch // Abbruchbedingung int piv = pivotsuche(i,j); // suche Pivotelement unterhalb des Element i,j if (A[piv][j] =){ // kein Pivotelement! gefunden zst_rek(i,j+1); // gleiche Zeile, nächste Spalte vertausche(i,piv); // vertausche Zeile i mit Zeile piv for(int ii = i+1; ii < n ; ++ii) addiere(-a[ii][j]/a[i][j],i,ii); // mache j. Spalte unter i.ter Zeile zu 0 zst_rek(i+1,j+1); // nächste Zeile, nächste Spalte Gauss::Gauss(){ cout << "Anzahl Zeilen: "; cin >> n; cout << "Anzahl Spalten: "; cin >> m; for(int i ; i < n; ++i){ cout << " Zeile " << i+1 << ": "; for(int j ; j < m; ++j) cin >> A[i][j]; void Gauss::vertausche(int i, int j){ for(int k ; k < m; ++k){ // vertausche Zeilen i und j. double temp = A[i][k]; A[i][k] = A[j][k]; A[j][k] = temp; 4

5 void Gauss::addiere (double la, int i, int j){ for(int k ; k < m; ++k){ // la-faches der Zeile i zur Zeile j. A[j][k] += A[i][k]*la; if(fabs(a[j][k]) < 1E-10) A[j][k] ; void Gauss::multipliziere(double la, int i){ for(int k ; k < m; ++k) // Zeile i mal la. A[i][k] *= la; int Gauss::pivotsuche(int i, int j){ int piv = i; for(int k = i; k < n; k++) if(fabs(a[k][j]) > A[piv][j]) piv = k; return piv; // damit werden in dieser Spielimplementierung // Rundungsfehler vermieden void Gauss::gaussjordan(){ for(int i = n-1; i >; --i){ // suche Leitkoeffizient der i.ten Zeile int j ; // beginne mit der letzten Zeile while(a[i][j] = && j < m) // suche Spalte mit Leitkoeffizienten j++; if (j < m && A[i][j]!){ // Leitkoeffizient vorhanden in Spalte j multipliziere(1/a[i][j],i);// normiere Leitkoeffizient auf 1 for(int ii ; ii < i; ii++){ addiere(-a[ii][j],i,ii); // mache j. Spalte über i.ter Zeile zu 0 void Gauss::ausgabe(){ for (int i ; i < n; ++i) { cout << endl; for (int j ; j < m; ++j) cout << A[i][j] << '\t'; cout << endl; main(){ Gauss matrix; matrix.zeilenstufenform(); matrix.gaussjordan(); 5