3. inverse Matrix

inverse Matrix

  • A

    Hallo,

    ich habe eine Matrix:

    double dM[3][3] = { t_vEA.getX(),  t_vEA.getY(),  t_vEA.getZ(), t_vEB.getX(), t_vEB.getY(), t_vEB.getZ(), vN.getX(), vN.getY(), vN.getZ() };

    Daraus möchte ich nun die Inverse erstellen.

    Hat das jemand schon mal gemacht und kann mir sagen wie das geht oder mir vielleicht nen Link geben, wo ich das nachlesen kann?

    Danke!

    Gruß, Amalthea

    0
  • V
     

    double dM[3][3] = { 
   t_vEA.getX(), t_vEA.getY(), t_vEA.getZ(), 
   t_vEB.getX(), t_vEB.getY(), t_vEB.getZ(), 
   vN.getX(),    vN.getY(),    vN.getZ(),
};
    0
  • A

    Hallo,

    hm, das ist jetzt aber nicht die Lösung, oder?

    Gruß,
    Amalthea

    0
  • N

    vielleicht kannste damit was anfangen:
    http://www.maths.cam.ac.uk/undergrad/tripos/catam/ccatsl/
    sind ein paar funktionen für matrizen dabei, source code ist ganz unten auf der seite.
    doku für die matrix routines: http://www.maths.cam.ac.uk/undergrad/tripos/catam/ccatsl/manual/node63.html

    0
  • W

    wollte mir sowas mal vor ner ganzen weile selber basteln, habs dann aber doch seingealassen und ne fertig matrixklasse genommen...

    hier mein ansatz dazu, ohne garantie obs wirklich funzt aber mit den paar matrizen mit denen ichs getestet hab gings...

    int matrix_inv(double*m,int n){//m ist zeiger auf eine quadratische matrix der grösse n zeilenweise abgespeichert
int i,j,k;
double h,*mat=new double[n*n];

    //Array mit Werten einer Einheitsmatrix erzeugen
    for(j=0;j<n;j++)for(i=0;i<n;i++)mat[i+j*n]=i!=j?0:1;

    //für jede Zeile der Matrix
    for(j=0;j<n;j++){
        k=0;
        if(!m[j*n+j])    //wenn das zu normierende element 0 ist zeilentausch
            for(k=j+1;k<n;++k)    //für jede zeile nach der jten
                if(m[k*n+j]){    //wenn element ungleich 0 gefunden zeilen tauschen und schleife abbrechen
                    for(i=0;i<n;++i){
                        h=m[j*n+i];m[j*n+i]=m[k*n+i];m[k*n+i]=h;
                        h=mat[j*n+i];mat[j*n+i]=mat[k*n+i];mat[k*n+i]=h;
                    }
                    break;
                }
        if(k==n){delete [] mat; return 0;}

        h=m[j*n+j];//wert des zu normierenden elements
        for(k=0;k<n;k++){m[k+j*n]/=h;mat[k+j*n]/=h;}//die komplette zeile normieren
        for(i=0;i<n;i++)// gauss über die matrix jagen
            if(i!=j && m[i*n+j]!=0){
                h=-m[i*n+j];
                for(k=0;k<n;k++){m[k+i*n]+=h*m[k+j*n];mat[k+i*n]+=h*mat[k+j*n];}   
            }

    }
    memcpy(m,mat,n*n*sizeof(double));//invertierte matrix in übergebenen speicher schreiben
    delete [] mat;
return 1;
}
    0
  • B

    das sind aber nicht senkrecht stehende Vektoren der Länge |1| ???

    0
  • T

    Amalthea schrieb:

    Daraus möchte ich nun die Inverse erstellen.

    Warum? Lernt man doch schon im ersten Semster: Wer Matrizen invertiert ist doof 🙂

    0
  • C

    Das Inversionsverfahren nach Gauss-Jordan, wie es Windalf gezeigt hat, (hab den Code aber nicht geprüft!) hat einen Nachteil, wie jede Matrizeninversion mit dem PC:
    Sobald die Matrix größer wird und nicht sicher regulär ist, können sich numerische Fehler derart aufschaukeln, dass auch singuläre Matrizen invertiert werden.
    Die Inverse wird dann sehr große Zahlen beinhalten, welche durch Division mit Werten fast gleich Null entstehen.
    Ich konnte dieses Problem umgehen in dem ich die Inversion rausgeworfen habe und mein Problem so umformuliert habe, dass ich mit einem Frontallösungsverfahren (auch nach Gauss) arbeiten konnte.
    Zudem lösche ich während der Umformung der Matrix regelmäßig sehr kleine Werte durch Nullsetzen.
    Damit erhalte ich zwar nur eine Näherungslösung, aber die singulären Matrizen werden sicher gefunden, was für mich wesentlich wichtiger war.
    Was man als einen Schwellwert für das Nullsetzen eines Elements ansehen sollte, kann ich nicht sicher sagen. Ich verwende eine Schwelle die etwa 6 bis 7 Größenordnungen kleiner ist, als meine Matrizenelemente.
    Ich habe meine Ergebnisse mit Berechnungen von Matlab verglichen. So schlecht stehe ich da gar nicht da.
    Wenn du umbedingt invertieren musst, solltest du versuchen auch dort derartige Nullsetzungen einzubauen.

    Es gibt außerdem noch ein Außtauschverfahren nach Pivot mit dem man angeblich Matrizen invertieren kann. Das habe ich aber nicht zum laufen bekommen. Entweder habe ich es nicht kapiert oder meine Quellen haben nicht gepasst. Diese haben sich auch z. T. wiedersprochen, bzw. waren unvollständig.

    Theorie und Code gibt es hier:
    http://fachschaft.informatik.fh-muenchen.de/~rink/num_skript_cvs_1.28.pdf
    http://www.hta-be.bfh.ch/~krucker/IAMSkript98.pdf
    PS: Falls du auf die Idee kommst die Determinate deiner Matrix zu berechnen, um deren Invertierbarkeit zu prüfen, rate ich von einem Rekursionsalgorithmus dringend ab. Für die 36*36 Matrix mit welcher ich ihn testen wollte, hätte der Rechner ungefähr 1,4E46 durch die Rekursion gemußt. 😮

    0
  • A

    Hallo,

    danke für diesen umfassenden Beitrag. Ich werd mich mal kundig machen...

    PS: meine Matrix ist immer in der From 3x3.

    Gruß,
    Amalthea

    0
  • T

    Amalthea schrieb:

    PS: meine Matrix ist immer in der From 3x3.

    In dem Fall kannst tut es in Bezug auf die Rechenzeit auch nicht weh, zu invertieren. Aber der Stil ist trotzdem doof. Was war jetzt noch mal deine konkrete Anwendung?

    0
Anmelden zum Antworten