Matlab-Femset

MATLAB-Interface-Routine Isiasb_m zur FEMSET-Funktion isiasb_f

Die MATLAB-Interface-Routine Isiasb_m (“MexFunction”) liefert mit Hilfe der FEMSET-Funktion isiasb_f für das allgemeine Eigenwertproblem mit symmetrischen Matrizen die kleinsten Eigenwerte und die zugehörigen Eigenvektoren. Die Möglichkeiten des Aufrufs aus MATLAB wird im Kommentar am Anfang der Interface-Funktion beschrieben:

/* ************************************************************************* */
/*  ###  MATLAB-Interface fuer den                                           */
/*                        Finite-Elemente-Baukasten FEMSET  ###              */
/*                                                                           */
/*  Eigenwerte und Eigenvektoren des allgemeinen Eigenwertproblems mit       */
/*  symmetrischen Bandmatrizen (Gram-Schmidt-Iteration)                      */
/*  ==================================================================       */
/*                                                                           */
/*  Es werden die neiwe kleinsten Eigenwerte und die zugehoerigen            */
/*  Eigenvektoren berechnet (und auf den Adressen eiwe_p bzw. x_p            */
/*  abgeliefert). Die Matrix A des allgemeinen symmetrischen                 */
/*  Eigenwertproblems (A - lambda * B) x = o muss positiv definit sein.      */
/*                                                                           */
/*  Von A und B sind nur die wesentlichen Elemente gespeichert (pro          */
/*  Matrixzeile iba bzw. ibb Elemente, iba und ibb sind die "halben          */
/*  Bandweiten").                                                            */
/*                                                                           */
/*  Die letzten iba - 1 bzw. ibb - 1 Zeilen muessen durch Null-Elemente      */
/*  auf jeweils iba bzw. ibb Elemente ergaenzt werden.                       */
/*                                                                           */
/*  Beispiel:                                                                */
/*                                                                           */
/*  Symmetrische Bandmatrix              Elemente auf dem Feld A bzw. B      */
/*                                                                           */
/*      4  2  0  0  0  0                     4  2  0                         */
/*      2  6  2  3  0  0                        6  2  3                      */
/*      0  2  7  1  4  0                           7  1  4                   */
/*      0  0  1  5  9  9         --->                 5  9  9                */
/*      0  3  4  9  1  2                                 1  2  0             */
/*      0  0  0  9  2  2                                    2  0  0          */
/*                                                                           */
/*  Diese Matrix mit 6 Zeilen hat die halbe Bandweite 3. Die Elemente        */
/*  koennen isiasb_m in zwei verschiedenen Speichervarianten angeboten       */
/*  werden.                                                                  */
/*                                                                           */
/*                                                                           */
/*  Speichervariante a:                                                      */
/*  ===================                                                      */
/*                                                                           */
/*  Zwei eindimensionale Felder (Vektoren) enthalten die wesentlichen        */
/*  (m*iba) bzw. (m*ibb) Elemente, fuer das betrachtete Beispiel muesste     */
/*  ein solches Feld so aussehen:                                            */
/*                                                                           */
/*                  [4 2 0 6 2 3 7 1 4 5 9 9 1 2 0 2 0 0]                    */
/*                                                                           */
/*  Aufrufmoeglichkeiten aus MATLAB fuer Speichervariante a:                 */
/*                                                                           */
/*  [nc ev X it scc] = isiasb_m (A , B , m , iba , ibb , nev) ;              */
/*  [nc ev X it scc] = isiasb_m (A , B , m , iba , ibb , nev , eps) ;        */
/*  [nc ev X it scc] = isiasb_m (A , B , m , iba , ibb , nev , eps , itmx) ; */
/*                                                                           */
/*  Von den Output-Parametern sind nur die beiden ersten (nc und ev)         */
/*  zwingend.                                                                */
/*                                                                           */
/*                                                                           */
/*  Speichervariante b:                                                      */
/*  ===================                                                      */
/*                                                                           */
/*  Ein oder zwei zweidimensionale Felder (Matrizen mit m Zeilen) enthalten  */
/*  in jeder Zeile die wesentlichen iba bzw. ibb Elemente, fuer das          */
/*  betrachtete Beispiel muesste ein solches Feld so aussehen:               */
/*                                                                           */
/*                                   [4  2  0  ;                             */
/*                                    6  2  3  ;                             */
/*                                    7  1  4  ;                             */
/*                                    5  9  9  ;                             */
/*                                    1  2  0  ;                             */
/*                                    2  0  0  ]                             */
/*                                                                           */
/*  Aufrufmoeglichkeiten aus MATLAB fuer Speichervariante b:                 */
/*                                                                           */
/*        [nc ev X it scc] = isiasb_m (A) ;                                  */
/*        [nc ev X it scc] = isiasb_m (A , B) ;                              */
/*        [nc ev X it scc] = isiasb_m (A , B , nev) ;                        */
/*        [nc ev X it scc] = isiasb_m (A , B , nev , eps) ;                  */
/*        [nc ev X it scc] = isiasb_m (A , B , nev , eps , itmx) ;           */
/*                                                                           */
/*  Von den Output-Parametern sind nur die beiden ersten (nc und ev)         */
/*  zwingend.                                                                */
/*                                                                           */
/*  Eingabe:  A   - Symmetrische Bandmatrix A mit m Zeilen und der Bandweite */
/*                  iba, gespeichert sind zeilenweise die m*iba              */
/*                  wesentlichen Elemente                                    */
/*            B   - Symmetrische Bandmatrix B mit m Zeilen und der Bandweite */
/*                  ibb, gespeichert sind zeilenweise die m*ibb              */
/*                  wesentlichen Elemente                                    */
/*            m   - Zeilenanzahl der Matrizen A und B                        */
/*            iba - Bandweite der Matrix A                                   */
/*            ibb - Bandweite der Matrix B                                   */
/*            nev - Anzahl der zu berechnenden Eigenwerte (Default: 1)       */
/*            eps - Relativer tolerierter Fehler fuer die Eigenwerte         */
/*                  (Default: 1.e-6)                                         */
/*           itmx - Maximale Anzahl der auszuführenden Iterationen           */
/*                  (Default: 1000)                                          */
/*                                                                           */
/* Ausgabe:   nc  - Anzahl der tatsaechlich berechneten Eigenwerte (ist im   */
/*                  Erfolgsfall gleich nev, nur bei vorzeitigem              */
/*                  Abbruch wegen Erreichens von itmx Iterationen kann       */
/*                  nc kleiner als nev sein)                                 */
/*            ev  - Vektor mit nc Elementen, enthaelt die berechneten        */
/*                  Eigenwerte                                               */
/*            X   - Matrix mit m Zeilen und nc Spalten, enthaelt die         */
/*                  berechneten Eigenvektoren                                */
/*            it  - Anzahl der tatsaechlich ausgefuehrten Iterationen        */
/*                  (Wert ist negativ, wenn die Anzahl der maximal           */
/*                  auszufuehrenden Iterationen erreicht wurde)              */
/*            scc - "Erfolgs-Indikator":                                     */
/*                  1 ---> Berechnung wurde ausgefuehrt                      */
/*                  0 ---> Berechnung wurde abgebrochen, weil Matrix A       */
/*                         nicht positiv definit ist                         */
/*                 -1 ---> Berechnung wurde aus einem anderen Grund          */
/*                         abgebrochen (z. B.: Kein ausreichender            */
/*                         Arbeitsspeicherplatz)                             */
/*                                                                           */
/*  Autor: J. Dankert                                                        */
/* ************************************************************************* */

Beispiel:

Das allgemeine Matrizeneigenwertproblem

 

wird durch zwei symmetrische Bandmatrizen beschrieben (beide haben die halbe Bandweite 4), die nach den Regeln der kompakten Speicherung dieser Matrizen also mit jeweils 28 Elementen definiert werden. Das folgende MATLAB-Script baut beide Matrizen als 7*4-Rechteckmatrizen auf. Der Aufruf von iviasb_m berechnet die 3 kleinsten Eigenwerte und die zugehörigen Eigenvektoren:

 

Das Command Window (rechts) zeigt die Ergebnisse.

Zum Download verfügbar: DLL Isiasb_m.dll (genügt für den Aufruf aus Matlab).

Für Interessenten: Der Quellcode für die Interface-Funktion steht als  isiasb_m.c zur Verfügung, das oben zu sehende Test-Script als isiasbtest.m.

Homepage MatlabFemset

www.JuergenDankert.de

D

nkert.de