Unterbestimmte Glgsysteme < Matlab < Mathe-Software < Mathe < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 09:32 Di 26.02.2008 | | Autor: | Imbecile |
| Aufgabe | | Implementiere die Lösung unterbestimmter linearer Gleichungssysteme in Octave, ohne eingebaute Routinen zur Lösung von Gleichungssystemen, Inversion von Matrizen etc. zu verwenden. Es kann aber angenommen werden, daß die Matrix vollen Zeilenrang hat. Teste die Implementierung anhand einiger Beispiele. |
Hallo!
Ich habe leider ein paar anfangsschwierigkeiten mit der Aufgabe.
Also ich weiß ich bringe das system als erstes auf Zeilenstufenform.
Ich habe auch schon etwas geschrieben, allerding nimmt mir mein Matlab die Schleifen nicht richtig.
Also mein erster Versuch für die Zeilenstufenform ist:
[m,n]=size(A);
z=n-1;
y=1;
for j=1:z;
for i=(j+1):m;
if A(i,j)~=0;
i=i+1;
y=y+1;
else A(i,1:n)=A(i,1:n)-A(y,1:n)*(A(i,j)/A(y,y));
i=i+1;
y=y+1;
end;
end;
j=j+1;
end;
A
Das Problem ist, er gibt mir keine Fehlermeldung, er macht aber auch nichts.
wenn ich es anders probier rechnet er mir zwar irgendwas, ignoriert mir aber das else, und macht den durchlauf nur einmal, das heißt er geht nicht zu den anderen Spalten.
Hat jemand eine Idee wie ich es anders machen könnte?
Auf jeden Fall schon mal Danke!
Lg,
Conny
|
|
| |
|
Hallo,
ich fange mal mit deinen Fehlern an:
Die Zeilenersetzung muss in dem Nicht-Null-Fall stattfinden, also, wenn die if-Bedingung erfüllt ist.
Den Parameter y brauchst du gar nicht. Er sollte immer mit j identisch sein, weil ja beide die aktuelle Spalte bezeichnen.
Außerdem werden die for-Schleifenparameter automatisch hochgezählt, das muss/darf man nicht zusätzlich selbst machen.
Den Parameter z habe ich einfach auch mal ersetzt, er ist ja auch nicht unbedingt notwendig.
[m,n]=size(A);
for j=1:n-1,
for i=(j+1):m,
if A(i,j) ~= 0;
A(i,1:n) = A(i,1:n) - A(j,1:n)*(A(i,j)/A(j,j));
end;
end;
end;
So bekommst du schon mal deine gewünschte Form.
Gruß
Martin
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 21:45 Di 26.02.2008 | | Autor: | Imbecile |
Vielen Dank!
Jetzt funktioniert es richtig!
Wünsche noch einen schönen Abend!
Lg,
Conny
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 13:48 Mi 27.02.2008 | | Autor: | Imbecile |
Hallo!
Zu dieser Aufgabe stellt sich jetzt noch ein Problem.
Ich habs jetzt mal auf Zeilenstufenform.
Würde ich es Händisch lösen, so würde ich eine unbekannte t setzen und alle anderen in abhängigkeit dieser ausdrücken.
So ists ja schön und gut, aber ich kann mir überhaupt nicht vorstellen wie ich das auf Matlab/Octave machen sollt.
Ich mein wie kann ich sagen setzt das t und löse die anderen in abhängigkeit?
Danke!
Liebe Grüße,
Conny
|
|
|
| |
|
Hallo,
> Würde ich es Händisch lösen, so würde ich eine unbekannte t setzen und alle anderen in abhängigkeit dieser ausdrücken.
Es können natürlich auch mehrere Unbekannte werden. Deren Anzahl ist abhängig von den Größen m und n.
> Ich mein wie kann ich sagen setzt das t und löse die anderen in abhängigkeit?
Na ja, du befindest dich nach wie vor in einer Matrix und es geht darum, sie so umzuformen, dass du die Abhängigkeiten leicht (ggf. automatisch von Matlab) ablesen kannst. Also musst du die Matrix A in eine bestimmte Form umwandeln.
Die gesuchte Form ist (für m=3 und n=5) die:
[mm] \pmat{ 1 & 0 & 0 & \ldots & \ldots\\ 0 & 1 & 0 & \ldots & \ldots \\ 0 & 0 & 1& \ldots & \ldots }
[/mm]
Mit anderen Worten: Du formst die Matrix durch Zeileoperationen (ggf. mit zusätzlichen Spaltenvertauschungen) dahingehend um, dass sie aus einer Einheitsmatrix nebst weiteren Spalten besteht. Wie du das Ergebnis ablesen kannst, kannst du dir noch überlegen. Versuch erst einmal die obige Umwandlung zu implementieren.
Gruß
Martin
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 22:39 Di 04.03.2008 | | Autor: | Imbecile |
Hallo!
Also ich hab es jetzt so weit, dass in der Diagonalen nur einser stehen, dafür sieht der Code jetzt so aus:
[m,n]=size(A);
for j=1:n-1,
for i=(j+1):m,
if A(i,j) ~= 0;
A(i,1:n) = A(i,1:n) - A(j,1:n)*(A(i,j)/A(j,j));
end;
end;
end;
A
for j=1:n-1,
for i=j,
if A(i,j)~=0;
A(i,1:n)=A(i,1:n)/A(i,j);
end;
end;
end;
A
Jetzt habe ich das Problem, dass ich von unten nach oben nach einander die Zeilen abziehen muss, dass nur noch in der Diagonalen Zahlen stehenl.
Dieses hab ich mit dem Code versucht:
for j=n-1:2,
for i=m:1,
if A(i-1,j)~=0;
A(i-1,1:n)=A(i-1,1:n)-A(i,1:n)*A(i-1,j);
end;
end;
end;
A
Das funktioniert aber nicht, ich vermute wegen der Aufzählung von m nach 1...
Hat jemand eine Idee wie ich das umformulieren könnte?
Liebe Grüße,
Conny
|
|
|
| |
|
Hallo,
es stimmt schon, dass das nicht funktioniert. Wenn man herunterzählen will, muss man noch zusätzlich die negative Schrittweite einfügen. Wenn ich also von 5 bis 1 zählen will, mache ich das so:
for i=5:-1:1, ......, end;
Aber da du nun alle Elemente um die Diagonale auslöschen willst und die Matrix mehr Spalten als Zeilen hat, können wir das problemlos alles in die erste Schleife packen. Vergleiche mal, was sich gegenüber meinem ersten Voschlag verändert hat:
[m,n]=size(A);
for j=1:m,
for i=[1:j-1 j+1:m],
if A(i,j) ~= 0,
A(i,1:n) = A(i,1:n) - A(j,1:n)*(A(i,j)/A(j,j));
end;
end;
end;
Wenn du die Elemente der Diagonalen auf 1 bringen willst, dann geht es auch etwas kürzer mit:
for i=1:m, A(i,:) = A(i,:)/A(i,i); end;
Gruß
Martin
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 14:32 Do 06.03.2008 | | Autor: | Imbecile |
Hallo!
Als erstes einmal danke für deine kontinuierliche Hilfe! Ich bin dir wirklich Dankbar!
Also ganz versteh ich jetzt aber nicht was du da gemacht hast, was macht diese Zeile: for i=[1:j-1 j+1:m],?
Das kann ich jetzt irgendwie nicht nachvollziehen...
Eine weitere Frage hätte ich dann noch, wie kann ich jetzt weiter machen?
Ich meine ich muss es jetzt ja aus der Matrix herausbekommen um eine Variable t zu setzen und die anderen glgs nach t auflösen.
Ich meine ich weiß wie ich einzelne zeilen bearbeiten kann, aber ich weiß nicht wie ich daraus die gewohnten gleichungen bekommen sollte...
Auf jeden Fall schon mal Danke!
Liebe Grüße,
Conny
|
|
|
| |
|
Hallo,
> Also ganz versteh ich jetzt aber nicht was du da gemacht hast, was macht diese Zeile: for i=[1:j-1 j+1:m],?
Nun, wir wollen ja die linke quadratische Teilmatrix in eine Einheitsmatrix umwandeln. Dazu gehen wir in der äußeren Schleife mit for j=1:m durch alle Spalten. Und in jeder Spalte gehen wir durch jede Zeile bis auf den Hauptdiagonaleneintrag. Würden wir den mit einbeziehen, müssten wir nur schreiben:
for i=1:m,
Da wir aber jeweils den Eintrag mit i=j weglassen wollen, lassen wir den Eintrag j weg und lassen so i von 1 bis j-1 und dann weiter von j+1 bis m laufen. Das erreichen wir durch Verkettung der beiden Teillisten:
for i=[1:j-1 , j+1:m],
Das Komma zwischen den beiden Teilen lasse ich manchmal weg, das macht keinen Unterschied.
> Ich meine ich muss es jetzt ja aus der Matrix herausbekommen um eine Variable t zu setzen und die anderen glgs nach t auflösen.
Was genau ist denn deine Aufgabe? Willst du nun am Ende die textuelle Darstellung der Lösung oder musst du damit weiterrechnen?
Die Lösung kann man nämlich ganz leicht ablesen. Mal angenommen, du kommst auf:
A = [mm] \pmat{ 1.0000 & 0 & 0.8984 & 0.2939 & 1.1954\\ 0 &1.0000 & -0.7841 & 0.3072 & -0.1290}
[/mm]
Dann lautet die Lösung des GLS:
$a = 1.1954 - 0.8984c - 0.2939d$
$b = -0.1290 + 0.7841c - 0.3072d$
Falls du genau diese Darstellung erreichen willst, dann schau dir vielleicht die Hilfe zu sprintf an.
Beschreib mal genauer, was du am Ende erreichen willst.
Gruß
Martin
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 15:48 So 09.03.2008 | | Autor: | Imbecile |
Hallo!
Also, folgendes, bei deinem Code funktioniert es zwar bei normalen Matrizen, wenn eine unterbestimmte Matrix eingegeben wird kommt es aber zu Problemen. Da bekomme ich immer die Fehlermeldung Division durch 0 nicht möglich.
Jetzt habe ich soweit herumgetüftelt, dass diese Meldung nicht mehr kommt, und jetzt bin ich wieder näher an meinem alten Versuch, der Code sieht nun so aus:
[m,n]=size(A);
for j=1:n-1,
for i=(j+1):m,
if A(i,j) ~= 0;
A(i,1:n) = A(i,1:n) - A(j,1:n)*(A(i,j)/A(j,j));
end;
end;
end;
A
for i=1:m,
if A(i,i)~=0;
A(i,:)=A(i,:)/A(i,i);
end;
end;
A
for j=n-1:-1:2,
for i=m-1:-1:1,
if A(i+1,j+1) ~= 0;
A(i,1:n) = A(i+1,1:n)*A(i,j);
end;
end;
end;
A
Wenn ich nun z.B.: die Matrix
[mm] A=\pmat{ 3 & -1 & -4 & 2 & -1 \\ 2 & 0 & 2 & -1 & 0 \\ 1 & 0 & -1 & 1 & 2 \\ 0 & 1 & 1 & 1 & 7 }
[/mm]
eingebe (diese ist unterbestimmt), erhalte ich nun diese Lösung:
[mm] A=\pmat{ 0 & 0 & 8.1667 & -6.125 & -8.1667 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & -0.75 & -1 \\ 0 & 0 & 0 & 0 & 0 }
[/mm]
So wie ich die Angabe verstanden habe, muss ich mir nun alle Zeilen der Matrix herausholen und jede für sich als Gleichung ansehen.
Außerdem würde ich die beiden 0-Zeilen als z.b. t und s wählen und die Restlichen Variablen durch t und s ausdrücken.
Um ehrlich zu sein, ich habe nur eine Englische Version von MatLab und mein Englisch ist nicht all zu besonders. Ganz habe ich die Hilfe zu sprintf nicht verstanden!
Hast du vielleicht einen Link zu einer Deutschen Seite, wo diese Funktion erklärt ist?
Liebe Grüße,
Conny
|
|
|
| |
|
Hallo,
leider muss ich dir sagen, dass es nicht ausreicht, wenn das Programm keine Fehlermeldung liefert. Die beiden Matrizen (vorher und nachher) haben nämlich nicht gemeinsam und gehören zu zwei verschiedenen Gleichungssystemen!
> Da bekomme ich immer die Fehlermeldung Division durch 0 nicht möglich.
Ja, meine Lösung war nur ein grober Entwurf, der bestimmte Spezialfälle nicht abdeckt. Insbesondere wäre da der Fall zu berücksichtigen, wenn beim Durchlauf durch die Spalten ein Hauptdiagonalenelement 0 ist. Da muss man mit Bedacht vorgehen! Ich würde das Folgende vorschlagen:
1. Falls unterhalb dieses Elements noch Elemente [mm] $\neq [/mm] 0$ vorhanden sind, vertauscht man die beiden Zeilen und macht wie gewohnt weiter.
2. Falls der Rest der Spalte nur noch Nullen enthält (oder sie schon zu Ende ist), dann "merkt" man sich das und arbeitet in den darauffolgenden Spalten nicht mehr mit der Hautpdiagonalen, sondern mit den Elementen eine Zeile darüber. Pro Spalte, in der man den 2. Fall antrifft, geht man jeweils ein Element höher. Falls man das nicht macht, dann unterschlägt man Gleichungen!!
Auf jeden Fall sollte man Obiges berücksichtigen, wenn man GANZ AM SCHLUSS die Elemente auf 1 bringen kann. Es wird nämlich im Allgemeinen nicht unbedingt die Hauptdiagonale sein, durch die man teilt, sondern zum Teil die Elemente darüber.
Ausgehend von meiner ersten Lösung konnte ich das aber schon implementieren.
> So wie ich die Angabe verstanden habe, muss ich mir nun alle Zeilen der Matrix herausholen und jede für sich als Gleichung ansehen.
Ja, nur: Gewusst, wie!
Da deine Lösung nicht funktioniert, schlage ich mal vor, du schreibst mal explizit auf, wie die Lösung aussieht, wenn die Matrix zum Schluss die ist:
[mm] $A^\prime [/mm] = [mm] \pmat{1 & 0 & 0 & 4 & 12 \\ 0 & 1 & 0 & -3 & -2 \\ 0 & 0 & 1 & 2 & 11 \\ 0 & 0 & 0 & 0 & 0 }$
[/mm]
Tipp: Ich würde für die Variablen (aus programmiertechnischen Gründen die Buchstaben a,b,c,... wählen) von links nach rechts wählen.
> Hast du vielleicht einen Link zu einer Deutschen Seite, wo diese Funktion erklärt ist?
Nein, nicht direkt, aber du kannst doch nach deutschen Seiten ![[]](/images/popup.gif) googeln.
Nur noch folgender Tipp:
Wenn du einen Zeilenvektor vars mit Variablennamen und einen Zeilenvektor coeffs mit Koeffizienten, dann kannst du mal folgendes Beispiel ausprobieren:
vars = ['a', 'b', 'c', 'd', 'e', 'f'];
coeffs = [1, 5, 0, -2, 3, -4];
disp(sprintf('%+g%c ', [coeffs ; double(vars)]));
Gruß
Martin
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 21:51 Mo 10.03.2008 | | Autor: | Imbecile |
Hallo!
Folgendes, hab es jetzt so weit, dass tatsächlich die richtigen Matrizen herauskommen.
Also, das Prog eliminiert mir jetzt alle Elemente unterhalb der Diagonalen und so weit wie möglich oberhalb, dann dividiert er mir die Zeilen so dass in der Diagonalen nur 1en stehen.
Ich habs jetzt ohne Fehlermeldung und ich habs mit mehreren Matrizen überprüft, natürlich händisch nachgerechnet, also jetzt sollts richtig funzen.
Für das weitere dachte ich mir das so, ich will Spalte für Spalte eine Variable hinein multiplizieren, die den index der Spalte trägt.
Dann möchte ich jede einzelne Zeile in eine Variable,wieder mit Index, jetzt aber der Zeile speichern.
Somit hätte ich normale gleichungen mit den Variablen, die ich dann über solve lösen könnte.
Mein Problem jetzt ist, dass ich mal mit diesem Code begonnen hab, und da hab ich bemerkt, ich kann zwar zahlen, aber keine variablen hineinmultiplizieren.
Komm ich ums sprintf nicht herum, oder gibt es noch eine weitere möglichkeit, wie ich meinen versuch umformulieren kann?
Mein Schnipsel dafür:
for j=1:n-1,
for i=1:m,
if A(i,j) ~= 0,
A(i,j) = A(i,j)*xj;
end;
end;
end;
A
Liebe Grüße,
Conny
|
|
|
| |
|
Hallo,
jetzt bin ich verwirrt...
Du hast die Matrix jetzt schon so weit umgeformt, dass die Lösung vor dir liegt und willst jetzt noch solve darauf loslassen? Das wäre aber nicht im Sinne des Erfinders, denke ich. Da kannst du gleich die Ausgangsmatrix nehmen und mit den Variablen multiplizieren.
> Mein Problem jetzt ist, dass ich mal mit diesem Code begonnen hab, und da hab ich bemerkt, ich kann zwar zahlen, aber keine variablen hineinmultiplizieren.
Stimmt nicht! Die Multiplikation mit den Variablen geht sogar in einem Schritt (statt spaltenweise), denn du kannst einfach einen Variablenvektor nehmen.
Folgendes Beispiel:
A = rand(3,4)
syms x1 x2 x3
vars = [x1 ; x2 ; x3 ; -1]
E = A * vars
Nun sind E(1), E(2) und E(3) die drei Gleichungen
Da du aber nicht vorher wissen kannst, wie groß deine Matrix ist, kann man auch ein paar Tricks anwenden, um das etwas zu automatisieren:
[m, n] = size(A)
eval(['syms' sprintf(' x%g', 1:n-1)])
eval(['vars = [' sprintf('x%g ; ', 1:n-1) '-1]'])
E = A * vars
Wenn du es wirklich so machen willst, dann kannst du Obiges als Grundlage nehmen. Falls du doch noch sprintf benutzen willst, dann musst du in jeder Zeile nur herausfinden, wo die erste 1 steht (falls überhaupt vorhanden), die dazu gehörende Variable ermitteln (nach Spalte) und dann die anderen Variablen mit ihren Koeffizienten ausgeben.
Gruß
Martin
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 23:54 Mo 10.03.2008 | | Autor: | Imbecile |
Hallo!
Als erstes mal nochmal Danke für deine kontinuierliche Hilfe!!
Naja, ich kanns nicht direkt ablesen...
Also, mein Code:
[m,n]=size(A);
for j=1:m,
for i=[1:j-1 j+1:m],
if A(j,j) ~= 0,
A(i,:) = A(i,:) - A(j,:)*(A(i,j)/A(j,j));
end;
end;
end;
A
for i=1:m,
if A(i,i) ~= 0,
A(i,:) = A(i,:)/A(i,i);
end;
end;
A
Sprich ich habe deinen Code genommen, aber bei der Überprüfung ob es wohl nicht 0 ist hab ich das A(i,j) durch das A(j,j) getauscht.
Jetzt funktioniert es.
Danach eben die Diagonale dividieren.
Jetzt hab ich aber bei den meißten unterbestimmten systemen, mehr als nur eine Zahl pro Zeile.
Deswegen dachte ich ich müsse es in versch. gleichungen spalten, um die entgültige lösung heraus zu bekommen.
Mein Professor meinte ich müsse die Basis des Lösungsraumes bestimmen.
Diese Basis ist ja jetzt in Abhängigkein von versch. Variablen, dass wollte ich eben mit den Gleichungen bestimmen.
Gibt es da eine bessere Variante?
Liebe Grüße,
Conny
|
|
|
| |
|
Hallo,
> Jetzt hab ich aber bei den meißten unterbestimmten systemen, mehr als nur eine Zahl pro Zeile.
Ja schon, aber es fällt auf:
In jeder Zeile gibt es entweder nur Nullen oder es taucht mindestens eine 1 auf. Die 1 ist der Koeffizient der Variablen, nach der wir auflösen wollen. Dafür haben wir ja auch die Division gemacht!
Also nochmal: Überleg dir, was eine Matrixzeile wie z.B.
1 0 2,4 5,3 12,3
aussagt.
Schreib mal die dazugehörige Gleichung auf und forme sie nach der ersten Variablen (der mit der 1 als Koeffizient) um. Was hast du dabei machen müssen? Dasselbe musst du dann eben in deinem Programm umsetzen.
Dabei musst du lediglich immer prüfen, ob dein Diagonalenelement nicht zufällig Null ist, aber das hatten wir ja auch schon vorher.
Mach dir einfach mal klar, wie du selbst vorgehen würdest, dann kannst du es evtl. auch in Matlab umsetzen.
Gruß
Martin
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 23:51 Mi 12.03.2008 | | Autor: | Imbecile |
Hallo!
Nur eine kurze Frage zwischen drin, gibt es für Matlab auch so einen Befehl wie in Maple?
Also in Maple kann ich so: v:=Vector(3,i->x[i]); einen Vektor erzeugen der 3 zeilen hat und dessen elemente x1, x2 und x3 sind.
Wenn es so einen Befehl gäbe wärs einfacher....
Lg,
Conny
|
|
|
| |
|
Hmmm,
auch bei Maple kannst du das nur mit x[i] und nicht mit xi machen.
Aber was spricht denn gegen
v = [x1 ; x2 ; x3] ?
Wenn das Ganze automatisch vonstatten gehen soll (also unabhängig von der Anzahl der Variablen), dann hat Matlab den Vorteil, dass hier Strings als Matlab-Ausdrücke ausgewertet werden können. Dann würde ich es wieder mit sprintf machen:
eval(['v = [ ' sprintf('x%g ', 1:anzahl_der_variablen) ']''']);
Gruß
Martin
|
|
|
| |
|
| Status: |
(Frage) reagiert/warte auf Reaktion  | | Datum: | 10:58 Mo 17.03.2008 | | Autor: | Imbecile |
Hallo!
Ich kann mit diesem sprint nichts anfangen, deswegen wollte ich dem aus dem Weg gehen.
Es ist nämlich, ich weiß nicht wie ich mit dem arbeiten soll, ich weiß nicht mal wie ich in dieser Form eine zeile ansprechen soll, außerdem ist es ja noch keine Gleichung, da das =0 auch fehlt...
Und wenn ich einen vektor hineinmultipliziere hätte ich eben wenigstens noch meine Matrix in der ich weiß wie ich die einzelnen zeilen ansprechen kann.
Ich habs in dieser Form wirklich versucht, aber ich komm nicht drauf, wie ich auch nur irgendwas bei dem machen könnte...
Liebe Grüße,
Conny
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 21:52 Di 18.03.2008 | | Autor: | Imbecile |
Hallo!
Weil du meintest ich solle mir überlegen wie ich es händisch lösen sollte...
Nehmen wir an meine Angabe lautet:
[mm] A=\pmat{ 3 & -2 & -4 & 2 &-1 \\ 2 & 0 & 2 & -1 & 0 \\ 1 & 0 & -1 & 1 & 2 \\ 0 & 1 & 1 & 1 & 7}
[/mm]
dann sieht sie nach der bearbeitung so aus:
[mm] A=\pmat{ 1 & 0 & 0 & 0.25 & 1 \\ 0 & 1 & 0 & 1.75 & 8 \\ 0 & 0 & 1 & -0.75 & -1 \\ 0 & 0 & 0 & 0 & 0}
[/mm]
Das bedeutet ich habe das Glg System:
x1 + 0.25x4 = 1
x2 + 1.75x4 = 8
x3 - 0.75x4 = -1
0=0
Dann würde ich eine Variable t setzen, weil eine 0 Zeile drinnen ist.
Also x1 = t und dann lösen, und somit folgt daraus die Basis meines Lösungsraums:
[mm] B=\pmat{ t \\ 1 +7t \\ 2 - 3t \\ 4 - 4t}
[/mm]
Und das Beispiel wäre gelöst!
Jetzt weiß ich mittlerweile zwar wie ich die einzelnen Zeilen von E anspreche, mir fehlt aber das =0 drinnen, ich kann sie nicht auflösen ich kann keine Variable t setzen oder sonst was.
Ich mein ich wüsste so ungefähr wie ich den Code schreibe, wenn ich die Gleichungen habe, vorher muss ich aber die Matrix in eine Gleichung umschreiben...
Lg,
Conny
|
|
|
| |
|
Hallo,
> Dann würde ich eine Variable t setzen, weil eine 0 Zeile drinnen ist.
> Also x1 = t und dann lösen, und somit folgt daraus die Basis meines Lösungsraums:
Und genau das x1 = t ist ungeschickt, denn damit machst du deine ganze Umformerei mit den Einsen zunichte.
Für t suchst du dir die Variable(n), von der (denen) alles abhängen soll, also mit den Spalten außerhalb der zur Einheitsmatrix umgeformten Teilmatrix. Hier also: x4 = t, da die vierte Spalte noch andere Elemente als 1 und 0 enthält.
Und damit kannst du aber die Lösung direkt aus der Matrix ablesen:
x1 = 1 - 0.25t
x2 = 8 - 1.75t
x3 = -1 + 0.75t
x4 = t
Also: x = [mm] \pmat{1 \\ 8 \\ -1 \\ 0} [/mm] + t * [mm] \pmat{-1 \\ -7 \\ 3 \\ 4}
[/mm]
> Jetzt weiß ich mittlerweile zwar wie ich die einzelnen Zeilen von E anspreche, mir fehlt aber das =0 drinnen, ich kann sie nicht auflösen ich kann keine Variable t setzen oder sonst was.
Das verstehe ich immer noch nicht, denn das Gleichungssystem ist inhomogen.
> Ich mein ich wüsste so ungefähr wie ich den Code schreibe, wenn ich die Gleichungen habe, vorher muss ich aber die Matrix in eine Gleichung umschreiben...
Wie man aus der Matrix Gleichungen bekommt, hatten wir schon (da brauchst du kein "=0", da das beim Lösen implizit angenommen wird):
A ist schon gegeben.
syms x1 x2 x3 x4
vars = [x1 ; x2 ; x3 ; x4 ; -1] %Die -1 bringt alles auf die linke Seite
E = A * vars %Nun kannst du auf die Gleichungen als Elemente von E zugreifen
Gruß
Martin
|
|
|
| |
|
Hallo!
Also ich bin jetzt mal draufgekommen, wie stark ich doch die letzten Wochen auf der Leitung gesessen bin.
Ich brauch bei der bearbeiteten variante ja nur die 0 spalten löschen und die matrix transponieren.
Jetzt brauch ich nur noch eine Möglichkeit, wie ich mein Ergebnis dann auch in Form einer Basis angeben kann, also: {(),(),....,()}.
Geht das überhaupt?
Ich mein, ja ich kann mit ner schleife alle spalten extra ausgebenlassen, aber ich müsste es irgendwo drinnen speichern, und ich schaff das nicht, kann nämlich keine variablen erzeugen, die automatisch weiterzählen, und dann auch noch ganze spalten speichern...
Ich habs auch mit sprintf versucht, aber wenn ichs in eine zeile schreibe, dann schreibt er mir nicht die spalte aus und wenn ichs extra schreib hab ich alles in einer jeweils anderen zeile...
Wenn ich dass jetzt dann noch zamgebracht hab, bin ich fertig mit der Hausübung, und du hast dann mal ruhe von mir! 
Aber auf jeden Fall Danke für alles!
Lg,
Conny
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 01:20 Di 25.03.2008 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
|
