A Manual 319

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 erhält man beispielsweise mit

                                     Help("B1DMD");

bzw. mit

                                     H.Help B1DMD();

eine Beschreibung der CoCoA-Funktion B1DMD. Sämtliche Funktionen sind unter der derzeit aktuellen Version CoCoA-4.1 lauffähig, die unter

                                   cocoa@dima.unige.it

kostenlos erhältlich 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 über den Menüpunkt “Help” oder über die F1-Taste.

Als günstig zur Trigonalisierung kann i.a. das Verfahren B2TMDMD bzw. in speziellen Fällen 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 den Kapiteln IV, V und VI. Bei den Funktionen, bei denen optional ein Verfahren gewählt 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 schützen. So wird etwa die Funktion MyDet auch für nichtquadratische Matrizen ein Ergebnis ausspucken. Abgesehen davon empfiehlt es sich stets, von vorneherein die Eingabewerte (Matrizen etc.) so zu manipulieren, dass keine unnötigen Berechnungen durchgeführt werden müssen. Zu beachten ist ferner, daß der Koeffizientenring ein Körper sein muß, denn obwohl die Trigonalisierung bzw. Diagonalisierung mit bruchfreien Verfahren vorgenommen wird, führt CoCoA beispielsweise in ℤ[...] 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);

320 A Manual

-------------
ERROR: Cannot divide
CONTEXT: Return(LM(X))
-------------

CoCoA stört sich am Koeffizientenring ℤ. Abhilfe schafft man, indem man stattdessen ℚ 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 lädt 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 gehörigen 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 enthält test.pkg Funktionen, um Beispielmatrizen (katalektische Matrizen u.a.) zu erzeugen und um Testreihen mit den Funktionen aus linalg.pkg durchzuführen. Die Online-Hilfe zu den jeweiligen Funktionen findet sich in help.pkg. Wer darauf verzichten kann, muß diese beiden Packages nicht unbedingt einlesen. Daneben existieren Dateien ∗2.∗, die jeweils identisch sind mit den entsprechenden Dateien ∗.∗, bis auf die Tatsache, daß in ihnen die Division mit “/” statt mit DivAlg durchgeführt wird. Sie sind zusammengefaßt 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)

A Manual 321

Dabei enthält test2.pkg ähnlich wie test.pkg Funktionen, um Beispielmatrizen (katalektische Matrizen u.a.) zu erzeugen und um Testreihen mit den Funktionen aus linalg2.pkg durchzuführen. Wer darauf verzichten kann, muß dieses Package nicht unbedingt einlesen. Das weiter oben angeführte Package help.pkg mit der Online-Hilfe gilt auch für die beiden Packages linalg2.pkg und test2.pkg. Der Inhalt der angegebenen Einzeldateien ist unter Punkt A.5 detailliert aufgeführt.

A.2 Wie lädt man ein Package?

Das CoCoA-Manual enthält unter Punkt 2.9 (CoCoA Packages) eine relativ ausführliche Beschreibung zu Packages. Kurzgefaßt geht man wie folgt vor: Zunächst 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, muß man hier eventuell die richtige Pfadangabe ergänzen. 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 muß:

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);

322 A Manual

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
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 Möglichkeit, 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

A Manual 323

Verwechselt man die Reihenfolge oder vergißt 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 möglicherweise auch erst dann, wenn man eine Funktion ausführen will, die eine Unterfunktion aus einer unbekannten Datei benötigt. Das Problem läßt sich sehr leicht beheben, indem man die fehlende Datei nachlädt. Die angegebene Reihenfolge der Dateien spiegelt die Tatsache wieder, daß eine Datei auf ihre Vorgängerinnen zurückgreift. Die zugehörigen Helpdateien kann man, muß 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 üblich 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 darüber, daß bestimmte Funktionen aus der nichteingelesenen Datei minors.coc für test.coc bekannt sein sollten. Entweder man lädt diese Datei nach oder auch nicht. Dann lassen sich trotzdem alle Funktionen ausführen, die nicht auf diese Datei zurückgreifen.

-------------------------------
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);

324 A Manual

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
Abschnitt 18
-------------

A Manual 325 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

326 A Manual

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

A Manual 327

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, daß in ihnen die Division mit “/” statt mit DivAlg durchgeführt 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

328 A Manual

- B1TMDRow
- B1TMDRow2Col
- B2TODRow
- B2TMDRow
- B2TMDMDRow
- B1DODRow
- B1DODRow2Col
- B1DMDRow
- B1DMDRow2Col
- B2DODRow
- B2DMDRow
- B2DMDMDRow

Kleine Programme

- ChangeRow
- ListFirstNonZeroPos
- ListFirstNonZero
⋆ helpbar.coc:

– zugehörige 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:

– zugehörige Online-Hilfe

Kapitel III: sasaki.coc, helpsas.coc

⋆ sasaki.coc:

Hauptprogramme

- B1TMDSM
- B2TMDMDSM
- B1DMDSM
- B2DMDMDSM
- BackupDMDSM
- B1DMDSMFB
- B2DMDMDSMFB
- B1DMDFBSM
- B2DMDMDFBSM

A Manual 329

- Mal1DMDSM

Unterprogramme

- Injection
- Projection
- BackSubstTMD
- BackSubstDMD
- MultSM
- C0 B2SM
- C1 B2SM
- C2 B2SM
- KFSM
- B1TMDSMRow
- B1TMDSMRow2Col
- B2TMDMDSMRow
- B1DMDSMRow
- B2DMDMDSMRow
- BackupDMDSMRow
- Mal1DMDSMRow
⋆ helpsas.coc

– zugehörige Online-Hilfe

Kapitel V: linalg.coc, helplin.coc

⋆ linalg.coc:

Hauptprogramme

- MyRank
- MyDet
- MyInv
- FindKer
- MyLinKer
- MyLinKerMin
- FindSol
- MyLinSol
- MyLinSolMin
⋆ helplin.coc:

- zugehörige 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

330 A Manual

- PartialPivot
- PartialC0Pivot

Kleine Programme

- Height
⋆ helpmin.coc:

– zugehörige 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
⋆ helptest.coc:

– zugehörige Online-Hilfe

A Manual 331 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 Einträge 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 muß 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
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 Abkürzung X gehörende Liste, nämlich für 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 außer 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

332 A Manual

    [B1DMDSM, B2DMDMDSM, Mal1DMDSM, B1DMDSMFB, B2DMDMDSMFB, B1DMDFBSM, B2DMDMDFBSM],

X = “D” die Liste aller DMD-Verfahren außer 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 nützlich für 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
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. Für 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
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 Fällen die Transponierte der entsprechenden Matrix A(N) ist, außer für N = 17. Vorher muß allerdings die Datei mata.coc eingelesen werden.

A Manual 333

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
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 ausgeräumt wird. Sie dient als Unterfunktion für 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 läßt sich das Ergebnis von AusrLUMat in die Matrix schreiben.

-------------

334 A Manual

SIEHE AUCH

mal.coc, mal2.coc
Satz 10.4 (MalDichHM, AusrLUMat)

Satz 10.8 (MalDichVM) Bemerkung 10.10 (Implementierung von MalDichHM, MalDichVM)

AusrLURow, AusrROMat, AusrRORow

============ AusrLURow ============

SYNTAX AusrRORow (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 ausgeräumt werden. Sie dient als Unterfunktion für 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 ausgeräumt worden mit KFLU=1. Zum Ergebnis vergleiche das Beispiel zu AusrLUMat.

-------------

SIEHE AUCH

mal.coc, mal2.coc
Satz 10.2 (MalDichHR, AusrRORow)

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 ausgeräumt und die vordere Teilmatrix in den Zeilen 1..K und den Spalten 1..K diagonalisiert wird. Sie dient als Unterfunktion für 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]]

A Manual 335

-------------
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 läßt sich das Ergebnis von AusrROMat in die Matrix schreiben.

-------------

SIEHE AUCH

mal.coc, mal2.coc
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 ausgeräumt werden. Sie dient als Unterfunktion für 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 ausgeräumt worden mit KFRO=8. Zum Ergebnis vergleiche das Beispiel zu AusrROMat.

-------------

SIEHE AUCH

mal.coc, mal2.coc
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 über S[x[1..(N-2)]] ist und L eine Liste der Länge N-2, deren Komponenten aus S stammen und für x[1] bis x[N-2] eingesetzt werden.

336 A Manual

BESCHREIBUNG Diese Funktion führt an der Diagonalmatrix A die Rücksubstitution anhand der Liste L aus, wobei der Diagonalkoeffizient nur ein einziges Mal berechnet zu werden braucht. Sie dient als Unterfunktion für 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

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 über S[x[1..(N-2)]] ist und L eine Liste der Länge N-2, deren Komponenten aus S stammen und für x[1] bis x[N-2] eingesetzt werden. BESCHREIBUNG Diese Funktion führt an der Matrix A die Rücksubstitution anhand der Liste L aus. Sie dient als Unterfunktion für 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]

A Manual 337

]
-------------

SIEHE AUCH

sasaki.coc

Satz 12.2 (B1TMDSM) Satz 13.3 (B2TMDMDSM)

============ BackupDMD ============

SYNTAX BackupDMD (A: MAT): MAT wobei A eine beliebige Zeilenstufenmatrix über einem Integritätsring 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 ausgeräumt werden. Sie dient als Unterfunktion für 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
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 zugehörigen Zeilenstufenspalten ausgeräumt werden. BackupDMDRow dient als Unterfunktion

für BackupDMD.

338 A Manual

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
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 über einem Integritätsring ist, die mit einem modifizierten Trigonalisierungsverfahren erzeugt worden ist und bei der die Rücksubstitution noch nicht durchgeführt ist. BESCHREIBUNG Diese Funktion diagonalisiert die Zeilenstufenmatrix A mit der modifizierten Backup-Prozedur, indem von unten nach oben die Zeilen ausgeräumt werden. Sie dient als Unterfunktion für B1DMDFBSM sowie für

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,

A Manual 339

   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
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 ausgeräumt werden. BackupDMDSMRow dient als Unterfunktion für

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]

340 A Manual

]
-------------
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
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 äquivalente Zeilenstufenmatrix ist, die mit einem Trigonalisierungsverfahren mit Division erzeugt worden ist. Außerdem ist L1 eine Liste von Listen, die N-elementige Teilmengen von 1..M darstellen. Die geordnete Liste L2 enthält maximale Minoren von A, und die Liste L0 enthält Spaltenindizes, deren zugehörige Spalten in B gleich 0 sind. BESCHREIBUNG Diese Funktion streicht aus L1 die Listen, deren zugehörige 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 außerdem die zu B äquivalente, 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]
]

A Manual 341

-------------
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 fünfte 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
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 äquivalente Matrix ist mit rang B = N, wobei K ein Zeilenindex aus 2..N und wobei J die Liste der N Zeilenstufenindizes von B ist. Außerdem ist L1 eine Liste von Listen, die N-elementige Teilmengen von 1..M darstellen, die geordnete Liste L2 enthält maximale Minoren von A, und die Liste L0 enthält Spaltenindizes, deren zugehörige 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 zugehörigen Zeilenstufenspalten ausgeräumt werden. Dabei werden aus L1 die Listen, deren zugehörige 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 für 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]

342 A Manual

];
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
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. Außerdem ist B eine Len(L1) x Len(L2)-Matrix oder eine entsprechende Liste von Zeilenvektoren.

A Manual 343

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

============ 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 über einem Integritätsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-1-Schritt-Verfahren mit Division eine zu A äquivalente Diagonalmatrix. Die beiden anderen Fälle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, nämlich von den Dichotomie- Verfahren MalDich∗ (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird für die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgeführt 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],

344 A Manual

[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
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 über einem Integritätsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Forward-Backup-Verfahren mit Division eine zu A äquivalente Diagonalmatrix, wobei die Trigonalisierung mit B1TMD vorgenommen wird. Die beiden anderen Fälle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, nämlich von den Dichotomie- Verfahren MalDich∗ (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird für die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgeführt 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],

A Manual 345

[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
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 über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Fällen berechnet diese Funktion nach dem Forward-Backup-Verfahren eine zu A äquivalente Diagonalmatrix, wobei die Trigonalisierung mit dem modifizierten Bareiss-1-Schritt-Verfahren und die Backup-Prozedur mit dem modifizierten Backup-Verfahren BackupDMDSM durchgeführt wird. Der zweite Fall tritt nur auf, wenn B1DMDFBSM intern von anderen Funktionen aufgerufen wird, nämlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb nötig, 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]
]
-------------

346 A Manual

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

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 Vorgängerzeile (K-1) ist. (KF=1 für 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 ausgeräumt wird. Sie dient als Unterfunktion für B1DMD und auch für 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 ausgeräumt.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc
Satz 5.6 (B1DMD, B1DMDRow)
B2DMD, B2DMDMD

A Manual 347 ============ 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 Vorgängerzeile (K-1) ist. (KF=1 für K=1.) Ferner ist Det = C0/KF, wobei man C0 mit C0Pivot(A,J,K) erhält. 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 ausgeräumt wird. Dabei wird außerdem der Koeffizient A[I,J+1] = Det gesetzt. B1DMDRow2Col dient als Unterfunktion für 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 ausgeräumt worden. Dabei wird der vierte Koeffizient nicht mehr berechnet, sondern gleich Det gesetzt.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc

Bemerkung 6.8 (Implementierung von B2DOD, B2DMD, B2DMDMD)

C0Pivot, B1DMDRow, 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 über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig wird. E1 und E2 sind beliebig.

348 A Manual

BESCHREIBUNG In beiden Fällen berechnet diese Funktion nach dem modifizierten Bareiss-1-Schritt-Verfahren eine zu A äquivalente Diagonalmatrix. Der zweite Fall tritt nur auf, wenn B1DMDSM intern von anderen Funktionen aufgerufen wird, nämlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb nötig, 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
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

A Manual 349

wobei A eine NxM-Matrix mit N ≤ M über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Fällen berechnet diese Funktion nach dem Forward-Backup-Verfahren eine zu A äquivalente Diagonalmatrix, wobei die Trigonalisierung mit dem modifizierten Verfahren B1TMDSM und die Backup-Prozedur mit dem herkömmlichen Verfahren BackupDMD durchgeführt wird. Der zweite Fall tritt nur auf, wenn B1DMDSMFB intern von anderen Funktionen aufgerufen wird, nämlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb nötig, 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

Satz 16.1 (B1DMDSMFB) Bemerkung 16.4 (Implementierung von B1DMDSMFB) Satz 26.1 (MyDet) Satz 27.3 (MyInv)

B1DMDFB

350 A Manual ============ 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 für K=1.) BESCHREIBUNG Diese Funktion berechnet nach der modifizierten Bareiss-1-Schritt-Formel die ober- oder unterhalb der Kten Zeile gelegene I-te Zeile von A neu, wenn bei der Diagonalisierung mit Hilfe der K-ten Zeile die K-te Spalte ausgeräumt wird. Sie dient als Unterfunktion für B1DMDSM und auch für 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 ausgeräumt.

-------------

SIEHE AUCH

sasaki.coc
Satz 14.2 (B1DMDSM, B1DMDSMRow)
B1DMDRow

============ B1DOD ============

SYNTAX B1DOD (A: MAT): MAT wobei A eine beliebige Matrix über einem Integritätsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A äquivalente Diagonalmatrix aus, die mit dem Bareiss-1-Schritt-Verfahren ohne Division (Gauß-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]
];

A Manual 351

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

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 ausgeräumt wird. Sie dient als Unterfunktion für B1DOD und auch für eine andere Unterfunktion, nämlich

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 ausgeräumt worden.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc

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 ausgeräumt wird. Dabei wird außerdem der Koeffizient A[I,J+1] = C0 gesetzt. B1DODRow2Col dient als Unterfunktion für B2DOD und auch für eine andere Unterfunktion, nämlich B1DMDRow2Col.

352 A Manual

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 ausgeräumt worden. Dabei wird der vierte Koeffizient nicht mehr berechnet, sondern gleich C0 gesetzt.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc

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 über einem Integritätsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-2-Schritt-Verfahren mit Division eine zu A äquivalente Diagonalmatrix. Die beiden anderen Fälle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, nämlich von den Dichotomie- Verfahren MalDich∗ (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird für die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgeführt 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],

A Manual 353

[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
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 über einem Integritätsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Forward-Backup-Verfahren mit Division eine zu A äquivalente Diagonalmatrix, wobei die Trigonalisierung mit B2TMD vorgenommen wird. Die beiden anderen Fälle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, nämlich von den Dichotomie- Verfahren MalDich∗ (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird für die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgeführt 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],

354 A Manual

[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
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 über einem Integritätsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-2-Schritt-Verfahren mit Division eine zu A äquivalente Diagonalmatrix. Dabei werden, statt wie bei B2DMD einmal durch einen quadrierten Teiler zu dividieren, zweimal die entsprechenden Zwischenergebnisse dividiert. Die beiden anderen Fälle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, nämlich von den Dichotomie-Verfahren MalDich∗ (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird für die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgeführt 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 Manual 355

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
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 über einem Integritätsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Forward-Backup-Verfahren mit Division eine zu A äquivalente Diagonalmatrix, wobei die Trigonalisierung mit B2TMDMD vorgenommen wird. Die beiden anderen Fälle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, nämlich von den Dichotomie- Verfahren MalDich∗ (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird für die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgeführt 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[

356 A Manual

[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
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 über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Fällen berechnet diese Funktion nach dem Forward-Backup-Verfahren eine zu A äquivalente Diagonalmatrix, wobei die Trigonalisierung mit dem modifizierten Bareiss-2-Schritt-Verfahren und die Backup-Prozedur mit dem modifizierten Verfahren BackupDMDSM durchgeführt wird. Der zweite Fall tritt nur auf, wenn B2DMDMDFBSM intern von anderen Funktionen aufgerufen wird, nämlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb nötig, 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],

A Manual 357

[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
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. Außerdem ist KF ≠ 0 der Zeilenstufenkoeffizient der Vorgängerzeile (K-1) mit KF=1 für 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 ausgeräumt werden. B2DMDMDRow dient als Unterfunktion für 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;

358 A Manual

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]
]
-------------

Räumt man in der vierten Zeile mit Hilfe der zweiten, dritten Zeile die Spalten 3 und 4 aus, so erhält man das angegebene Ergebnis mit der Bareiss-2-Schritt-Formel unter Verwendung von Det=C0/KF.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc
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 über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Fällen berechnet diese Funktion nach dem modifizierten Bareiss-2-Schritt-Verfahren eine zu A äquivalente Diagonalmatrix. Der zweite Fall tritt nur auf, wenn B2DMDMDSM intern von anderen Funktionen aufgerufen wird, nämlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb nötig, 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],

A Manual 359

[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
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 über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Fällen berechnet diese Funktion nach dem Forward-Backup-Verfahren eine zu A äquivalente Diagonalmatrix, wobei die Trigonalisierung mit dem modifizierten Verfahren B2TMDMDSM und die Backup-Prozedur mit dem herkömmlichen Verfahren BackupDMD durchgeführt wird. Der zweite Fall tritt nur auf, wenn B2DMDMDSMFB intern von anderen Funktionen aufgerufen wird, nämlich von MyDet (Satz 26.1) oder My-Inv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb nötig, 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]

360 A Manual

];
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
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 für 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 ausgeräumt werden. B2DMDMDSMRow dient als Unterfunktion

für 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 Manual 361

-------------
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 ausgeräumt worden.

-------------

SIEHE AUCH

sasaki.coc
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. Außerdem ist KF2 ≠ 0 das Quadrat des Zeilenstufenkoeffizienten KF der Vorgängerzeile (K-1) mit KF=KF2=1 für 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 ausgeräumt werden. Dabei wird der Kofaktor C0 verwendet. B2DMDRow dient als Unterfunktion für 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);

362 A Manual

-- 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 ausgeräumt.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc
Satz 6.3 (B2DMD,B2DMDRow)

Bemerkung 6.8 (Implementierung von B2DOD, B2DMD, B2DMDMD)

============ B2DOD ============

SYNTAX B2DOD (A: MAT): MAT wobei A eine beliebige Matrix über einem Integritätsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A äquivalente 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

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 ausgeräumt werden. B2DODRow dient als Unterfunktion für B2DOD und auch für eine andere Unterfunktion, nämlich B2DMDRow.

A Manual 363

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 ausgeräumt.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc

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 über einem Integritätsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-1-Schritt-Verfahren mit Division eine zu A äquivalente Zeilenstufenmatrix. Die beiden anderen Fälle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, nämlich von den Dichotomie- Verfahren MalDich∗ (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird für die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgeführt 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],

364 A Manual

[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
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 Vorgängerzeile (K-1) ist. (KF=1 für 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 ausgeräumt wird. Sie dient als Unterfunktion für B1TMD und auch für 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]

A Manual 365

]
-------------

Im obigen Beispiel wird in der zweiten Zeile mit Hilfe der ersten Zeile die erste Spalte ausgeräumt, 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 ausgeräumt.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc
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 Vorgängerzeile (K-1) ist. (KF=1 für K=1.) Ferner ist Det = C0/KF, wobei man C0 mit C0Pivot(A,J,K) erhält. 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 ausgeräumt wird. Dabei wird außerdem der Koeffizient A[I,J+1] = Det gesetzt. B1TMDRow2Col dient als Unterfunktion für 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 C0Pivot: mit der ersten Spalte wird automatisch auch die zweite ausgeräumt, daher enthält die obige Liste als zweite Komponente C0=0. Im folgenden muß 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.

366 A Manual

-------------
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 C0Pivot: an Position (3,4) kommt (ohne Zeilentausch) ein Koeffizient ungleich 0, wenn man die dritte Spalte mit Hilfe der zweiten Zeile ausräumt, nämlich der Koeffizient C0/KF=16/2=8. Damit folgt für 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

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

A Manual 367

wobei A eine NxM-Matrix mit N ≤ M über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig wird. E1 und E2 sind beliebig.

BESCHREIBUNG In beiden Fällen berechnet diese Funktion nach dem modifizierten Bareiss-1-Schritt-Verfahren eine zu A äquivalente 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 nötig, weil MyDet stets Trigonalisierungsoder 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
Satz 12.2 (B1TMDSM,B1TMDSMRow)

Bemerkung 12.3 (Implementierung von B1TMDSM) Satz 26.1 (MyDet)

B1TMD

368 A Manual ============ 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 für 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 ausgeräumt wird. Sie dient als Unterfunktion für B1TMDSM und auch für 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 ausgeräumt.

-------------

SIEHE AUCH

sasaki.coc
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 für 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 ausgeräumt wird. Dabei wird außerdem der Koeffizient A[I,K+1] = Det gesetzt. B1TMDSMRow2Col dient als

Unterfunktion für 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]
];

A Manual 369

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

Bemerkung 13.4 (Implementierung von B2TMDMDSM)

B1TMDRow2Col

============ B1TOD ============

SYNTAX B1TOD (A: MAT): MAT wobei A eine beliebige Matrix über einem Integritätsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A äquivalente Zeilenstufenmatrix aus, die mit dem Bareiss-1-Schritt-Verfahren ohne Division (Gauß-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

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 ausgeräumt wird. Sie dient als Unterfunktion für B1TOD und auch für eine andere Unterfunktion, nämlich

B1TMDRow.

370 A Manual

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 ausgeräumt, und zwar mit der Bareiss-1-Schritt-Formel ohne Division (Gaußformel).

-------------
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 ausgeräumt.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc

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 ausgeräumt wird. Dabei wird außerdem der Koeffizient A[I,J+1] = C0 gesetzt. B1TODRow2Col dient als Unterfunktion für B2TOD und auch für eine andere Unterfunktion, nämlich B1TMDRow2Col. BEISPIEL

P:= Mat[
[2, 1, 3, 1, 0, 4],
[2, 1, 3, 0, 2, 1],
[4, 2, 2, 2, 2, 2],

A Manual 371

[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 C0Pivot: mit der ersten Spalte wird automatisch auch die zweite ausgeräumt, daher enthält die obige Liste als zweite Komponente C0=0. Im folgenden muß 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 ausräumt, nämlich der Koeffizient C0=16. Damit folgt für 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

Bemerkung 4.8 (Implementierung von B2TOD, B2TMD,B2TMDMD)

B1TODRow, B1TMDRow2Col, C0Pivot

372 A Manual ============ 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 über einem Integritätsring ist und E beliebig.

BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-2-Schritt-Verfahren mit Division eine zu A äquivalente Zeilenstufenmatrix. Die beiden anderen Fälle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, nämlich von den Dichotomie-Verfahren MalDich∗ (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird für die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgeführt 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
Satz 4.3 (B2TMD, B2TMDRow, C0Pivot)

Bemerkung 4.8 (Implementierung von B2TMD) Abschnitt 10 (MalDich∗) Satz 26.1 (MyDet) Satz 27.3 (MyInv)

A Manual 373 ============ 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 über einem Integritätsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Bareiss-2-Schritt-Verfahren mit Division eine zu A äquivalente Zeilenstufenmatrix. Dabei werden, statt wie bei B2TMD einmal durch einen quadrierten Teiler zu dividieren, zweimal die entsprechenden Zwischenergebnisse dividiert. Die beiden anderen Fälle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, nämlich von den Dichotomie-Verfahren MalDich∗ (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird für die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgeführt 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
Satz 4.6 (B2TMDMD, B2TMDMDRow)

Bemerkung 4.8 (Implementierung von B2TMDMD) Abschnitt 10 (MalDich∗) Satz 26.1 (MyDet) Satz 27.3 (MyInv)

B2TMD

374 A Manual ============ 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 Vorgängerzeile (K-1) ist. (KF=1 für K=1.) Ferner ist Det = C0/KF, wobei man C0 mit C0Pivot(A,J,K) erhält. 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 ausgeräumt werden. B2TMDMDRow dient als Unterfunktion für 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]
]
-------------

Räumt man in der vierten Zeile mit Hilfe der zweiten, dritten Zeile die Spalten 3 und 4 aus, so erhält man das angegebene Ergebnis mit der Bareiss-2-Schritt-Formel unter Verwendung von Det=C0/KF.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc
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 über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Fällen berechnet diese Funktion nach dem modifizierten Bareiss-2-Schritt-Verfahren eine zu A äquivalente 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 nötig, weil MyDet stets Trigonalisierungs- oder Diagonalisierungsverfahren mit drei Argumenten verwendet.

A Manual 375

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
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 für 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 ausgeräumt werden. B2TMDMDSMRow dient als Unterfunktion für B2TMDMDSM, B2DMDMDFBSM.

376 A Manual

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
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 Vorgängerzeile (K-1) ist. (KF2=1 für 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 ausgeräumt werden. Dabei wird der Kofaktor C0 verwendet. B2TMDRow dient als Unterfunktion für 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]

A Manual 377

-------------
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]
]
-------------

Räumt man in der vierten Zeile mit Hilfe der zweiten, dritten Zeile die Spalten 3 und 4 aus, so erhält 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
Satz 4.3 (B2TMD,B2TMDRow)

Bemerkung 4.8 (Implementierung von B2TOD, B2TMD, B2TMDMD)

============ B2TOD ============

SYNTAX B2TOD (A: MAT): MAT wobei A eine beliebige Matrix über einem Integritätsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A äquivalente 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

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 ausgeräumt werden. B2TODRow dient als Unterfunktion für B2TOD und auch für eine andere Unterfunktion, nämlich B2TMDRow.

378 A Manual

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]
]
-------------

Räumt man in der vierten Zeile mit Hilfe der zweiten, dritten Zeile die Spalten 3 und 4 aus, so erhält man das angegebene Ergebnis mit der Bareiss-2-Schritt-Formel unter Verwendung des Kofaktors C0.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc

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],... enthält. 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]],

A Manual 379

[z[5], z[8], z[9], z[12], z[13], z[14]]
]
-------------

SIEHE AUCH

test.coc

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

============ CheckEq ============

SYNTAX CheckEq (A: OBJECT, B: OBJECT): BOOL BESCHREIBUNG Diese Funktion prüft, 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

============ 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 prüft, ob die Listen aus B Lösungen 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]
-------------

380 A Manual

SIEHE AUCH

test.coc
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 ausgedrückt, 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
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 prüft, ob die Listen aus X Det-fache von speziellen Lösungen 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]
-------------

A Manual 381

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
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. Außerdem 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 ausgeräumt werden. Coeff dient als Unterfunktion für 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 ausräumt. 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 nächste Zeilenstufe.

-------------

SIEHE AUCH

mal.coc, mal2.coc
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].

382 A Manual

BESCHREIBUNG Diese Funktion versucht, durch Zeilentausch die nächste 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 Jte Spalte ausräumt. Beim Zeilentausch wird außerdem die L-te Zeile mit −1 multipliziert. Als Ergebnis erhält man eine Liste, die als erste Komponente die Matrix mit eventuell getauschten Zeilen und als zweite Komponente C0 enthält. 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 möglich, Zeilen so zu tauschen, daß man an der Position (2,2) einen Koeffizienten ungleich 0 erhält, wenn man mit der ersten Zeile die erste Spalte ausräumt. In diesem Fall werden also automatisch die ersten beiden Spalten ausgeräumt. Als Ergebnis wird daher die unveränderte 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 muß man die zweite und dritte Zeile tauschen, um an Position (2,2) die nächste 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]
-------------

A Manual 383

Im dritten Beispiel kommt ohne Zeilentausch an Position (3,4) ein Koeffizient ungleich 0, wenn man die dritte Spalte mit Hilfe der zweiten Zeile ausräumt. Daher wird als Ergebnis die unveränderte Matrix und C0=16 ausgegeben.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc

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 für die Bareiss-2-Schritt-Formel benötigten Kofaktor C0, wenn mit Hilfe der K-, K+1-ten Zeile die J-, J+1-te Spalte ausgeräumt 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

Bemerkung 4.5 (B2TODRow) Satz 4.3 (B2TMDRow)

Satz 4.6 (B2TMDMDRow)

Bemerkung 6.5 (B2DODRow) Satz 6.3 (B2DMDRow)

Satz 6.6 (B2DMDMDRow)
C0Pivot
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 für die modifizierte Bareiss-2-Schritt-Formel benötigten Kofaktor C0, wenn mit Hilfe der K-, K+1-ten Zeile die K-te und K+1-te Spalte ausgeräumt werden sollen. C0 B2SM dient als

Unterfunktion für 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
-------------

384 A Manual

SIEHE AUCH

sasaki.coc
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 für die Bareiss-2-Schritt-Formel benötigten Kofaktor C1, wenn mit Hilfe der K-, K+1-ten Zeile die J-, J+1-te Spalte ausgeräumt werden sollen in der I-ten Zeile. C1 B2 dient als

Unterfunktion für 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

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 für die modifizierte Bareiss-2-Schritt-Formel benötigten Kofaktor C1, wenn mit Hilfe der K-, K+1-ten Zeile die K-, K+1-te Spalte ausgeräumt werden sollen in der I-ten Zeile. C1 B2SM dient als Unterfunktion für 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
-------------

A Manual 385

SIEHE AUCH

sasaki.coc
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 für die Bareiss-2-Schritt-Formel benötigten Kofaktor C2, wenn mit Hilfe der K-, K+1-ten Zeile die J-, J+1-te Spalte ausgeräumt werden sollen in der I-ten Zeile. C2 B2 dient als

Unterfunktion für 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

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 für die modifizierte Bareiss-2-Schritt-Formel benötigten Kofaktor C2, wenn mit Hilfe der K-, K+1-ten Zeile die K-, K+1-te Spalte ausgeräumt werden sollen in der I-ten Zeile. C2 B2SM dient als Unterfunktion für 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
-------------

386 A Manual

SIEHE AUCH

sasaki.coc
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 muß.

BESCHREIBUNG Diese Funktion ruft eine mit RandMatPoly erzeugte Zufallsmatrix in der Variablen v ab, und zwar für N = 1 eine 6x7-Matrix, deren Koeffizienten höchstens vom Grad 20 sind (RandMatPoly(6,7,20)) N = 2 eine 6x7-Matrix, deren Koeffizienten höchstens vom Grad 40 sind (RandMatPoly(6,7,40)) N = 3 eine 8x7-Matrix, deren Koeffizienten höchstens vom Grad 20 sind (RandMatPoly(8,7,20)) N = 4 eine 8x9-Matrix, deren Koeffizienten höchstens vom Grad 20 sind (RandMatPoly(8,9,20)). Vorher muß allerdings die Datei matdef.coc eingelesen werden.

SIEHE AUCH

matdef.coc

Abschnitt 20

RandMatPoly, E, F

============ E ============

SYNTAX E (N: INT): MAT

wobei 1 ≤ N ≤ 4 ist und wobei CurrentRing() die Variablen v und w enthalten muß.

BESCHREIBUNG Diese Funktion ruft eine mit RandMatPolyHom erzeugte Zufallsmatrix in den Variablen v, w ab, und zwar für N = 1 eine 4x5-Matrix, deren Koeffizienten höchstens vom Grad 10 sind (RandMatPolyHom(4,5,10)) N = 2 eine 4x5-Matrix, deren Koeffizienten höchstens vom Grad 20 sind (RandMatPolyHom(4,5,20)) N = 3 eine 5x6-Matrix, deren Koeffizienten höchstens vom Grad 10 sind (RandMatPolyHom(5,6,10)) N = 4 eine 5x4-Matrix, deren Koeffizienten höchstens vom Grad 20 sind (RandMatPolyHom(5,4,20)) Vorher muß allerdings die Datei matdef.coc eingelesen werden.

SIEHE AUCH

matdef.coc

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 muß.

BESCHREIBUNG Diese Funktion ruft eine mit RandMatPolyHom erzeugte Zufallsmatrix in den Variablen v, w und x ab, und zwar für N = 1 eine 4x5-Matrix, deren Koeffizienten höchstens vom Grad 5 sind (RandMatPolyHom(4,5,5)) N = 2 eine 4x5-Matrix, deren Koeffizienten höchstens vom Grad 5 sind (RandMatPolyHom(4,5,5)) Vorher muß allerdings die Datei matdef.coc eingelesen werden.

SIEHE AUCH

matdef.coc

Abschnitt 20

RandMatPolyHom, D, E

A Manual 387 ============ FindKer ============

SYNTAX FindKer (A: MAT): LIST wobei A eine Diagonalmatrix über einem Integritätsring ist, die durch ein Verfahren mit Division erzeugt worden ist. BESCHREIBUNG Diese Funktion gibt als Ergebnis eine Liste von Listen aus, die Basisvektoren für den Lösungraum des homogenen linearen Gleichungssystems Ax=0 darstellen. FindKer dient als Unterfunktion für 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 Lösung existiert, wird als Ergebnis die leere Liste ausgegeben.

-------------

SIEHE AUCH

linalg.coc

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 über einem Integritätsring ist, die durch ein Verfahren mit Division erzeugt worden ist und äquivalent 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 äquivalenten Matrix ist. Als zweite Komponente folgt eine Liste, deren Komponenten spezielle Lösungen für den Lösungraum des inhomogenen linearen Gleichungssystems Ax=B darstellen, wenn man sie durch Det teilt, bzw. die “Das Gleichungssystem ist nicht lösbar.” besagen. Die dritte Komponente ist eine Liste, deren Komponenten Basisvektoren des zugehörigen homogenen Gleichungssystems Ax=0 darstellen. FindSol dient als Unterfunktion für 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[

388 A Manual

[-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 lösbar mit der speziellen Lösung ((-20) (-1)) ∗ [0, 0, -20, -20, 20] = [0, 0, 1, 1, -1]. Das zugehörige 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 lösbar.",
"Das Gleichungssystem ist nicht lösbar."],
[[-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 lösbar. Das zugehörige 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 lösbar.",
"Das Gleichungssystem ist nicht lösbar.",
"Das Gleichungssystem ist nicht lösbar.",
"Das Gleichungssystem ist nicht lösbar."],
[ ]]
-------------

Das Gleichungssystem Ax=B mit A:= Mat[ [2],

A Manual 389

[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 für die erste Spalte von B lösbar mit der speziellen Lösung ((-20) (-1)) ∗ [-10] = [1/2]. Für die übrigen Spalten ist es nicht lösbar. Das zugehörige homogene Gleichungssystem Ax=0 besitzt nur die triviale Lösung.

-------------

SIEHE AUCH

linalg.coc

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 enthält, deren zugehörige Spalten in B gleich 0 sind. BESCHREIBUNG Diese Funktion streicht aus der Liste L1 solche Komponenten, deren zugehörige 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]]
-------------

390 A Manual

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
Satz 31.5 (FindZeroMaxMinors)

Bemerkung 31.6 (Implementierung von FindZeroMaxMinors)

============ GaussDOD ============

SYNTAX GaussDOD (A: MAT): MAT wobei A eine beliebige Matrix über einem Integritätsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A äquivalente Diagonalmatrix aus, die mit dem Gauß-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
B1DOD

============ GaussTOD ============

SYNTAX GaussTOD (A: MAT): MAT wobei A eine beliebige Matrix über einem Integritätsring ist. BESCHREIBUNG Diese Funktion gibt eine zu A äquivalente Zeilenstufenmatrix aus, die mit dem Gauß-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],

A Manual 391

[0, 0, 0, 0, -80, 80]
]
-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc
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 muß. 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

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 muß. 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

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 muß. BESCHREIBUNG Diese Funktion erzeugt die generische NxM-Hankelmatrix.

392 A Manual

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

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 zugehörige Spalten in der Matrix B auf der Höhe 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

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 über 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 für 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],

A Manual 393

[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

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 ursprünglichen 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

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 für MalDichHM und MalDichHR, indem sie anhand der Liste P der Partitionierung und dem Blockende K der oberen Hälfte das Blockende der unteren Hälfte 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];

394 A Manual

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
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 für

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, außer an vorletzter Position, an der 0 mit dem zu [2,4,5,6] gehörigen Minor noch überschrieben werden muß.

-------------
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
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] höchstens (K-1)-mal 0 enthält und wobei die Listen X, Y K-elementige Teilmengen von 1..N bzw. 1..M darstellen.

A Manual 395

BESCHREIBUNG Diese Funktion berechnet den durch X, Y definierten Minor von A mittels linearer Relationen aus A[1] und L3. LinRelMinors dient als Unterfunktion für 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 enthält alle Minoren dritter Ordnung von P außer 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
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] erhält 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
ListFirstNonZeroPos

============ 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] erhält man 0 als Ergebnis.

396 A Manual

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
ListFirstNonZero

============ 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 über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig 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 äquivalente Diagonalmatrix. Im zweiten und dritten Fall werden dabei Blockmatrizen der Größe S mit dem Verfahren Diag diagonalisiert. (Als Voreinstellungen sind S=1 und Diag=B2DMDMDFB gewählt.) 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 durchgeführt. 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]
]
-------------

A Manual 397

SIEHE AUCH

mal.coc, mal2.coc

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 über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig 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 äquivalente Diagonalmatrix. Im zweiten und dritten Fall werden dabei Blockmatrizen der Größe S mit dem Verfahren Diag diagonalisiert. (Als Voreinstellungen sind S=1 und Diag=B2DMDMDFB gewählt.) 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 durchgeführt. 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

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

398 A Manual

wobei A eine NxM-Matrix mit N ≤ M über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig 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 äquivalente Diagonalmatrix. Im zweiten und dritten Fall werden dabei Blockmatrizen der Größe S mit dem Verfahren Diag diagonalisiert. (Als Voreinstellungen sind S=1 und Diag=B2DMDMDFB gewählt.) 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 durchgeführt. 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

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 über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig 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 äquivalente Diagonalmatrix. Im zweiten und dritten Fall werden dabei Blockmatrizen der Größe S mit dem Verfahren Diag diagonalisiert. (Als Voreinstellungen sind S=1 und Diag=B2DMDMDFB gewählt.) 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 durchgeführt.

A Manual 399

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

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 über einem Integritätsring und E beliebig ist. BESCHREIBUNG Im ersten Fall berechnet diese Funktion nach dem Malashonok-1-Schritt-Verfahren mit Division eine zu A äquivalente Diagonalmatrix. Die beiden anderen Fälle treten nur auf, wenn diese Funktion intern von anderen Funktionen aufgerufen wird, nämlich von den Dichotomie- Verfahren MalDich∗ (Abschnitt 10) bzw. von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Dann wird für die Dichotomie-Verfahren die erste Division mit dem Teiler KF statt mit 1 durchgeführt 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]
]
-------------

400 A Manual

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
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 ausgeräumt werden, wobei außerdem der Koeffizient A[K+1,J[K+1]] = C gesetzt wird. Mal1DMDRow dient als Unterfunktion für Mal1DMD. Falls dabei Mal1DMD von einem Dichotomie-Verfahren MalDich∗ aufgerufen wird, muß zusätzlich die Division durch KF1 durchgeführt 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 auszuräumen, müssen 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 nächste Zeilenstufe an Position 3 liegen, mit dem Zeilenstufenkoeffizienten 8.

A Manual 401

-------------
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

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 über einem Integritätsring ist, wobei rang A = N gilt und alle Zeilenstufen auf der Diagonalen liegen und wobei außerdem ein Zeilentausch zur Diagonalisierung nicht nötig wird. E1 und E2 sind beliebig. BESCHREIBUNG In beiden Fällen berechnet diese Funktion nach dem modifizierten Malashonok-1-Schritt-Verfahren eine zu A äquivalente Diagonalmatrix. Der zweite Fall tritt nur auf, wenn Mal1DMDSM intern von anderen Funktionen aufgerufen wird, nämlich von MyDet (Satz 26.1) oder MyInv (Satz 27.3). Die beliebigen Argumente E1 und E2 sind nur deshalb nötig, 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],

402 A Manual

[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

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 ausgeräumt werden. Mal1DMDSMRow dient als Unterfunktion für 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

Satz 17.4 (Mal1DMDSM) Bemerkung 17.5 (Implementierung von Mal1DMDSM)

Mal1DMDRow

A Manual 403 ============ 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. Außerdem 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 nächstgelegenen Zeile I unter der (K+1)-ten Zeile, falls nicht die Zeile (K+1), sondern die Zeile I die nächste Zeilenstufe enthält. Als Ergebnis erhält man eine Liste, die als erste Komponente die Matrix mit eventuell getauschten Zeilen enthält, als zweite Komponente den nächsten Zeilenstufenindex L und als dritte Komponente den nächsten Zeilenstufenkoeffizienten C. Beim Zeilentausch wird außerdem 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 auszuräumen, müssen 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 nächste 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
Satz 8.4 (Mal1Pivot)

Bemerkung 8.6 (Implementierung von Mal1DMD)

Mal1DMDRow

404 A Manual ============ 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 Abkürzung X gehörende Liste, nämlich für 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 nützlich für die Funktionen RunTest∗. Vorher muß 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
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 über einem Integritätsring ist. BESCHREIBUNG Diese Funktion berechnet alle maximalen Minoren von A. Sie dient auch als Unterfunktion für 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],

A Manual 405

[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

Satz 32.2 (MaxMinors) Bemerkung 32.4 (Implementierung von MaxMinors)

MaxMinorsLR, MaxMinors 2

============ MaxMinorsLR ============

SYNTAX MaxMinorsLR (A: MAT): LIST wobei A eine beliebige Matrix über einem Integritätsring ist. BESCHREIBUNG Diese Funktion berechnet alle maximalen Minoren von A unter Verwendung von linearen Relationen. Sie dient auch als Unterfunktion für 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
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 über einem Integritätsring 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 für Alg zusätzlich

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 gewählt 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]

406 A Manual

-------------

SIEHE AUCH

minors.coc, minors2.coc
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 muß. 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

Abschnitt 19

MMS, MMD

============ MMD ============

SYNTAX MMD (N: INT): MAT wobei 4 ≤ N ≤ 9 ist und wobei CurrentRing() die Variablen v und w enthalten muß. BESCHREIBUNG Diese Funktion läßt 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

Abschnitt 19

MM, MMS

A Manual 407 ============ MMS ============

SYNTAX MMS (N: INT): MAT wobei 4 ≤ N ≤ 9 ist und wobei CurrentRing() die Variablen v und w enthalten muß. BESCHREIBUNG Diese Funktion läßt 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

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

Abschnitt 11

============ MyDet ============

SYNTAX MyDet (A: MAT): INT oder POLY MyDet (A: MAT, Alg: FUNCTION): INT oder POLY wobei A eine quadratische Matrix über einem Integritätsring ist und wobei außerdem Alg eine der folgenden Trigonalisierungs- oder Diagonalisierungsfunktionen B1TMD, B2TMD, B2TMDMD, B1DMD, B2DMD, B2DMDMD,

408 A Manual

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 für Alg zusätzlich 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, während im ersten Fall B2TMDMD als Voreinstellung gewählt 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 zugehörige Zeilenstufenmatrix Mat[ [2, 1, 3, 1], [0, 0, 8, 0], [0, 0, 0, -8], [0, 0, 0, 0] ] nicht vollständig erzeugt, denn es läßt sich bereits nach dem Ausräumen der ersten Spalte erkennen, daß rang A < N gilt und daher |A| = 0. Analog muß 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 vollständig berechnet werden.

-------------

SIEHE AUCH

linalg.coc

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 über einem Integritätsring ist und wobei Alg eine der Diagonalisierungs-

funktionen 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 für

Alg zusätzlich 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, während im ersten Fall B2DMDMDFB als Voreinstellung gewählt ist.

A Manual 409

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 zugehörige Diagonalmatrix nicht vollständig berechnet, denn es läßt sich bereits nach dem Ausräumen der ersten Spalte sehen, daß rang A < N gilt und daß 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 für die erste Komponente −8 = |B|, die zweite Komponente gibt die Adjunkte von B an. Die Inverse von B erhält 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

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 über einem Integritätsring ist und wobei Alg eine der Diagonalisie-

rungsfunktionen 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 für

Alg zusätzlich eines der Verfahren B1DMDSM, B2DMDMDSM, B1DMDSMFB, B2DMDMDSMFB, B1DMDFBSM, B2DMDMDFBSM,
Mal1DMDSM, MalDichHM, MalDichHR, MalDichVM, MalDichVR hernehmen.

410 A Manual

BESCHREIBUNG Diese Funktion gibt als Ergebnis eine Liste von Listen aus, die Basisvektoren für den Lösungraum des homogenen linearen Gleichungssystems Ax=0 darstellen. Dieses Ergebnis wird im zweiten Fall unter Verwendung von Alg ermittelt, während 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 Lösung existiert, wird als Ergebnis die leere Liste ausgegeben.

-------------

SIEHE AUCH

linalg.coc

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 eingebauten Funktion Minors als Ergebnis eine Liste aus, deren einzige Komponente ein Basisvektor für den eindimensionalen Lösungraum 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
Satz 28.6 (MyLinKerMin)
MyLinKer
MyLinSol, MyLinSolMin

A Manual 411 ============ MyLinSol ============

SYNTAX MyLinSol (A: MAT, B: MAT): LIST MyLinSol (A: MAT, B: MAT, Alg: FUNCTION): LIST wobei A eine beliebige NxM-Matrix über einem Integritätsring und B eine beliebige NxP-Matrix über demselben Integritätsring 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 für Alg zusätzlich eines der Verfahren B1DMDSM,

B2DMDMDSM, B1DMDSMFB, B2DMDMDSMFB, B1DMDFBSM, B2DMDMDFBSM, Mal1DMDSM, MalDichHM, MalDichHR, Mal-
DichVM, 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 äquivalenten Matrix ist. Als zweite Komponente folgt eine Liste, deren Komponenten spezielle Lösungen für den Lösungraum des inhomogenen linearen Gleichungssystems Ax=B darstellen, wenn man sie durch Det teilt, bzw. die “Das Gleichungssystem ist nicht lösbar.” besagen. Die dritte Komponente ist eine Liste, deren Komponenten Basisvektoren des zugehörigen homogenen Gleichungssystems Ax=0 darstellen. Das Ergebnis von MyLinSol wird unter Verwendung von Alg ermittelt, wobei im ersten Fall als Voreinstellung Alg = B2DMDMDFB gewählt 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 lösbar mit der speziellen Lösung ((-20) (-1)) ∗ [0, 0, -20, -20, 20] = = [0, 0, 1, 1, -1]. Das zugehörige 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 lösbar.",
"Das Gleichungssystem ist nicht lösbar."],
[[-10, 20, 0, 0]]]
-------------

Das Gleichungssystem Ax=B ist also nicht lösbar. Das zugehörige homogene Gleichungssystem Ax=0 besitzt [-10, 20, 0, 0] als Basisvektor.

412 A Manual

-------------
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 lösbar.",
"Das Gleichungssystem ist nicht lösbar.",
"Das Gleichungssystem ist nicht lösbar.",
"Das Gleichungssystem ist nicht lösbar."],
[ ]]
-------------

Das Gleichungssystem Ax=B ist für die erste Spalte von B lösbar mit der speziellen Lösung ((-20) (-1)) ∗ [-10] = [1/2]. Für die übrigen Spalten ist es nicht lösbar. Das zugehörige homogene Gleichungssystem Ax=0 besitzt nur die triviale Lösung.

-------------

SIEHE AUCH

linalg.coc

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) läßt 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 Lösung 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],

A Manual 413

];
MyLinSolMin(A,B);-- bei Verwendung von Packages: LA.MyLinSolMin(A,B);
[-20, [[0, -20, -20, 20]]]
-------------

Die eindeutig bestimmte spezielle Lösung 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
Satz 29.6 (MyLinSolMin)
MyLinSol
MyLinKer, MyLinKerMin

============ MyMinors ============

SYNTAX MyMinors (K: INT, A: MAT): LIST wobei A eine beliebige NxM-Matrix über einem Integritätsring 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

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 über einem Integritätsring und 1 ≤ K ≤ N, M ist. BESCHREIBUNG Diese Funktion berechnet alle Minoren K-ter Ordnung von A unter Verwendung von MaxMinorsLR.

414 A Manual

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
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 über einem Integritätsring 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
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 über einem Integritätsring 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.

A Manual 415

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

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 über einem Integritätsring 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, während im ersten Fall B2TMDMD als Voreinstellung gewählt 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] ]

-------------

416 A Manual

SIEHE AUCH

linalg.coc

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 für 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 muß allerdings die Datei matp.coc eingelesen werden. SIEHE AUCH

matp.coc

Abschnitt 24

RandMatInt

============ PartialB2TMDMD ============

SYNTAX PartialB2TMDMD (A: MAT, K: INT): LIST wobei A eine beliebige NxM-Matrix über einem Integritätsring 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 äquivalente partielle Zeilenstufenmatrix, in der die ersten K-1 Zeilenstufenspalten ausgeräumt sind und in der nach eventuellem Zeilentausch die K-te Zeile die nächste Zeilenstufe stellt, sofern eine solche existiert. Als Ergebnis erhält 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 schließlich die zu A äquivalente 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]
]]
-------------

A Manual 417

Neben der Zeilenstufenspalte 1 wird zugleich auch die zweite Spalte ausgeräumt. Außerdem werden bereits die zweite und dritte Zeile vertauscht, so daß an Position (2,3) die nächste 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 ausgeräumt, 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
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].

418 A Manual

BESCHREIBUNG Diese Funktion versucht, durch Zeilentausch die nächste 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 ausräumt. Beim Zeilentausch wird außerdem die L-te Zeile mit −1 multipliziert. Dieselbe Vertauschung wird entsprechend an Pi vorgenommen. Als Ergebnis erhält man eine Liste, die als erste Komponente die Matrix mit eventuell getauschten Zeilen und als zweite Komponente C0 enthält. 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 möglich, Zeilen so zu tauschen, daß man an der Position (2,2) einen Koeffizienten ungleich 0 erhält, wenn man mit der ersten Zeile die erste Spalte ausräumt.

-------------
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 muß man die zweite und dritte Zeile tauschen, um an Position (2,2) die nächste Zeilenstufe mit C0=4 zu erhalten.

-------------

SIEHE AUCH

minors.coc, minors2.coc
Satz 35.4 (PartialB2TMDMD, PartialC0Pivot)

Bemerkung 35.5 (Implementierung von PartialB2TMDMD)

C0Pivot

A Manual 419 ============ 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 nächstgelegene 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 nächste Zeilenstufe an Position (K,J) zu bringen. Bei einem Zeilentausch wird außerdem 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
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 nächstgelegene 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 nächste Zeilenstufe an Position (K,J) zu bringen. Bei einem Zeilentausch wird außerdem 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],

420 A Manual

[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 möglich, 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, daß an der Position (2,2) ein Koeffizient ungleich 0 steht.

-------------

SIEHE AUCH

bareiss.coc, bareiss2.coc

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 für 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 erhält 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

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 über 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 für 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],

A Manual 421

[-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

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

============ 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^2 w - 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,

422 A Manual

   -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, daß die Koeffizienten zu groß werden, sollte man als Koeffizientenring einen endlichen Ring wählen.

-------------

SIEHE AUCH

test.coc
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^2 w + 4vw^2 - 2w^3, 5v^2 + 5vw + w^2, -5v^3 + 2v^2 w + 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, daß die Koeffizienten zu groß werden, sollte man als Koeffizientenring einen endlichen Ring wählen, denn sonst erhält 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^2 w + 26252vw^2 - 36372w^3, -20170],
[36199v^3 + 5572v^2 w + 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
RandMatPoly

============ RunTest ============

SYNTAX RunTest (L1: LIST, L2: LIST): NULL wobei L1 eine Liste von Matrizen über einem Integritätsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung ist. Dafür 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.

A Manual 423

BESCHREIBUNG Diese Funktion führt 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];

424 A Manual

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
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 über einem Integritätsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung (mit Division) ist. Dafür 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 führt 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
MyDet

A Manual 425

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 über einem Integritätsring und L2 eine Liste von Funktionen zur Diagonalisierung (mit Division) ist. Dafür 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 führt 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
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 über einem Integritätsring und L2 eine Liste von Funktionen zur Diagonalisierung (mit Division) ist. Dafür kommen B1DMD, B1DMDSM, B2DMD, B2DMDMD, B2DMDMDSM, B1DMDFB,

B1DMDSMFB, B1DMDFBSM, B2DMDFB, B2DMDMDFB, B2DMDMDSMFB, B2DMDMDFBSM, B2DMDMDSM, Mal1DMD, Mal1DMDSM,
MalDichHR, MalDichHM, MalDichVR, MalDichVM.

BESCHREIBUNG Diese Funktion führt MyLinKer unter Verwendung der Verfahren aus L2 an den Matrizen aus L1 durch, wobei jeweils die Rechenzeit und das Ergebnis ausgegeben werden.

426 A Manual

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
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 über einem Integritätsring und L2 eine Liste von Funktionen zur Minorenberechnung ist. Dafür kommen MyMinors, MyMinorsLR, MyMinors 2, MyMinorsLR 2. Ferner muß K so gewählt sein, daß es für alle Matrizen aus L1 möglich ist, Minoren K-ter Ordnung zu berechnen. BESCHREIBUNG Diese Funktion führt die Verfahren aus L2 an den Matrizen aus L1 durch, wobei jeweils die Rechenzeit und das Ergebnis, nämlich 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]

A Manual 427

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
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 über einem Integritätsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung ist. Dafür 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 führt 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

428 A Manual

-------------
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
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 über einem Integritätsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung ist. Dafür 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 führt 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

A Manual 429

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
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 über einem Integritätsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung (mit Division) ist. Dafür 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 führt 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

430 A Manual

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
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 über einem Integritätsring und L2 eine Liste von Funktionen zur Diagonalisierung (mit Division) ist. Dafür 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 führt 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);

A Manual 431

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
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 über einem Integritätsring und L2 eine Liste von Funktionen zur Diagonalisierung (mit Division) ist. Dafür 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 führt 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

432 A Manual

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
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 über einem Integritätsring und L2 eine Liste von Funktionen zur Minorenberechnung ist. Dafür kommen MyMinors, MyMinorsLR, MyMinors 2, MyMinorsLR 2. Ferner muß K so gewählt sein, daß es für alle Matrizen aus L1 möglich ist, Minoren K-ter Ordnung zu berechnen. BESCHREIBUNG Diese Funktion führt die Verfahren aus L2 an den Matrizen aus L1 durch, wobei jeweils die Rechenzeit, nicht aber das Ergebnis, nämlich 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)

A Manual 433

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
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 über einem Integritätsring und L2 eine Liste von Funktionen zur Trigonalisierung oder Diagonalisierung ist. Dafür 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 führt 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
-------------

434 A Manual

SIEHE AUCH

test.coc
MyRank
RunTestRank
Alg, Mats
MM, MMS, MMD, D, E, F, P, A, AT

============ Signum ============

SYNTAX Signum (X: LIST): INT wobei X aus paarweise verschiedenen natürlichen 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

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 enthält, in denen genau K-mal die 1 und (N-K)-mal die 0 vorkommt. Sie dient als Unterfunktion für 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

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 muß. 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]],

A Manual 435

[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

Abschnitt 18

============ Update ============

SYNTAX Update (A: MAT, Var L: LIST): NULL wobei A die zu einer Matrix B äquivalente Nx(N+1)-Diagonalmatrix ist, die man mit einem Diagonalisierungsverfahren mit Division gewinnt, und wobei die geordnete Liste L maximale Minoren von B enthält. 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 für 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
Satz 32.9 (MaxMinors 2)

Bemerkung 32.10 (Implementierung von MaxMinors 2)

436 B Beispiele zur Implementierung

Anhang B Beispiele zur Implementierung

Es folgen nun einige Beispiele zur Programmierung der in der Arbeit vorgestellten Algorithmen, vgl. dazu auch das Manual (Anhang A). Der gesamte source code befindet sich auf der beiliegenden Diskette; einen Überblick über den Inhalt der einzelnen Dateien verschafft unter anderem Punkt A.5 im Manual.

B.1 Beispiel (Algorithmus B2TMDMD)

Der Algorithmus B2TMDMD aus Satz 4.6 ist folgendermaßen in eine CoCoA-Funktion umgesetzt, wobei die unterstrichenen Befehle Unterprogramme aufrufen. Siehe dazu auch die entsprechenden Einträge im Manual. 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

Define B2TMDMD(...)
   A:= ARGV[1];

If Len(ARGV) = 2 Then -- Kuerzungsfaktor KF (Rekursionsanfang)

      KF:= ARGV[2]; Else
      KF:= Poly(1);
   End;

N:= Len(A); -- Zeilenanzahl von A

M:= Len(A[1]); -- Spaltenanzahl von A

K:= 1; -- Zeilenzaehler

J:= 1; -- Spaltenzaehler

   A:= Mat[[Poly(X) | X In A[I]] | I In 1..N];
   While J <= M And K <= N Do
      A:= \underline{Pivot}(A,J,K);                           -- evtl. Zeilentausch
      If A[K,J] = 0 Then J:= J+1;                 -- sonst naechste Spalte
         If Len(ARGV) = 3 Then Return FALSE End;
      Elsif J= M Then                             -- j=m: B1TMD mit KF

For I:= K+1 To N Do -- 2-Schritt geht nicht

            A[I]:= \underline{B1TMDRow}(A,I,J,K,KF);          -- auf: m-Sp. ausraeumen

End; -- dann fertig

      J:= J+1;
      Else
         C0P:= \underline{C0Pivot}(A,J,K);                    -- evtl. Zeilentausch (C0)
         A:= C0P[1];
         C0:= C0P[2];
         If C0 = 0 Then                           -- c0 = 0: B1TMD mit KF
            If Len(ARGV) = 3 And K < N Then Return FALSE End;

For I:= K+1 To N Do -- j-, j+1-Sp. gleichzeitig

               A[I]:= \underline{B1TMDRow2Col}(A,I,J,K,0,KF);

End; -- ausraeumen unter k-Zeile

            KF:= A[K,J];                          -- naechster KF

K:= K+1; -- naechste Zeile

J:= J+2; -- uebernaechste Spalte

   Else                                     -- c0 <> 0:
      Det:= DivAlg(C0,[KF]);                -- B2TMDMD mit KF:
      Det:= Det.Quotients[1];               -- unter k+1-Zeile

For I:= K+2 To N Do -- j-, j+1-Spalte ausraeumen

         A[I]:= \underline{B2TMDMDRow}(A,I,J,K,KF,Det);

End; -- B1TMD, KF: in k+1-Zeile

      A[K+1]:= \underline{B1TMDRow2Col}(A,K+1,J,K,Det,KF); -- j-Spalte ausr.
      KF:= A[K+1,J+1];                      -- naechster KF

K:= K+2; -- uebernaechste Zeile J:= J+2; -- uebernaechste Spalte

   End;
End;
End;
Return A;
End;

B.2 Beispiel (Algorithmus B2TMDMDSM)

Der Algorithmus B2TMDMDSM aus Satz 13.3 stellt eine Modifikation von B2TMDMD dar, vgl. das vorangegangene Beispiel B.1. Die unterstrichenen Befehle bezeichnen wieder Unterprogramme, siehe dazu auch die entsprechenden Einträge im Manual (Anhang A). Syntax B2TMDMDSM (A: MAT): MAT B2TMDMDSM (A: MAT, E1: OBJECT, E2: OBJECT): MAT

Define B2TMDMDSM(...)
A:= ARGV[1];             -- Matrix A

N:= Len(A); -- Zeilenanzahl von A

S:= NumIndets();         -- Variablenanzahl
P:= Characteristic();    -- Charakteristik
If  P = 0 Then
SRing::= Q[x[1..(N-2+S)]];                  -- erweitere CurrentRing mit

Else -- Subst.variablen x 1..x n-2

SRing::= Z/(P)[x[1..(N-2+S)]];
End;

Using SRing Do -- weiter in Ringerw. N:= Len(A); -- Zeilenanzahl von A

A:= \underline{Injection}(A,N-2);

M:= Len(A[1]); -- Spaltenanzahl von A K:= 1; -- Zeilenzaehler KF:= 1; -- Kuerzungsfaktor (=1 bei Rekursionsanfang)

SubstList:= [A[I,I] | I In 1..(N-2)];       -- Liste der Subst. (Diagonale)
For I:= 1 To N-2 Do                         -- subst. Diagonale
   A[I,I]:= x[I];
End;
While K < N Do
C0:= \underline{C0 B2SM}(A,K);
Det:= \underline{MultSM}(C0,KF,1,K-1);
For I:= K+2 To N Do                         -- B2TMDMDSM: unter k+1-Z.
   A[I]:= \underline{B2TMDMDSMRow}(A,I,K,KF,Det);       -- k-, k+1-Sp. ausr.
End;                                        -- B1TMDSM: in k+1-Zeile
A[K+1]:= \underline{B1TMDSMRow2Col}(A,K+1,K,Det,KF);    -- k-Spalte ausr.
If K <= N-3 Then
   KF:= \underline{KFSM}(A,K+1);                        -- naechster KF
End;

K:= K+2; -- uebernaechste Zeile/Sp.

End;
A:= \underline{BackSubstTMD}(A,SubstList);                 -- Ruecksubstitution

End; -- zurueck zu CurrentRing

A:= \underline{Projection}(A,N-2);
Return A;
End;

B.3 Beispiel (Algorithmus MalDichVM)

Um den Algorithmus MalDichVM aus Satz 10.8 zu implementieren, wird die entsprechende CoCoA-Funktion rekursiv programmiert. Bei einem rekursiven Aufruf ist besondere Vorsicht geboten, will man den Rechner nicht in eine Endlosschleife schicken. Die unterstrichenen Befehle bezeichnen wieder Unterprogramme, siehe dazu auch die entsprechenden Einträge im Manual (Anhang A).

Define MalDichVM(...)
A:= ARGV[1];

N:= Len(A); -- Zeilenanzahl von A M:= Len(A[1]); -- Spaltenanzahl von A

A:= Mat[[Poly(X) | X In A[I]] | I In 1..N];

If Len(ARGV) = 1 Then -- default: Schrittgroesse s = 1

S:= 1; Else
S:= ARGV[2];
End;

If Len(ARGV) <= 2 Then -- default: diag. mit B2DMDMDFB (bei s=1 unnoetig)

Diag:= Function("\underline{B2DMDMDFB}"); Else
Diag:= ARGV[3];
End;

If Len(ARGV) <= 3 Then -- benoetige fuer Rekursion KFLU KFLU:= Poly(1); Else -- Rekursionsanfang: KFLU = 1

KFLU:= ARGV[4];
End;

K:= Min(S,N); -- Zeilenzaehler: Blockende obere Haelfte K2:= Min(2*K,N); -- Zeilenzaehler: Blockende untere Haelfte If S > 1 Then -- (1) Rekursionsanfang:

B:= Call(Diag,Submat(A,1..K,1..M),KFLU); -- diag. links oben
A:= \underline{BlockMat}(A, 1..K, 1..M, B);        -- s = 1: Rechnung unnoetig
End;
While K < N Do                            -- Rekursion:
B:= \underline{AusrLUMat}(A,KFLU,K,K2);            -- (2) ausraeumen links unten
A:= \underline{BlockMat}(A, (K+1)..K2, 1..M, B);   -- (k+1..k2)x(1..k)-Teilmatrix = 0
B:= Submat(A, (K+1)..K2, (K+1)..M );   -- (3) diag. rechts unten

KFRO:= A[K,K]; -- (rekursiv): KFRO = a kk

B:= \underline{MalDichVM}(B,S,Diag,KFRO);
A:= \underline{BlockMat}(A, (K+1)..K2, (K+1)..M, B);

-- (4) ausr. rechts oben: KFRO = a kk

B:= \underline{AusrROMat}(A,KFRO,K,K2); -- (1..k)x(k+1..k2)-Teilmatrix = 0

A:= \underline{BlockMat}(A, 1..K, 1..M, B);        -- Diagonale = a k2,k2

K:= K2; -- naechster Rekursionsschritt:

K2:= Min(2*K,N);                       -- wh. (2) - (4)
End;
Return A;
End;