============ANHANG A Manual============ Dieses Manual gibt die Online-Hilfe zu den selbstgeschriebenen Funktionen wieder, in denen die Algorithmen aus den vorangegangenen sechs Kapiteln umgesetzt sind. Die Online-Hilfe ist mit Help('Funktionsname'); bzw. mit H.Help_Funktionsname(); abrufbar, je nachdem, ob man die Helpdateien einzeln oder als Package eingelesen hat, siehe die Punkte A.1 bis A.3. So erhaelt man beispielsweise mit Help('B1DMD'); bzw. mit H.Help_B1DMD(); eine Beschreibung der CoCoA-Funktion B1DMD. Saemtliche Funktionen sind unter der derzeit aktuellen Version CoCoA-4.1 lauffaehig, die unter cocoa@dima.unige.it kostenlos erhaeltlich ist. Daneben sei auf die Online-Hilfe zu den eingebauten Funktionen von CoCoA verwiesen, die bekanntlich mit dem Befehl Man('Funktionsname'); aufgerufen werden kann oder ueber den Menuepunkt "Help" oder ueber die F1-Taste. Als guenstig zur Trigonalisierung kann i.a. das Verfahren B2TMDMD bzw. in speziellen Faellen die modifizierte Variante B2TMDMDSM empfohlen werden. Zur Diagonalisierung erweist sich meist das Verfahren B2DMDMDFB als gut, bzw. die modifizierten Varianten B2DMDMDFBSM und B2DMDMDSMFB, siehe den Vergleich der Verfahren in Kapitel IV, V und VI. Bei den Funktionen, bei denen optional ein Verfahren gewaehlt werden kann, z.B. bei MyDet etc., liegen als Voreinstellungen die genannten Verfahren B2TMDMD bzw. B2DMDMDFB zugrunde. WARNUNG Alle selbstgeschriebenen Funktionen laufen fehlerfrei, jedoch sind keinerlei Routinen eingebaut, um den Nutzer vor der eigenen Dummheit zu schuetzen. So wird etwa die Funktion MyDet auch fuer nichtquadratische Matrizen ein Ergebnis ausspucken. Abgesehen davon empfiehlt es sich stets, von vorneherein die Eingabewerte (Matrizen etc.) so zu manipulieren, dass keine unnoetigen Berechnungen durchgefuehrt werden muessen. Zu beachten ist ferner, dass der Koeffizientenring ein Koerper sein muss, denn obwohl die Trigonalisierung bzw. Diagonalisierung mit bruchfreien Verfahren vorgenommen wird, fuehrt CoCoA beispielsweise in Z[...] keinen Divisionsalgorithmus aus. BEISPIEL Use S::= Z[z[0..4]]; A:= Mat[ [z[0], z[1], z[2]], [z[1], z[2], z[3]], [z[2], z[3], z[4]] ]; B1TMD(A); ------------- ERROR: Cannot divide CONTEXT: Return(LM(X)) ------------- CoCoa stoert sich am Koeffizientenring Z. Abhilfe schafft man, indem man stattdessen Q verwendet. ------------- Use T::= Q[z[0..4]]; A:= Mat[ [z[0], z[1], z[2]], [z[1], z[2], z[3]], [z[2], z[3], z[4]] ]; B1TMD(A); Mat[ [z[0], z[1], z[2]], [0, -z[1]^2 + z[0]z[2], -z[1]z[2] + z[0]z[3]], [0, 0, -z[2]^3 + 2z[1]z[2]z[3] - z[0]z[3]^2 - z[1]^2z[4] + z[0]z[2]z[4]] ] ------------- Es folgt nun im einzelnen: A.1 Welche Packages gibt es? A.2 Wie laedt man ein Package? A.3 Wie liest man einzelne Dateien ein? A.4 Alphabetisches Verzeichnis aller Befehle A.5 Verzeichnis aller Befehle, geordnet nach Kapiteln bzw. Dateien A.6 Befehle in alphabetischer Reihenfolge ============ A.1 Welche Packages gibt es? ============ Der bequeme Weg, die zu dieser Diplomarbeit gehoerigen CoCoA-Funktionen zu nutzen, besteht darin, die entsprechenden Packages einzulesen, die aus den folgenden Dateien bestehen: linalg.pkg: bareiss.coc (Kapitel I) mal.coc (Kapitel II) sasaki.coc (Kapitel III) linalg.coc (Kapitel V) minors.coc (Kapitel VI) test.pkg: test.coc (Kapitel IV) help.pkg: helpbar.coc helpmal.coc helpsas.coc helplin.coc helpmin.coc helptest.coc Dabei enthaelt test.pkg Funktionen, um Beispielmatrizen (katalektische Matrizen u.a.) zu erzeugen und um Testreihen mit den Funktionen aus linalg.pkg durchzufuehren. Die Online-Hilfe zu den jeweiligen Funktionen findet sich in help.pkg. Wer darauf verzichten kann, muss diese beiden Packages nicht unbedingt einlesen. Daneben existieren Dateien *2.*, die jeweils identisch sind mit den entsprechenden Dateien *.*, bis auf die Tatsache, dass in ihnen die Division mit "/" statt mit DivAlg durchgefuehrt wird. Sie sind zusammengefasst zu den Packages linalg2.pkg: bareiss2.coc (Kapitel I) mal2.coc (Kapitel II) sasaki.coc (Kapitel III) linalg.coc (Kapitel V) minors2.coc (Kapitel VI) test2.pkg: test.coc (Kapitel IV) Dabei enthaelt test2.pkg aehnlich wie test.pkg Funktionen, um Beispielmatrizen (katalektische Matrizen u.a.) zu erzeugen und um Testreihen mit den Funktionen aus linalg2.pkg durchzufuehren. Wer darauf verzichten kann, muss dieses Package nicht unbedingt einlesen. Das dazugehoerige Package help.pkg mit der Online-Hilfe ist genau wie oben. Der Inhalt der angegebenen Einzeldateien ist unter Punkt A.5 detailliert aufgefuehrt. ============ A.2 Wie laedt man ein Package? ============ Das CoCoA-Manual enthaelt unter Punkt 2.9 (CoCoA Packages) eine relativ ausfuehrliche Beschreibung zu Packages. Kurzgefasst geht man wie folgt vor: Zunaechst liest man ein Package mit dem "Source"-Befehl ein, beispielsweise <<'linalg.pkg'; <<'test.pkg'; <<'help.pkg'; oder <<'linalg2.pkg'; <<'test2.pkg'; <<'help.pkg'; Je nachdem, wo der Nutzer seine Dateien aufbewahrt, muss man hier eventuell die richtige Pfadangabe ergaenzen. Liegt die Datei linalg.pkg etwa auf der Festplatte "c:" im Verzeichnis "programme", so lautet der Befehl korrekt <<'c:\programme\linalg.pkg'; Konkret enthalten die Packages die entsprechenden Unterfunktionen $contrib/bettina_krammer/linalg $contrib/bettina_krammer/linalg2 $contrib/bettina_krammer/test $contrib/bettina_krammer/test2 $contrib/bettina_krammer/help Es empfiehlt sich, um Schreibarbeit zu vermeiden, ein Alias zu definieren, welches nicht mit einem bereits vorhandenen kollidieren sollte, etwa Alias LA:= $contrib/bettina_krammer/linalg; Alias T:= $contrib/bettina_krammer/test; Alias H:= $contrib/bettina_krammer/help; Zusammenfassend zeigt nun ein Beispiel, wie man vorgehen muss: BEISPIEL <<'linalg.pkg'; <<'test.pkg'; <<'help.pkg'; Alias LA:= $contrib/bettina_krammer/linalg; Alias T:= $contrib/bettina_krammer/test; Alias H:= $contrib/bettina_krammer/help; Use S::= Z/(32003)[z[0..4]]; A:= T.Hankel(3,3); A; Mat[ [z[0], z[1], z[2]], [z[1], z[2], z[3]], [z[2], z[3], z[4]] ] ------------- LA.B1TMD(A); Mat[ [z[0], z[1], z[2]], [0, -z[1]^2 + z[0]z[2], -z[1]z[2] + z[0]z[3]], [0, 0, -z[2]^3 + 2z[1]z[2]z[3] - z[0]z[3]^2 - z[1]^2z[4] + z[0]z[2]z[4]] ] ------------- P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; LA.B1DMDFB(P); Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- H.Help_Generic(); ============ Generic ============ SYNTAX Generic(N: INT, M: INT): MAT wobei 1 <= N, M ist und wobei CurrentRing() die Variablen z[0..N*M-1] enthalten muss. BESCHREIBUNG Diese Funktion erzeugt die generische NxM-Matrix. BEISPIEL Use S::= Q[z[0..23]]; Generic(4,6); --bei Verwendung von Packages: T.Generic(4,6); Mat[ [z[0], z[1], z[2], z[3], z[4], z[5]], [z[6], z[7], z[8], z[9], z[10], z[11]], [z[12], z[13], z[14], z[15], z[16], z[17]], [z[18], z[19], z[20], z[21], z[22], z[23]] ] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 Abschnitt 18 ------------- Wichtig ist es, vor dem eigentlichen Funktionsnamen stets mit "LA.", "T." oder "H." anzugeben, aus welchem Package die Funktion stammt, denn sonst macht CoCoA sich mit einer Fehlermeldung bemerkbar. ------------- ============ A.3 Wie liest man einzelne Dateien ein? ============ Abgesehen von den Packages besteht die Moeglichkeit, die Dateien einzeln zu laden, und zwar am besten in der Reihenfolge bareiss.coc bzw. bareiss2.coc mal.coc bzw. mal2.coc sasaki.coc linalg.coc minors.coc bzw. minors2.coc test.coc Verwechselt man die Reihenfolge oder vergisst man eine der Dateien, so wird sich CoCoA entweder sofort mit einer Fehlermeldung der Art ERROR: Unknown operator B1DMD CONTEXT: B1DMD := Function("B1DMD") melden oder moeglicherweise auch erst dann, wenn man eine Funktion ausfuehren will, die eine Unterfunktion aus einer unbekannten Datei benoetigt. Das Problem laesst sich sehr leicht beheben, indem man die fehlende Datei nachlaedt. Die angegebene Reihenfolge der Dateien spiegelt die Tatsache wieder, dass eine Datei auf ihre Vorgaengerinnen zurueckgreift. Die zugehoerigen Helpdateien kann man, muss man aber nicht einlesen: helpbar.coc helpmal.coc helpsas.coc helplin.coc helpmin.coc helptest.coc Dabei ist die Reihenfolge egal. Bei Verwendung des "Source"-Befehls ist wie ueblich auf die korrekte Pfadangabe zu achten, siehe A.2. Zum Inhalt der einzelnen Dateien vergleiche A.5. BEISPIEL <<'bareiss.coc'; <<'sasaki.coc'; <<'mal.coc'; <<'test.coc'; ERROR: Unknown operator MaxMinors CONTEXT: MaxMinors := Function("MaxMinors") ------------------------------- ERROR: Unknown operator MaxMinorsLR CONTEXT: MaxMinorsLR := Function("MaxMinorsLR") ------------------------------- ERROR: Unknown operator MyMinors CONTEXT: MyMinors := Function("MyMinors") ------------------------------- ERROR: Unknown operator MyMinorsLR CONTEXT: MyMinorsLR := Function("MyMinorsLR") ------------------------------- ERROR: Unknown operator MyMinors_2 CONTEXT: MyMinors_2 := Function("MyMinors_2") ------------------------------- ERROR: Unknown operator MyMinorsLR_2 CONTEXT: MyMinorsLR_2 := Function("MyMinorsLR_2") ------------------------------- Hier beschwert sich CoCoA darueber, dass bestimmte Funktionen aus der nichteingelesenen Datei minors.coc fuer test.coc bekannt sein sollten. Entweder man laedt diese Datei nach oder auch nicht. Dann lassen sich trotzdem alle Funktionen ausfuehren, die nicht auf diese Datei zurueckgreifen. ------------------------------- Use S::= Z/(32003)[z[0..4]]; A:= Hankel(3,3); A; Mat[ [z[0], z[1], z[2]], [z[1], z[2], z[3]], [z[2], z[3], z[4]] ] ------------- B1TMD(A); Mat[ [z[0], z[1], z[2]], [0, -z[1]^2 + z[0]z[2], -z[1]z[2] + z[0]z[3]], [0, 0, -z[2]^3 + 2z[1]z[2]z[3] - z[0]z[3]^2 - z[1]^2z[4] + z[0]z[2]z[4]] ] ------------- RunTest([A],[B1TMD]); Matrix1: Cpu time = 0.00, User time = 0 B1TMD(...): Mat[ [z[0], z[1], z[2]], [0, -z[1]^2 + z[0]z[2], -z[1]z[2] + z[0]z[3]], [0, 0, -z[2]^3 + 2z[1]z[2]z[3] - z[0]z[3]^2 - z[1]^2z[4] + z[0]z[2]z[4]] ] ------------- RunTest([A],[MaxMinors]); ERROR: Undefined variable MaxMinors CONTEXT: RunTest([A],[MaxMinors]) ------------- <<'minors.coc'; RunTest([A],[MaxMinors]); Matrix1: Cpu time = 2.80, User time = 0 MaxMinors(A): [-z[2]^3 + 2z[1]z[2]z[3] - z[0]z[3]^2 - z[1]^2z[4] + z[0]z[2]z[4]] ------------- <<'helptest.coc'; Help('Generic'); ============ Generic ============ SYNTAX Generic(N: INT, M: INT): MAT wobei 1 <= N, M ist und wobei CurrentRing() die Variablen z[0..N*M-1] enthalten muss. BESCHREIBUNG Diese Funktion erzeugt die generische NxM-Matrix. BEISPIEL Use S::= Q[z[0..23]]; Generic(4,6); --bei Verwendung von Packages: T.Generic(4,6); Mat[ [z[0], z[1], z[2], z[3], z[4], z[5]], [z[6], z[7], z[8], z[9], z[10], z[11]], [z[12], z[13], z[14], z[15], z[16], z[17]], [z[18], z[19], z[20], z[21], z[22], z[23]] ] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 Abschnitt 18 ------------- ============ A.4 ALPHABETISCHES VERZEICHNIS ALLER BEFEHLE ============ A Alg AllSubsets AT AusrLUMat AusrLURow AusrROMat AusrRORow BackSubstDMD BackSubstTMD BackupDMD BackupDMDRow BackupDMDSM BackupDMDSMRow BackupMaxMinors BackupMaxMinorsRow BlockMat B1DMD B1DMDFB B1DMDFBSM B1DMDRow B1DMDRow2Col B1DMDSM B1DMDSMFB B1DMDSMRow B1DOD B1DODRow B1DODRow2Col B2DMD B2DMDFB B2DMDMD B2DMDMDFB B2DMDMDFBSM B2DMDMDRow B2DMDMDSM B2DMDMDSMFB B2DMDMDSMRow B2DMDRow B2DOD B2DODRow B1TMD B1TMDRow B1TMDRow2Col B1TMDSM B1TMDSMRow B1TMDSMRow2Col B1TOD B1TODRow B1TODRow2Col B2TMD B2TMDMD B2TMDMDRow B2TMDMDSM B2TMDMDSMRow B2TMDRow B2TOD B2TODRow CatMat ChangeRow CheckEq CheckHomSol CheckInv CheckSol Coeff C0Pivot C0_B2 C0_B2SM C1_B2 C1_B2SM C2_B2 C2_B2SM D E F FindKer FindSol FindZeroMaxMinors GaussDOD GaussTOD Generic GenericSymm Hankel Height Injection KFSM K2 LinRelMaxMinors LinRelMinors ListFirstNonZero ListFirstNonZeroPos MalDichHM MalDichHR MalDichVM MalDichVR Mal1DMD Mal1DMDRow Mal1DMDSM Mal1DMDSMRow Mal1Pivot Mats MaxMinors MaxMinorsLR MaxMinors_2 MM MMD MMS MultSM MyDet MyInv MyLinKer MyLinKerMin MyLinSol MyLinSolMin MyMinors MyMinorsLR MyMinors_2 MyMinorsLR_2 MyRank P PartialB2TMDMD PartialC0Pivot PartialPivot Pivot PosMinor Projection RandMatInt RandMatPoly RandMatPolyHom RunTest RunTestDet RunTestInv RunTestLinKer RunTestMinors RunTestRank RunTestTime RunTestTimeDet RunTestTimeInv RunTestTimeLinKer RunTestTimeMinors RunTestTimeRank Signum Subsets Toeplitz Update =============== A.5 VERZEICHNIS ALLER BEFEHLE =============== ============ GEORDNET NACH KAPITELN BZW. DATEIEN ============ Die Dateien *2.coc sind jeweils identisch mit den entsprechenden Dateien *.coc, bis auf die Tatsache, dass in ihnen die Division mit / statt mit DivAlg durchgefuehrt wird. *****Kapitel I: bareiss.coc, bareiss2.coc, helpbar.coc =====bareiss.coc, bareiss2.coc: -----Hauptprogramme GaussTOD B1TOD B1TMD B2TOD B2TMD B2TMDMD GaussDOD B1DOD B1DMD B2DOD B2DMD B2DMDMD -----Unterprogramme Pivot C0Pivot C0_B2 C1_B2 C2_B2 B1TODRow B1TODRow2Col B1TMDRow B1TMDRow2Col B2TODRow B2TMDRow B2TMDMDRow B1DODRow B1DODRow2Col B1DMDRow B1DMDRow2Col B2DODRow B2DMDRow B2DMDMDRow -----Kleine Programme ChangeRow ListFirstNonZeroPos ListFirstNonZero =====helpbar.coc: -----zugehoerige Online-Hilfe *****Kapitel II: mal.coc, mal2.coc, helpmal.coc =====mal.coc, mal2.coc: -----Hauptprogramme BackupDMD B1DMDFB B2DMDFB B2DMDMDFB Mal1DMD MalDichVM MalDichHM MalDichVR MalDichHR -----Unterprogramme Mal1Pivot Coeff BackupDMDRow Mal1DMDRow K2 AusrLUMat AusrROMat AusrLURow AusrRORow -----Kleine Programme BlockMat =====helpmal.coc: -----zugehoerige Online-Hilfe *****Kapitel III: sasaki.coc, helpsas.coc =====sasaki.coc: -----Hauptprogramme B1TMDSM B2TMDMDSM B1DMDSM B2DMDMDSM BackupDMDSM B1DMDSMFB B2DMDMDSMFB B1DMDFBSM B2DMDMDFBSM Mal1DMDSM -----Unterprogramme Injection Projection BackSubstTMD BackSubstDMD MultSM C0_B2SM C1_B2SM C2_B2SM KFSM B1TMDSMRow B1TMDSMRow2Col B2TMDMDSMRow B1DMDSMRow B2DMDMDSMRow BackupDMDSMRow Mal1DMDSMRow =====helpsas.coc -----zugehoerige Online-Hilfe *****Kapitel V: linalg.coc, helplin.coc =====linalg.coc: -----Hauptprogramme MyRank MyDet MyInv FindKer MyLinKer MyLinKerMin FindSol MyLinSol MyLinSolMin =====helplin.coc: -----zugehoerige Online-Hilfe *****Kapitel VI: minors.coc, minors2.coc, helpmin.coc =====minors.coc, minors2.coc: -----Hauptprogramme MaxMinors MaxMinorsLR MaxMinors_2 MyMinors MyMinorsLR MyMinors_2 MyMinorsLR_2 PartialB2TMDMD -----Unterprogramme Subsets AllSubsets PosMinor Signum FindZeroMaxMinors BackupMaxMinors BackupMaxMinorsRow LinRelMaxMinors LinRelMinors Update PartialPivot PartialC0Pivot -----Kleine Programme Height =====helpmin.coc: -----zugehoerige Online-Hilfe *****Kapitel IV: test.coc mata.coc, matdef.coc, matm.coc, matp.coc, helptest.coc =====test.coc: -----Hauptprogramme RunTest RunTestTime RunTestRank RunTestTimeRank RunTestDet RunTestTimeDet RunTestInv RunTestTimeInv RunTestLinKer RunTestTimeLinKer RunTestMinors RunTestTimeMinors CheckEq CheckInv CheckHomSol CheckSol Mats Alg RandMatInt RandMatPolyHom RandMatPoly Hankel Toeplitz Generic GenericSymm CatMat -----Beispielmatrizen =====matm.coc: MM MMS MMD =====matdef.coc: D E F =====matp.coc: P =====mata.coc: A AT ============ A.6 BEFEHLE IN ALPHABETISCHER REIHENFOLGE ============ Wird im folgenden bei den "BEISPIELEN" auf Packages verwiesen, so liegen dabei die Bezeichnungen aus Punkt A.2 zugrunde. Wie man diese Packages bzw. die entsprechenden Einzeldateien einliest, ist unter A.2 bzw. A.3 beschrieben. Unter dem Punkt "SIEHE AUCH" ist an erster Stelle stets die Datei genannt, in der sich die beschriebene Funktion befindet. Danach folgen Querverweise auf die sechs Kapitel dieser Arbeit und auf verwandte Eintraege im Manual. ============ A ============ SYNTAX A(N: INT): MAT wobei 1 <= N <= 17 ist. BESCHREIBUNG Diese Funktion ruft eine ganzzahlige NxM-Matrix mit N <= M ab. Vorher muss allerdings die Datei mata.coc eingelesen werden. BEISPIEL A(1); --vorher mata.coc einlesen Mat[ [1, 5, 1, 1, 5, 2, 5], [5, 4, 3, 5, 4, 2, 1], [3, 3, 3, 0, 4, 1, 0], [0, 5, 1, 1, 5, 4, 3], [1, 3, 4, 2, 3, 0, 1] ] ------------- A(17); Mat[ [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 3], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 2] ] ------------- SIEHE AUCH mata.coc, Manual A.1 bis A.3, A.5 AT ============ Alg ============ SYNTAX Alg(X: STRING): LIST wobei X einer der folgenden Strings sein kann: "TB", "TS", "T", "DB", "DM", "DBM", "DS", "D", "Dich", "MaxMinors, "MyMinors". BESCHREIBUNG Diese Funktion erzeugt die zur Abkuerzung X gehoerende Liste, naemlich fuer X = "TB" die Liste aller Bareiss-Trigonalisierungs-Verfahren mit Division [B1TMD,B2TMD,B2TMDMD], X = "TS" die Liste aller Sasaki-Trigonalisierungs-Verfahren mit Division [B1TMDSM,B2TMDMDSM], X = "T" die Liste aller Trigonalisierungs-Verfahren mit Division [B1TMD,B2TMD,B2TMDMD,B1TMDSM,B2TMDMDSM] = TB + TS, X = "DB" die Liste aller Bareiss-Diagonalisierungs-Verfahren mit Division [B1DMD,B2DMD,B2DMDMD], X = "DM" die Liste aller Malashonok-Verfahren ausser Dichotomie-Verfahren [Mal1DMD,B1DMDFB,B2DMDFB,B2DMDMDFB], X = "DBM" die Liste aller Bareiss-,Malashonok-Diagonalisierungs-Verfahren [B1DMD,B2DMD,B2DMDMD,Mal1DMD,B1DMDFB,B2DMDFB,B2DMDMDFB] = DB + DM, X = "DS" die Liste aller Sasaki-Diagonalisierungs-Verfahren [B1DMDSM,B2DMDMDSM,Mal1DMDSM,B1DMDSMFB,B2DMDMDSMFB,B1DMDFBSM,B2DMDMDFBSM], X = "D" die Liste aller DMD-Verfahren ausser Dichotomie-Verfahren [B1DMD,B2DMD,B2DMDMD,Mal1DMD,B1DMDFB,B2DMDFB,B2DMDMDFB,B1DMDSM,B2DMDMDSM, Mal1DMDSM,B1DMDSMFB,B2DMDMDSMFB,B1DMDFBSM,B2DMDMDFBSM] = DBM + DS, X = "Dich" die Liste aller Dichotomieverfahren [MalDichHR,MalDichVR,MalDichHM,MalDichVM], X = "MaxMinors" die Liste der Verfahren zur Berechnung maximaler Minoren [MaxMinors,MaxMinorsLR], X = "MyMinors" die Liste der Verfahren zur Berechnung beliebiger Minoren [MyMinors,MyMinorsLR,MyMinors_2,MyMinorsLR_2] Sie ist nuetzlich fuer die Funktionen RunTest*. BEISPIEL Use S::= Z/(32003)[vw]; RunTestTime([MM(4)],Alg("TB")); --bei Verwendung von Packages: T.RunTestTime([MM(4)],T.Alg("TB")); Matrix1: B1TMD(...) Cpu time = 3.30, User time = 1 B2TMD(...) Cpu time = 0.50, User time = 0 B2TMDMD(...) Cpu time = 0.60, User time = 0 ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 bareiss*.coc, mal*.coc, sasaki.coc, linalg.coc, minors*.coc ============ AllSubsets ============ SYNTAX AllSubsets(L: LIST, K: INT): LIST wobei L eine N-elementige Liste ist und wobei K <= N gilt. BESCHREIBUNG Diese Funktion gibt eine Liste von Listen aus, die alle K-elementigen Teilmengen von L darstellen. Fuer den Fall K <= 0 wird als Ergebnis [[ ]] ausgegeben. BEISPIEL AllSubsets(1..6,4); --bei Packages: LA.AllSubsets(1..6,4); [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 2, 5, 6], [1, 3, 4, 5], [1, 3, 4, 6], [1, 3, 5, 6], [1, 4, 5, 6], [2, 3, 4, 5], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6], [3, 4, 5, 6]] ------------- AllSubsets(1..6,-4); --bei Packages: LA.AllSubsets(1..6,-4); [[ ]] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 30.4 (AllSubsets) Bemerkung 30.6 (Implementierung von AllSubsets) ============ AT ============ SYNTAX AT(N: INT): MAT wobei 1 <= N <= 17 ist. BESCHREIBUNG Diese Funktion ruft eine ganzzahlige NxM-Matrix mit N >= M ab, die in allen Faellen die Transponierte der entsprechenden Matrix A(N) ist, ausser fuer N = 17. Vorher muss allerdings die Datei mata.coc eingelesen werden. BEISPIEL AT(1); --vorher mata.coc einlesen Mat[ [1, 5, 3, 0, 1], [5, 4, 3, 5, 3], [1, 3, 3, 1, 4], [1, 5, 0, 1, 2], [5, 4, 4, 5, 3], [2, 2, 1, 4, 0], [5, 1, 0, 3, 1] ] ------------- AT(17); Mat[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 3], [0, 0, 0, 0, 1], [0, 0, 0, 0, 2] ] ------------- SIEHE AUCH mata.coc, Manual A.1 bis A.3, A.5 A ============ AusrLUMat ============ SYNTAX AusrLUMat(A: MAT, KFLU: INT oder POLY, K: INT, K2: INT): LIST BESCHREIBUNG Diese Funktion berechnet die Teilmatrix (die Liste der Zeilenvektoren) der NxM-Matrix A in den Zeilen K+1..K2 und den Spalten 1..M neu, wenn im Laufe des Dichotomie-Verfahrens die vordere Teilmatrix in den Zeilen K+1..K2 und den Spalten 1..K ausgeraeumt wird. Sie dient als Unterfunktion fuer MalDichHM, MalDichVM. BEISPIEL A:= Mat[ [8, 0, 4, 6, -2, 4], [0, 8, 0, -4, 12, 0], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; B:= AusrLUMat(A,1,2,4); --bei Packages: B:= LA.AusrLUMat(A,1,2,4); B; [[0, 0, -8, 16, -24, 0], [0, 0, 8, 4, 4, 0]] ------------- BlockMat(A,3..4,1..6,B);--bei Packages: LA.BlockMat(A,3..4,1..6,B); Mat[ [8, 0, 4, 6, -2, 4], [0, 8, 0, -4, 12, 0], [0, 0, -8, 16, -24, 0], [0, 0, 8, 4, 4, 0] ] ------------- Mit der Funktion BlockMat laesst sich das Ergebnis von AusrLUMat in die Matrix schreiben. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 10.4 (MalDichHM, AusrLUMat) Satz 10.8 (MalDichVM) Bemerkung 10.10 (Implementierung von MalDichHM, MalDichVM) AusrLURow, AusrROMat, AusrRORow ============ AusrLURow ============ SYNTAX AusrLURow(A: MAT, I: INT, K: INT, KFLU: INT oder POLY): LIST BESCHREIBUNG Diese Funktion berechnet die I-te Zeile der NxM-Matrix A neu, wenn im Laufe des Dichotomie-Verfahrens die Spalten 1..K ausgeraeumt werden. Sie dient als Unterfunktion fuer MalDichHR, MalDichVR. BEISPIEL A:= Mat[ [8, 0, 4, 6, -2, 4], [0, 8, 0, -4, 12, 0], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; A[3]:= AusrLURow(A,3,2,1); --bei Packages: A[3]:= LA.AusrLURow(A,3,2,1); A[4]:= AusrLURow(A,4,2,1); --bei Packages: A[4]:= LA.AusrLURow(A,4,2,1); A; Mat[ [8, 0, 4, 6, -2, 4], [0, 8, 0, -4, 12, 0], [0, 0, -8, 16, -24, 0], [0, 0, 8, 4, 4, 0] ] ------------- Es sind in den unteren beiden Zeilen die Spalten 1 und 2 ausgeraeumt worden mit KFLU=1. Zum Ergebnis vergleiche das Beispiel zu AusrLUMat. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 10.2 (MalDichHR, AusrLURow) Satz 10.6 (MalDichVR) Bemerkung 10.10 (Implementierung von MalDichHR, MalDichVR) AusrLUMat, AusrROMat, AusrRORow ============ AusrROMat ============ SYNTAX AusrROMat(A: MAT, KFRO: INT oder POLY, K: INT, K2: INT): LIST BESCHREIBUNG Diese Funktion berechnet die Teilmatrix (die Liste der Zeilenvektoren) der NxM-Matrix A in den Zeilen 1..K und den Spalten 1..M neu, wenn im Laufe des Dichotomie-Verfahrens die mittlere Teilmatrix in den Zeilen 1..K und den Spalten K+1..K2 ausgeraeumt und die vordere Teilmatrix in den Zeilen 1..K und den Spalten 1..K diagonalisiert wird. Sie dient als Unterfunktion fuer MalDichHM, MalDichVM. BEISPIEL A:= Mat[ [8, 0, 4, 6, -2, 4], [0, 8, 0, -4, 12, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ]; B:= AusrROMat(A,8,2,4); --bei Packages: B:= LA.AusrROMat(A,8,2,4); B; [[-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0]] ------------- BlockMat(A,1..2,1..6,B);--bei Packages: LA.BlockMat(A,1..2,1..6,B); [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- Mit der Funktion BlockMat laesst sich das Ergebnis von AusrROMat in die Matrix schreiben. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 10.4 (MalDichHM, AusrROMat) Satz 10.8 (MalDichVM) Bemerkung 10.10 (Implementierung von MalDichHM, MalDichVM) AusrR0Row, AusrLUMat, AusrLURow ============ AusrRORow ============ SYNTAX AusrRORow(A: MAT, I: INT, K: INT, K2: INT, KFRO: INT oder POLY): LIST BESCHREIBUNG Diese Funktion berechnet die I-te Zeile der NxM-Matrix A neu, wenn im Laufe des Dichotomie-Verfahrens die Spalten K+1..K2 ausgeraeumt werden. Sie dient als Unterfunktion fuer MalDichHR, MalDichVR. BEISPIEL A:= Mat[ [8, 0, 4, 6, -2, 4], [0, 8, 0, -4, 12, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ]; A[1]:= AusrRORow(A,1,2,4,8); --bei Verwendung von Packages: A[1]:= LA.AusrRORow(A,1,2,4,8); A[2]:= AusrRORow(A,2,2,4,8); --bei Verwendung von Packages: A[2]:= LA.AusrRORow(A,2,2,4,8); A; [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- Es sind in den ersten beiden Zeilen die Spalten 3 und 4 ausgeraeumt worden mit KFRO=8. Zum Ergebnis vergleiche das Beispiel zu AusrROMat. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 10.2 (MalDichHR, AusrRORow) Satz 10.6 (MalDichVR) Bemerkung 10.10 (Implementierung von MalDichHR, MalDichVR) AusrROMat, AusrLUMat, AusrLURow ============ BackSubstDMD ============ SYNTAX BackSubstDMD(A: MAT, L: LIST): MAT wobei A eine NxM-Matrix ueber S[x[1..(N-2)]] ist und L eine Liste der Laenge N-2, deren Komponenten aus S stammen und fuer x[1] bis x[N-2] eingesetzt werden. BESCHREIBUNG Diese Funktion fuehrt an der Diagonalmatrix A die Ruecksubstitution anhand der Liste L aus, wobei der Diagonalkoeffizient nur ein einziges Mal berechnet zu werden braucht. Sie dient als Unterfunktion fuer die modifizierten Diagonalisierungs- Verfahren B1DMDSM, B2DMDMDSM, B1DMDFBSM, B2DMDMDFBSM, Mal1DMDSM. BEISPIEL Use S::= Q[x[1..3]]; L:= [2, -2, 0]; A:= Mat[ [2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 0, 0, 8x[2]x[3] - 18x[2] + 12x[3] - 36, 2x[2]x[3] - 4x[2] + 6x[3] - 18], [0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 0, -4x[1]x[3] + 8x[1] + 16x[3] - 36, -2x[1]x[3] + 4x[1] + 4x[3] - 8], [0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 2x[1]x[2] + 12x[1] - 36, 6x[1] - 12], [0, 0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, -2x[1]x[2] - 8x[2]x[3] - 12x[1] + 18x[2] - 12x[3] + 72, x[1]x[2]x[3] - 2x[1]x[2] - 2x[2]x[3] - 6x[1] + 4x[2] + 12] ]; BackSubstDMD(A,L); --bei Packages: LA.BackSubstDMD(A,L); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 14.2 (B1DMDSM) Satz 15.2 (B2DMDMDSM) Satz 16.3 (B1DMDSMFB, B2DMDMDSMFB) Satz 17.2 (Mal1DMDSM) ============ BackSubstTMD ============ SYNTAX BackSubstTMD(A: MAT, L: LIST): MAT wobei A eine NxM-Matrix ueber S[x[1..(N-2)]] ist und L eine Liste der Laenge N-2, deren Komponenten aus S stammen und fuer x[1] bis x[N-2] eingesetzt werden. BESCHREIBUNG Diese Funktion fuehrt an der Matrix A die Ruecksubstitution anhand der Liste L aus. Sie dient als Unterfunktion fuer die modifizierten Trigonalisierungs- Verfahren B1TMDSM, B2TMDMDSM. BEISPIEL Use S::= Q[x[1..3]]; L:= [2, -2, 0]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 0, x[1]x[2]x[3] + 6x[1] - 2x[2] + 12x[3] - 24, 2x[1]x[2] + 6x[1] + 12, x[1]x[2] + 6x[1] - 8x[2] - 48, x[1]x[2] + 6x[1] - 2x[2] - 12], [0, 0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, -2x[1]x[2] - 8x[2]x[3] - 12x[1] + 18x[2] - 12x[3] + 72, x[1]x[2]x[3] - 2x[1]x[2] - 2x[2]x[3] - 6x[1] + 4x[2] + 12] ]; BackSubstTMD(A,L); --bei Packages: LA.BackSubstTMD(A,L); Mat[ [2, 3, 1, 0, 4, 1], [0, 8, 0, -4, 12, 0], [0, 0, -8, 16, -24, 0], [0, 0, 0, -20, 20, 0] ] ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 12.2 (B1TMDSM) Satz 13.3 (B2TMDMDSM) ============ BackupDMD ============ SYNTAX BackupDMD(A: MAT): MAT wobei A eine beliebige Zeilenstufenmatrix ueber einem Integritaetsring ist, die mit einem Trigonalisierungsverfahren mit Division erzeugt worden ist. BESCHREIBUNG Diese Funktion diagonalisiert die Zeilenstufenmatrix A mit der Backup-Prozedur, indem von unten nach oben die Zeilen ausgeraeumt werden. Sie dient als Unterfunktion fuer B1DMDFB, B2DMDFB, B2DMDMDFB, B1DMDSMFB, B2DMDMDSMFB. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; A:= B1TMD(P); --bei Verwendung von Packages: A:= LA.B1TMD(P); A; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ] ------------- BackupDMD(A); --bei Verwendung von Packages: LA.BackupDMD(A); Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 7.5 (B1DMDFB, B2DMDFB, B2DMDMDFB, BackupRow) Bemerkung 7.7 (Implementierung von B1DMDFB, B2DMDFB, B2DMDMDFB) Satz 16.1 (B1DMDSMFB, B2DMDMDSMFB) Bemerkung 16.4 (Implementierung von B1DMDSMFB, B2DMDMDSMFB) B1DMDFB, B2DMDFB, B2DMDMDFB, B1DMDSMFB, B2DMDMDSMFB ============ BackupDMDRow ============ SYNTAX BackupDMDRow(A: MAT, J: LiST, K: INT, R: INT): LIST wobei A eine NxM-Matrix ist mit R = rang A, wobei K ein Zeilenindex aus 2..R und wobei J die Liste der Zeilenstufenindizes der ersten R Zeilen von A ist. BESCHREIBUNG Diese Funktion berechnet nach der Backup-Formel die (K-1)-te Zeile von A neu, wenn mit Hilfe der unteren Zeilen K..R die zugehoerigen Zeilenstufenspalten ausgeraeumt werden. BackupDMDRow dient als Unterfunktion fuer BackupDMD. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ]; J:= [1, 3, 4, 5]; P[3]:= BackupDMDRow(P,J,4,4); --bei Verwendung von Packages: P[3]:= LA.BackupDMDRow(P,J,4,4); P; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- P[2]:= BackupDMDRow(P,J,3,4); --bei Verwendung von Packages: P[2]:= LA.BackupDMDRow(P,J,3,4); P; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- Damit sind nacheinander die dritte und zweite Zeile diagonalisiert worden. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 7.5 (B1DMDFB, B2DMDFB, B2DMDMDFB, BackupRow) Bemerkung 7.7 (Implementierung von B1DMDFB, B2DMDFB, B2DMDMDFB) ============ BackupDMDSM ============ SYNTAX BackupDMDSM(A: MAT): MAT wobei A eine Zeilenstufenmatrix ueber einem Integritaetsring ist, die mit einem modifizierten Trigonalisierungsverfahren erzeugt worden ist und bei der die Ruecksubstitution noch nicht durchgefuehrt ist. BESCHREIBUNG Diese Funktion diagonalisiert die Zeilenstufenmatrix A mit der modifizierten Backup-Prozedur, indem von unten nach oben die Zeilen ausgeraeumt werden. Sie dient als Unterfunktion fuer B1DMDFBSM und B2DMDMDFBSM. BEISPIEL Use S::= Q[x[1..3]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 0, x[1]x[2]x[3] + 6x[1] - 2x[2] + 12x[3] - 24, 2x[1]x[2] + 6x[1] + 12, x[1]x[2] + 6x[1] - 8x[2] - 48, x[1]x[2] + 6x[1] - 2x[2] - 12], [0, 0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, -2x[1]x[2] - 8x[2]x[3] - 12x[1] + 18x[2] - 12x[3] + 72, x[1]x[2]x[3] - 2x[1]x[2] - 2x[2]x[3] - 6x[1] + 4x[2] + 12] ]; BackupDMDSM(A); --bei Verwendung von Packages: LA.BackupDMDSM(A); Mat[ [2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 0, 0, 8x[2]x[3] - 18x[2] + 12x[3] - 36, 2x[2]x[3] - 4x[2] + 6x[3] - 18], [0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 0, -4x[1]x[3] + 8x[1] + 16x[3] - 36, -2x[1]x[3] + 4x[1] + 4x[3] - 8], [0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 2x[1]x[2] + 12x[1] - 36, 6x[1] - 12], [0, 0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, -2x[1]x[2] - 8x[2]x[3] - 12x[1] + 18x[2] - 12x[3] + 72, x[1]x[2]x[3] - 2x[1]x[2] - 2x[2]x[3] - 6x[1] + 4x[2] + 12] ] ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 16.3 (B1DMDFBSM, B2DMDMDFBSM) Bemerkung 16.4 (Implementierung von B1DMDFBSM, B2DMDMDFBSM) BackupDMD ============ BackupDMDSMRow ============ SYNTAX BackupDMDSMRow(A: MAT, K: INT, N: INT): LIST wobei A eine NxM-Matrix und wobei K ein Zeilenindex aus 2..N ist. BESCHREIBUNG Diese Funktion berechnet nach der modifizierten Backup-Formel die (K-1)-te Zeile von A neu, wenn mit Hilfe der unteren Zeilen K..N die Spalten K..N ausgeraeumt werden. BackupDMDSMRow dient als Unterfunktion fuer BackupDMDSM. BEISPIEL Use S::= Q[x[1..3]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 0, x[1]x[2]x[3] + 6x[1] - 2x[2] + 12x[3] - 24, 2x[1]x[2] + 6x[1] + 12, x[1]x[2] + 6x[1] - 8x[2] - 48, x[1]x[2] + 6x[1] - 2x[2] - 12], [0, 0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, -2x[1]x[2] - 8x[2]x[3] - 12x[1] + 18x[2] - 12x[3] + 72, x[1]x[2]x[3] - 2x[1]x[2] - 2x[2]x[3] - 6x[1] + 4x[2] + 12] ]; A[3]:= BackupDMDSMRow(A,4,4); --bei Verwendung von Packages: A[3]:= LA.BackupDMDSMRow(A,4,4); A; Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 2x[1]x[2] + 12x[1] - 36, 6x[1] - 12], [0, 0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, -2x[1]x[2] - 8x[2]x[3] - 12x[1] + 18x[2] - 12x[3] + 72, x[1]x[2]x[3] - 2x[1]x[2] - 2x[2]x[3] - 6x[1] + 4x[2] + 12] ] ------------- A[2]:= BackupDMDSMRow(A,3,4); --bei Verwendung von Packages: A[2]:= LA.BackupDMDSMRow(A,3,4); A; Mat[ [x[1], 3, 1, 0, 4, 1], [0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 0, -4x[1]x[3] + 8x[1] + 16x[3] - 36, -2x[1]x[3] + 4x[1] + 4x[3] - 8], [0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 2x[1]x[2] + 12x[1] - 36, 6x[1] - 12], [0, 0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, -2x[1]x[2] - 8x[2]x[3] - 12x[1] + 18x[2] - 12x[3] + 72, x[1]x[2]x[3] - 2x[1]x[2] - 2x[2]x[3] - 6x[1] + 4x[2] + 12] ] ------------- A[1]:= BackupDMDSMRow(A,2,4); --bei Verwendung von Packages: A[1]:= LA.BackupDMDSMRow(A,2,4); A; Mat[ [2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 0, 0, 8x[2]x[3] - 18x[2] + 12x[3] - 36, 2x[2]x[3] - 4x[2] + 6x[3] - 18], [0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 0, -4x[1]x[3] + 8x[1] + 16x[3] - 36, -2x[1]x[3] + 4x[1] + 4x[3] - 8], [0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, 0, 2x[1]x[2] + 12x[1] - 36, 6x[1] - 12], [0, 0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, -2x[1]x[2] - 8x[2]x[3] - 12x[1] + 18x[2] - 12x[3] + 72, x[1]x[2]x[3] - 2x[1]x[2] - 2x[2]x[3] - 6x[1] + 4x[2] + 12] ] ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 16.3 (B1DMDFBSM, B2DMDMDFBSM) Bemerkung 16.4 (Implementierung von B1DMDFBSM, B2DMDMDFBSM) BackupDMDRow ============ BackupMaxMinors ============ SYNTAX BackupMaxMinors(B: MAT, Var L1: LIST, Var L2: LIST, L0: LIST): MAT wobei B die zu einer NxM-Matrix A aequivalente Zeilenstufenmatrix ist, die mit einem Trigonalisierungsverfahren mit Division erzeugt worden ist. Ausserdem ist L1 eine Liste von Listen, die N-elementige Teilmengen von 1..M darstellen. Die geordnete Liste L2 enthaelt maximale Minoren von A, und die Liste L0 enthaelt Spaltenindizes, deren zugehoerige Spalten in B gleich 0 sind. BESCHREIBUNG Diese Funktion streicht aus L1 die Listen, deren zugehoerige maximalen Minoren berechnet worden und in der Liste L2 an die richtige Position gebracht worden sind, wobei bei diesen Minoren keine Spalte aus L0 enthalten ist. Als Ergebnis wird ausserdem die zu B aequivalente, mit der Backup-Prozedur hergestellte Diagonalmatrix ausgegeben. BEISPIEL B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ]; L1:= AllSubsets(1..6,4); --bei Packages: L1:= LA.AllSubsets(1..6,4); L1; [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 2, 5, 6], [1, 3, 4, 5], [1, 3, 4, 6], [1, 3, 5, 6], [1, 4, 5, 6], [2, 3, 4, 5], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6], [3, 4, 5, 6]] ------------- L0:= [ ]; L2:= NewList(Len(L1),0); BackupMaxMinors(B,L1,L2,L0); --bei Verwendung von Packages: LA.BackupMaxMinors(B,L1,L2,L0); Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- L1; [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 2, 5, 6], [1, 3, 4, 6], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6]] ------------- L2; [0, 0, 0, 0, 0, 0, -20, 0, 20, -20, -10, 0, 0, 0, 0] ------------- Nun setzt man die fuenfte Spalte gleich 0 und wiederholt die Prozedur: ------------- B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, 0, 12], [0, 0, 0, -8, 0, -24], [0, 0, 0, 0, 0, 20] ]; L0:= [5]; BackupMaxMinors(B,L1,L2,L0); --bei Verwendung von Packages: LA.BackupMaxMinors(B,L1,L2,L0); Mat[ [20, 10, 0, 0, 0, 0], [0, 0, 20, 0, 0, 0], [0, 0, 0, 20, 0, 0], [0, 0, 0, 0, 0, 20] ] ------------- L1; [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 2, 5, 6], [2, 3, 5, 6], [2, 4, 5, 6]] ------------- L2; [0, 0, 0, 0, 0, 0, -20, 20, 20, -20, -10, 10, 0, 0, 0] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 32.2 (BackupMaxMinors) Bemerkung 32.4 (Implementierung von BackupMaxMinors) BackupDMD ============ BackupMaxMinorsRow ============ SYNTAX BackupMaxMinorsRow(B: MAT, J: LIST, K: INT, Var L1: LIST, Var L2: LIST, L0: LIST): LIST wobei B eine zu einer NxM-Matrix A aequivalente Matrix ist mit rang B = N, wobei K ein Zeilenindex aus 2..N und wobei J die Liste der N Zeilenstufenindizes von B ist. Ausserdem ist L1 eine Liste von Listen, die N-elementige Teilmengen von 1..M darstellen, die geordnete Liste L2 enthaelt maximale Minoren von A, und die Liste L0 enthaelt Spaltenindizes, deren zugehoerige Spalten in B gleich 0 sind. BESCHREIBUNG Diese Funktion berechnet nach der Backup-Formel die (K-1)-te Zeile von A neu, wenn mit Hilfe der unteren Zeilen K..N die zugehoerigen Zeilenstufenspalten ausgeraeumt werden. Dabei werden aus L1 die Listen, deren zugehoerige maximalen Minoren berechnet worden und in der Liste L2 an die richtige Position gebracht worden sind, gestrichen, wobei bei diesen Minoren keine Spalte aus L0 enthalten ist. BackupMaxMinorsRow dient als Unterfunktion fuer BackupMaxMinors. BEISPIEL B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ]; J:= [1,3,4,5]; L1:= AllSubsets(1..6,4); --bei Packages: L1:= LA.AllSubsets(1..6,4); L1; [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 2, 5, 6], [1, 3, 4, 5], [1, 3, 4, 6], [1, 3, 5, 6], [1, 4, 5, 6], [2, 3, 4, 5], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6], [3, 4, 5, 6]] ------------- L0:= [ ]; L2:= NewList(Len(L1),0); B[3]:= BackupMaxMinorsRow(B,J,4,L1,L2,L0); --bei Verwendung von Packages: B[3]:= LA.BackupMaxMinorsRow(B,J,4,L1,L2,L0); B; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- L1; [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 2, 5, 6], [1, 3, 4, 5], [1, 3, 4, 6], [1, 4, 5, 6], [2, 3, 4, 5], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6], [3, 4, 5, 6]] ------------- L2; [0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0] ------------- B[2]:= BackupMaxMinorsRow(B,J,3,L1,L2,L0); --bei Verwendung von Packages: B[2]:= LA.BackupMaxMinorsRow(B,J,3,L1,L2,L0); B; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- L1; [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 2, 5, 6], [1, 3, 4, 5], [1, 3, 4, 6], [2, 3, 4, 5], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6], [3, 4, 5, 6]] ------------- L2; [0, 0, 0, 0, 0, 0, 0, 0, 20, -20, 0, 0, 0, 0, 0] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 32.2 (BackupMaxMinors) Bemerkung 32.4 (Implementierung von BackupMaxMinors) BackupMaxMinors BackupDMDRow ============ BlockMat ============ SYNTAX BlockMat(A: MAT, L1: LIST ,L2: LIST, B: MAT oder LIST): MAT wobei A eine beliebige NxM-Materix ist mit Len(L1) <= N und Len(L2) <= M und wobei die Komponenten von L1 aus 1..N und die Komponenten von L2 aus 1..M stammen. Ausserdem ist B eine Len(L1) x Len(L2)-Matrix oder eine entsprechende Liste von Zeilenvektoren. BESCHREIBUNG Diese Funktion ersetzt in der Matrix A die Teilmatrix mit Zeilen aus L1 und Spalten aus L2 durch B. BEISPIEL A:= Mat[ [8, 0, 4, 6, -2, 4], [0, 8, 0, -4, 12, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ]; B:= [[-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0]]; BlockMat(A,1..2,1..6,B); --bei Verwendung von Packages: LA.BlockMat(A,1..2,1..6,B); [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 ============ B1DMD ============ SYNTAX B1DMD(A: MAT): MAT B1DMD(A: MAT, KF: INT oder POLY): MAT B1DMD(A: MAT, KF: INT oder POLY, E: OBJECT): MAT oder BOOL wobei A eine beliebige Matrix ueber einem Integritaetsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-1-Schritt- Verfahren mit Division eine zu A aequivalente Diagonalmatrix. Die beiden anderen Faelle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, naemlich von den Dichotomie- Verfahren MalDich* (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird fuer die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgefuehrt bzw. es wird das Abbruchkriterium FALSE ausgegeben, falls rang A nicht maximal ist. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B1DMD(P); --bei Verwendung von Packages: LA.B1DMD(P); Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; B1DMD(A); --bei Verwendung von Packages: LA.B1DMD(A); Mat[ [-8, -4, 0, 0], [0, 0, -8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- B1DMD(A,1,"MyInv"); --bei Packages: LA.B1DMD(A,1,"MyInv"); FALSE ------------- MyInv(A,B1DMD); --bei Packages: LA.MyInv(A,B1DMD); Die Matrix ist nicht invertierbar. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 5.6 (B1DMD, B1DMDRow) Bemerkung 5.9 (Implementierung von B1DMD) Abschnitt 10 (MalDich*) Satz 26.1 (MyDet) Satz 27.3 (MyInv) ============ B1DMDFB ============ SYNTAX B1DMDFB(A: MAT): MAT B1DMDFB(A: MAT, KF: POLY oder INT): MAT B1DMDFB(A: MAT, KF: POLY oder INT, E: OBJECT): MAT oder BOOL wobei A eine beliebige Matrix ueber einem Integritaetsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Forward-Backup- Verfahren mit Division eine zu A aequivalente Diagonalmatrix, wobei die Trigonalisierung mit B1TMD vorgenommen wird. Die beiden anderen Faelle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, naemlich von den Dichotomie- Verfahren MalDich* (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird fuer die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgefuehrt bzw. es wird das Abbruchkriterium FALSE ausgegeben, falls rang A nicht maximal ist. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B1DMDFB(P); --bei Verwendung von Packages: LA.B1DMDFB(P); Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; B1DMDFB(A); --bei Verwendung von Packages: LA.B1DMDFB(A); Mat[ [-8, -4, 0, 0], [0, 0, -8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- B1DMDFB(A,1,"MyInv"); --bei Packages: LA.B1DMDFB(A,1,"MyInv"); FALSE ------------- MyInv(A,B1DMDFB); --bei Packages: LA.MyInv(A,B1DMDFB); Die Matrix ist nicht invertierbar. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 7.5 (B1DMDFB, BackupRow) Bemerkung 7.7 (Implementierung von B1DMDFB) B1TMD, BackupDMD ============ B1DMDFBSM ============ SYNTAX B1DMDFBSM(A: MAT): MAT B1DMDFBSM(A: MAT, E1: OBJECT, E2: OBJECT): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Faellen berechnet diese Funktion nach dem Forward-Backup-Verfahren eine zu A aequivalente Diagonalmatrix, wobei die Trigonalisierung mit dem modifizierten Bareiss-1-Schritt-Verfahren und die Backup-Prozedur mit dem modifizierten Backup-Verfahren BackupDMDSM durchgefuehrt wird. Der zweite Fall tritt nur auf, wenn B1DMDFBSM intern von anderen Funktionen aufgerufen wird, naemlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb noetig, weil MyDet und MyInv stets Trigonalisierungs- oder Diagonalisierungsverfahren mit drei Argumenten verwenden. BEISPIEL A:= Mat[ [2, 3, 1, 0, 4, 1], [-4, -2, -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; B1DMDFBSM(A); --bei Verwendung von Packages: LA.B1DMDFBSM(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; B1DMDFBSM(B); --bei Verwendung von Packages: LA.B1DMDFBSM(B); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- B1DMDFBSM(B,1,"MyDet"); --bei Packages: LA.B1DMDFBSM(B,1,"MyDet"); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- MyDet(B,B1DMDFBSM); --bei Packages: LA.MyDet(B,B1DMDFBSM); -20 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 16.3 (B1DMDFBSM) Bemerkung 16.4 (Implementierung von B1DMDFBSM) Satz 26.1 (MyDet) Satz 27.3 (MyInv) B1DMDFB ============ B1DMDRow ============ SYNTAX B1DMDRow(A: MAT, I:INT, J: INT, K: INT, KF: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus 1..N mit I <> K ist, wobei K ein Zeilenindex aus 1..N und J ein Spaltenindex aus 1..M ist und wobei KF <> 0 der Zeilenstufenkoeffizient der Vorgaengerzeile (K-1) ist. (KF=1 fuer K=1.) BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-1-Schritt-Formel mit Division durch KF die ober- oder unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Diagonalisierung mit Hilfe der K-ten Zeile die J-te Spalte ausgeraeumt wird. Sie dient als Unterfunktion fuer B1DMD und auch fuer B2DMD, B2DMDMD. BEISPIEL A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ]; KF:= 2; A[1]:= B1DMDRow(A,1,3,2,KF); --bei Packages: A[1]:= LA.B1DMDRow(A,1,3,2,KF); A[4]:= B1DMDRow(A,4,3,2,KF); --bei Packages: A[4]:= LA.B1DMDRow(A,4,3,2,KF); A; Mat[ [8, 4, 0, 4, 6, -2], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, 0, 8, 4, 4] ] ------------- Hier wird in der ersten und vierten Zeile mit Hilfe der zweiten Zeile die dritte Spalte ausgeraeumt. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 5.6 (B1DMD, B1DMDRow) B2DMD, B2DMDMD ============ B1DMDRow2Col ============ SYNTAX B1DMDRow2Col(A: MAT, I: INT, J: INT, K: INT, Det: INT oder POLY, KF: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus 1..N mit I <> K ist, wobei K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) und wobei KF <> 0 der Zeilenstufenkoeffizient der Vorgaengerzeile (K-1) ist. (KF=1 fuer K=1.) Ferner ist Det = C0/KF, wobei man C0 mit C0Pivot(A,J,K) erhaelt. BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-1-Schritt-Formel mit Division durch KF die ober- oder unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Diagonalisierung mit Hilfe der K-ten Zeile die J-te Spalte ausgeraeumt wird. Dabei wird ausserdem der Koeffizient A[I,J+1] = Det gesetzt. B1DMDRow2Col dient als Unterfunktion fuer B2DMD, B2DMDMD. BEISPIEL A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ]; C0Pivot(A,3,2); --bei Verwendung von Packages: LA.C0Pivot(A,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6], ], 16] ------------- C0:= 16; KF:= 2; Det:= C0 / KF; A[3]:= B1DMDRow2Col(A,3,3,2,Det,KF); --bei Verwendung von Packages A[3]:= LA.B1DMDRow2Col(A,3,3,2,Det,KF); A; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, 8, 4, 4], [0, 0, 0, -2, 4, -6] ] ------------- Hier ist in der dritten Zeile mit Hilfe der zweiten Zeile die dritte Spalte ausgeraeumt worden. Dabei wird der vierte Koeffizient nicht mehr berechnet, sondern gleich Det gesetzt. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 6.8 (Implementierung von B2DOD, B2DMD, B2DMDMD) B1DMDRow C0Pivot B1DODRow2Col B2DMD, B2DMDMD ============ B1DMDSM ============ SYNTAX B1DMDSM(A: MAT): MAT B1DMDSM(A: MAT, E1: OBJECT, E2: OBJECT): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Faellen berechnet diese Funktion nach dem modifizierten Bareiss-1-Schritt-Verfahren eine zu A aequivalente Diagonalmatrix. Der zweite Fall tritt nur auf, wenn B1DMDSM intern von anderen Funktionen aufgerufen wird, naemlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb noetig, weil MyDet und MyInv stets Trigonalisierungs- oder Diagonalisierungsverfahren mit drei Argumenten verwenden. BEISPIEL A:= Mat[ [2, 3, 1, 0, 4, 1], [-4, -2, -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; B1DMDSM(A); --bei Verwendung von Packages: LA.B1DMDSM(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; B1DMDSM(B); --bei Verwendung von Packages: LA.B1DMDSM(B); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- B1DMDSM(B,1,"MyDet"); --bei Packages: LA.B1DMDSM(B,1,"MyDet"); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- MyDet(B,B1DMDSM); --bei Packages: LA.MyDet(B,B1DMDSM); -20 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 14.2 (B1DMDSM, B1DMDSMRow) Bemerkung 14.3 (Implementierung von B1DMDSM) Satz 26.1 (MyDet) Satz 27.3 (MyInv) B1DMD ============ B1DMDSMFB ============ SYNTAX B1DMDSMFB(A: MAT): MAT B1DMDSMFB(A: MAT, E1: OBJECT, E2: OBJECT): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Faellen berechnet diese Funktion nach dem Forward-Backup-Verfahren eine zu A aequivalente Diagonalmatrix, wobei die Trigonalisierung mit dem modifizierten Verfahren B1TMDSM und die Backup-Prozedur mit dem herkoemmlichen Verfahren BackupDMD durchgefuehrt wird. Der zweite Fall tritt nur auf, wenn B1DMDSMFB intern von anderen Funktionen aufgerufen wird, naemlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb noetig, weil MyDet und MyInv stets Trigonalisierungs- oder Diagonalisierungsverfahren mit drei Argumenten verwenden. BEISPIEL A:= Mat[ [2, 3, 1, 0, 4, 1], [-4, -2, -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; B1DMDSMFB(A); --bei Verwendung von Packages: LA.B1DMDSMFB(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; B1DMDSMFB(B); --bei Verwendung von Packages: LA.B1DMDSMFB(B); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- B1DMDSMFB(B,1,"MyDet"); --bei Packages: LA.B1DMDSMFB(B,1,"MyDet"); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- MyDet(B,B1DMDSMFB); --bei Packages: LA.MyDet(B,B1DMDSMFB); -20 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 16.1 (B1DMDSMFB) Bemerkung 16.4 (Implementierung von B1DMDSMFB) Satz 26.1 (MyDet) Satz 27.3 (MyInv) B1DMDFB ============ B1DMDSMRow ============ SYNTAX B1DMDSMRow(A: MAT, I:INT, K: INT, KF: POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus 1..N mit I <> K ist, wobei K ein Zeilenindex aus 1..N und wobei KF = KFSM(A,K-1) <> 0 ist. (KF=1 fuer K=1.) BESCHREIBUNG Diese Funktion berechnet nach der modifizierten Bareiss-1-Schritt-Formel die ober- oder unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Diagonalisierung mit Hilfe der K-ten Zeile die K-te Spalte ausgeraeumt wird. Sie dient als Unterfunktion fuer B1DMDSM und auch fuer B2DMDMDSM, B1DMDFBSM, B2DMDMDFBSM. BEISPIEL Use S::= Q[x[1..3]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 3x[1] - 6, -2, x[1]x[3], x[1] - 8, x[1] - 2], [0, -6, 2x[1] - 2, 2x[1], -8, x[1] - 2] ]; KF:= KFSM(A,1); --bei Verwendung von Packages: KF:= LA.KFSM(A,1); KF; x[1] ------------- A[1]:= B1DMDSMRow(A,1,2,KF); --bei Verwendung von Packages: A[1]:= LA.B1DMDSMRow(A,1,2,KF); A[3]:= B1DMDSMRow(A,3,2,KF); --bei Verwendung von Packages: A[3]:= LA.B1DMDSMRow(A,3,2,KF); A[4]:= B1DMDSMRow(A,4,2,KF); --bei Verwendung von Packages: A[4]:= LA.B1DMDSMRow(A,4,2,KF); A; Mat[ [x[1]x[2] + 12, 0, x[2] + 6, 6, 4x[2] + 6, x[2] + 6], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 0, 6x[1] - 2x[2] - 24, x[1]x[2]x[3] + 6x[1] + 12x[3] - 12, x[1]x[2] + 6x[1] - 8x[2] - 48, x[1]x[2] + 6x[1] - 2x[2] - 12], [0, 0, 2x[1]x[2] - 2x[2] + 12, 2x[1]x[2] + 12, -8x[2] - 12, x[1]x[2] - 2x[2]] ] ------------- Damit ist mit Hilfe der zweiten Zeile in den Zeilen 1, 3, 4 die zweite Spalte ausgeraeumt. ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 14.2 (B1DMDSM, B1DMDSMRow) B1DMDRow ============ B1DOD ============ SYNTAX B1DOD(A: MAT): MAT wobei A eine beliebige Matrix ueber einem Integritaetsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A aequivalente Diagonalmatrix aus, die mit dem Bareiss-1-Schritt-Verfahren ohne Division (Gauss-Eliminationsverfahren) erzeugt wird. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B1DOD(P); --bei Verwendung von Packages: LA.B1DOD(P); Mat[ [2560, 1280, 0, 0, 0, 0], [0, 0, -640, 0, 0, -640], [0, 0, 0, 160, 0, 160], [0, 0, 0, 0, -80, 80] ] ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 5.8 (B1DOD, B1DODRow) ============ B1DODRow ============ SYNTAX B1DODRow(A: MAT, I:INT, J: INT, K: INT): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus 1..N mit I <> K ist, wobei K ein Zeilenindex aus 1..N und J ein Spaltenindex aus 1..M ist. BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-1-Schritt-Formel ohne Division die ober- oder unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Diagonalisierung mit Hilfe der K-ten Zeile die J-te Spalte ausgeraeumt wird. Sie dient als Unterfunktion fuer B1DOD und auch fuer eine andere Unterfunktion, naemlich B1DMDRow. BEISPIEL A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ]; A[1]:= B1DODRow(A,1,3,2); --bei Packages: A[1]:= LA.B1DODRow(A,1,3,2); A[4]:= B1DODRow(A,4,3,2); --bei Packages: A[4]:= LA.B1DODRow(A,4,3,2); A; Mat[ [16, 8, 0, 8, 12, -4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, 0, 16, 8, 8] ] ------------- Hier ist in der ersten und vierten Zeile mit Hilfe der zweiten Zeile die dritte Spalte ausgeraeumt worden. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 5.8 (B1DOD, B1DODRow) ============ B1DODRow2Col ============ SYNTAX B1DODRow2Col(A: MAT, I:INT, J: INT, K: INT, C0: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus 1..N mit I <> K ist, wobei K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist. Ferner stammt C0 aus dem Ergebnis von C0Pivot(A,J,K). BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-1-Schritt-Formel ohne Division die ober- oder unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Diagonalisierung mit Hilfe der K-ten Zeile die J-te Spalte ausgeraeumt wird. Dabei wird ausserdem der Koeffizient A[I,J+1] = C0 gesetzt. B1DODRow2Col dient als Unterfunktion fuer B2DOD und auch fuer eine andere Unterfunktion, naemlich B1DMDRow2Col. BEISPIEL A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ]; C0Pivot(A,3,2); --bei Verwendung von Packages: LA.C0Pivot(A,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ], 16] ------------- C0:= 16; A[3]:= B1DODRow2Col(A,3,3,2,C0); --bzw. A[3]:= LA.B1DODRow2Col(A,3,3,2,C0); A; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, 16, 8, 8], [0, 0, 0, -2, 4, -6] ] ------------- Hier ist in der dritten Zeile mit Hilfe der zweiten Zeile die dritte Spalte ausgeraeumt worden. Dabei wird der vierte Koeffizient nicht mehr berechnet, sondern gleich C0 gesetzt. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 6.8 (Implementierung von B2DOD, B2DMD,B2DMDMD) B1DODRow B1DMDRow2Col C0Pivot ============ B2DMD ============ SYNTAX B2DMD(A: MAT): MAT B2DMD(A: MAT, KF: INT oder POLY): MAT B2DMD(A: MAT, KF: INT oder POLY, E: OBJECT): MAT oder BOOL wobei A eine beliebige Matrix ueber einem Integritaetsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-2-Schritt- Verfahren mit Division eine zu A aequivalente Diagonalmatrix. Die beiden anderen Faelle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, naemlich von den Dichotomie- Verfahren MalDich* (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird fuer die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgefuehrt bzw. es wird das Abbruchkriterium FALSE ausgegeben, falls rang A nicht maximal ist. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B2DMD(P); --bei Verwendung von Packages: LA.B2DMD(P); Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; B2DMD(A); --bei Verwendung von Packages: LA.B2DMD(A); Mat[ [-8, -4, 0, 0], [0, 0, -8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- B2DMD(A,1,"MyInv"); --bei Packages: LA.B2DMD(A,1,"MyInv"); FALSE ------------- MyInv(A,B2DMD); --bei Packages: LA.MyInv(A,B2DMD); Die Matrix ist nicht invertierbar. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 6.3 (B2DMD, B2DMDRow) Bemerkung 6.8 (Implementierung von B2DMD) Abschnitt 10 (MalDich*) Satz 26.1 (MyDet) Satz 27.3 (MyInv) ============ B2DMDFB ============ SYNTAX B2DMDFB(A: MAT): MAT B2DMDFB(A: MAT, KF: POLY oder INT): MAT B2DMDFB(A: MAT, KF: POLY oder INT, E: OBJECT): MAT oder BOOL wobei A eine beliebige Matrix ueber einem Integritaetsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Forward-Backup- Verfahren mit Division eine zu A aequivalente Diagonalmatrix, wobei die Trigonalisierung mit B2TMD vorgenommen wird. Die beiden anderen Faelle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, naemlich von den Dichotomie- Verfahren MalDich* (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird fuer die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgefuehrt bzw. es wird das Abbruchkriterium FALSE ausgegeben, falls rang A nicht maximal ist. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B2DMDFB(P); --bei Verwendung von Packages: LA.B2DMDFB(P); Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; B2DMDFB(A); --bei Verwendung von Packages: LA.B2DMDFB(A); Mat[ [-8, -4, 0, 0], [0, 0, -8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- B2DMDFB(A,1,"MyInv"); --bei Packages: LA.B2DMDFB(A,1,"MyInv"); FALSE ------------- MyInv(A,B2DMDFB); --bei Packages: LA.MyInv(A,B2DMDFB); Die Matrix ist nicht invertierbar. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 7.5 (B2DMDFB, BackupRow) Bemerkung 7.7 (Implementierung von B2DMDFB) B2TMD, BackupDMD ============ B2DMDMD ============ SYNTAX B2DMDMD(A: MAT): MAT B2DMDMD(A: MAT, KF: INT oder POLY): MAT B2DMDMD(A: MAT, KF: INT oder POLY, E: OBJECT): MAT oder BOOL wobei A eine beliebige Matrix ueber einem Integritaetsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-2-Schritt- Verfahren mit Division eine zu A aequivalente Diagonalmatrix. Dabei werden, statt wie bei B2DMD einmal durch einen quadrierten Teiler zu dividieren, zweimal die entsprechenden Zwischenergebnisse dividiert. Die beiden anderen Faelle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, naemlich von den Dichotomie- Verfahren MalDich* (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird fuer die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgefuehrt bzw. es wird das Abbruchkriterium FALSE ausgegeben, falls rang A nicht maximal ist. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B2DMDMD(P); --bei Verwendung von Packages: LA.B2DMDMD(P); Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; B2DMDMD(A); --bei Verwendung von Packages: LA.B2DMDMD(A); Mat[ [-8, -4, 0, 0], [0, 0, -8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- B2DMDMD(A,1,"MyInv"); --bei Packages: LA.B2DMDMD(A,1,"MyInv"); FALSE ------------- MyInv(A,B2DMDMD); --bei Packages: LA.MyInv(A,B2DMDMD); Die Matrix ist nicht invertierbar. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 6.6 (B2DMDMD, B2DMDMDRow) Bemerkung 6.8 (Implementierung von B2DMDMD) Abschnitt 10 (MalDich*) Satz 26.1 (MyDet) Satz 27.3 (MyInv) B2DMD ============ B2DMDMDFB ============ SYNTAX B2DMDMDFB(A: MAT): MAT B2DMDMDFB(A: MAT, KF: POLY oder INT): MAT B2DMDMDFB(A: MAT, KF: POLY oder INT, E: OBJECT): MAT oder BOOL wobei A eine beliebige Matrix ueber einem Integritaetsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Forward-Backup- Verfahren mit Division eine zu A aequivalente Diagonalmatrix, wobei die Trigonalisierung mit B2TMDMD vorgenommen wird. Die beiden anderen Faelle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, naemlich von den Dichotomie- Verfahren MalDich* (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird fuer die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgefuehrt bzw. es wird das Abbruchkriterium FALSE ausgegeben, falls rang A nicht maximal ist. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B2DMDMDFB(P); --bei Verwendung von Packages: LA.B2DMDMDFB(P); Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; B2DMDMDFB(A); --bei Verwendung von Packages: LA.B2DMDMDFB(A); Mat[ [-8, -4, 0, 0], [0, 0, -8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- B2DMDMDFB(A,1,"MyInv"); --bei Packages: LA.B2DMDMDFB(A,1,"MyInv"); FALSE ------------- MyInv(A,B2DMDMDFB); --bei Packages: LA.MyInv(A,B2DMDMDFB); Die Matrix ist nicht invertierbar. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 7.5 (B2DMDMDFB, BackupRow) Bemerkung 7.7 (Implementierung von B2DMDMDFB) B2TMDMD, BackupDMD ============ B2DMDMDFBSM ============ SYNTAX B2DMDMDFBSM(A: MAT): MAT B2DMDMDFBSM(A: MAT, E1: OBJECT, E2: OBJECT): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Faellen berechnet diese Funktion nach dem Forward-Backup-Verfahren eine zu A aequivalente Diagonalmatrix, wobei die Trigonalisierung mit dem modifizierten Bareiss-2-Schritt-Verfahren und die Backup-Prozedur mit dem modifizierten Verfahren BackupDMDSM durchgefuehrt wird. Der zweite Fall tritt nur auf, wenn B2DMDMDFBSM intern von anderen Funktionen aufgerufen wird, naemlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb noetig, weil MyDet und MyInv stets Trigonalisierungs- oder Diagonalisierungsverfahren mit drei Argumenten verwenden. BEISPIEL A:= Mat[ [2, 3, 1, 0, 4, 1], [-4, -2, -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; B2DMDMDFBSM(A); --bei Verwendung von Packages: LA.B2DMDMDFBSM(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; B2DMDMDFBSM(B); --bei Verwendung von Packages: LA.B2DMDMDFBSM(B); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- B2DMDMDFBSM(B,1,"MyDet");--bei Packages: LA.B2DMDMDFBSM(B,1,"MyDet"); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- MyDet(B,B2DMDMDFBSM); --bei Packages: LA.MyDet(B,B2DMDMDFBSM); -20 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 16.3 (B2DMDMDFBSM) Bemerkung 16.4 (Implementierung von B2DMDMDFBSM) Satz 26.1 (MyDet) Satz 27.3 (MyInv) B2DMDMDFB ============ B2DMDMDRow ============ SYNTAX B2DMDMDRow(A: MAT, I:INT, J: INT, K: INT, KF: INT oder POLY, Det: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus 1..N mit I <> K, K+1 ist, wobei K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist. Ausserdem ist KF <> 0 der Zeilenstufenkoeffizient der Vorgaengerzeile (K-1) mit KF=1 fuer K=1. Ferner gilt Det=C0 / KF, wobei C0 aus dem Ergebnis von C0Pivot(A,J,K) stammt. BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-2-Schritt-Formel mit zweimaliger Division durch KF die oberhalb der K-ten Zeile oder unterhalb der K+1-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Diagonalisierung mit Hilfe der K-ten, (K+1)-ten Zeile die J-te, (J+1)-te Spalte ausgeraeumt werden. B2DMDMDRow dient als Unterfunktion fuer B2DMDMD. BEISPIEL B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ]; C0Pivot(B,3,2); --bei Verwendung von Packages: LA.C0Pivot(B,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ], 16] ------------- C0:= 16; KF:= 2; Det:= C0 / KF; B[4]:= B2DMDMDRow(B,4,3,2,KF,Det); --bei Verwendung von Packages: B[4]:= LA.B2DMDMDRow(B,4,3,2,KF,Det); B[1]:= B2DMDMDRow(B,1,3,2,KF,Det); --bei Verwendung von Packages: B[1]:= LA.B2DMDMDRow(B,1,3,2,KF,Det); B; Mat[ [8, 4, 0, 0, 4, -4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, 0, 20, -20] ] ------------- Raeumt man in der ersten und vierten Zeile mit Hilfe der zweiten, dritten Zeile die Spalten 3 und 4 aus, so erhaelt man das angegebene Ergebnis mit der Bareiss-2-Schritt-Formel unter Verwendung von Det=C0/KF. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 6.6 (B2DMDMD, B2DMDMDRow) Bemerkung 6.8 (Implementierung von B2DOD, B2DMD, B2DMDMD) ============ B2DMDMDSM ============ SYNTAX B2DMDMDSM(A: MAT): MAT B2DMDMDSM(A: MAT, E1: OBJECT, E2: OBJECT): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Faellen berechnet diese Funktion nach dem modifizierten Bareiss-2-Schritt-Verfahren eine zu A aequivalente Diagonalmatrix. Der zweite Fall tritt nur auf, wenn B2DMDMDSM intern von anderen Funktionen aufgerufen wird, naemlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb noetig, weil MyDet und MyInv stets Trigonalisierungs- oder Diagonalisierungsverfahren mit drei Argumenten verwenden. BEISPIEL A:= Mat[ [2, 3, 1, 0, 4, 1], [-4, -2, -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; B2DMDMDSM(A); --bei Verwendung von Packages: LA.B2DMDMDSM(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; B2DMDMDSM(B); --bei Verwendung von Packages: LA.B2DMDMDSM(B); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- B2DMDMDSM(B,1,"MyDet"); --bei Packages: LA.B2DMDMDSM(B,1,"MyDet"); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- MyDet(B,B2DMDMDSM); --bei Packages: LA.MyDet(B,B2DMDMDSM); -20 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 15.2 (B2DMDMDSM, B2DMDMDSMRow) Bemerkung 15.3 (Implementierung von B2DMDMDSM) Satz 26.1 (MyDet) Satz 27.3 (MyInv) B2DMDMD ============ B2DMDMDSMFB ============ SYNTAX B2DMDMDSMFB(A: MAT): MAT B2DMDMDSMFB(A: MAT, E1: OBJECT, E2: OBJECT): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Faellen berechnet diese Funktion nach dem Forward-Backup-Verfahren eine zu A aequivalente Diagonalmatrix, wobei die Trigonalisierung mit dem modifizierten Verfahren B2TMDMDSM und die Backup-Prozedur mit dem herkoemmlichen Verfahren BackupDMD durchgefuehrt wird. Der zweite Fall tritt nur auf, wenn B2DMDMDSMFB intern von anderen Funktionen aufgerufen wird, naemlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb noetig, weil MyDet und MyInv stets Trigonalisierungs- oder Diagonalisierungsverfahren mit drei Argumenten verwenden. BEISPIEL A:= Mat[ [2, 3, 1, 0, 4, 1], [-4, -2, -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; B2DMDMDSMFB(A); --bei Verwendung von Packages: LA.B2DMDMDSMFB(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; B2DMDMDSMFB(B); --bei Verwendung von Packages: LA.B2DMDMDSMFB(B); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- B2DMDMDSMFB(B,1,"MyDet");--bei Packages: LA.B2DMDMDSMFB(B,1,"MyDet"); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- MyDet(B,B2DMDMDSMFB); --bei Packages: LA.MyDet(B,B2DMDMDSMFB); -20 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 16.1 (B2DMDMDSMFB) Bemerkung 16.4 (Implementierung von B2DMDMDSMFB) Satz 26.1 (MyDet) Satz 27.3 (MyInv) B2DMDMDFB ============ B2DMDMDSMRow ============ SYNTAX B2DMDMDSMRow(A: MAT, I:INT, K: INT, KF: POLY, Det: POLY): LIST wobei A eine NxM-Matrix ist, wobei I ein Zeilenindex aus 1..N mit I <> K, K+1 ist, wobei K ein Zeilenindex aus 1..(N-1) und wobei KF = KFSM(A,K-1) <> 0 ist. (KF=1 fuer K=1.) Ferner ist Det = MultSM(C0,KF,1,K-1) mit C0 = C0_B2SM(A,K). BESCHREIBUNG Diese Funktion berechnet nach der modifizierten Bareiss-2-Schritt-Formel die oberhalb der K-ten Zeile oder unterhalb der K+1-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Diagonalisierung mit Hilfe der K-ten, (K+1)- Zeile die K-te, (K+1)-te Spalte ausgeraeumt werden. B2DMDMDSMRow dient als Unterfunktion fuer B2DMDMDSM und B2DMDMDFBSM. BEISPIEL Use S::= Q[x[1..3]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 3x[1] - 6, x[1]x[3] - 2, 2x[1], x[1] - 8, x[1] - 2], [0, -6, 2x[1] - 2, 2x[1], -8, x[1] - 2] ]; KF:= KFSM(A,1); --bei Verwendung von Packages: KF:= LA.KFSM(A,1); KF; x[1] ------------- C0:= C0_B2SM(A,2); --bei Packages: C0:= LA.C0_B2SM(A,2); C0; x[1]x[2]x[3] + 6x[1] - 2x[2] + 12x[3] - 24 ------------- Det:= MultSM(C0,KF,1,1); --bei Packages: Det:= LA.MultSM(C0,KF,1,1); Det; x[1]x[2]x[3] + 6x[1] - 2x[2] + 12x[3] - 24 ------------- A[1]:= B2DMDMDSMRow(A,1,2,KF,Det); --bei Verwendung von Packages: A[1]:= LA.B2DMDMDSMRow(A,1,2,KF,Det); A[4]:= B2DMDMDSMRow(A,4,2,KF,Det); --bei Verwendung von Packages: A[4]:= LA.B2DMDMDSMRow(A,4,2,KF,Det); A; Mat[ [x[1]x[2]x[3] + 6x[1] - 2x[2] + 12x[3] - 24, 0, 0, -2x[2] + 6x[3] - 18, 4x[2]x[3] - x[2] + 6x[3] + 12, x[2]x[3] - x[2] + 6x[3] - 6], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 3x[1] - 6, x[1]x[3] - 2, 2x[1], x[1] - 8, x[1] - 2], [0, 0, 0, 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3] - 36, -2x[1]x[2] - 8x[2]x[3] - 12x[1] + 18x[2] - 12x[3] + 72, x[1]x[2]x[3] - 2x[1]x[2] - 2x[2]x[3] - 6x[1] + 4x[2] + 12] ] ------------- Hier sind in der ersten und vierten Zeile mit Hilfe der zweiten und dritten Zeile die beiden Spalten 2 und 3 ausgeraeumt worden. ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 15.2 (B2DMDMDSM, B2DMDMDSMRow) Bemerkung 15.3 (Implementierung von B2DMDMDSM) B2DMDMDRow ============ B2DMDRow ============ SYNTAX B2DMDRow(A: MAT, I:INT, J: INT, K: INT, C0: INT oder POLY, KF2: INT oder POLY, Det: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus 1..N mit I <> K, K+1 ist, wobei K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist. Ausserdem ist KF2 <> 0 das Quadrat des Zeilenstufenkoeffizienten KF der Vorgaengerzeile (K-1) mit KF=KF2=1 fuer K=1. Ferner stammt C0 aus dem Ergebnis von C0Pivot(A,J,K), und es ist Det=C0 / KF. BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-2-Schritt-Formel mit Division durch KF2 die oberhalb der K-ten Zeile oder unterhalb der K+1-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Diagonalisierung mit Hilfe der K-ten, (K+1)-ten Zeile die J-te, (J+1)-te Spalte ausgeraeumt werden. Dabei wird der Kofaktor C0 verwendet. B2DMDRow dient als Unterfunktion fuer B2DMD. BEISPIEL A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ]; C0Pivot(A,3,2); --bei Verwendung von Packages: LA.C0Pivot(A,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ], -16] ------------- C0:= -16; KF:= 2; KF2:= KF^2; Det:= C0 / KF; A[1]:= B2DMDRow(A,1,3,2,C0,KF2,Det); --bei Verwendung von Packages: A[1]:= LA.B2DMDRow(A,1,3,2,C0,KF2,Det); A[4]:= B2DMDRow(A,4,3,2,C0,KF2,Det); --bei Verwendung von Packages: A[4]:= LA.B2DMDRow(A,4,3,2,C0,KF2,Det); A; Mat[ [-8, -2, 0, 0, -14, 14], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, 0, 0, -20, 20] ] ------------- Hier werden in der ersten und vierten Zeile mit Hilfe der zweiten und dritten Zeile die dritte und vierte Spalte ausgeraeumt. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 6.3 (B2DMD,B2DMDRow) Bemerkung 6.8 (Implementierung von B2DOD, B2DMD, B2DMDMD) ============ B2DOD ============ SYNTAX B2DOD(A: MAT): MAT wobei A eine beliebige Matrix ueber einem Integritaetsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A aequivalente Diagonalmatrix aus, die mit dem Bareiss-2-Schritt-Verfahren ohne Division erzeugt wird. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B2DOD(P); --bei Verwendung von Packages: LA.B2DOD(P); Mat[ [2560, 1280, 0, 0, 0, 0], [0, 0, -640, 0, 0, -640], [0, 0, 0, 160, 0, 160], [0, 0, 0, 0, -80, 80] ] ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 6.5 (B2DOD, B2DODRow) Bemerkung 6.8 (Implementierung von B2DOD) ============ B2DODRow ============ SYNTAX B2DODRow(A: MAT, I:INT, J: INT, K: INT, C0: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus 1..N mit I <> K, K+1 ist, wobei K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist und wobei C0 aus dem Ergebnis von C0Pivot(A,J,K) stammt. BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-2-Schritt-Formel ohne Division die oberhalb der K-ten Zeile oder unterhalb der K+1-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Diagonalisierung mit Hilfe der K-ten, (K+1)-ten Zeile die J-te, (J+1)-te Spalte ausgeraeumt werden. B2DODRow dient als Unterfunktion fuer B2DOD und auch fuer eine andere Unterfunktion, naemlich B2DMDRow. BEISPIEL A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ]; C0Pivot(A,3,2); --bei Verwendung von Packages: LA.C0Pivot(A,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ], -16] ------------- C0:= -16; A[1]:= B2DODRow(A,1,3,2,C0); --bei Packages: A[1]:= LA.B2DODRow(A,1,3,2,C0); A[4]:= B2DODRow(A,4,3,2,C0); --bei Packages: A[4]:= LA.B2DODRow(A,4,3,2,C0); A; Mat[ [-32, -16, 0, 0, -56, 56], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, 0, 0, -80, 80] ] ------------- Hier werden in der ersten und vierten Zeile mit Hilfe der zweiten und dritten Zeile die dritte und vierte Spalte ausgeraeumt. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 6.5 (B2DOD, B2DODRow) Bemerkung 6.8 (Implementierung von B2DOD, B2DMD, B2DMDMD) B2DMDRow ============ B1TMD ============ SYNTAX B1TMD(A: MAT): MAT B1TMD(A: MAT, KF: POLY oder INT): MAT B1TMD(A: MAT, KF: POLY oder INT,E: OBJECT): MAT oder BOOL wobei A eine beliebige Matrix ueber einem Integritaetsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-1-Schritt- Verfahren mit Division eine zu A aequivalente Zeilenstufenmatrix. Die beiden anderen Faelle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, naemlich von den Dichotomie- Verfahren MalDich* (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird fuer die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgefuehrt bzw. es wird das Abbruchkriterium FALSE ausgegeben, falls rang A nicht maximal ist. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B1TMD(P); --bei Verwendung von Packages: LA.B1TMD(P); Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ] ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; B1TMD(A); --bei Verwendung von Packages: LA.B1TMD(A); Mat[ [2, 1, 3, 1], [0, 0, 8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- B1TMD(A,1,"MyDet"); --bei Packages: LA.B1TMD(A,1,"MyDet"); FALSE ------------- MyDet(A,B1TMD); --bei Packages: LA.MyDet(A,B1TMD); 0 ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 3.7 (B1TMD,B1TMDRow, Pivot) Bemerkung 3.10 (Implementierung von B1TMD) Abschnitt 10 (MalDich*) Satz 26.1 (MyDet) Satz 27.3 (MyInv) ============ B1TMDRow ============ SYNTAX B1TMDRow(A: MAT, I:INT, J: INT, K: INT, KF: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus (K+1)..N, K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..M ist und wobei KF <> 0 der Zeilenstufenkoeffizient der Vorgaengerzeile (K-1) ist. (KF=1 fuer K=1.) BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-1-Schritt-Formel mit Division durch KF die unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Trigonalisierung mit Hilfe der K-ten Zeile die J-te Spalte ausgeraeumt wird. Sie dient als Unterfunktion fuer B1TMD und auch fuer B2TMD, B2TMDMD. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; KF:= 1; P[2]:= B1TMDRow(P,2,1,1,KF); --bei Packages: P[2]:= LA.B1TMDRow(P,2,1,1,KF); P; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 0, -2, 4, -6], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ] ------------- Im obigen Beispiel wird in der zweiten Zeile mit Hilfe der ersten Zeile die erste Spalte ausgeraeumt, und zwar mit der Bareiss-1-Schritt- Formel mit Division. ------------- A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ]; KF:= 2; A[4]:= B1TMDRow(A,4,3,2,KF); --bei Packages: A[4]:= LA.B1TMDRow(A,4,3,2,KF); A; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, 0, 8, 4, 4] ] ------------- Hier wird in der vierten Zeile mit Hilfe der zweiten Zeile die dritte Spalte ausgeraeumt. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 3.7 (B1TMD, B1TMDRow) B2TMD, B2TMDMD ============ B1TMDRow2Col ============ SYNTAX B1TMDRow2Col(A: MAT, I: INT, J: INT, K: INT, Det: INT oder POLY, KF: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus (K+1)..N, K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) und wobei KF <> 0 der Zeilenstufenkoeffizient der Vorgaengerzeile (K-1) ist. (KF=1 fuer K=1.) Ferner ist Det = C0/KF, wobei man C0 mit C0Pivot(A,J,K) erhaelt. BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-1-Schritt-Formel mit Division durch KF die unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Trigonalisierung mit Hilfe der K-ten Zeile die J-te Spalte ausgeraeumt wird. Dabei wird ausserdem der Koeffizient A[I,J+1] = Det gesetzt. B1TMDRow2Col dient als Unterfunktion fuer B2TMD, B2TMDMD. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; C0Pivot(P,1,1); --bei Verwendung von Packages: LA.C0Pivot(P,1,1); [Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ], 0] ------------- Siehe CoPivot: mit der ersten Spalte wird automatisch auch die zweite ausgeraeumt, daher enthaelt die obige Liste als zweite Komponente C0=0. Im folgenden muss also die zweite Spalte nicht noch einmal eigens berechnet werden, denn dies ist schon im Rahmen von C0Pivot erfolgt. Stattdessen wird ihr der Wert 0 zugewiesen. ------------- C0:= 0; KF:= 1; Det:= C0 / KF; P[2]:= B1TMDRow2Col(P,2,1,1,Det,KF); --bei Verwendung von Packages: P[2]:= LA.B1TMDRow2Col(P,2,1,1,Det,KF); P[3]:= B1TMDRow2Col(P,3,1,1,Det,KF); --bei Verwendung von Packages: P[3]:= LA.B1TMDRow2Col(P,3,1,1,Det,KF); P[4]:= B1TMDRow2Col(P,4,1,1,Det,KF); --bei Verwendung von Packages: P[4]:= LA.B1TMDRow2Col(P,4,1,1,Det,KF); P; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 0, -2, 4, -6], [0, 0, -8, 0, 4, -12], [0, 0, -6, 2, 4, -8] ] ------------- B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ]; C0Pivot(B,3,2); --bei Verwendung von Packages: LA.C0Pivot(B,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ], 16] ------------- Siehe CoPivot: an Position (3,4) kommt (ohne Zeilentausch) ein Koeffizient ungleich 0, wenn man die dritte Spalte mit Hilfe der zweiten Zeile ausraeumt, naemlich der Koeffizient C0\KF=16\2=8. Damit folgt fuer die dritte Zeile: ------------- C0:= 16; KF:= 2; Det:= C0 / KF; B[3]:= B1TMDRow2Col(B,3,3,2,Det,KF); --bei Verwendung von Packages: B[3]:= LA.B1TMDRow2Col(B,3,3,2,Det,KF); B; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, 8, 4, 4], [0, 0, 0, -2, 4, -6] ] ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 4.8 (Implementierung von B2TOD, B2TMD, B2TMDMD) B1TMDRow C0Pivot B1TODRow2Col B2TMD, B2TMDMD ============ B1TMDSM ============ SYNTAX B1TMDSM(A: MAT): MAT B1TMDSM(A: MAT, E1: OBJECT, E2: OBJECT): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Faellen berechnet diese Funktion nach dem modifizierten Bareiss-1-Schritt-Verfahren eine zu A aequivalente Zeilenstufenmatrix. Der zweite Fall tritt nur auf, wenn B1TMDSM intern von MyDet (Satz 26.1) aufgerufen wird. Die beliebigen Argumente E1 und E2 sind nur deshalb noetig, weil MyDet stets Trigonalisierungs- oder Diagonalisierungsverfahren mit drei Argumenten verwendet. BEISPIEL A:= Mat[ [2, 3, 1, 0, 4, 1], [-4, -2, -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; B1TMDSM(A); --bei Verwendung von Packages: LA.B1TMDSM(A); Mat[ [2, 3, 1, 0, 4, 1], [0, 8, 0, -4, 12, 0], [0, 0, -8, 16, -24, 0], [0, 0, 0, -20, 20, 0] ] ------------- B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; B1TMDSM(B); --bei Verwendung von Packages: LA.B1TMDSM(B); Mat[ [2, 3, 1, 0], [0, 8, 0, -4], [0, 0, -8, 16], [0, 0, 0, -20] ] ------------- B1TMDSM(B,1,"MyDet"); --bei Packages: LA.B1TMDSM(B,1,"MyDet"); Mat[ [2, 3, 1, 0], [0, 8, 0, -4], [0, 0, -8, 16], [0, 0, 0, -20] ] ------------- MyDet(B,B1TMDSM); --bei Packages: LA.MyDet(B,B1TMDSM); -20 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 12.2 (B1TMDSM,B1TMDSMRow) Bemerkung 12.3 (Implementierung von B1TMDSM) Satz 26.1 (MyDet) B1TMD ============ B1TMDSMRow ============ SYNTAX B1TMDSMRow(A: MAT, I:INT, K: INT, KF: POLY): LIST wobei A eine NxM-Matrix ist, wobei I ein Zeilenindex aus (K+1)..N, K ein Zeilenindex aus 1..(N-1) und wobei KF = KFSM(A,K-1) <> 0 ist. (KF = 1 fuer K = 1.) BESCHREIBUNG Diese Funktion berechnet nach der modifizierten Bareiss-1-Schritt-Formel die unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Trigonalisierung mit Hilfe der K-ten Zeile die K-te Spalte ausgeraeumt wird. Sie dient als Unterfunktion fuer B1TMDSM und auch fuer B2TMDMDSM, B1DMDFBSM, B2DMDMDFBSM. BEISPIEL Use S::= Q[x[1..2]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [-4, x[2], -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; KF:= 1; A[2]:= B1TMDSMRow(A,2,1,KF); --bei Verwendung von Packages: A[2]:= LA.B1TMDSMRow(A,2,1,KF); A[3]:= B1TMDSMRow(A,3,1,KF); --bei Verwendung von Packages: A[3]:= LA.B1TMDSMRow(A,3,1,KF); A[4]:= B1TMDSMRow(A,4,1,KF); --bei Verwendung von Packages: A[4]:= LA.B1TMDSMRow(A,4,1,KF); A; Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 3x[1] - 6, -2, 2x[1], x[1] - 8, x[1] - 2], [0, -6, 2x[1] - 2, 2x[1], -8, x[1] - 2] ] ------------- Es wird in der zweiten, dritten und vierten Zeile mit Hilfe der ersten Zeile die erste Spalte ausgeraeumt. ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 12.2 (B1TMDSM, B1TMDSMRow) B1TMDRow ============ B1TMDSMRow2Col ============ SYNTAX B1TMDSMRow2Col(A: MAT, I: INT, K: INT, Det: POLY, KF: POLY): LIST wobei A eine NxM-Matrix ist, wobei I ein Zeilenindex aus (K+1)..N und K ein Zeilenindex aus 1..(N-1) und wobei KF = KFSM(A,K-1) <> 0 ist. (KF=1 fuer K=1.) Ferner ist Det = MultSM(C0,KF,1,K-1) mit C0 = C0_B2SM(A,K). BESCHREIBUNG Diese Funktion berechnet nach der modifizierten Bareiss-1-Schritt-Formel die unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Trigonalisierung mit Hilfe der K-ten Zeile die K-te Spalte ausgeraeumt wird. Dabei wird ausserdem der Koeffizient A[I,K+1] = Det gesetzt. B1TMDSMRow2Col dient als Unterfunktion fuer B2TMDMDSM, B2DMDMDSM und B2DMDMDFBSM. BEISPIEL Use S::= Q[x[1..2]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [-4, x[2], -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; C0:= C0_B2SM(A,1); --bei Packages: C0:= LA.C0_B2SM(A,1); C0; x[1]x[2] + 12 ------------- KF:= 1; Det:= C0; A[2]:= B1TMDSMRow2Col(A,2,1,Det,KF); --bei Verwendung von Packages: A[2]:= LA.B1TMDSMRow2Col(A,2,1,Det,KF); A; Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ] ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Bemerkung 13.4 (Implementierung von B2TMDMDSM) B1TMDRow2Col ============ B1TOD ============ SYNTAX B1TOD(A: MAT): MAT wobei A eine beliebige Matrix ueber einem Integritaetsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A aequivalente Zeilenstufenmatrix aus, die mit dem Bareiss-1-Schritt-Verfahren ohne Division (Gauss-Eliminationsverfahren) erzeugt wird. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B1TOD(P); --bei Verwendung von Packages: LA.B1TOD(P); Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, 0, 0, -80, 80] ] ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 3.9 (B1TOD, B1TODRow) Bemerkung 3.10 (Implementierung von B1TOD) ============ B1TODRow ============ SYNTAX B1TODRow(A: MAT, I:INT, J: INT, K: INT): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus (K+1)..N, K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..M ist. BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-1-Schritt-Formel ohne Division die unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Trigonalisierung mit Hilfe der K-ten Zeile die J-te Spalte ausgeraeumt wird. Sie dient als Unterfunktion fuer B1TOD und auch fuer eine andere Unterfunktion, naemlich B1TMDRow. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; P[2]:= B1TODRow(P,2,1,1); --bei Packages: P[2]:= LA.B1TODRow(P,2,1,1); P[3]:= B1TODRow(P,3,1,1); --bei Packages: P[3]:= LA.B1TODRow(P,3,1,1); P[4]:= B1TODRow(P,4,1,1); --bei Packages: P[4]:= LA.B1TODRow(P,4,1,1); P; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 0, -2, 4, -6], [0, 0, -8, 0, 4, -12], [0, 0, -6, 2, 4, -8] ] ------------- In den obigen Beispielen wird jeweils in der zweiten, dritten bzw. vierten Zeile mit Hilfe der ersten Zeile die erste Spalte ausgeraeumt, und zwar mit der Bareiss-1-Schritt-Formel ohne Division (Gaussformel). ------------- A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ]; A[4]:= B1TODRow(A,4,3,2); --bei Packages: A[4]:= LA.B1TODRow(A,4,3,2); A; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, 0, 16, 8, 8] ]; ------------- Hier wird in der vierten Zeile mit Hilfe der zweiten Zeile die dritte Spalte ausgeraeumt. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 3.9 (B1TOD, B1TODRow) Bemerkung 3.10 (Implementierung von B1TOD) ============ B1TODRow2Col ============ SYNTAX B1TODRow2Col(A: MAT, I:INT, J: INT, K: INT, C0: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus (K+1)..N, K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist. Ferner stammt C0 aus dem Ergebnis von C0Pivot(A,J,K). BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-1-Schritt-Formel ohne Division die unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Trigonalisierung mit Hilfe der K-ten Zeile die J-te Spalte ausgeraeumt wird. Dabei wird ausserdem der Koeffizient A[I,J+1] = C0 gesetzt. B1TODRow2Col dient als Unterfunktion fuer B2TOD und auch fuer eine andere Unterfunktion, naemlich B1TMDRow2Col. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; C0Pivot(P,1,1); --bei Verwendung von Packages: LA.C0Pivot(P,1,1); [Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ], 0] ------------- Siehe CoPivot: mit der ersten Spalte wird automatisch auch die zweite ausgeraeumt, daher enthaelt die obige Liste als zweite Komponente C0=0. Im folgenden muss also die zweite Spalte nicht noch einmal eigens berechnet werden, denn dies ist schon im Rahmen von C0Pivot erfolgt. Stattdessen wird ihr der Wert 0 zugewiesen. ------------- C0:= 0; P[2]:= B1TODRow2Col(P,2,1,1,C0);--bzw. P[2]:= LA.B1TODRow2Col(P,2,1,1,C0); P[3]:= B1TODRow2Col(P,3,1,1,0); --bzw. P[3]:= LA.B1TODRow2Col(P,3,1,1,0); P[4]:= B1TODRow2Col(P,4,1,1,0); --bzw. P[4]:= LA.B1TODRow2Col(P,4,1,1,0); P; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 0, -2, 4, -6], [0, 0, -8, 0, 4, -12], [0, 0, -6, 2, 4, -8] ] ------------- B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ]; C0Pivot(B,3,2); --bei Verwendung von Packages: LA.C0Pivot(B,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ], 16] ------------- An Position (3,4) kommt (ohne Zeilentausch) ein Koeffizient ungleich 0, wenn man die dritte Spalte mit Hilfe der zweiten Zeile ausraeumt, naemlich der Koeffizient C0=16. Damit folgt fuer die dritte Zeile: ------------- C0:= 16; B[3]:= B1TODRow2Col(B,3,3,2,C0);--bzw. B[3]:= LA.B1TODRow2Col(B,3,3,2,C0); B; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, 16, 8, 8], [0, 0, 0, -2, 4, -6] ] ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 4.8 (Implementierung von B2TOD, B2TMD,B2TMDMD) B1TODRow B1TMDRow2Col C0Pivot ============ B2TMD ============ SYNTAX B2TMD(A: MAT): MAT B2TMD(A: MAT, KF: INT oder POLY): MAT B2TMD(A: MAT, KF: INT oder POLY, E: OBJECT): MAT oder BOOL wobei A eine beliebige Matrix ueber einem Integritaetsring ist und E beliebig. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-2-Schritt- Verfahren mit Division eine zu A aequivalente Zeilenstufenmatrix. Die beiden anderen Faelle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, naemlich von den Dichotomie- Verfahren MalDich* (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird fuer die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgefuehrt bzw. es wird das Abbruchkriterium FALSE ausgegeben, falls rang A nicht maximal ist. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B2TMD(P); --bei Verwendung von Packages: LA.B2TMD(P); Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ] ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; B2TMD(A); --bei Verwendung von Packages: LA.B2TMD(A); Mat[ [2, 1, 3, 1], [0, 0, 8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- B2TMD(A,1,"MyDet"); --bei Packages: LA.B2TMD(A,1,"MyDet"); FALSE ------------- MyDet(A,B2TMD); --bei Packages: LA.MyDet(A,B2TMD); 0 ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 4.3 (B2TMD, B2TMDRow, C0Pivot) Bemerkung 4.8 (Implementierung von B2TMD) Abschnitt 10 (MalDich*) Satz 26.1 (MyDet) Satz 27.3 (MyInv) ============ B2TMDMD ============ SYNTAX B2TMDMD(A: MAT): MAT B2TMDMD(A: MAT, KF: INT oder POLY): MAT B2TMDMD(A: MAT, KF: INT oder POLY, E: OBJECT): MAT oder BOOL wobei A eine beliebige Matrix ueber einem Integritaetsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-2-Schritt- Verfahren mit Division eine zu A aequivalente Zeilenstufenmatrix. Dabei werden, statt wie bei B2TMD einmal durch einen quadrierten Teiler zu dividieren, zweimal die entsprechenden Zwischenergebnisse dividiert. Die beiden anderen Faelle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, naemlich von den Dichotomie- Verfahren MalDich* (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird fuer die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgefuehrt bzw. es wird das Abbruchkriterium FALSE ausgegeben, falls rang A nicht maximal ist. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B2TMDMD(P); --bei Verwendung von Packages: LA.B2TMDMD(P); Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ] ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; B2TMDMD(A); --bei Verwendung von Packages: LA.B2TMDMD(A); Mat[ [2, 1, 3, 1], [0, 0, 8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- B2TMDMD(A,1,"MyDet"); --bei Packages: LA.B2TMDMD(A,1,"MyDet"); FALSE ------------- MyDet(A,B2TMDMD); --bei Packages: LA.MyDet(A,B2TMDMD); 0 ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 4.6 (B2TMDMD, B2TMDMDRow) Bemerkung 4.8 (Implementierung von B2TMDMD) Abschnitt 10 (MalDich*) Satz 26.1 (MyDet) Satz 27.3 (MyInv) B2TMD ============ B2TMDMDRow ============ SYNTAX B2TMDMDRow(A: MAT, I:INT, J: INT, K: INT, KF: INT oder POLY, Det: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus (K+2)..N, K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist und wobei KF <> 0 der Zeilenstufenkoeffizient der Vorgaengerzeile (K-1) ist. (KF=1 fuer K=1.) Ferner ist Det = C0/KF, wobei man C0 mit C0Pivot(A,J,K) erhaelt. BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-2-Schritt-Formel mit zweimaliger Division durch KF die unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Trigonalisierung mit Hilfe der K-ten, (K+1)-ten Zeile die J-te, (J+1)-te Spalte ausgeraeumt werden. B2TMDMDRow dient als Unterfunktion fuer B2TMDMD. BEISPIEL B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ]; C0Pivot(B,3,2); --bei Verwendung von Packages: LA.C0Pivot(B,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ], 16] ------------- C0:= 16; KF:= 2; Det:= C0 / KF; B[4]:= B2TMDMDRow(B,4,3,2,KF,Det); --bei Verwendung von Packages: B[4]:= LA.B2TMDMDRow(B,4,3,2,KF,Det); B; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, 0, 20, -20] ] ------------- Raeumt man in der vierten Zeile mit Hilfe der zweiten, dritten Zeile die Spalten 3 und 4 aus, so erhaelt man das angegebene Ergebnis mit der Bareiss-2-Schritt-Formel unter Verwendung von Det=C0/KF. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 4.6 (B2TMDMD, B2TMDMDRow) Bemerkung 4.8 (Implementierung von B2TOD, B2TMD, B2TMDMD) ============ B2TMDMDSM ============ SYNTAX B2TMDMDSM(A: MAT): MAT B2TMDMDSM(A: MAT, E1: OBJECT, E2: OBJECT): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Faellen berechnet diese Funktion nach dem modifizierten Bareiss-2-Schritt-Verfahren eine zu A aequivalente Zeilenstufenmatrix. Der zweite Fall tritt nur auf, wenn B2TMDMDSM intern von MyDet (Satz 26.1) aufgerufen wird. Die beliebigen Argumente E1 und E2 sind nur deshalb noetig, weil MyDet stets Trigonalisierungs- oder Diagonalisierungsverfahren mit drei Argumenten verwendet. BEISPIEL A:= Mat[ [2, 3, 1, 0, 4, 1], [-4, -2, -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; B2TMDMDSM(A); --bei Verwendung von Packages: LA.B2TMDMDSM(A); Mat[ [2, 3, 1, 0, 4, 1], [0, 8, 0, -4, 12, 0], [0, 0, -8, 16, -24, 0], [0, 0, 0, -20, 20, 0] ] ------------- B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; B2TMDMDSM(B); --bei Verwendung von Packages: LA.B2TMDMDSM(B); Mat[ [2, 3, 1, 0], [0, 8, 0, -4], [0, 0, -8, 16], [0, 0, 0, -20] ] ------------- B2TMDMDSM(B,1,"MyDet"); --bei Packages: LA.B2TMDMDSM(B,1,"MyDet"); Mat[ [2, 3, 1, 0], [0, 8, 0, -4], [0, 0, -8, 16], [0, 0, 0, -20] ] ------------- MyDet(B,B2TMDMDSM); --bei Packages: LA.MyDet(B,B2TMDMDSM); -20 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 13.3 (B2TMDMDSM, B2TMDMDSMRow) Bemerkung 13.4 (Implementierung von B2TMDMDSM) Satz 26.1 (MyDet) B2TMDMD ============ B2TMDMDSMRow ============ SYNTAX B2TMDMDSMRow(A: MAT, I:INT, K: INT, KF: POLY, Det: POLY): LIST wobei A eine NxM-Matrix ist, wobei I ein Zeilenindex aus (K+2)..N, K ein Zeilenindex aus 1..(N-1) und wobei KF = KFSM(A,K-1) <> 0 ist. (KF=1 fuer K=1.) Ferner ist Det = MultSM(C0,KF,1,K-1) mit C0 = C0_B2SM(A,K). BESCHREIBUNG Diese Funktion berechnet nach der modifizierten Bareiss-2-Schritt-Formel die unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Trigonalisierung mit Hilfe der K-ten, (K+1)-ten Zeile die K-te, (K+1)-te Spalte ausgeraeumt werden. B2TMDMDSMRow dient als Unterfunktion fuer B2TMDMDSM, B2DMDMDFBSM. BEISPIEL Use S::= Q[x[1..2]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [-4, x[2], -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; C0:= C0_B2SM(A,1); --bei Packages: C0:= LA.C0_B2SM(A,1); C0; x[1]x[2] + 12 ------------- KF:= 1; Det:= C0; A[3]:= B2TMDMDSMRow(A,3,1,KF,Det); --bei Verwendung von Packages: A[3]:= LA.B2TMDMDSMRow(A,3,1,KF,Det); A[4]:= B2TMDMDSMRow(A,4,1,KF,Det); --bei Verwendung von Packages: A[4]:= LA.B2TMDMDSMRow(A,4,1,KF,Det); A; Mat[ [x[1], 3, 1, 0, 4, 1], [-4, x[2], -2, -2, -2, -2], [0, 0, 6x[1] - 2x[2] - 24, 2x[1]x[2] + 6x[1] + 12, x[1]x[2] + 6x[1] - 8x[2] - 48, x[1]x[2] + 6x[1] - 2x[2] - 12], [0, 0, 2x[1]x[2] - 2x[2] + 12, 2x[1]x[2] + 12, -8x[2] - 12, x[1]x[2] - 2x[2]] ] ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 13.3 (B2TMDMDSM, B2TMDMDSMRow) Bemerkung 13.4 (Implementierung von B2TMDMDSM) B2TMDMDRow ============ B2TMDRow ============ SYNTAX B2TMDRow(A: MAT, I:INT, J: INT, K: INT, C0: INT oder POLY, KF2: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus (K+2)..N, K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist und wobei KF2 <> 0 das Quadrat des Zeilenstufenkoeffizienten der Vorgaengerzeile (K-1) ist. (KF2=1 fuer K=1.) Ferner stammt C0 aus dem Ergebnis von C0Pivot(A,J,K). BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-2-Schritt-Formel mit Division durch KF2 die unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Trigonalisierung mit Hilfe der K-ten, (K+1)-ten Zeile die J-te, (J+1)-te Spalte ausgeraeumt werden. Dabei wird der Kofaktor C0 verwendet. B2TMDRow dient als Unterfunktion fuer B2TMD. BEISPIEL B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ]; C0Pivot(B,3,2); --bei Verwendung von Packages: LA.C0Pivot(B,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ], 16] ------------- C0:= 16; KF:= 2; KF2:= KF^2; B[4]:= B2TMDRow(B,4,3,2,C0,KF2); --bzw. B[4]:= LA.B2TMDRow(B,4,3,2,C0,KF2); B; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, 0, 20, -20] ] ------------- Raeumt man in der vierten Zeile mit Hilfe der zweiten, dritten Zeile die Spalten 3 und 4 aus, so erhaelt man das angegebene Ergebnis mit der Bareiss-2-Schritt-Formel unter Verwendung des Kofaktors C0 und des quadrierten Teilers KF2. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 4.3 (B2TMD,B2TMDRow) Bemerkung 4.8 (Implementierung von B2TOD, B2TMD, B2TMDMD) ============ B2TOD ============ SYNTAX B2TOD(A: MAT): MAT wobei A eine beliebige Matrix ueber einem Integritaetsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A aequivalente Zeilenstufenmatrix aus, die mit dem Bareiss-2-Schritt-Verfahren ohne Division erzeugt wird. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; B2TOD(P); --bei Verwendung von Packages: LA.B2TOD(P); Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, 0, 0, -80, 80] ] ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 4.5 (B2TOD, B2TODRow) Bemerkung 4.8 (Implementierung von B2TOD) ============ B2TODRow ============ SYNTAX B2TODRow(A: MAT, I:INT, J: INT, K: INT, C0: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix ist, wobei I ein Zeilenindex aus (K+2)..N, K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist und wobei C0 aus dem Ergebnis von C0Pivot(A,J,K) stammt. BESCHREIBUNG Diese Funktion berechnet nach der Bareiss-2-Schritt-Formel ohne Division die unterhalb der K-ten Zeile gelegene I-te Zeile von A neu, wenn bei der Trigonalisierung mit Hilfe der K-ten, (K+1)-ten Zeile die J-te, (J+1)-te Spalte ausgeraeumt werden. B2TODRow dient als Unterfunktion fuer B2TOD und auch fuer eine andere Unterfunktion, naemlich B2TMDRow. BEISPIEL B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ]; C0Pivot(B,3,2); --bei Verwendung von Packages: LA.C0Pivot(B,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ], 16] ------------- C0:= 16; B[4]:= B2TODRow(B,4,3,2,C0); --bzw. B[4]:= LA.B2TODRow(B,4,3,2,C0); B; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, 0, 80, -80] ] ------------- Raeumt man in der vierten Zeile mit Hilfe der zweiten, dritten Zeile die Spalten 3 und 4 aus, so erhaelt man das angegebene Ergebnis mit der Bareiss-2-Schritt-Formel unter Verwendung des Kofaktors C0. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 3.9 (B2TOD, B2TODRow) Bemerkung 3.10 (Implementierung von B2TOD, B2TMD, B2TMDMD) B2TMDRow C0Pivot ============ CatMat ============ SYNTAX CatMat(I: INT, J: INT, N: INT): MAT wobei 1 <= N, I und 0 <= J ist und wobei der CurrentRing() ausreichend viele Variablen z[0], z[1],... enthaelt. BESCHREIBUNG Diese Funktion erzeugt die katalektische Matrix Cat(I,J+I,N-1). BEISPIEL Use S::= Z/(2)[z[0..100]]; CatMat(1,1,5); --bei Verwendung von Packages: T.CatMat(1,1,5); Mat[ [z[0], z[1], z[2], z[3], z[4]], [z[1], z[5], z[6], z[7], z[8]], [z[2], z[6], z[9], z[10], z[11]], [z[3], z[7], z[10], z[12], z[13]], [z[4], z[8], z[11], z[13], z[14]] ] ------------- CatMat(2,2,3); --bei Verwendung von Packages: T.CatMat(2,2,3); Mat[ [z[0], z[1], z[2], z[3], z[4], z[5]], [z[1], z[3], z[4], z[6], z[7], z[8]], [z[2], z[4], z[5], z[7], z[8], z[9]], [z[3], z[6], z[7], z[10], z[11], z[12]], [z[4], z[7], z[8], z[11], z[12], z[13]], [z[5], z[8], z[9], z[12], z[13], z[14]] ] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 Abschnitt 18 ============ ChangeRow ============ SYNTAX ChangeRow(L: LIST, I: INT, K: INT): LIST BESCHREIBUNG Diese Funktion vertauscht in der Liste L die beiden Komponenten an der I-ten und K-ten Position. BEISPIEL L:= [1, 2, 3, 4, 5]; ChangeRow(L,2,3); --bei Verwendung von Packages: LA.ChangeRow(L,2,3); [1, 3, 2, 4, 5] ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 ============ CheckEq ============ SYNTAX CheckEq(A: OBJECT, B: OBJECT): BOOL BESCHREIBUNG Diese Funktion prueft, ob A und B gleich sind. BEISPIEL CheckEq([1, 2], [1, 2]); --bei Packages: T.CheckEq([1, 2], [1, 2]); TRUE ------------- CheckEq([1, 2], [2, 1]); --bei Packages: T.CheckEq([1, 2], [2, 1]); FALSE ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 ============ CheckHomSol ============ SYNTAX CheckHomSol(A: MAT, B: LIST): BOOL wobei A eine NxM-Matrix und B eine Liste von M-elementigen Listen ist. BESCHREIBUNG Dies Funktion prueft, ob die Listen aus B Loesungen des homogenen linearen Gleichungssystems Ax=0 sind. BEISPIEL A:= Mat[ [1, 1, 2, 2, 3], [2, 2, 3, 3, 4], [3, 3, 4, 6, 6] ]; B:= MyLinKer(A); --bei Verwendung von Packages: B:= LA.MyLinKer(A); B; [[-2, 2, 0, 0, 0], [2, 0, -3, -1, 2]] ------------- CheckHomSol(A, B); --bei Verwendung von Packages: T.CheckHomSol(A, B); [TRUE, TRUE] ------------- C:= [[-2, 2, 0, 0, 0], [2, 1, -3, -1, 2]]; CheckHomSol(A, C); --bei Verwendung von Packages: T.CheckHomSol(A, C); [TRUE, FALSE] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyLinKer ============ CheckInv ============ SYNTAX CheckInv(A: MAT, B:MAT, Det: INT oder POLY): BOOL wobei A und B quadratische Matrizen sind. BESCHREIBUNG Diese Funktion testet, ob das Produkt der beiden Matrizen A und B gleich dem Det-fachen der Einheitsmatrix ist, oder anders ausgedrueckt, ob (1/Det) * B die Inverse von A ist (Det <> 0). BEISPIEL A:= Mat[ [1, 2, 3], [2, 3, 4], [3, 4, 6] ]; I:= MyInv(A); --bei Verwendung von Packages: I:= LA.MyInv(A); I; [-1, Mat[ [2, 0, -1], [0, -3, 2], [-1, 2, -1] ]] ------------- CheckInv(A, I[2],I[1]); --bei Packages: T.CheckInv(A, I[2],I[1]); TRUE ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyInv ============ CheckSol ============ SYNTAX CheckSol(A: MAT, B: MAT, Det: INT oder POLY, X: LIST): BOOL wobei A eine NxM-Matrix, B eine NxP-Matrix und X eine Liste von M-elementigen Listen ist. BESCHREIBUNG Dies Funktion prueft, ob die Listen aus X Det-fache von speziellen Loesungen des inhomogenen linearen Gleichungssystems Ax=B sind. BEISPIEL A:= Mat[ [1, 1, 2, 2, 3], [2, 2, 3, 3, 4], [3, 3, 4, 6, 6] ]; B:= Mat[ [1, 2, 0], [1, 3, 0], [2, 1, 1] ]; C:= MyLinSol(A,B); --bei Verwendung von Packages: C:= LA.MyLinSol(A,B); C; [-2, [[2, 0, -1, -1, 0], [0, 0, -5, 3, 0], [0, 0, 1, -1, 0]], [[-2, 2, 0, 0, 0], [2, 0, -3, -1, 2]]] ------------- CheckSol(A,B,C[1],C[2]);--bei Packages: T.CheckSol(A,B,C[1],C[2]); [TRUE, TRUE, TRUE] ------------- D:= [[2, 1, -1, -1, 1], [0, 0, -5, 3, 0], [0, 0, 1, -1, 0]]; CheckSol(A,B,C[1],D); --bei Packages: T.CheckSol(A,B,C[1],D); [FALSE, TRUE, TRUE] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyLinSol ============ Coeff ============ SYNTAX Coeff(A: MAT, J: LIST, JK: INT, K: INT, L: INT): INT oder POLY wobei A eine beliebige NxM-Matrix ist und wobei K ein Zeilenindex aus 1..(N-1) und JK ein Spaltenindex aus 1..M ist. Ausserdem besteht die Liste J aus den Zeilenstufenindizes der ersten K Zeilen, und L ist ein zeilenindex aus K+1..N. BESCHREIBUNG Diese Funktion berechnet nach der Malashonok-1-Schritt-Formel den Koeffizienten, der an der Position (L,K) zu erwarten ist, wenn in der L-ten Zeile mit Hilfe der ersten K Zeilen die ersten K Zeilenstufenspalten aus der Liste J ausgeraeumt werden. Coeff dient als Unterfunktion fuer Mal1Pivot. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; Coeff(P,[1],2,1,2); --bei Packages: LA.Coeff(P,[1],2,1,2); 0 ------------- Coeff(P,[1],2,1,3); --bei Packages: LA.Coeff(P,[1],2,1,3); 0 ------------- Coeff(P,[1],2,1,4); --bei Packages: LA.Coeff(P,[1],2,1,4); 0 ------------- An den Positionen (2,2), (3,2), (4,2) ist also 0 als Koeffizient zu erwarten, wenn man mit der ersten Zeile die erste Spalte ausraeumt. Wie schaut es aus in der dritten Spalte? ------------- Coeff(P,[1],3,1,2); --bei Packages: LA.Coeff(P,[1],3,1,2); 0 ------------- Coeff(P,[1],3,1,3); --bei Packages: LA.Coeff(P,[1],3,1,3); -8 ------------- An der Position (2,3) ist 0 als Koeffizient zu erwarten, an der Position (3,3) dagegen -8. Hier liegt also die naechste Zeilenstufe. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Mal1Pivot ============ C0Pivot ============ SYNTAX C0Pivot(A: MAT, J: INT, K: INT): LIST wobei A eine beliebige NxM-Matrix ist und wobei K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist. Die Ergebnisliste ist von der Form [B: MAT, C0: INT oder POLY]. BESCHREIBUNG Diese Funktion versucht, durch Zeilentausch die naechste Zeilenstufe an Position (K+1,J+1) zu erhalten, wobei C0 der an dieser Position zu erwartende Koeffizient ist, wenn man mit Hilfe der K-ten Zeile die J-te Spalte ausraeumt. Beim Zeilentausch wird ausserdem die L-te Zeile mit -1 multipliziert. Als Ergebnis erhaelt man eine Liste, die als erste Komponente die Matrix mit eventuell getauschten Zeilen und als zweite Komponente C0 enthaelt. Liegt in der Spalte (J+1) keine Zeilenstufe, so ist insbesondere C0=0. Diese Funktion wird als Unterfunktion von allen Bareiss-2-Schritt-Verfahren B2TOD, B2TMD, B2TMDMD, B2DOD, B2DMD, B2DMDMD aufgerufen. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; C0Pivot(P,1,1); --bei Verwendung von Packages: LA.C0Pivot(P,1,1); [Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ], 0] ------------- Im ersten Beispiel ist es nicht moeglich, Zeilen so zu tauschen, dass man an der Position (2,2) einen Koeffizienten ungleich 0 erhaelt, wenn man mit der ersten Zeile die erste Spalte ausraeumt. In diesem Fall werden also automatisch die ersten beiden Spalten ausgeraeumt. Als Ergebnis wird daher die unveraenderte Matrix P und C0=0 ausgegeben. ------------- A:= Mat[ [ 1, 3, 1, 0, 4], [ 1, 3, 0, 2, 1], [ 2, 2, 2, 2, 2], [ 1, 0, 2, 2, 0] ]; C0Pivot(A,1,1); --bei Verwendung von Packages: LA.C0Pivot(A,1,1); [Mat[ [1, 3, 1, 0, 4], [-2, -2, -2, -2, -2], [1, 3, 0, 2, 1], [1, 0, 2, 2, 0] ], 4] ------------- Beim zweiten Beispiel muss man die zweite und dritte Zeile tauschen, um an Position (2,2) die naechste Zeilenstufe mit C0=4 zu erhalten. Dabei wird die nach oben getauschte Zeile mit -1 multipliziert. ------------- B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ]; C0Pivot(B,3,2); --bei Verwendung von Packages: LA.C0Pivot(B,3,2); [Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, -6, 2, 4, -8], [0, 0, 0, -2, 4, -6] ], 16] ------------- Im dritten Beispiel kommt ohne Zeilentausch an Position (3,4) ein Koeffizient ungleich 0, wenn man die dritte Spalte mit Hilfe der zweiten Zeile ausraeumt. Daher wird als Ergebnis die unveraenderte Matrix und C0=16 ausgegeben. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 4.3 (C0Pivot) Bemerkung 4.8 (Implementierung) B2TOD, B2TMD, B2TMDMD, B2DOD, B2DMD, B2DMDMD ============ C0_B2 ============ SYNTAX C0_B2(A: MAT, J: INT, K: INT): INT oder POLY wobei A eine beliebige NxM-Matrix ist und wobei K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist. BESCHREIBUNG Diese Funktion berechnet den fuer die Bareiss-2-Schritt-Formel benoetigten Kofaktor C0, wenn mit Hilfe der K-, K+1-ten Zeile die J-, J+1-te Spalte ausgeraeumt werden sollen. BEISPIEL A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ]; C0_B2(A,3,2); --bei Verwendung von Packages: LA.C0_B2(A,3,2); -16 ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 4.5 (B2TODRow) Satz 4.3 (B2TMDRow) Satz 4.6 (B2TMDMDRow) Bemerkung 6.5 (B2DODRow) Satz 6.3 (B2DMDRow) Satz 6.6 (B2DMDMDRow) CoPivot C1_B2, C2_B2 ============ C0_B2SM ============ SYNTAX C0_B2SM(A: MAT, K: INT): INT oder POLY wobei A eine NxM-Matrix und K ein Zeilenindex aus 1..(N-1) ist. BESCHREIBUNG Diese Funktion berechnet den fuer die modifizierte Bareiss-2-Schritt- Formel benoetigten Kofaktor C0, wenn mit Hilfe der K-, K+1-ten Zeile die K-te und K+1-te Spalte ausgeraeumt werden sollen. C0_B2SM dient als Unterfunktion fuer B2TMDMDSMRow und B2DMDMDSMRow. BEISPIEL Use S::= Q[x[1..2]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 3x[1] - 6, -2, 2x[1], x[1] - 8, x[1] - 2], [0, -6, 2x[1] - 2, 2x[1], -8, x[1] - 2] ]; C0_B2SM(A,2); --bei Verwendung von Packages: LA.C0_B2SM(A,2); 6x[1] - 2x[2] - 24 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 13.3 (B2TMDMDSMRow) Satz 15.2 (B2DMDMDSMRow) C1_B2SM, C2_B2SM C0_B2 ============ C1_B2 ============ SYNTAX C1_B2(A: MAT, I: INT, J: INT, K: INT): INT oder POLY wobei A eine beliebige NxM-Matrix ist und wobei I ein Zeilenindex aus 1..N, K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist. BESCHREIBUNG Diese Funktion berechnet den fuer die Bareiss-2-Schritt-Formel benoetigten Kofaktor C1, wenn mit Hilfe der K-, K+1-ten Zeile die J-, J+1-te Spalte ausgeraeumt werden sollen in der I-ten Zeile. C1_B2 dient als Unterfunktion fuer B2TODRow, B2TMDRow, B2TMDMDRow, B2DODRow, B2DMDRow, B2DMDMDRow. BEISPIEL A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ]; C1_B2(A,4,3,2); --bei Verwendung von Packages: LA.C1_B2(A,4,3,2); 16 ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 4.5 (B2TODRow) Satz 4.3 (B2TMDRow) Satz 4.6 (B2TMDMDRow) Bemerkung 6.5 (B2DODRow) Satz 6.3 (B2DMDRow) Satz 6.6 (B2DMDMDRow) C0_B2, C2_B2 ============ C1_B2SM ============ SYNTAX C1_B2SM(A: MAT, I: INT, K: INT): INT oder POLY wobei A eine NxM-Matrix ist und wobei I ein Zeilenindex aus 1..N und K ein Zeilenindex aus 1..(N-1) ist. BESCHREIBUNG Diese Funktion berechnet den fuer die modifizierte Bareiss-2-Schritt- Formel benoetigten Kofaktor C1, wenn mit Hilfe der K-, K+1-ten Zeile die K-, K+1-te Spalte ausgeraeumt werden sollen in der I-ten Zeile. C1_B2SM dient als Unterfunktion fuer B2TMDMDSMRow und B2DMDMDSMRow. BEISPIEL Use S::= Q[x[1..2]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 3x[1] - 6, -2, 2x[1], x[1] - 8, x[1] - 2], [0, -6, 2x[1] - 2, 2x[1], -8, x[1] - 2] ]; C1_B2SM(A,4,2); --bei Verwendung von Packages: LA.C1_B2SM(A,4,2); 2x[1]x[2] - 2x[2] + 12 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 13.3 (B2TMDMDSMRow) Satz 15.2 (B2DMDMDSMRow) C0_B2SM, C2_B2SM C1_B2 ============ C2_B2 ============ SYNTAX C2_B2(A: MAT, I: INT, J: INT, K: INT): INT oder POLY wobei A eine beliebige NxM-Matrix ist und wobei I ein Zeilenindex aus 1..N, K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist. BESCHREIBUNG Diese Funktion berechnet den fuer die Bareiss-2-Schritt-Formel benoetigten Kofaktor C2, wenn mit Hilfe der K-, K+1-ten Zeile die J-, J+1-te Spalte ausgeraeumt werden sollen in der I-ten Zeile. C2_B2 dient als Unterfunktion fuer B2TODRow, B2TMDRow, B2TMDMDRow, B2DODRow, B2DMDRow, B2DMDMDRow. BEISPIEL A:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ]; C2_B2(A,4,3,2); --bei Verwendung von Packages: LA.C2_B2(A,4,3,2); -12 ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Bemerkung 4.5 (B2TODRow) Satz 4.3 (B2TMDRow) Satz 4.6 (B2TMDMDRow) Bemerkung 6.5 (B2DODRow) Satz 6.3 (B2DMDRow) Satz 6.6 (B2DMDMDRow) C0_B2, C1_B2 ============ C2_B2SM ============ SYNTAX C2_B2SM(A: MAT, I: INT, K: INT): INT oder POLY wobei A eine beliebige NxM-Matrix ist und wobei I ein Zeilenindex aus 1..N und K ein Zeilenindex aus 1..(N-1) ist. BESCHREIBUNG Diese Funktion berechnet den fuer die modifizierte Bareiss-2-Schritt- Formel benoetigten Kofaktor C2, wenn mit Hilfe der K-, K+1-ten Zeile die K-, K+1-te Spalte ausgeraeumt werden sollen in der I-ten Zeile. C2_B2SM dient als Unterfunktion fuer B2TMDMDSMRow, B2DMDMDSMRow. BEISPIEL Use S::= Q[x[1..2]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 3x[1] - 6, -2, 2x[1], x[1] - 8, x[1] - 2], [0, -6, 2x[1] - 2, 2x[1], -8, x[1] - 2] ]; C2_B2SM(A,4,2); --bei Verwendung von Packages: LA.C2_B2SM(A,4,2); 6x[1] - 18 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 13.3 (B2TMDMDSMRow) Satz 15.2 (B2DMDMDSMRow) C0_B2SM, C1_B2SM C2_B2 ============ D ============ SYNTAX D(N: INT): MAT wobei 1 <= N <= 4 ist und wobei CurrentRing() die Variable v enthalten muss. BESCHREIBUNG Diese Funktion ruft eine mit RandMatPoly erzeugte Zufallsmatrix in der Variablen v ab, und zwar fuer N = 1 eine 6x7-Matrix, deren Koeffizienten hoechstens vom Grad 20 sind (RandMatPoly(6,7,20)) N = 2 eine 6x7-Matrix, deren Koeffizienten hoechstens vom Grad 40 sind (RandMatPoly(6,7,40)) N = 3 eine 8x7-Matrix, deren Koeffizienten hoechstens vom Grad 20 sind (RandMatPoly(8,7,20)) N = 4 eine 8x9-Matrix, deren Koeffizienten hoechstens vom Grad 20 sind (RandMatPoly(8,9,20)). Vorher muss allerdings die Datei matdef.coc eingelesen werden. SIEHE AUCH matdef.coc, Manual A.1 bis A.3, A.5 Abschnitt 20 E, F RandMatPoly ============ E ============ SYNTAX E(N: INT): MAT wobei 1 <= N <= 4 ist und wobei CurrentRing() die Variablen v und w enthalten muss. BESCHREIBUNG Diese Funktion ruft eine mit RandMatPolyHom erzeugte Zufallsmatrix in den Variablen v, w ab, und zwar fuer N = 1 eine 4x5-Matrix, deren Koeffizienten hoechstens vom Grad 10 sind (RandMatPolyHom(4,5,10)) N = 2 eine 4x5-Matrix, deren Koeffizienten hoechstens vom Grad 20 sind (RandMatPolyHom(4,5,20)) N = 3 eine 5x6-Matrix, deren Koeffizienten hoechstens vom Grad 10 sind (RandMatPolyHom(5,6,10)) N = 4 eine 5x4-Matrix, deren Koeffizienten hoechstens vom Grad 20 sind (RandMatPolyHom(5,4,20)) Vorher muss allerdings die Datei matdef.coc eingelesen werden. SIEHE AUCH matdef.coc, Manual A.1 bis A.3, A.5 Abschnitt 20 RandMatPolyHom, D, F ============ F ============ SYNTAX F(N: INT): MAT wobei 1 <= N <= 2 ist und wobei CurrentRing() die Variablen v, w und x enthalten muss. BESCHREIBUNG Diese Funktion ruft eine mit RandMatPolyHom erzeugte Zufallsmatrix in den Variablen v, w, x ab, und zwar fuer N = 1 eine 4x5-Matrix, deren Koeffizienten hoechstens vom Grad 5 sind (RandMatPolyHom(4,5,5)) N = 2 eine 4x5-Matrix, deren Koeffizienten hoechstens vom Grad 5 sind (RandMatPolyHom(4,5,5)) Vorher muss allerdings die Datei matdef.coc eingelesen werden. SIEHE AUCH matdef.coc, Manual A.1 bis A.3, A.5 Abschnitt 20 RandMatPolyHom, D, E ============ FindKer ============ SYNTAX FindKer(A: MAT): LIST wobei A eine Diagonalmatrix ueber einem Integritaetsring ist, die durch ein Verfahren mit Division erzeugt worden ist. BESCHREIBUNG Diese Funktion gibt als Ergebnis eine Liste von Listen aus, die Basisvektoren fuer den Loesungraum des homogenen linearen Gleichungssystems Ax=0 darstellen. FindKer dient als Unterfunktion fuer MyLinKer. BEISPIEL P:= Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ]; FindKer(P); --bei Verwendung von Packages: LA.FindKer(P); [[-10, 20, 0, 0, 0, 0], [0, 0, -20, -20, 20, 20]] ------------- A:= Mat[ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ]; FindKer(A); --bei Verwendung von Packages: LA.FindKer(A); [ ] ------------- Falls nur die triviale Loesung existiert, wird als Ergebnis die leere Liste ausgegeben. ------------- SIEHE AUCH linalg.coc, Manual A.1 bis A.3, A.5 Satz 28.3 (MyLinKer) Bemerkung 28.5 (Implementierung von MyLinKer, FindKer) ============ FindSol ============ SYNTAX FindSol(C: MAT, M: INT): LIST wobei C eine Nx(M+P)-Diagonalmatrix ueber einem Integritaetsring ist, die durch ein Verfahren mit Division erzeugt worden ist und aequivalent zu einer erweiterten Koeffizientenmatrix (A|B) mit einer NxM-Matrix A und einer NxP-Matrix B ist. Die Ergebnisliste ist von der Form [Det: INT oder POLY, Sol: LIST, LinKer: LIST]. BESCHREIBUNG Diese Funktion gibt als Ergebnis eine Liste aus, deren erste Komponente Det der Zeilenstufenkoeffizient der zu A aequivalenten Matrix ist. Als zweite Komponente folgt eine Liste, deren Komponenten spezielle Loesungen fuer den Loesungraum des inhomogenen linearen Gleichungssystems Ax=B darstellen, wenn man sie durch Det teilt, bzw. die "Das Gleichungssystem ist nicht loesbar." besagen. Die dritte Komponente ist eine Liste, deren Komponenten Basisvektoren des zugehoerigen homogenen Gleichungssystems Ax=0 darstellen. FindSol dient als Unterfunktion fuer MyLinSol. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; C:= B2DMD(P); --bei Verwendung von Packages: C:= LA.B2DMD(P); C; Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- FindSol(C,5); --bei Verwendung von Packages: LA.FindSol(C,5); [-20, [[0, 0, -20, -20, 20]], [[-10, 20, 0, 0, 0]]] ------------- Das Gleichungssystem Ax=B mit A:= Mat[ [2, 1, 3, 1, 0], [2, 1, 3, 0, 2], [4, 2, 2, 2, 2], [2, 1, 0, 2, 2] ] und B:= Mat[ [4], [1], [2], [0] ] ist loesbar mit der speziellen Loesung (-20)^(-1) * [0, 0, -20, -20, 20] = [0, 0, 1, 1, -1]. Das zugehoerige homogene Gleichungssystem Ax=0 besitzt [-10, 20, 0, 0, 0] als Basisvektor. ------------- FindSol(C,4); --bei Verwendung von Packages: LA.FindSol(C,4); [-20, ["Das Gleichungssystem ist nicht loesbar.", "Das Gleichungssystem ist nicht loesbar."], [[-10, 20, 0, 0]]] ------------- Das Gleichungssystem Ax=B mit A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ] und B:= Mat[ [0, 4], [2, 1], [2, 2], [2, 0] ] ist also nicht loesbar. Das zugehoerige homogene Gleichungssystem Ax=0 besitzt [-10, 20, 0, 0] als Basisvektor. ------------- FindSol(C,1); --bei Verwendung von Packages: LA.FindSol(C,1); [-20, [[-10], "Das Gleichungssystem ist nicht loesbar.", "Das Gleichungssystem ist nicht loesbar.", "Das Gleichungssystem ist nicht loesbar.", "Das Gleichungssystem ist nicht loesbar."], [ ]] ------------- Das Gleichungssystem Ax=B mit A:= Mat[ [2], [2], [4], [2] ] und B:= Mat[ [1, 3, 1, 0, 4], [1, 3, 0, 2, 1], [2, 2, 2, 2, 2], [1, 0, 2, 2, 0] ] ist fuer die erste Spalte von B loesbar mit der speziellen Loesung (-20)^(-1) * [-10] = [1/2]. Fuer die uebrigen Spalten ist es nicht loesbar. Das zugehoerige homogene Gleichungssystem Ax=0 besitzt nur die triviale Loesung. ------------- SIEHE AUCH linalg.coc, Manual A.1 bis A.3, A.5 Satz 29.3 (MyLinSol) Bemerkung 29.5 (Implementierung von MyLinSol, FindSol) ============ FindZeroMaxMinors ============ SYNTAX FindZeroMaxMinors(B: MAT, Var L1: LIST, L0: LIST): NULL wobei B eine NxM-Zeilenstufenmatrix mit N <= M ist, wobei L1 eine Liste ist von Listen, die N-elementige Teilmengen von 1..M darstellen, und wobei die Liste L0 Spaltenindizes enthaelt, deren zugehoerige Spalten in B gleich 0 sind. BESCHREIBUNG Diese Funktion streicht aus der Liste L1 solche Komponenten, deren zugehoerige maximale Minoren von B verschwinden und die keine Spalte aus L0 enthalten. BEISPIEL B:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ]; L1:= AllSubsets(1..6,4); --bei Packages: L1:= LA.AllSubsets(1..6,4); L1; [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 2, 5, 6], [1, 3, 4, 5], [1, 3, 4, 6], [1, 3, 5, 6], [1, 4, 5, 6], [2, 3, 4, 5], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6], [3, 4, 5, 6]] ------------- L0:= [ ]; FindZeroMaxMinors(B,L1,L0); --bei Verwendung von Packages: LA.FindZeroMaxMinors(B,L1,L0); L1; [[1, 3, 4, 5], [1, 3, 4, 6], [1, 3, 5, 6], [1, 4, 5, 6], [2, 3, 4, 5], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6], [3, 4, 5, 6]] ------------- C:= Mat[ [2, 0, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ]; L1:= AllSubsets(1..6,4); --bei Packages: L1:= LA.AllSubsets(1..6,4); L1; [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 2, 5, 6], [1, 3, 4, 5], [1, 3, 4, 6], [1, 3, 5, 6], [1, 4, 5, 6], [2, 3, 4, 5], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6], [3, 4, 5, 6]] ------------- L0:= [2]; FindZeroMaxMinors(C,L1,L0); --bei Verwendung von Packages: LA.FindZeroMaxMinors(C,L1,L0); L1; [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 2, 5, 6], [1, 3, 4, 5], [1, 3, 4, 6], [1, 3, 5, 6], [1, 4, 5, 6], [2, 3, 4, 5], [2, 3, 4, 6], [2, 3, 5, 6], [2, 4, 5, 6], [3, 4, 5, 6]] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 31.5 (FindZeroMaxMinors) Bemerkung 31.6 (Implementierung von FindZeroMaxMinors) ============ GaussDOD ============ SYNTAX GaussDOD(A: MAT): MAT wobei A eine beliebige Matrix ueber einem Integritaetsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A aequivalente Diagonalmatrix aus, die mit dem Gauss-Eliminationsverfahren erzeugt wird. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; GaussDOD(P); --bei Verwendung von Packages: LA.GaussDOD(P); Mat[ [2560, 1280, 0, 0, 0, 0], [0, 0, -640, 0, 0, -640], [0, 0, 0, 160, 0, 160], [0, 0, 0, 0, -80, 80] ] ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 B1DOD ============ GaussTOD ============ SYNTAX GaussTOD(A: MAT): MAT wobei A eine beliebige Matrix ueber einem Integritaetsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A aequivalente Zeilenstufenmatrix aus, die mit dem Gauss-Eliminationsverfahren erzeugt wird. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; GaussTOD(P); --bei Verwendung von Packages: LA.GaussTOD(P); Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, 0, 0, -80, 80] ] ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 B1TOD ============ Generic ============ SYNTAX Generic(N: INT, M: INT): MAT wobei 1 <= N, M ist und wobei CurrentRing() die Variablen z[0..N*M-1] enthalten muss. BESCHREIBUNG Diese Funktion erzeugt die generische NxM-Matrix. BEISPIEL Use S::= Q[z[0..23]]; Generic(4,6); --bei Verwendung von Packages: T.Generic(4,6); Mat[ [z[0], z[1], z[2], z[3], z[4], z[5]], [z[6], z[7], z[8], z[9], z[10], z[11]], [z[12], z[13], z[14], z[15], z[16], z[17]], [z[18], z[19], z[20], z[21], z[22], z[23]] ] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 Abschnitt 18 ============ GenericSymm ============ SYNTAX GenericSymm(N: INT): MAT wobei 1 <= N ist und wobei CurrentRing() die Variablen z[0..(1/2*N*(N+1)-1)] enthalten muss. BESCHREIBUNG Diese Funktion erzeugt die generische symmetrische NxM-Matrix. BEISPIEL Use S::= Q[z[0..20]]; GenericSymm(6); --bei Verwendung von Packages: T.GenericSymm(6); Mat[ [z[0], z[1], z[2], z[3], z[4], z[5]], [z[1], z[6], z[7], z[8], z[9], z[10]], [z[2], z[7], z[11], z[12], z[13], z[14]], [z[3], z[8], z[12], z[15], z[16], z[17]], [z[4], z[9], z[13], z[16], z[18], z[19]], [z[5], z[10], z[14], z[17], z[19], z[20]] ] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 Abschnitt 18 ============ Hankel ============ SYNTAX Hankel(N: INT, M: INT): MAT wobei 1 <= N, M ist und wobei CurrentRing() die Variablen z[0..N+M-2] enthalten muss. BESCHREIBUNG Diese Funktion erzeugt die generische NxM-Hankelmatrix. BEISPIEL Use S::= Q[z[0..8]]; Hankel(4,6); --bei Verwendung von Packages: T.Hankel(4,6); Mat[ [z[0], z[1], z[2], z[3], z[4], z[5]], [z[1], z[2], z[3], z[4], z[5], z[6]], [z[2], z[3], z[4], z[5], z[6], z[7]], [z[3], z[4], z[5], z[6], z[7], z[8]] ] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 Abschnitt 18 ============ Height ============ SYNTAX Height(B: MAT, I: INT): LIST wobei B eine NxM-Zeilenstufenmatrix ist und 0 <= I <= N. BESCHREIBUNG Diese Funktion gibt eine Liste der Indizes aus, deren zugehoerige Spalten in der Matrix B auf der Hoehe I liegen. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ]; Height(P,0); --bei Verwendung von Packages: LA.Height(P,0); [ ] ------------- Height(P,1); --bei Verwendung von Packages: LA.Height(P,1); [1, 2] ------------- Height(P,2); --bei Verwendung von Packages: LA.Height(P,2); [3] ------------- Height(P,4); --bei Verwendung von Packages: LA.Height(P,4); [5, 6] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 31.6 Bemerkung (Implementierung von FindZeroMaxMinors, Height) ============ Injection ============ SYNTAX Injection(A: MAT, N: INT): MAT wobei CurrentRing() = S[x[1..N]] mit einem Ring S ist und A eine Matrix ueber S. BESCHREIBUNG Diese Funktion gibt das Bild der Matrix A unter der kanonischen Injektion von einem Ring S in den Erweiterungsring S[x[1..N]] an. Sie dient als Unterfunktion fuer alle modifizierten Verfahren B1TMDSM, B2TMDMDSM, B1DMDSM, B2DMDMDSM, B1DMDSMFB, B2DMDMDSMFB, B1DMDFBSM, B2DMDMDFBSM, Mal1DMDSM. BEISPIEL Use S::= Q[v]; B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; Use T::= Q[v,x[1..3]]; Injection(B,3); --bei Verwendung von Packages: LA.Injection(B,3); Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ] ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 12.3 (Bemerkung zur Implementierung) ============ KFSM ============ SYNTAX KFSM(A: MAT, K: INT): POLY wobei A eine NxM-Matrix und K ein Zeilenindex aus 1..N ist. BESCHREIBUNG Diese Funktion berechnet den Faktor, der bei den modifizierten Trigonalisierungs- und Diagonalisierungsverfahren den urspruenglichen Teiler KF ersetzt. BEISPIEL Use S::= Q[x[1..2]]; A:= Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [0, 0, 6x[1] - 2x[2] - 24, 2x[1]x[2] + 6x[1] + 12, x[1]x[2] + 6x[1] - 8x[2] - 48, x[1]x[2] + 6x[1] - 2x[2] - 12], [0, 0, 2x[1]x[2] - 2x[2] + 12, 2x[1]x[2] + 12, -8x[2] - 12, x[1]x[2] - 2x[2]] ]; KFSM(A,2); --bei Verwendung von Packages: LA.KFSM(A,2); x[1]x[2] - 12 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 12.2 (B1TMDSM) Satz 13.3 (B2TMDMDSM) Satz 14.2 (B1DMDSM) Satz 15.2 (B2DMDMDSM) Satz 16.3 (B1DMDFBSM, B2DMDMDFBSM) Satz 17.2 (Mal1DMDSM) ============ K2 ============ SYNTAX K2(P: LIST, K: INT): INT BESCHREIBUNG Diese Funktion dient als Unterfunktion fuer MalDichHM und MalDichHR, indem sie anhand der Liste P der Partitionierung und dem Blockende K der oberen Haelfte das Blockende der unteren Haelfte ausgibt. BEISPIEL P:= [1, 2, 4, 8]; --Liste der Partitionierung einer 8xM-Matrix K:= 1; P:= [2, 4, 8]; K2(P,K); --bei Verwendung von Packages: LA.K2(P,K); 2; ------------- K:= 2; P:= [4, 8]; K2(P,K); --bei Verwendung von Packages: LA.K2(P,K); 4; ------------- K:= 4; P:= [8]; K2(P,K); --bei Verwendung von Packages: LA.K2(P,K); 8; ------------- K:= 8; P:= [ ]; K2(P,K); --bei Verwendung von Packages: LA.K2(P,K); 8; ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 MalDichHM, MalDichHR ============ LinRelMaxMinors ============ SYNTAX LinRelMaxMinors(P: LIST, Var L2: LIST, X: LIST): INT oder POLY wobei L2 eine Liste von maximalen Minoren einer NxM-Matrix A mit N <= M ist, wobei P eine Zeile ungleich 0 von A ist und wobei X eine N-elementige Teilmenge von 1..M darstellt. BESCHREIBUNG Diese Funktion berechnet den durch X definierten maximalen Minor von A mittels linearer Relationen aus P und L2 und schreibt ihn dann in L2 an die richtige Position. LinRelMaxMinors dient als Unterfunktion fuer MaxMinorsLR. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; L2:= [0, 0, 0, 0, 0, 0, -20, 20, 20, -20, -10, 10, 10, 0, 0]; ------------- In der Liste L2 sind alle maximalen Minoren von P eingetragen, ausser an vorletzter Position, an der 0 mit dem zu [2,4,5,6] gehoerigen Minor noch ueberschrieben werden muss. ------------- X:= [2,4,5,6]; LinRelMaxMinors(P[1],L2,X); --bei Verwendung von Packages: LA.LinRelMaxMinors(P[1],L2,X); -10 ------------- L2; [0, 0, 0, 0, 0, 0, -20, 20, 20, -20, -10, 10, 10, -10, 0] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 32.5 (MaxMinorsLR, LinRelMaxMinors) Bemerkung 32.7 (Implementierung von MaxMinorsLR) ============ LinRelMinors ============ SYNTAX LinRelMinors(A: MAT, L3: LIST, X: LIST, Y: LIST): INT oder POLY wobei L3 eine Liste von Minoren K-ter Ordnung der NxM-Matrix A ist, wobei die Zeile A[1] hoechstens (K-1)-mal 0 enthaelt und wobei die Listen X, Y K-elementige Teilmengen von 1..N bzw. 1..M darstellen. BESCHREIBUNG Diese Funktion berechnet den durch X, Y definierten Minor von A mittels linearer Relationen aus A[1] und L3. LinRelMinors dient als Unterfunktion fuer MyMinors_2 und MyMinorsLR_2. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; K:= 3; L3:=[0, 0, 0, 0, -8, 16, -24, -4, 12, -12, -4, 8, -12, -2, 6, -6, -14, 14, 14, -14, 0, 0, 0, 0, -6, 12, -18, -8, 14, -4, -3, 6, -9, -4, 7, -2, -18, 18, 18, -18, 0, 0, 0, 0, -8, -4, -4, -4, 12, 8, -4, -2, -2, -2, 6, 4, -4, 4, 4, -4, 0, 0, 0, 0, -4, -12, 8, 8, -4, 4, -2, -6, 4, 4, -2, 2, 8, -8, -8]; ------------- Die Liste L3 enthaelt alle Minoren dritter Ordnung von P ausser den letzten durch [2,3,4][4,5,6] definierten. ------------- LinRelMinors(P,L3,[2,3,4],[4,5,6]); --bei Verwendung von Packages: LA.LinRelMinors(P,L3,[2,3,4],[4,5,6]); 8 ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 34.5 (MyMinors_2, MyMinorsLR_2, LinRelMinors) Bemerkung 34.7 (Implementierung von MyMinors_2, MyMinorsLR_2) ============ ListFirstNonZero ============ SYNTAX ListFirstNonZero(L): OBJECT BESCHREIBUNG Diese Funktion gibt die erste Komponente ungleich 0 aus der Liste L an. Bei L=[] oder L=[0,...,0] erhaelt man 0 als Ergebnis. BEISPIEL L:= [0, 0, 0, 1, 2]; ListFirstNonZero(L); --bei Verwendung von Packages: LA.ListFirstNonZero(L); 1 ------------- L:= [0, 0, 0]; ListFirstNonZero(L); --bzw. LA.ListFirstNonZero(L); 0 ------------- L:= [ ]; ListFirstNonZero(L); --bzw. LA.ListFirstNonZero(L); 0 ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 ============ ListFirstNonZeroPos ============ SYNTAX ListFirstNonZeroPos(L:LIST): INT BESCHREIBUNG Diese Funktion gibt die Position der ersten Komponente ungleich 0 in der Liste L an. Bei L=[] oder L=[0,...,0] erhaelt man 0 als Ergebnis. BEISPIEL L:= [0, 0, 0, 1, 2]; ListFirstNonZeroPos(L); --bei Verwendung von Packages: LA.ListFirstNonZeroPos(L); 4 ------------- L:= [0, 0, 0]; ListFirstNonZeroPos(L); --bzw. LA.ListFirstNonZeroPos(L); 0 ------------- L:= [ ]; ListFirstNonZeroPos(L); --bzw. LA.ListFirstNonZeroPos(L); 0 ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 ============ MalDichHM ============ SYNTAX MalDichHM(A: MAT): MAT MalDichHM(A: MAT, S: INT): MAT MalDichHM(A: MAT, S: INT, Diag: FUNCTION): MAT MalDichHM(A: MAT, S: INT, Diag: FUNCTION, KFLU: INT oder POLY): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. Ferner ist 1 <= S <= N, und Diag ist eine der Funktionen B1DMD, B1DMDFB, B2DMD, B2DMDFB, B2DMDMD, B2DMDMDFB, Mal1DMD. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Dichotomie- Verfahren mit Matrizenmultiplikation und Halbierungs-Partitionierung eine zu A aequivalente Diagonalmatrix. Im zweiten und dritten Fall werden dabei Blockmatrizen der Groesse S mit dem Verfahren Diag diagonalisiert. (Als Voreinstellungen sind S=1 und Diag=B2DMDMDFB gewaehlt.) Der vierte Fall tritt nur auf, wenn diese Funktion sich rekursiv selbst aufruft. Dann wird die erste Division mit dem Teiler KFLU statt mit 1 durchgefuehrt. BEISPIEL A:= Mat[ [2,3,1,0,4,1], [-4,-2,-2,-2,-2,-2], [2,3,0,2,1,1], [2,0,2,2,0,1] ]; MalDichHM(A); --bei Verwendung von Packages: LA.MalDichHM(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- MalDichHM(A,2,B1DMD); --bei Packages: LA.MalDichHM(A,2,B1DMD); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 10.4 (MalDichHM) Bemerkung 10.10 (Implementierung von MalDichHM) MalDichVM, MalDichVR, MalDichHR B1DMD, B1DMDFB, B2DMD, B2DMDFB, B2DMDMD, B2DMDMDFB, Mal1DMD ============ MalDichHR ============ SYNTAX MalDichHR(A: MAT): MAT MalDichHR(A: MAT, S: INT): MAT MalDichHR(A: MAT, S: INT, Diag: FUNCTION): MAT MalDichHR(A: MAT, S: INT, Diag: FUNCTION, KFLU: INT oder POLY): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. Ferner ist 1 <= S <= N, und Diag ist eine der Funktionen B1DMD, B1DMDFB, B2DMD, B2DMDFB, B2DMDMD, B2DMDMDFB, Mal1DMD. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Dichotomie- Verfahren mit zeilenweisem Vorgehen und Halbierungs-Partitionierung eine zu A aequivalente Diagonalmatrix. Im zweiten und dritten Fall werden dabei Blockmatrizen der Groesse S mit dem Verfahren Diag diagonalisiert. (Als Voreinstellungen sind S=1 und Diag=B2DMDMDFB gewaehlt.) Der vierte Fall tritt nur auf, wenn diese Funktion sich rekursiv selbst aufruft. Dann wird die erste Division mit dem Teiler KFLU statt mit 1 durchgefuehrt. BEISPIEL A:= Mat[ [2,3,1,0,4,1], [-4,-2,-2,-2,-2,-2], [2,3,0,2,1,1], [2,0,2,2,0,1] ]; MalDichHR(A); --bei Verwendung von Packages: LA.MalDichHR(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- MalDichHR(A,2,B1DMD); --bei Packages: LA.MalDichHR(A,2,B1DMD); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 10.2 (MalDichHR) Bemerkung 10.10 (Implementierung von MalDichHR) B1DMD, B1DMDFB, B2DMD, B2DMDFB, B2DMDMD, B2DMDMDFB, Mal1DMD ============ MalDichVM ============ SYNTAX MalDichVM(A: MAT): MAT MalDichVM(A: MAT, S: INT): MAT MalDichVM(A: MAT, S: INT, Diag: FUNCTION): MAT MalDichVM(A: MAT, S: INT, Diag: FUNCTION, KFLU: INT oder POLY): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. Ferner ist 1 <= S <= N, und Diag ist eine der Funktionen B1DMD, B1DMDFB, B2DMD, B2DMDFB, B2DMDMD, B2DMDMDFB, Mal1DMD. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Dichotomie- Verfahren mit Matrizenmultiplikation und Verdopplungs-Partitionierung eine zu A aequivalente Diagonalmatrix. Im zweiten und dritten Fall werden dabei Blockmatrizen der Groesse S mit dem Verfahren Diag diagonalisiert. (Als Voreinstellungen sind S=1 und Diag=B2DMDMDFB gewaehlt.) Der vierte Fall tritt nur auf, wenn diese Funktion sich rekursiv selbst aufruft. Dann wird die erste Division mit dem Teiler KFLU statt mit 1 durchgefuehrt. BEISPIEL A:= Mat[ [2,3,1,0,4,1], [-4,-2,-2,-2,-2,-2], [2,3,0,2,1,1], [2,0,2,2,0,1] ]; MalDichVM(A); --bei Verwendung von Packages: LA.MalDichVM(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- MalDichVM(A,2,B1DMD); --bei Packages: LA.MalDichVM(A,2,B1DMD); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 10.8 (MalDichVM) Bemerkung 10.10 (Implementierung von MalDichVM) MalDichVR, MalDichHM, MalDichHR B1DMD, B1DMDFB, B2DMD, B2DMDFB, B2DMDMD, B2DMDMDFB, Mal1DMD ============ MalDichVR ============ SYNTAX MalDichVR(A: MAT): MAT MalDichVR(A: MAT, S: INT): MAT MalDichVR(A: MAT, S: INT, Diag: FUNCTION): MAT MalDichVR(A: MAT, S: INT, Diag: FUNCTION, KFLU: INT oder POLY): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. Ferner ist 1 <= S <= N, und Diag ist eine der Funktionen B1DMD, B1DMDFB, B2DMD, B2DMDFB, B2DMDMD, B2DMDMDFB, Mal1DMD. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Dichotomie- Verfahren mit zeilenweisem Vorgehen und Verdopplungs-Partitionierung eine zu A aequivalente Diagonalmatrix. Im zweiten und dritten Fall werden dabei Blockmatrizen der Groesse S mit dem Verfahren Diag diagonalisiert. (Als Voreinstellungen sind S=1 und Diag=B2DMDMDFB gewaehlt.) Der vierte Fall tritt nur auf, wenn diese Funktion sich rekursiv selbst aufruft. Dann wird die erste Division mit dem Teiler KFLU statt mit 1 durchgefuehrt. BEISPIEL A:= Mat[ [2,3,1,0,4,1], [-4,-2,-2,-2,-2,-2], [2,3,0,2,1,1], [2,0,2,2,0,1] ]; MalDichVR(A); --bei Verwendung von Packages: LA.MalDichVR(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- MalDichVR(A,2,B1DMD); ----bei Packages: LA.MalDichVR(A,2,B1DMD); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 10.6 (MalDichVR) Bemerkung 10.10 (Implementierung von MalDichVR) MalDichVM, MalDichHM, MalDichHR B1DMD, B1DMDFB, B2DMD, B2DMDFB, B2DMDMD, B2DMDMDFB, Mal1DMD ============ Mal1DMD ============ SYNTAX Mal1DMD(A: MAT): MAT Mal1DMD(A: MAT, KF: POLY oder INT): MAT Mal1DMD(A: MAT, KF: POLY oder INT, E: OBJECT): MAT oder BOOL wobei A eine beliebige Matrix ueber einem Integritaetsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Malashonok-1-Schritt- Verfahren mit Division eine zu A aequivalente Diagonalmatrix. Die beiden anderen Faelle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, naemlich von den Dichotomie- Verfahren MalDich* (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird fuer die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgefuehrt bzw. es wird das Abbruchkriterium FALSE ausgegeben, falls rang A nicht maximal ist. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; Mal1DMD(P); --bei Verwendung von Packages: LA.Mal1DMD(P); Mat[ [-20, -10, 0, 0, 0, 0], [0, 0, -20, 0, 0, -20], [0, 0, 0, -20, 0, -20], [0, 0, 0, 0, -20, 20] ] ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; Mal1DMD(A); --bei Verwendung von Packages: LA.Mal1DMD(A); Mat[ [-8, -4, 0, 0], [0, 0, -8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- Mal1DMD(A,1,"MyInv"); --bei Packages: LA.Mal1DMD(A,1,"MyInv"); FALSE ------------- MyInv(A,Mal1DMD); --bei Packages: LA.MyInv(A,Mal1DMD); Die Matrix ist nicht invertierbar. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 8.4 (Mal1DMD, Mal1DMDRow, Mal1Pivot) Bemerkung 8.6 (Implementierung von Mal1DMD) ============ Mal1DMDRow ============ SYNTAX Mal1DMDRow(A: MAT, J: LIST, K:INT, C: INT oder POLY, KF1: INT oder POLY): LIST wobei A eine beliebige NxM-Matrix, K ein Zeilenindex aus 1..(N-1) und wobei J die Liste der Zeilenstufenindizes der ersten K Zeilen von A ist. Ferner stammt C aus dem Ergebnis von Mal1Pivot(A,J,JK,K), und KF1 ist gleich 1 oder gleich dem dritten Argument von Mal1DMD, falls ein solches existiert. BESCHREIBUNG Diese Funktion berechnet nach der Malashonok-1-Schritt-Formel die (K+1)-te Zeile von A neu, wenn mit Hilfe der ersten K Zeilen die ersten K Zeilenstufenspalten aus der Liste J ausgeraeumt werden, wobei ausserdem der Koeffizient A[K+1,J[K+1]] = C gesetzt wird. Mal1DMDRow dient als Unterfunktion fuer Mal1DMD. Falls dabei Mal1DMD von einem Dichotomie-Verfahren MalDich* aufgerufen wird, muss zusaetzlich die Division durch KF1 durchgefuehrt werden. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; J:= [1]; E:= Mal1Pivot(P,J,2,1); --bei Packages: E:= LA.Mal1Pivot(P,J,2,1); E; [Mat[ [2, 1, 3, 1, 0, 4], [-4, -2, -2, -2, -2, -2], [2, 1, 3, 0, 2, 1], [2, 1, 0, 2, 2, 0] ], 3, 8] ------------- Um ausgehend von der Zeilenstufenliste J=[1] unter der ersten Zeile die zweite Spalte auszuraeumen, muessen die zweite und dritte Zeile vertauscht werden. Wendet man die Malashonok-1-Schritt-Formel auf die Matrix mit den getauschten Zeilen an, so wird die naechste Zeilenstufe an Position 3 liegen, mit dem Zeilenstufenkoeffizienten 8. ------------- Append(J,E[2]); J; [1, 3] ------------- P[2]:= Mal1DMDRow(E[1],J,1,E[3],1); --bei Verwendung von Packages: P[2]:= LA.Mal1DMDRow(E[1],J,1,E[3],1); P; Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ] ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 8.4 (Mal1DMD) Bemerkung 8.6 (Implementierung von Mal1DMD) Mal1Pivot ============ Mal1DMDSM ============ SYNTAX Mal1DMDSM(A: MAT): MAT Mal1DMDSM(A: MAT, E1: OBJECT, E2: OBJECT): MAT wobei A eine NxM-Matrix mit N <= M ueber einem Integritaetsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei ausserdem ein Zeilentausch zur Diagonalisierung nicht noetig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Faellen berechnet diese Funktion nach dem modifizierten Malashonok-1-Schritt-Verfahren eine zu A aequivalente Diagonalmatrix. Der zweite Fall tritt nur auf, wenn Mal1DMDSM intern von anderen Funktionen aufgerufen wird, naemlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb noetig, weil MyDet und MyInv stets Trigonalisierungs- oder Diagonalisierungsverfahren mit drei Argumenten verwenden. BEISPIEL A:= Mat[ [2, 3, 1, 0, 4, 1], [-4, -2, -2, -2, -2, -2], [2, 3, 0, 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; Mal1DMDSM(A); --bei Verwendung von Packages: LA.Mal1DMDSM(A); Mat[ [-20, 0, 0, 0, 0, -10], [0, -20, 0, 0, -20, 0], [0, 0, -20, 0, -20, 0], [0, 0, 0, -20, 20, 0] ] ------------- B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; Mal1DMDSM(B); --bei Verwendung von Packages: LA.Mal1DMDSM(B); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- Mal1DMDSM(B,1,"MyDet"); --bei Packages: LA.Mal1DMDSM(B,1,"MyDet"); Mat[ [-20, 0, 0, 0], [0, -20, 0, 0], [0, 0, -20, 0], [0, 0, 0, -20] ] ------------- MyDet(B,Mal1DMDSM); --bei Packages: LA.MyDet(B,Mal1DMDSM); -20 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 17.2 (Mal1DMDSM) Bemerkung 17.3 (Implementierung von Mal1DMDSM) Satz 26.1 (MyDet) Satz 27.3 (MyInv) Mal1DMD ============ Mal1DMDSMRow ============ SYNTAX Mal1DMDSMRow(A: MAT, K:INT): LIST wobei A eine NxM-Matrix und K ein Zeilenindex aus 1..(N-1) ist. BESCHREIBUNG Diese Funktion berechnet nach der modifizierten Malashonok-1-Schritt- Formel die (K+1)-te Zeile von A neu, wenn mit Hilfe der ersten K Zeilen die ersten K Spalten ausgeraeumt werden. Mal1DMDSMRow dient als Unterfunktion fuer Mal1DMDSM. BEISPIEL Use S::= Q[x[1..3]]; A:=Mat[ [x[1], 3, 1, 0, 4, 1], [-4, x[2], -2, -2, -2, -2], [2, 3, x[3], 2, 1, 1], [2, 0, 2, 2, 0, 1] ]; A[2]:= Mal1DMDSMRow(A,1); --bei Verwendung von Packages: A[2]:= LA.Mal1DMDSMRow(A,1); A; Mat[ [x[1], 3, 1, 0, 4, 1], [0, x[1]x[2] + 12, -2x[1] + 4, -2x[1], -2x[1] + 16, -2x[1] + 4], [2, 3, x[3], 2, 1, 1], [2, 0, 2, 2, 0, 1] ] ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Satz 17.4 (Mal1DMDSM) Bemerkung 17.5 (Implementierung von Mal1DMDSM) Mal1DMDRow ============ Mal1Pivot ============ SYNTAX Mal1Pivot(A: MAT, J: LIST, JK: INT, K: INT): LIST wobei A eine beliebige NxM-Matrix ist und wobei K ein Zeilenindex aus 1..(N-1) und JK ein Spaltenindex aus 1..M ist. Ausserdem besteht die Liste J aus den Zeilenstufenindizes der ersten K Zeilen. Die Ergebnisliste ist von der Form [B: MAT, L: INT, C: INT oder POLY]. BESCHREIBUNG Diese Funktion vertauscht die Zeile (K+1) mit der naechstgelegenen Zeile I unter der (K+1)-ten Zeile, falls nicht die Zeile (K+1), sondern die Zeile I die naechste Zeilenstufe enthaelt. Als Ergebnis erhaelt man eine Liste, die als erste Komponente die Matrix mit eventuell getauschten Zeilen enthaelt, als zweite Komponente den naechsten Zeilenstufenindex L und als dritte Komponente den naechsten Zeilenstufenkoeffizienten C. Beim Zeilentausch wird ausserdem die I-te Zeile mit -1 multipliziert. Existiert unter der K-ten Zeile keine weitere Zeilenstufe mehr, so wird das Ergebnis [A,M+1,0] ausgegeben. Diese Funktion wird als Unterfunktion von Mal1DMD aufgerufen. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; Mal1Pivot(P,[1],2,1); --bei Packages: LA.Mal1Pivot(P,[1],2,1); [Mat[ [2, 1, 3, 1, 0, 4], [-4, -2, -2, -2, -2, -2], [2, 1, 3, 0, 2, 1], [2, 1, 0, 2, 2, 0] ], 3, 8] ------------- Um ausgehend von der Zeilenstufenliste J=[1] unter der ersten Zeile die zweite Spalte auszuraeumen, muessen die zweite und dritte Zeile vertauscht werden. Wendet man die Malashonok-1-Schritt-Formel auf die Matrix mit den getauschten Zeilen an, so wird die naechste Zeilenstufe an Position 3 liegen, mit dem Zeilenstufenkoeffizienten 8. ------------- A:= Mat[ [2, 3, 1, 0, 4, 1], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0] ]; Mal1Pivot(A,[1],2,1); --bei Packages: LA.Mal1Pivot(A,[1],2,1); [Mat[ [2, 3, 1, 0, 4, 1], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0] ], 7, 0] ------------- Hier gibt es unterhalb der ersten Zeile keine weitere Zeilenstufe mehr. ------------- SIEHE AUCH mal.coc, mal2.coc, Manual A.1 bis A.3, A.5 Satz 8.4 (Mal1Pivot) Bemerkung 8.6 (Implementierung von Mal1DMD) Mal1DMDRow ============ Mats ============ SYNTAX Mats(X: String): LIST wobei X einer der folgenden Strings sein kann: "MM", "MMS", "D", "E", "F", "A", "AT", "P". BESCHREIBUNG Diese Funktion erzeugt die zur Abkuerzung X gehoerende Liste, naemlich fuer X = "MM" die Liste der Goldmatrizen mit Variablen v,w [MM(N) | N In 4..7], X = "MMS" die Liste der Goldmatrizen ohne letzte Zeile [MMS(N) | N In 4..7], X = "D" die Liste der Zufallsmatrizen mit der Variablen v [D(N) | N In 1..4], X = "E" die Liste der Zufallsmatrizen mit Variablen v, w [E(N) | N In 1..4], X = "F" die Liste der Zufallsmatrizen mit Variablen v, w, x [F(N) | N In 1..2], X = "A" die Liste der ganzzahligen NxM-Zufallsmatrizen mit N <= M [A(I) | I In 1..17], X = "AT" die Liste der ganzzahligen NxM-Zufallsmatrizen mit N >= M (Transponierte von A(I)) [AT(I) | I In 1..17], X = "P" die Liste der ganzzahligen NxM-Zufallsmatrizen mit N <= M [P(N) | N In 1..4]. Sie ist nuetzlich fuer die Funktionen RunTest*. Vorher muss man allerdings die Dateien mata.coc, matdef.coc, matm.coc und matp.coc einlesen. BEISPIEL Use S::= Z/(32003)[vw]; RunTestTime(Mats("MMS"),[B2TMDMD]); --bei Verwendung von Packages: T.RunTestTime(T.Mats("MMS"),[B2TMDMD]); Matrix1: B2TMDMD(...) Cpu time = 0.50, User time = 0 Matrix2: B2TMDMD(...) Cpu time = 7.10, User time = 1 Matrix3: B2TMDMD(...) Cpu time = 48.40, User time = 5 Matrix4: B2TMDMD(...) Cpu time = 292.20, User time = 29 ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 mata.coc, matdef.coc, matm.coc, matp.coc Beispielklassen (Abschnitt 18, 19, 20, 24) ============ MaxMinors ============ SYNTAX MaxMinors(A: MAT): LIST wobei A eine beliebige Matrix ueber einem Integritaetsring ist. BESCHREIBUNG Diese Funktion berechnet alle maximalen Minoren von A. Sie dient auch als Unterfunktion fuer MyMinors und MyMinors_2. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; MaxMinors(P); --bei Verwendung von Packages: LA.MaxMinors(P); [0, 0, 0, 0, 0, 0, -20, 20, 20, -20, -10, 10, 10, -10, 0] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 32.2 (MaxMinors) Bemerkung 32.4 (Implementierung von MaxMinors) MaxMinorsLR, MaxMinors_2 ============ MaxMinorsLR ============ SYNTAX MaxMinorsLR(A: MAT): LIST wobei A eine beliebige Matrix ueber einem Integritaetsring ist. BESCHREIBUNG Diese Funktion berechnet alle maximalen Minoren von A unter Verwendung von linearen Relationen. Sie dient auch als Unterfunktion fuer MyMinorsLR und MyMinorsLR_2. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; MaxMinorsLR(P); --bei Verwendung von Packages: LA.MaxMinorsLR(P); [0, 0, 0, 0, 0, 0, -20, 20, 20, -20, -10, 10, 10, -10, 0] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 32.5 (MaxMinorsLR) Bemerkung 32.7 (Implementierung von MaxMinorsLR) MaxMinors, MaxMinors_2 ============ MaxMinors_2 ============ SYNTAX MaxMinors_2(A: MAT): LIST MaxMinors_2(A: MAT, Alg: FUNCTION): LIST wobei A eine beliebige NxM-Matrix ueber einem Integritaetsring ist mit M = N+1 oder M = N-1 und wobei Alg eine der Diagonalisierungsfunktionen B1DMD, B2DMD, B2DMDMD, B1DMDFB, B2DMDFB, B2DMDMDFB, Mal1DMD sein kann. Gilt N <= M und rang A = N und kommt A ohne Zeilentausch aus, so darf man fuer Alg zusaetzlich eines der Verfahren B1DMDSM, B2DMDMDSM, B1DMDSMFB, B2DMDMDSMFB, B1DMDFBSM, B2DMDMDFBSM, Mal1DMDSM, MalDichHM, MalDichHR, MalDichVM, MalDichVR hernehmen. BESCHREIBUNG Diese Funktion berechnet alle maximalen Minoren von A unter Verwendung der Funktion Alg, wobei im ersten Fall als Voreinstellung Alg = B2DMDMDFB gewaehlt ist. BEISPIEL A:= Mat[ [1, 3, 1, 0, 4], [1, 3, 0, 2, 1], [2, 2, 2, 2, 2], [1, 0, 2, 2, 0] ]; MaxMinors_2(A); --bei Verwendung von Packages: LA.MaxMinors_2(A); [-10, 10, 10, -10, 0] ------------- MaxMinors_2(A,Mal1DMD); --bei Packages: LA.MaxMinors_2(A,Mal1DMD); [-10, 10, 10, -10, 0] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 32.9 (MaxMinors_2) Bemerkung 32.10 (Implementierung von MaxMinors_2) MaxMinorsLR, MaxMinors ============ MM ============ SYNTAX MM(N: INT): MAT wobei 4 <= N <= 9 ist und wobei CurrentRing() die Variablen v und w enthalten muss. BESCHREIBUNG Diese Funktion gibt die Goldmatrix N-ter Ordnung aus. BEISPIEL Use S::= Z/(32003)[vw]; --vorher matm.coc einlesen MM(4); Mat[ [-v^4 - 3v^3 - 3v^2w - vw^2 - 3v^2 - 2vw - v, 3v^2w + 3vw^2 + w^3 + 4vw + 2w^2 + w, -w^2, 0], [4v^4 + 3v^3w + v^2w^2 + 9v^3 + 7v^2w + vw^2 + 6v^2 + 2vw + v, -v^4 - 3v^3w - 3v^2w^2 - vw^3 - 3v^3 - 13v^2w - 8vw^2 - w^3 - 3v^2 - 9vw - 2w^2 - v - w, 3v^2w + 4vw^2 + w^3 + 4vw + 3w^2 + w, -w^2], [-6v^4 - 5v^3w - v^2w^2 - 9v^3 - 4v^2w - 3v^2, 4v^4 + 9v^3w + 6v^2w^2 + vw^3 + 9v^3 + 17v^2w + 5vw^2 + 6v^2 + 5vw + v, -v^4 - 3v^3w - 3v^2w^2 - vw^3 - 3v^3 - 12v^2w - 9vw^2 - w^3 - 3v^2 - 9vw - 2w^2 - v - w, v^2w + 2vw^2 + w^3 + 2vw + 3w^2 + w], [3v^4 + 2v^3w + 3v^3, -3v^4 - 6v^3w - 3v^2w^2 - 6v^3 - 7v^2w - 3v^2, v^4 + 3v^3w + 3v^2w^2 + vw^3 + 3v^3 + 9v^2w + 5vw^2 + 3v^2 + 5vw + v, -v^2w - 2vw^2 - w^3 - 2vw - 2w^2 - w] ] ------------- SIEHE AUCH matm.coc, Manual A.1 bis A.3, A.5 Abschnitt 19 MMS, MMD ============ MMD ============ SYNTAX MMD(N: INT): MAT wobei 4 <= N <= 9 ist und wobei CurrentRing() die Variablen v und w enthalten muss. BESCHREIBUNG Diese Funktion laesst bei der Goldmatrix N-ter Ordnung die letzte Zeile und die letzte Spalte weg. BEISPIEL Use S::= Z/(32003)[vw]; MMD(4); --vorher matm.coc einlesen Mat[ [-v^4 - 3v^3 - 3v^2w - vw^2 - 3v^2 - 2vw - v, 3v^2w + 3vw^2 + w^3 + 4vw + 2w^2 + w, -w^2], [4v^4 + 3v^3w + v^2w^2 + 9v^3 + 7v^2w + vw^2 + 6v^2 + 2vw + v, -v^4 - 3v^3w - 3v^2w^2 - vw^3 - 3v^3 - 13v^2w - 8vw^2 - w^3 - 3v^2 - 9vw - 2w^2 - v - w, 3v^2w + 4vw^2 + w^3 + 4vw + 3w^2 + w], [-6v^4 - 5v^3w - v^2w^2 - 9v^3 - 4v^2w - 3v^2, 4v^4 + 9v^3w + 6v^2w^2 + vw^3 + 9v^3 + 17v^2w + 5vw^2 + 6v^2 + 5vw + v, -v^4 - 3v^3w - 3v^2w^2 - vw^3 - 3v^3 - 12v^2w - 9vw^2 - w^3 - 3v^2 - 9vw - 2w^2 - v - w] ] ------------- SIEHE AUCH matm.coc, Manual A.1 bis A.3, A.5 Abschnitt 19 MM, MMS ============ MMS ============ SYNTAX MMS(N: INT): MAT wobei 4 <= N <= 9 ist und wobei CurrentRing() die Variablen v und w enthalten muss. BESCHREIBUNG Diese Funktion laesst bei der Goldmatrix N-ter Ordnung die letzte Zeile weg. BEISPIEL Use S::= Z/(32003)[vw]; MMS(4); --vorher matm.coc einlesen Mat[ [-v^4 - 3v^3 - 3v^2w - vw^2 - 3v^2 - 2vw - v, 3v^2w + 3vw^2 + w^3 + 4vw + 2w^2 + w, -w^2, 0], [4v^4 + 3v^3w + v^2w^2 + 9v^3 + 7v^2w + vw^2 + 6v^2 + 2vw + v, -v^4 - 3v^3w - 3v^2w^2 - vw^3 - 3v^3 - 13v^2w - 8vw^2 - w^3 - 3v^2 - 9vw - 2w^2 - v - w, 3v^2w + 4vw^2 + w^3 + 4vw + 3w^2 + w, -w^2], [-6v^4 - 5v^3w - v^2w^2 - 9v^3 - 4v^2w - 3v^2, 4v^4 + 9v^3w + 6v^2w^2 + vw^3 + 9v^3 + 17v^2w + 5vw^2 + 6v^2 + 5vw + v, -v^4 - 3v^3w - 3v^2w^2 - vw^3 - 3v^3 - 12v^2w - 9vw^2 - w^3 - 3v^2 - 9vw - 2w^2 - v - w, v^2w + 2vw^2 + w^3 + 2vw + 3w^2 + w] ] ------------- SIEHE AUCH matm.coc, Manual A.1 bis A.3, A.5 Abschnitt 19 MM, MMD ============ MultSM ============ SYNTAX MultSM(F: POLY, G: POLY, I: INT, K: INT): POLY wobei F und G linear in N Unbestimmten x[1..N] sind, wobei K aus 0..N und I aus 1..N ist. BESCHREIBUNG Diese Funktion berechnet das spezielle Sasaki-Murao-Produkt von F und G. BEISPIEL F:= x[1]x[2] + 12; G:= x[1] - 2; MultSM(F,G,1,1); --bei Verwendung von Packages: LA.MultSM(F,G,1,1); x[1]x[2] - 2x[2] + 12 ------------- F:= 6x[1] - 2x[2] - 24; G:= -8x[2] - 12; MultSM(F,G,1,2); --bei Verwendung von Packages: LA.MultSM(F,G,1,2); -48 ------------- F:= 2x[1]x[2]x[3] - 4x[1]x[2] + 12x[3]- 36; G:= x[2]x[3] - x[2] + 6x[3] - 6; MultSM(F,G,1,3); --bei Verwendung von Packages: LA.MultSM(F,G,1,3); 2x[2]x[3] - 6x[2] + 12x[3] - 36 ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 Abschnitt 11 ============ MyDet ============ SYNTAX MyDet(A: MAT): INT oder POLY MyDet(A: MAT, Alg: FUNCTION): INT oder POLY wobei A eine quadratische Matrix ueber einem Integritaetsring ist und wobei Alg eine der Trigonalisierungs- oder Diagonalisierungsfunktionen B1TMD, B2TMD, B2TMDMD, B1DMD, B2DMD, B2DMDMD, B1DMDFB, B2DMDFB, B2DMDMDFB, Mal1DMD sein kann, wenn A eine beliebige quadratische Matrix ist. Ist der Rang von A maximal und kommt A ohne Zeilentausch aus, so darf man fuer Alg zusaetzlich eines der Verfahren B1TMDSM, B2TMDMDSM, B1DMDSM, B2DMDMDSM, B1DMDSMFB, B2DMDMDSMFB, B1DMDFBSM, B2DMDMDFBSM, Mal1DMDSM, MalDichHM, MalDichHR, MalDichVM, MalDichVR hernehmen. BESCHREIBUNG Diese Funktion gibt die Determinante der Matrix A aus, wobei im zweiten Fall eines der genannten Verfahren zur Bestimmung der Determinante dient, waehrend im ersten Fall B2TMDMD als Voreinstellung gewaehlt ist. BEISPIEL A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; MyDet(A); --bei Verwendung von Packages: LA.MyDet(A); 0 ------------- MyDet(A, Mal1DMD); --bei Packages: LA.MyDet(A, Mal1DMD); 0 ------------- Im ersten Beispiel wird mit B2TMDMD die zugehoerige Zeilenstufenmatrix Mat[ [2, 1, 3, 1], [0, 0, 8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] nicht vollstaendig erzeugt, denn es laesst sich bereits nach dem Ausraeumen der ersten Spalte sehen, dass rang A < N gilt und daher |A| = 0. Analog muss auch im zweiten Beispiel mit Mal1DMD die Diagonalmatrix Mat[ [-8, -4, 0, 0], [0, 0, -8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] nicht vollstaendig berechnet werden. ------------- SIEHE AUCH linalg.coc, Manual A.1 bis A.3, A.5 Satz 26.1 (MyDet) Bemerkung 26.3 (Implementierung von MyDet) B1TMD, B2TMD, B2TMDMD, B1DMD, B2DMD, B2DMDMD, B1DMDFB, B2DMDFB, B2DMDMDFB, Mal1DMD (Abbruchkriterium FALSE) ============ MyInv ============ SYNTAX MyInv(A: MAT): LIST oder STRING MyInv(A: MAT, Alg: FUNCTION): LIST oder STRING wobei A eine quadratische Matrix ueber einem Integritaetsring ist und wobei Alg eine der Diagonalisierungsfunktionen B1DMD, B2DMD, B2DMDMD, B1DMDFB, B2DMDFB, B2DMDMDFB, Mal1DMD sein kann, wenn A eine beliebige quadratische Matrix ist. Ist der Rang von A maximal und kommt A ohne Zeilentausch aus, so darf man fuer Alg zusaetzlich eines der Verfahren B1DMDSM, B2DMDMDSM, B1DMDSMFB, B2DMDMDSMFB, B1DMDFBSM, B2DMDMDFBSM, Mal1DMDSM, MalDichHM, MalDichHR, MalDichVM, MalDichVR hernehmen. Die Ergebnisliste ist von der Form [Det: INT oder POLY, Adj: MAT]. BESCHREIBUNG Diese Funktion gibt, sofern A invertierbar ist, die Ergebnisliste mit der Determinanten und der Adjunkten von A aus bzw. andernfalls das Ergebnis "Die Matrix ist nicht invertierbar." Im zweiten Fall dient eines der genannten Verfahren zur Bestimmung der Inversen, waehrend im ersten Fall B2DMDMDFB als Voreinstellung gewaehlt ist. BEISPIEL A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; MyInv(A, Mal1DMD); --bei Packages: LA.MyInv(A, Mal1DMD); "Die Matrix ist nicht invertierbar." ------------- Im ersten Beispiel wird mit Mal1DMD die zugehoerige Diagonalmatrix nicht vollstaendig berechnet, denn es laesst sich bereits nach dem Ausraeumen der ersten Spalte sehen, dass rang A < N gilt und dass daher A nicht invertierbar ist. ------------- B:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 2, 0, 2] ]; L:= MyInv(B,Mal1DMD); --bei Packages: L:= LA.MyInv(B,Mal1DMD); L; [-8, Mat[ [4, 0, -6, 4], [4, -8, 6, -8], [-4, 0, 2, 0], [-8, 8, 0, 0] ]] ------------- Es gilt fuer die erste Komponente -8 = |B|, die zweite Komponente gibt die Adjunkte von B an. Die Inverse von B erhaelt man mit ------------- L[1]^(-1) * L[2]; Mat[ [-1/2, 0, 3/4, -1/2], [-1/2, 1, -3/4, 1], [1/2, 0, -1/4, 0], [1, -1, 0, 0] ] ------------- SIEHE AUCH linalg.coc, Manual A.1 bis A.3, A.5 Satz 27.3 (MyInv) Bemerkung 27.5 (Implementierung von MyInv) B1TMD, B2TMD, B2TMDMD, B1DMD, B2DMD, B2DMDMD, B1DMDFB, B2DMDFB, B2DMDMDFB, Mal1DMD (Abbruchkriterium FALSE) ============ MyLinKer ============ SYNTAX MyLinKer(A: MAT): LIST MyLinKer(A: MAT, Alg: FUNCTION): LIST wobei A eine beliebige NxM-Matrix ueber einem Integritaetsring ist und wobei Alg eine der Diagonalisierungsfunktionen B1DMD, B2DMD, B2DMDMD, B1DMDFB, B2DMDFB, B2DMDMDFB, Mal1DMD sein kann. Gilt N <= M, rang A = N, liegen alle zeilenstufen auf der Diagonalen und kommt A ohne Zeilentausch aus, so darf man fuer Alg zusaetzlich eines der Verfahren B1DMDSM, B2DMDMDSM, B1DMDSMFB, B2DMDMDSMFB, B1DMDFBSM, B2DMDMDFBSM, Mal1DMDSM, MalDichHM, MalDichHR, MalDichVM, MalDichVR hernehmen. BESCHREIBUNG Diese Funktion gibt als Ergebnis eine Liste von Listen aus, die Basisvektoren fuer den Loesungraum des homogenen linearen Gleichungssystems Ax=0 darstellen. Dieses Ergebnis wird im zweiten Fall unter Verwendung von Alg ermittelt, waehrend im ersten Fall als Voreinstellung Alg = B2DMDMDFB gilt. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; MyLinKer(P); --bei Verwendung von Packages: LA.MyLinKer(P); [[-10, 20, 0, 0, 0, 0], [0, 0, -20, -20, 20, 20]] ------------- MyLinKer(P,Mal1DMD); --bei Packages: LA.MyLinKer(P,Mal1DMD); [[-10, 20, 0, 0, 0, 0], [0, 0, -20, -20, 20, 20]] ------------- A:= Mat[ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ]; MyLinKer(A); --bei Verwendung von Packages: LA.MyLinKer(A); [ ] ------------- Falls nur die triviale Loesung existiert, wird als Ergebnis die leere Liste ausgegeben. ------------- SIEHE AUCH linalg.coc, Manual A.1 bis A.3, A.5 Satz 28.3 (MyLinKer) Bemerkung 28.5 (Implementierung von MyLinKer, FindKer) FindKer MyLinKerMin MyLinSol, MyLinSolMin ============ MyLinKerMin ============ SYNTAX MyLinKerMin(A: MAT): LIST wobei A eine beliebige Nx(N+1)-Matrix mit rang A = N ist, deren Zeilenstufen alle auf der Diagonalen liegen. BESCHREIBUNG Diese Funktion gibt unter Verwendung der eingabauten Funktion Minors als Ergebnis eine Liste aus, deren einzige Komponente ein Basisvektor fuer den eindimensionalen Loesungraum des homogenen linearen Gleichungssystems Ax=0 darstellt. BEISPIEL P:= Mat[ [2, 3, 1, 0, 4], [2, 3, 0, 2, 1], [4, 2, 2, 2, 2], [2, 0, 2, 2, 0] ]; MyLinKerMin(P); --bei Verwendung von Packages: LA.MyLinKerMin(P); [[0, -20, -20, 20, 20]] ------------- SIEHE AUCH linalg.coc, Manual A.1 bis A.3, A.5 Satz 28.6 (MyLinKerMin) MyLinKer MyLinSol, MyLinSolMin ============ MyLinSol ============ SYNTAX MyLinSol(A: MAT, B: MAT): LIST MyLinSol(A: MAT, B: MAT, Alg: FUNCTION): LIST wobei A eine beliebige NxM-Matrix ueber einem Integritaetsring und B eine beliebige NxP-Matrix ueber demselben Integritaetsring ist und wobei Alg eine der Diagonalisierungsfunktionen B1DMD, B2DMD, B2DMDMD, B1DMDFB, B2DMDFB, B2DMDMDFB, Mal1DMD sein kann. Gilt N <= M, rang A = N, liegen alle Zeilenstufen auf der Diagonalen und kommt A ohne Zeilentausch aus, so darf man fuer Alg zusaetzlich eines der Verfahren B1DMDSM, B2DMDMDSM, B1DMDSMFB, B2DMDMDSMFB, B1DMDFBSM, B2DMDMDFBSM, Mal1DMDSM, MalDichHM, MalDichHR, MalDichVM, MalDichVR hernehmen. Die Ergebnisliste ist von der Form [Det: INT oder POLY, Sol: LIST, LinKer: LIST]. BESCHREIBUNG Diese Funktion gibt als Ergebnis eine Liste aus, deren erste Komponente Det der Zeilenstufenkoeffizient der zu A aequivalenten Matrix ist. Als zweite Komponente folgt eine Liste, deren Komponenten spezielle Loesungen fuer den Loesungraum des inhomogenen linearen Gleichungssystems Ax=B darstellen, wenn man sie durch Det teilt, bzw. die "Das Gleichungssystem ist nicht loesbar." besagen. Die dritte Komponente ist eine Liste, deren Komponenten Basisvektoren des zugehoerigen homogenen Gleichungssystems Ax=0 darstellen. Das Ergebnis von MyLinSol wird unter Verwendung von Alg ermittelt, wobei im ersten Fall als Voreinstellung Alg = B2DMDMDFB gewaehlt ist. BEISPIEL A:= Mat[ [2, 1, 3, 1, 0], [2, 1, 3, 0, 2], [4, 2, 2, 2, 2], [2, 1, 0, 2, 2] ]; B:= Mat[ [4], [1], [2], [0] ]; MyLinSol(A,B); --bei Verwendung von Packages: LA.MyLinSol(A,B); [-20, [[0, 0, -20, -20, 20]], [[-10, 20, 0, 0, 0]]] ------------- Das Gleichungssystem Ax=B ist loesbar mit der speziellen Loesung ((-20)^(-1)) * [0, 0, -20, -20, 20] = [0, 0, 1, 1, -1]. Das zugehoerige homogene Gleichungssystem Ax=0 besitzt [-10, 20, 0, 0, 0] als Basisvektor. ------------- A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; B:= Mat[ [0, 4], [2, 1], [2, 2], [2, 0] ]; MyLinSol(A,B); --bei Verwendung von Packages: LA.MyLinSol(A,B); [-20, ["Das Gleichungssystem ist nicht loesbar.", "Das Gleichungssystem ist nicht loesbar."], [[-10, 20, 0, 0]]] ------------- Das Gleichungssystem Ax=B ist also nicht loesbar. Das zugehoerige homogene Gleichungssystem Ax=0 besitzt [-10, 20, 0, 0] als Basisvektor. ------------- A:= Mat[ [2], [2], [4], [2] ]; B:= Mat[ [1, 3, 1, 0, 4], [1, 3, 0, 2, 1], [2, 2, 2, 2, 2], [1, 0, 2, 2, 0] ]; MyLinSol(A,B); --bei Verwendung von Packages: LA.MyLinSol(A,B); [-20, [[-10], "Das Gleichungssystem ist nicht loesbar.", "Das Gleichungssystem ist nicht loesbar.", "Das Gleichungssystem ist nicht loesbar.", "Das Gleichungssystem ist nicht loesbar."], [ ]] ------------- Das Gleichungssystem Ax=B ist fuer die erste Spalte von B loesbar mit der speziellen Loesung ((-20)^(-1)) * [-10] = [1/2]. Fuer die uebrigen Spalten ist es nicht loesbar. Das zugehoerige homogene Gleichungssystem Ax=0 besitzt nur die triviale Loesung. ------------- SIEHE AUCH linalg.coc, Manual A.1 bis A.3, A.5 Satz 29.3 (MyLinSol) Bemerkung 29.5 (Implementierung von MyLinSol, FindSol) FindSol MyLinSolMin MyLinKer, MyLinKerMin ============ MyLinSolMin ============ SYNTAX MyLinSolMin(A: MAT, B: MAT): LIST MyLinSolMin(C: MAT): LIST wobei im ersten Fall A eine quadratische NxN-Matrix mit rang A= N und B eine Nx1-Matrix ist. Im zweiten Fall ist C eine beliebige Nx(N+1)-Matrix mit rang C = N, deren Zeilenstufen alle auf der Diagonalen liegen, d.h. C = (A|B) laesst sich als erweiterte Koeffizientenmatrix mit Matrizen A und B wie im ersten Fall auffassen. Die Ergebnisliste ist von der Form [Det: INT oder POLY, Sol: LIST]. BESCHREIBUNG Diese Funktion gibt unter verwendung der eingebauten Funktion Minors als Ergebnis eine Liste aus, deren erste Komponente Det die Determinante von A darstellt. Die zweite Komponente ist eine Liste, deren einzige Komponente die eindeutig bestimmte spezielle Loesung von Ax=B ist, wenn man sie durch Det teilt. BEISPIEL A:= Mat[ [2, 3, 1, 0], [2, 3, 0, 2], [4, 2, 2, 2], [2, 0, 2, 2] ]; B:= Mat[ [4], [1], [2], [0] ]; MyLinSolMin(A,B);--bei Verwendung von Packages: LA.MyLinSolMin(A,B); [-20, [[0, -20, -20, 20]]] ------------- Die eindeutig bestimmte spezielle Loesung von Ax=B lautet also ((-20)^(-1)) * [0, -20, -20, 20] = [0, 1, 1, -1]. ------------- C:= Mat[ [2, 3, 1, 0, 4], [2, 3, 0, 2, 1], [4, 2, 2, 2, 2], [2, 0, 2, 2, 0] ]; MyLinSolMin(C); --bei Verwendung von Packages: LA.MyLinSolMin(C); [-20, [[0, -20, -20, 20]]] ------------- SIEHE AUCH linalg.coc, Manual A.1 bis A.3, A.5 Satz 29.6 (MyLinSolMin) MyLinSol MyLinKer, MyLinKerMin ============ MyMinors ============ SYNTAX MyMinors(K: INT, A: MAT): LIST wobei A eine beliebige NxM-Matrix ueber einem Integritaetsring und 1 <= K <= N, M ist. BESCHREIBUNG Diese Funktion berechnet alle Minoren K-ter Ordnung von A unter Verwendung von MaxMinors. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; MyMinors(3,P); --bei Verwendung von Packages: LA.MyMinors(3,P); [0, 0, 0, 0, -8, 16, -24, -4, 12, -12, -4, 8, -12, -2, 6, -6, -14, 14, 14, -14, 0, 0, 0, 0, -6, 12, -18, -8, 14, -4, -3, 6, -9, -4, 7, -2, -18, 18, 18, -18, 0, 0, 0, 0, -8, -4, -4, -4, 12, 8, -4, -2, -2, -2, 6, 4, -4, 4, 4, -4, 0, 0, 0, 0, -4, -12, 8, 8, -4, 4, -2, -6, 4, 4, -2, 2, 8, -8, -8, 8] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 34.1 (MyMinors) Bemerkung 34.3 (Implementierung von MyMinors) MaxMinors MyMinorsLR, MyMinors_2, MyMinorsLR_2 ============ MyMinorsLR ============ SYNTAX MyMinorsLR(K: INT, A: MAT): LIST wobei A eine beliebige NxM-Matrix ueber einem Integritaetsring und 1 <= K <= N, M ist. BESCHREIBUNG Diese Funktion berechnet alle Minoren K-ter Ordnung von A unter Verwendung von MaxMinorsLR. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; MyMinorsLR(3,P); --bei Packages: LA.MyMinorsLR(3,P); [0, 0, 0, 0, -8, 16, -24, -4, 12, -12, -4, 8, -12, -2, 6, -6, -14, 14, 14, -14, 0, 0, 0, 0, -6, 12, -18, -8, 14, -4, -3, 6, -9, -4, 7, -2, -18, 18, 18, -18, 0, 0, 0, 0, -8, -4, -4, -4, 12, 8, -4, -2, -2, -2, 6, 4, -4, 4, 4, -4, 0, 0, 0, 0, -4, -12, 8, 8, -4, 4, -2, -6, 4, 4, -2, 2, 8, -8, -8, 8] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 34.1 (MyMinorsLR) Bemerkung 34.3 (Implementierung von MyMinorsLR) MaxMinorsLR MyMinors, MyMinors_2, MyMinorsLR_2 ============ MyMinorsLR_2 ============ SYNTAX MyMinorsLR_2(K: INT, A: MAT): LIST wobei A eine beliebige NxM-Matrix ueber einem Integritaetsring und 1 <= K <= N, M ist. BESCHREIBUNG Diese Funktion berechnet alle Minoren K-ter Ordnung von A unter Verwendung von MaxMinorsLR und von linearen Relationen. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; MyMinorsLR_2(3,P); --bei Packages: LA.MyMinorsLR_2(3,P); [0, 0, 0, 0, -8, 16, -24, -4, 12, -12, -4, 8, -12, -2, 6, -6, -14, 14, 14, -14, 0, 0, 0, 0, -6, 12, -18, -8, 14, -4, -3, 6, -9, -4, 7, -2, -18, 18, 18, -18, 0, 0, 0, 0, -8, -4, -4, -4, 12, 8, -4, -2, -2, -2, 6, 4, -4, 4, 4, -4, 0, 0, 0, 0, -4, -12, 8, 8, -4, 4, -2, -6, 4, 4, -2, 2, 8, -8, -8, 8] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 34.5 (MyMinorsLR_2) Bemerkung 34.7 (Implementierung von MyMinorsLR_2) MaxMinorsLR MyMinors, MyMinorsLR, MyMinors_2 ============ MyMinors_2 ============ SYNTAX MyMinors_2(K: INT, A: MAT): LIST wobei A eine beliebige NxM-Matrix ueber einem Integritaetsring und 1 <= K <= N, M ist. BESCHREIBUNG Diese Funktion berechnet alle Minoren K-ter Ordnung von A unter Verwendung von MaxMinors und von linearen Relationen. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; MyMinors_2(3,P); --bei Packages: LA.MyMinors_2(3,P); [0, 0, 0, 0, -8, 16, -24, -4, 12, -12, -4, 8, -12, -2, 6, -6, -14, 14, 14, -14, 0, 0, 0, 0, -6, 12, -18, -8, 14, -4, -3, 6, -9, -4, 7, -2, -18, 18, 18, -18, 0, 0, 0, 0, -8, -4, -4, -4, 12, 8, -4, -2, -2, -2, 6, 4, -4, 4, 4, -4, 0, 0, 0, 0, -4, -12, 8, 8, -4, 4, -2, -6, 4, 4, -2, 2, 8, -8, -8, 8] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 34.5 (MyMinors_2) Bemerkung 34.7 (Implementierung von MyMinors_2) MaxMinors MyMinors, MyMinorsLR, MyMinorsLR_2 ============ MyRank ============ SYNTAX MyRank(A: MAT): INT MyRank(A: MAT, Alg: FUNCTION): INT wobei A eine beliebige Matrix ueber einem Integritaetsring ist und wobei Alg eine der Trigonalisierungs- oder Diagonalisierungsfunktionen B1TOD, B1TMD, B2TMD, B2TMDMD, B1DOD, B1DMD, B2DOD, B2DMD, B2DMDMD, B1DMDFB, B2DMDFB, B2DMDMDFB, Mal1DMD ist. BESCHREIBUNG Diese Funktion gibt den Rang der Matrix A aus, wobei im zweiten Fall eines der genannten Verfahren zur Bestimmung des Rangs dient, waehrend im ersten Fall B2TMDMD als Voreinstellung gewaehlt ist. BEISPIEL A:= Mat[ [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; MyRank(A); --bei Verwendung von Packages: LA.MyRank(A); 3 ------------- MyRank(A, Mal1DMD); --bei Packages: LA.MyRank(A, Mal1DMD); 3 ------------- Im ersten Beispiel wird mit B2TMDMD die Zeilenstufenmatrix Mat[ [2, 1, 3, 1], [0, 0, 8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] erzeugt, im zweiten Beispiel mit Mal1DMD die Diagonalmatrix Mat[ [-8, -4, 0, 0], [0, 0, -8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] ------------- SIEHE AUCH linalg.coc, Manual A.1 bis A.3, A.5 Satz 25.1 (MyRank) Bemerkung 25.3 (Implementierung von MyRank) ============ P ============ SYNTAX P(N: INT): MAT wobei 1 <= N <= 4 ist. BESCHREIBUNG Diese Funktion ruft eine ganzzahlige, mit RandMatInt erzeugte NxM-Zufallsmatrix mit N <= M ab, deren Koeffizienten zwischen 0 und 100 liegen, und zwar fuer N = 1 eine 50x51-Matrix (RandMatInt(50,51,100)) N = 2 eine 50x60-Matrix (RandMatInt(50,60,100)) N = 3 eine 100x101-Matrix (RandMatInt(100,101,100)) N = 4 eine 100x110-Matrix (RandMatInt(100,110,100)). Vorher muss allerdings die Datei matp.coc eingelesen werden. SIEHE AUCH matp.coc, Manual A.1 bis A.3, A.5 Abschnitt 24 RandMatInt ============ PartialB2TMDMD ============ SYNTAX PartialB2TMDMD(A: MAT, K: INT): LIST wobei A eine beliebige NxM-Matrix ueber einem Integritaetsring und 1 <= K <= N, M ist. Die Ergebnisliste ist von der Form [Pi: LIST, Zst: LIST, B: MAT]. BESCHREIBUNG Diese Funktion berechnet nach dem Bareiss-2-Schritt- Verfahren mit zweimaliger Division eine zu A aequivalente partielle Zeilenstufenmatrix, in der die ersten K-1 Zeilenstufenspalten ausgeraeumt sind und in der nach eventuellem Zeilentausch die K-te Zeile die naechste Zeilenstufe stellt, sofern eine solche existiert. Als Ergebnis erhaelt man eine Liste, deren erste Komponente Pi die Zeilenpermutation darstellt. Die zweite Komponente Zst ist die Indexliste der Zeilenstufenspalten der ersten K Zeilen. Die dritte Komponente ist schliesslich die zu A aequivalente partiell trigonalisierte Zeilenstufenmatrix. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; PartialB2TMDMD(P,1); --bei Packages: LA.PartialB2TMDMD(P,1); [[1, 2, 3, 4], [1], Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]] ------------- PartialB2TMDMD(P,2); --bei Packages: LA.PartialB2TMDMD(P,2); [[1, 3, 2, 4], [1, 3], Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ]] ------------- Neben der Zeilenstufenspalte 1 wird zugleich auch die zweite Spalte ausgeraeumt. Ausserdem werden bereits die zweite und dritte Zeile vertauscht, so dass an Position (2,3) die naechste Zeilenstufe zu liegen kommt. ------------- PartialB2TMDMD(P,3); --bei Packages: LA.PartialB2TMDMD(P,3); [[1, 3, 2, 4], [1, 3, 4], Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 8, 4, 4] ]] ------------- PartialB2TMDMD(P,4); --bei Packages: LA.PartialB2TMDMD(P,4); [[1, 3, 2, 4], [1, 3, 4, 5], Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -8, 16, -24], [0, 0, 0, 0, -20, 20] ]] ------------- A:= Mat[ [0, 0, 0, 0], [2, 1, 3, 1], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]; PartialB2TMDMD(A,1); --bei Packages: LA.PartialB2TMDMD(A,1); [[2, 1, 3, 4, 5], [1], Mat[ [-2, -1, -3, -1], [0, 0, 0, 0], [2, 1, 3, 0], [4, 2, 2, 2], [2, 1, 0, 2] ]] ------------- Es wird zwar keine Spalte ausgeraeumt, aber ein Zeilentausch bringt die erste Zeilenstufe an die richtige Position. ------------- PartialB2TMDMD(A,4); --bei Packages: LA.PartialB2TMDMD(A,4); [[2, 4, 3, 1, 5], [1, 3, 4], Mat[ [-2, -1, -3, -1], [0, 0, -8, 0], [0, 0, 0, 8], [0, 0, 0, 0], [0, 0, 0, 0] ]] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 35.4 (PartialB2TMDMD) Bemerkung 35.5 (Implementierung von PartialB2TMDMD) B2TMDMD ============ PartialC0Pivot ============ SYNTAX PartialC0Pivot(A: MAT, J: INT, K: INT, Var Pi: LIST): LIST wobei A eine beliebige NxM-Matrix ist und wobei K ein Zeilenindex aus 1..(N-1) und J ein Spaltenindex aus 1..(M-1) ist. Pi ist eine Permutation von 1..N. Die Ergebnisliste ist von der Form [B: MAT, C0: INT oder POLY]. BESCHREIBUNG Diese Funktion versucht, durch Zeilentausch die naechste Zeilenstufe an Position (K+1,J+1) zu erhalten, wobei C0 der an dieser Position zu erwartende Koeffizient ist, wenn man mit Hilfe der K-ten Zeile die J-te Spalte ausraeumt. Beim Zeilentausch wird ausserdem die L-te Zeile mit -1 multipliziert. Dieselbe Vertauschung wird entsprechend an Pi vorgenommen. Als Ergebnis erhaelt man eine Liste, die als erste Komponente die Matrix mit eventuell getauschten Zeilen und als zweite Komponente C0 enthaelt. Liegt in der Spalte (J+1) keine Zeilenstufe, so ist insbesondere C0=0. Diese Funktion wird als Unterfunktion von PartialB2TMDMD aufgerufen. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ]; Pi:= [1, 2, 3, 4]; PartialC0Pivot(P,1,1,Pi); --bei Packages: LA.PartialC0Pivot(P,1,1,Pi); [Mat[ [2, 1, 3, 1, 0, 4], [2, 1, 3, 0, 2, 1], [4, 2, 2, 2, 2, 2], [2, 1, 0, 2, 2, 0] ], 0] ------------- Pi; [1, 2, 3, 4] ------------- Im ersten Beispiel ist es nicht moeglich, Zeilen so zu tauschen, dass man an der Position (2,2) einen Koeffizienten ungleich 0 erhaelt, wenn man mit der ersten Zeile die erste Spalte ausraeumt. ------------- A:= Mat[ [ 1, 3, 1, 0, 4], [ 1, 3, 0, 2, 1], [ 2, 2, 2, 2, 2], [ 1, 0, 2, 2, 0] ]; Pi:= [1, 2, 3, 4]; PartialC0Pivot(A,1,1,Pi); --bei Packages: LA.PartialC0Pivot(A,1,1,Pi); [Mat[ [1, 3, 1, 0, 4], [-2, -2, -2, -2, -2], [1, 3, 0, 2, 1], [1, 0, 2, 2, 0] ], 4] ------------- Pi; [1, 3, 2, 4] ------------- Beim zweiten Beispiel muss man die zweite und dritte Zeile tauschen, um an Position (2,2) die naechste Zeilenstufe mit C0=4 zu erhalten. ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 35.4 (PartialB2TMDMD, PartialC0Pivot) Bemerkung 35.5 (Implementierung von PartialB2TMDMD) C0Pivot ============ PartialPivot ============ SYNTAX PartialPivot(A: MAT, J: INT, K: INT, Var Pi: LIST): MAT wobei A eine beliebige NxM-Matrix ist und wobei K ein Zeilenindex aus 1..N und J ein Spaltenindex aus 1..M ist. Pi ist eine Permutation von 1..N. BESCHREIBUNG Falls A[K,J]=0 gilt, so vertauscht diese Funktion die Zeile K und die naechstgelegene Zeile L unter der K-ten Zeile mit A[L,J] <> 0, falls eine solche Zeile L existiert. Es wird also versucht, durch einen Zeilentausch die naechste Zeilenstufe an Position (K,J) zu bringen. Bei einem Zeilentausch wird ausserdem die L-te Zeile mit -1 multipliziert. Dieselbe Vertauschung wird entsprechend an Pi vorgenommen. Diese Funktion wird als Unterfunktion von PartialB2TMDMD aufgerufen. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 0, -2, 4, -6], [0, 0, -8, 0, 4, -12], [0, 0, -6, 2, 4, -8] ]; Pi:= [1, 2, 3, 4]; PartialPivot(P,3,2,Pi); --bei Packages: LA.PartialPivot(P,3,2,Pi); Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ] ------------- Pi; [1, 3, 2, 4] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 35.4 (PartialB2TMDMD, PartialPivot) Bemerkung 35.5 (Implementierung von PartialB2TMDMD, PartialPivot) Pivot ============ Pivot ============ SYNTAX Pivot(A: MAT, J: INT, K: INT): MAT wobei A eine beliebige NxM-Matrix ist und wobei K ein Zeilenindex aus 1..N und J ein Spaltenindex aus 1..M ist. BESCHREIBUNG Falls A[K,J]=0 gilt, so vertauscht diese Funktion die Zeile K und die naechstgelegene Zeile L unter der K-ten Zeile mit A[L,J] <> 0, falls eine solche Zeile L existiert. Es wird also versucht, durch einen Zeilentausch die naechste Zeilenstufe an Position (K,J) zu bringen. Bei einem Zeilentausch wird ausserdem die L-te Zeile mit -1 multipliziert. Diese Funktion wird als Unterfunktion von allen Bareiss- Verfahren B1TOD, B1TMD, B2TOD, B2TMD, B2TMDMD, B1DOD, B1DMD, B2DOD, B2DMD, B2DMDMD und von Mal1DMD aufgerufen. BEISPIEL P:= Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 0, -2, 4, -6], [0, 0, -8, 0, 4, -12], [0, 0, -6, 2, 4, -8] ]; Pivot(P,3,2); --bei Verwendung von Packages: LA.Pivot(P,3,2); Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 8, 0, -4, 12], [0, 0, 0, -2, 4, -6], [0, 0, -6, 2, 4, -8] ] ------------- Pivot(P,2,2); --bei Verwendung von Packages: LA.Pivot(P,2,2); Mat[ [2, 1, 3, 1, 0, 4], [0, 0, 0, -2, 4, -6], [0, 0, -8, 0, 4, -12], [0, 0, -6, 2, 4, -8] ] ------------- Im ersten Beispiel ist es moeglich, die zweite und dritte Zeile zu tauschen, um an der Position (2,3) einen Koeffizienten ungleich 0 zu erhalten, im zweiten Beispiel kann dagegen kein Zeilentausch bewirken, dass an der Position (2,2) ein Koeffizient ungleich 0 steht. ------------- SIEHE AUCH bareiss.coc, bareiss2.coc, Manual A.1 bis A.3, A.5 Satz 3.7 (Pivot) Bemerkung 3.10 (Implementierung) B1TOD, B1TMD, B2TOD, B2TMD, B2TMDMD, B1DOD, B1DMD, B2DOD, B2DMD, B2DMDMD Mal1DMD ============ PosMinor ============ SYNTAX PosMinor(X: LIST, N: INT): INT PosMinor(X: LIST, Y: LIST, N: INT, M: INT): INT wobei N, M >= 1 gilt und wobei die Listen X bzw. X und Y jeweils K-elementige Teilmengen von 1..N bzw. 1..M darstellen fuer ein K mit 1 <= K <= N, M. BESCHREIBUNG Im ersten Fall berechnet diese Funktion die Position von X in der lexikographisch geordneten Liste aller K-elementigen Teilmengen von 1..N. Im zweiten Fall erhaelt man die Position von [X,Y] im lexikographisch geordneten kartesischen Produkt der beiden Listen, die die K-elementigen Teilmengen von 1..N und 1..M enthalten. BEISPIEL PosMinor([2,3,4,6],6); --bei Packages: LA.PosMinor([2,3,4,6],6); 12 ------------- PosMinor([1,3,4],[2,3,6],4,6); --bei Verwendung von Packages: LA.PosMinor([1,3,4],[2,3,6],4,6); 53 ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 30.3 (PosMinor) Bemerkung 30.6 (Implementierung von PosMinor) ============ Projection ============ SYNTAX Projection(A: MAT, N: INT): MAT wobei CurrentRing() = S mit einem Ring S ist und A eine Matrix ueber S[x[1..N]] mit Koeffizienten aus S. BESCHREIBUNG Diese Funktion gibt das Bild der Matrix A unter der kanonischen Projektion vom Erweiterungsring S[x[1..N]] auf den Ring S an. Sie dient als Unterfunktion fuer alle modifizierten Verfahren B1TMDSM, B2TMDMDSM, B1DMDSM, B2DMDMDSM, B1DMDSMFB, B2DMDMDSMFB, B1DMDFBSM, B2DMDMDFBSM, Mal1DMDSM. BEISPIEL Use T::= Q[v,x[1..3]]; B:= Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ]; Use S::= Q[v]; Projection(B,3); --bei Verwendung von Packages: LA.Projection(B,3); Mat[ [2, 3, 1, 0], [-4, -2, -2, -2], [2, 3, 0, 2], [2, 0, 2, 2] ] ------------- SIEHE AUCH sasaki.coc, Manual A.1 bis A.3, A.5 12.3 (Bemerkung zur Implementierung) ============ RandMatInt ============ SYNTAX RandMatInt(N: INT, M: INT, C: INT): MAT wobei N, M >= 1 sind. BESCHREIBUNG Diese Funktion erzeugt eine ganzzahlige NxM-Zufallsmatrix, deren Koeffizienten zwischen 0 und C liegen. BEISPIEL RandMatInt(4,6,10); --bei Verwendung von Packages: T.RandMatInt(4,6,10); Mat[ [4, 4, 4, 5, 6, 9], [10, 2, 8, 0, 10, 10], [1, 2, 6, 4, 10, 8], [10, 6, 1, 8, 6, 5] ] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 ============ RandMatPoly ============ SYNTAX RandMatPoly(N: INT, M: INT, D: INT): MAT wobei N, M, D >= 1 sind. BESCHREIBUNG Diese Funktion erzeugt eine NxM-Zufallsmatrix, deren Koeffizienten Polynome vom Grad <= D sind. BEISPIEL Use S::= Z/(20)[vw]; RandMatPoly(4,4,5); --bei Verwendung von Packages: T.RandMatPoly(4,4,5); Mat[ [7v^3 - 4v^2w - 9vw^2 + 4w^3 + 2v^2 + vw - 4w^2 + 9v - 6w, -2v^3 + 8v^2w - 8vw^2 - 9w^3 - 8v^2 + 7vw - w^2 - 9v + 2w + 6, 10v^3 + 6v^2w + vw^2 - 7w^3 + 6v^2 + 2w^2 - 4v - 5w + 9, 9v + 2w + 4], [6v^3 + 10v^2w + vw^2 - 4w^3 + 10v^2 + 9vw - 3w^2 - 4v + 2w - 6, 8v + 2w - 5, 3v^3 - 2v^2w + 10vw^2 + 4w^3 - 7v^2 - vw - 2w^2 - 3v + 8w - 5, 9v^4 - v^3w - 4v^2w^2 - 2vw^3 + 3w^4 - 7v^3 - 6v^2w + 9vw^2 - 4w^3 - 3v^2 - 8vw + 9w^2 + 7], [9v^3 - 2v^2w + 9vw^2 - 3w^3 + 3v + 3w, -8v^3 - 5v^2w + 8vw^2 + 6w^3 - 7v^2 + 9vw + 2w^2 + 8v - 4w - 5, 5v^5 + 2v^4w + 5v^3w^2 + 8v^2w^3 + 6vw^4 - 3w^5 + 9v^2 - 5vw - 8w^2 - 3, -4v^3 + 7v^2w + 9vw^2 + 9w^3 - 6v^2 + 9vw + w^2 - 4v - 5w], [6v^4 + 3v^3w - 7v^2w^2 - 5vw^3 + 5w^4 + 10v + 8w - 6, 5v^4 + 9v^3w + 6v^2w^2 - 7vw^3 - 6w^4 - 8v^2 - vw - 7w^2 + 4v + w, -6v^3 + 4v^2w - 6vw^2 - 6w^3 + 10v^2 + 7vw - 3w^2 - 1, 5v^3 - 6v^2w + 7vw^2 + 5w^3 + 2v^2 - vw + 7w^2 + 5v + 2w - 7] ] ------------- Um zu vermeiden, dass die Koeffizienten zu gross werden, sollte man als Koeffizientenring einen endlichen Ring waehlen. ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 RandMatPolyHom ============ RandMatPolyHom ============ SYNTAX RandMatPolyHom(N: INT, M: INT, D: INT): MAT wobei N, M, D >= 1 sind. BESCHREIBUNG Diese Funktion erzeugt eine NxM-Zufallsmatrix, deren Koeffizienten homogene Polynome vom Grad <= D sind. BEISPIEL Use S::= Z/(20)[vw]; RandMatPolyHom(4,4,5); --bei Packages: T.RandMatPolyHom(4,4,5); Mat[ [9v^2w + 4vw^2 - 2w^3, 5v^2 + 5vw + w^2, -5v^3 + 2v^2w + 7vw^2 - 4w^3, -7v^3 - 8v^2w + 2vw^2 + w^3], [7v^4 + 6v^3w - 9v^2w^2 - 2vw^3 + 9w^4, -5v^2 - 6vw + 3w^2, -7v^5 + 4v^4w + v^3w^2 - 9v^2w^3 - 7vw^4 + 8w^5, -3v^3 - 3v^2w - vw^2 + 3w^3], [-4v^5 - 5v^4w + 10v^3w^2 + 2v^2w^3 + 8vw^4 + 6w^5, 8v^2 + 6vw + 5w^2, 10, 8], [-6v - 4w, -9v^4 + 8v^3w + 4v^2w^2 - vw^3 + 6w^4, -2v^5 + 2v^4w + 9v^3w^2 + v^2w^3 - 7vw^4 - 5w^5, 10v^5 - 3v^4w + 6v^3w^2 - 7v^2w^3 + 6vw^4 + w^5] ] ------------- Um zu vermeiden, dass die Koeffizienten zu gross werden, sollte man als Koeffizientenring einen endlichen Ring waehlen, denn sonst erhaelt man: ------------- Use S::= Z[vw]; RandMatPolyHom(4,4,3); --bei Packages: T.RandMatPolyHom(4,4,3); Mat[ [62022v^3 + 51594v^2w - 29442vw^2 - 55687w^3, -14499v - 10096w, -54032, 9096v - 43317w], [-38560, -23541v^2 - 38096vw - 10803w^2, 10154v^3 + 1394v^2w + 26252vw^2 - 36372w^3, -20170], [36199v^3 + 5572v^2w + 28678vw^2 + 48990w^3, -11954v - 25951w, 19448v^3 - 54621v^2w + 41489vw^2 - 13812w^3, -14950v^3 - 58986v^2w - 9675vw^2 + 64184w^3], [-65120v - 7877w, -32763v^3 + 39716v^2w + 56306vw^2 + 45788w^3, -36467v^2 + 52122vw - 52933w^2, 12616v^2 + 43614vw + 49975w^2] ] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 RandMatPoly ============ RunTest ============ SYNTAX RunTest(L1: LIST, L2: LIST): NULL wobei L1 eine Liste von Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung ist. Dafuer kommen B1TOD, B1TMD, B1TMDSM, B2TOD, B2TMD, B2TMDMD, B2TMDMDSM, B1DOD, B1DMD, B1DMDSM, B2DOD, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB, B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM, MalDichHR, MalDichHM, MalDichVR, MalDichVM in Frage. L2 kann auch aus den Funktionen MaxMinors, MaxMinorsLR bestehen. BESCHREIBUNG Diese Funktion fuehrt die Verfahren aus L2 an den Matrizen aus L1 durch, wobei jeweils die Rechenzeit und das Ergebnis ausgegeben werden. BEISPIEL B:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 2] ]; L1:= [B]; L2:= [B1TMD, B2DMDMD]; RunTest(L1,L2); --bei Verwendung von Packages: T.RunTest(L1,L2); Matrix1: Cpu time = 0.00, User time = 0 B1TMD(...): Mat[ [1, 2, 3, 0], [0, -1, -2, 1], [0, 0, 0, 0] ] Cpu time = 0.50, User time = 0 B2DMDMD(...): Mat[ [-1, 0, 1, -2], [0, -1, -2, 1], [0, 0, 0, 0] ] ------------- L2:= Alg("TB"); --bei Verwendung von Packages: L2:= T.Alg("TB"); RunTest(L1,L2); --bei Verwendung von Packages: T.RunTest(L1,L2); Matrix1: Cpu time = 0.00, User time = 0 B1TMD(...): Mat[ [1, 2, 3, 0], [0, -1, -2, 1], [0, 0, 0, 0] ] Cpu time = 0.00, User time = 0 B2TMD(...): Mat[ [1, 2, 3, 0], [0, -1, -2, 1], [0, 0, 0, 0] ] Cpu time = 0.00, User time = 0 B2TMDMD(...): Mat[ [1, 2, 3, 0], [0, -1, -2, 1], [0, 0, 0, 0] ] ------------- A:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 3] ]; B:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 2] ]; L1:= [A,B]; L2:= Alg("MaxMinors"); --bei Packages: L2:= T.Alg("MaxMinors"); RunTest(L1,L2); --bei Packages: T.RunTest(L1,L2); Matrix1: Cpu time = 1.10, User time = 0 MaxMinors(A): [0, -1, -2, -1] Cpu time = 1.10, User time = 0 MaxMinorsLR(A): [0, -1, -2, -1] Matrix2: Cpu time = 0.60, User time = 0 MaxMinors(A): [0, 0, 0, 0] Cpu time = 0.00, User time = 0 MaxMinorsLR(A): [0, 0, 0, 0] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 RunTestTime Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT ============ RunTestDet ============ SYNTAX RunTestDet(L1: LIST, L2: LIST): NULL wobei L1 eine Liste von quadratischen Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung (mit Division) ist. Dafuer kommen B1TMD, B1TMDSM, B2TMD, B2TMDMD, B2TMDMDSM, B1DMD, B1DMDSM, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB, B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM, MalDichHR, MalDichHM, MalDichVR, MalDichVM in Frage. BESCHREIBUNG Diese Funktion fuehrt MyDet unter Verwendung der Verfahren aus L2 an den Matrizen aus L1 durch, wobei jeweils die Rechenzeit und das Ergebnis ausgegeben werden. BEISPIEL A:= Mat[ [1, 2, 3], [2, 3, 4], [3, 4, 5] ]; L1:= [A]; L2:= [B1TMD, B2DMDMD]; RunTestDet(L1,L2); --bei Verwendung von Packages: T.RunTestDet(L1,L2); Matrix1: Cpu time = 0.00, User time = 0 B1TMD(...): 0 Cpu time = 0.00, User time = 0 B2DMDMD(...): 0 ------------- L2:= Alg("TB"); --bei Verwendung von Packages: L2:= T.Alg("TB"); RunTestDet(L1,L2); --bei Verwendung von Packages: T.RunTestDet(L1,L2); Matrix1: Cpu time = 0.00, User time = 0 B1TMD(...): 0 Cpu time = 0.00, User time = 0 B2TMD(...): 0 Cpu time = 0.50, User time = 0 B2TMDMD(...): 0 ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyDet RunTestTimeDet Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT ============ RunTestInv ============ SYNTAX RunTestInv(L1: LIST, L2: LIST): NULL wobei L1 eine Liste von quadratischen Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Diagonalisierung (mit Division) ist. Dafuer kommen B1DMD, B1DMDSM, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB, B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM, MalDichHR, MalDichHM, MalDichVR, MalDichVM in Frage. BESCHREIBUNG Diese Funktion fuehrt MyInv unter Verwendung der Verfahren aus L2 an den Matrizen aus L1 durch, wobei jeweils die Rechenzeit und das Ergebnis ausgegeben werden. BEISPIEL A:= Mat[ [1, 2, 3], [2, 3, 4], [3, 4, 5] ]; L1:= [A]; L2:= [B1DMD, B2DMDMD]; RunTestInv(L1,L2); --bei Verwendung von Packages: T.RunTestInv(L1,L2); Matrix1: Cpu time = 0.00, User time = 0 B1DMD(...): Die Matrix ist nicht invertierbar. Cpu time = 0.00, User time = 0 B2DMDMD(...): Die Matrix ist nicht invertierbar. ------------- L2:= Alg("DB"); --bei Verwendung von Packages: L2:= T.Alg("DB"); RunTestInv(L1,L2); --bei Verwendung von Packages: T.RunTestInv(L1,L2); Matrix1: Cpu time = 0.00, User time = 0 B1DMD(...): Die Matrix ist nicht invertierbar. Cpu time = 0.00, User time = 0 B2DMD(...): Die Matrix ist nicht invertierbar. Cpu time = 0.00, User time = 0 B2DMDMD(...): Die Matrix ist nicht invertierbar. ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyInv RunTestTimeInv Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT CheckInv ============ RunTestLinKer ============ SYNTAX RunTestLinKer(L1: LIST, L2: LIST): NULL wobei L1 eine Liste von Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Diagonalisierung (mit Division) ist. Dafuer kommen B1DMD, B1DMDSM, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB, B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM, MalDichHR, MalDichHM, MalDichVR, MalDichVM. BESCHREIBUNG Diese Funktion fuehrt MyLinKer unter Verwendung der Verfahren aus L2 an den Matrizen aus L1 durch, wobei jeweils die Rechenzeit und das Ergebnis ausgegeben werden. BEISPIEL A:= Mat[ [1, 2, 3], [2, 3, 4], [3, 4, 5] ]; L1:= [A]; L2:= [B1DMD, B2DMDMD]; RunTestLinKer(L1,L2); --bei Packages: T.RunTestLinKer(L1,L2); Matrix1: Cpu time = 0.00, User time = 0 B1DMD(...): [[1, -2, 1]] Cpu time = 0.00, User time = 0 B2DMDMD(...): [[1, -2, 1]] ------------- L2:= Alg("DB"); --bei Verwendung von Packages: L2:= T.Alg("DB"); RunTestLinKer(L1,L2); --bei Packages: T.RunTestLinKer(L1,L2); Matrix1: Cpu time = 0.00, User time = 0 B1DMD(...): [[1, -2, 1]] Cpu time = 0.50, User time = 0 B2DMD(...): [[1, -2, 1]] Cpu time = 0.00, User time = 0 B2DMDMD(...): [[1, -2, 1]] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyLinKer RunTestTimeLinKer Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT CheckHomSol ============ RunTestMinors ============ SYNTAX RunTestMinors(K: INT, L1: LIST, L2: LIST): NULL wobei L1 eine Liste von Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Minorenberechnung ist. Dafuer kommen MyMinors, MyMinorsLR, MyMinors_2, MyMinorsLR_2. Ferner muss K so gewaehlt sein, dass es fuer alle Matrizen aus L1 moeglich ist, Minoren K-ter Ordnung zu berechnen. BESCHREIBUNG Diese Funktion fuehrt die Verfahren aus L2 an den Matrizen aus L1 durch, wobei jeweils die Rechenzeit und das Ergebnis, naemlich alle Minoren K-ter Ordnung, ausgegeben werden. BEISPIEL B:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 2] ]; L1:= [B]; L2:= Alg("MyMinors"); --bei Packages: L2:= T.Alg("MyMinors"); RunTestMinors(2,L1,L2); --bei Packages: T.RunTestMinors(2,L1,L2); Matrix1: Cpu time = 3.30, User time = 0 MyMinors(K,A): [-1, -2, 1, -1, 2, 3, -2, -4, 2, -2, 4, 6, -1, -2, 1, -1, 2, 3] Cpu time = 3.30, User time = 0 MyMinorsLR(K,A): [-1, -2, 1, -1, 2, 3, -2, -4, 2, -2, 4, 6, -1, -2, 1, -1, 2, 3] Cpu time = 3.30, User time = 1 MyMinors_2(K,A): [-1, -2, 1, -1, 2, 3, -2, -4, 2, -2, 4, 6, -1, -2, 1, -1, 2, 3] Cpu time = 3.30, User time = 0 MyMinorsLR_2(K,A): [-1, -2, 1, -1, 2, 3, -2, -4, 2, -2, 4, 6, -1, -2, 1, -1, 2, 3] ------------- A:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 3] ]; B:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 2] ]; L1:= [A,B]; L2:= [MyMinors, MyMinorsLR]; RunTestMinors(2,L1,L2); --bei Packages: T.RunTestMinors(2,L1,L2); Matrix1: Cpu time = 3.30, User time = 1 MyMinors(K,A): [-1, -2, 1, -1, 2, 3, -2, -4, 3, -2, 6, 9, -1, -2, 3, -1, 5, 7] Cpu time = 3.30, User time = 0 MyMinorsLR(K,A): [-1, -2, 1, -1, 2, 3, -2, -4, 3, -2, 6, 9, -1, -2, 3, -1, 5, 7] Matrix2: Cpu time = 3.30, User time = 0 MyMinors(K,A): [-1, -2, 1, -1, 2, 3, -2, -4, 2, -2, 4, 6, -1, -2, 1, -1, 2, 3] Cpu time = 3.30, User time = 0 MyMinorsLR(K,A): [-1, -2, 1, -1, 2, 3, -2, -4, 2, -2, 4, 6, -1, -2, 1, -1, 2, 3] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 RunTestTimeMinors Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT ============ RunTestRank ============ SYNTAX RunTestRank(L1: LIST, L2: LIST): NULL wobei L1 eine Liste von Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung ist. Dafuer kommen B1TOD, B1TMD, B1TMDSM, B2TOD, B2TMD, B2TMDMD, B2TMDMDSM, B1DOD, B1DMD, B1DMDSM, B2DOD, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB, B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM, MalDichHR, MalDichHM, MalDichVR, MalDichVM in Frage. BESCHREIBUNG Diese Funktion fuehrt MyRank unter Verwendung der Verfahren aus L2 an den Matrizen aus L1 durch, wobei jeweils die Rechenzeit und das Ergebnis ausgegeben werden. BEISPIEL B:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 2] ]; L1:= [B]; L2:= [B1TMD, B2DMDMD]; RunTestRank(L1,L2); --bei Verwendung von Packages: T.RunTestRank(L1,L2); Matrix1: Cpu time = 0.00, User time = 0 B1TMD(...): 2 Cpu time = 0.00, User time = 0 B2DMDMD(...): 2 ------------- L2:= Alg("TB"); --bei Verwendung von Packages: L2:= T.Alg("TB"); RunTestRank(L1,L2); --bei Verwendung von Packages: T.RunTestRank(L1,L2); Matrix1: Cpu time = 0.50, User time = 0 B1TMD(...): 2 Cpu time = 0.00, User time = 0 B2TMD(...): 2 Cpu time = 0.00, User time = 0 B2TMDMD(...): 2 ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyRank RunTestTimeRank Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT ============ RunTestTime ============ SYNTAX RunTestTime(L1: LIST, L2: LIST): NULL wobei L1 eine Liste von Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung ist. Dafuer kommen B1TOD, B1TMD, B1TMDSM, B2TOD, B2TMD, B2TMDMD, B2TMDMDSM, B1DOD, B1DMD, B1DMDSM, B2DOD, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB, B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM, MalDichHR, MalDichHM, MalDichVR, MalDichVM in Frage. L2 kann auch aus den Funktionen MaxMinors, MaxMinorsLR bestehen. BESCHREIBUNG Diese Funktion fuehrt die Verfahren aus L2 an den Matrizen aus L1 durch, ohne explizit zu den Matrizen die jeweiligen Ergebnisse auszugeben. Es wird nur die Rechenzeit angezeigt. BEISPIEL B:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 2] ]; L1:= [B]; L2:= [B1TMD, B2DMDMD]; RunTestTime(L1,L2); --bei Verwendung von Packages: T.RunTestTime(L1,L2); Matrix1: B1TMD(...) Cpu time = 0.00, User time = 0 B2DMDMD(...) Cpu time = 0.00, User time = 0 ------------- Use S::= Q[vw]; L1:= [MM(4), MMS(4)]; --vorher matm.coc einlesen L2:= Alg("DB"); --bei Verwendung von Packages: L2:= T.Alg("DB"); RunTestTime(L1,L2); --bei Verwendung von Packages: T.RunTestTime(L1,L2); Matrix1: B1DMD(...) Cpu time = 8.70, User time = 1 B2DMD(...) Cpu time = 4.40, User time = 1 B2DMDMD(...) Cpu time = 4.40, User time = 0 Matrix2: B1DMD(...) Cpu time = 5.50, User time = 1 B2DMD(...) Cpu time = 3.20, User time = 0 B2DMDMD(...) Cpu time = 3.90, User time = 0 ------------- A:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 3] ]; B:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 2] ]; L1:= [A,B]; L2:= Alg("MaxMinors"); --bei Packages: L2:= T.Alg("MaxMinors"); RunTestTime(L1,L2); --bei Verwendung von Packages: T.RunTestTime(L1,L2); Matrix1: MaxMinors(A) Cpu time = 1.10, User time = 0 MaxMinorsLR(A) Cpu time = 1.10, User time = 0 Matrix2: MaxMinors(A) Cpu time = 0.60, User time = 0 MaxMinorsLR(A) Cpu time = 0.50, User time = 0 ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 RunTest Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT ============ RunTestTimeDet ============ SYNTAX RunTestTimeDet(L1: LIST, L2: LIST): NULL wobei L1 eine Liste von quadratischen Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung (mit Division) ist. Dafuer kommen B1TMD, B1TMDSM, B2TMD, B2TMDMD, B2TMDMDSM, B1DMD, B1DMDSM, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB, B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM, MalDichHR, MalDichHM, MalDichVR, MalDichVM in Frage. BESCHREIBUNG Diese Funktion fuehrt MyDet unter Verwendung der Verfahren aus L2 an den Matrizen aus L1 durch, wobei nur die Rechenzeit, nicht aber das Ergebnis explizit ausgegeben wird. BEISPIEL A:= Mat[ [1, 2, 3], [2, 3, 4], [3, 4, 5] ]; L1:= [A]; L2:= [B1TMD, B2DMDMD]; RunTestTimeDet(L1,L2); --bei Packages: T.RunTestTimeDet(L1,L2); Matrix1: B1TMD(...) Cpu time = 0.00, User time = 0 B2DMDMD(...) Cpu time = 0.00, User time = 0 ------------- Use S::= Q[vw]; L1:= [MM(4), MMD(4)]; --vorher matm.coc einlesen L2:= Alg("DB"); --bei Verwendung von Packages: L2:= T.Alg("DB"); RunTestTimeDet(L1,L2); --bei Packages: T.RunTestTimeDet(L1,L2); Matrix1: B1DMD(...) Cpu time = 8.80, User time = 1 B2DMD(...) Cpu time = 2.20, User time = 0 B2DMDMD(...) Cpu time = 2.20, User time = 0 Matrix2: B1DMD(...) Cpu time = 2.20, User time = 1 B2DMD(...) Cpu time = 1.10, User time = 0 B2DMDMD(...) Cpu time = 1.70, User time = 0 ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyDet RunTestDet Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT ============ RunTestTimeInv ============ SYNTAX RunTestTimeInv(L1: LIST, L2: LIST): NULL wobei L1 eine Liste von quadratischen Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Diagonalisierung (mit Division) ist. Dafuer kommen B1DMD, B1DMDSM, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB, B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM, MalDichHR, MalDichHM, MalDichVR, MalDichVM in Frage. BESCHREIBUNG Diese Funktion fuehrt MyInv unter Verwendung der Verfahren aus L2 an den Matrizen aus L1 durch, wobei nur die Rechenzeit, nicht aber das Ergebnis explizit ausgegeben wird. BEISPIEL A:= Mat[ [1, 2, 3], [2, 3, 4], [3, 4, 5] ]; L1:= [A]; L2:= [B1DMD, B2DMDMD]; RunTestTimeInv(L1,L2); --bei Packages: T.RunTestTimeInv(L1,L2); Matrix1: B1DMD(...) Cpu time = 0.00, User time = 0 B2DMDMD(...) Cpu time = 0.50, User time = 0 ------------- Use S::= Q[vw]; L1:= [MM(4), MMD(4)]; --vorher matm.coc einlesen L2:= Alg("DB"); --bei Verwendung von Packages: L2:= T.Alg("DB"); RunTestTimeInv(L1,L2); --bei Packages: T.RunTestTimeInv(L1,L2); Matrix1: B1DMD(...) Cpu time = 24.70, User time = 2 B2DMD(...) Cpu time = 2.80, User time = 0 B2DMDMD(...) Cpu time = 2.20, User time = 1 Matrix2: B1DMD(...) Cpu time = 9.90, User time = 1 B2DMD(...) Cpu time = 7.70, User time = 0 B2DMDMD(...) Cpu time = 7.10, User time = 1 ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyInv RunTestInv Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT ============ RunTestTimeLinKer ============ SYNTAX RunTestTimeLinKer(L1: LIST, L2: LIST): NULL wobei L1 eine Liste von Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Diagonalisierung (mit Division) ist. Dafuer kommen B1DMD, B1DMDSM, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB, B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM, MalDichHR, MalDichHM, MalDichVR, MalDichVM in Frage. BESCHREIBUNG Diese Funktion fuehrt MyLinKer unter Verwendung der Verfahren aus L2 an den Matrizen aus L1 durch, wobei nur die Rechenzeit, nicht aber das Ergebnis explizit ausgegeben wird. BEISPIEL A:= Mat[ [1, 2, 3], [2, 3, 4], [3, 4, 5] ]; L1:= [A]; L2:= [B1DMD, B2DMDMD]; RunTestTimeLinKer(L1,L2); --bei Packages: T.RunTestTimeLinKer(L1,L2); Matrix1: B1DMD(...) Cpu time = 0.00, User time = 0 B2DMDMD(...) Cpu time = 0.00, User time = 0 ------------- Use S::= Q[vw]; L1:= [MM(4), MMD(4)]; --vorher matm.coc einlesen L2:= Alg("DB"); --bei Packages: L2:= T.Alg("DB"); RunTestTimeLinKer(L1,L2); --bei Packages: T.RunTestTimeLinKer(L1,L2); Matrix1: B1DMD(...) Cpu time = 8.20, User time = 1 B2DMD(...) Cpu time = 4.90, User time = 1 B2DMDMD(...) Cpu time = 4.40, User time = 0 Matrix2: B1DMD(...) Cpu time = 2.20, User time = 0 B2DMD(...) Cpu time = 1.60, User time = 0 B2DMDMD(...) Cpu time = 1.10, User time = 1 ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyLinKer RunTestLinKer Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT ============ RunTestTimeMinors ============ SYNTAX RunTestTimeMinors(K: INT, L1: LIST, L2: LIST): NULL wobei L1 eine Liste von Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Minorenberechnung ist. Dafuer kommen MyMinors, MyMinorsLR, MyMinors_2, MyMinorsLR_2. Ferner muss K so gewaehlt sein, dass es fuer alle Matrizen aus L1 moeglich ist, Minoren K-ter Ordnung zu berechnen. BESCHREIBUNG Diese Funktion fuehrt die Verfahren aus L2 an den Matrizen aus L1 durch, wobei jeweils die Rechenzeit, nicht aber das Ergebnis, naemlich alle Minoren K-ter Ordnung, ausgegeben wird. BEISPIEL B:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 2] ]; L1:= [B]; L2:= Alg("MyMinors"); --bei Packages: L2:= T.Alg("MyMinors"); RunTestTimeMinors(2,L1,L2); --bei Packages: T.RunTestTimeMinors(2,L1,L2); Matrix1: MyMinors(K,A) Cpu time = 3.20, User time = 0 MyMinorsLR(K,A) Cpu time = 3.30, User time = 1 MyMinors_2(K,A) Cpu time = 3.30, User time = 0 MyMinorsLR_2(K,A) Cpu time = 3.90, User time = 0 ------------- A:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 3] ]; B:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 2] ]; L1:= [A,B]; L2:= [MyMinors, MyMinorsLR]; RunTestTimeMinors(2,L1,L2); --bei Packages: T.RunTestTimeMinors(2,L1,L2); Matrix1: MyMinors(K,A) Cpu time = 3.30, User time = 1 MyMinorsLR(K,A) Cpu time = 3.80, User time = 0 Matrix2: MyMinors(K,A) Cpu time = 3.30, User time = 0 MyMinorsLR(K,A) Cpu time = 3.90, User time = 1 ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 RunTestMinors Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT ============ RunTestTimeRank ============ SYNTAX RunTestTimeRank(L1: LIST, L2: LIST): NULL wobei L1 eine Liste von Matrizen ueber einem Integritaetsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung ist. Dafuer kommen B1TOD, B1TMD, B1TMDSM, B2TOD, B2TMD, B2TMDMD, B2TMDMDSM, B1DOD, B1DMD, B1DMDSM, B2DOD, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB, B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM, MalDichHR, MalDichHM, MalDichVR, MalDichVM in Frage. BESCHREIBUNG Diese Funktion fuehrt MyRank unter Verwendung der Verfahren aus L2 an den Matrizen aus L1 durch, wobei nur die Rechenzeit, nicht aber das Ergebnis explizit ausgegeben wird. BEISPIEL B:= Mat[ [1, 2, 3, 0], [2, 3, 4, 1], [3, 4, 5, 2] ]; L1:= [B]; L2:= [B1TMD, B2DMDMD]; RunTestTimeRank(L1,L2); --bei Packages: T.RunTestTimeRank(L1,L2); Matrix1: B1TMD(...) Cpu time = 0.00, User time = 0 B2DMDMD(...) Cpu time = 0.50, User time = 0 ------------- Use S::= Q[vw]; L1:= [MM(4), MMS(4)]; --vorher matm.coc einlesen L2:= Alg("DB"); --bei Verwendung von Packages: L2:= T.Alg("DB"); RunTestTimeRank(L1,L2); --bei Packages: T.RunTestTimeRank(L1,L2); Matrix1: B1DMD(...) Cpu time = 8.20, User time = 0 B2DMD(...) Cpu time = 4.40, User time = 1 B2DMDMD(...) Matrix2: B1DMD(...) Cpu time = 5.50, User time = 1 B2DMD(...) Cpu time = 3.30, User time = 0 B2DMDMD(...) Cpu time = 3.80, User time = 1 ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 MyRank RunTestRank Alg, Mats MM, MMS, MMD, D, E, F, P, A, AT ============ Signum ============ SYNTAX Signum(X: LIST): INT wobei X aus paarweise verschiedenen natuerlichen Zahlen besteht. BESCHREIBUNG Diese Funktion berechnet das Signum von X. BEISPIEL Signum([1,3,5,4,2,7]); --bei Packages: LA.Signum([1,3,5,4,2,7]); 1 ------------- Signum([1,5,3]); --bei Packages: LA.Signum([1,5,3]); -1 ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 30.5 (Signum) Bemerkung 30.6 (Implementierung von Signum) ============ Subsets ============ SYNTAX Subsets(N: INT, K: INT): LIST wobei 0 <= K <= N ist. BESCHREIBUNG Diese Funktion gibt eine Liste aus, die in lexikographischer Reihenfolge alle N-elementigen Listen enthaelt, in denen genau K-mal die 1 und (N-K)-mal die 0 vorkommt. Sie dient als Unterfunktion fuer AllSubsets. BEISPIEL Subsets(6,4); --bei Verwendung von Packages: LA.Subsets(6,4); [[1, 1, 1, 1, 0, 0], [1, 1, 1, 0, 1, 0], [1, 1, 1, 0, 0, 1], [1, 1, 0, 1, 1, 0], [1, 1, 0, 1, 0, 1], [1, 1, 0, 0, 1, 1], [1, 0, 1, 1, 1, 0], [1, 0, 1, 1, 0, 1], [1, 0, 1, 0, 1, 1], [1, 0, 0, 1, 1, 1], [0, 1, 1, 1, 1, 0], [0, 1, 1, 1, 0, 1], [0, 1, 1, 0, 1, 1], [0, 1, 0, 1, 1, 1], [0, 0, 1, 1, 1, 1]] ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 30.4 (Subsets) Bemerkung 30.6 (Implementierung von Subsets) ============ Toeplitz ============ SYNTAX Toeplitz(N: INT, M: INT): MAT wobei 1 <= N, M ist und wobei CurrentRing() die Variablen z[0..N+M-2] enthalten muss. BESCHREIBUNG Diese Funktion erzeugt die generische NxM-Toeplitzmatrix. BEISPIEL Use S::= Q[z[0..8]]; Toeplitz(4,6); --bei Verwendung von Packages: T.Toeplitz(4,6); Mat[ [z[5], z[4], z[3], z[2], z[1], z[0]], [z[6], z[5], z[4], z[3], z[2], z[1]], [z[7], z[6], z[5], z[4], z[3], z[2]], [z[8], z[7], z[6], z[5], z[4], z[3]] ] ------------- SIEHE AUCH test.coc, Manual A.1 bis A.3, A.5 Abschnitt 18 ============ Update ============ SYNTAX Update(A: MAT, Var L: LIST): NULL wobei A die zu einer Matrix B aequivalente Nx(N+1)-Diagonalmatrix ist, die man mit einem Diagonalisierungsverfahren mit Division gewinnt, und wobei die geordnete Liste L maximale Minoren von B enthaelt. BESCHREIBUNG Diese Funktion bringt aus der Matrix A Determinanten mit dem richtigen Vorzeichen in die Minorenliste L an die richtige Position. Sie dient als Unterfunktion fuer MaxMinors_2. BEISPIEL B:= Mat[ [2, 1, 3, 1, 0], [2, 1, 3, 0, 2], [4, 2, 2, 2, 2], [2, 1, 0, 2, 2] ]; L:= [0, 0, 0, 0, 0]; A:= B1DMD(B); --bei Verwendung von Packages: A:= LA.B1DMD(B); A; Mat[ [-20, -10, 0, 0, 0], [0, 0, -20, 0, 0], [0, 0, 0, -20, 0], [0, 0, 0, 0, -20] ] ------------- Update(A,L); --bei Verwendung von Packages: LA.Update(A,L); L; [0, 0, 0, -20, -10] ------------- Dies ist die Liste der maximalen Minoren von B. ------------- SIEHE AUCH minors.coc, minors2.coc, Manual A.1 bis A.3, A.5 Satz 32.9 (MaxMinors_2) Bemerkung 32.10 (Implementierung von MaxMinors_2)