			cdmarfmsp1hr( p, M )

	"common denominator matrix of rational functions over modular
	single prime, transcendence degree 1, hermitian reduction"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix cdmarfmsp1hr(p,M) single p; matrix M;
	Mr = cdmarfmsp1hr(p,M);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	M ist eine CD - Matrix ueber dem rationalen Funktionenkoerper
	(Z/pZ) (x) (siehe cdmarfmsp1id).
	k sei der kgV der Nenner aller Eintraege ungleich 0 von M.
	Mpol := k * M ist somit eine Matrix ueber dem Polynomring Z/pZ [x].
	Die Spaltenzahl von Mpol muss gleich dem Rang von Mpol sein.
	Mred sei die quadratische obere Dreiecksmatrix ueber Z/pZ [x],
	deren Zeilen eine (Z/pZ) [x] - Basis in Hermit-Normal-Form bilden
	von dem Modul, den die Zeilen von Mpol ueber Z/pZ [x] erzeugen.
	Mr ist eine CD - Matrix ueber dem rationalen Funktionenkoerper
	Z/pZ (x); sie entspricht (1 / k) * Mred.



			cdmarfmsp1id( n )

	"common denominator matrix of rational functions over modular
	single prime, transcendence degree 1, identity construction"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix cdmarfmsp1id(n) single n;
	A = cdmarfmsp1id(n);
	n ist eine positive single.
	A ist eine Liste von n Listen der Laenge (n+1). A repraesentiert
	als common-denominator (CD-) Matrix ueber dem rationalen
	Funktionenkoerper ueber Z/pZ, wobei p eine single Primzahl ist,
	die n x n Einheitsmatrix ueber obigem rationalen Funktionenkoerper.
	Allgemein entspricht eine m x (n+1) CD - Matrix mit Polynomen in
	einer Veraenderlichen ueber (Z/pZ) als Eintraegen, wobei
	insbesondere jede Zeile mit einem Element ungleich dem Nullpolynom
	beginnen muss, einer m x n Matrix ueber dem rationalen Funktionen-
	koerper ueber (Z/pZ).
	Dabei entsprechen sich die m Zeilen vermoege der Zuordnung:
	(d_1, r_2, ..., r_(n+1) )  <-->  (r_2 / d_1, ..., r_(n+1) / d_1 ).



			cdmarhermred( M )

	"common denominator matrix of rationals, hermitian reduction"
	Quellbibliothek : srclib.matr1
	Include - Datei : _matr1.h
	matrix cdmarhermred(M) matrix M;
	Mr = cdmarhermred(M);
	M ist eine CD - Matrix ueber den rationalen Zahlen (siehe cdmarid).
	k sei der kgV der Nenner aller Eintraege ungleich 0 von M.
	Mint := k * M ist somit eine Matrix ueber den ganzen Zahlen.
	Die Spaltenzahl von Mint muss gleich dem Rang von Mint sein.
	Mred sei die quadratische obere Dreiecksmatrix ueber den
	ganzen Zahlen, deren Zeilen eine Z-Basis in Hermit-Normal-Form
	bilden von dem Z-Modul, den die Zeilen von Mint ueber Z erzeugen.
	Mr ist eine CD-Matrix ueber den rationalen Zahlen,
	die (1 / k) * Mred entspricht.



			cdmarid( n )

	"common denominator matrix of rationals, identity construction"
	Quellbibliothek: srclib.matr1
	Include Datei  : _matr1.h
	matrix cdmarid(n) single n;
	A = cdmarid(n);
	n ist eine positive single;
	A ist eine Liste von n Listen der Laenge (n+1), die als
	common - denominator (CD -) Matrix ueber den rationalen
	Zahlen die n x n Einheitsmatrix ueber den rationalen Zahlen
	repraesentiert.
	Allgemein entspricht eine m x (n+1) CD - Matrix mit ganzen Zahlen
	als Eintraegen, wobei insbesondere jede Zeile mit einem Element
        ungleich Null beginnen muss, einer m x n Matrix ueber den
        rationalen Zahlen;
      	dabei entsprechen sich die m Zeilen vermoege der Zuordnung:
	(d_1, r_2, ..., r_(n+1) )  <-->  (r_2 / d_1, ..., r_(n+1) / d_1 ).



			fgetma( pf, fgetfkt, anzahlargs, arg1, arg2, arg3 )

	"file get matrix"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix fgetma(pf,fgetfkt,anzahlargs,arg1,arg2,arg3)
	    FILE *pf; obj (*fgetfkt)(); single anzahlargs;
	    obj arg1,arg2,arg3;
	M = fgetma(pf,fgetfkt,anzahlargs,arg1,arg2,arg3);
	*pf ist ein zum Lesen geoeffnetes File.
	fgetfkt ist die Einlesefunktion fuer Elemente eines Grundringes R.
	fgetfkt benoetigt ausser *pf noch anzahlargs Argumente;
	arg1, arg2 und arg3 (maximal) sind diese Argumente.
	fgetma liest eine Matrix von Elementen aus R vom File *pf.
	Eine korrekte mxn-Matrix hat die Form
	( (a11 .. a1n) (a21 .. a2n) .. (am1 .. amn) ),
	wobei aij aus R fuer i=1..m, j=1..n.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.
	siehe auch fgetmai, fgetmar, fgetmams, ...



			fgetmagfs( p, AL, V, pf )       (MACRO)

	"file get matrix of Galois-field with single characteristic
	 elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix fgetmagfs(p,AL,V,pf)  single p; list AL,V; FILE *pf;
	M = fgetmagfs(p,AL,V,pf);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Va-
		riablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist eine einelementige Variablenliste.
	      - *pf ist ein zum Lesen geoeffnetes File.
	fgetmagfs liest von *pf eine Matrix von Elementen aus GF(p^n) ein.
	Eine korrekte mxn-Matrix von Elementen aus GF(p^n) hat die Form
	( ( A11 ... A1n ) ( A21 ... A2n ) ... ( Am1 ... Amn ) ),
	wobei Aij ein Element aus GF(p^n) ist fuer i = 1, ..., m,
	j = 1, ..., n, dessen korrekter Aufbau in "fgetgfsel" und
	"gfsalgen" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.



			fgetmai( pf )                   (MACRO)

	"file get matrix of integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix fgetmai(pf) FILE *pf;
	M = fgetmai(pf);
	*pf ist ein zum Lesen geoeffnetes File.
	fgetmai liest eine Matrix von ganzen Zahlen vom File *pf.
	Eine korrekte mxn-Matrix von ganzen Zahlen hat die Form
	( (a11 .. a1n) (a21 .. a2n) .. (am1 .. amn) ),
	wobei aij vom Typ integer sind fuer i=1..m, j=1..n.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			fgetmami( m, pf )               (MACRO)

	"file get matrix of modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix fgetmami(m,pf)  int m; FILE *pf;
	M = fgetmami(m,pf);
	m ist positiv.
	*pf ist ein zum Lesen geoeffnetes File.
	Vom File *pf wird eine Matrix von ganzen Zahlen nach M eingelesen 
	und modulo m reduziert.
	M ist die eingelesene, modulo m reduzierte Matrix, falls das
	Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen oder Eingabe keine korrekte
	Matrix.



			fgetmams( m, pf )               (MACRO)

	"file get matrix of modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix fgetmams(m,pf)  single m; FILE *pf;
	M = fgetmams(m,pf);
	m ist positiv.
	*pf ist ein zum Lesen geoeffnetes File.
	Vom File *pf wird eine Matrix von einfach genauen ganzen Zahlen
	nach M eingelesen und modulo m reduziert.
	M ist die eingelesene, modulo m reduzierte Matrix, falls das
	Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen oder Eingabe keine korrekte
	Matrix.



			fgetmanf( F, VL, pf )           (MACRO)

	"file get matrix of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix fgetmanf(F,VL,pf)  pol F; list VL; FILE *pf;
	M = fgetmanf(F,VL,pf);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - VL ist eine einelementige Variablenliste.
	      - *pf ist ein zum Lesen geoeffnetes File.
	fgetmanf liest von *pf eine Matrix von Elementen aus k ein. Eine
	korrekte mxn-Matrix von Elementen aus k hat die Form
	( ( A11 ... A1n ) ( A21 ... A2n ) ... ( Am1 ... Amn ) ),
	wobei Aij ein Element aus k ist fuer i = 1, ..., m, j = 1, ..., n,
	dessen korrekter Aufbau in "fgetnfel" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.



			fgetmanfs( F, VL, pf )          (MACRO)

	"file get matrix of number field elements, sparse representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix fgetmanfs(F,VL,pf)  pol F; list VL; FILE *pf;
	M = fgetmanfs(F,VL,pf);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - VL ist eine einelementige Variablenliste.
	      - *pf ist ein zum Lesen geoeffnetes File.
	fgetmanfs liest von *pf eine Matrix von Elementen aus k ein.
	Eine korrekte mxn-Matrix von Elementen aus k hat die Form
	( ( A11 ... A1n ) ( A21 ... A2n ) ... ( Am1 ... Amn ) ),
	wobei Aij ein Element aus k ist fuer i = 1, ..., m, j = 1, ..., n,
	dessen korrekter Aufbau in "fgetnfels" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.



			fgetmapgfs( r, p, AL, V, Vgfs, pf )(MACRO)

	"file get matrix of polynomials over Galois-field with single
	 characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix fgetmapgfs(r,p,AL,V,Vgfs,pf)  single r,p; list AL,V,Vgfs;
		FILE *pf;
	M = fgetmapgfs(r,p,AL,V,Vgfs,pf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vgfs ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung
		GF(p^n)/(Z/pZ) repraesentiert.
	      - *pf ist ein zum Lesen geoeffnetes File.
	fgetmapgfs liest von *pf eine Matrix von Polynomen ueber GF(p^n)
	ein. Eine korrekte mxn-Matrix von Elementen aus GF(p^n)[X] hat die
	Form  ( ( P11 ... P1n ) ( P21 ... P2n ) ... ( Pm1 ... Pmn ) ),
	wobei Pij ein Polynom ueber GF(p^n) ist fuer i = 1, ..., m,
	j = 1, ..., n, dessen korrekter Aufbau in "fgetpgfs" beschrieben
	ist. M ist die eingelesene Matrix, falls das Einlesen erfolgreich
	war, M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.



			fgetmapi( r, V, pf )            (MACRO)

	"file get matrix of polynomials over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix fgetmapi(r,V,pf) single r; list V; FILE *pf;
	M = fgetmapi(r,V,pf);
	pf ist ein zum Lesen geoeffnetes File.
	V ist die Variablenliste.
	fgetmapi liest eine Matrix von Polynomen in r (0<=r<BASIS)
	ueber den ganzen Zahlen vom File *pf.
	Eine korrekte mxn-Matrix von Polynomen hat die Form
	( (p11 .. p1n) (p21 .. p2n) .. (pm1 .. pmn) ),
	wobei pij Polynome sind fuer i=1..m, j=1..n, deren korrekter
	Aufbau in "fgetpi" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			fgetmapmi( r, m, V, pf )        (MACRO)

	"file get matrix of polynomials over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix fgetmapmi(r,m,V,pf)  single r; int m; list V; FILE *pf;
	M = fgetmapmi(r,m,V,pf);
	*pf ist ein zum Lesen geoeffnetes File.
	V ist eine r-elementige Variablenliste (r>=0).
	fgetmapmi liest eine Matrix von Polynomen in den durch V gegebenen
	r Variablen ueber Z vom File *pf ein und reduziert die Polynome 
	modulo m (m>0).
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen oder Eingabe keine korrekte
	Matrix.



			fgetmapms( r, m, V, pf )        (MACRO)

	"file get matrix of polynomials over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix fgetmapms(r,m,V,pf)  single r,m; list V; FILE *pf;
	M = fgetmapms(r,m,V,pf);
	*pf ist ein zum Lesen geoeffnetes File.
	V ist eine r-elementige Variablenliste (r>=0).
	fgetmapms liest eine Matrix von Polynomen in den durch V gegebenen 
	r Variablen ueber Z vom File *pf ein und reduziert die Polynome 
	modulo m (m>0).
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen oder Eingabe keine korrekte
	Matrix.



			fgetmapnf( r, F, V, Vnf, pf )   (MACRO)

	"file get matrix of polynomials over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix fgetmapnf(r,F,V,Vnf,pf)  single r; pol F; list V,Vnf;
		FILE *pf;
	M = fgetmapnf(r,F,V,Vnf,pf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vnf ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung von Q
		repraesentiert.
	      - *pf ist ein zum Lesen geoeffnetes File.
	fgetmapnf liest von *pf eine Matrix von Polynomen ueber k ein.
	Eine korrekte mxn-Matrix von Elementen aus k[X] hat die Form
	( ( P11 ... P1n ) ( P21 ... P2n ) ... ( Pm1 ... Pmn ) ),
	wobei Pij ein Polynom ueber k ist fuer i = 1, ..., m, j = 1,...,n,
	dessen korrekter Aufbau in "fgetpnf" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.



			fgetmapr( r, V, pf )            (MACRO)

	"file get matrix of polynomials over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix fgetmapr(r,V,pf) single r; list V; FILE *pf;
	M = fgetmapr(r,V,pf);
	*pf ist ein zum Lesen geoeffnetes File.
	V ist die Variablenliste.
	fgetmapr liest eine Matrix von Polynomen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen vom File *pf.
	Eine korrekte mxn-Matrix von Polynomen hat die Form
	( (p11 .. p1n) (p21 .. p2n) .. (pm1 .. pmn) ),
	wobei pij Polynome sind fuer i=1..m, j=1..n, deren korrekter
	Aufbau in "fgetpr" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			fgetmar( pf )                   (MACRO)

	"file get matrix of rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix fgetmar(pf) FILE *pf;
	M = fgetmar(pf);
	*pf ist ein zum Lesen geoeffnetes File.
	fgetmar liest eine Matrix von rationalen Zahlen vom File *pf.
	Eine korrekte mxn-Matrix von rationalen Zahlen hat die Form
	( (a11 .. a1n) (a21 .. a2n) .. (am1 .. amn) ),
	wobei aij vom Typ rational sind fuer i=1..m, j=1..n.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			fgetmarfmsp1( p, V, pf )        (MACRO)

	"file get matrix of rational functions over modular single primes,
	 transcendence degree 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix fgetmarfmsp1(p,V,pf)  single p; list V; FILE *pf;
	M = fgetmarfmsp1(p,V,pf);
	*pf ist ein zum Lesen geoeffnetes File.
	p ist eine Primzahl kleiner BASIS.
	V ist die Variablenliste.
	fgetmarfmsp1 liest eine Matrix von rationalen Funktionen in einer
	Variablen ueber dem Primzahlkoerper Z/pZ vom File *pf.
	Eine korrekte mxn-Matrix von rationalen Funktionen hat die Form
	( (p11 .. p1n) (p21 .. p2n) .. (pm1 .. pmn) ),
	wobei pij rationale Funktionen sind fuer i=1..m, j=1..n, deren
	korrekter Aufbau in "fgetrfmsp1" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			fgetmarfr( r, V, pf )           (MACRO)

	"file get matrix of rational functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix fgetmarfr(r,V,pf)  single r; list V; FILE *pf;
	M = fgetmarfr(r,V,pf);
	*pf ist ein zum Lesen geoeffnetes File.
	V ist die Variablenliste.
	fgetmarfr liest eine Matrix von rationalen Funktionen in r
	(0<=r<BASIS) Variablen ueber den rationalen Zahlen vom File *pf.
	Eine korrekte mxn-Matrix von rationalen Funktionen hat die Form
	( (p11 .. p1n) (p21 .. p2n) .. (pm1 .. pmn) ),
	wobei pij rationale Funktionen sind fuer i=1..m, j=1..n, deren
	korrekter Aufbau in "fgetrfr" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			fgetmaspec( pf, fgetfkt, anzahlargs, arg1, ..., arg8 )

	"file get matrix special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix fgetmaspec(pf,fgetfkt,anzahlargs,arg1,...,arg8)
	       FILE *pf; obj (*fgetfkt)(); single anzahlargs;
	       obj arg1,...,arg8;
	M = fgetmaspec(pf,fgetfkt,anzahlargs,arg1,...,arg8);
	Dabei muss gelten:
	      - *pf ist ein zum Lesen geoeffnetes File.
	      - fgetfkt ist die Einlesefunktion fuer Elemente eines Grund-
		ringes R.
	      - fgetfkt benoetigt ausser *pf noch anzahlargs Argumente;
		arg1, ..., arg8 (maximal) sind diese Argumente.
	fgetmaspec liest eine Matrix von Elementen aus R vom File *pf.
	Eine korrekte mxn-Matrix hat die Form
	( ( A11 ... A1n ) ( A21 ... A2n ) ... ( Am1 ... Amn ) ),
	wobei Aij aus R fuer i = 1, ..., m, j = 1, ..., n.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war.
	M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.
	siehe auch fgetmapgfs



			fgetvec( pf, fgetfkt, anzahlargs, arg1, arg2, arg3 )

	"file get vector"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec fgetvec( pf, fgetfkt, anzahlargs, arg1, arg2, arg3 )
	    FILE *pf; obj (*fgetfkt)(); single anzahlargs;
	    obj arg1,arg2,arg3;
	V = fgetvec(pf,fgetfkt,anzahlargs,arg1,arg2,arg3);
	*pf ist ein zum Lesen geoeffnetes File.
	fgetfkt ist die Einlesefunktion fuer Elemente eines Grundringes R.
	fgetfkt benoetigt ausser *pf noch anzahlargs Argumente;
	arg1, arg2 und arg3 (maximal) sind diese Argumente.
	fgetvec liest einen Vektor von Elementen aus R vom File *pf.
	Ein korrekter Vektor hat die Form
	( a1 a2 ... am ), wobei ai aus R fuer i=1..m.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe kein
	korrekter Vektor war.
	siehe auch fgetveci, fgetvecr, fgetvecms, ...



			fgetvecgfs( p, AL, VL, pf )     (MACRO)

	"file get vector of Galois-field with single characteristic
	 elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec fgetvecgfs(p,AL,VL,pf)  single p; list AL,VL; FILE *pf;
	V = fgetvecgfs(p,AL,VL,pf);
	Dabei muss gelten:
              - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - VL ist eine einelementige Variablenliste.
	      - *pf ist ein zum Lesen geoeffnetes File.
	fgetvecgfs liest von *pf einen Vektor von Elementen aus GF(p^n)
	ein. Ein korrekter Vektor von Elementen aus GF(p^n) hat die Form
	( A1 ... An ),
	wobei Ai ein Element aus GF(p^n) ist fuer i = 1, ..., n, dessen
	korrekter Aufbau in "fgetgfsel" und "gfsalgen" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war.
	V = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	kein korrekter Vektor war.



			fgetveci( pf )                  (MACRO)

	"file get vector of integers "
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec fgetveci( pf );  FILE *pf;
	V = fgetveci( pf )
	*pf ist ein zum Lesen geoeffnetes File.
	fgetveci liest einen Vektor von ganzen Zahlen vom File *pf.
	Ein korrekter Vektor von ganzen Zahlen hat die Form
	( a1 a2 ... am ), wobei ai vom Typ integer fuer i=1..m.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor von ganzen Zahlen.



			fgetvecmi( m, pf )              (MACRO)

	"file get vector of modular integers "
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec fgetvecmi( m, pf )  int m; FILE *pf;
	V = fgetvecmi( m, pf )
	m ist positiv.
	*pf ist ein zum Lesen geoeffnetes File.
	Vom File *pf wird ein Vektor von ganzen Zahlen nach V eingelesen 
	und modulo m reduziert.
	V ist der eingelesene, modulo m reduzierte Vektor, falls das
	Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen oder Eingabe kein korrekter
	Vektor.



			fgetvecms( m, pf )              (MACRO)

	"file get vector of modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec fgetvecms( m, pf )  single m; FILE *pf;
	V = fgetvecms( m, pf )
	m ist positiv.
	*pf ist ein zum Lesen geoeffnetes File.
	Vom File *pf wird ein Vektor von einfach genauen ganzen Zahlen
	nach V eingelesen und modulo m reduziert.
	V ist der eingelesene, modulo m reduzierte Vektor, falls das
	Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen oder Eingabe kein korrekter
	Vektor.



			fgetvecnf( F, VL, pf )          (MACRO)

	"file get vector of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec fgetvecnf(F,VL,pf)  pol F; list VL; FILE *pf;
	V = fgetvecnf(F,VL,pf);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - VL ist eine einelementige Variablenliste.
	      - *pf ist ein zum Lesen geoeffnetes File.
	fgetvecnf liest von *pf einen Vektor von Elementen aus k ein.
	Ein korrekter Vektor von Elementen aus k hat die Form
	( A1 ... An ),
	wobei Ai ein Element aus k ist fuer i = 1, ..., n, dessen korrekter
	Aufbau in "fgetnfel" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war.
	V = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe kein
	korrekter Vektor war.



			fgetvecnfs( F, VL, pf )         (MACRO)

	"file get vector of number field elements, sparse representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec fgetvecnfs(F,VL,pf)  pol F; list VL; FILE *pf;
	V = fgetvecnfs(F,VL,pf);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - VL ist eine einelementige Variablenliste.
	      - *pf ist ein zum Lesen geoeffnetes File.
	fgetvecnfs liest von *pf einen Vektor von Elementen aus k ein.
	Ein korrekter Vektor von Elementen aus k hat die Form
	( A1 ... An ),
	wobei Ai ein Element aus k ist fuer i = 1, ..., n, dessen korrekter
	Aufbau in "fgetnfels" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war.
	V = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe kein
	korrekter Vektor war.



			fgetvecpi( r, VL, pf )          (MACRO)

	"file get vector of polynomials over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec fgetvecpi( r, VL, pf) single r; list VL; FILE *pf;
	V = fgetvecpi( r, VL, pf );
	pf ist ein zum Lesen geoeffnetes File.
	VL ist die Variablenliste.
	fgetvecpi liest einen Vektor von Polynomen in r (0<=r<BASIS)
	ueber den ganzen Zahlen vom File *pf.
	Ein korrekter Vektor von Polynomen hat die Form
	( p1 p2 ... pm ), wobei pi Polynome sind fuer i=1..m, deren
	korrekter Aufbau in "fgetpi" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor.



			fgetvecpmi( r, m, VL, pf )      (MACRO)

	"file get vector of polynomials over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec fgetvecpmi(r,m,VL,pf)  single r; int m; list VL; FILE *pf;   
	V = fgetvecpmi(r,m,VL,pf);
	*pf ist ein zum Lesen geoeffnetes File.
	VL ist eine r-elementige Variablenliste (r>=0).
	fgetvecpmi liest einen Vektor von Polynomen in den durch V gegebenen
	r Variablen ueber Z vom File *pf ein und reduziert die Polynome 
	modulo m (m>0).
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen oder Eingabe kein korrekter
	Vektor.



			fgetvecpms( r, m, VL, pf )      (MACRO)

	"file get vector of polynomials over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec fgetvecpms( r, m, VL, pf )  single r, m; list VL; FILE *pf;
	V = fgetvecpms( r, m, VL, pf );
	*pf ist ein zum Lesen geoeffnetes File.
	VL ist eine r-elementige Variablenliste (r>=0).
	fgetvecpms liest einen Vektor von Polynomen in den durch V 
	gegebenen r Variablen ueber Z vom File *pf ein und reduziert die
	Polynome modulo m (m>0).
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen oder Eingabe kein korrekter
	Vektor.



			fgetvecpnf( r, F, VL, VLnf, pf )(MACRO)

	"file get vector of polynomials over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec fgetvecpnf(r,F,VL,VLnf,pf)  single r; pol F; list VL,VLnf;
		FILE *pf;
	W = fgetvecpnf(r,F,VL,VLnf,pf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - VL ist eine Variablenliste der Laenge r (Fall: r=0, VL ist
		leere Liste, sonst VL = ( VL1, ..., VLr ) ).
	      - VLnf ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung von Q
		repraesentiert.
	      - *pf ist ein zum Lesen geoeffnetes File.
	fgetvecpnf liest von *pf einen Vektor von Polynomen ueber k ein.
	Ein korrekter Vektor von Elementen aus k[X] hat die Form
	( P1 ... Pn ),
	wobei Pi ein Polynom ueber k ist fuer i = 1, ..., n,
	dessen korrekter Aufbau in "fgetpnf" beschrieben ist.
	W ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	W = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	kein korrekter Vektor war.



			fgetvecpr( r, VL, pf )          (MACRO)

	"file get vector of polynomials over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec fgetvecpr( r, VL, pf) single r; list VL; FILE *pf;
	V = fgetvecpr( r, VL, pf );
	pf ist ein zum Lesen geoeffnetes File.
	VL ist die Variablenliste.
	fgetvecpr liest einen Vektor von Polynomen in r (0<=r<BASIS)
	ueber den rationalen Zahlen vom File *pf.
	Ein korrekter Vektor von Polynomen hat die Form
	( p1 p2 ... pm ), wobei pi Polynome sind fuer i=1..m, deren
	korrekter Aufbau in "fgetpr" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor.



			fgetvecr( pf )                  (MACRO)

	"file get vector of rationals "
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec fgetvecr( pf );  FILE *pf;
	V = fgetvecr( pf )
	*pf ist ein zum Lesen geoeffnetes File.
	fgetvecr liest einen Vektor von rationalen Zahlen vom File *pf.
	Ein korrekter Vektor von rationalen Zahlen hat die Form
	( a1 a2 ... am ), wobei ai vom Typ rational fuer i=1..m.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor von rationalen Zahlen.



			fgetvecrfr( r, VL, pf )         (MACRO)

	"file get vector of rational functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec fgetvecrfr( r, VL, pf)  single r; list VL; FILE *pf;
	V = fgetvecrfr( r, VL, pf );
	*pf ist ein zum Lesen geoeffnetes File.
	VL ist die Variablenliste.
	fgetvecrfr liest einen Vektor von rationalen Funktionen in r
	(0<=r<BASIS) Variablen ueber den rationalen Zahlen vom File *pf.
	Ein korrekter Vektor von rationalen Funktionen hat die Form
	( p1 p2 ... pm ), wobei p1, ..., pm rationale Funktionen sind,
	deren korrekter Aufbau in "fgetrfr" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls ein Fehler beim Einlesen auftrat oder die Eingabe
	kein korrekter Vektor war.



			fgetvecspec( pf, fgetfkt, anzahlargs, arg1, ..., arg8 )

	"file get vector special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec fgetvecspec(pf,fgetfkt,anzahlargs,arg1,...,arg8)
	    FILE *pf; obj (*fgetfkt)(); single anzahlargs;
	    obj arg1,...,arg8;
	V = fgetvecspec(pf,fgetfkt,anzahlargs,arg1,...,arg8);
	Dabei muss gelten:
	      - *pf ist ein zum Lesen geoeffnetes File.
	      - fgetfkt ist die Einlesefunktion fuer Elemente eines Grund-
		ringes R.
	      - fgetfkt benoetigt ausser *pf noch anzahlargs Argumente;
		arg1, ..., arg8 (maximal) sind diese Argumente.
	fgetvecspec liest einen Vektor von Elementen aus R vom File *pf.
	Ein korrekter Vektor hat die Form
	( A1 A2 ... Am ),
	wobei die Ai aus R fuer i = 1, ..., m.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe kein
	korrekter Vektor war.
	siehe auch fgetvecpgfs



			fgetvpgfs( r, p, AL, V, Vgfs, pf )(MACRO)

	"file get vector of polynomials over Galois-field with single
	 characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec fgetvpgfs(r,p,AL,V,Vgfs,pf)  single r,p; list AL,V,Vgfs;
		FILE *pf;
	W = fgetvpgfs(r,p,AL,V,Vgfs,pf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vgfs ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung
		GF(p^n)/(Z/pZ) repraesentiert.
	      - *pf ist ein zum Lesen geoeffnetes File.
	fgetvpgfs liest von *pf einen Vektor von Polynomen ueber GF(p^n)
	ein. Ein korrekter Vektor von Elementen aus GF(p^n)[X] hat die Form
	( P1 ... Pn ),
	wobei Pi ein Polynom ueber GF(p^n) ist fuer i = 1, ..., n, dessen
	korrekter Aufbau in "fgetpgfs" beschrieben ist.
	W ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	W = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe kein
	korrekter Vektor war.



			fgetvrfmsp1( p, VL, pf )        (MACRO)

	"file get vector of rational functions over modular single primes,
	 transcendence degree 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec fgetvrfmsp1( p, VL, pf)  single p; list VL; FILE *pf;
	V = fgetvrfmsp1( p, VL, pf );
	p ist eine Primzahl kleiner BASIS.
	*pf ist ein zum Lesen geoeffnetes File.
	VL ist die Variablenliste.
	fgetvrfmsp1 liest einen Vektor von rationalen Funktionen in einer
	Variablen ueber Z/pZ vom File *pf.
	Ein korrekter Vektor von rationalen Funktionen hat die Form
	( p1 p2 ... pm ), wobei p1, ..., pm rationale Funktionen sind,
	deren korrekter Aufbau in "fgetrfmsp1" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor.



			fputma( M, pf, fputfkt, anzahlargs, arg1, arg2, arg3 )

	"file put matrix"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputma(M,pf,fputfkt,anzahlargs,arg1,arg2,arg3)
	       matrix M; FILE *pf; single (*fputfkt)();
	       single anzahlargs; obj arg1,arg2,arg3;
	a = fputma(M,pf,fputfkt,anzahlargs,arg1,arg2,arg3);
	M ist eine Matrix ueber einem Grundring R.
	*pf ist ein zum Schreiben geoeffnetes File.
	fputfkt ist die zum Schreiben der Elemente aus dem Ring R
	notwendige Funktion.
	fputfkt benoetigt ausser *pf und einem Element aus R noch
	anzahlargs Argumente; arg1, arg2 und arg3 (maximal) sind diese
	Argumente.
	Beispielaufruf fuer das Schreiben von Matrizen von Polynomen
	in 3 Variablen ueber den ganzen Zahlen auf stdout mit der
	Variablenliste V:
	fputma(M,stdout,fputpi,3,V);
	fputma schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	  (a11 .. a1n)
	  (a21 .. a2n)
	  ..
	  (am1 .. amn)
	).
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmaflfx( M, v, n, pf )

	"file put matrix of floatings by fix point"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmaflfx( M , v, n, pf )  matrix M; single v, n; 
					   FILE *pf;
	a = fputmaflfx( M, v, n, pf );
	M ist eine Matrix von floating-Zahlen.
        v ist die Anzahl der Vor-, n die Anzahl der Nachkommastellen,
        mit denen die Matrixeintraege ausgegeben werden.
	fputmaflfx schreibt die rxs-Matrix M auf das File *pf 
	in der Form
	( 
	( a11 .. a1s )
	( a21 .. a2s )
	  ..
	( ar1 .. ars )
	 ).
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmagfs( p, AL, M, V, pf )    (MACRO)

	"file put matrix of Galois-field with single characteristic
	 elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single fputmagfs(p,AL,M,V,pf)  single p; list AL,V; matrix M;
		FILE *pf;
	a = fputmagfs(p,AL,M,V,pf);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine Matrix von Elementen aus GF(p^n).
	      - V ist eine einelementige Variablenliste.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	fputmagfs schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	  ( A11 ... A1n )
	  ( A21 ... A2n )
	  ...
	  ( Am1 ... Amn )
	),
	wobei die Elemente Aij aus GF(p^n) gemaess der in "fputgfsel" be-
	schriebenen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmai( M, pf )                (MACRO)

	"file put matrix of integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmai(M,pf)  matrix M; FILE *pf;
	a = fputmai(M,pf);
	M ist eine Matrix von ganzen Zahlen.
	*pf ist eine zum Schreiben geoeffnete Datei.
	fputmai schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	(a11 .. a1n)
	(a21 .. a2n)
	  ..
	(am1 .. amn)
	).
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0, sonst.



			fputmami( m, M, pf )            (MACRO)

	"file put matrix of modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmami(m,M,pf)  int m; matrix M; FILE *pf;
	t = fputmami(m,M,pf);
	M ist eine Matrix ueber Z/mZ (m>0).
	*pf ist eine zum Schreiben geoeffnete Datei.
	fputmami schreibt die rxs-Matrix M auf *pf in der Form
	(
	(a11 .. a1s)
	(a21 .. a2s)
	..
	(ar1 .. ars)
	)
	Ist s<7, so wird M formatiert ausgegeben, d.h. die Spalten werden 
	rechtsbuendig mit einer Breite von 11 Zeichen ausgegeben.
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			fputmams( m, M, pf )            (MACRO)

	"file put matrix of modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmams(m,M,pf)  single m; matrix M; FILE *pf;
	t = fputmams(m,M,pf);
	M ist eine Matrix ueber Z/mZ (m>0).
	*pf ist eine zum Schreiben geoeffnete Datei.
	fputmams schreibt die rxs-Matrix M auf *pf in der Form
	(
	(a11 .. a1s)
	(a21 .. a2s)
	..
	(ar1 .. ars)
	)
	Ist s<7, so wird M formatiert ausgegeben, d.h. die Spalten werden
	rechtsbuendig mit einer Breite von 11 Zeichen ausgegeben.
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			fputmanf( F, M, VL, pf )        (MACRO)

	"file put matrix of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single fputmanf(F,M,VL,pf)  pol F; matrix M; list VL; FILE *pf;
	a = fputmanf(F,M,VL,pf);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine Matrix von Elementen aus k ( vgl. fgetmanf ).
	      - VL ist eine einelementige Variablenliste.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	fputmanf schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	  ( A11 ... A1n )
	  ( A21 ... A2n )
	  ...
	  ( Am1 ... Amn )
	),
	wobei die Elemente Aij aus k gemaess der in "fputnfel" beschrieb-
	enen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmanfs( F, M, VL, pf )       (MACRO)

	"file put matrix of number field elements, sparse representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single fputmanfs(F,M,VL,pf)  pol F; matrix M; list VL; FILE *pf;
	a = fputmanfs(F,M,VL,pf);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine Matrix von Elementen aus k ( vgl. fgetmanfs ).
	      - VL ist eine einelementige Variablenliste.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	fputmanfs schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	  ( A11 ... A1n )
	  ( A21 ... A2n )
	  ...
	  ( Am1 ... Amn )
	),
	wobei die Elemente Aij aus k gemaess der in "fputnfels" beschrieb-
	enen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmapgfs( r, p, AL, M, V, Vgfs, pf )(MACRO)

	"file put matrix of polynomials over Galois-field with single
	 characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single fputmapgfs(r,p,AL,M,V,Vgfs,pf)  single r,p; list AL;
		matrix M; list V,Vgfs; FILE *pf;
	a = fputmapgfs(r,p,AL,M,V,Vgfs,pf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine Matrix von Polynomen ueber GF(p^n).
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vgfs ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung
		GF(p^n)/(Z/pZ) repraesentiert.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	fputmapgfs schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	  ( P11 ... P1n )
	  ( P21 ... P2n )
	  ...
	  ( Pm1 ... Pmn )
	),
	wobei die Polynome Pij aus GF(p^n)[X] gemaess der in "fputpgfs" be-
	schriebenen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmapi( r, M, V, pf )         (MACRO)

	"file put matrix of polynomials over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmapi(r,M,V,pf) single r; matrix M; list V; FILE *pf;
	a = fputmapi(r,M,V,pf);
	M ist eine Matrix von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen.
	*pf ist ein zum Schreiben geoeffnetes File.
	V ist eine Variblenliste.
	fputmapi schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	(p11 .. p1n)
	(p21 .. p2n)
	..
	(pm1 .. pmn)
	),
	wobei die Polynome pij gemaess der in "fputpi" beschriebenen
	Vorschriften auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmapmi( r, m, M, V, pf )     (MACRO)

	"file put matrix of polynomials over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmapmi(r,m,M,V,pf)  single r; int m; matrix M;
				      list V; FILE *pf;
	a = fputmapmi(r,m,M,V,pf);
	M ist eine Matrix von Polynomen in r (r>=0) Variablen ueber
	Z/mZ (m>0).
	*pf ist ein zum Schreiben geoeffnetes File.
	V ist eine r-elementige Variablenliste.
	fputmapmi schreibt die rxs-Matrix M auf das File *pf in der Form
	(
	(p11 .. p1s)
	(p21 .. p2s)
	  ..
	(pr1 .. prs)
	)
	wobei die Polynome pij gemaess der in "fputpmi" beschriebenen
	Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmapms( r, m, M, V, pf )     (MACRO)

	"file put matrix of polynomials over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmapms(r,m,M,V,pf)  single r,m; matrix M;
				      list V; FILE *pf;
	a = fputmapms(r,m,M,V,pf);
	M ist eine Matrix von Polynomen in r (r>=0) Variablen ueber
	Z/mZ (m>0).
	*pf ist ein zum Schreiben geoeffnetes File.
	V ist eine r-elementige Variablenliste.
	fputmapms schreibt die rxs-Matrix M auf das File *pf in der Form
	(
	(p11 .. p1s)
	(p21 .. p2s)
	  ..
	(pr1 .. prs)
	),
	wobei die Polynome pij gemaess der in "fputpms" beschriebenen
	Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmapnf( r, F, M, V, Vnf, pf )(MACRO)

	"file put matrix of polynomials over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single fputmapnf(r,F,M,V,Vnf,pf)  single r; pol F;
		matrix M; list V,Vnf; FILE *pf;
	a = fputmapnf(r,F,M,V,Vnf,pf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine Matrix von Polynomen ueber k.
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vnf ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung von Q
		repraesentiert.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	fputmapnf schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	  ( P11 ... P1n )
	  ( P21 ... P2n )
	  ...
	  ( Pm1 ... Pmn )
	),
	wobei die Polynome Pij aus k[X] gemaess der in "fputpnf" be-
	schriebenen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmapr( r, M, V, pf )         (MACRO)

	"file put matrix of polynomials over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmapr(r,M,V,pf) single r; matrix M; list V; FILE *pf;
	a = fputmapr(r,M,V,pf);
	M ist eine Matrix von Polynomen in r (0<=r<BASIS) Variablen ueber
	den rationalen Zahlen.
	*pf ist ein zum Schreiben geoeffnetes File.
	V ist eine Variblenliste.
	fputmapr schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	(p11 .. p1n)
	(p21 .. p2n)
	  ..
	(pm1 .. pmn)
	),
	wobei die Polynome pij gemaess der in "fputpr" beschriebenen
	Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmar( M, pf )                (MACRO)

	"file put matrix of rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmar(M,pf)  matrix M; FILE *pf;
	a = fputmar(M,pf);
	M ist eine Matrix von rationalen Zahlen.
	*pf ist eine zum Schreiben geoeffnete Datei.
	fputmar schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	(a11 .. a1n)
	(a21 .. a2n)
	  ..
	(am1 .. amn)
	).
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0, sonst.



			fputmarfmsp1( p, M, V, pf )     (MACRO)

	"file put matrix of rational functions over modular single primes,
	 transcendence degree 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single fputmarfmsp1(p,M,V,pf) single p; matrix M; list V; FILE *pf;
	a = fputmarfmsp1(p,M,V,pf);
	p ist eine Primzahl.
	M ist eine Matrix von rationalen Funktionen in einer Variablen
	ueber dem Primkoerper Z/pZ.
	*pf ist ein zum Schreiben geoeffnetes File.
	V ist eine Variblenliste.
	fputmarfmsp1 schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	(p11 .. p1n)
	(p21 .. p2n)
	  ..
	(pm1 .. pmn)
	),
	wobei die rationalen Funktionen pij gemaess der in "fputrfmsp1"
	beschriebenen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmarfr( r, M, V, pf )        (MACRO)

	"file put matrix of rational functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single fputmarfr(r,M,V,pf)  single r; matrix M; list V; FILE *pf;
	a = fputmarfr(r,M,V,pf);
	M ist eine Matrix von rationalen Funktionen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen.
	*pf ist ein zum Schreiben geoeffnetes File.
	V ist eine Variblenliste.
	fputmarfr schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	(p11 .. p1n)
	(p21 .. p2n)
	  ..
	(pm1 .. pmn)
	),
	wobei die rationalen Funktionen pij gemaess der in "fputrfr"
	beschriebenen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmas( M )

	"file put matrix of singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmas(M,pf) matrix M; FILE *pf;
	a = fputmas(M,pf);
	M ist eine Matrix von einfach genauen Zahlen.
	*pf ist ein zum Schreiben geoeffnetes File.
	fputmas schreibt die mxn-Matrix auf das File *pf in der Form
	(
	(a11 .. a1n)
	(a21 .. a2n)
	..
	(am1 .. amn)
	)       , falls M nicht Nullmatrix.
	Ist Zeilenlaenge der Matrix M <= 6, so wird M formatiert,
	d.h. die Spalten untereinander rechtsbuendig, ausgegeben.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputmaspec( M, pf, fputfkt, anzahlargs, arg1, ..., arg8 )

	"file put matrix special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputmaspec(M,pf,fputfkt,anzahlargs,arg1,...,arg8)
	       matrix M; FILE *pf; single (*fputfkt)();
	       single anzahlargs; obj arg1,...,arg8;
	a = fputmaspec(M,pf,fputfkt,anzahlargs,arg1,...,arg8);
	Dabei muss gelten:
	      - M ist eine Matrix ueber einem Grundring R.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	      - fputfkt ist die zum Schreiben der Elemente aus dem Ring R
		notwendige Funktion.
	      - fputfkt benoetigt ausser *pf und einem Element aus R noch
		anzahlargs Argumente; arg1, ..., arg8 (maximal) sind diese
		Argumente.
	fputmaspec schreibt die mxn-Matrix M auf das File *pf in der Form
	(
	  ( A11 ... A1n )
	  ( A21 ... A2n )
	  ...
	  ( Am1 ... Amn )
	).
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvec( V, pf, fputfkt, anzahlargs, arg1, arg2, arg3 )

	"file put vector"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputvec( V, pf, fputfkt, anzahlargs, arg1, arg2, arg3 )
	       vec V; FILE *pf; single (*fputfkt)();
	       single anzahlargs; obj arg1,arg2,arg3;
	a = fputvec(V,pf,fputfkt,anzahlargs,arg1,arg2,arg3)
	V ist ein Vektor ueber einem Grundring R.
	*pf ist ein zum Schreiben geoeffnetes File.
	fputfkt ist die zum Schreiben der Elemente aus dem Ring R
	notwendige Funktion.
	fputfkt benoetigt ausser *pf und einem Element aus R noch
	anzahlargs Argumente; arg1, arg2 und arg3 (maximal) sind diese
	Argumente.
	fputvec schreibt einen Vektor V auf das File *pf in der Form
	( a1 ... an ).
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecgfs( p, AL, V, VL, pf )  (MACRO)

	"file put vector of Galois-field with single characteristic
	 elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single fputvecgfs(p,AL,V,VL,pf)  single p; list AL,VL; vector V;
		FILE *pf;
	a = fputvecgfs(p,AL,V,VL,pf);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist ein Vektor von Elementen aus GF(p^n).
	      - VL ist eine einelementige Variablenliste.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	fputvecgfs schreibt den Vektor V auf das File *pf in der Form
	( A1 ... An ),
	wobei die Elemente Ai aus GF(p^n) gemaess der in "fputgfsel" be-
	schriebenen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputveci( V, pf )               (MACRO)

	"file put vector of integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputveci( V, pf ) vec V; FILE *pf;
	a = fputveci( V, pf );
	V ist ein Vektor von ganzen Zahlen.
	*pf ist ein zum Schreiben geoeffnetes File.
	fputveci schreibt den Vektoer V auf das File *pf in der Form
	( a1 ... an );
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecmi( m, V, pf )           (MACRO)

	"file put vector of modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputvecmi( m, V, pf )  int m; vec V; FILE *pf;
	a = fputvecmi( m, V, pf );
	V ist ein Vektor ueber Z/mZ (m>0).
	*pf ist eine zum Schreiben geoeffnete Datei.
	fputvecmi schreibt den Vektor V auf die Datei *pf.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecms( m, V, pf )           (MACRO)

	"file put vector of modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputvecms( m, V, pf )  single m; vec V; FILE *pf;
	a = fputvecms( m, V, pf );
	V ist ein Vektor ueber Z/mZ (m>0).
	*pf ist eine zum Schreiben geoeffnete Datei.
	fputvecms schreibt den Vektor V auf die Datei *pf.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecnf( F, V, VL, pf )       (MACRO)

	"file put vector of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single fputvecnf(F,V,VL,pf)  pol F; vec V; list VL; FILE *pf;
	a = fputvecnf(F,V,VL,pf);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist ein Vektor von Elementen aus k ( vgl. fgetvecnf ).
	      - VL ist eine einelementige Variablenliste.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	fputvecnf schreibt den Vektor V auf das File *pf in der Form
	( A1 ... An ),
	wobei die Elemente Ai aus k gemaess der in "fputnfel" beschriebenen
	Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecnfs( F, V, VL, pf )      (MACRO)

	"file put vector of number field elements, sparse representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single fputvecnfs(F,V,VL,pf)  pol F; vec V; list VL; FILE *pf;
	a = fputvecnfs(F,V,VL,pf);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist ein Vektor von Elementen aus k ( vgl. fgetmanfs ).
	      - VL ist eine einelementige Variablenliste.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	fputvecnfs schreibt den Vektor V auf das File *pf in der Form
	( A1 ... An ),
	wobei die Elemente Ai aus k gemaess der in "fputnfels" beschrieb-
	enen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecpi( r, V, VL, pf )       (MACRO)

	"file put vector of polynomials over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputvecpi( r, V, VL, pf) single r; vec V; list VL; FILE *pf;
	a = fputvecpi( r, V, VL, pf );
	V ist ein Vektor von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen.
	*pf ist ein zum Schreiben geoeffnetes File.
	VL ist eine Variblenliste.
	fputvecpi schreibt den Vektor V auf das File *pf in der Form
	( p1 ... pn ),
	wobei die Polynome pi gemaess der in "fputpi" beschriebenen
	Vorschriften auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecpmi( r, m, V, VL, pf )   (MACRO)

	"file put vector of polynomials over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputvecpmi( r, m, V, VL, pf )  single r; int m; vec V;
					      list VL; FILE *pf;
	a = fputvecpmi( r, m, V, VL, pf );
	V ist ein Vektor von Polynomen in r (r>=0) Variablen ueber 
	Z/mZ (m>0).
	*pf ist ein zum Schreiben geoeffnetes File.
	VL ist eine r-elementige Variablenliste.
	fputvecpmi schreibt den Vektor V auf das File *pf, wobei die
	Polynome gemaess der in "fputpmi" beschriebenen Vorschrift 
	auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecpms( r, m, V, VL, pf )   (MACRO)

	"file put vector of polynomials over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputvecpms( r, m, V, VL, pf )  single r, m; vec V;
					      list VL; FILE *pf;
	a = fputvecpms( r, m, V, VL, pf );
	V ist ein Vektor von Polynomen in r (r>=0) Variablen ueber
	Z/mZ (m>0).
	*pf ist ein zum Schreiben geoeffnetes File.
	VL ist eine r-elementige Variablenliste.
	fputvecpms schreibt den Vektor V auf das File *pf, wobei die
	Polynome gemaess der in "fputpms" beschriebenen Vorschrift auf 
	*pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecpnf( r, F, W, VL, VLnf, pf )(MACRO)

	"file put vector of polynomials over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single fputvecpnf(r,F,W,VL,VLnf,pf)  single r; pol F;
		vec W; list VL,VLnf; FILE *pf;
	a = fputvecpnf(r,F,W,VL,VLnf,pf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - W ist ein Vektor von Polynomen ueber k.
	      - VL ist eine Variablenliste der Laenge r (Fall: r=0, VL ist
		leere Liste, sonst VL = ( VL1, ..., VLr ) ).
	      - VLnf ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung von Q
		repraesentiert.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	fputvecpnf schreibt den Vektor W auf das File *pf in der Form
	( P1 ... Pn ),
	wobei die Polynome Pi aus k[X] gemaess der in "fputpnf" be-
	schriebenen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecpr( r, V, VL, pf )       (MACRO)

	"file put vector of polynomials over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputvecpr( r, V, VL, pf) single r; vec V; list VL; FILE *pf;
	a = fputvecpr( r, V, VL, pf );
	V ist ein Vektor von Polynomen in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen.
	*pf ist ein zum Schreiben geoeffnetes File.
	VL ist eine Variblenliste.
	fputvecpr schreibt den Vektor V auf das File *pf in der Form
	( p1 ... pn ),
	wobei die Polynome pi gemaess der in "fputpr" beschriebenen
	Vorschriften auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecr( V, pf )               (MACRO)

	"file put vector of rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputvecr( V, pf ) vec V; FILE *pf;
	a = fputvecr( V, pf );
	V ist ein Vektor von rationalen Zahlen.
	*pf ist ein zum Schreiben geoeffnetes File.
	fputvecr schreibt den Vektoer V auf das File *pf in der Form
	( a1 ... an );
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecrfr( r, V, VL, pf )      (MACRO)

	"file put vector of rational functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single fputvecrfr( r, V, VL, pf)  single r; vec V; list VL;
		FILE *pf;
	a = fputvecrfr( r, V, VL, pf );
	V ist ein Vektor von rationalen Funktionen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen.
	*pf ist ein zum Schreiben geoeffnetes File.
	VL ist eine Variblenliste.
	fputvecrfr schreibt den Vektor V auf das File *pf in der Form
	( p1 ... pn ),
	wobei die rationalen Funktionen pi gemaess der in "fputrfr"
	beschriebenen Vorschriften auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvecspec( V, pf, fputfkt, anzahlargs, arg1, ..., arg8 )

	"file put vector special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single fputvecspec(V,pf,fputfkt,anzahlargs,arg1,...,arg8)
	       vec V; FILE *pf; single (*fputfkt)(); single anzahlargs;
	       obj arg1,...,arg8;
	a = fputvecspec(V,pf,fputfkt,anzahlargs,arg1,...,arg8);
	Dabei muss gelten:
	      - V ist ein Vektor ueber einem Grundring R.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	      - fputfkt ist die zum Schreiben der Elemente aus dem Ring R
		notwendige Funktion.
	      - fputfkt benoetigt ausser *pf und einem Element aus R noch
		anzahlargs Argumente; arg1, ..., arg8 (maximal) sind diese
		Argumente.
	fputvecspec schreibt einen Vektor V auf das File *pf in der Form
	( A1 ... An ).
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvpgfs( r, p, AL, W, V, Vgfs, pf )(MACRO)

	"file put vector of polynomials over Galois-field with single
	 characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single fputvpgfs(r,p,AL,W,V,Vgfs,pf)  single r,p; list AL; vec W;
		list V,Vgfs; FILE *pf;
	a = fputvpgfs(r,p,AL,W,V,Vgfs,pf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - W ist ein Vektor von Polynomen ueber GF(p^n).
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vgfs ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung
		GF(p^n)/(Z/pZ) repraesentiert.
	      - *pf ist ein zum Schreiben geoeffnetes File.
	fputvpgfs schreibt den Vektor W auf das File *pf in der Form
	( P1 ... Pn ),
	wobei die Polynome Pi aus GF(p^n)[X] gemaess der in "fputpgfs" be-
	schriebenen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			fputvrfmsp1( p, V, VL, pf )     (MACRO)

	"file put vector of rational functions over modular single primes,
	 transcendence degree 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single fputvrfmsp1( p, V, VL, pf)  single p; vec V; list VL;
		FILE *pf;
	a = fputvrfmsp1( p, V, VL, pf );
	p ist eine Primzahl kleiner BASIS.
	V ist ein Vektor von rationalen Funktionen in einer Variablen
	ueber Z/pZ.
	*pf ist ein zum Schreiben geoeffnetes File.
	VL ist eine Variblenliste.
	fputvrfmsp1 schreibt den Vektor V auf das File *pf in der Form
	( p1 ... pn ),
	wobei die rationalen Funktionen pi gemaess der in "fputrfr"
	beschriebenen Vorschriften auf *pf geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			getmagfs( p, AL, V )            (MACRO)

	"get matrix of Galois-field with single characteristic elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix getmagfs(p,AL,V)  single p; list AL,V;
	M = getmagfs(p,AL,V);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist eine einelementige Variablenliste.
	getmagfs liest von stdin eine Matrix von Elementen aus GF(p^n) ein.
	Eine korrekte mxn-Matrix von Elementen aus GF(p^n) hat die Form
	( ( A11 ... A1n ) ( A21 ... A2n ) ... ( Am1 ... Amn ) ),
	wobei Aij ein Element aus GF(p^n) ist fuer i = 1, ..., m, und
	j = 1, ..., n, dessen korrekter Aufbau in "fgetgfsel" und
	"gfsalgen" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.



			getmai(  )                      (MACRO)

	"get matrix of integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix getmai();
	M = getmai();
	fgetmai liest eine Matrix von ganzen Zahlen vom stdin.
	Eine korrekte mxn-Matrix von ganzen Zahlen hat die Form
	( (a11 .. a1n) (a21 .. a2n) .. (am1 .. amn) ),
	wobei aij vom Typ integer sind fuer i=1..m, j=1..n.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			getmami( m )                    (MACRO)

	"get matrix of modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix getmami(m)  int m;
	M = getmami(m);
	m ist positiv.
	Von der Standardeingabe wird eine Matrix von ganzen Zahlen nach M 
	eingelesen und modulo m reduziert.
	M ist die eingelesene, modulo m reduzierte Matrix, falls das
	Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen oder Eingabe keine korrekte
	Matrix.



			getmams( m )                    (MACRO)

	"get matrix of modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix getmams(m)  single m;
	M = getmams(m);
	m ist positiv.
	Von der Standardeingabe wird eine Matrix von einfach genauen
	ganzen Zahlen nach M eingelesen und modulo m reduziert.
	M ist die eingelesene, modulo m reduzierte Matrix, falls das
	Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen oder Eingabe keine korrekte
	Matrix.



			getmanf( F, VL )                (MACRO)

	"get matrix of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix getmanf(F,VL)  pol F; list VL;
	M = getmanf(F,VL);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - VL ist eine einelementige Variablenliste.
	getmanf liest von stdin eine Matrix von Elementen aus k ein.
	Eine korrekte mxn-Matrix von Elementen aus k hat die Form
	( ( A11 ... A1n ) ( A21 ... A2n ) ... ( Am1 ... Amn ) ),
	wobei Aij ein Element aus k ist fuer i = 1, ..., m, j = 1, ..., n,
	dessen korrekter Aufbau in "fgetnfel" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.



			getmanfs( F, VL )               (MACRO)

	"get matrix of number field elements, sparse representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix getmanfs(F,VL)  pol F; list VL;
	M = getmanfs(F,VL);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - VL ist eine einelementige Variablenliste.
	getmanfs liest von stdin eine Matrix von Elementen aus k ein.
	Eine korrekte mxn-Matrix von Elementen aus k hat die Form
	( ( A11 ... A1n ) ( A21 ... A2n ) ... ( Am1 ... Amn ) ),
	wobei Aij ein Element aus k ist fuer i = 1, ..., m, j = 1, ..., n,
	dessen korrekter Aufbau in "fgetnfels" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.



			getmapgfs( r, p, AL, V, Vgfs )  (MACRO)

	"get matrix of polynomials over Galois-field with single
	 characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix getmapgfs(r,p,AL,V,Vgfs)  single r,p; list AL,V,Vgfs;
	M = getmapgfs(r,p,AL,V,Vgfs);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vgfs ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung
		GF(p^n)/(Z/pZ) repraesentiert.
	getmapgfs liest von stdin eine Matrix von Polynomen ueber GF(p^n)
	ein. Eine korrekte mxn-Matrix von Elementen aus GF(p^n)[X] hat die
	Form  ( ( P11 ... P1n ) ( P21 ... P2n ) ... ( Pm1 ... Pmn ) ),
	wobei Pij ein Polynom ueber GF(p^n) ist fuer i = 1, ..., m,
	j = 1, ..., n, dessen korrekter Aufbau in "fgetpgfs" beschrieben
	ist. M ist die eingelesene Matrix, falls das Einlesen erfolgreich
	war, M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.



			getmapi( r, V )                 (MACRO)

	"get matrix of polynomials over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix getmapi(r,V) single r; list V;
	M = getmapi(r,V);
	V ist die Variablenliste.
	getmapi liest eine Matrix von Polynomen in r (0<=r<BASIS)
	Variablen ueber den ganzen Zahlen von der Standardeingabe.
	Eine korrekte mxn-Matrix von Polynomen hat die Form
	( (p11 .. p1n) (p21 .. p2n) .. (pm1 .. pmn) ),
	wobei pij Polynome sind fuer i=1..m, j=1..n , deren korrekter
	Aufbau in "fgetpi" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			getmapmi( r, m, V )             (MACRO)

	"get matrix of polynomials over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix getmapmi(r,m,V)  single r; int m; list V;
	M = getmapmi(r,m,V);
	V ist eine r-elementige Variablenliste (r>=0).
	getmapmi liest eine Matrix von Polynomen in den durch V gegebenen 
	r Variablen ueber Z von der Standardeingabe und reduziert die 
	Polynome modulo m (m>0).
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen oder Eingabe keine korrekte
	Matrix.



			getmapms( r, m, V )             (MACRO)

	"get matrix of polynomials over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix getmapms(r,m,V)  single r,m; list V;
	M = getmapms(r,m,V);
	V ist eine r-elementige Variablenliste (r>=0).
	getmapms liest eine Matrix von Polynomen in den durch V gegebenen 
	r Variablen ueber Z von der Standardeingabe und reduziert die 
	Polynome modulo m (m>0).
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen oder Eingabe keine korrekte
	Matrix.



			getmapnf( r, F, V, Vnf )        (MACRO)

	"get matrix of polynomials over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix getmapnf(r,F,V,Vnf)  single r; pol F; list V,Vnf;
	M = getmapnf(r,F,V,Vnf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vnf ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung von Q
		repraesentiert.
	getmapnf liest von stdin eine Matrix von Polynomen ueber k ein.
	Eine korrekte mxn-Matrix von Elementen aus k[X] hat die Form
	( ( P11 ... P1n ) ( P21 ... P2n ) ... ( Pm1 ... Pmn ) ),
	wobei Pij ein Polynom ueber k ist fuer i = 1, ..., m, j = 1,...,n,
	dessen korrekter Aufbau in "fgetpnf" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	keine korrekte Matrix war.



			getmapr( r, V )                 (MACRO)

	"get matrix of polynomials over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix getmapr(r,V) single r; list V;
	M = getmapr(r,V);
	V ist die Variablenliste.
	getmapr liest eine Matrix von Polynomen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen von der Standardeingabe.
	Eine korrekte mxn-Matrix von Polynomen hat die Form
	( (p11 .. p1n) (p21 .. p2n) .. (pm1 .. pmn) ),
	wobei pij Polynome sind fuer i=1..m, j=1..n , deren korrekter
	Aufbau in "fgetpr" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			getmar(  )                      (MACRO)

	"get matrix of rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix getmar();
	M = fgetmar();
	fgetmar liest eine Matrix von rationalen Zahlen von stdin.
	Eine korrekte mxn-Matrix von rationalen Zahlen hat die Form
	( (a11 .. a1n) (a21 .. a2n) .. (am1 .. amn) ),
	wobei aij vom Typ rational sind fuer i=1..m, j=1..n.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			getmarfmsp1( p, V )             (MACRO)

	"get matrix of rational functions over modular single primes,
	 transcendence degree 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix getmarfmsp1(p,V)  single p; list V;
	M = getmarfmsp1(p,V);                    
	p ist eine Primzahl kleiner BASIS.
	V ist die Variablenliste.
	getmarfmsp1 liest eine Matrix von rationalen Funktionen in einer
	Variablen ueber dem Primzahlkoerper Z/pZ von der Standardeingabe.
	Eine korrekte mxn-Matrix von rationalen Funktionen hat die Form
	( (p11 .. p1n) (p21 .. p2n) .. (pm1 .. pmn) ),
	wobei pij rationale Funktionen sind fuer i=1..m, j=1..n , deren
	korrekter Aufbau in "fgetrfmsp1" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			getmarfr( r, V )                (MACRO)

	"get matrix of rational functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix getmarfr(r,V)  single r; list V;
	M = getmarfr(r,V);
	V ist die Variablenliste.
	getmarfr liest eine Matrix von rationalen Funktionen in r
	(0<=r<BASIS) Variablen ueber den rationalen Zahlen von der
	Standardeingabe.
	Eine korrekte mxn-Matrix von rationalen Funktionen hat die Form
	( (p11 .. p1n) (p21 .. p2n) .. (pm1 .. pmn) ),
	wobei pij rationale Funktionen sind fuer i=1..m, j=1..n , deren
	korrekter Aufbau in "fgetrfr" beschrieben ist.
	M ist die eingelesene Matrix, falls das Einlesen erfolgreich war,
	M = ERROR, falls Fehler beim Einlesen, oder Eingabe keine korrekte
	Matrix.



			getvecgfs( p, AL, VL )          (MACRO)

	"get vector of Galois-field with single characteristic elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec getvecgfs(p,AL,VL)  single p; list AL,VL;
	V = getmagfs(p,AL,VL);
	Dabei muss gelten:
              - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - VL ist eine einelementige Variablenliste.
	getvecgfs liest von stdin einen Vektor von Elementen aus GF(p^n)
	ein. Ein korrekter Vektor von Elementen aus GF(p^n) hat die Form
	( A1 ... An ),
	wobei Ai ein Element aus GF(p^n) ist fuer i = 1, ..., n, dessen
	korrekter Aufbau in "fgetgfsel" und "gfsalgen" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war.
	V = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	kein korrekter Vektor war.



			getveci(  )                     (MACRO)

	"get vector of integers "
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec getveci( );
	V = getveci( )
	getveci liest einen Vektor von ganzen Zahlen vom stdin.
	Ein korrekter Vektor von ganzen Zahlen hat die Form
	( a1 a2 ... am ), wobei ai vom Typ integer fuer i=1..m.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor von ganzen Zahlen.



			getvecmi( m )                   (MACRO)

	"get vector of modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec getvecmi( m )  int m;
	V = getvecmi( m )
	m ist positiv.
	Von stdin wird ein Vektor von ganzen Zahlen nach V eingelesen und 
	modulo m reduziert.
	V ist der eingelesene, modulo m reduzierte Vektor, falls das
	Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen oder Eingabe kein korrekter
	Vektor.



			getvecms( m )                   (MACRO)

	"get vector of modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec getvecms( m )  single m;
	V = getvecms( m )
	m ist positiv.
	Von stdin wird ein Vektor von einfach genauen ganzen Zahlen
	nach V eingelesen und modulo m reduziert.
	V ist der eingelesene, modulo m reduzierte Vektor, falls das
	Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen oder Eingabe kein korrekter
	Vektor.



			getvecnf( F, VL )               (MACRO)

	"get vector of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec getvecnf(F,VL)  pol F; list VL;
	V = getvecnf(F,VL);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - VL ist eine einelementige Variablenliste.
	getvecnf liest von stdin einen Vektor von Elementen aus k ein. Ein
	korrekter Vektor von Elementen aus k hat die Form
	( A1 ... An ),
	wobei Ai ein Element aus k ist fuer i = 1, ..., n, dessen korrekter
	Aufbau in "fgetnfel" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe kein
	korrekter Vektor war.



			getvecnfs( F, VL )              (MACRO)

	"get vector of number field elements, sparse representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec getvecnfs(F,VL)  pol F; list VL;
	V = getvecnfs(F,VL);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - VL ist eine einelementige Variablenliste.
	getvecnfs liest von stdin einen Vektor von Elementen aus k ein.
	Ein korrekter Vektor von Elementen aus k hat die Form
	( A1 ... An ),
	wobei Ai ein Element aus k ist fuer i = 1, ..., n, dessen korrekter
	Aufbau in "fgetnfels" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe kein
	korrekter Vektor war.



			getvecpi( r, VL )               (MACRO)

	"get vector of polynomials over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec getvecpi( r, VL ) single r; list VL;
	V = getvecpi( r, VL );
	VL ist die Variablenliste.
	getvecpi liest einen Vektor von Polynomen in r (0<=r<BASIS)
	ueber den ganzen Zahlen vom stdin.
	Ein korrekter Vektor von Polynomen hat die Form
	( p1 p2 ... pm ), wobei pi Polynome sind fuer i=1..m, deren
	korrekter Aufbau in "getpi" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor.



			getvecpmi( r, m, VL )           (MACRO)

	"get vector of polynomials over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec getvecpmi( r, m, VL )  single r; int m; list VL;
	V = getvecpmi( r, m, VL );
	VL ist eine r-elementige Variablenliste (r>=0).
	getvecpmi liest einen Vektor von Polynomen in den durch V gegebenen 
	r Variablen ueber Z von stdin ein und reduziert die Polynome modulo
	m (m>0).
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen oder Eingabe kein korrekter
	Vektor.



			getvecpms( r, m, VL )           (MACRO)

	"get vector of polynomials over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec getvecpms( r, m, VL )  single r, m; list VL;
	V = getvecpms( r, m, VL );
	VL ist eine r-elementige Variablenliste (r>=0).
	getvecpms liest einen Vektor von Polynomen in den durch V gegebenen
	r Variablen ueber Z von stdin ein und reduziert die Polynome modulo
	m (m>0).
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen oder Eingabe kein korrekter
	Vektor.



			getvecpnf( r, F, VL, VLnf )     (MACRO)

	"get vector of polynomials over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec getvecpnf(r,F,VL,VLnf)  single r; pol F; list VL,VLnf;
	W = getvecpnf(r,F,VL,VLnf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - VL ist eine Variablenliste der Laenge r (Fall: r=0, VL ist
		leere Liste, sonst VL = ( VL1, ..., VLr ) ).
	      - VLnf ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung von Q
		repraesentiert.
	getvecpnf liest von stdin einen Vektor von Polynomen ueber k ein.
	Ein korrekter Vektor von Elementen aus k[X] hat die Form
	( P1 ... Pn ),
	wobei Pi ein Polynom ueber k ist fuer i = 1, ..., n,
	dessen korrekter Aufbau in "fgetpnf" beschrieben ist.
	W ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	W = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe
	kein korrekter Vektor war.



			getvecpr( r, VL )               (MACRO)

	"get vector of polynomials over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec getvecpr( r, VL ) single r; list VL;
	V = getvecpr( r, VL );
	VL ist die Variablenliste.
	getvecpr liest einen Vektor von Polynomen in r (0<=r<BASIS)
	ueber den rationalen Zahlen vom stdin.
	Ein korrekter Vektor von Polynomen hat die Form
	( p1 p2 ... pm ), wobei pi Polynome sind fuer i=1..m, deren
	korrekter Aufbau in "getpr" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor.



			getvecr(  )                     (MACRO)

	"get vector of rationals "
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec getvecr( );
	V = getvecr( )
	getvecr liest einen Vektor von rationalen Zahlen vom stdin.
	Ein korrekter Vektor von rationalen Zahlen hat die Form
	( a1 a2 ... am ), wobei ai vom Typ rational fuer i=1..m.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor von rationalen Zahlen.



			getvecrfmsp1( p, VL )           (MACRO)

	"get vector of rational functions over modular single primes,
 	 transcendence degree 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec getvecrfmsp1( p, VL )  single p; list VL;
	V = getvecrfmsp1( p, VL );
	p ist eine Primzahl kleiner BASIS.
	VL ist die Variablenliste.
	getvecrfmsp1 liest einen Vektor von rationalen Funktionen in einer
	Variablen ueber Z/pZ von stdin.
	Ein korrekter Vektor von rationalen Funktionen hat die Form
	( p1 p2 ... pm ), wobei pi rationale Funktionen sind fuer i=1..m,
	deren korrekter Aufbau in "getrfmsp1" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor.



			getvecrfr( r, VL )              (MACRO)

	"get vector of rational functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec getvecrfr( r, VL )  single r; list VL;
	V = getvecrfr( r, VL );
	VL ist die Variablenliste.
	getvecrfr liest einen Vektor von rationalen Funktionen in r
	(0<=r<BASIS) Variablen ueber den rationalen Zahlen von stdin.
	Ein korrekter Vektor von rationalen Funktionen hat die Form
	( p1 p2 ... pm ), wobei pi rationale Funktionen sind fuer i=1..m,
	deren korrekter Aufbau in "getrfr" beschrieben ist.
	V ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	V = ERROR, falls Fehler beim Einlesen, oder Eingabe kein korrekter
	Vektor.



			getvpgfs( r, p, AL, V, Vgfs )   (MACRO)

	"get vector of polynomials over Galois-field with single
	 characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec getvpgfs(r,p,AL,V,Vgfs)  single r,p; list AL,V,Vgfs;
	W = getvpgfs(r,p,AL,V,Vgfs);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vgfs ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung
		GF(p^n)/(Z/pZ) repraesentiert.
	getvpgfs liest von stdin einen Vektor von Polynomen ueber GF(p^n)
	ein. Ein korrekter Vektor von Elementen aus GF(p^n)[X] hat die Form
	( P1 ... Pn ),
	wobei Pi ein Polynom ueber GF(p^n) ist fuer i = 1, ..., n, dessen
	korrekter Aufbau in "fgetpgfs" beschrieben ist.
	W ist der eingelesene Vektor, falls das Einlesen erfolgreich war,
	W = ERROR, falls es Fehler beim Einlesen gab, oder die Eingabe kein
	korrekter Vektor war.



			isma( M )

	"is matrix ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isma(M) obj M;
	a = isma(M);
	M ist ein Objekt.
	a =  1,  falls M als eine Matrix (von beliebigen Objekten)
		 interpretiert werden kann,
	     0,  sonst.



			isma_( M, is, anzahlargs, arg1, arg2 )

	"is matrix of ____ ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isma_(M,is,anzahlargs,arg1,arg2)
	       obj M, (*is)();  single anzahlargs;  obj arg1, arg2;
	a = isma_(M,is,anzahlargs,arg1,arg2);
	is ist eine Funktion, die testet, ob ein Objekt einem Ring R
	angehoert.
	is benoetigt ausser einem Element aus R noch anzahlargs Argumente;
	arg1 und arg2 (maximal) sind diese Argumente.
	a =  1,  falls M als Matrix ueber R interpretiert werden kann,
	     0,  sonst.



			ismadp( r, M )                  (MACRO)

	"is matrix of dense polynomials ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismadp(r,M)  obj r,M;
	a = ismadp(r,M);
	a = 1, falls M als Matrix von dense-Polynomen in r (0<=r<BASIS)
	       Variablen interpretiert werden kann;
	    0, sonst.



			ismadpi( r, M )                 (MACRO)

	"is matrix of dense polynomials over integers ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismadpi(r,M)  obj r,M;
	a = ismadpi(r,M);
	a = 1,  falls M als Matrix von dense-Polynomen in r (0<=r<BASIS)
		Variablen ueber den ganzen Zahlen interpretiert
		werden kann;
	    0,  sonst.



			ismadpms( r, m, M )             (MACRO)

	"is matrix of dense polynomials over modular singles ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismadpms(r,m,M)  obj r,m,M;
	a = ismadpms(r,m,M);
	a = 1,  falls M als Matrix von dense-Polynomen in r (0<=r<BASIS)
		Variablen ueber Z/mZ, m aus [1,BASIS), interpretiert
		werden kann;
	    0,  sonst.



			ismadpr( r, M )                 (MACRO)

	"is matrix of dense polynomials over rationals ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismadpr(r,M)  obj r,M;
	a = ismadpr(r,M);
	a = 1,  falls M als Matrix von dense-Polynomen in r (0<=r<BASIS)
		Variablen ueber den rationalen Zahlen interpretiert
		werden kann;
	    0,  sonst.



			ismaeqel( M, el )

	"is matrix of equal elements"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismaeqel (M, el) matrix M; obj el;
	n = ismaeqel (M, el)
	M ist eine Matrix ueber einem beliebigen Grundring R.
	el ist ein Element dieses Grundrings R.
	n = 1, falls alle Elemente von M gleich el sind, d.h falls fuer
	alle Elemente a von M gilt: oequal (a, el) = 1.
	n = 0, falls ein Element von M ungleich el ist.



			ismagfs( p, AL, M )             (MACRO)

	"is matrix of Galois-field with single characteristic elements ?"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single ismagfs(p,AL,M)  obj p,AL,M;
	s = ismagfs(p,AL,M);
	s hat den Wert 1, falls 
	      - p eine Primzahl < BASIS ist,
	      - AL = (G,AL1) als Arithmetikliste fuer GF(p^n) interpretiert
		werden kann (siehe gfsalgen), n = llength(AL1) + 1 gilt,
		G ein irreduzibles, normiertes Polynom in einer Variablen
		ueber Z/pZ ist, das Grad n >= 1 hat, und
	      - M als Matrix von Elementen aus GF(p^n) interpretiert werden
		kann,
	und 0, sonst.



			ismai( M )                      (MACRO)

	"is matrix of integers ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismai(M) obj M;
	a = ismai(M);
	M ist ein Objekt.
	a =  1,  falls M als Matrix von ganzen Zahlen interpretiert
		 werden kann,
	     0,  sonst.



			ismami( m, M )                  (MACRO)

	"is matrix of modular integers ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismami(m,M)  int m; obj M;
	a = ismami(m,M);
	m ist positiv.
	a =  1,  falls M als Matrix ueber Z/mZ interpretiert werden kann,
	     0,  sonst.



			ismams( m, M )                  (MACRO)

	"is matrix of modular singles ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismams(m,M)  single m; obj M;
	a = ismams(m,M);
	m ist positiv.
	a =  1,  falls M als Matrix ueber Z/mZ interpretiert werden kann,
	     0,  sonst.



			ismanf( F, M )                  (MACRO)

	"is matrix of number field elements ?"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single ismanf(F,M)  obj F,M;
	s = ismanf(F,M);
	s hat den Wert 1, falls
	      - F ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung ist, das den Zahl-
		koerper k erzeugt,
	      - M als Matrix von Elementen aus k interpretiert werden
		kann,
	und 0, sonst.



			ismanfs( F, M )                 (MACRO)

	"is matrix of number field elements, sparse representation ?"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single ismanfs(F,M)  obj F,M;
	s = ismanfs(F,M);
	s hat den Wert 1, falls
	      - F ein irreduzibles Polynom in einer Variablen ueber Q
		vom Grad >= 1 in sparse-Darstellung ist, das den Zahlkoer-
		per k erzeugt.
	      - M als Matrix von Elementen aus k interpretiert werden kann,
	und 0, sonst.



			ismap( r, M )                   (MACRO)

	"is matrix of polynomials ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismap(r,M)  obj r,M;
	a = ismap(r,M);
	a = 1, falls M als Matrix von Polynomen in r (0<=r<BASIS)
	       Variablen interpretiert werden kann;
	    0, sonst.



			ismapgfs( r, p, AL, M )         (MACRO)

	"is matrix of polynomials over Galois-field with single
	 characteristic ?"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single ismapgfs(r,p,AL,M)  obj r,p,AL,M;
	s = ismapgfs(r,p,AL,M);
	s hat den Wert 1, falls 
	      - 0 <= r < BASIS,
	      - p eine Primzahl < BASIS ist,
	      - AL = (G,AL1) als Arithmetikliste fuer GF(p^n) interpretiert
		werden kann (siehe gfsalgen), n = llength(AL1) + 1 gilt,
		G ein irreduzibles, normiertes Polynom in einer Variablen
		ueber Z/pZ ist, das Grad n >= 1 hat, und
	      - M als Matrix von Polynomen ueber GF(p^n) interpretiert wer-
		den kann,
	und 0, sonst.



			ismapi( r, M )                  (MACRO)

	"is matrix of polynomials over integers ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismapi(r,M) obj r, M;
	a = ismapi(r,M);
	r und M sind Objekte.
	a =  1,  falls M als Matrix von Polynomen in r (0<=r<BASIS)
		 Variablen ueber den ganzen Zahlen interpretiert
		 werden kann;
	     0,  sonst.



			ismapmi( r, m, M )              (MACRO)

	"is matrix of polynomials over modular integers ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismapmi(r,m,M)  obj r,m,M;
	a = ismapmi(r,m,M);
	r, m und M sind Objekte.
	a =  1,  falls M als Matrix von Polynomen in r (r>=0) Variablen
		 ueber Z/mZ (m>0) interpretiert werden kann;
	     0,  sonst.



			ismapms( r, m, M )              (MACRO)

	"is matrix of polynomials over modular singles ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismapms(r,m,M)  obj r,m,M;
	a = ismapms(r,m,M);
	r, m und M sind Objekte.
	a =  1,  falls M als Matrix von Polynomen in r (r>=0) Variablen
		 ueber Z/mZ (m>0) interpretiert werden kann;
	     0,  sonst.



			ismapr( r, M )                  (MACRO)

	"is matrix of polynomials over rationals ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismapr(r,M) obj r, M;
	a = ismapr(r,M);
	r und M sind Objekte.
	a =  1,  falls M als Matrix von Polynomen in r (0<=r<BASIS)
		 Variablen ueber den rationalen Zahlen interpretiert
		 werden kann;
	     0,  sonst.



			ismar( M )                      (MACRO)

	"is matrix of rationals ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismar(M) obj M;
	a = ismar(M);
	M ist ein Objekt.
	a =  1,  falls M als Matrix von rationalen Zahlen interpretiert
		 werden kann,
	     0,  sonst.



			ismarfmsp1( p, M )              (MACRO)

	"is matrix of rational functions over modular single primes,
	 transcendence degree 1 ?"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single ismarfmsp1(p,M)  obj p, M;
	a = ismarfmsp1(p,M);
	a =  1,  falls M als Matrix von rationalen Funktionen in einer
		 Variablen ueber Z/pZ, p Primzahl kleiner BASIS, inter-
		 pretiert werden kann;
	     0,  sonst.



			ismarfr( r, M )                 (MACRO)

	"is matrix of rational functions over rationals ?"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single ismarfr(r,M)  obj r, M;
	a = ismarfr(r,M);
	a =  1,  falls M als Matrix von rationalen Funktionen in r
		 (0<=r<BASIS) Variablen ueber den rationalen Zahlen
		 interpretiert werden kann;
	     0,  sonst.



			ismas( M )

	"is matrix of singles ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismas(M) obj M;
	a = ismas(M);
	M ist ein Objekt.
	a =  1,  falls M als Matrix von einfach genauen Zahlen
		 interpretiert werden kann,
	     0,  sonst.



			ismaspec_( M, is, anzahlargs, arg1, ..., arg5 )

	"is matrix of ____, special ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single ismaspec_(M,is,anzahlargs,arg1,...,arg5)
	       obj M,(*is)(); single anzahlargs; obj arg1,...,arg5;
	a = ismaspec_(M,is,anzahlargs,arg1,...,arg5);
	Dabei muss gelten:
	      - is ist eine Funktion, die testet, ob ein Objekt einem Ring
		R angehoert.
	      - is benoetigt ausser einem Element aus R noch anzahlargs
		Argumente; arg1, ..., arg5 (maximal) sind diese Argumente.
	a = 1, falls M als Matrix ueber R interpretiert werden kann,
	    0, sonst.



			isnullma( M )                   (MACRO)

	"is null-matrix"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isnullma(M)  matrix M;
	a = isnullma(M);
	M ist eine Matrix ueber einem beliebigen Grundring R.
	a = 1, falls alle Elemente von M gleich 0 sind.
	a = 0, falls ein Element von M ungleich 0 ist.



			isnullvec( V )

	"is null-vector"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isnullvec( V )  vec V;
	a = isnullvec( V )
	V ist ein Vektor ueber einem beliebigen Grundring R.
	a = 1, falls alle Elemente von V gleich 0 sind.
	a = 0, falls ein Element von V ungleich 0 ist.



			isvec( V )                      (MACRO)

	"is vector ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvec(V)  obj V;
	s = isvec(V);
	s hat den Wert 1, falls V Vektor ist,
	und 0, sonst.



			isvec_( V, is, anzahlargs, arg1, arg2 )

	"is vector of ____ ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvec_(V,is,anzahlargs,arg1,arg2)
	       obj V,(*is)(); single anzahlargs; obj arg1,arg2;
	a = isvec_(V,is,anzahlargs,arg1,arg2);
	is ist eine Funktion, die testet, ob ein Objekt einem Ring R
	angehoert.
	is benoetigt ausser einem Element aus R noch anzahlargs Argumente;
	arg1 und arg2 (maximal) sind diese Argumente.
	a =  1,  falls V als Vektor ueber R interpretiert werden kann,
	     0,  sonst.



			isvecdp( r, V )                 (MACRO)

	"is vector of dense polynomials ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecdp(r,V)  obj r,V;
	a = isvecdp(r,V);
	a = 1, falls V als Vektor von dense-Polynomen in r (0<=r<BASIS)
	       Variablen interpretiert werden kann;
	    0, sonst.



			isvecdpi( r, V )                (MACRO)

	"is vector of dense polynomials over integers ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecdpi(r,V)  obj r,V;
	s = isvecdpi(r,M);
	s = 1,  falls V als Vektor von dense-Polynomen in r (0<=r<BASIS)
		Variablen ueber den ganzen Zahlen interpretiert
		werden kann;
	    0,  sonst.



			isvecdpms( r, m, V )            (MACRO)

	"is vector of dense polynomials over modular singles ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecdpms(r,m,V)  obj r,m,V;
	s = isvecdpms(r,m,V);
	s = 1,  falls V als Vektor von dense-Polynomen in r (0<=r<BASIS)
		Variablen ueber Z/mZ, m aus [1,BASIS[, interpretiert
		werden kann;
	    0,  sonst.



			isvecdpr( r, V )                (MACRO)

	"is vector of dense polynomials over rationals ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecdpr(r,V)  obj r,V;
	s = isvecdpr(r,V);
	s = 1,  falls V als Vektor von dense-Polynomen in r (0<=r<BASIS)
		Variablen ueber den rationalen Zahlen interpretiert
		werden kann;
	    0,  sonst.



			isvecgfs( p, AL, A )            (MACRO)

	"is vector of Galois-field with single characteristic elements ?"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single isvecgfs(p,AL,A)  obj p,AL,A;
	s = isvecgfs(p,AL,A);
	s hat den Wert 1, falls p eine Primzahl < BASIS ist, AL = (G,AL1)
		als Arithmetikliste fuer GF(p^n) interpretiert werden kann
		(siehe gfsalgen), n = llength(AL1) + 1 gilt und L ein
		Vektor mit Elementen aus GF(p^n) ist,
	und 0, sonst.



			isveci( V )                     (MACRO)

	"is vector of integers ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isveci(V) obj V;
	s = isveci(V);
	V ist ein Objekt.
	s =  1,  falls V als Vektor von ganzen Zahlen interpretiert
		 werden kann,
	     0,  sonst.



			isvecms( m, A )                 (MACRO)

	"is vector of modular singles ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecms(m,A)  obj m,A;
	s = isvecms(m,A);
	s hat den Wert 1, falls m positive single ist und A Vektor von
		Elementen aus Z/mZ,
	und 0, sonst.



			isvecnf( F, V )                 (MACRO)

	"is vector of number field elements ?"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single isvecnf(F,V)  obj F,V;
	s = isvecnf(F,V);
	s hat den Wert 1, falls
	      - F ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung ist, das den Zahl-
		koerper k erzeugt.
	      - V als Vektor von Elementen aus k interpretiert werden
		kann,
	und 0, sonst.



			isvecnfs( F, V )                (MACRO)

	"is vector of number field elements, sparse representation ?"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single isvecnfs(F,V)  obj F,V;
	s = isvecnfs(F,V);
	s hat den Wert 1, falls
	      - F ein irreduzibles Polynom in einer Variablen ueber Q
		vom Grad >= 1 in sparse-Darstellung ist, das den Zahlkoer-
		per k erzeugt.
	      - V als Vektor von Elementen aus k interpretiert werden kann,
	und 0, sonst.



			isvecp( r, V )                  (MACRO)

	"is vector of polynomials ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecp(r,V)  obj r,V;
	a = isvecp(r,V);
	a = 1, falls V als Vektor von Polynomen in r (0<=r<BASIS)
	       Variablen interpretiert werden kann;
	    0, sonst.



			isvecpgfs( r, p, AL, V )        (MACRO)

	"is vector of polynomials over Galois-field with single
	 characteristic ?"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single isvecpgfs(r,p,AL,V)  obj r,p,AL,V;
	s = isvecpgfs(r,p,AL,V);
	s hat den Wert 1, falls 
	      - 0 <= r < BASIS,
	      - p eine Primzahl < BASIS ist,
	      - AL = (G,AL1) als Arithmetikliste fuer GF(p^n) interpretiert
		werden kann (siehe gfsalgen), n = llength(AL1) + 1 gilt,
		G ein irreduzibles, normiertes Polynom in einer Variablen
		ueber Z/pZ ist, das Grad n >= 1 hat, und
	      - V als Vektor von Polynomen ueber GF(p^n) interpretiert wer-
		den kann,
	und 0, sonst.



			isvecpi( r, V )                 (MACRO)

	"is vector of polynomials over integers ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecpi(r,V) obj r, V;
	s = isvecpi(r,M);
	r und V sind Objekte.
	s =  1,  falls V als Vektor von Polynomen in r (0<=r<BASIS)
		 Variablen ueber den ganzen Zahlen interpretiert
		 werden kann;
	     0,  sonst.



			isvecpms( r, m, V )             (MACRO)

	"is vector of polynomials over modular singles ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecpms(r,m,V) obj r,m,V;
	s = isvecpms(r,m,V);
	r, m und V sind Objekte.
	s =  1,  falls V als Vektor von Polynomen in r (0<=r<BASIS)
		 Variablen ueber Z/mZ, m aus [1,BASIS), interpretiert
		 werden kann;
	     0,  sonst.



			isvecpr( r, V )                 (MACRO)

	"is vector of polynomials over rationals ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecpr(r,V) obj r, V;
	s = isvecpr(r,M);
	r und V sind Objekte.
	s =  1,  falls V als Vektor von Polynomen in r (0<=r<BASIS)
		 Variablen ueber den rationalen Zahlen interpretiert
		 werden kann;
	     0,  sonst.



			isvecr( V )                     (MACRO)

	"is vector of rationals ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecr(V) obj V;
	s = isvecr(V);
	V ist ein Objekt.
	s =  1,  falls V als Vektor von rationalen Zahlen interpretiert
		 werden kann,
	     0,  sonst.



			isvecrfmsp1( p, V )             (MACRO)

	"is vector of rational functions over modular single primes,
	 transcendence degree 1 ?"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single isvecrfmsp1(p,V)  obj p, V;
	s = isvecrfmsp1(p,M);
	s =  1,  falls V als Vektor von rationalen Funktionen in einer
		 Variablen ueber Z/pZ, p Primzahl < BASIS, interpretiert
		 werden kann;
	     0,  sonst.



			isvecrfr( r, V )                (MACRO)

	"is vector of rational functions over rationals ?"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single isvecrfr(r,V)  obj r, V;
	s = isvecrfr(r,M);
	s =  1,  falls V als Vektor von rationalen Funktionen in r
		 (0<=r<BASIS) Variablen ueber den rationalen Zahlen
		 interpretiert werden kann;
	     0,  sonst.



			isvecspec_( V, is, anzahlargs, arg1, ..., arg5 )

	"is vector of ____, special ?"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single isvecspec_(V,is,anzahlargs,arg1,...,arg5)  obj V,(*is)();
		single anzahlargs; obj arg1,...,arg5;
	a = isvecspec_(V,is,anzahlargs,arg1,...,arg5);
	Dabei muss gelten:
	      - is ist eine Funktion, die testet, ob ein Objekt einem Ring
		R angehoert.
	      - is benoetigt ausser einem Element aus R noch anzahlargs
		Argumente; arg1, ..., arg5 (maximal) sind diese Argumente.
	a = 1, falls V als Vektor ueber R interpretiert werden kann,
	    0, sonst.



			maam( M, el )

	"matrix adjoin matrix"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maam (M, el) matrix M; obj el;
	N = maam (M, el);
	M ist eine mxn - Matrix ueber einem Ring R.
	el ist ein Element diese Ringes.
	N ist eine mx(m+1) - Matrix ueber R, wobei der rechte mxm - Teil
	der Matrix eine Diagonalmatrix ist, deren Diagonalelemente
	alle gleich el sind.
	typischer Aufruf: maam (M, list2(1,1)) (ueber Q)
	Vorsicht: M wird veraendert.



			macconc( M, N )

	"matrix constructive concatenation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix macconc(M,N)  matrix M, N;
	L = macconc(M,N);
	M ist eine mxn-Matrix, N eine mxl-Matrix.
	L = ( M, N ), d.h. die mx(n+l)-Matrix, die entsteht,
	wenn man M und N hintereinander schreibt.
	M und N bleiben erhalten.



			machpol( M, det, minusEins, anzahlargs, arg1, arg2 )

	"matrix characteristic polynomial"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol machpol(M,det,minusEins,anzahlargs,arg1,arg2)
	    matrix M; obj (*det)(),minusEins; single anzahlargs;
	    obj arg1,arg2;
	p = machpol(M,det,minusEins,anzahlargs,arg1,arg2);
	M ist eine Matrix ueber einem Ring R.
	det ist die Funktion, die die Determinante von Matrizen ueber dem
	Polynomring in einer Variablen ueber R berechnet.
	det benoetigt ausser M-X*E noch anzahlargs Argumente; arg1 und arg2
	(maximal) sind diese Argumente.
	minusEins ist -1 des Ringes R.
	p ist das charakteristische Polynom von M, also
	p(X) = det( M - X * E ); E ist dabei die Einheitsmatrix ueber R.
	p ist ein Polynom in einer Variablen ueber R.
	siehe auch: maichpol, marchpol, mamschpol, ...



			machpolspec( M, det, minusEins, anzahlargs, arg1, ..., arg5 )

	"matrix characteristic polynomial special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol machpolspec(M,det,minusEins,anzahlargs,arg1,...,arg5)
	    matrix M; obj (*det)(),minusEins; single anzahlargs;
	    obj arg1,...,arg5;
	p = machpolspec(M,det,minusEins,anzahlargs,arg1,...,arg5);
	Dabei muss gelten:
	      - M ist eine Matrix ueber einem Ring R.
	      - det ist die Funktion, die die Determinante von Matrizen
		ueber dem Polynomring in einer Variablen ueber R berechnet.
	      - det benoetigt ausser M-X*E noch anzahlargs Argumente;
		arg1, ..., arg5 (maximal) sind diese Argumente.
	      - minusEins ist -1 des Ringes R.
	p ist das charakteristische Polynom von M, also:
	p(X) = det( M - X * E ); E ist dabei die Einheitsmatrix ueber R.
	p ist ein Polynom in einer Variablen ueber R.
	siehe auch: magfschpol, mapgfschpol.



			maconc( M, N )

	"matrix concatenation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maconc(M,N)  matrix M, N;
	L = maconc(M,N);
	M ist eine mxn-Matrix, N eine mxl-Matrix.
	L = ( M, N ), d.h. die mx(n+l)-Matrix, die entsteht,
	wenn man M und N hintereinander schreibt.
	M wird veraendert.



			maconsdiag( n, el )

	"matrix construction diagonal-matrix"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maconsdiag(n,el) single n; obj el;
	M = maconsdiag(n,el);
	n ist eine ganze Zahl, n>=1.
	M ist eine nxn-Matrix mit Eintraegen el auf der Hauptdiagonalen.
	M = ( dij * el ) mit dij=1, falls i=j, und 0 sonst fuer i,j=1..n.



			maconszero( m, n )

	"matrix construction zero"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	maconszero(m,n)  single m,n;
	N = maconszero(m,n)
	m und n sind positiv.
	N ist eine mxn-Matrix, deren Eintraege alle 0 sind.



			macopy( M )

	"matrix copy"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix macopy(M) matrix M;
	N = macopy(M);
	N ist eine Kopie der Matrix M.



			mactransp( M )

	"matrix constructive transpose"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mactransp(M) matrix M;
	N = mactransp(M)
	M ist eine Matrix von beliebigen Objekten.
	mactransp liefert die Matrix M transponiert.
	Ist M die mxn-Matrix
	( (a11 .. a1n) (a21 .. a2n) .. (am1 .. amn) ),
	so ist N die nxm-Matrix
	( (a11 .. am1) (a12 .. am2) .. (a1n .. amn) ).



			macup( n, L )

	"matrix of coefficients of univariate polynomials"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix macup(n,L)  single n;  list L;
	M = macup(n,L);
	L = (L1,...,Lr) mit r >= 0 ist eine Liste von Polynomen in einer
	Variable, deren Grad < n ist, wobei n > 0.
	M = ((m[1,0],...,m[1,n-1]),...,(m[r,0],...,m[r,n-1])) ist die
	Matrix der Koeffizienten von L1,...,Lr , d.h. fuer i = 1,...,r
	gilt :
	Li = m[i,0] X^0 + m[i,1] X^1 + ... + m[i,n-1] X^(n-1).



			madel1rc( pM, i, j )

	"matrix delete 1 row and 1 column"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	obj madel1rc (pM,i,j)  matrix *pM; single i,j;
	m_ij = madel1rc (pM,i,j);
        Dabei muss gelten:
              - *pM ist eine beliebige nxm-Matrix,
              - 1 <= i <= n,
              - 1 <= j <= m.
	m_ij ist das Element in Zeile i und Spalte j von *pM.
	Aus *pM werden die i-te Zeile sowie die j-te Spalte entfernt.
!!!	Ist *pM eine 1xm-Matrix oder eine nx1-Matrix, so wird *pM = _0.



			madelsc( pM, I )

	"matrix delete several columns"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single madelsc (pM,I)  matrix *pM; list I;
	a = madelsc (pM,I);
	Dabei muss gelten:
              - *pM ist eine beliebige nxm-Matrix,
	      - I ist eine Liste von Zahlen < BASIS, fuer die gilt:
		    1 <= i1 < i2 < ... < ik <= m,
		wobei I auch die leere Liste sein darf.
	Aus *pM werden die Spalten i1 bis ik entfernt.
	a hat den Wert 0.
!!!	Ist k = m, so ist *pM = _0.



			madelsr( pM, I )

	"matrix delete several rows"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single madelsr (pM,I)  matrix *pM; list I;
	a = madelsr (pM,I);
	Dabei muss gelten:
              - *pM ist eine beliebige nxm-Matrix,
	      - I ist eine Liste von Zahlen < BASIS, fuer die gilt:
		    1 <= i1 < i2 < ... < ik <= n,
		wobei I auch die leere Liste sein darf.
	Aus *pM werden die Zeilen i1 bis ik entfernt.
	a hat den Wert 0.
!!!	Ist k = n, so ist *pM = _0.



			madelsrc( pM, I, J )            (MACRO)

	"matrix delete several rows and columns"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single madelsrc (pM,I,J)  matrix *pM; list I,J;
	a = madelsrc (pM,I,J);
	Dabei muss gelten:
              - *pM ist eine beliebige nxm-Matrix,
	      - I ist eine Liste von Zahlen < BASIS, fuer die gilt:
		    1 <= i1 < i2 < ... < ik <= n,
	      - J ist eine Liste von Zahlen < BASIS, fuer die gilt:
		    1 <= j1 < j2 < ... < jl <= m,
	      wobei I und J auch die leere Liste sein duerfen.
	Aus *pM werden die Zeilen i1 bis ik und die 
	Spalten j1 bis jl entfernt.
	a hat den Wert 0.
!!!	Ist k = n oder l = m, so ist *pM = _0.



			madptomap( r, M )

	"matrix of dense polynomials to matrix of polynomials"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix madptomap(r,M)  single r; matrix M;
	L = madptomap(r,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - M ist eine Matrix von Polynomen in r Variablen in dense-
		Darstellung.
	Die Matrix M von Polynomen in r Variablen in dense-Darstellung
	wird in die Matrix L von Polynomen in r Variablen in rekursiver
	Darstellung umgewandelt.
	L = M. (rekursive Darstellung der Polynome)



			mafldet( M )

	"matrix of floatings determinant"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	floating mafldet( M )  matrix M;
	D = mafldet( M );
	M ist eine quadratische Matrix von floating-Zahlen.
	D ist die Determinante von M.



			magfschpol( p, AL, M )          (MACRO)

	"matrix of Galois-field with single characteristic elements
	 characteristic polynomial"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	pol magfschpol(p,AL,M)  single p; list AL; matrix M;
	chp = magfschpol(p,AL,M);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine quadratische Matrix von Elementen aus GF(p^n).
	chp ist das charakteristische Polynom von M:
	chp(X) = det( M - X * E ), E Einheitsmatrix.
	chp ist ein Polynom in einer Variablen ueber GF(p^n).



			magfscons1( p, AL, n )          (MACRO)

	"matrix of Galois-field with single characteristic elements
	 construction 1"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix magfscons1(p,AL,n)  single p; list AL; single n;
	E = magfscons1(p,AL,n);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - 1 <= n < BASIS.
	E ist die n-dimensionale Einheitsmatrix.
	E = ( Dij ) i,j = 1, ..., n mit Dij = 1, falls i = j, 0 sonst.
	Dij sind Elemente aus GF(p^n).



			magfsdet( p, AL, M )

	"matrix of Galois-field with single characteristic elements
	 determinant"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	gfel magfsdet(p,AL,M)  single p; list AL; matrix M;
	P = magfsdet(p,AL,M);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine quadratische Matrix von Elementen aus GF(p^n).
	P ist die Determinante von M, also ein Element aus GF(p^n).



			magfsdif( p, AL, M, N )         (MACRO)

	"matrix of Galois-field with single characteristic elements
	 difference"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix magfsdif(p,AL,M,N)  single p; list AL; matrix M,N;
	L = magfsdif(p,AL,M,N);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M und N sind Matrizen von Elementen aus GF(p^n) gleicher
		Dimension.
	L = M - N.



			magfsefe( p, ALm, M, g )

	"matrix over Galois-field with single characteristic embedding 
	in field extension"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix magfsefe(p, ALm, M, g)  single p; list ALm; 
		matrix M; gfel g;
	N = magfsefe( p, ALm, M, g );
	Es wird die Matrix M ueber GF(p^n) dargestellt als Matrix 
	ueber einer Koerpererweiterung GF(p^m) (p Primzahl, 1<n,m<BASIS,
	n teilt echt m), deren Arithmetikliste mittels gfsalgenies 
	erzeugt wurde. Die Liste ALm entspricht der Arithmetikliste
	von GF(p^m), wie sie einer Ausgabe von gfsalgen entspricht, 
	g als Polynom in einer Unbestimmten entspricht dem Bild des
	separablen Erzeugers von GF(p^n) ueber GF(p) unter der von
	gfsalgenies gefundenen isomorphen Einbettung von GF(p^n) in 
	GF(p^m) (vgl. gfsalgen, gfsalgenies).
	N ist die Darstellung von M als Matrix ueber GF(p^m).
!!!     HINWEIS: g ist vom Typ "gfel", d.h. ein sparse-Polynom in einer
		 Unbestimmten mit Koeffizienten aus Z/pZ.



			magfsevifcp( p, AL, M, pL )

	"matrix over Galois-field with single characteristic eigenvalues
	 and irreducible factors of the characteristic polynomial"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	list magfsevifcp( p, AL, M, pL )  single p; matrix M; list AL,*pL;
	L = magfsevifcp( p, AL, M, pL );
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = ( G, AL1 ) kann als Arithmetikliste fuer GF(p^n)
		interpretiert werden ( vgl. gfsalgen ), wobei 
		n = llength( AL1 ) + 1. G ist ein irreduzibles 
		normiertes Polynom in  einer Variablen ueber Z/pZ, das 
		Grad n >= 1 hat.
	      - M ist eine quadratische Matrix von Elementen aus GF(p^n).
	L = (EW1, ..., EWk) mit EWi aus GF(p^n) ist die Liste der 
	Eigenwerte der Matrix M (ihrer algebraischen Vielfachheit 
	entsprechend oft auftretend). Diese erhaelt man durch 
	Faktorisierung des charakteristischen Polynoms von M.
        *pL = (P1, ..., Pn), wobei die Pj fuer 1 <= j <= n die 
	irreduziblen Faktoren des charakteristischen Polynoms (ihrer 
	Vielfachheit entsprechend oft auftretend) sind.
	(Die Nullstellen der Linearfaktoren sind die Eigenwerte von M.)



			magfsexp( p, AL, M, n )

	"matrix of Galois-field with single characteristic elements
	 exponentiation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix magfsexp(p,AL,M,n)  single p; list AL; matrix M; single n;
	X = magfsexp(p,AL,M,n);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine quadratische Matrix ueber GF(p^m).
	      - -BASIS+1 <= n <= BASIS-1.
	X = M^n.
	Im Falle n < 0, muss M invertierbar sein,
	!! also Det(M) != 0 !!



			magfsinv( p, AL, M )

	"matrix of Galois-field with single characteristic elements
	 inverse"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix magfsinv(p,AL,M)  single p; list AL; matrix M;
	N = magfsinv(p,AL,M);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine quadratische, invertierbare Matrix ueber
		GF(p^n),
		!!!  also Det(M) != 0  !!!
	N = M^-1.



			magfsneg( p, AL, M )            (MACRO)

	"matrix of Galois-field with single characteristic elements
	 negation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix magfsneg(p,AL,M)  single p; list AL; matrix M;
	N = magfsneg(p,AL,M);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine Matrix von Elementen aus GF(p^n).
	N = -M.



			magfsnsb( p, AL, M )

	"matrix of Galois-field with single characteristic elements,
	null space basis"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list magfsnsb(p,AL,M)  single p; list AL; matrix M;
	L = magfsnsb(p,AL,M);
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^m) interpretiert werden (siehe gfsalgen), und es gilt
	m = llength(AL1) + 1.
	M ist eine (n,n) - Matrix mit Komponenten aus GF(p^m), 1<=n<Basis.
	L = (L1,...,Lr) ist eine Liste von Vektoren, die eine Basis des
	Nullraums von M bilden, also M * Li = 0 fuer alle i = 1,...,r.
	Jeder Vektor Li ist eine Liste der Laenge n.
!!!     Die Matrix M wird veraendert.



			magfsprod( p, AL, M, N )        (MACRO)

	"matrix of Galois-field with single characteristic elements
	 product"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix magfsprod(p,AL,M,N)  single p; list AL; matrix M,N;
	L = magfsprod(p,AL,M,N);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine mxn-Matrix,
	      - N ist eine nxl-Matrix mit l,m,n >= 1 und Elementen aus
		GF(p^n).
	L = M * N, ist eine mxl-Matrix.



			magfsrk( p, AL, M )

	"matrix of Galois-field with single characteristic elements rank"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single magfsrk(p,AL,M)  single p; list AL; matrix M;
	r = magfsrk(p,AL,M);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine beliebige Matrix ueber GF(p^n).
	Mit Hilfe des Gausschen Algorithmus wird der Rang von M berechnet.



			magfssmul( p, AL, M, el )

	"matrix of Galois-field with single characteristic elements scalar
	 multiplication"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix magfssmul(p,AL,M,el)  single p; list AL; matrix M; gfel el;
	N = magfssmul(p,AL,M,el);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine mxn-Matrix mit m,n >= 1 und Elementen aus
		GF(p^n).
	      - el ist ein Element aus GF(p^n).
	N = el * M ist eine mxn-Matrix.



			magfsssle( p, AL, A, b, pX, pN )

	"matrix of Galois-field with single characteristic elements
	 solution of a system of linear equations"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single magfsssle(p,AL,A,b,pX,pN)  single p; list AL; matrix A;
		vec b, *pX; list *pN;
	z = magfsssle(p,AL,A,b,pX,pN);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - A ist eine mxl-Matrix ueber GF(p^n). Mindestens ein Eintrag
		von A muss != 0 sein.
	      - b ist ein Vektor der Laenge m ueber GF(p^n).
	Geloest wird das Gleichungssytem (*) A * x = b.
	Ist (*) eindeutig loesbar, so ist z=0, *pX ist der Loesungsvektor,
	und *pN ist die leere Liste.
	Ist (*) unloesbar, so ist z = -1, *pX und *pN sind die leere Liste.
	Ist (*) mehrdeutig loesbar, so ist *pX eine spezielle Loesung,
	z ist die Dimension des Nullraums von A, und *pN ist eine Liste 
	der Nullraum-Basis-Vektoren.



			magfssum( p, AL, M, N )         (MACRO)

	"matrix of Galois-field with single characteristic elements sum"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix magfssum(p,AL,M,N)  single p; list AL; matrix M,N;
	L = magfssum(p,AL,M,N);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M und N sind Matrizen von Elementen aus GF(p^n) gleicher
		Dimension.
	L = M + N.



			magfsvecmul( p, AL, A, x )      (MACRO)

	"matrix of Galois-field with single characteristic elements vector
	 multiplication"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix magfsvecmul(p,AL,A,x)  single p; list AL; matrix A; vec x;
	y = magfsvecmul(p,AL,A,x);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - A ist eine mxn-Matrix mit m,n >= 1 und Elementen aus
		GF(p^n).
	      - x ist ein Vektor der Laenge n mit Elementen aus GF(p^n).
	y = A * x, ist ein Vektor der Laenge m.



			maichpol( M )                   (MACRO)

	"matrix of integers characteristic polynomial"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol maichpol(M) matrix M;
	p = maichpol(M);
	M ist eine Matrix von ganzen Zahlen.
	p ist das charakteristische Polynom von M, also
	p(X) = det( M - X * E ), E Einheitsmatrix.
	p ist ein Polynom in einer Variablen ueber Z.



			maicons1( n )                   (MACRO)

	"matrix of integers construction 1"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maicons1(n) single n;
	E = maicons1(n);
	n ist eine ganze Zahl, n>=1.
	E ist die n-dimensionale Einheitsmatrix von ganzen Zahlen.
	E = ( dij ) i,j = 1..n mit dij = 1, falls i=j, 0 sonst.



			maidet( M )

	"matrix of integers determinant"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	int maidet(M) matrix M;
	D = maidet(M);
	M ist eine quadratische Matrix von ganzen Zahlen.
	D ist die Determinante von M.



			maidif( M, N )                  (MACRO)

	"matrix of integers difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maidif(M,N) matrix M, N;
	L = maidif(M,N);
	M und N sind Matrizen von ganzen Zahlen gleicher Dimension.
	L = M - N.



			maiedfcf( M, pA, pB )

	"matrix of integers elementary divisor form and cofactors"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maiedfcf(M,pA,pB)  matrix M,*pA,*pB;
	N = maiedfcf(M,pA,pB);
	M ist eine Matrix ueber den ganzen Zahlen, M != 0.
	N ist die Elementarteilerform von M.
	Es gilt: N = (*pA) * M * (*pB), mit *pA, *pB unimodular.
	N = (
	( d1  0 ..           0 )
	( 0   d2 0 ..        0 )
	( ..                   )
	( 0 ..   0 dr 0 ..   0 )
	( 0 ..   0 0  0 ..   0 )
	( ..                   )
	( 0 ..               0 )
	), wobei di>0 fuer i=1..r und di teilt d(i+1) fuer i=1..r-1.



			maiegsc( M, A, B )

	"matrix of integers Euklid- Gauss- step for columns"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single maiegsc(M,A,B)  matrix M,A,B;
	a = maiegsc(M,A,B);
	M, A und B sind Matrizen ueber den ganzen Zahlen.
	M ist mxn-Matrix, A ist mxm-Matrix, B ist nxn-Matrix.
	Auf M wird ein Euklid-Gauss-Schritt nach E. Lamprecht, Lineare
	Algebra, Lemma 1.1 (fuer Spalten) angewandt.
	M, A und B werden veraendert.
	Ist M(alt) = (
	(a11 a12 .. a1n)
		*
	),
	mit a1i != 0 fuer ein i, so ist M(neu) = (
	( ggT(a11, .. ,a1n) 0 .. 0 )
		  **
	).
	Sind alle a1i = 0, so wird die Zeile niedrigster Nummer, die ein
	Element != 0 enthaelt, mit der ersten Zeile vertauscht und
	maiegsc auf diese Matrix angewandt.
	Sind alle Eintraege von M = 0, so wird nichts veraendert.
	a = 1, falls M nur noch 0-Eintraege enthaelt, 0 sonst.
	Die Zeilenumformungen in M werden auf die Zeilen von A angewandt,
	die Spaltenumformungen in M werden auf die Zeilen von B angewandt.
	maiegsc wird von _maiegs (static-Modul von maiedfcf) aufgerufen, 
	von wo aus der Euklid-Gauss-Algorithmus gesteuert wird. Am Anfang 
	ist A mxm- und B nxn- Matrix. Am Ende gilt: N=A*M*(B)T hat 
	Elementarteilerform.
	Beim rekursiven Anwenden des Algorithmus auf die Untermatrizen
	von M werden bei jedem Aufruf von _maiegs A und B um eine Zeile
	verkleinert uebergeben, da die im naechsten Schritt notwendigen
	Umformungen nur auf diese Zeilen zugreifen.



			maiegsr( M, A, B )

	"matrix of integers Euklid- Gauss- step for rows"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single maiegsr(M,A,B)  matrix M,A,B;
	a = maiegsr(M,A,B);
	M, A und B sind Matrizen ueber den ganzen Zahlen.
	M ist mxn-Matrix, A ist mxm-Matrix, B ist nxn-Matrix.
	Auf M wird ein Euklid-Gauss-Schritt nach E. Lamprecht, Lineare
	Algebra, Lemma 1.1 (fuer Zeilen) angewandt.
	M, A und B werden veraendert.
	Ist M(alt) = (
	(a11     *     )
	 ..
	(am1     *     )
	),
	mit ai1 != 0 fuer ein i, so ist M(neu) = (
	( ggT(a11, .. ,am1)   **   )
	( 0       **               )
	..
	( 0       **               )
	).
	Sind alle ai1 = 0, so wird die Spalte niedrigster Nummer, die ein
	Element != 0 enthaelt, mit der ersten Spalte vertauscht und
	maiegsr auf diese Matrix angewandt.
	Sind alle Eintraege von M = 0, so wird nichts veraendert.
	a = 1, falls M nur noch 0-Eintraege enthaelt, 0 sonst.
	Die Zeilenumformungen in M werden auf die Zeilen von A angewandt,
	die Spaltenumformungen in M werden auf die Zeilen von B angewandt.
	maiegsr wird von _maiegs (static-Modul von maiedfcf) aufgerufen, 
	von wo aus der Euklid-Gauss-Algorithmus gesteuert wird. Am Anfang 
	ist A mxm- und B nxn- Matrix. Am Ende gilt: N=A*M*(B)T hat 
	Elementarteilerform.
	Beim rekursiven Anwenden des Algorithmus auf die Untermatrizen
	von M werden bei jedem Aufruf von _maiegs A und B um eine Zeile
	verkleinert uebergeben, da die im naechsten Schritt notwendigen
	Umformungen nur auf diese Zeilen zugreifen.



			maiev( M )                      (MACRO)

	"matrix of integers eigenvalues"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list maiev( M )  matrix M;
	L = maiev( M );
	Dabei muss gelten:
	      M ist eine Matrix von ganzen Zahlen.
	L = (EW1, av1, ..., EWk, avk) ist die Liste der ganzen
	Eigenwerte EWi der Matrix M mit ihren algebraischen
	Vielfachheiten avi fuer 1 <= i <= k.



			maievifcp( M, pL )

	"matrix of integers eigenvalues and irreducible factors
	 of the characteristic polynomial"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list maievifcp( M, pL )  matrix M; list *pL;
	L = maievifcp( M, pL );
	Dabei muss gelten:
	      - M ist eine Matrix von ganzen Zahlen.
	      - *pL ist die Liste der irreduziblen Faktoren
		des charakteristischen Polynoms.
	L = (EW1, av1, ..., EWk, avk) ist die Liste der ganzen
	Eigenwerte EWi der Matrix M mit ihren algebraischen Vielfach-
	heiten avi fuer 1 <= i <= k. Diese erhaelt man durch Faktor-
	isierung des charakteristischen Polynoms von M. 
	Zusaetzlich werden die irreduziblen Faktoren des charakter-
	istischen Polynoms angegeben:
        *pL = (P1, e1, ..., Pn, en),
        wobei die Pj fuer 1 <= j <= n die irreduziblen Faktoren des
	charakteristischen Polynoms mit ihren Exponenten ej sind.
	Die Nullstellen der Linearfaktoren sind die ganzen Eigenwerte
	EWi.



			maiexp( M, n )

	"matrix of integers exponentiation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maiexp(M,n)  matrix M; single n;
	X = maiexp(M,n);
	M ist eine quadratische Matrix ueber Z.
	Im Falle n<0 muss M invertierbar sein, also Det(M)=+-1.
	X = M^n.



			maiherm( A, ne )

	"matrix of integers Hermite normal form"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maiherm(A,ne)  matrix A; single lt;
	H = maiherm(A,ne);
	A ist eine quadratische nxn-Matrix ueber Z mit det(A) != 0.
	H ist die zu A gehoerende Hermite-Normalform.
	ne ist ein Schalter, der die spezielle Art der Hermite-Normalform
	bestimmt.
	Ist ne = 1, so sind die Eintraege unter der Hauptdiagonalen
		    negativ.
	Ist ne = 0, so sind die Eintraege unter der Hauptdiagonalen
		    positiv.
	siehe auch maihermltne, maihermltpe.



			maihermltne( A )                (MACRO)

	"matrix of integers Hermite normal form
	 ( lower triangular form with negative entries )"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maihermltne(A)  matrix A;
	H = maihermltne(A);
	A ist eine quadratische nxn-Matrix ueber Z mit det(A) != 0.
	H ist die zu A gehoerende Hermite-Normalform in unterer Dreicks-
	form mit negativen Eintraegen unterhalb der Hauptdiagonalen,
	d.h. es existiert eine nxn-Matrix K mit det(K) = +-1,
	A * K = H, und
	hii > 0 fuer i = 1..n,
	hij = 0 fuer i,j = 1..n, i<j,
	hij < 0 fuer i,j = 1..n, i>j,
	|hij| < hii fuer i,j = 1..n, i>j.  (*)
	H hat also den Aufbau (
	(+      0)
	(  +     )
	..
	(-      +)
	), mit Bedingung (*).
	Der Berechnung liegt der "modulare" Algorithmus von
	P.D. Domich, R. Kannan und L.E. Trotter
	(Hermite Normal Form Computation Using Modulo Determinant
	Arithmetic, Mathematics of Operations Research, Vol. 12, No 1,
	Februar 1987)
	zugrunde, der gewaehrleistet, dass im Laufe der Berechnung keine
	"entry explosion", also das Auftreten sehr grosser Zwischenwerte,
	stattfindet. Fuer die auftretenden Zwischenwerte x gilt:
	|x| <= d = |Det (A)|.
	siehe auch maihermltpe.



			maihermltpe( A )                (MACRO)

	"matrix of integers Hermite normal form
	 ( lower triangular form with positive entries )"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maihermltpe(A)  matrix A;
	H = maihermltpe(A);
	A ist eine quadratische nxn-Matrix ueber Z mit det(A) != 0.
	H ist die zu A gehoerende Hermite-Normalform in unterer Dreicks-
	form mit positiven Eintraegen unterhalb der Hauptdiagonalen,
	d.h. es existiert eine nxn-Matrix K mit det(K) = +-1,
	A * K = H, und
	hii > 0 fuer i = 1..n,
	hij = 0 fuer i,j = 1..n, i<j,
	hij > 0 fuer i,j = 1..n, i>j,
	|hij| < hii fuer i,j = 1..n, i>j.  (*)
	H hat also den Aufbau (
	(+      0)
	(  +     )
	..
	(+      +)
	), mit Bedingung (*).
	Der Berechnung liegt der "modulare" Algorithmus von
	P.D. Domich, R. Kannan und L.E. Trotter
	(Hermite Normal Form Computation Using Modulo Determinant
	Arithmetic, Mathematics of Operations Research, Vol. 12, No 1,
	Februar 1987)
	zugrunde, der gewaehrleistet, dass im Laufe der Berechnung keine
	"entry explosion", also das Auftreten sehr grosser Zwischenwerte,
	stattfindet. Fuer die auftretenden Zwischenwerte x gilt:
	|x| <= d = |Det (A)|.
	siehe auch maihermltne.



			maihermspec( M, r, pD )

	"matrix of integers hermitian reduction, special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maihermspec(M,r,pD)  matrix M; single r; int *pD;
	Mred = maihermspec(M,r,pD);
	M ist eine m x r Matrix mit ganzen Zahlen als Eintraegen und
	m >= r. Der Rang von M ist ebenfalls gleich r.
	Mred ist eine r x r obere Dreiecksmatrix, deren Zeilen eine
	Z - Basis des durch die Zeilen von M erzeugten Z - Moduls bilden.
	Mred ist in Hermite - Normalform, d.h. alle Eintraege sind
	positiv und die Elemente einer Spalte sind kleiner als das oder
	gleich dem Hauptdiagonalelement dieser Spalte.
	*pD ist der Wert der Determinante von Mred.



			maiinv( M )

	"matrix of integers inverse"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maiinv(M) matrix M;
	N = maiinv(M);
	M ist eine quadratische, invertierbare Matrix von ganzen Zahlen,
	!! also Det(M) == +/- 1 ( da +/- 1 einzige Einheiten in Z ) !!
	N = M ^ -1.



			maineg( M )                     (MACRO)

	"matrix of integers negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maineg(M) matrix M;
	N = maineg(M);
	N = -M.



			maiprod( M, N )                 (MACRO)

	"matrix of integers product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maiprod(M,N) matrix M,N;
	L = maiprod(M,N);
	M ist eine mxn-Matrix, N ist eine nxl-Matrix mit l,m,n >= 1.
	L = M * N.



			maismul( M, el )

	"matrix of integers scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maismul( M, el )  matrix M; int el;
	N = maismul( M, el );
	M ist eine Matrix ueber Z.
	Berechnet wird das Skalarprodukt el * M.



			maisum( M, N )                  (MACRO)

	"matrix of integers sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maisum(M,N) matrix M,N;
	L = maisum(M,N);
	M und N sind Matrizen von ganzen Zahlen gleicher Dimension.
	L = M + N.



			maitomagfs( p, M )

	"matrix over integers to matrix over Galois-field with single 
	 characteristic" 
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix maitomagfs(p,M)  single p; matrix M;
	N = maitomagfs(p,M);
	Dabei ist M eine Matrix ueber Z. p ist eine Primzahl.
	N ist die Matrix M dargestellt als Matrix ueber dem endlichen
	Koerper GF(p^n). 



			maitomami( m, M )

	"matrix of integers to matrix of modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maitomami(m,M)  int m; matrix M;
	L = maitomami(m,M);
	m ist positiv.
	Die Matrix M von ganzen Zahlen wird in die Matrix L von
	Zahlen aus Z/mZ umgewandelt, d.h. jeder Eintrag in M wird
	modulo m reduziert.



			maitomams( m, M )

	"matrix of integers to matrix of modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maitomams(m,M) single m; matrix M;
	L = maitomams(m,M);
	Die Matrix M von ganzen Zahlen  wird in die Matrix L von
	Zahlen aus Z/mZ umgewandelt, dabei ist 0 < m < BASIS.



			maitomanf( M )

	"matrix of integers to matrix of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maitomanf(M)  matrix M;
	L = maitomanf(M);
	Dabei muss gelten:
	      - M ist eine Matrix von ganzen Zahlen.
	M wird in die Matrix L von Elementen eines Zahlkoerpers umgewan-
	delt, in dense-Darstellung.
	( siehe auch: itonf )



			maitomanfs( M )

	"matrix of integers to matrix of number field elements, sparse
	 representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maitomanfs(M)  matrix M;
	L = maitomanfs(M);
	Dabei muss gelten:
	      - M ist eine Matrix von ganzen Zahlen.
	M wird in die Matrix L von Elementen eines Zahlkoerpers, in sparse-
	Darstellung, umgewandelt.
	( siehe auch: itonfs )



			maitomapi( r, M )

	"matrix of integers to matrix of polynomials over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maitomapi(r,M) single r; matrix M;
	L = maitomapi(r,M);
	Die Matrix von ganzen Zahlen M wird in die Matrix von
	Polynomen in r Variablen ueber den ganzen Zahlen L umgewandelt.



			maitomar( M )

	"matrix of integers to matrix of rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maitomar(M) matrix M;
	L = maitomar(M);
	Die Matrix von ganzen Zahlen M wird in die Matrix von
	rationalen Zahlen L umgewandelt.



			maitrace( M )

	"matrix of integers trace"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	int maitrace(M)  matrix M;
	S = maitrace(M);
	M ist eine quadratische Matrix von ganzen Zahlen.
	S ist die Spur von M.



			maivecmul( A, x )               (MACRO)

	"matrix of integers vector multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec maivecmul (A, x) matrix A; vec x;
	y = maivecmul (A, x)
	A ist eine mxn -Matrix ueber Z.
	x ist ein Vektor der Laenge n mit Elementen aus Z.
	y = A * x ist ein Vektor der Laenge m.



			mamichpol( m, M )               (MACRO)

	"matrix of modular integers characteristic polynomial"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol mamichpol(m,M)  int m; matrix M;
	p = mamichpol(m,M);
	M ist eine quadratische Matrix ueber Z/mZ (m>0).
	p ist das charakteristische Polynom von M, also
	p(X) = det( M - X * E ), E Einheitsmatrix.
	p ist ein Polynom in einer Variablen ueber Z/mZ.



			mamicons1( m, n )               (MACRO)

	"matrix of modular integers construction 1"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamicons1(m,n)  int m; single n;
	E = mamicons1(m,n);
	m und n sind positiv.
	E ist die n-dimensionale Einheitsmatrix ueber Z/mZ, d.h.
	E = ( dij ) i,j = 1..n mit dij = 1, falls i=j, 0 sonst.



			mamidet( m, M )

	"matrix of modular integers determinant"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	int mamidet(m,M)  int m; matrix M;
	D = mamidet(m,M);
	M ist eine quadratische Matrix ueber Z/mZ (m>0).
	D ist die Determinante von M.



			mamidif( m, M, N )              (MACRO)

	"matrix of modular integers difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamidif(m,M,N)  int m; matrix M, N;
	L = mamidif(m,M,N);
	M und N sind Matrizen gleicher Dimension ueber Z/mZ (m>0).
	L = M - N.



			mamiev( p, M )                  (MACRO)

	"matrix of modular integers eigenvalues"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list mamiev( p, M )  int p; matrix M;
	L = mamiev( p, M );
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - M ist eine quadratische Matrix ueber Z/pZ.
	L = (EW1, ..., EWk) mit EWi aus Z/pZ ist die Liste der Eigenwerte 
	der Matrix M (ihrer algebraischen Vielfachheit entsprechend oft
	auftretend). 



			mamievifcp( p, M, pL )

	"matrix of modular integers eigenvalues and irreducible
	 factors of the characteristic polynomial"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list mamievifcp( p, M, pL )  int p; matrix M; list *pL;
	L = mamievifcp( p, M, pL );
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - M ist eine quadratische Matrix ueber Z/pZ.
	L = (EW1, ..., EWk) mit EWi aus Z/pZ ist die Liste der Eigenwerte 
	der Matrix M ( ihrer algebraischen Vielfachheit entsprechend oft 
	auftretend ). Diese erhaelt man durch Faktorisierung des 
	charakteristischen Polynoms von M.
        *pL = (P1, ..., Pn),
	wobei die Pj fuer 1 <= j <= n die irreduziblen Faktoren des
	charakteristischen Polynoms ( ihrer Vielfachheit entsprech-
	end oft auftretend ) sind.
	(Die Nullstellen der Linearfaktoren sind die Eigenwerte von M.)



			mamiexp( m, M, n )

	"matrix of modular integers exponentiation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamiexp(m,M,n)  int m; matrix M; single n;
	X = mamiexp(m,M,n);
	Dabei muss gelten:
	      - m > 0.
	      - M ist eine quadratische Matrix ueber dem Restklassen-
		ring Z/mZ.
	X = M^n .
	Im Falle n < 0 muss M invertierbar sein, also:
	!! Det(M) ist eine Einheit in Z/mZ fuer n < 0 !!



			mamiinv( m, M )

	"matrix of modular integers inverse"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamiinv(m,M)  int m; matrix M;
	N = mamiinv(m,M);
	M ist eine quadratische, invertierbare Matrix ueber Z/mZ (m>0),
	!! also Det(M) ist eine Einheit in Z/mZ !!
	N = M ^ -1.



			mamineg( m, M )                 (MACRO)

	"matrix of modular integers negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamineg(m,M)  int m; matrix M;
	N = mamineg(m,M);
	M ist eine Matrix ueber Z/mZ (m>0).
	N = -M.



			maminsb( P, M )

	"matrix of modular integers, null space basis"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	list maminsb(P,M)  int P; matrix M;
	L = maminsb(P,M);
	P ist eine Primzahl.
	M ist eine (n,n) - Matrix mit Komponenten aus Z / P*Z, wobei
	n eine positive single ist.
	L = (L1,...,Lr) ist eine Liste von Vektoren, die eine Basis des
	Nullraums von M bilden, also M * Li = 0 fuer alle i = 1,...,r.
	Jeder Vektor Li ist eine Liste der Laenge n.
!!!     Die Matrix M wird veraendert.



			mamiprod( m, M, N )             (MACRO)

	"matrix of modular integers product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamiprod(m,M,N)  int m; matrix M,N;
	L = mamiprod(m,M,N);
	M und N sind Matrizen ueber Z/mZ (m>0).
	M ist eine rxs-Matrix, N ist eine sxt-Matrix mit r,s,t >= 1.
	L = M * N.



			mamismul( m, M, el )

	"matrix of modular integers scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamismul( m, M, el )  int m; matrix M; int el;
	N = mamismul( m, M, el );
	m ist positiv.
	M ist eine Matrix ueber Z/mZ und el aus Z/mZ. Berechnet
	wird das Skalarprodukt el * M.



			mamisum( m, M, N )              (MACRO)

	"matrix of modular integers sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamisum(m,M,N)  int m; matrix M,N;
	L = mamisum(m,M,N);
	M und N sind Matrizen gleicher Dimension ueber Z/mZ (m>0).
	L = M + N.



			mamivecmul( m, A, x )           (MACRO)

	"matrix of modular integers vector multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec mamivecmul (m, A, x)  int m; matrix A; vec x;
	y = mamivecmul (m, A, x);
	A ist eine rxs - Matrix ueber Z/mZ (m>0).
	x ist ein Vektor der Laenge s mit Elementen aus Z/mZ.
	y = A * x ist ein Vektor der Laenge r.



			mamschpol( m, M )               (MACRO)

	"matrix of modular singles characteristic polynomial"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol mamschpol(m,M)  single m; matrix M;
	p = mamschpol(m,M);
	M ist eine quadratische Matrix ueber Z/mZ (m>0).
	p ist das charakteristische Polynom von M, also
	p(X) = det( M - X * E ), E Einheitsmatrix.
	p ist ein Polynom in einer Variablen ueber Z/mZ.



			mamscons1( m, n )               (MACRO)

	"matrix of modular singles construction 1"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamscons1(m,n)  single m,n;
	E = mamscons1(m,n);
	m und n sind positiv.
	E ist die n-dimensionale Einheitsmatrix ueber Z/mZ, d.h.:
	E = ( dij ) i,j = 1..n mit dij = 1, falls i=j, 0 sonst.



			mamsdet( m, M )

	"matrix of modular singles determinant"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single mamsdet(m,M)  single m; matrix M;
	D = mamsdet(m,M);
	M ist eine quadratische Matrix ueber Z/mZ (m>0).
	D ist die Determinante von M.



			mamsdif( m, M, N )              (MACRO)

	"matrix of modular singles difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamsdif(m,M,N)  single m; matrix M, N;
	L = mamsdif(m,M,N);
	M und N sind gleicher Dimension ueber Z/mZ (m>0).
	L = M - N.



			mamsev( p, M )                  (MACRO)

	"matrix of modular singles eigenvalues"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list mamsev( p, M )  single p; matrix M;
	L = mamsev( p, M );
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - M ist eine quadratische Matrix ueber Z/pZ.
	L = (EW1, ..., EWk) mit EWi aus Z/pZ ist die Liste der Eigenwerte 
	der Matrix M (ihrer algebraischen Vielfachheit entsprechend oft 
	auftretend). 



			mamsevifcp( p, M, pL )

	"matrix of modular singles eigenvalues and irreducible
	 factors of the characteristic polynomial"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list mamsevifcp( p, M, pL )  single p; matrix M; list *pL;
	L = mamsevifcp( p, M, pL );
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - M ist eine quadratische Matrix ueber Z/pZ.
	L = (EW1, ..., EWk) mit EWi aus Z/pZ ist die Liste der Eigenwerte 
	der Matrix M ( ihrer algebraischen Vielfachheit entsprechend oft 
	auftretend ). Diese erhaelt man durch Faktorisierung des 
	charakteristischen Polynoms von M.
        *pL = (P1, ..., Pn),
	wobei die Pj fuer 1 <= j <= n die irreduziblen Faktoren des
	charakteristischen Polynoms ( ihrer Vielfachheit entsprech-
	end oft auftretend ) sind.
	(Die Nullstellen der Linearfaktoren sind die Eigenwerte von M.)



			mamsexp( m, M, n )

	"matrix of modular singles exponentiation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamsexp(m,M,n)  single m; matrix M; single n;
	X = mamsexp(m,M,n);
	Dabei muss gelten:
	      - m > 0.
	      - M ist eine quadratische Matrix ueber dem Restklassen-
		ring Z/mZ.
	X = M^n .
	Im Falle n < 0 muss M invertierbar sein, also:
	!! Det(M) ist eine Einheit in Z/mZ fuer n < 0 !!



			mamsinv( m, M )

	"matrix of modular singles inverse"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamsinv(m,M)  single m; matrix M;
	N = mamsinv(m,M);
	M ist eine quadratische, invertierbare Matrix ueber Z/mZ (m>0),
	!! also Det(M) ist eine Einheit in Z/mZ !!
	N = M ^ -1.



			mamsneg( m, M )                 (MACRO)

	"matrix of modular singles negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamsneg(m,M)  single m; matrix M;
	N = mamsneg(m,M);
	M ist eine Matrix ueber Z/mZ (m>0).
	N = -M.



			mamsnsb( p, A )                 (MACRO)

	"matrix of modular singles null space basis"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	list mamsnsb (p,A)  single p; matrix A;
        N = mamsnsb (p,A);
        p ist Primzahl < BASIS.
        A ist eine mxn-Matrix ueber Z/pZ ; 0 < m,n < BASIS.
        N ist eine Liste von Vektoren, die eine Basis des Nullraums
	von A bilden.
!!!	Die Matrix A wird veraendert.



			mamsprod( m, M, N )             (MACRO)

	"matrix of modular singles product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamsprod(m,M,N)  single m; matrix M,N;
	L = mamsprod(m,M,N);
	M und N sind Matrizen ueber Z/mZ (m>0).
	M ist eine rxs-Matrix, N ist eine sxt-Matrix mit r,s,t >= 1.
	L = M * N.



			mamssmul( m, M, el )

	"matrix of modular singles scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamssmul( m, M, el )  single m; matrix M; int el;
	N = mamssmul( m, M, el );
	m ist positiv.
	M ist eine Matrix ueber Z/mZ und el aus Z/mZ. Berechnet
	wird das Skalarprodukt el * M.



			mamsssle( p, A, b, pX, pN )

	"matrix of modular singles solution of a system of linear
	equations"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single mamsssle(p, A, b, pX, pN)  single p; matrix A; vec b, *pX; 
		list *pN;
	z = mamsssle(p, A, b, pX, pN);
	Dabei muss gelten:
	      - p ist Primzahl.
	      - A ist eine mxn-Matrix ueber Z/pZ.
	      - b ist ein Vektor der Laenge m ueber Z/pZ.
	Geloest wird das Gleichungssytem (*) A * x = b.
	Ist (*) eindeutig loesbar, so ist z = 0, *pX ist der Loesungsvektor,
	und *pN ist die leere Liste.
	Ist (*) unloesbar, so ist z = -1, *pX und *pN sind die leere Liste.
	Ist (*) nicht eindeutig loesbar, so ist *pX eine spezielle Loesung,
	z ist die Dimension des Nullraums von A, und *pN ist eine Liste 
	der Nullraum-Basis-Vektoren.
!!!	Die Matrix A wird veraendert.



			mamssum( m, M, N )              (MACRO)

	"matrix of modular singles sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mamssum(m,M,N)  single m; matrix M,N;
	L = mamssum(m,M,N);
	M und N sind Matrizen gleicher Dimension ueber Z/mZ (m>0).
	L = M + N.



			mamsvecmul( m, A, x )           (MACRO)

	"matrix of modular singles vector multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec mamsvecmul (m, A, x)  single m; matrix A; vec x;
	y = mamsvecmul (m, A, x)
	A ist eine rxs - Matrix ueber Z/mZ (m>0).
	x ist ein Vektor der Laenge s mit Elementen aus Z/mZ.
	y = A * x ist ein Vektor der Laenge r.



			maneg( M, neg, anzahlargs, arg1, arg2 )

	"matrix negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maneg(M,neg,anzahlargs,arg1,arg2)
	       matrix M; obj (*neg)(); single anzahlargs; obj arg1,arg2;
	N = maneg(M,neg,anzahlargs,arg1,arg2);
	M ist eine mxn - Matrix ueber einem Ring R.
	neg ist die Negations - Funktion des Ringes R.
	neg benoetigt ausser einem Element aus R noch anzahlargs Argumente;
	arg1 und arg2 (maximal) sind diese Argumente.
	typischer Aufruf: N = maneg( M, pineg, 1, 2 );
	(Negation einer Matrix ueber dem Polynomring in 2 Variablen)
	siehe auch: maineg, marneg, mamsneg, ...



			manegspec( M, neg, anzahlargs, arg1, ..., arg5 )

	"matrix negation special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix manegspec(M,neg,anzahlargs,arg1,...,arg5)
	       matrix M; obj (*neg)(); single anzahlargs;
	       obj arg1,...,arg5;
	N = manegspec(M,neg,anzahlargs,arg1,...,arg5);
	Dabei muss gelten:
	      - M ist eine mxn - Matrix ueber einem Ring R.
	      - neg ist die Negations - Funktion des Ringes R.
	      - neg benoetigt ausser einem Element aus R noch anzahlargs
		Argumente; arg1, ..., arg5 (maximal) sind diese Argumente.
	N = -M.
	siehe auch: mapgfsneg



			manfchpol( F, M )               (MACRO)

	"matrix of number field elements characteristic polynomial"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	pol manfchpol(F,M)  pol F; matrix M;
	chp = manfchpol(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische Matrix von Elementen aus k.
	chp ist das charakteristische Polynom von M:
	chp(X) = det( M - X * E ), E Einheitsmatrix.
	chp ist ein Polynom in einer Variablen ueber k.



			manfcons1( F, n )               (MACRO)

	"matrix of number field elements construction 1"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfcons1(F,n)  single n;
	E = manfcons1(F,n);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - 1 <= n < BASIS.
	E ist die n-dimensionale Einheitsmatrix.
	E = ( Dij ) i,j = 1, ..., n mit Dij = 1, falls i = j, 0 sonst.
	Dij sind Elemente aus k.



			manfdet( F, M )

	"matrix of number field elements determinant"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	nfel manfdet(F,M)  pol F; matrix M;
	P = manfdet(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische Matrix von Elementen aus k.
	P ist die Determinante von M, also ein Element aus k.



			manfdif( F, M, N )              (MACRO)

	"matrix of number field elements difference"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfdif(F,M,N)  pol F; matrix M,N;
	L = manfdif(F,M,N);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M und N sind Matrizen gleicher Dimension von Elementen
		aus k.
	L = M - N.



			manfexp( F, M, n )

	"matrix of number field elements exponentiation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfexp(F,M,n)  pol F; matrix M; single n;
	X = manfexp(F,M,n);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische Matrix ueber k.
	      - -BASIS+1 <= n <= BASIS-1.
	X = M^n.
	Im Falle n < 0, muss M invertierbar sein,
	!! also Det(M) != 0 !!



			manfinv( F, M )

	"matrix of number field elements inverse"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfinv(F,M)  pol F; matrix M;
	N = manfinv(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische, invertierbare Matrix ueber K,
		!!! also Det(M) != 0 !!!
	N = M^-1.



			manfneg( F, M )                 (MACRO)

	"matrix of number field elements negation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfneg(F,M)  pol F; matrix M;
	N = manfneg(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine Matrix von Elementen aus k.
	N = -M.



			manfnsb( F, M )

	"matrix of number field elements null space basis"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list manfnsb(F,M)  pol F; matrix M;
	L = manfnsb(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine (n,n) - Matrix mit Komponenten aus k,
		1 <= n < BASIS.
	L = ( L1, ..., Lr ) ist eine Liste von Vektoren, die eine Basis
	des Nullraums von M bilden, also M * Li = 0 fuer alle
	i = 1, ..., r. Jeder Vektor Li ist eine Liste der Laenge n.
!!!     Die Matrix M wird veraendert.



			manfprod( F, M, N )             (MACRO)

	"matrix of number field elements product"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
        matrix manfprod(F,M,N)  pol F; matrix M,N;
	L = manfprod(F,M,N);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine mxn-Matrix, 
	      - N ist eine nxl-Matrix mit l,m,n >= 1 und Elementen aus k.
	L = M * N, ist eine mxl-Matrix.



			manfrk( F, M )

	"matrix of number field elements rank"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single manfrk(F,M)  pol F; matrix M;
	r = manfrk(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine beliebige Matrix ueber k.
	Mit Hilfe des Gausschen Algorithmus wird der Rang von M berechnet.



			manfscons1( F, n )              (MACRO)

	"matrix of number field elements, sparse representation,
	 construction 1"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfscons1(F,n)  pol F; single n;
	E = manfscons1(F,n);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - 1 <= n < BASIS.
	E ist die n-dimensionale Einheitsmatrix.
	E = ( Dij ) i,j = 1, ..., n mit Dij = 1, falls i = j, 0 sonst.
	Dij sind Elemente aus k.



			manfsdet( F, M )

	"matrix of number field elements, sparse representation,
	 determinant"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	nfel manfsdet(F,M)  pol F; matrix M;
	P = manfsdet(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische Matrix von Elementen aus k.
	P ist die Determinante von M, also ein Element aus k.



			manfsdif( F, M, N )             (MACRO)

	"matrix of number field elements, sparse representation,
	 difference"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfsdif(F,M,N)  pol F; matrix M,N;
	L = manfsdif(F,M,N);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M und N sind Matrizen gleicher Dimension von Elementen 
	        aus k.
	L = M - N.



			manfsexp( F, M, n )

	"matrix of number field elements, sparse representation,
	 exponentiation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfsexp(F,M,n)  pol F; matrix M; single n;
	X = manfsexp(F,M,n);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische Matrix ueber k.
	      - -BASIS+1 <= n <= BASIS-1.
	X = M^n.
	Im Falle n < 0, muss M invertierbar sein,
	!!! also Det(M) != 0 !!!



			manfsinv( F, M )

	"matrix of number field elements, sparse representation, inverse"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfsinv(F,M)  pol F; matrix M;
	N = manfsinv(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische, invertierbare Matrix ueber k,
	        !!! also Det(M) != 0 !!!
	N = M^-1.



			manfsmul( F, M, el )

	"matrix of number field elements scalar multiplication"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfsmul(F,M,el)  pol F; matrix M; nfel el;
	N = manfsmul(F,M,el);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine mxn-Matrix mit m,n >= 1 und Elementen aus k.
	      - el ist ein Element aus k.
	N = el * M ist eine mxn-Matrix.



			manfsneg( F, M )                (MACRO)

	"matrix of number field elements, sparse representation, negation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfsneg(F,M)  pol F; matrix M;
	N = manfsneg(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine Matrix von Elementen aus k.
	N = -M.



			manfsnsb( F, M )

	"matrix of number field elements, sparse representation, null space
	 basis"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list manfsnsb(F,M)  pol F; matrix M;
	L = manfsnsb(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine (n,n) - Matrix mit Komponenten aus k,
		1 <= n < Basis.
	L = (L1,...,Lr) ist eine Liste von Vektoren, die eine Basis des
	Nullraums von M bilden, also M * Li = 0 fuer alle
	i = 1, ..., r. Jeder Vektor Li ist eine Liste der Laenge n.
!!!     Die Matrix M wird veraendert.



			manfsprod( F, M, N )            (MACRO)

	"matrix of number field elements, sparse representation, product"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfsprod(F,M,N)  pol F; matrix M,N;
	L = manfsprod(F,M,N);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine mxn-Matrix,
	      - N ist eine nxl-Matrix mit l,m,n >= 1 und Elementen aus k.
	L = M * N ist eine mxl-Matrix.



			manfsrk( F, M )

	"matrix of number field elements, sparse representation, rank"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single manfsrk(F,M)  pol F; matrix M;
	r = manfsrk(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine beliebige Matrix ueber k.
	Mit Hilfe des Algorithmus von Gauss wird der Rang von M berechnet.



			manfssle( F, A, b, pX, pN )

	"matrix of number field elements solution of a system of linear
	 equations"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single manfssle(F,A,b,pX,pN) pol F; matrix A; vec b, *pX; list *pN;
	z = manfssle(F,A,b,pX,pN);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - A ist eine mxn-Matrix ueber k. Mindestens ein Eintrag von A
		muss != 0 sein.
	      - b ist ein Vektor der Laenge m ueber k.
	Geloest wird das Gleichungssytem (*) A * x = b.
	Ist (*) eindeutig loesbar, so ist z=0, *pX ist der Loesungsvektor,
	und *pN ist die leere Liste.
	Ist (*) unloesbar, so ist z = -1, *pX und *pN sind die leere Liste.
	Ist (*) mehrdeutig loesbar, so ist *pX eine spezielle Loesung,
	z ist die Dimension des Nullraums von A, und *pN ist eine Liste 
	der Nullraum-Basis-Vektoren.



			manfssmul( F, M, el )

	"matrix of number field elements, sparse representation, scalar
	 multiplication"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfssmul(F,M,el)  pol F; matrix M; nfel el;
	N = manfssmul(F,M,el);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine mxn-Matrix mit m,n >= 1 und Elementen aus k.
	      - el ist ein Element aus k.
	N = el * M ist eine mxn-Matrix.



			manfsssle( F, A, b, pX, pN )

	"matrix of number field elements, sparse representation, solution
	 of a system of linear equations"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single manfsssle(F,A,b,pX,pN) pol F; matrix A; vec b,*pX; list *pN;
	z = manfsssle(F,A,b,pX,pN);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - A ist eine mxn-Matrix ueber k. Mindestens ein Eintrag von A
		muss != 0 sein.
	      - b ist ein Vektor der Laenge m ueber k.
	Geloest wird das Gleichungssytem (*) A * x = b.
	Ist (*) eindeutig loesbar, so ist z=0, *pX ist der Loesungsvektor,
	und *pN ist die leere Liste.
	Ist (*) unloesbar, so ist z = -1, *pX und *pN sind die leere Liste.
	Ist (*) mehrdeutig loesbar, so ist *pX eine spezielle Loesung,
	z ist die Dimension des Nullraums von A, und *pN ist eine Liste 
	der Nullraum-Basis-Vektoren.



			manfssum( F, M, N )             (MACRO)

	"matrix of number field elements, sparse representation, sum"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfssum(F,M,N)  pol F; matrix M,N;
	L = manfssum(F,M,N);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M und N sind Matrizen gleicher Dimension von Elementen
		aus k.
	L = M + N.



			manfsum( F, M, N )              (MACRO)

	"matrix of number field elements sum"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfsum(F,M,N)  pol F; matrix M,N;
	L = manfsum(F,M,N);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M und N sind Matrizen gleicher Dimension von Elementen
		aus k.
	L = M + N.



			manfsvecmul( F, A, x )          (MACRO)

	"matrix of number field elements, sparse representation, vector
	 multiplication"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfsvecmul(F,A,x)  pol F; matrix A; vec x;
	y = manfsvecmul(F,A,x);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - A ist eine mxn-Matrix mit m,n >= 1 und Elementen aus k.
	      - x ist ein Vektor der Laenge n mit Elementen aus k.
	y = A * x ist ein Vektor der Laenge m.



			manftomudpr( F, M )

	"matrix of number field elements to matrix of univariate dense
	 polynomials over rationals"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manftomudpr(F,M)  pol F; matrix M;
	L = manftomudpr(F,M);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine beliebige Matrix ueber k.
	Die Matrix M von Elementen aus k wird in die Matrix L von Polynomen
	in einer Variablen ueber Q, in dense-Darstellung, umgewandelt.
	( siehe auch: nfeltoudpr )



			manfvecmul( F, A, x )           (MACRO)

	"matrix of number field elements vector multiplication"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix manfvecmul(F,A,x)  pol F; matrix A; vec x;
	y = manfvecmul(F,A,x);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - A ist eine mxn-Matrix mit m,n >= 1 und Elementen aus k.
	      - x ist ein Vektor der Laenge n mit Elementen aus k.
	y = A * x ist ein Vektor der Laenge m.



			manrcol( M )                    (MACRO)

	"matrix number of columns"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single manrcol(M) matrix M;
	a = manrcol(M);
	M ist eine Matrix ueber einem beliebigen Grundring.
	Falls M eine mxn-Matrix, so ist a = n, also die Anzahl der Spalten.



			manrrow( M )                    (MACRO)

	"matrix number of rows"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single manrrow(M) matrix M;
	a = manrrow(M);
	M ist eine Matrix ueber einem beliebigen Grundring.
	Falls M eine mxn-Matrix, so ist a = m, also die Anzahl der Zeilen.



			mapgfschpol( r, p, AL, M )      (MACRO)

	"matrix of polynomials over Galois-field with single characteristic
	 characteristic polynomial"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	pol mapgfschpol(r,p,AL,M)  single r,p; list AL; matrix M;
	chp = mapgfschpol(r,p,AL,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine quadratische Matrix von Polynomen in r Variablen
		ueber GF(p^n).
	chp ist das charakteristische Polynom von M:
	chp(X) = det( M - X * E ), E Einheitsmatrix.
	chp ist ein Polynom in r + 1 Variablen ueber GF(p^n).



			mapgfscons1( r, p, AL, n )      (MACRO)

	"matrix of polynomials over Galois-field with single characteristic
	 construction 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfscons1(r,p,AL,n)  single r,p; list AL; single n;
	E = mapgfscons1(r,p,AL,n);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - 1 <= n < BASIS.
	E ist die n-dimensionale Einheitsmatrix.
	E = ( Dij ) i,j = 1, ..., n mit Dij = 1, falls i = j, 0 sonst.
	Dij sind Elemente aus GF(p^n)[X].



			mapgfsdet( r, p, AL, M )

        "matrix of polynomials over Galois-field with single characteristic 
	 determinant"
        Quellbibliothek: srclib.matr3
        Include-Datei:   _matr3.h
	pol mapgfsdet(r,p,AL,M)  single r,p; list AL; matrix M;
        P = mapgfsdet(r,p,AL,M);
        M ist eine quadratische Matrix von Polynomen in r (0<=r<BASIS)
        Variablen ueber dem endlichen Koerper GF(q) der Charakteristik
        p < BASIS, wobei AL = (G,AL1) die Arithmetikliste zu GF(q) ist.
        P ist die Determinante von M, also ein Polynom in r Variablen.



			mapgfsdif( r, p, AL, M, N )     (MACRO)

	"matrix of polynomials over Galois-field with single characteristic
	 difference"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfsdif(r,p,AL,M,N)  single r,p; list AL; matrix M,N;
	L = mapgfsdif(r,p,AL,M,N);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M und N sind Matrizen gleicher Dimension von Polynomen in
		r Variablen ueber GF(p^n).
	L = M - N.



			mapgfsefe( r, p, ALm, M, g )

	"matrix over polynomials over Galois-field with single 
	characteristic embedding in field extension"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfsefe(r,p,ALm,M,g)  single r,p; list ALm; 
		matrix M; gfel g;
	N = mapgfsefe( r,p,ALm,M,g );
	Es wird die Matrix M von Polynomen ueber GF(p^n) dargestellt 
	als Matrix von Polynomen ueber einer Koerpererweiterung 
	GF(p^m) (p Primzahl, 1<n,m<BASIS, n teilt echt m), deren 
	Arithmetikliste mittels gfsalgenies erzeugt wurde. 
	Die Liste ALm entspricht der Arithmetikliste von GF(p^m), wie 
	sie einer Ausgabe von gfsalgen entspricht, g als Polynom in 
	einer Unbestimmten entspricht dem Bild des separablen 
	Erzeugers von GF(p^n) ueber GF(p) unter der von gfsalgenies 
	gefundenen isomorphen Einbettung von GF(p^n) in GF(p^m).
	(vgl. gfsalgen, gfsalgenies)
	r ist die Anzahl der Variablen der Eintraege von M.
	N ist die Darstellung von M als Matrix von Polynomen ueber 
	GF(p^m).
!!!     HINWEIS: g ist vom Typ "gfel", d.h. ein sparse-Polynom in einer
		 Unbestimmten mit Koeffizienten aus Z/pZ.



			mapgfsexp( r, p, AL, M, n )

	"matrix of polynomials over Galois-field with single characteristic
	 exponentiation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfsexp(r,p,AL,M,n)  single r,p; list AL; matrix M;
		single n;
	X = mapgfsexp(r,p,AL,M,n);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine quadratische Matrix von Polynomen ueber GF(p^m).
	      - -BASIS+1 <= n <= BASIS-1.
	X = M^n.
	Im Falle n < 0, muss M invertierbar sein,
	!!! also Det(M) ist aus GF(p^n) !!!



			mapgfsinv( r, p, AL, M )

	"matrix of polynomials over Galois-field with single characteristic
	 inverse"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfsinv(r,p,AL,M)  single r,p; list AL; matrix M;
	N = mapgfsinv(r,p,AL,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine quadratische, invertierbare Matrix ueber dem
		Polynomring ueber GF(p^n),
		!!! also Det(M) ist aus GF(p^n) !!!
	N = M ^ -1.



			mapgfsneg( r, p, AL, M )        (MACRO)

	"matrix of polynomials over Galois-field with single characteristic
	 negation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfsneg(r,p,AL,M)  single r,p; list AL; matrix M;
	N = mapgfsneg(r,p,AL,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine Matrix von Polynomen in r Variablen ueber
		GF(p^n).
	N = -M.



			mapgfsprod( r, p, AL, M, N )    (MACRO)

	"matrix of polynomials over Galois-field with single characteristic
	 product"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfsprod(r,p,AL,M,N)  single r,p; list AL; matrix M,N;
	L = mapgfsprod(r,p,AL,M,N);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine mxn-Matrix,
	      - N ist eine nxl-Matrix mit l,m,n >= 1 und von Polynomen in
		r Variablen ueber GF(p^n).
	L = M * N ist eine mxl-Matrix.



			mapgfssmul( r, p, AL, M, el )

	"matrix of polynomials over Galois-field with single characteristic
	 scalar multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfssmul(r,p,AL,M,el)  single r,p; list AL; matrix M;
		pol el;
	N = mapgfssmul(r,p,AL,M,el);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine mxn-Matrix mit m,n >= 1 von Polynomen in r
		Variablen ueber GF(p^n).
	      - el ist ein Polynom ueber GF(p^n).
	N = el * M ist eine mxn-Matrix.



			mapgfssum( r, p, AL, M, N )     (MACRO)

	"matrix of polynomials over Galois-field with single characteristic
	 sum"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfssum(r,p,AL,M,N)  single r,p; list AL; matrix M,N;
	L = mapgfssum(r,p,AL,M,N);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M und N sind Matrizen gleicher Dimension von Polynomen in r
		Variablen ueber GF(p^n).
	L = M + N.



			mapgfstransf( r1, p, AL, M1, V1, r2, P2, V2, Vn, pV3 )

	"matrix of polynomials over Galois-field with single 
	 characteristic transformation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfstransf(r1,p,AL,M1,V1,r2,P2,V2,Vn,pV3)
		single r1,p; list AL; matrix M1; list V1; single r2; 
		pol P2; list V2,Vn,*pV3;
	M3 = mapgfstransf(r1,p,AL,M1,V1,r2,P2,V2,Vn,pV3);
	Dabei muss gelten:
	      - r1 >= 1.
	      - p ist Primzahl > 2.
	      - AL = ( G, AL1 ) kann als Arithmetikliste fuer GF(p^n)
		interpretiert werden.
	      - M1 ist eine Matrix von Polynomen in r1 Variablen ueber 
		dem endlichen Koerper GF(p^n).
	      - V1 ist die zur Matrix M1 gehoerige Variablenliste.
	      - r2 >= 0.
	      - P2 ist ein Polynom in r2 Variablen ueber GF(p^n).
	      - V2 ist die zum Polynom P2 gehoerige Variablenliste.
	      - Vn ist eine Liste, die einen in V1 auftretenden 
		Variablennamen repraesentiert.
	      - In *pV3 ist die Vereinigung der Variablenlisten V1 und 
		V2 abgelegt und alphabetisch sortiert.
	M3 ist die Matrix, die entsteht, wenn in M1 die Variable Vn 
	durch das Polynom P2 ersetzt wird, und *pV3 ist die zur Matrix 
	M3 gehoerige Variablenliste.



			mapgfsvmul( r, p, AL, A, x )    (MACRO)

	"matrix of polynomials over Galois-field with single characteristic
	 vector multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapgfsvmul(r,p,AL,A,x)  single r,p; list AL; matrix A;
		vec x;
	y = mapgfsvmul(r,p,AL,A,x);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - A ist eine mxn-Matrix mit m,n >= 1 und von Polynomen in r
		Variablen ueber GF(p^n).
	      - x ist ein Vektor der Laenge n von Polynomen in r Variablen
		ueber GF(p^n).
	y = A * x ist ein Vektor der Laenge m.



			mapichpol( r, M )               (MACRO)

	"matrix of polynomials over integers characteristic polynomial"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol maichpol(r,M) single r; matrix M;
	p = maichpol(r,M);
	M ist eine Matrix von Polynomen in r (0<=r<BASIS) Variablen
	X1,..,Xr ueber den ganzen Zahlen.
	p ist das charakteristische Polynom von M:
	p(X) = det( M - X * E ), E Einheitsmatrix.
	p ist ein Polynom in den r+1 Variablen X1,..,Xr,X.



			mapicons1( r, n )               (MACRO)

	"matrix of polynomials over integers construction 1"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapicons1(r,n) single r, n;
	E = mapicons1(r,n);
	r und n sind ganze Zahlen, 0<=r<BASIS, 1<=n<BASIS.
	E ist die n-dimensionale Einheitsmatrix.
	E = ( dij ) i,j = 1..n mit dij = 1, falls i=j, 0 sonst.
	dij sind Polynome in r Variablen ueber den ganzen Zahlen.



			mapidet( r, M )

	"matrix of polynomials over integers determinant"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol mapidet(r,M) single r; matrix M;
	P = mapidet(r,M);
	M ist eine quadratische Matrix von Polynomen in r (0<=r<BASIS)
	Variablen ueber den ganzen Zahlen.
	P ist die Determinante von M, also ein Polynom in r Variablen.



			mapidif( r, M, N )              (MACRO)

	"matrix of polynomials over integers difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapidif(r,M,N) single r; matrix M,N;
	L = mapidif(r,M,N);
	M und N sind Matrizen von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen.
	L = M - N.



			mapiexp( r, M, n )

	"matrix of polynomials over integers exponentiation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapiexp(r,M,n)  single r; matrix M; single n;
	X = mapiexp(r,M,n);
	M ist eine quadratische Matrix von Polynomen in r (0<=r<BASIS) 
	Variablen ueber den ganzen Zahlen.
	Im Falle n<0 muss M invertierbar sein, also Det(M)=+-1.
	X = M^n.



			mapigfsevfvs( r, p, AL, M )

	"matrix over polynomials over integers Galois-field with single 
	 characteristic element evaluation first variable special version"    
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapigfsevfvs(r,p,AL,M) single r,p; list AL; matrix M;
	N = mapigfsevfvs(r,p,AL,M);
	Dabei muss gelten:
	      - AL ist die Arithmetikliste fuer GF(p^n), wobei p
		eine Primzahl ist.
	      - M ist eine Matrix von Polynomen in r >= 1 Variablen
		ueber Z.
	Die erste Variable der zu M gehoerenden Variablenliste wird
	durch das erzeugende Element des durch AL bestimmten endlichen
	Koerpers ersetzt.
	N ist dann eine Matrix von Polynomen in r-1 Variablen ueber 
	diesem endlichen Koerper.



			mapiinv( r, M )

	"matrix of polynomials over integers inverse"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapiinv(r,M) single r; matrix M;
	N = mapiinv(r,M);
	M ist eine quadratische, invertierbare Matrix ueber dem Polynomring
	in r (0 <= r < BASIS) Variablen ueber Z.
	!! also Det(M) == +/- 1 ( da +/- 1 einzige Einheiten in Z[X] ) !!
	N = M ^ -1.



			mapineg( r, M )                 (MACRO)

	"matrix of polynomials over integers negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapineg(r,M) single r; matrix M;
	N = mapineg(r,M);
	M ist eine Matrix von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen.
	N = -M.



			mapinfevlfvs( r, F, M )

	"matrix of polynomials over integers number field element
         evaluation first variable special version"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapinfevlfvs( r, F, M )  single r; pol F; matrix M;
	N = mapinfevlfvs( r, F, M );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variablen ueber Z in dense-Darstellung.
	      - M ist eine Matrix von Polynomen in r >= 1 Variablen
                ueber Z.
        In den einzelnen Matrixelementen wird die erste Variable der
        zu M gehoerigen Variablenliste durch das erzeugende Element
	des durch F bestimmten Zahlkoerpers ersetzt.
	N ist eine Matrix von Polynomen in r-1 Variablen ueber diesem
        Zahlkoerper.



			mapiprod( r, M, N )             (MACRO)

	"matrix of polynomials over integers product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapiprod(r,M,N) single r; matrix M,N;
	L = mapiprod(r,M,N);
	M und N sind Matrizen von Polynomen in r (0<=r<BASIS)
	Variablen ueber den ganzen Zahlen.
	M ist eine mxn-Matrix, N ist eine nxl-Matrix mit l,m,n >= 1.
	L = M * N.



			mapismul( r, M, P )

	"matrix of polynomials over integers scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapismul( r, M, p )  single r; matrix M; pol P;
	N = mapismul( r, M, P );
	M ist eine Matrix von Polynomen in r (0<r<BASIS) Variablen
	ueber Z. P ist Polynom in denselben r Variablen ueber Z. 
	Berechnet wird das Skalarprodukt P * M.



			mapisum( r, M, N )              (MACRO)

	"matrix of polynomials over integers sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapisum(r,M,N) single r; matrix M,N;
	L = mapisum(r,M,N);
	M und N sind Matrizen von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen gleicher Dimension.
	L = M + N.



			mapitomapmi( r, M, m )

	"matrix of polynomials over integers to matrix of polynomials 
	 over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapitomapmi(r, M, m)  single r; matrix M; int m;
	L = mapitomapmi (r, M, m);
	m ist positiv.
	Die Matrix M von Polynomen in r (0<=r<BASIS) Variablen ueber Z
	wird in die Matrix L von Polynomen in r Variablen ueber Z/mZ
	umgewandelt, d.h. jeder Polynomkoeffizient wird modulo m
	reduziert.



			mapitomapms( r, M, m )

	"matrix of polynomials over integers to
	 matrix of polynomials over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapitomapms(r, M, m) single r; matrix M; single m;
	L = mapitomapms (r, M, m);
	Die Matrix M von Polynomen in r (0<=r<BASIS) Variablen ueber Z
	wird in die Matrix L von Polynomen in r Variablen ueber Z/mZ
	umgewandelt, wobei 0 < m < BASIS.



			mapitomapnf( r, M )

	"matrix of polynomials over integers to matrix of polynomials over
	 number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapitomapnf(r,M)  single r; matrix M;
	L = mapitomapnf(r,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - M ist eine Matrix von Polynomen in r Variablen ueber Z.
	Die Matrix M wird in die Matrix L von Polynomen in r Variablen
	ueber einem Zahlkoerper umgewandelt.
	( siehe auch: pitopnf )



			mapitomapr( r, M )

	"matrix of integers to matrix of rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapitomapr(r, M) single r; matrix M;
	L = mapitomapr (r, M);
	Die Matrix von Polynomen ueber Z wird in die Matrix von
	Polynomen ueber Q L umgewandelt.



			mapitomarfr( r, M )

	"matrix of polynomials over integers to matrix of rational
	 functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapitomarfr(r, M)  single r; matrix M;
	L = mapitomarfr(r, M);
	Die Matrix M von Polynomen ueber Z wird in die Matrix L von
	rationalen Funktionen ueber Q umgewandelt.



			mapitompmpi( r, M, P )

	"matrix of polynomials over integers to matrix of polynomials
	 modulo polynomial over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapitompmpi( r, M, P )  single r; matrix M; pol P;
	L = mapitompmpi( r, M, P );
	M ist eine Matrix von Polynomen in r (0<=r<BASIS) Variablen 
	ueber Z. P ist Polynom in r Variablen ueber Z.
	Jeder Eintrag in M wird modulo P reduziert.



			mapitransf( r1, M1, V1, r2, P2, V2, Vn, pV3 )

	"matrix of polynomials over the integers transformation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapitransf(r1,M1,V1,r2,P2,V2,Vn,pV3)  single r1; matrix M1; 
		list V1; single r2; pol P2; list V2; list Vn; list *pV3;
	M3 = mapitransf(r1,M1,V1,r2,P2,V2,Vn,pV3);
	M1 ist eine Matrix von Polynomen in r1 (1<=r1<BASIS) Variablen
	ueber den ganzen Zahlen; V1 ist die zugehoerige Variablenliste.
	P2 ist ein Polynom in r2 (0<=r2<BASIS) Variablen ueber den
	ganzen Zahlen; V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	M3 ist die Matrix, die entsteht, wenn in M1 die Variable Vn
	durch das Polynom P2 ersetzt wird, und die zugehoerige, in
	*pV3 abgelegte Variablenliste alphabetisch sortiert ist.
	(Die in *pV3 abgelegte Variablenliste ist die Vereinigung von
	V1 und V2.)



			mapivecmul( r, A, x )           (MACRO)

	"matrix of polynomials over integers vector multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec mapivecmul (r, A, x) single r; matrix A; vec x;
	y = mapivecmul (r, A, x)
	A ist eine mxn - Matrix ueber dem Polynomring in r (0<=r<BASIS)
	Variablen ueber Z R.
	x ist ein Vektor der Laenge n mit Elementen aus R.
	y = A * x ist ein Vektor der Laenge m.



			mapmichpol( r, m, M )           (MACRO)

	"matrix of polynomials over modular integers characteristic
	 polynomial"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol mapmichpol(r,m,M)  single r; int m; matrix M;
	p = mapmichpol(r,m,M);
	M ist eine Matrix von Polynomen in r Variablen X1,..,Xr (r>=0)
	ueber Z/mZ (m>0).
	p ist das charakteristische Polynom von M:
	p(X) = det( M - X * E ), E Einheitsmatrix.
	p ist ein Polynom in den r+1 Variablen X1,..,Xr,X.



			mapmicons1( r, m, n )           (MACRO)

	"matrix of polynomials over modular integers construction 1"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmicons1(r,m,n)  single r; int m; single n;
	E = maprcons1(r,m,n);
	Es muss gelten: r>=0 und m,n>0.
	E ist die n-dimensionale Einheitsmatrix, d.h.:
	E = ( dij ) i,j = 1..n mit dij = 1, falls i=j, 0 sonst.
	Die dij sind Polynome in r Variablen ueber Z/mZ.



			mapmidet( r, m, M )

	"matrix of polynomials over modular integers determinant"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol mapmidet(r,m,M)  single r; int m; matrix M;
	P = mapmidet(r,m,M);
	m ist eine Primzahl.
	M ist eine quadratische Matrix von Polynomen in r (0<=r<BASIS)
	Variablen ueber Z/mZ.
	P ist die Determinante von M, also ein Polynom in r Variablen.



			mapmidif( r, m, M, N )          (MACRO)

	"matrix of polynomials over modular integers difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmidif(r,m,M,N)  single r; int m; matrix M,N;
	L = mapmidif(r,m,M,N);
	M und N sind Matrizen von Polynomen in r (r>=0) Variablen
	ueber Z/mZ (m>0).
	L = M - N.



			mapmiexp( r, m, M, n )

	"matrix of polynomials over modular integers exponentiation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmiexp(r,m,M,n)  single r; int m; matrix M; single n;
	Y = mapmiexp(r,m,M,n);
	Dabei muss gelten:
	      - r >= 0.
	      - m > 0.
	      - M ist eine quadratische Matrix von Polynomen in r
		Variablen ueber dem Restklassenring Z/mZ.
	Y = M^n.
	Im Falle n < 0 muss M invertierbar sein, also:
	!! Det(M) ist eine Einheit in Z/mZ[X] fuer n < 0 !!



			mapmiinv( r, m, M )

	"matrix of polynomials over modular integers inverse"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmiinv(r,m,M)  single r; int m; matrix M;
	N = mapmiinv (r,m,M);
	M ist eine quadratische, invertierbare Matrix ueber dem
	Polynomring in r (r>=0) Variablen ueber Z/mZ (m>0),
	!! also Det(M) ist eine Einheit in Z/mZ[X] !!
	N = M ^ -1.



			mapmineg( r, m, M )             (MACRO)

	"matrix of polynomials over modular integers negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmineg(r,m,M)  single r; int m; matrix M;
	N = mapmineg(r,m,M);
	M ist eine Matrix von Polynomen in r (r>=0) Variablen 
	ueber Z/mZ (m>0).
	N = -M.



			mapmiprod( r, m, M, N )         (MACRO)

	"matrix of polynomials over modular integers product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmiprod(r,m,M,N)  single r; int m; matrix M,N;
	L = mapmiprod(r,m,M,N);
	M und N sind Matrizen von Polynomen in r (r>=0) Variablen
	ueber Z/mZ (m>0).
	M ist eine sxt-Matrix, N ist eine txu-Matrix mit s,t,u >= 1.
	L = M * N.



			mapmismul( r, m, M, P )

	"matrix of polynomials over modular integers scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmismul( r, m, M, P )  single r; int m; matrix M; pol P;
	N = mapmismul( r, m, M, P );
	m ist positiv.
	M ist eine Matrix von Polynomen in r (r>=0) Variablen ueber Z/mZ.
	P ist ein Polynom in r Variablen ueber Z/mZ. 
	Berechnet wird das Skalarprodukt P * M.



			mapmisum( r, m, M, N )          (MACRO)

	"matrix of polynomials over modular integers sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmisum(r,m,M,N)  single r; int m; matrix M,N;
	L = mapmisum(r,M,N);
	M und N sind Matrizen von Polynomen in r (r>=0) Variablen
	ueber Z/mZ (m>0).
	L = M + N.



			mapmitomapmp( r, m, P, M )

	"matrix of polynomials over modular integers to matrix of
	polynomials modulo polynomial over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmitomapmp(r, m, P, M)  single r; int m; pol P; matrix M;
	X = mapmitomapmp(r, m, P, M);
	M ist eine Matrix bestehend aus Polynomen in r (r >= 0) Variablen
	ueber Z/mZ (m > 0), und m ist Primzahl.
	P ist ein Polynom in r Variablen ueber Z/mZ.
	X ist die Matrix bestehend aus den Polynomen von M, reduziert
	modulo P.



			mapmitransf( r1, m, M1, V1, r2, P2, V2, Vn, pV3 )

	"matrix of polynomials over modular integers transformation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmitransf(r1,m,M1,V1,r2,P2,V2,Vn,pV3)
		int m; single r1; matrix M1; list V1; single r2; pol P2;
		list V2,Vn,*pV3;
	M3 = mapmitransf(r1,m,M1,V1,r2,P2,V2,Vn,pV3);
	Dabei muss gelten:
	      - r1 >= 1.
	      - m > 0.
	      - M1 ist eine Matrix von Polynomen in r1 Variablen ueber dem
		Restklassenring Z/mZ.
	      - V1 ist die zur Matrix M1 gehoerige Variablenliste.
	      - r2 >= 0.
	      - P2 ist ein Polynom in r2 Variablen ueber Z/mZ.
	      - V2 ist die zum Polynom P2 gehoerige Variablenliste.
	      - Vn ist eine Liste, die einen in V1 auftretenden Variablen-
		namen repraesentiert.
	      - In *pV3 ist die Vereinigung der Variablenlisten V1 und V2
		abgelegt und alphabetisch sortiert.
	M3 ist die Matrix, die entsteht, wenn in M1 die Variable Vn durch
	das Polynom P2 ersetzt wird, und *pV3 ist die zur Matrix M3 ge-
	hoerige Variablenliste.



			mapmivecmul( r, m, A, x )       (MACRO)

	"matrix of polynomials over modular integers vector multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec mapmivecmul (r, m, A, x)  single r; int m; matrix A; vec x;
	y = mapmivecmul (r, m, A, x)
	A ist eine sxt - Matrix ueber R, dem Polynomring in r (r>=0)
	Variablen ueber Z/mZ (m>0).
	x ist ein Vektor der Laenge t ueber R.
	y = A * x ist ein Vektor der Laenge s.



			mapmschpol( r, m, M )           (MACRO)

	"matrix of polynomials over modular singles characteristic
	 polynomial"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol mapmschpol(r,m,M)  single r,m; matrix M;
	p = mapmschpol(r,m,M);
	M ist eine Matrix von Polynomen in r Variablen X1,..,Xr (r>=0) 
	ueber Z/mZ (m>0).
	p ist das charakteristische Polynom von M:
	p(X) = det( M - X * E ), E Einheitsmatrix.
	p ist ein Polynom in den r+1 Variablen X1,..,Xr,X.



			mapmscons1( r, m, n )           (MACRO)

	"matrix of polynomials over modular singles construction 1"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprcons1(r,m,n)  single r, m, n;
	E = maprcons1(r,m,n);
	Es muss gelten: r>=0 und n,m>0.
	E ist die n-dimensionale Einheitsmatrix, d.h.:
	E = ( dij ) i,j = 1..n mit dij = 1, falls i=j, 0 sonst.
	Die dij sind Polynome in r Variablen ueber Z/mZ.



			mapmsdet( r, m, M )

	"matrix of polynomials over modular singles determinant"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol mapmsdet(r,m,M)  single r,m; matrix M;
	P = mapmsdet(r,m,M);
	m ist Primzahl.
	M ist eine quadratische Matrix von Polynomen in r (r>=0)
	Variablen ueber Z/mZ.
	P ist die Determinante von M, also ein Polynom in r Variablen.



			mapmsdif( r, m, M, N )          (MACRO)

	"matrix of polynomials over modular singles difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmsdif(r,m,M,N)  single r, m; matrix M,N;
	L = mapmsdif(r,m,M,N);
	M und N sind Matrizen von Polynomen in r (r>=0) Variablen
	ueber Z/mZ (m>0).
	L = M - N.



			mapmsexp( r, m, M, n )

	"matrix of polynomials over modular singles exponentiation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmsexp(r,m,M,n)  single r,m; matrix M; single n;
	Y = mapmsexp(r,m,M,n);
	Dabei muss gelten:
	      - r >= 0.
	      - m > 0.
	      - M ist eine quadratische Matrix von Polynomen in r
		Variablen ueber dem Restklassenring Z/mZ.
	Y = M^n.
	Im Falle n < 0 muss M invertierbar sein, also:
	!! Det(M) ist eine Einheit in Z/mZ[X] fuer n < 0 !!



			mapmsinv( r, m, M )

	"matrix of polynomials over modular singles inverse"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmsinv(r,m,M)  single r,m; matrix M;
	N = mapmsinv (r,m,M);
	M ist eine quadratische, invertierbare Matrix ueber dem Polynomring
	in r (r>=0) Variablen ueber Z/mZ (m>0),
	!! also Det(M) ist eine Einheit in Z/mZ[X] !!
	N = M ^ -1.



			mapmsneg( r, m, M )             (MACRO)

	"matrix of polynomials over modular singles negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmsneg(r,m,M)  single r,m; matrix M;
	N = mapmsneg(r,m,M);
	M ist eine Matrix von Polynomen in r (r>=0) Variablen
	ueber Z/mZ (m>0).
	N = -M.



			mapmsprod( r, m, M, N )         (MACRO)

	"matrix of polynomials over modular singles product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmsprod(r,m,M,N)  single r,m; matrix M,N;
	L = mapmsprod(r,m,M,N);
	M und N sind Matrizen von Polynomen in r (r>=0) Variablen
	ueber Z/mZ (m>0).
	M ist eine sxt-Matrix, N ist eine txu-Matrix mit s,t,u >= 1.
	L = M * N.



			mapmssmul( r, m, M, P )

	"matrix of polynomials over modular singles scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmssmul(r, m, M, P)  single r; single m; matrix M; pol P;
	N = mapmssmul(r, m, M, P);
	m ist positiv.
	M ist eine Matrix von Polynomen in r (r>=0) Variablen ueber Z/mZ.
	P ist ein Polynom in r Variablen ueber Z/mZ. 
	Berechnet wird das Skalarprodukt P * M.



			mapmssum( r, m, M, N )          (MACRO)

	"matrix of polynomials over modular singles sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmssum(r,m,M,N)  single r,m; matrix M,N;
	L = mapmssum(r,M,N);
	M und N sind Matrizen von Polynomen in r (r>=0) Variablen
	ueber Z/mZ (m>0).
	L = M + N.



			mapmstomapmp( r, m, P, M )

	"matrix of polynomials over modular singles to matrix of
	polynomials modulo polynomial over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmstomapmp(r, m, P, M)  single r,m; pol P; matrix M;
	X = mapmstomapmp(r, m, P, M);
	M ist eine Matrix bestehend aus Polynomen in r (r >= 0) Variablen
	ueber Z/mZ (0 < m < BASIS), und m ist Primzahl.
	P ist ein Polynom in r Variablen ueber Z/mZ.
	X ist die Matrix bestehend aus den Polynomen von M, reduziert
	modulo P.



			mapmstransf( r1, m, M1, V1, r2, P2, V2, Vn, pV3 )

	"matrix of polynomials over modular singles transformation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mapmstransf(r1,m,M1,V1,r2,P2,V2,Vn,pV3)
		single r1,m; matrix M1; list V1; single r2; pol P2;
		list V2,Vn,*pV3;
	M3 = mapmstransf(r1,m,M1,V1,r2,P2,V2,Vn,pV3);
	Dabei muss gelten:
	      - r1 >= 1.
	      - m > 0.
	      - M1 ist eine Matrix von Polynomen in r1 Variablen ueber dem
		Restklassenring Z/mZ.
	      - V1 ist die zur Matrix M1 gehoerige Variablenliste.
	      - r2 >= 0.
	      - P2 ist ein Polynom in r2 Variablen ueber Z/mZ.
	      - V2 ist die zum Polynom P2 gehoerige Variablenliste.
	      - Vn ist eine Liste, die einen in V1 auftretenden Variablen-
		namen repraesentiert.
	      - In *pV3 ist die Vereinigung der Variablenlisten V1 und V2
		abgelegt und alphabetisch sortiert.
	M3 ist die Matrix, die entsteht, wenn in M1 die Variable Vn durch
	das Polynom P2 ersetzt wird, und *pV3 ist die zur Matrix M3 ge-
	hoerige Variablenliste.



			mapmsvecmul( r, m, A, x )       (MACRO)

	"matrix of polynomials over modular singles vector multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec mapmsvecmul (r, m, A, x)  single r, m; matrix A; vec x;
	y = mapmsvecmul (r, m, A, x);
	A ist eine sxt - Matrix ueber R, dem Polynomring in r (r>=0)
	Variablen ueber Z/mZ (m>0).
	x ist ein Vektor der Laenge t ueber R.
	y = A * x ist ein Vektor der Laenge s.



			mapnfchpol( r, F, M )           (MACRO)

	"matrix of polynomials over number field characteristic polynomial"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	pol mapnfchpol(r,F,M)  single r; pol F; matrix M;
	chp = mapnfchpol(r,F,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische Matrix von Polynomen ueber k.
	chp ist das charakteristische Polynom von M:
	chp(X) = det( M - X * E ), E Einheitsmatrix.
	chp ist ein Polynom ueber k.



			mapnfcons1( r, F, n )           (MACRO)

	"matrix of polynomials over number field construction 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnfcons1(r,F,n)  single r; pol F; single n;
	E = mapnfcons1(r,F,n);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - 1 <= n < BASIS.
	E ist die n-dimensionale Einheitsmatrix.
	E = ( Dij ) i,j = 1, ..., n mit Dij = 1, falls i = j, 0 sonst.
	Dij sind Elemente aus k[X].



			mapnfdet( r, F, M )

	"matrix of polynomials over number field determinant"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	pol mapnfdet(r,F,M)  single r; pol F; matrix M;
	P = mapnfdet(r,F,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische Matrix von Polynomen in r Vari-
		ablen ueber k.
	P ist die Determinante von M, also ein Polynom aus k[X].



			mapnfdif( r, F, M, N )          (MACRO)

	"matrix of polynomials over number field difference"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnfdif(r,F,M,N)  single r; pol F; matrix M,N;
	L = mapnfdif(r,F,M,N);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M und N sind Matrizen gleicher Dimension von Polynomen in
		r Variablen ueber k.
	L = M - N.



			mapnfexp( r, F, M, n )

	"matrix of polynomials over number field exponentiation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnfexp(r,F,M,n)  single r; pol F; matrix M; single n;
	Y = mapnfexp(r,F,M,n);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische Matrix von Polynomen in r Variablen
		ueber k.
	      - -BASIS+1 <= n <= BASIS-1.
	Y = M^n.
	Im Falle n < 0, muss M invertierbar sein,
	!!! also Det(M) ist aus k !!!



			mapnfinv( r, F, M )

	"matrix of polynomials over number field inverse"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnfinv(r,F,M)  single r; pol F; matrix M;
	N = mapnfinv(r,F,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine quadratische, invertierbare Matrix von Poly-
		nomen in r Variablen ueber k,
		!!! also Det(M) ist aus k !!!
	N = M^-1.



			mapnfneg( r, F, M )             (MACRO)

	"matrix of polynomials over number field negation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnfneg(r,F,M)  single r; pol F; matrix M;
	N = mapnfneg(r,F,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine Matrix von Polynomen in r Variablen ueber k.
	N = -M.



			mapnfprod( r, F, M, N )         (MACRO)

	"matrix of polynomials over number field product"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnfprod(r,F,M,N)  single r; pol F; matrix M,N;
	L = mapnfprod(r,F,M,N);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine mxn-Matrix,
	      - N ist eine nxl-Matrix mit l,m,n >= 1 und von Polynomen in
		r Variablen ueber k.
	L = M * N ist eine mxl-Matrix.



			mapnfsmul( r, F, M, el )

	"matrix of polynomials over number field scalar multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnfsmul(r,F,M,el)  single r; pol F; matrix M; pol el;
	N = mapnfsmul(r,F,M,el);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine mxn-Matrix mit m,n >= 1 von Polynomen in r
		Variablen ueber k.
	      - el ist ein Polynom ueber k.
	N = el * M ist eine mxn-Matrix.



			mapnfsum( r, F, M, N )          (MACRO)

	"matrix of polynomials over number field sum"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnfsum(r,F,M,N)  single r; pol F; matrix M,N;
	L = mapnfsum(r,F,M,N);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M und N sind Matrizen gleicher Dimension von Polynomen
		in r Variablen ueber k.
	L = M + N.



			mapnftomapmp( r, F, P, M )

	"matrix of polynomials over number field to matrix of
	polynomials modulo polynomial over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnftomapmp( r, F, P, M )  single r; pol F,P; matrix M;
	X = mapnftomapmp( r, F, P, M );
	Dabei muss gelten:
              - 0 <= r < BASIS.
              - F ist ein irreduzibles Polynom in einer Variablen ueber
                Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
                per k erzeugt.
	      - P ist ein Polynom in r Variablen ueber k.
              - M ist eine Matrix von Polynomen in r Variablen ueber k.
	X ist die Matrix bestehend aus den Polynomen von M, reduziert
	modulo P.



			mapnftomapr( r, M )

	"matrix of polynomials over number field to matrix
	 of polynomials over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnftomapr(r, M)  single r; matrix M;
	N = mapnftomapr(r, M);
        M ist eine Matrix von Polynomen in r Variablen ueber einem 
	Zahlkoerper.
	N ist eine Matrix von Polynomen in r + 1 Variablen ueber Q, 
	die aus M hervorgegangen ist durch Umformung der 
	Koeffizienten der einzelnen Polynome von M, die algebraische 
	Zahlen sind, in Polynome in einer Variablen ueber Q.



			mapnftransf( r1, F, M1, V1, r2, P2, V2, Vn, pV3 )

	"matrix of polynomials over number field transformation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnftransf(r1,F,M1,V1,r2,P2,V2,Vn,pV3)
		single r1,r2; pol F,P2; matrix M1; list V1,V2,Vn,*pV3;
	M3 = mapnftransf(r1,F,M1,V1,r2,P2,V2,Vn,pV3);
	Dabei muss gelten:
	      - r1 >= 1.
	      - F ist ein irreduzibles Polynom ueber Z in einer Variab-
	        len in dense-Darstellung, das einen Zahlkoerper K er-
		zeugt.	
	      - M1 ist eine Matrix von Polynomen in r1 Variablen ueber 
		K.
	      - V1 ist die zur Matrix M1 gehoerige Variablenliste.
	      - r2 >= 0.
	      - P2 ist ein Polynom in r2 Variablen ueber K.
	      - V2 ist die zum Polynom P2 gehoerige Variablenliste.
	      - Vn ist eine Liste, die einen in V1 auftretenden Variab-
		lennamen repraesentiert.
	      - In *pV3 ist die Vereinigung der Variablenlisten V1 und
	        V2 abgelegt, und zwar alphabetisch sortiert.
	M3 ist die Matrix, die entsteht, wenn in M1 die durch Vn reprae-
	sentierte Variable durch das Polynom P2 ersetzt wird, und *pV3 
	ist die zur Matrix M3 gehoerige Variablenliste.



			mapnfvecmul( r, F, A, x )       (MACRO)

	"matrix of polynomials over number field vector multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mapnfvecmul(r,F,A,x)  single r; pol F; matrix A; vec x;
	y = mapnfvecmul(r,F,A,x);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - A ist eine mxn-Matrix mit m,n >= 1 und von Polynomen in r
		Variablen ueber k.
	      - x ist ein Vektor der Laenge n von Polynomen in r Variablen
		ueber k.
	y = A * x ist ein Vektor der Laenge m.



			maprchpol( r, M )               (MACRO)

	"matrix of polynomials over rationals characteristic polynomial"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol maprchpol(r,M) single r; matrix M;
	p = maprchpol(r,M);
	M ist eine Matrix von Polynomen in r Variablen X1,..,Xr ueber den
	rationalen Zahlen.
	p ist das charakteristische Polynom von M:
	p(X) = det( M - X * E ), E Einheitsmatrix.
	p ist ein Polynom in den r+1 Variablen X1,..,Xr,X.



			maprcons1( r, n )               (MACRO)

	"matrix of polynomials over rationals construction 1"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprcons1(r,n) single r, n;
	E = maprcons1(r,n);
	r und n sind ganze Zahlen, 0<=r<BASIS, 1<=n<BASIS.
	E ist die n-dimensionale Einheitsmatrix.
	E = ( dij ) i,j = 1..n mit dij = 1, falls i=j, 0 sonst.
	dij sind Polynome in r Variablen ueber den rationalen Zahlen.



			maprdet( r, M )

	"matrix of polynomials over rationals determinant"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol maprdet(r,M) single r; matrix M;
	P = maprdet(r,M);
	M ist eine quadratische Matrix von Polynomen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen.
	P ist die Determinante von M, also ein Polynom in r Variablen.



			maprdif( r, M, N )              (MACRO)

	"matrix of polynomials over rationals difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprdif(r,M,N) single r; matrix M,N;
	L = maprdif(r,M,N);
	M und N sind Matrizen von Polynomen in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen.
	L = M - N.



			maprexp( r, M, n )

	"matrix of polynomials over rationals exponentiation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprexp(r,M,n)  single r; matrix M; single n;
	X = maprexp(r,M,n);
	M ist eine quadratische Matrix von Polynomen in r (0<=r<BASIS) 
	Variablen ueber den rationalen Zahlen.
	Im Falle n<0 muss M invertierbar sein, also Det(M)!=0.
	X = M^n.



			maprinv( r, M )

	"matrix of polynomials over rationals inverse"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprinv(r,M) single r; matrix M;
	N = maprinv(r,M);
	M ist eine quadratische, invertierbare Matrix ueber dem Polynomring
	in r (0 <= r < BASIS) Variablen ueber Q.
	!! also Det(M) ist Einheit in Q[X], d.h. Det(M) ist aus Q \ {0} !!
	N = M ^ -1.



			maprneg( r, M )                 (MACRO)

	"matrix of polynomials over rationals negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprneg(r,M) single r; matrix M;
	N = maprneg(r,M);
	M ist eine Matrix von Polynomen in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen.
	N = -M.



			maprnfevlfvs( r, F, M )

	"matrix of polynomials over rationals number field element
         evaluation first variable special version"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix maprnfevlfvs( r, F, M )  single r; pol F; matrix M;
	N = maprnfevlfvs( r, F, M );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variablen ueber Z in dense-Darstellung.
	      - M ist eine Matrix von Polynomen in r >= 1 Variablen
                ueber Q.
        In den einzelnen Matrixelementen wird die erste Variable der
        zu M gehoerigen Variablenliste durch das erzeugende Element
	des durch F bestimmten Zahlkoerpers ersetzt.
	N ist eine Matrix von Polynomen in r-1 Variablen ueber diesem
        Zahlkoerper.



			maprod( M, N, prod, sum, anzahlargs, arg1, arg2 )

	"matrix product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprod(M,N,prod,sum,anzahlargs,arg1,arg2)
	     matrix M,N; obj (*prod)(),(*sum)(); single anzahlargs;
	     obj arg1,arg2;
	L = maprod(M,N,prod,sum,anzahlargs,arg1,arg2);
	M ist eine mxn-Matrix, N ist eine nxl-Matrix mit l,m,n >= 1.
	sum und prod sind die Additions- bzw. Multiplikationsfunktionen
	des Grundrings R.
	sum und prod benoetigen ausser 2 Elementen aus R noch anzahlargs
	Argumente; arg1 und arg2 (maximal) sind diese Argumente.
	L = M * N.
	Beispiel: Multiplikation zweier Matrizen ueber Z:
	L = maprod( M, N, isum, iprod, 0 );
	siehe auch: maiprod, marprod, mamsprod, ...



			maprodspec( M, N, prod, sum, anzahlargs, arg1, ..., arg5 )

	"matrix product special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprodspec(M,N,prod,sum,anzahlargs,arg1,...,arg5)
	       matrix M,N; obj (*prod)(),(*sum)(); single anzahlargs;
	       obj arg1,...,arg5;
	L = maprodspec(M,N,prod,sum,anzahlargs,arg1,...,arg5);
	Dabei muss gelten:
	      - M ist eine mxn-Matrix, und
	      - N ist eine nxl-Matrix ueber einem Ring R mit l,m,n >= 1.
	      - sum ist die Additions - Funktion, und
	      - prod ist die Multiplikations - Funktion des Ringes R.
	      - sum und prod benoetigen ausser 2 Elementen aus R noch
		anzahlargs Argumente; arg1, ..., arg5 (maximal) sind diese
		Argumente.
	L = M * N.
	Beispiel: Multiplikation zweier Matrizen ueber GF(p^n)[X]:
	L = maprodspec( M, N, pgfssum, pgfsprod, 3, r, p, AL, 0, 0 );



			maprprod( r, M, N )             (MACRO)

	"matrix of polynomials over rationals product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprprod(r,M,N) single r; matrix M,N;
	L = maprprod(r,M,N);
	M und N sind Matrizen von Polynomen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen.
	M ist eine mxn-Matrix, N ist eine nxl-Matrix mit l,m,n >= 1.
	L = M * N.



			maprsmul( r, M, P )

	"matrix of polynomials over rationals scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprsmul( r, M, p )  single r; matrix M; pol P;
	N = maprsmul( r, M, P );
	M ist eine Matrix von Polynomen in r (0<r<BASIS) Variablen
	ueber Q. P ist Polynom in denselben r Variablen ueber Q. 
	Berechnet wird das Skalarprodukt P * M.



			maprsum( r, M, N )              (MACRO)

	"matrix of polynomials over rationals sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprsum(r,M,N) single r; matrix M,N;
	L = maprsum(r,M,N);
	M und N sind Matrizen von Polynomen in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen gleicher Dimension.
	L = M + N.



			maprtomapmi( r, M, m )

	"matrix of polynomials over rationals to matrix of polynomials 
	 over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprtomapmi(r, M, m)  single r; matrix M; int m;
	L = maprtomapmi (r, M, m);
	m ist positiv.
	Die Matrix M von Polynomen in r (0<=r<BASIS) Variablen ueber Z
	wird in die Matrix L von Polynomen in r Variablen ueber Z/mZ
	umgewandelt, d.h. jeder Polynomkoeffizient wird modulo m
	reduziert. Falls der ggt des Hauptnenners eines Matrixelements 
	und m ungleich 1 ist, so wird ERROR zurueckgegeben.



			maprtomapnf( r, M )

	"matrix of polynomials over rationals to matrix of polynomials 
	 over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix maprtomapnf(r,M)  single r; matrix M;
	L = maprtomapnf(r,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - M ist eine Matrix von Polynomen in r Variablen ueber Q.
	Die Matrix M wird in die Matrix L von Polynomen in r Variablen
	ueber einem Zahlkoerper umgewandelt.
	( siehe auch: prtopnf )



			maprtomarfr( r, M )

	"matrix of polynomials over rationals to matrix of rational
	 functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix maprtomarfr(r, M)  single r; matrix M;
	L = maprtomarfr(r, M);
	Die Matrix M von Polynomen ueber Q wird in die Matrix L von
	rationalen Funktionen ueber Q umgewandelt.



			maprtompmpr( r, M, P )

	"matrix of polynomials over rationals to matrix of polynomials
	 modulo polynomial over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprtompmpr( r, M, P )  single r; matrix M; pol P;
	L = maprtompmpr( r, M, P );
	M ist eine Matrix von Polynomen in r (0<=r<BASIS) Variablen 
	ueber Q. P ist Polynom in r Variablen ueber Q.
	Jeder Eintrag in M wird modulo P reduziert.



			maprtransf( r1, M1, V1, r2, P2, V2, Vn, pV3 )

	"matrix of polynomials over the rationals transformation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maprtransf(r1,M1,V1,r2,P2,V2,Vn,pV3)  single r1; matrix M1; 
		list V1; single r2; pol P2; list V2; list Vn; list *pV3;
	M3 = maprtransf(r1,M1,V1,r2,P2,V2,Vn,pV3);
	M1 ist eine Matrix von Polynomen in r1 (0<r1<BASIS) Variablen
	ueber den rationalen Zahlen; V1 ist die zugehoerige Variablen-
	liste. P2 ist ein Polynom in r2 (0<=r2<BASIS) Variablen ueber den
	rationalen Zahlen; V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	M3 ist die Matrix, die entsteht, wenn in M1 die Variable Vn
	durch das Polynom P2 ersetzt wird, und die zugehoerige, in
	*pV3 abgelegte Variablenliste alphabetisch sortiert ist.
	(Die in *pV3 abgelegte Variablenliste ist die Vereinigung von
	V1 und V2.)



			maprvecmul( r, A, x )           (MACRO)

	"matrix of polynomials over rationals vector multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec maprvecmul (r, A, x) single r; matrix A; vec x;
	y = maprvecmul (r, A, x)
	A ist eine mxn - Matrix ueber dem Polynomring in r (0<=r<BASIS)
	Variablen ueber Q R.
	x ist ein Vektor der Laenge n mit Elementen aus R.
	y = A * x ist ein Vektor der Laenge m.



			maptomadp( r, M )

	"matrix of polynomials to matrix of dense polynomials"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maptomadp(r,M)  single r; matrix M;
	L = maptomadp(r,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - M ist eine Matrix von Polynomen in r Variablen
		in rekursiver Darstellung.
	M wird in die Matrix L von Polynomen in r Variablen in dense-
	Darstellung umgewandelt.
	L = M. (dense-Darstellung der Polynome)



			maptomaup( r, M )

	"matrix of polynomials to matrix of univariate polynomials"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix maptomaup(r,M)  single r; matrix M;
	L = maptomaup(r,M);
	Dabei muss gelten;
	      - 0 <= r < BASIS.
	      - M ist eine Matrix von Polynomen in r Variablen.
	M wird in die Matrix L von Polynomen in einer Variablen umge-
	wandelt.
	(siehe auch: ptoup)



			marchpol( M )                   (MACRO)

	"matrix of rationals characteristic polynomial"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol marchpol(M) matrix M;
	p = marchpol(M);
	M ist eine Matrix von rationalen Zahlen.
	p ist das charakteristische Polynom von M:
	p(X) = det( M - X * E ), E Einheitsmatrix.
	p ist ein Polynom in einer Variablen ueber Q.



			marcons1( n )                   (MACRO)

	"matrix of rationals construction 1"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix marcons1(n) single n;
	E = marcons1(n);
	n ist eine ganze Zahl, n>=1.
	E ist die n-dimensionale Einheitsmatrix.
	E = ( dij ) i,j = 1..n mit dij = 1, falls i=j, 0 sonst.



			mardet( M )

	"matrix of rationals determinant"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	rat mardet(M) matrix M;
	D = mardet(M);
	M ist eine quadratische Matrix von rationalen Zahlen.
	D ist die Determinante von M.



			mardif( M, N )                  (MACRO)

	"matrix of rationals difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mardif(M,N) matrix M, N;
	L = mardif(M,N);
	M und N sind Matrizen von rationalen Zahlen gleicher Dimension.
	L = M - N.



			marev( M )                      (MACRO)

	"matrix of rationals eigenvalues"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list marev( M )  matrix M;
	L = marev( M );
	Dabei muss gelten:
	      M ist eine Matrix von rationalen Zahlen.
	L = (EW1, av1, ..., EWk, avk) ist die Liste der
	rationalen Eigenwerte EWi der Matrix M mit mit ihren
	algebraischen Vielfachheiten avi fuer 1 <= i <= k. 



			marevifcp( M, *pL )

	"matrix of rationals eigenvalues and irreducible factors
	 of the characteristic polynomial"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	list marevifcp( M, pL )  matrix M; list *pL;
	L = marevifcp( M, pL );
	Dabei muss gelten:
	      - M ist eine Matrix von rationalen Zahlen.
	      - *pL ist die Liste der irreduziblen Faktoren
		des charakteristischen Polynoms von M.
	L = (EW1, av1, ..., EWk, avk) ist die Liste der rationalen
	Eigenwerte der Matrix M mit ihren algebraischen Vielfach-
	heiten avi fuer 1 <= i <= k. Diese erhaelt man durch Faktor-
	isierung des charakteristischen Polynoms von M.
	Zusaetzlich werden die irreduziblen Faktoren des charakter-
	istischen Polynoms angegeben:
        *pL = (P1, e1, ..., Pn, en),
        wobei die Pj fuer 1 <= j <= n die irreduziblen Faktoren des
	charakteristischen Polynoms mit ihren Exponenten ej sind. 
        Die Nullstellen der Linearfaktoren sind die rationalen Eigen-
	werte. 



			marexp( M, n )

	"matrix of rationals exponentiation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix marexp(M,n)  matrix M; single n;
	X = marexp(M,n);
	M ist eine quadratische Matrix ueber den rationalen Zahlen.
	Im Falle n<0 muss M invertierbar sein, also Det(M)!=0.
	X = M^n.



			marfmsp1c1( p, n )              (MACRO)

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, construction 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfmsp1c1(p,n)  single p, n;
	E = marfmsp1c1(p,n);
	p ist Primzahl, n ist positiv.
	E ist die n-dimensionale Einheitsmatrix, d.h.
	E = ( dij ) i,j = 1..n mit dij = 1, falls i=j, 0 sonst.
	dij sind rationale Funktionen in r Variablen ueber den
	rationalen Zahlen.



			marfmsp1det( p, M )

	"matrix of rational functions over modular single primes
	 transcendence degree 1, determinant"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	rfunc marfmsp1det(p,M)  single p; matrix M;
	P = marfmsp1det(p,M);
	p ist eine Primzahl.
	M ist eine quadratische Matrix von rationalen Funktionen in einer
	Variablen ueber Z/pZ.
	P ist die Determinante von M, also eine rationale Funktion in einer
	Variablen.



			marfmsp1dif( p, M, N )          (MACRO)

	"matrix of rational functions over modular single primes
	 transcendence degree 1, difference"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfmsp1dif(p,M,N)  single p; matrix M,N;
	L = marfmsp1dif(p,M,N);
	p ist Primzahl.
	M und N sind Matrizen gleicher Dimension von rationalen Funktionen
	in einer Variablen ueber Z/pZ.
	L = M - N.



			marfmsp1exp( p, M, n )

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, exponentiation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfmsp1exp(p,M,n)  single p; matrix M; single n;
	X = marfmsp1exp(p,M,n);
	p ist Primzahl.
	M ist eine mxm-Matrix von rationalen Funktionen in einer Variablen
	ueber Z/pZ.
	Im Falle n<0 muss M invertierbar sein, also Det(M)<>0.
	X = M^n.



			marfmsp1inv( p, M )

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, inverse"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfmsp1inv(p,M)  single p; matrix M;
	N = marfmsp1inv(p,M);
	p ist eine Primzahl.
	M ist eine quadratische, invertierbare Matrix ueber dem Koerper
	der rationalen Funktionen in einer Variablen ueber Z/pZ.
	!! also Det(M) != 0 und aus Z/pZ(X) !!
	N = M ^ -1.



			marfmsp1neg( p, M )             (MACRO)

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, negation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfmsp1neg(p,M)  single p; matrix M;
	N = marfmsp1neg(p,M);
	p ist eine Primzahl.
	M ist eine Matrix von rationalen Funktionen in einer Variablen
	ueber Z/pZ.
	N = -M.



			marfmsp1nsb( p, M )

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, null space basis"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	list marfmsp1nsb(p,M)  single p; matrix M;
	L = marfmsp1nsb(p,M);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - M ist eine (n,n) - Matrix mit Elementen aus Z/pZ(x) in
		einer Variablen, 1 <= n < BASIS.
	L = ( L1, ..., Lr ) ist eine Liste von Vektoren, die eine Basis
	des Nullraums von M bilden, also M * Li = 0 fuer alle i = 1,...,r.
	Jeder Vektor Li ist eine Liste der Laenge n.
!!!     Die Matrix M wird veraendert.



			marfmsp1prod( p, M, N )         (MACRO)

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, product"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfmsp1prod(p,M,N)  single p; matrix M,N;
	L = marfmsp1prod(p,M,N);
	p ist Primzahl.
	M und N sind Matrizen von rationalen Funktionen in einer
	Variablen ueber Z/pZ.
	M ist eine mxn-Matrix, N ist eine nxl-Matrix mit l,m,n >= 1.
	L = M * N.



			marfmsp1rk( p, M )

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, rank"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single marfmsp1rk(p,M)  single p; matrix M;
	r = marfmsp1rk(p,M);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - M ist eine beliebige Matrix ueber Z/pZ(X) in einer
		Variablen.
	Mit Hilfe des Algorithmus von Gauss wird der Rang von M berechnet.



			marfmsp1smul( p, M, F )

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, scalar multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfmsp1smul( p, M, F )  single p; matrix M; rfunc F;
	N = marfmsp1smul( p, M, F );
	p ist eine Primzahl.
	M ist eine mxn-Matrix von rationalen Funktionen in einer Variablen
	ueber Z/pZ. F ist eine rationale Funktion in einer Variablen ueber
	Z/pZ.
	Berechnet wird das Skalarprodukt F * M.



			marfmsp1ssle( p, A, b, pX, pN )

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, solution of a system of linear equations"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single marfmsp1ssle(p,A,b,pX,pN)  single p; matrix A; vec b,*pX;
		list *pN;
	z = marfmsp1ssle(p,A,b,pX,pN);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - A ist eine mxn-Matrix ueber Z/pZ(X).
		Mindestens ein Eintrag von A muss != 0 sein.
	      - b ist ein Vektor der Laenge m ueber Z/pZ(X).
	Geloest wird das Gleichungssytem (*) A * x = b.
	Ist (*) eindeutig loesbar, so ist z=0, *pX ist der Loesungsvektor,
	und *pN ist die leere Liste.
	Ist (*) unloesbar, so ist z = -1, *pX und *pN sind die leere Liste.
	Ist (*) mehrdeutig loesbar, so ist *pX eine spezielle Loesung,
	z ist die Dimension des Nullraums von A, und *pN ist eine Liste 
	der Nullraum-Basis-Vektoren.



			marfmsp1sum( p, M, N )          (MACRO)

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, sum"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfmsp1sum(p,M,N)  single p; matrix M,N;
	L = marfmsp1sum(p,M,N);
	p ist eine Primzahl.
	M und N sind Matrizen gleicher Dimension von rationalen Funktionen
	in einer Variablen ueber Z/pZ.
	L = M + N.



			marfmsp1vmul( p, A, x )         (MACRO)

	"matrix of rational functions over modular single primes,
	 transcendence degree 1, vector multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec marfmsp1vmul(p, A, x)  single p; matrix A; vec x;
	y = marfmsp1vmul (p, A, x)
	p ist eine Primzahl.
	A ist eine mxn - Matrix ueber den rationalen Funktionen in einer
	Variablen ueber Z/pZ.
	x ist ein Vektor der Laenge n ueber den rationalen Funktionen in
	einer Variablen ueber Z/pZ.
	y = A * x ist ein Vektor der Laenge m.



			marfrchpol( r, M )

	"matrix of rational functions over rationals characteristic
	 polynomial"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	rfunc marfrchpol(r,M)  single r; matrix M;
	f = marfrchpol(r,M);
	M ist eine quadratische Matrix von rationalen Funktionen in r
	Variablen X1,...,Xr ueber den rationalen Zahlen.
	f ist das charakteristische Polynom von M:
	f(X) = det( M - X * E ), E Einheitsmatrix.
	f ist eine rationale Funktion in den r+1 Variablen X1,...,Xr,X.



			marfrcons1( r, n )              (MACRO)

	"matrix of rational functions over rationals construction 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfrcons1(r,n)  single r,n;
	E = marfrcons1(r,n);
	r und n sind ganze Zahlen, 0<=r<BASIS, 1<=n<BASIS.
	E ist die n-dimensionale Einheitsmatrix, d.h.
	E = ( dij ) i,j = 1..n mit dij = 1, falls i=j, 0 sonst.
	dij sind rationale Funktionen in r Variablen ueber den rationalen
	Zahlen.



			marfrdet( r, M )

	"matrix of rational functions over rationals determinant"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	rfunc marfrdet(r,M)  single r; matrix M;
	P = marfrdet(r,M);
	M ist eine quadratische Matrix von rationalen Funktionen in r
	(0<=r<BASIS) Variablen ueber den rationalen Zahlen.
	P ist die Determinante von M, also eine rationale Funktion in
	r Variablen.



			marfrdif( r, M, N )             (MACRO)

	"matrix of rational functions over rationals difference"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfrdif(r,M,N)  single r; matrix M,N;
	L = marfrdif(r,M,N);
	M und N sind Matrizen gleicher Dimension von rationalen Funktionen
	in r (0<=r<BASIS) Variablen ueber den rationalen Zahlen.
	L = M - N.



			marfrexp( r, M, n )

	"matrix of rational functions over rationals exponentiation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfrexp(r,M,n)  single r; matrix M; single n;
	X = marfrexp(r,M,n);
	M ist eine quadratische Matrix von rationalen Funktionen in r
	(0<=r<BASIS) Variablen ueber den rationalen Zahlen.
	Im Falle n<0 muss M invertierbar sein, also Det(M)<>0.
	X = M^n.



			marfrinv( r, M )

	"matrix of rational functions over rationals inverse"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfrinv(r,M)  single r; matrix M;
	N = marfrinv(r,M);
	M ist eine quadratische, invertierbare Matrix ueber dem Koerper
	der rationalen Funktionen in r (0<=r<BASIS) Variablen ueber Q.
	!! also Det(M) != 0 und aus Q(X) !!
	N = M ^ -1.



			marfrneg( r, M )                (MACRO)

	"matrix of rational functions over rationals negation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfrneg(r,M)  single r; matrix M;
	N = marfrneg(r,M);
	M ist eine Matrix von rationalen Funktionen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen.
	N = -M.



			marfrnsb( r, M )

	"matrix of rational functions over rationals, null space basis"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	list marfrnsb(r,M)  single r; matrix M;
	L = marfrnsb(r,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - M ist eine (n,n) - Matrix mit Elementen aus Q(X) in r
		Variablen, 1 <= n < BASIS.
	L = ( L1, ..., Lr ) ist eine Liste von Vektoren, die eine Basis des
	Nullraums von M bilden, also M * Li = 0 fuer alle i = 1, ..., r.
	Jeder Vektor Li ist eine Liste der Laenge n.
!!!     Die Matrix M wird veraendert.



			marfrprod( r, M, N )            (MACRO)

	"matrix of rational functions over rationals product"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfrprod(r,M,N)  single r; matrix M,N;
	L = marfrprod(r,M,N);
	M und N sind Matrizen von rationalen Funktionen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen.
	M ist eine mxn-Matrix, N ist eine nxl-Matrix mit l,m,n >= 1.
	L = M * N.



			marfrrk( r, M )

	"matrix of rational functions over rationals rank"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single marfrrk(r,M)  single r; matrix M;
	rang = marfrrk(r,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - M ist eine beliebige Matrix ueber Q(X) in r Variablen.
	Mit Hilfe des Gausschen Algorithmus wird der Rang von M berechnet.



			marfrsmul( r, M, F )

	"matrix of rational functions over rationals scalar multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfrsmul( r, M, F )  single r; matrix M; rfunc F;
	N = marfrsmul( r, M, F );
	M ist eine Matrix von rationalen Funktionen in r (0<=r<BASIS)
	Variablen ueber Q. F ist eine rationale Funktion in r Variablen
	ueber Q.
	Berechnet wird das Skalarprodukt F * M.



			marfrssle( r, A, b, pX, pN )

	"matrix of rational functions over rationals solution of a system 
	 of linear equations"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single marfrssle(r,A,b,pX,pN)  single r; matrix A; vec b, *pX;
	       list *pN;
	z = marfrssle(r,A,b,pX,pN);
	A ist eine mxn-Matrix ueber R = Menge der rationalen Funktionen in
	r ( 0<=r<BASIS ) Variablen ueber Q.
	Mindestens ein Eintrag von A muss != 0 sein.
	b ist ein Vektor der Laenge m ueber R.
	Geloest wird das Gleichungssytem (*) A * x = b.
	Ist (*) eindeutig loesbar, so ist z=0, *pX ist der Loesungsvektor,
	und *pN ist die leere Liste.
	Ist (*) unloesbar, so ist z=-1, *pX und *pN sind die leere Liste.
	Ist (*) mehrdeutig loesbar, so ist *pX eine spezielle Loesung,
	z ist die Dimension des Nullraums von A, und *pN ist eine Liste 
	der Nullraum-Basis-Vektoren.



			marfrsum( r, M, N )             (MACRO)

	"matrix of rational functions over rationals sum"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mrfrsum(r,M,N)  single r; matrix M,N;
	L = marfrsum(r,M,N);
	M und N sind Matrizen gleicher Dimension von rationalen Funktionen
	in r (0<=r<BASIS) Variablen ueber den rationalen Zahlen.
	L = M + N.



			marfrtransf( r1, M1, V1, r2, R2, V2, Vn, pV3 )

	"matrix of rational functions over the rationals transformation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix marfrtransf(r1,M1,V1,r2,R2,V2,Vn,pV3)  single r1; matrix M1;
		list V1; single r2; rfunc R2; list V2, Vn, *pV3;
	M3 = marfrtransf(r1,M1,V1,r2,R2,V2,Vn,pV3);
	M1 ist eine Matrix von rationalen Funktionen in r1 (1<=r1<BASIS)
	Variablen ueber Q; V1 ist die zugehoerige Variablenliste.
	R2 ist eine rationale Funktion in r2 (0<=r2<BASIS) Variablen
	ueber Q; V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	M3 ist die Matrix, die entsteht, wenn in M1 die Variable
	Vn durch die rationale Funktion R2 ersetzt wird, und
	die zugehoerige, in *pV3 abgelegte Variablenliste alphabetisch
	sortiert ist. (Die in *pV3 abgelegte Variablenliste ist die
	Vereinigung von V1 und V2.)
	Warnung ! Ergibt die Transformation von Vn im Nenner eines Ma-
	--------- trixelementes Null, so wird -BASIS-1 zurueckgegeben.



			marfrvecmul( r, A, x )          (MACRO)

	"matrix of rational functions over rationals vector multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec marfrvecmul(r, A, x)  single r; matrix A; vec x;
	y = marfrvecmul(r, A, x)
	A ist eine mxn - Matrix ueber R = Menge der rationalen Funktionen
	in r (0<=r<BASIS) Variablen ueber Q.
	x ist ein Vektor der Laenge n mit Elementen aus R.
	y = A * x ist ein Vektor der Laenge m.



			marinv( M )

	"matrix of rationals inverse"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix marinv(M) matrix M;
	N = marinv(M);
	M ist eine quadratische, invertierbare Matrix ueber Q,
	!! also Det(M) != 0 und aus Q ( da Q Koerper ) !!
	N = M ^ -1.



			marneg( M )                     (MACRO)

	"matrix of rationals negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix marneg(M) matrix M;
	N = marneg(M);
	N = -M.



			marnsb( M )

	"matrix of rationals null space basis"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	list marnsb(M)  matrix M;
	L = marnsb(M);
	Dabei muss gelten:
	      - M ist eine nxn - Matrix mit Komponenten aus Q, n< BASIS.
	L = (L1,...,Lr) ist eine Liste von Vektoren, die eine Basis des
	Nullraums von M bilden, also M * Li = 0 fuer alle i = 1,...,r.
	Jeder Vektor Li ist eine Liste der Laenge n.
!!!     Die Matrix M wird veraendert.



			marprod( M, N )                 (MACRO)

	"matrix of rationals product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix marprod(M,N) matrix M,N;
	L = marprod(M,N);
	M und N sind Matrizen von rationalen Zahlen.
	M ist eine mxn-Matrix, N ist eine nxl-Matrix mit l,m,n >= 1.
	L = M * N.



			marrk( M )

	"matrix of rationals rank"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single marrk(M)  matrix M;
	r = marrk(M);
	Dabei muss gelten:
	      - M ist eine beliebige Matrix ueber Q.
	Mit Hilfe des Algorithmus von Gauss wird der Rang von M berechnet.



			marsmul( M, el )

	"matrix of rationals scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix marsmul( M, el )  matrix M; rat el;
	N = marsmul( M, el );
	M ist eine Matrix ueber Q.
	Berechnet wird das Skalarprodukt el * M.



			marssle( A, b, pX, pN )

	"matrix of rationals solution of a system of linear equations"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single marssle(A,b,pX,pN)  matrix A; vec b, *pX; list *pN;
	z = marssle(A,b,pX,pN);
	A ist eine mxn-Matrix ueber Q. Mindestens ein Eintrag
	von A muss != 0 sein.
	b ist ein Vektor der Laenge m ueber Q.
	Geloest wird das Gleichungssytem (*) A * x = b.
	Ist (*) eindeutig loesbar, so ist z=0, *pX ist der Loesungsvektor,
	und *pN ist die leere Liste.
	Ist (*) unloesbar, so ist z=-1, *pX und *pN sind die leere Liste.
	Ist (*) mehrdeutig loesbar, so ist *pX eine spezielle Loesung,
	z ist die Dimension des Nullraums von A, und *pN ist eine Liste 
	der Nullraum-Basis-Vektoren.



			marsum( M, N )                  (MACRO)

	"matrix of rationals sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix marsum(M,N) matrix M,N;
	L = marsum(M,N);
	M und N sind Matrizen von rationalen Zahlen gleicher Dimension.
	L = M + N.



			martomami( m, M )

	"matrix of rationals to matrix of modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix martomami(m,M)  int m; matrix M;
	L = martomami(m,M);
	m ist positiv.
	Die Matrix M von rationalen Zahlen wird in die Matrix L von
	Zahlen aus Z/mZ umgewandelt, d.h. jeder Eintrag von M wird
	modulo m reduziert. Falls der ggT des Nenners eines Matrix-
	elements und m ungleich 1 ist, so wird ERROR zurueckgegeben.



			martomanf( M )

	"matrix of rationals to matrix of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix martomanf(M)  matrix M;
	L = martomanf(M);
	Dabei muss gelten:
	      - M ist eine Matrix von rationalen Zahlen.
	Die Matrix M ueber Q wird in die Matrix L von Elementen eines
	Zahlkoerpers umgewandelt.
	( siehe auch: rtonf )



			martomanfs( M )

	"matrix of rationals to matrix of number field elements, sparse
	 representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix martomanfs(M)  matrix M;
	L = martomanfs(M);
	Dabei muss gelten:
	      - M ist eine Matrix von rationalen Zahlen.
	Die Matrix M ueber Q wird in die Matrix L von Elementen eines
	Zahlkoerpers, in sparse-Darstellung, umgewandelt.
	( siehe auch: rtonfs )



			martomapr( r, M )

	"matrix of rationals to matrix of polynomials over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix martomapr(r,M) single r; matrix M;
	L = martomapr(r,M);
	Die Matrix von rationalen Zahlen M wird in die Matrix von
	Polynomen in r Variablen ueber den rationalen Zahlen L umgewandelt.



			marvecmul( A, x )               (MACRO)

	"matrix of rationals vector multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec marvecmul (A, x) matrix A; vec x;
	y = marvecmul (A, x)
	A ist eine mxn -Matrix ueber Q.
	x ist ein Vektor der Laenge n mit Elementen aus Q.
	y = A * x ist ein Vektor der Laenge m.



			maselel( M, m, n )              (MACRO)

	"matrix select element"
	Quellbibliothek: srclib.matr1
	Includedatei:    _matr1.h
	obj maselel (M,m,n) matrix M; single m, n;
	a = maselel (M, m, n)
	M ist eine kxl-Matrix ueber einem Ring R.
	m, n aus Z, 1<=m<=k, 1<=n<=l.
	a = M(m,n).



			masetel( M, m, n, el )          (MACRO)

	"matrix set element"
	Quellbibliothek: srclib.matr1
	Includedatei:    _matr1.h
	masetel (M,m,n,el) matrix M; single m, n; obj el;
	a = masetel (M, m, n, el)
	M ist ein kxl-Matrix ueber einem Ring R.
	m, n aus Z, 1<=m<=k, 1<=n<=l.
	el ist ein Element aus R.
	In M wird das Element M(m,n) veraendert zu el, d.h.
	gilt vor dem Aufruf M=(M(i,j)) i=1..k, j=1..l, so gilt nach
	dem Aufruf: M(m,n) = el.
	M wird veraendert.



			masrand( m, n, grenze )

	"matrix of singles randomize"
	Quellbibliothek: srclib.matr1
	Includedatei:    _matr1.h
	masrand (m,n,grenze)  single m,n,grenze;
	M = masrand (m,n,grenze);
	m, n und grenze sind positiv.
	Es wird eine mxn-Matrix mit zufaelligen Eintraegen erzeugt,
	wobei fuer alle Eintraege aij gilt: 0<=aij<=grenze fuer
	1<=i<=m, 1<=j<=n.



			masum( M, N, sum, anzahlargs, arg1, arg2 )

	"matrix sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix masum(M,N,sum,anzahlargs,arg1,arg2)
	       matrix M,N; obj (*sum)(); single anzahlargs; obj arg1,arg2;
	L = masum(M,N,sum,anzahlargs,arg1,arg2);
	M und N sind Matrizen gleicher Dimension ueber einem Ring R.
	sum ist die Additions-Funktion dieses Ringes.
	sum benoetigt ausser 2 Elementen aus R noch anzahlargs Argumente;
	arg1 und arg2 (maximal) sind diese Argumente.
	L = M + N.
	siehe auch maisum, marsum, mamssum, ...



			masumspec( M, N, sum, anzahlargs, arg1, ..., arg5 )

	"matrix sum special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix masumspec(M,N,sum,anzahlargs,arg1,...,arg5)
	       matrix M,N; obj (*sum)(); single anzahlargs;
	       obj arg1,...,arg5;
	L = masumspec(M,N,sum,anzahlargs,arg1,...,arg5);
	Dabei muss gelten:
	      - M und N sind Matrizen gleicher Dimension ueber einem
		Ring R.
	      - sum ist die Additions - Funktion dieses Ringes.
	      - sum benoetigt ausser 2 Elementen aus R noch anzahlargs
		Argumente; arg1, ..., arg5 (maximal) sind diese Argumente.
	L = M + N.
	siehe auch mapgfssum.



			matransp( M )

	"matrix transpose"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix matransp(M)  matrix M;
	T = matransp( M );
	T ist die transponierte Matrix zu M. M wird zerstoert.



			maudprtomnf( M )

	"matrix of univariate dense polynomials over rationals to matrix of
	 number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maudprtomnf(M)  matrix M;
	L = maudprtomnf(M);
	Dabei muss gelten:
	      - M ist eine Matrix von Polynomen in einer Variablen ueber Q.
	Die Matrix M von Polynomen in einer Variablen ueber Q, in dense-
	Darstellung, wird in die Matrix L von Elementen eines Zahlkoerpers
	umgewandelt.
	( siehe auch: udprtonfel )



			maupmipedfcf( p, M, pA, pB )

	"matrix of univariate polynomials over modular integer primes
         elementary divisor form and cofactors"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maupmipedfcf(p,M,pA,pB)  int p; matrix M,*pA,*pB;
	N = maupmipedfcf(p,M,pA,pB);
	p ist eine Primzahl.
	M ist eine Matrix ueber Polynomen in einer Variablen ueber Z/pZ. 
	M ist nicht die Nullmatrix.
        N ist die Elementarteilerform von M.
	Es gilt: N = (*pA) * M * (*pB), mit *pA, *pB unimodular.
	N = (
	( d1  0 ..           0 )
	( 0   d2 0 ..        0 )
	( ..                   )
	( 0 ..   0 dr 0 ..   0 )
	( 0 ..   0 0  0 ..   0 )
	( ..                   )
	( 0 ..               0 )
	), wobei di teilt d(i+1) fuer i=1..r-1.



			maupmipegsc( p, M, A, B )

	"matrix of univariate polynomials over modular integer primes
         Euklid- Gauss- step for columns"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single maupmipegsc(p,M,A,B)  int p; matrix M,A,B;
	a = maupmipegsc(p,M,A,B);
        p ist eine Primzahl.
	M, A und B sind Matrizen ueber dem Polynomring in einer Variablen
	ueber Z/pZ. M ist mxn-Matrix, A ist mxm-Matrix, B ist nxn-Matrix.
	Auf M wird ein Euklid-Gauss-Schritt nach E. Lamprecht, Lineare
	Algebra, Lemma 1.1 (fuer Spalten) angewandt.
	M, A und B werden veraendert.
	Ist M(alt) = (
	(a11 a12 .. a1n)
		*
	),
	mit a1i != 0 fuer ein i, so ist M(neu) = (
	( ggT(a11, .. ,a1n) 0 .. 0 )
		  **
	).
	Sind alle a1i = 0, so wird die Zeile niedrigster Nummer, die ein
	Element != 0 enthaelt, mit der ersten Zeile vertauscht und
	maupmipegsc auf diese Matrix angewandt.
	Sind alle Eintraege von M = 0, so wird nichts veraendert.
	a = 1, falls M nur noch 0-Eintraege enthaelt, 0 sonst.
	Die Zeilenumformungen in M werden auf die Zeilen von A angewandt,
	die Spaltenumformungen in M werden auf die Zeilen von B angewandt.
	maupmipegsc wird von _maupmipegs (static-Modul von maupmiedfcf) 
	aufgerufen, von wo aus der Euklid-Gauss-Algorithmus gesteuert wird. 
	Am Anfang ist A mxm- und B nxn- Matrix. 
	Am Ende gilt: N=A*M*(B)T hat Elementarteilerform.
	Beim rekursiven Anwenden des Algorithmus auf die Untermatrizen
	von M werden bei jedem Aufruf von _maupmipegs A und B um eine Zeile
	verkleinert uebergeben, da die im naechsten Schritt notwendigen
	Umformungen nur auf diese Zeilen zugreifen.



			maupmipegsr( p, M, A, B )

	"matrix of univariate polynomials over modular integer primes
         Euklid- Gauss- step for rows"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single maupmipegsr(p,M,A,B)  int p; matrix M,A,B;
	a = maupmipegsr(p,M,A,B);
	p ist eine Primzahl.
	M, A und B sind Matrizen ueber dem Polynomring in einer Variablen
	ueber Z/pZ. M ist mxn-Matrix, A ist mxm-Matrix, B ist nxn-Matrix.
	Auf M wird ein Euklid-Gauss-Schritt nach E. Lamprecht, Lineare
	Algebra, Lemma 1.1 (fuer Zeilen) angewandt.
	M, A und B werden veraendert.
	Ist M(alt) = (
	(a11     *     )
	 ..
	(am1     *     )
	),
	mit ai1 != 0 fuer ein i, so ist M(neu) = (
	( ggT(a11, .. ,am1)   **   )
	( 0       **               )
	..
	( 0       **               )
	).
	Sind alle ai1 = 0, so wird die Spalte niedrigster Nummer, die ein
	Element != 0 enthaelt, mit der ersten Spalte vertauscht und
	maupmipegsr auf diese Matrix angewandt.
	Sind alle Eintraege von M = 0, so wird nichts veraendert.
	a = 1, falls M nur noch 0-Eintraege enthaelt, 0 sonst.
	Die Zeilenumformungen in M werden auf die Zeilen von A angewandt,
	die Spaltenumformungen in M werden auf die Zeilen von B angewandt.
	maupmipegsr wird von _maupmipegs (static-Modul von maupmiedfcf) 
	aufgerufen, von wo aus der Euklid-Gauss-Algorithmus gesteuert wird. 
	Am Anfang ist A mxm- und B nxn- Matrix. 
	Am Ende gilt: N=A*M*(B)T hat Elementarteilerform.
	Beim rekursiven Anwenden des Algorithmus auf die Untermatrizen
	von M werden bei jedem Aufruf von _maupmipegs A und B um eine Zeile
	verkleinert uebergeben, da die im naechsten Schritt notwendigen
	Umformungen nur auf diese Zeilen zugreifen.



			maupmshermsp( p, M, r, pD )

	"matrix of univariate polynomials over modular single primes
	hermitian reduction, special"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maupmshermsp(p,M,r,pD)  single p,r; matrix M; pol *pD;
	Mred = maupmshermsp(p,M,r,pD);
	Sei x eine Variable ueber Z/pZ, wobei p eine single Primzahl ist.
	M ist eine m x r Matrix mit Polynomen in x ueber Z/pZ als
	Eintraegen und m >= r. Der Rang von M ist ebenfalls gleich r.
	Mred ist eine r x r obere Dreiecksmatrix ueber (Z/pZ) [x],
	deren Zeilen eine (Z/pZ) [x] - Basis des durch die Zeilen von M
	ueber (Z/pZ) [x] erzeugten Moduls bilden.
	Mred ist in Hermite - Normalform, d.h. die Hauptdiagonalelemente
	sind normiert und die Elemente einer Spalte haben einen Grad der
	kleiner gleich dem Grad des Hauptdiagonalelements dieser Spalte
	ist. *pD ist der Wert der Determinante von Mred also ein Element
	aus (Z/pZ) [x].
	Ist der Rang von M kleiner als r, so wird ERROR als Ersatzwert
	uebergeben.



			maupmspedfcf( p, M, pA, pB )

	"matrix of univariate polynomials over modular single primes
         elementary divisor form and cofactors"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maupmspedfcf(p,M,pA,pB)  single p; matrix M,*pA,*pB;
	N = maupmspedfcf(p,M,pA,pB);
	p ist eine Primzahl.
	M ist eine Matrix ueber dem Polynomring in einer Variablen ueber
	Z/pZ. M ist nicht die Nullmatrix.
        N ist die Elementarteilerform von M.
	Es gilt: N = (*pA) * M * (*pB), mit *pA, *pB unimodular.
	N = (
	( d1  0 ..           0 )
	( 0   d2 0 ..        0 )
	( ..                   )
	( 0 ..   0 dr 0 ..   0 )
	( 0 ..   0 0  0 ..   0 )
	( ..                   )
	( 0 ..               0 )
	), wobei di teilt d(i+1) fuer i=1..r-1.



			maupmspegsc( p, M, A, B )

	"matrix of univariate polynomials over modular single primes
         Euklid- Gauss- step for columns"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single maupmspegsc(p,M,A,B)  single p; matrix M,A,B;
	a = maupmspegsc(p,M,A,B);
        p ist eine Primzahl.
	M, A und B sind Matrizen ueber Polynomen in einer Variablen ueber 
        Z/pZ. M ist mxn-Matrix, A ist mxm-Matrix, B ist nxn-Matrix.
	Auf M wird ein Euklid-Gauss-Schritt nach E. Lamprecht, Lineare
	Algebra, Lemma 1.1 (fuer Spalten) angewandt.
	M, A und B werden veraendert.
	Ist M(alt) = (
	(a11 a12 .. a1n)
		*
	),
	mit a1i != 0 fuer ein i, so ist M(neu) = (
	( ggT(a11, .. ,a1n) 0 .. 0 )
		  **
	).
	Sind alle a1i = 0, so wird die Zeile niedrigster Nummer, die ein
	Element != 0 enthaelt, mit der ersten Zeile vertauscht und
	maupmspegsc auf diese Matrix angewandt.
	Sind alle Eintraege von M = 0, so wird nichts veraendert.
	a = 1, falls M nur noch 0-Eintraege enthaelt, 0 sonst.
	Die Zeilenumformungen in M werden auf die Zeilen von A angewandt,
	die Spaltenumformungen in M werden auf die Zeilen von B angewandt.
	maupmspegsc wird von _maupmspegs (static-Modul von maupmsedfcf) 
	aufgerufen, von wo aus der Euklid-Gauss-Algorithmus gesteuert wird. 
	Am Anfang ist A mxm- und B nxn- Matrix. 
	Am Ende gilt: N=A*M*(B)T hat Elementarteilerform.
	Beim rekursiven Anwenden des Algorithmus auf die Untermatrizen
	von M werden bei jedem Aufruf von _maupmspegs A und B um eine Zeile
	verkleinert uebergeben, da die im naechsten Schritt notwendigen
	Umformungen nur auf diese Zeilen zugreifen.



			maupmspegsr( p, M, A, B )

	"matrix of univariate polynomials over modular single primes
         Euklid- Gauss- step for rows"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single maupmspegsr(p,M,A,B)  single p; matrix M,A,B;
	a = maupmspegsr(p,M,A,B);
	p ist eine Primzahl.
	M, A und B sind Matrizen ueber Polynomen in einer Variablen ueber
        Z/pZ. M ist mxn-Matrix, A ist mxm-Matrix, B ist nxn-Matrix.
	Auf M wird ein Euklid-Gauss-Schritt nach E. Lamprecht, Lineare
	Algebra, Lemma 1.1 (fuer Zeilen) angewandt.
	M, A und B werden veraendert.
	Ist M(alt) = (
	(a11     *     )
	 ..
	(am1     *     )
	),
	mit ai1 != 0 fuer ein i, so ist M(neu) = (
	( ggT(a11, .. ,am1)   **   )
	( 0       **               )
	..
	( 0       **               )
	).
	Sind alle ai1 = 0, so wird die Spalte niedrigster Nummer, die ein
	Element != 0 enthaelt, mit der ersten Spalte vertauscht und
	maupmspegsr auf diese Matrix angewandt.
	Sind alle Eintraege von M = 0, so wird nichts veraendert.
	a = 1, falls M nur noch 0-Eintraege enthaelt, 0 sonst.
	Die Zeilenumformungen in M werden auf die Zeilen von A angewandt,
	die Spaltenumformungen in M werden auf die Zeilen von B angewandt.
	maupmspegsr wird von _maupmspegs (static-Modul von maupmsedfcf) 
	aufgerufen, von wo aus der Euklid-Gauss-Algorithmus gesteuert wird. 
	Am Anfang ist A mxm- und B nxn- Matrix. 
	Am Ende gilt: N=A*M*(B)T hat Elementarteilerform.
	Beim rekursiven Anwenden des Algorithmus auf die Untermatrizen
	von M werden bei jedem Aufruf von _maupmspegs A und B um eine Zeile
	verkleinert uebergeben, da die im naechsten Schritt notwendigen
	Umformungen nur auf diese Zeilen zugreifen.



			maupredfcf( M, pA, pB )

	"matrix of univariate polynomials over rationals elementary divisor
	 form and cofactors"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	matrix maupredfcf(M,pA,pB)  matrix M,*pA,*pB;
	N = maupredfcf(M,pA,pB);
	M ist eine Matrix ueber rationalen Polynomen in einer Variablen, 
	M != 0.
	N ist die Elementarteilerform von M.
	Es gilt: N = (*pA) * M * (*pB), mit *pA, *pB unimodular.
	N = (
	( d1  0 ..           0 )
	( 0   d2 0 ..        0 )
	( ..                   )
	( 0 ..   0 dr 0 ..   0 )
	( 0 ..   0 0  0 ..   0 )
	( ..                   )
	( 0 ..               0 )
	), wobei di teilt d(i+1) fuer i=1..r-1.



			maupregsc( M, A, B )

	"matrix of univariate polynomials over rationals Euklid- Gauss- 
	 step for columns"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single maupregsc(M,A,B)  matrix M,A,B;
	a = maupregsc(M,A,B);
	M, A und B sind Matrizen ueber rationalen Polynomen in einer 
	Variablen. M ist mxn-Matrix, A ist mxm-Matrix, B ist nxn-Matrix.
	Auf M wird ein Euklid-Gauss-Schritt nach E. Lamprecht, Lineare
	Algebra, Lemma 1.1 (fuer Spalten) angewandt.
	M, A und B werden veraendert.
	Ist M(alt) = (
	(a11 a12 .. a1n)
		*
	),
	mit a1i != 0 fuer ein i, so ist M(neu) = (
	( ggT(a11, .. ,a1n) 0 .. 0 )
		  **
	).
	Sind alle a1i = 0, so wird die Zeile niedrigster Nummer, die ein
	Element != 0 enthaelt, mit der ersten Zeile vertauscht und
	maupregsc auf diese Matrix angewandt.
	Sind alle Eintraege von M = 0, so wird nichts veraendert.
	a = 1, falls M nur noch 0-Eintraege enthaelt, 0 sonst.
	Die Zeilenumformungen in M werden auf die Zeilen von A angewandt,
	die Spaltenumformungen in M werden auf die Zeilen von B angewandt.
	maupregsc wird von _maupregs (static-Modul von maupredfcf) 
	aufgerufen, von wo aus der Euklid-Gauss-Algorithmus gesteuert wird. 
	Am Anfang ist A mxm- und B nxn- Matrix. Am Ende gilt: N=A*M*(B)T 
	hat Elementarteilerform.
	Beim rekursiven Anwenden des Algorithmus auf die Untermatrizen
	von M werden bei jedem Aufruf von _maupregs A und B um eine Zeile
	verkleinert uebergeben, da die im naechsten Schritt notwendigen
	Umformungen nur auf diese Zeilen zugreifen.



			maupregsr( M, A, B )

	"matrix of univariate polynomials over rationals Euklid- Gauss- 
	 step for rows"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single maupregsr(M,A,B)  matrix M,A,B;
	a = maupregsr(M,A,B);
	M, A und B sind Matrizen ueber rationalen Polynomen in einer 
	Variablen. M ist mxn-Matrix, A ist mxm-Matrix, B ist nxn-Matrix.
	Auf M wird ein Euklid-Gauss-Schritt nach E. Lamprecht, Lineare
	Algebra, Lemma 1.1 (fuer Zeilen) angewandt.
	M, A und B werden veraendert.
	Ist M(alt) = (
	(a11     *     )
	 ..
	(am1     *     )
	),
	mit ai1 != 0 fuer ein i, so ist M(neu) = (
	( ggT(a11, .. ,am1)   **   )
	( 0       **               )
	..
	( 0       **               )
	).
	Sind alle ai1 = 0, so wird die Spalte niedrigster Nummer, die ein
	Element != 0 enthaelt, mit der ersten Spalte vertauscht und
	maupregsr auf diese Matrix angewandt.
	Sind alle Eintraege von M = 0, so wird nichts veraendert.
	a = 1, falls M nur noch 0-Eintraege enthaelt, 0 sonst.
	Die Zeilenumformungen in M werden auf die Zeilen von A angewandt,
	die Spaltenumformungen in M werden auf die Zeilen von B angewandt.
	maupregsr wird von _maupregs (static-Modul von maupredfcf) 
	aufgerufen, von wo aus der Euklid-Gauss-Algorithmus gesteuert wird. 
	Am Anfang ist A mxm- und B nxn- Matrix. Am Ende gilt: N=A*M*(B)T 
	hat Elementarteilerform.
	Beim rekursiven Anwenden des Algorithmus auf die Untermatrizen
	von M werden bei jedem Aufruf von _maupregs A und B um eine Zeile
	verkleinert uebergeben, da die im naechsten Schritt notwendigen
	Umformungen nur auf diese Zeilen zugreifen.



			mavecmul( A, x, prod, sum, anzahlargs, arg1, arg2 )

	"matrix vector multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec mavecmul(A,x,prod,sum,anzahlargs,arg1,arg2)
	    matrix A; vec x; obj (*prod)(),(*sum)(); single anzahlargs;
	    obj arg1,arg2;
	y = mavecmul(A,x,prod,sum,anzahlargs,arg1,arg2);
	A ist eine mxn - Matrix ueber einem Ring R.
	x ist ein Vektor der Laenge n mit Elementen aus R.
	sum und prod sind die Additions- bzw. die Multiplikations-
	funktionen des Ringes R.
	sum und prod benoetigen ausser 2 Elementen aus R noch anzahlargs
	Argumente; arg1 und arg2 (maximal) sind diese Argumente.
	y = A * x ist ein Vektor der Laenge m.
	siehe auch maivecmul, marvecmul, mamsvecmul, ...



			mavmulspec( A, x, prod, sum, anzahlargs, arg1, ..., arg5 )

	"matrix vector multiplication special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec mavmulspec(A,x,prod,sum,anzahlargs,arg1,...,arg5)
	    matrix A; vec x; obj (*prod)(),(*sum)(); single anzahlargs;
	    obj arg1,...,arg5;
	y = mavmulspec(A,x,prod,sum,anzahlargs,arg1,..,arg5);
	Dabei muss gelten:
	      - A ist eine mxn-Matrix ueber einem Ring R.
	      - x ist ein Vektor der Laenge n mit Elementen aus R.
	      - sum ist die Additions - Funktion, und
	      - prod ist die Multiplikations - Funktion des Ringes R.
	      - sum und prod benoetigen ausser 2 Elementen aus R noch
		anzahlargs Argumente; arg1, ..., arg5 (maximal) sind
		diese Argumente.
	y = A * x, wobei y ein Vektor der Laenge m ist.
	siehe auch mapgfsvmul



			mavpermut( r, M, PI )

	"matrix of polynomials variable permutation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mavpermut(r,M,PI)  single r; matrix M; list PI;
	M1 = mavpermut(r,M,PI);
	M ist eine Matrix von Polynomen in r (0<=r<BASIS) Variablen
	X1,...,Xr.
	Fuer r>0 ist PI eine Liste, die eine Permutation der Zahlen
	1,...,r enthaelt, d.h.  PI = ( pi(1) ,..., pi(r) )
	mit  1<=pi(i)<=r  fuer 1<=i<=r
	und  pi(i) != pi(j)  fuer i!=j.
	Im Fall r=0 ist PI die leere Liste.
	M1 = M, wobei fuer r>0 die Reihenfolge der Variablen X1,...,Xr
	so wie in PI angegeben permutiert wurde.



			mpgfstompmp( r, p, AL, P, M )

	"matrix of polynomials over Galois-field with single  
	 characteristic to matrix of polynomials modulo polynomial over 
	 Galois-field with single characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mpgfstompmp(r, p, AL, P, M)  single r,p; list AL; pol P; 
		matrix M;
	N = mpgfstompmp(r, p, AL, P, M);
	M ist eine Matrix bestehend aus Polynomen in r (r >= 0) 
	Variablen ueber GF(p^n) (p Primzahl).
	P ist ein Polynom in r Variablen ueber GF(p^n).
	AL = ( G, AL1 ) kann als Arithmetikliste fuer GF(p^n) 
	interpretiert werden (vgl. gfsalgen), wobei n = llength(AL1)+1.
	G  ist ein irreduzibles, normiertes Polynom in einer Variablen 
	ueber Z/pZ vom Grad n >= 1.
	N ist die Matrix bestehend aus den Polynomen von M, reduziert
	modulo P.



			mpmstmrfmsp1( p, M )

	"matrix of polynomials over modular singles to matrix of rational
	 functions over modular single primes, transcendence degree 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mpmstmrfmsp1(p, M)  single p; matrix M;
	L = mpmstmrfmsp1(p, M);
	p ist eine Primzahl.
	Die Matrix M von Polynomen ueber Z/pZ in einer Variablen wird in
	die Matrix L von rationalen Funktionen in einer Variablen ueber
	Z/pZ umgewandelt.



			mpmstompgfs( r, p, M )

	"matrix of polynomials over modular singles to matrix of
	 polynomials over Galois-field with single characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	matrix mpmstompgfs(r,p,M)  single r,p; matrix M;
	L = mpmstompgfs(r,p,M);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - M ist eine Matrix von Polynomen in r Variablen ueber Z/pZ.
	Dann gilt fuer eine beliebige natuerliche Zahl n aus [1,(BASIS-1)]:
	L = M (aufgefasst als Matrix ueber GF(p^n)).
	Das heisst, die Basiskoeffizienten der (Matrix-)Polynome werden von
	Z/pZ nach GF(p^n) eingebettet.
	( siehe auch: pmstopgfs )



			mudpitmudpr( M )

	"matrix of univariate dense polynomials over integers to matrix of
	 univariate dense polynomials over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mudpitmudpr(M)  matrix M;
	L = mudpitmudpr(M);
	Dabei muss gelten:
	      - M ist eine Matrix von Polynomen in einer Variablen ueber Z
		in dense-Darstellung.
	M wird in die Matrix L von Polynomen in einer Variablen ueber Q in
	dense-Darstellung umgewandelt.
	(siehe auch: udpitoudpr)



			mudpitudpmi( M, m )

	"matrix of univariate dense polynomials over integers to matrix of
	 univariate dense polynomials over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	matrix mudpitudpmi(M,m)  matrix M; int m;
	L = mudpitudpmi(M,m);
	Dabei muss gelten:
	      - M ist eine Matrix von Polynomen in einer Variablen ueber Z
		in dense-Darstellung.
	      - 0 < m (!! Achtung: m kann hier >= BASIS sein !!).
	M wird in die Matrix L von Polynomen in einer Variablen ueber Z/mZ
	in dense-Darstellung umgewandelt.
	(siehe auch: udpitoudpmi)



			putmaflfx( M, v, n )            (MACRO)

	"put matrix of floatings by fix point"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putmaflfx( M, v, n )  matrix M;  single v, n;
	a = putmaflfx( M, v, n );
	M ist eine Matrix von floating-Zahlen. 
	v ist die Anzahl der Vor-, n die Anzahl der Nachkommastellen,
	mit denen die Matrixeintraege ausgegeben werden.
	putmaflfx schreibt die rxs-Matrix M auf stdout in der Form
	(
	(a11 .. a1s)
	(a21 .. a2s)
	  ..
	(ar1 .. ars)
	),
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putmagfs( p, AL, M, V )         (MACRO)

	"put matrix of Galois-field with single characteristic elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single putmagfs(p,AL,M,V)  single p; list AL,V; matrix M;
	a = putmagfs(p,AL,M,V);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine Matrix von Elementen aus GF(p^n).
	      - V ist eine einelementige Variablenliste.
	putmagfs schreibt die mxn-Matrix M auf stdout in der Form
	(
	  ( A11 ... A1n )
	  ( A21 ... A2n )
	  ...
	  ( Am1 ... Amn )
	),
	wobei die Elemente Aij aus GF(p^n) gemaess der in "fputgfsel" be-
	schriebenen Vorschrift auf stdout geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putmai( M )                     (MACRO)

	"put matrix of integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putmai(M) matrix M;
	t = putmai(M);
	M ist eine Matrix von ganzen Zahlen.
	putmai schreibt die mxn-Matrix M auf stdout in der Form
	(
	(a11 .. a1n)
	(a21 .. a2n)
	..
	(am1 .. amn)
	).
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			putmami( m, M )                 (MACRO)

	"put matrix of modular integers"
	Quellbilbiothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putmami(m,M)  int m; matrix M;
	t = putmami(m,M);
	M ist eine Matrix ueber Z/mZ (m>0).
	putmami schreibt die rxs-Matrix M auf stdout in der Form
	(
	(a11 .. a1s)
	(a21 .. a2s)
	..
	(ar1 .. ars)
	)
	Ist s<7, so wird M formatiert ausgegeben, d.h. die Spalten werden
	rechtsbuendig mit einer Breite von 11 Zeichen ausgegeben.
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			putmams( m, M )                 (MACRO)

	"put matrix of modular singles"
	Quellbilbiothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putmams(m,M)  single m; matrix M;
	t = putmams(m,M);
	M ist eine Matrix ueber Z/mZ (m>0).
	putmams schreibt die rxs-Matrix M auf stdout in der Form
	(
	(a11 .. a1s)
	(a21 .. a2s)
	..
	(ar1 .. ars)
	)
	Ist s<7, so wird M formatiert ausgegeben, d.h. die Spalten werden 
	rechtsbuendig mit einer Breite von 11 Zeichen ausgegeben.
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			putmanf( F, M, VL )             (MACRO)

	"put matrix of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single putmanf(F,M,VL)  pol F; matrix M; list VL;
	a = putmanf(F,M,VL);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine Matrix von Elementen aus k.
	      - VL ist eine einelementige Variablenliste.
	putmanf schreibt die mxn-Matrix M auf stdout in der Form
	(
	  ( A11 ... A1n )
	  ( A21 ... A2n )
	  ...
	  ( Am1 ... Amn )
	),
	wobei die Elemente Aij aus k gemaess der in "fputnfel" be-
	schriebenen Vorschrift auf stdout geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putmanfs( F, M, VL )            (MACRO)

	"put matrix of number field elements, sparse representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single putmanfs(F,M,VL)  pol F; matrix M; list VL;
	a = putmanfs(F,M,VL);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine Matrix von Elementen aus k.
	      - VL ist eine einelementige Variablenliste.
	putmanfs schreibt die mxn-Matrix M auf stdout in der Form
	(
	  ( A11 ... A1n )
	  ( A21 ... A2n )
	  ...
	  ( Am1 ... Amn )
	),
	wobei die Elemente Aij aus k gemaess der in "fputnfels" be-
	schriebenen Vorschrift auf stdout geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putmapgfs( r, p, AL, M, V, Vgfs )(MACRO)

	"put matrix of polynomials over Galois-field with single
	 characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single putmapgfs(r,p,AL,M,V,Vgfs)   single r,p; list AL; matrix M;
		list V,Vgfs;
	a = putmapgfs(r,p,AL,M,V,Vgfs);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - M ist eine Matrix von Polynomen ueber GF(p^n).
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vgfs ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung
		GF(p^n)/(Z/pZ) repraesentiert.
	putmapgfs schreibt die mxn-Matrix M auf stdout in der Form
	(
	  ( P11 ... P1n )
	  ( P21 ... P2n )
	  ...
	  ( Pm1 ... Pmn )
	),
	wobei die Polynome Pij aus GF(p^n)[X] gemaess der in "fputpgfs" be-
	schriebenen Vorschrift auf stdout geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putmapi( r, M, V )              (MACRO)

	"put matrix of polynomials over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putmapi(r,M,V) single r; matrix M; list V;
	t = putmapi(r,M,V);
	M ist eine Matrix von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen.
	V ist eine Variablenliste.
	putmapi schreibt die mxn-Matrix M auf stdout in der Form
	(
	(p11 .. p1n)
	(p21 .. p2n)
	..
	(pm1 .. pmn)
	),
	wobei die Polynome pij gemaess der in "putpi" beschriebenen
	Vorschrift ausgegeben werden.
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			putmapmi( r, m, M, V )          (MACRO)

	"put matrix of polynomials over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putmapmi(r,m,M,V)  single r; int m; matrix M; list V;
	t = putmapmi(r,m,M,V);
	M ist eine Matrix von Polynomen in r (r>=0) Variablen ueber
	Z/mZ (m>0).
	V ist eine r-elementige Variablenliste.
	putmapmi schreibt die sxt-Matrix M auf stdout in der Form
	(
	(p11 .. p1t)
	(p21 .. p2t)
	..
	(ps1 .. pst)
	),
	wobei die Polynome pij gemaess der in "putpmi" beschriebenen
	Vorschrift ausgegeben werden.
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			putmapms( r, m, M, V )          (MACRO)

	"put matrix of polynomials over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putmapms(r,m,M,V)  single r,m; matrix M; list V;
	t = putmapms(r,m,M,V);
	M ist eine Matrix von Polynomen in r (r>=0) Variablen ueber 
	Z/mZ (m>0).
	V ist eine r-elementige Variablenliste.
	putmapms schreibt die sxt-Matrix M auf stdout in der Form
	(
	(p11 .. p1t)
	(p21 .. p2t)
	..
	(ps1 .. pst)
	)
	wobei die Polynome pij gemaess der in "putpms" beschriebenen
	Vorschrift ausgegeben werden.
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			putmapnf( r, F, M, V, Vnf )     (MACRO)

	"put matrix of polynomials over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single putmapnf(r,F,M,V,Vnf)  single r; pol F; matrix M;
		list V,Vnf;
	a = putmapnf(r,F,M,V,Vnf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - M ist eine Matrix von Polynomen ueber k.
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vnf ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung von Q
		repraesentiert.
	putmapnf schreibt die mxn-Matrix M auf stdout in der Form
	(
	  ( P11 ... P1n )
	  ( P21 ... P2n )
	  ...
	  ( Pm1 ... Pmn )
	),
	wobei die Polynome Pij aus k[X] gemaess der in "fputpnf" be-
	schriebenen Vorschrift auf stdout geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putmapr( r, M, V )              (MACRO)

	"put matrix of polynomials over rationals".
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putmapr(r,M,V) single r; matrix M; list V;
	t = putmapr(r,M,V);
	M ist eine Matrix von Polynomen in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen.
	V ist eine Variablenliste.
	putmapr schreibt die mxn-Matrix M auf stdout in der Form
	(
	(p11 .. p1n)
	(p21 .. p2n)
	..
	(pm1 .. pmn)
	),
	wobei die Polynome pij gemaess der in "putpr" beschriebenen
	Vorschrift ausgegeben werden.
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			putmar( M )                     (MACRO)

	"put matrix of rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putmar(M) matrix M;
	t = putmar(M);
	M ist eine Matrix von rationalen Zahlen.
	putmar schreibt die mxn-Matrix M auf stdout in der Form
	(
	(a11 .. a1n)
	(a21 .. a2n)
	..
	(am1 .. amn)
	).
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			putmarfmsp1( p, M, V )          (MACRO)

	"put matrix of rational functions over modular single primes,
	 transcendence degree 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single putmarfmsp1(p,M,V)  single p; matrix M; list V;
	t = putmarfmsp1(p,M,V);
	p ist eine Primzahl.
	M ist eine Matrix von rationalen Funktionen in einer Variablen
	ueber dem Primkoerper Z/pZ.
	V ist eine Variablenliste.
	putmarfmsp1 schreibt die mxn-Matrix M auf stdout in der Form
	(
	(p11 .. p1n)
	(p21 .. p2n)
	..
	(pm1 .. pmn)
	),
	wobei die rationalen Funktionen pij gemaess der in "putrfmsp1"
	beschriebenen Vorschrift ausgegeben werden.
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			putmarfr( r, M, V )             (MACRO)

	"put matrix of rational functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single putmarfr(r,M,V)  single r; matrix M; list V;
	t = putmarfr(r,M,V);
	M ist eine Matrix von rationalen Funktionen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen.
	V ist eine Variablenliste.
	putmarfr schreibt die mxn-Matrix M auf stdout in der Form
	(
	(p11 .. p1n)
	(p21 .. p2n)
	..
	(pm1 .. pmn)
	),
	wobei die rationalen Funktionen pij gemaess der in "putrfr"
	beschriebenen Vorschrift ausgegeben werden.
	t = ERROR, falls Fehler beim Schreiben vorliegt,
	t = 0 sonst.



			putvecgfs( p, AL, V, VL )       (MACRO)

	"put vector of Galois-field with single characteristic elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single putvecgfs(p,AL,V,VL)  single p; list AL,VL; vec V;
	a = putvecgfs(p,AL,V,VL);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist ein Vektor von Elementen aus GF(p^n).
	      - VL ist eine einelementige Variablenliste.
	putvecgfs schreibt den Vektor V auf stdout in der Form
	( A1 ... An ),
	wobei die Elemente aus GF(p^n) Ai gemaess der in "fputgfsel" be-
	schriebenen Vorschrift auf stdout geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putveci( V )                    (MACRO)

	"put vector of integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putveci( V ) vec V;
	a = putveci( V );
	V ist ein Vektor von ganzen Zahlen.
	putveci schreibt den Vektoer V auf stdout in der Form
	( a1 ... an );
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecmi( m, V )                (MACRO)

	"put vector of modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putvecmi( m, V )  int m; vec V;
	a = putvecmi( m, V );
	V ist ein Vektor ueber Z/mZ (m>0).
	putvecmi schreibt den Vektor V auf stdout.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecms( m, V )                (MACRO)

	"put vector of modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putvecms( m, V )  single m; vec V;
	a = putvecms( m, V );
	V ist ein Vektor ueber Z/mZ (m>0).
	putvecms schreibt den Vektor V auf stdout.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecnf( F, V, VL )            (MACRO)

	"put vector of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single putvecnf(F,V,VL)  pol F; vec V; list VL;
	a = putvecnf(F,V,VL);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist ein Vektor von Elementen aus k.
	      - VL ist eine einelementige Variablenliste.
	putvecnf schreibt den Vektor V auf stdout in der Form
	( A1 ... An ),
	wobei die Elemente Ai aus k gemaess der in "fputnfel" beschriebenen
	Vorschrift auf stdout geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecnfs( F, V, VL )           (MACRO)

	"put vector of number field elements, sparse representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single putvecnfs(F,V,VL)  pol F; vec V; list VL;
	a = putvecnfs(F,V,VL);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist ein Vektor von Elementen aus k.
	      - VL ist eine einelementige Variablenliste.
	putvecnfs schreibt den Vektor V auf stdout in der Form
	( A1 ... An ),
	wobei die Elemente Ai aus k gemaess der in "fputnfels" be-
	schriebenen Vorschrift auf stdout geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecpi( r, V, VL )            (MACRO)

	"put vector of polynomials over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putvecpi( r, V, VL ) single r; vec V; list VL;
	a = putvecpi( r, V, VL );
	V ist ein Vektor von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen.
	VL ist eine Variblenliste.
	putvecpi schreibt den Vektor V auf stdout in der Form
	( p1 ... pn ),
	wobei die Polynome pi gemaess der in "putpi" beschriebenen
	Vorschriften auf stdout geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecpmi( r, m, V, VL )        (MACRO)

	"put vector of polynomials over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putvecpmi(r, m, V, VL)  single r; int m; vec V; list VL;
	a = putvecpmi(r, m, V, VL);
	V ist ein Vektor von Polynomen in r (r>=0) Variablen ueber 
	Z/mZ (m>0).
	VL ist eine r-elementige Variablenliste.
	putvecpmi schreibt den Vektor V auf stdout, wobei die Polynome 
	gemaess der in "putpmi" beschriebenen Vorschrift auf stdout 
	geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecpms( r, m, V, VL )        (MACRO)

	"put vector of polynomials over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putvecpms( r, m, V, VL )  single r, m; vec V; list VL;
	a = putvecpms( r, m, V, VL );
	V ist ein Vektor von Polynomen in r (r>=0) Variablen ueber
	Z/mZ (m>0).
	VL ist eine r-elementige Variablenliste.
	putvecpms schreibt den Vektor V auf stdout, wobei die Polynome
	gemaess der in "putpms" beschriebenen Vorschrift auf stdout 
	geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecpnf( r, F, W, VL, VLnf )  (MACRO)

	"put vector of polynomials over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single putvecpnf(r,F,W,VL,VLnf)  single r; pol F;
		vec W; list VL,VLnf;
	a = putvecpnf(r,F,W,VL,VLnf);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - W ist ein Vektor von Polynomen ueber k.
	      - VL ist eine Variablenliste der Laenge r (Fall: r=0, VL ist
		leere Liste, sonst VL = ( VL1, ..., VLr ) ).
	      - VLnf ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung von Q
		repraesentiert.
	putvecpnf schreibt den Vektor W auf stdout in der Form
	( P1 ... Pn ),
	wobei die Polynome Pi aus k[X] gemaess der in "fputpnf" be-
	schriebenen Vorschrift auf stdout geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecpr( r, V, VL )            (MACRO)

	"put vector of polynomials over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putvecpr( r, V, VL ) single r; vec V; list VL;
	a = putvecpr( r, V, VL );
	V ist ein Vektor von Polynomen in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen.
	VL ist eine Variblenliste.
	putvecpr schreibt den Vektor V auf stdout in der Form
	( p1 ... pn ),
	wobei die Polynome pi gemaess der in "putpr" beschriebenen
	Vorschriften auf stdout geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecr( V )                    (MACRO)

	"put vector of rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single putvecr( V ) vec V;
	a = putvecr( V );
	V ist ein Vektor von rationalen Zahlen.
	putvecr schreibt den Vektoer V auf stdout in der Form
	( a1 ... an );
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecrfmsp1( p, V, VL )        (MACRO)

	"put vector of rational functions over modular single primes,
	 transcendence degree 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single putvecrfmsp1( p, V, VL )  single p; vec V; list VL;
	a = putvecrfmsp1( p, V, VL );
	p ist eine Primzahl.
	V ist ein Vektor von rationalen Funktionen in einer Variablen
	ueber Z/pZ.
	VL ist eine Variblenliste.
	putvecrfmsp1 schreibt den Vektor V auf stdout in der Form
	( p1 ... pn ),
	wobei die rationalen Funktionen pi gemaess der in "putrfr"
	beschriebenen Vorschriften auf stdout geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvecrfr( r, V, VL )           (MACRO)

	"put vector of rational functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single putvecrfr( r, V, VL )  single r; vec V; list VL;
	a = putvecrfr( r, V, VL );
	V ist ein Vektor von rationalen Funktionen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen.
	VL ist eine Variblenliste.
	putvecrfr schreibt den Vektor V auf stdout in der Form
	( p1 ... pn ),
	wobei die rationalen Funktionen pi gemaess der in "putrfr"
	beschriebenen Vorschriften auf stdout geschrieben werden.
	a = ERROR, falls Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			putvpgfs( r, p, AL, W, V, Vgfs )(MACRO)

	"put vector of polynomials over Galois-field with single
	 characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	single putvpgfs(r,p,AL,W,V,Vgfs)  single r,p; list AL; vec W;
		list V,Vgfs;
	a = putvpgfs(r,p,AL,W,V,Vgfs);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - W ist ein Vektor von Polynomen ueber GF(p^n).
	      - V ist eine Variablenliste der Laenge r ( Fall: r = 0, V ist
		leere Liste, sonst V = ( V1, ..., Vr ) ).
	      - Vgfs ist eine einelementige Variablenliste, die den Namen
		eines primitiven Elementes der Koerpererweiterung
		GF(p^n)/(Z/pZ) repraesentiert.
	putvpgfs schreibt den Vektor W auf stdout in der Form
	( P1 ... Pn ),
	wobei die Polynome Pi aus GF(p^n)[X] gemaess der in "fputpgfs" be-
	schriebenen Vorschrift auf *pf geschrieben werden.
	a = ERROR, falls ein Fehler beim Schreiben vorliegt,
	a = 0 sonst.



			vecdptovecp( r, V )

	"vector of dense polynomials to vector of polynomials"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecdptovecp(r,V)  single r; vec V;
	L = vecdptovectp(r,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - V ist ein Vektor von Polynomen in r Variablen in dense-
		Darstellung.
	Der Vektor V von Polynomen in r Variablen in dense-Darstellung
	wird in den Vektor L von Polynomen in r Variablen in rekursiver
	Darstellung umgewandelt.
	L = V. (rekursive Darstellung der Polynome)



			vecgf2sprod( G, V, W )

	"vector of Galois-field with characteristic 2 elements scalar 
	product"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	gf2el vecgf2sprod( G, V, W )  obj G; vec V,W;
	s = vecgf2sprod( G, V, W );
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	V und W sind Vektoren der gleichen Laenge ueber GF(2^n).
	s ist das Skalarprodukt von V und W.



			vecgfsdif( p, AL, U, V )        (MACRO)

	"vector of Galois-field with single characteristic elements
	 difference"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecgfsdif(p,AL,U,V)  single p; list AL; matrix U,V;
	W = vecgfsdif(p,AL,U,V);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - U und V sind Vektoren gleicher Laenge von Elementen aus
		GF(p^n).
	W = U - V.



			vecgfsefe( p, ALm, V, g )

	"vector over Galois-field with single characteristic embedding 
	in field extension"
	Quellbibliothek: srclib.matr3
	Include-Datei:	 _matr3.h
	vec vecgfsefe(p,ALm,V,g)  single p; list ALm; vec V; gfel g;
	W = vecgfsefe( p,ALm,V,g );
	Es wird der Vektor V ueber GF(p^n) dargestellt als Vektor 
	ueber einer Koerpererweiterung GF(p^m) (p Primzahl, 1<n,m<BASIS,
	n teilt echt m), deren Arithmetikliste mittels gfsalgenies 
	erzeugt wurde. Die Liste ALm entspricht der Arithmetikliste
	von GF(p^m), wie sie einer Ausgabe von gfsalgen entspricht, 
	g als Polynom in einer Unbestimmten entspricht dem Bild des
	separablen Erzeugers von GF(p^n) ueber GF(p) unter der von
	gfsalgenies gefundenen isomorphen Einbettung von GF(p^n) in 
	GF(p^m) (vgl. gfsalgen, gfsalgenies).
	W ist die Darstellung von V als Vektor ueber GF(p^m).
!!!     HINWEIS: g ist vom Typ "gfel", d.h. ein sparse-Polynom in einer
		 Unbestimmten mit Koeffizienten aus Z/pZ.



			vecgfslc( p, AL, s1, s2, L1, L2 )

	"vector of Galois-field with single characteristic elements
	linear combination"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecgfslc(p,AL,s1,s2,L1,L2) single p; list AL; gfel s1,s2;
				       vec L1,L2;
	L = vecgfslc(p,AL,s1,s2,L1,L2);
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	s1, s2 sind Elemente aus GF(p^n). L1, L2 sind Vektoren mit
	Koeffizienten  aus GF(p^n). L1 und L2 haben gleiche Laenge.
	L ist ein Vektor der Laenge von L1 bzw. L2,
	fuer den gilt L = (s1*L1)+(s2*L2).



			vecgfsneg( p, AL, V )           (MACRO)

	"vector of Galois-field with single characteristic elements
	 negation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vector vecgfsneg(p,AL,V)  single p; list AL; vec V;
	W = vecgfsneg(p,AL,V);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist ein Vektor von Elementen aus GF(p^n).
	W = -V.



			vecgfssmul( p, AL, V, el )

	"vector of Galois-field with single characteristic elements scalar
	 multiplication"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecgfssmul(p,AL,V,el)  single p; list AL; vec V; gfel el;
	W = vecgfssmul(p,AL,V,el);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist ein Vektor von Elementen aus GF(p^n).
	      - el ist ein Element aus GF(p^n).
	W = el * V ist ein Vektor.



			vecgfssprod( p, AL, V, W )

	"vector of Galois-field with single characteristic elements
	scalar product"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	gfel vecgfssprod(p,AL,V,W)  single p; list AL; vec V,W;
	s = vecgfssprod(p,AL,V,W);
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	V und W sind Vektoren der gleichen Laenge ueber GF(p^n).
	s ist das Skalarprodukt von V und W.



			vecgfssum( p, AL, U, V )        (MACRO)

	"vector of Galois-field with single characteristic elements sum"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecgfssum(p,AL,U,V)  single p; list AL; matrix U,V;
	W = vecgfssum(p,AL,U,V);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - U und V sind Vektoren von Elementen aus GF(p^n) gleicher
		Laenge.
	W = U + V.



			vecidif( U, V )                 (MACRO)

	"vector of integers difference"
	Quellbibliothek: srclib.matr1
	Include-datei:   _matr1.h
	vec vecidif( U, V ) vec U, V;
	W = vecidif( U, V );
	U und V sind Vektoren gleicher Laenge ueber Z.
	W = U - V



			vecilc( s1, s2, V1, V2 )

	"vector of integers linear combination"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecilc( s1, s2, V1, V2 ) int s1, s2; vec V1, V2;
	V = vecilc( s1, s2, V1, V2 );
	s1, s2 sind ganze Zahlen. V1, V2 sind Vektoren gleicher Laenge
	ueber Z.
	V ist ein Vektor der Laenge von V1 bzw. V2,
	fuer den gilt V = (s1*V1)+(s2*V2).



			vecineg( V )                    (MACRO)

	"vector of integers negation"
	Quellbibliothek: srclib.matr1
	Include-datei:   _matr1.h
	vec vecineg( V ) vec V;
	W = vecineg( V );
	V ist ein Vektor ueber Z.
	W = -V.



			vecismul( s, V )

	"vector of integers scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecismul( s, V );  int s; vec V;
	W = vecismul( s, V );
	s ist eine ganze Zahl und V ein Vektor ueber Z.
	W = s*V.



			vecisprod( V, W )

	"vector of integers scalar product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	int vecisprod(V,W)  vec V, W;
	s = vecisprod(V,W);
	V und W sind Vektoren derselben Laenge ueber Z.
	s ist das Skalarprodukt von V und W.
	s = <V,W>.



			vecisum( U, V )                 (MACRO)

	"vector of integers sum"
	Quellbibliothek: srclib.matr1
	Include-datei:   _matr1.h
	vec vecisum(U,V) vec U, V;
	W = vecisum( U, V );
	U und V sind Vektoren gleicher Laenge ueber Z.
	W = U + V.



			vecitovecgfs( p, V )

	"vector over integers to vector over Galois-field with single
	 characteristic" 
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecitovecgfs(p,V)  single p; vec V;
	W = vecitovecgfs(p,V);	
	Dabei ist V ein Vektor ueber Z, p eine Primzahl.
	W ist der Vektor V, dargestellt als Vektor ueber dem endlichen
	Koerper GF(p^n).



			vecitovecmi( M, V )

	"vector of integers to vector of modular integers".
	Quellbibliothek : srclib.matr1
	Include - Datei : _matr1.h
	vec vecitovecmi( M, V )  int M; vec V;
	W = vecitovecmi( M, V );
	W besteht aus den Eintraegen von V (ganzen Zahlen) reduziert
	modulo der positiven ganzen Zahl M.



			vecitovecms( m, V )

	"vector of integers to vector of modular singles".
	Quellbibliothek: srclib.matr1
	Include- Datei: _matr1.h
	vec vecitovecms( m, V )  single m; vec V;
	X = vecitovecms( m, V );
	Der Vektor V von ganzen Zahlen wird in den Vektor X von 
	Zahlen aus Z/mZ umgewandelt, wobei 0 < m < BASIS.



			vecitovecnf( V )

	"vector of integers to vector of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecitovecnf(V)  vec V;
	L = vecitovecnf(V);
	Dabei muss gelten:
	      - V ist ein Vektor von ganzen Zahlen.
	Der Vektor V ueber Z wird in den Vektor L von Elementen eines
	Zahlkoerpers, in dense-Darstellung, umgewandelt.
	( siehe auch: itonf )



			vecitovecpi( r, V )

	"vector of integers to vector of polynomials over integers".
	Quellbibliothek: srclib.matr1
	Include- Datei: _matr1.h
	vec vecitovecpi( r, V );  single r; vec V;
	X = vecitovecpi( r, V );
	Der Vektor von ganzen Zahlen V wird in den Vektor von Polyno-
	men in r Variablen ueber den ganzen Zahlen X umgewandelt.



			vecitovecr( V )

	"vector of integers to vector of rationals".
	Quellbibliothek: srclib.matr1
	Include- Datei: _matr1.h
	vec vecitovecr( V );  vec V;
	X = vecitovecr( V );
	Der Vektor von ganzen Zahlen V wird in den Vektor von ratio-
	nalen Zahlen X umgewandelt.



			vecitovnfs( V )

	"vector of integers to vector of number field elements, sparse
	 representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecitovnfs(V)  vec V;
	L = vecitovnfs(V);
	Dabei muss gelten:
	      - V ist ein Vektor von ganzen Zahlen.
	Der Vektor V ueber Z wird in den Vektor L von Elementen eines
	Zahlkoerpers, in sparse-Darstellung, umgewandelt.
	( siehe auch: itonfs )



			veciunimtr( V, W, i, pV1, pW1 )

	"vector of integers unimodular transformation"
	Quellbibliothek : srclib.matr1
	Include - Datei : _matr1.h
	single veciunimtr(V,W,i,pV1,pW1) vec V,W; single i; vec *pV1,*pW1;
	a = veciunimtr(V,W,i,pV1,pW1)
	V und W sind Vektoren der gleichen Laenge ueber den ganzen Zahlen.
        i ist eine positive ganze Zahl kleiner gleich der Laenge von V 
        bzw. W.
	Seien v und w jeweils die i - ten Elemente von V bzw. W.
	*pV1 und *pW1 sind ganzzahlige Linearkombinationen von V und W
	mit der zusaetzlichen Bedingung, dass das i - te Element von *pV1
	der ggT(v,w) ist und das i - te Element von *pW1 gleich Null ist.
	a = 0, falls die Umformung durchgefuehrt werden kann.



			veclength( V )                  (MACRO)

	"vector length"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single veclength( V ) vec V;
	a = veclength( V );
	V ist ein Vektor ueber einem beliebigen Grundring.
	Falls V ein Vektor der Laenge n ist, so ist a = n.



			vecmidif( m, U, V )             (MACRO)

	"vector of modular integers difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecmidif( m, U, V)  int m; vec U, V;
	W = vecmidif( m, U, V );
	U und V sind Vektoren gleicher Laenge ueber Z/mZ (m>0).
	W = U - V.



			vecmilc( M, S1, S2, L1, L2 )

	"vector of modular integers linear combination"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecmilc(M,S1,S2,L1,L2)  int M,S1,S2; vec L1,L2;
	L = vecmilc(M,S1,S2,L1,L2);
	M ist eine positive ganze Zahl.
	S1 und S2 sind Elemente aus Z / M*Z.
	L1 und L2 sind Vektoren mit Koeffizienten aus Z / M*Z.
	L1 und L2 haben gleiche Laenge.
	L ist ein Vektor der Laenge von L1 bzw. L2,
	fuer den gilt L = ( S1 * L1)  +  ( S2 * L2 ).



			vecmineg( m, V )                (MACRO)

	"vector of modular integers negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecmineg( m, V )  int m; vec V;
	W = vecmineg( m, V );
	V ist ein Vektor ueber Z/mZ (m>0).
	W = -V.



			vecmismul( m, s, V )

	"vector of modular integers scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecmismul( m, s, V )  int m, s; vec V;
	W = vecmismul( m, s, V );
	m ist positiv.
	s ist aus Z/mZ und V ein Vektor ueber Z/mZ.
	W = s*V ueber Z/mZ.



			vecmisprod( M, V, W )

	"vector of modular integers scalar product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	int vecmisprod(M,V,W)  int M; vec V,W;
	s = vecmisprod(M,V,W);
	M ist eine positive ganze Zahl.
	V und W sind Vektoren derselben Dimension ueber Z / M*Z.
	s ist das Skalarprodukt von V und W.



			vecmisum( m, U, V )             (MACRO)

	"vector of modular integers sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecmisum( m, U, V)  int m; vec U, V;
	W = vecmisum( m, U, V );
	U und V sind Vektoren gleicher Laenge ueber Z/mZ (m>0).
	W = U + V.



			vecmsdif( m, U, V )             (MACRO)

	"vector of modular singles difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecmsdif( m, U, V)  single m; vec U, V;
	W = vecmdif( m, U, V );
	U und V sind Vektoren gleicher Laenge ueber Z/mZ (m>0).
	W = U - V.



			vecmslc( m, s1, s2, L1, L2 )

	"vector of modular singles linear combination"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecmslc(m,s1,s2,L1,L2)  single m,s1,s2; vec L1,L2;
	L = vecmslc(m,s1,s2,L1,L2);
	m ist positiv.
	s1,s2 sind Elemente aus Z/mZ. L1,L2 sind Vektoren mit
	Koeffizienten aus Z/mZ. L1 und L2 haben gleiche Laenge.
	L ist ein Vektor der Laenge von L1 bzw. L2,
	fuer den gilt L = (s1*L1)+(s2*L2).



			vecmsneg( m, V )                (MACRO)

	"vector of modular singles negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecmsneg( m, V )  single m; vec V;
	W = vecmsneg( m, V );
	V ist ein Vektor ueber Z/mZ (m>0).
	W = -V.



			vecmssmul( m, s, V )

	"vector of modular singles scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecmssmul( m, s, V )  single m, s; vec V;
	W = vecmssmul( m, s, V );
	m ist positiv.
	s ist aus Z/mZ und V ein Vektor ueber Z/mZ.
	W = s*V ueber Z/mZ.



			vecmssprod( m, V, W )

	"vector of modular singles scalar product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	single vecmssprod(m,V,W)  single m; vec V,W;
	s = vecmssprod(m,V,W);
	m ist positiv, V und W sind Vektoren derselben Laenge ueber Z/mZ.
	s ist das Skalarprodukt von V und W.



			vecmssum( m, U, V )             (MACRO)

	"vector of modular singles sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecmssum( m, U, V)  single m; vec U, V;
	W = vecmsum( m, U, V );
	U und V sind Vektoren gleicher Laenge ueber Z/mZ (m>0).
	W = U + V.



			vecneg( V, neg, anzahlargs, arg1, arg2 )

	"vector negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecneg(V,neg,anzahlargs,arg1,arg2)
	    vec V; obj (*neg)(); single anzahlargs; obj arg1,arg2;
	W = vecneg(V,neg,anzahlargs,arg1,arg2);
	V ist ein Vektor ueber einem Ring R.
	neg ist ist Negations - Funktion des Ringes R.
	neg benoetigt ausser einem Element aus R noch anzahlargs Argumente;
	arg1 und arg2 (maximal) sind diese Argumente.
	siehe auch:  vecineg, vecrneg, vecmsneg, ...



			vecnegspec( V, neg, anzahlargs, arg1, ..., arg5 )

	"vector negation special"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecnegspec(V,neg,anzahlargs,arg1,...,arg5)
	    vec V; obj (*neg)(); single anzahlargs; obj arg1,...,arg5;
	W = vecnegspec(V,neg,anzahlargs,arg1,...,arg5);
	Dabei muss gelten:
	      - V ist ein Vektor ueber einem Ring R.
	      - neg ist die Negations - Funktion des Ringes R.
	      - neg benoetigt ausser einem Element aus R noch anzahlargs
		Argumente; arg1, ..., arg5 (maximal) sind diese Argumente.
	W = -V.
	siehe auch: vecpgfsneg



			vecnfdif( F, U, V )             (MACRO)

	"vector of number field elements difference"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecnfdif(F,U,V)  pol F; vec U,V;
	W = vecnfdif(F,U,V);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - U und V sind Vektoren gleicher Laenge von Elementen aus k.
	W = U - V.



			vecnflc( F, s1, s2, L1, L2 )

	"vector of number field elements linear combination"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecnflc(F,s1,s2,L1,L2)  pol F; nfel s1,s2; vec L1,L2;
	L = vecnflc(F,s1,s2,L1,L2);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - s1 und s2 sind Elemente aus k.
	      - L1 und L2 sind Vektoren gleicher Laenge von Elementen
		aus k.
	L ist ein Vektor der Laenge von L1 bzw. L2, fuer den gilt:
	L = ( s1 * L1 ) + ( s2 * L2 ).



			vecnfneg( F, V )                (MACRO)

	"vector of number field elements negation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecnfneg(V)  vec V;
	W = vecnfneg(V);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist ein Vektor von Elementen aus k.
	W = -V.



			vecnfsdif( F, U, V )            (MACRO)

	"vector of number field elements, sparse representation,
	 difference"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecnfsdif(F,U,V)  pol F; vec U,V;
	W = vecnfsdif(F,U,V);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - U und V sind Vektoren gleicher Laenge von Elementen aus k.
	W = U - V.



			vecnfslc( F, s1, s2, L1, L2 )

	"vector of number field elements, sparse representation, linear
	 combination"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecnfslc(F,s1,s2,L1,L2)  pol F; nfel s1,s2; vec L1,L2;
	L = vecnfslc(F,s1,s2,L1,L2);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - s1 und s2 sind Elemente aus k.
	      - L1, L2 sind Vektoren gleicher Laenge von Elementen aus k.
	L ist ein Vektor der Laenge von L1 bzw. L2, fuer den gilt:
	L = ( s1 * L1 ) + ( s2 * L2 ).



			vecnfsmul( F, V, el )

	"vector of number field elements scalar multiplication"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecnfsmul(F,V,el)  pol F; vec V; nfel el;
	W = vecnfsmul(F,V,el);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist ein Vektor von Elementen aus k.
	      - el ist ein Element aus k.
	W = el * V ist ein Vektor.



			vecnfsneg( F, V )               (MACRO)

	"vector of number field elements, sparse representation, negation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecnfsneg(F,V)  pol F; vec V;
	W = vecnfsneg(F,V);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist ein Vektor von Elementen aus k.
	W = -V.



			vecnfsprod( F, V, W )

	"vector of number field elements scalar product"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	nfel vecnfsprod(F,V,W)  pol F; vec V,W;
	s = vecnfsprod(F,V,W);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V und W sind Vektoren gleicher Laenge von Elementen aus k.
	s = < V, W > ( das Skalarprodukt von V und W ) ist ein Element
	aus k.



			vecnfssmul( F, V, el )

	"vector of number field elements, sparse representation, scalar
	 multiplication"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecnfssmul(F,V,el)  pol F; vec V; nfel el;
	W = vecnfssmul(F,V,el);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist ein Vektor von Elementen aus k.
	      - el ist ein Element aus k.
	W = el * V ist ein Vektor.



			vecnfssprod( F, V, W )

	"vector of number field elements, sparse representation, scalar
	 product"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	nfel vecnfssprod(F,V,W)  pol F; vec V,W;
	s = vecnfssprod(F,V,W);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V und W sind Vektoren gleicher Laenge von Elementen aus k.
	s = < V, W > ( das Skalarprodukt von V und W ) ist ein Element
	aus k.



			vecnfssum( F, U, V )            (MACRO)

	"vector of number field elements, sparse representation, sum"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecnfssum(F,U,V)  pol F; vec V;
	W = vecnfssum(F,U,V);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Q vom Grad >= 1 in sparse-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - U und V sind Vektoren gleicher Laenge von Elementen k.
	W = U + V.



			vecnfsum( F, U, V )             (MACRO)

	"vector of number field elements sum"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecnfsum(F,U,V)  pol F; vec U,V;
	W = vecnfsum(F,U,V);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - U und V sind Vektoren gleicher Laenge von Elementen aus k.
	W = U + V.



			vecpgfsdif( r, p, AL, U, V )    (MACRO)

	"vector of polynomials over Galois-field with single characteristic
	 difference"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpgfsdif(r,p,AL,U,V)  single r,p; list AL; matrix U,V;
	W = vecpgfsdif(r,p,AL,U,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - U und V sind Vektoren gleicher Laenge von Polynomen in r
		Variablen ueber GF(p^n).
	W = U - V.



			vecpgfsefe( r, p, ALm, V, g )

	"vector over polynomials over Galois-field with single 
	 characteristic embedding in field extension"
	Quellbibliothek: srclib.matr3
	Include-Datei	 _matr3.h
	vec vecpgfsefe(r,p,ALm,V,g)  single r,p; list ALm; vec V; 
		gfel g;
	W = vecpgfsefe( r,p,ALm,V,g );
	Es wird der Vektor V von Polynomen ueber GF(p^n) dargestellt 
	als Vektor von Polynomen ueber einer Koerpererweiterung 
	GF(p^m) (p Primzahl, 1<n,m<BASIS, n teilt echt m), deren 
	Arithmetikliste mittels gfsalgenies erzeugt wurde. 
	Die Liste ALm entspricht der Arithmetikliste von GF(p^m), wie 
	sie einer Ausgabe von gfsalgen entspricht, g als Polynom in 
	einer Unbestimmten entspricht dem Bild des separablen 
	Erzeugers von GF(p^n) ueber GF(p) unter der von gfsalgenies 
	gefundenen isomorphen Einbettung von GF(p^n) in GF(p^m).
	(vgl. gfsalgen, gfsalgenies)
	r ist die Anzahl der Variablen der Eintraege von V.
	W ist die Darstellung von V als Vektor von Polynomen ueber 
	GF(p^m).
!!!     HINWEIS: g ist vom Typ "gfel", d.h. ein sparse-Polynom in einer
		 Unbestimmten mit Koeffizienten aus Z/pZ.



			vecpgfslc( r, p, AL, s1, s2, L1, L2 )

	"vector of polynomials over Galois-field with single characteristic
	 linear combination"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpgfslc(r,p,AL,s1,s2,L1,L2)  single r,p; list AL; pol s1,s2;
		vec L1,L2;
	L = vecpgfslc(r,p,AL,s1,s2,L1,L2);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - s1 und s2 sind Polynome ueber GF(p^n).
	      - L1 und L2 sind Vektoren gleicher Laenge von Polynomen in r
		Variablen ueber GF(p^n).
	L ist ein Vektor der Laenge von L1 bzw. L2, fuer den gilt:
	L = ( s1 * L1 ) + ( s2 * L2 ).



			vecpgfsneg( r, p, AL, V )       (MACRO)

	"vector of polynomials over Galois-field with single characteristic
	 negation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpgfsneg(r,p,AL,V)  single r,p; list AL; vec V;
	W = vecpgfsneg(r,p,AL,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist ein Vektor von Polynomen in r Variablen ueber
		GF(p^n).
	W = -V.



			vecpgfssmul( r, p, AL, V, el )

	"vector of polynomials over Galois-field with single characteristic
	 scalar multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpgfssmul(r,p,AL,V,el)  single r,p; list AL; vec V; pol el;
	W = vecpgfssmul(r,p,AL,V,el);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V ist ein Vektor von Polynomen in r Variablen ueber
		GF(p^n).
	      - el ist ein Polynom ueber GF(p^n).
	W = el * V ist ein Vektor.



			vecpgfssum( r, p, AL, U, V )    (MACRO)

	"vector of polynomials over Galois-field with single characteristic
	 sum"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpgfssum(r,p,AL,U,V)  single r,p; list AL; matrix U,V;
	W = vecpgfssum(r,p,AL,U,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - U und V sind Vektoren gleicher Laenge von Polynomen in r
		Variablen ueber GF(p^n).
	W = U + V.



			vecpidif( r, U, V )             (MACRO)

	"vector of polynomials over integers difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpidif( r, U, V ) single r; vec U, V;
	W = vecpidif( r, U, V );
	U und V sind Vektoren von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen gleicher Laenge.
	W = U - V.



			vecpigfsefvs( r, p, AL, V )

	"vector over polynomials over integers Galois-field with single 
	 characteristic element evaluation first variable special version"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpigfsefvs(r,p,AL,V)  single r,p; list AL; vec V;
	W = vecpigfsefvs(r,p,AL,V);
	Dabei muss gelten:
	      - AL ist die Arithmetikliste fuer GF(p^n), wobei p
		eine Primzahl ist.
	      - V ist ein Vektor von Polynomen in r >= 1 Variablen
		ueber Z.
	Die erste Variable der zu V gehoerenden Variablenliste wird
	durch das erzeugende Element des durch AL bestimmten endlichen
	Koerpers ersetzt.
	W ist dann ein Vektor von Polynomen in r-1 Variablen ueber diesem 
	endlichen Koerper.



			vecpilc( r, P1, P2, V1, V2 )

	"vector of polynomials over integers linear combination"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpilc( r, P1, P2, V1, V2 ) single r; pol P1, P2; vec V1, V2;
	V = vecpilc( r, P1, P2, V1, V2 );
	P1, P2 sind Polynome in r ( 0<=r<BASIS ) Variablen ueber Z.
	V1, V2 sind Vektoren gleicher Laenge von Polynomen in r Variablen
	ueber Z.
	V ist ein Vektor der Laenge von V1 bzw. V2,
	fuer den gilt V = (s1*V1)+(s2*V2).



			vecpineg( r, V )                (MACRO)

	"vector of polynomials over integers negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpineg( r, V ) single r; vec V;
	W = vecpineg( r, V );
	V ist ein Vektor von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen.
	W = -V.



			vecpismul( r, P, V )

	"vector of polynomials over integers scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpismul( r, P, V );  single r; pol P; vec V;
	W = vecpismul( r, P, V );
	P ist ein Polynom ueber Z in r ( 0<=r<BASIS ) Variablen und
	V ein Vektor von Polynomen ueber Z in r Variablen.
	W = P*V.



			vecpisprod( r, V, W )

	"vector of polynomials over integers scalar product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol vecpisprod( r, V, W )  single r; vec V, W;
	P = vecpisprod( r, V, W );
	V und W sind Vektoren derselben Laenge von Polynomen ueber Z in
	r ( 0<=r<BASIS ) Variablen.
	P ist das Skalarprodukt von V und W, also ein Polynom ueber Z in
	r Variablen.
	P = <V,W>.



			vecpisum( r, U, V )             (MACRO)

	"vector of polynomials over integers sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpisum( r, U, V ) single r; vec U, V;
	W = vecpisum( r, U, V );
	U und V sind Vektoren von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen gleicher Laenge.
	W = U + V.



			vecpitovpmi( r, V, m )

	"vector of polynomials over integers to vector of polynomials over
	 modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpitovpmi( r, V, m )  single r; vec V; int m;
	X = vecpitovpmi( r, V, m );
	m ist positiv.
	Der Vektor V von Polynomen in r (0<=r<BASIS) Variablen ueber Z
	wird in den Vektor X von Polynomen in r Variablen ueber Z/mZ
	umgewandelt, d.h. jede Komponente von V wird modulo m reduziert.



			vecpitovpms( r, V, m )

	"vector of polynomials over integers to vector of polynomials over
	 modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpitovpms( r, V, m )  single r; vec V; single m;
	X = vecpitovpms( r, V, m );
	Der Vektor V von Polynomen in r (0<=r<BASIS) Variablen ueber Z
	wird in den Vektor X von Polynomen in r Variablen ueber Z/mZ
	umgewandelt, wobei 0 < m < BASIS.



			vecpitovpnf( r, V )

	"vector of polynomials over integers to vector of polynomials over
	 number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpitovpnf(r,V)  single r; vec V;
	L = vecpitovpnf(r,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - V ist ein Vektor von Polynomen in r Variablen ueber Z.
	Der Vektor V wird in den Vektor L von Polynomen in r Variablen
	ueber einem Zahlkoerper umgewandelt.
	( siehe auch: pitopnf )



			vecpitovpr( V )

	"vector of polynomials over integers to vector of polynomials
	 over rationals".
	Quellbibliothek: srclib.matr1
	Include- Datei: _matr1.h
	vec vecpitovpr( r, V );  single r; vec V;
	X = vecpitovpr( r, V );
	Der Vektor V von Polynomen in r Variablen ueber Z wird in den
	Vektor X von Polynomen in r Variablen ueber Q umgewandelt.



			vecpitovrfr( r, V )

	"vector of polynomials over integers to vector of rational
	 functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpitovrfr( r, V )  single r; vec V;
	X = vecpitovrfr( r, V );
	Der Vektor V von Polynomen in r Variablen ueber Z  wird in den
	Vektor X von rationalen Funktionen in r Variablen ueber Q umge-
	wandelt.



			vecpitransf( r1, W1, V1, r2, P2, V2, Vn, pV3 )

	"vector of polynomials over the integers transformation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpitransf(r1,W1,V1,r2,P2,V2,Vn,pV3)  single r1; vec W1; 
		list V1; single r2; pol P2; list V2; list Vn; list *pV3;
	W3 = vecpitransf(r1,W1,V1,r2,P2,V2,Vn,pV3);
	W1 ist ein Vektor von Polynomen in r1 (0<r1<BASIS) Variablen
	ueber den ganzen Zahlen; V1 ist die zugehoerige Variablenliste.
	P2 ist ein Polynom in r2 (0<=r2<BASIS) Variablen ueber den
	ganzen Zahlen; V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	W3 ist der Vektor, der entsteht, wenn in W1 die Variable Vn
	durch das Polynom P2 ersetzt wird, und die zugehoerige, in
	*pV3 abgelegte Variablenliste alphabetisch sortiert ist.
	(Die in *pV3 abgelegte Variablenliste ist die Vereinigung von
	V1 und V2.)



			vecpitvpmpi( r, V, P )

	"vector of polynomials over integers to vector of polynomials
	 modulo polynomial over integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpitvpmpi( r, V, P )  single r; vec V; pol P;
	X = vecpitvpmpi( r, V, P );
	V ist ein Vektor von Polynomen in r (0<=r<BASIS) Variablen ueber Z.
	P ein Polynom in r Variablen ueber Z.
	Jede Komponente von V wird modulo P reduziert.
	Das Ergebnis X ist wie V ein Vektor von Polynomen in r Variablen
	ueber Z.



			vecpmidif( r, m, U, V )         (MACRO)

	"vector of polynomials over modular integers difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmidif( r, m, U, V )  single r; int m; vec U, V;
	W = vecpmidif( r, m, U, V);
	U und V sind Vektoren gleicher Laenge von Polynomen in r (r>=0) 
	Variablen ueber Z/mZ (m>0).
	W = U - V.



			vecpmilc( r, m, P1, P2, V1, V2 )

	"vector of polynomials over modular integers linear combination"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmilc( r, m, P1, P2, V1, V2 )  single r; int m; pol P1,P2; 
					      vec V1,V2;
	V = vecpmilc( r, m, P1, P2, V1, V2 );
	P1, P2 sind Polynome in r (r>=0) Variablen ueber Z/mZ (m>0).
	V1, V2 sind Vektoren gleicher Laenge von Polynomen in r Variablen
	ueber Z/mZ.
	V ist ein Vektor der Laenge von V1 bzw. V2,
	fuer den gilt V = (s1*V1)+(s2*V2).



			vecpmineg( r, m, V )            (MACRO)

	"vector of polynomials over modular integers negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmineg( r, m, V )  single r; int m; vec V;
	W = vecpmineg( r, m, V );
	m ist positiv.
	V ist ein Vektor von Polynomen in r (r>=0) Variablen ueber Z/mZ.
	W = -V.



			vecpmismul( r, m, P, V )

	"vector of polynomials over modular integers scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmismul( r, m, P, V )  single r; int m; pol P; vec V;
	W = vecpmismul( r, m, P, V );
	m ist positiv.
	P ist ein Polynom in r (r>=0) Variablen ueber Z/mZ und V ein
	Vektor von Polynomen in r Variablen ueber Z/mZ.
	W = P*V ueber Z/mZ.



			vecpmisprod( r, m, V, W )

	"vector of polynomials over modular integers scalar product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol vecpmisprod( r, m, V, W )  single r; int m; vec V, W;
	P = vecpmisprod( r, m, V, W );
	V und W sind Vektoren derselben Laenge von Polynomen in r (r>=0)
	Variablen ueber Z/mZ (m>0).
	P ist das Skalarprodukt von V und W, also ein Polynom in r 
	Variablen ueber Z/mZ.
	P = <V,W>.



			vecpmisum( r, m, U, V )         (MACRO)

	"vector of polynomials over modular integers sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmisum( r, m, U, V )  single r; int m; vec U, V;
	W = vecpmisum( r, m, U, V);
	U und V sind Vektoren derselben Laenge von Polynomen in r (r>=0) 
	Variablen ueber Z/mZ (m>0).
	W = U + V.



			vecpmitovpmp( r, m, P, V )

	"vector of polynomials over modular integers to vector of
	polynomials modulo polynomial over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmitovpmp(r, m, P, V)  single r; int m; pol P; vec V;
	X = vecpmitovpmp(r, m, P, V);
	V ist ein Vektor bestehend aus Polynomen in r (r >= 0) Variablen
	ueber Z/mZ (m > 0), und m ist Primzahl.
	P ist ein Polynom in r Variablen ueber Z/mZ.
	X ist ein Vektor bestehend aus den Polynomen von V reduziert
	modulo P.



			vecpmsdif( r, m, U, V )         (MACRO)

	"vector of polynomials over modular singles difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmsdif( r, m, U, V )  single r, m; vec U, V;
	W = vecpmsdif( r, m, U, V);
	U und V sind Vektoren gleicher Laenge von Polynomen in r (r>=0) 
	Variablen ueber Z/mZ (m>0).
	W = U - V.



			vecpmslc( r, m, P1, P2, V1, V2 )

	"vector of polynomials over modular singles linear combination"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmslc( r, m, P1, P2, V1, V2 )  single r,m; pol P1,P2; 
					      vec V1,V2;
	V = vecpmslc( r, m, P1, P2, V1, V2 );
	P1, P2 sind Polynome in r (r>=0) Variablen ueber Z/mZ (m>0).
	V1, V2 sind Vektoren gleicher Laenge von Polynomen in r Variablen
	ueber Z/mZ.
	V ist ein Vektor der Laenge von V1 bzw. V2,
	fuer den gilt V = (s1*V1)+(s2*V2).



			vecpmsneg( r, m, V )            (MACRO)

	"vector of polynomials over modular singles negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmsneg( r, m, V )  single r, m; vec V;
	W = vecpmsneg( r, m, V );
	V ist ein Vektor von Polynomen in r (r>=0) Variablen 
	ueber Z/mZ (m>0).
	W = -V.



			vecpmssmul( r, m, P, V )

	"vector of polynomials over modular singles scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmssmul( r, m, P, V )  single r, m; pol P; vec V;
	W = vecpmssmul( r, m, P, V );
	P ist ein Polynom in r (r>=0) Variablen ueber Z/mZ (m>0) und
	V ein Vektor von Polynomen in r Variablen ueber Z/mZ.
	W = P*V ueber Z/mZ.



			vecpmssprod( r, m, V, W )

	"vector of polynomials over modular singles scalar product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol vecpmssprod( r, m, V, W )  single r, m; vec V, W;
	P = vecpmssprod( r, m, V, W );
	m ist eine ganze, positive Zahl < BASIS.
	V und W sind Vektoren derselben Laenge von Polynomen in r (r>=0)
	Variablen ueber Z/mZ (m>0).
	P ist das Skalarprodukt von V und W, also ein Polynom in r 
	Variablen ueber Z/mZ.



			vecpmssum( r, m, U, V )         (MACRO)

	"vector of polynomials over modular singles sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmssum( r, m, U, V )  single r, m; vec U, V;
	W = vecpmssum( r, m, U, V);
	U und V sind Vektoren derselben Laenge von Polynomen in r (r>=0) 
	Variablen ueber Z/mZ (m>0).
	W = U + V.



			vecpmstovpmp( r, m, P, V )

	"vector of polynomials over modular singles to vector of
	polynomials modulo polynomial over modular singles"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecpmstovpmp(r, m, P, V)  single r, m; pol P; vec V;
	X = vecpmstovpmp(r, m, P, V);
	V ist ein Vektor bestehend aus Polynomen in r (r >= 0) Variablen
	ueber Z/mZ (0 < m < BASIS), und m ist Primzahl.
	P ist ein Polynom in r Variablen ueber Z/mZ.
	X ist ein Vektor bestehend aus den Polynomen von V reduziert
	modulo P.



			vecpnfdif( r, F, U, V )         (MACRO)

	"vector of polynomials over number field difference"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpnfdif(r,F,U,V)  single r; pol F; vec U,V;
	W = vecpnfdif(r,F,U,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - U und V sind Vektoren gleicher Laenge von Polynomen in r
		Variablen ueber k.
	W = U - V.



			vecpnflc( r, F, s1, s2, L1, L2 )

	"vector of polynomials over number field linear combination"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpnflc(r,F,s1,s2,L1,L2)  single r; pol F,s1,s2; vec L1,L2;
	L = vecpnflc(r,F,s1,s2,L1,L2);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - s1 und s2 sind Polynome ueber k.
	      - L1 und L2 sind Vektoren gleicher Laenge von Polynomen in r
		Variablen ueber k.
	L ist ein Vektor der Laenge von L1 bzw. L2, fuer den gilt:
	L = ( s1 * L1 ) + ( s2 * L2 ).



			vecpnfneg( r, F, U )            (MACRO)

	"vector of polynomials over number field negation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpnfneg(r,U)  single r; vec U;
	V = vecpnfneg(r,U);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - U ist ein Vektor von Polynomen in r Variablen ueber k.
	V = -U.



			vecpnfsmul( r, F, U, el )

	"vector of polynomials over number field scalar multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpnfsmul(r,F,U,el)  single r; pol F; vec U; pol el;
	V = vecpnfsmul(r,F,U,el);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - U ist ein Vektor von Polynomen in r Variablen ueber k.
	      - el ist ein Polynom ueber k.
	V = el * U ist ein Vektor.



			vecpnfsum( r, F, U, V )         (MACRO)

	"vector of polynomials over number field sum"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpnfsum(r,F,U,V)  single r; pol F; vec U,V;
	W = vecpnfsum(r,U,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - U und V sind Vektoren gleicher Laenge von Polynomen in r
		Variablen ueber k.
	W = U + V.



			vecpnftovpmp( r, F, P, V )

	"vector of polynomials over number field to vector of
	polynomials modulo polynomial over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpnftovpmp( r, F, P, V )  single r; pol F, P; vec V;
	X = vecpnftovpmp( r, F, P, V );
	Dabei muss gelten:
              - 0 <= r < BASIS.
              - F ist ein irreduzibles Polynom in einer Variablen ueber
                Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
                per k erzeugt.
	      - P ist ein Polynom in r Variablen ueber k.
              - V ist ein Vektor von Polynomen in r Variablen ueber k.
	X ist der Vektor bestehend aus den Polynomen von V, reduziert
	modulo P.



			vecpnftovpr( r, V )

	"vector of polynomials over number field to vector
	 of polynomials over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecpnftovpr(r, V)  single r;  vec V;
	W = vecpnftovpr(r, V);
        V ist ein Vektor von Polynomen in r Variablen ueber einem 
	Zahlkoerper.
	W ist ein Vektor von Polynomen in r + 1 Variablen ueber Q, 
	der aus V hervorgegangen ist durch Umformung der 
	Koeffizienten der einzelnen Polynome von V, die algebraische 
	Zahlen sind, in Polynome in einer Variablen ueber Q.



			vecprdif( r, U, V )             (MACRO)

	"vector of polynomials over rationals difference"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecprdif( r, U, V ) single r; vec U, V;
	W = vecprdif( r, U, V );
	U und V sind Vektoren von Polynomen in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen gleicher Laenge.
	W = U - V.



			vecprlc( r, P1, P2, V1, V2 )

	"vector of polynomials over rationals linear combination"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecprlc( r, P1, P2, V1, V2 ) single r; pol P1, P2; vec V1, V2;
	V = vecprlc( r, P1, P2, V1, V2 );
	P1, P2 sind Polynome in r ( 0<=r<BASIS ) Variablen ueber Q.
	V1, V2 sind Vektoren gleicher Laenge von Polynomen in r Variablen
	ueber Q.
	V ist ein Vektor der Laenge von V1 bzw. V2,
	fuer den gilt V = (s1*V1)+(s2*V2).



			vecprneg( r, V )                (MACRO)

	"vector of polynomials over rationals negation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecprneg( r, V ) single r; vec V;
	W = vecprneg( r, V );
	V ist ein Vektor von Polynomen in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen.
	W = -V.



			vecprsmul( r, P, V )

	"vector of polynomials over rationals scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecprsmul( r, P, V );  single r; pol P; vec V;
	W = vecprsmul( r, P, V );
	P ist ein Polynom ueber Q in r ( 0<=r<BASIS ) Variablen und
	V ein Vektor von Polynomen ueber Q in r Variablen.
	W = P*V.



			vecprsprod( r, V, W )

	"vector of polynomials over rationals scalar product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	pol vecprsprod( r, V, W )  single r; vec V, W;
	P = vecprsprod( r, V, W );
	V und W sind Vektoren derselben Laenge von Polynomen ueber Q in
	r ( 0<=r<BASIS ) Variablen.
	P ist das Skalarprodukt von V und W, also ein Polynom ueber Q in
	r Variablen.
	P = <V,W>.



			vecprsum( r, U, V )             (MACRO)

	"vector of polynomials over rationals sum"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecprsum( r, U, V ) single r; vec U, V;
	W = vecprsum( r, U, V );
	U und V sind Vektoren von Polynomen in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen gleicher Laenge.
	W = U + V.



			vecprtovpmi( r, V, m )

	"vector of polynomials over rationals to vector of polynomials over
	 modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecprtovpmi( r, V, m )  single r; vec V; int m;
	X = vecprtovpmi( r, V, m );
	m ist positiv.
	Der Vektor V von Polynomen in r (0<=r<BASIS) Variablen ueber Q
	wird in den Vektor X von Polynomen in r Variablen ueber Z/mZ
	umgewandelt, d.h. jede Komponente von V wird modulo m reduziert.
	Falls der ggT des Nenners eines Matrixelements und m ungleich 1
	ist, so wird ERROR zurueckgegeben.



			vecprtovpnf( r, V )

	"vector of polynomials over rationals to vector of polynomials 
	 over number field"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecprtovpnf(r,V)  single r; vec V;
	L = vecprtovpnf(r,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - V ist ein Vektor von Polynomen in r Variablen ueber Q.
	Der Vektor V wird in den Vektor L von Polynomen in r Variablen
	ueber einem Zahlkoerper umgewandelt.
	( siehe auch: prtopnf )



			vecprtovrfr( r, V )

	"vector of polynomials over rationals to vector of rational
	 functions over rationals"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecprtovrfr( r, V )  single r; vec V;
	X = vecprtovrfr( r, V );
	Der Vektor V von Polynomen in r Variablen ueber Q  wird in den
	Vektor X von rationalen Funktionen in r Variablen ueber Q umge-
	wandelt.



			vecprtransf( r1, W1, V1, r2, P2, V2, Vn, pV3 )

	"vector of polynomials over the rationals transformation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecprtransf(r1,W1,V1,r2,P2,V2,Vn,pV3)  single r1; vec W1; 
		list V1; single r2; pol P2; list V2; list Vn; list *pV3;
	W3 = vecprtransf(r1,W1,V1,r2,P2,V2,Vn,pV3);
	W1 ist ein Vektor von Polynomen in r1 (0<r1<BASIS) Variablen
	ueber den rationalen Zahlen; V1 ist die zugehoerige Variablenliste.
	P2 ist ein Polynom in r2 (0<=r2<BASIS) Variablen ueber den
	rationalen Zahlen; V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	W3 ist der Vektor, der entsteht, wenn in W1 die Variable Vn
	durch das Polynom P2 ersetzt wird, und die zugehoerige, in
	*pV3 abgelegte Variablenliste alphabetisch sortiert ist.
	(Die in *pV3 abgelegte Variablenliste ist die Vereinigung von
	V1 und V2.)



			vecprtvpmpr( r, V, P )

	"vector of polynomials over rationals to vector of polynomials
	 modulo polynomial over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecprtvpmpr( r, V, P )  single r; vec V; pol P;
	X = vecprtvpmpr( r, V, P );
	V ist ein Vektor von Polynomen in r (0<=r<BASIS) Variablen ueber Q.
	P ein Polynom in r Variablen ueber Q.
	Jedes Element von V wird modulo P reduziert.
	Das Ergebnis X ist wie V ein Vektor von Polynomen in r Variablen
	ueber Q.



			vecptovecdp( r, V )

	"vector of polynomials to vector of dense polynomials"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecptovecdp(r,V)  single r; vec V;
	L = vecptovectdp(r,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - V ist ein Vektor von Polynomen in r Variablen in
		rekursiver Darstellung.
	V wird in den Vektor L von Polynomen in r Variablen in dense-
	Darstellung umgewandelt.
	L = V. (dense-Darstellung der Polynome)



			vecptovecup( r, V )

	"vector of polynomials to vector of univariate polynomials"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecptovecup(r,V)  single r; vec V;
	L = vecptovecup(r,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - V ist ein Vektor von Polynomen in r Variablen.
	V wird in den Vektor L von Polynomen in einer Variablen umge-
	wandelt.
	(siehe auch: ptoup)



			vecrdif( U, V )                 (MACRO)

	"vector of rationals difference"
	Quellbibliothek: srclib.matr1
	Include-datei:   _matr1.h
	vec vecrdif( U, V ) vec U, V;
	W = vecrdif( U, V );
	U und V sind Vektoren gleicher Laenge ueber Q.
	W = U - V



			vecrfmsp1dif( p, U, V )         (MACRO)

	"vector of rational functions over modular single primes,
	 transcendence degree 1, difference"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfmsp1dif( p, U, V )  single p; vec U, V;
	W = vecrfmsp1dif( p, U, V );
	p ist eine Primzahl.
	U und V sind Vektoren gleicher Laenge von rationalen Funktionen
	in einer Variablen ueber Z/pZ.
	W = U - V.



			vecrfmsp1lc( p, F1, F2, V1, V2 )

	"vector of rational functions over modular single primes,
	 transcendence degree 1, linear combination"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfmsp1lc(p,F1,F2,V1,V2 )  single p; rfunc F1,F2; vec V1,V2;
	V = vecrfmsp1lc( p, F1, F2, V1, V2 );
	p ist eine Primzahl.
	F1, F2 sind rationale Funktionen in einer Variablen ueber Z/pZ.
	V1, V2 sind Vektoren gleicher Laenge von rationalen Funktionen in
	einer Variablen ueber Z/pZ.
	V ist gleich (F1*V1)+(F2*V2).



			vecrfmsp1neg( p, V )            (MACRO)

	"vector of rational functions over modular single primes,
	 transcendence degree 1, negation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfmsp1neg( p, V )  single p; vec V;
	W = vecrfmsp1neg( p, V );
	p ist eine Primzahl.
	V ist ein Vektor von rationalen Funktionen in einer Variablen
	ueber Z/pZ.
	W = -V.



			vecrfmsp1sm( p, F, V )

	"vector of rational functions over modular single primes,
	 transcendence degree 1, scalar multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfmsp1sm( p, F, V )  single p; rfunc F; vec V;
	W = vecrfmsp1sm( p, F, V );
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - F ist eine rationale Funktion ueber Z/pZ in einer
		Variablen.
	      - V ist ein Vektor von rationalen Funktionen ueber Z/pZ
		in einer Variablen.
	W = F*V.



			vecrfmsp1sp( p, V, W )

	"vector of rational functions over modular single primes,
	 transcendence degree 1, scalar product"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	rfunc vecrfmsp1sp( p, V, W )  single p; vec V, W;
	F = vecrfmsp1sp( p, V, W );
	p ist eine Primzahl.
	V und W sind Vektoren derselben Laenge von rationalen Funktionen
	ueber Z/pZ in einer Variablen.
	F ist das Skalarprodukt von V und W, also eine rationale Funktion
	ueber Z/pZ in einer Variablen.
	F = <V,W>.



			vecrfmsp1sum( p, U, V )         (MACRO)

	"vector of rational functions over modular single primes,
	 transcendence degree 1, sum"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfmsp1sum( p, U, V )  single p; vec U, V;
	W = vecrfmsp1sum( p, U, V );
	p ist eine Primzahl.
	U und V sind Vektoren gleicher Laenge von rationalen Funktionen
	in einer Variablen ueber Z/pZ.
	W = U + V.



			vecrfrdif( r, U, V )            (MACRO)

	"vector of rational functions over rationals difference"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfrdif( r, U, V )  single r; vec U, V;
	W = vecrfrdif( r, U, V );
	U und V sind Vektoren gleicher Laenge von rationalen Funktionen
	in r (0<=r<BASIS) Variablen ueber den rationalen Zahlen.
	W = U - V.



			vecrfrlc( r, F1, F2, V1, V2 )

	"vector of rational functions over rationals linear combination"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfrlc(r,F1,F2,V1,V2)  single r; rfunc F1,F2; vec V1,V2;
	V = vecrfrlc(r,F1,F2,V1,V2);
	F1, F2 sind rationale Funktionen in r ( 0<=r<BASIS ) Variablen
	ueber Q. V1, V2 sind Vektoren gleicher Laenge von rationalen
	Funktionen in r Variablen ueber Q.
	V = (s1*V1)+(s2*V2).



			vecrfrneg( r, V )               (MACRO)

	"vector of rational functions over rationals negation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfrneg( r, V )  single r; vec V;
	W = vecrfrneg( r, V );
	V ist ein Vektor von rationalen Funktionen in r (0<=r<BASIS)
	Variablen ueber den rationalen Zahlen.
	W = -V.



			vecrfrsmul( r, F, V )

	"vector of rational functions over rationals scalar multiplication"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfrsmul( r, F, V )  single r; rfunc F; vec V;
	W = vecrfrsmul( r, F, V );
	F ist eine rationale Funktion ueber Q in r ( 0<=r<BASIS ) Variablen
	und V ein Vektor von rationalen Funktionen ueber Q in r Variablen.
	W = F*V.



			vecrfrsprod( r, V, W )

	"vector of rational functions over rationals scalar product"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	rfunc vecrfrsprod( r, V, W )  single r; vec V, W;
	F = vecrfrsprod( r, V, W );
	V und W sind Vektoren derselben Laenge von rationalen Funktionen
	ueber Q in r ( 0<=r<BASIS ) Variablen.
	F ist das Skalarprodukt von V und W, also eine rationale Funktion
	ueber Q in r Variablen.
	F = <V,W>.



			vecrfrsum( r, U, V )            (MACRO)

	"vector of rational functions over rationals sum"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfrsum( r, U, V )  single r; vec U, V;
	W = vecrfrsum( r, U, V );
	U und V sind Vektoren gleicher Laenge von rationalen Funktionen
	in r (0<=r<BASIS) Variablen ueber den rationalen Zahlen.
	W = U + V.



			vecrfrtrnsf( r1, W1, V1, r2, R2, V2, Vn, pV3 )

	"vector of rational functions over the rationals transformation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vecrfrtrnsf(r1,W1,V1,r2,R2,V2,Vn,pV3)  single r1; vec W1;
		list V1; single r2; rfunc R2; list V2, Vn, *pV3;
	W3 = vecrfrtrnsf(r1,W1,V1,r2,R2,V2,Vn,pV3);
	W1 ist ein Vektor von rationalen Funktionen in r1 (1<=r1<BASIS)
	Variablen ueber Q; V1 ist die zugehoerige Variablenliste.
	R2 ist eine rationale Funktion in r2 (0<=r2<BASIS) Variablen
	ueber Q; V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	W3 ist der Vektor, die entsteht, wenn in W1 die Variable
	Vn durch die rationale Funktion R2 ersetzt wird, und
	die zugehoerige, in *pV3 abgelegte Variablenliste alphabetisch
	sortiert ist. (Die in *pV3 abgelegte Variablenliste ist die
	Vereinigung von V1 und V2.)
	Warnung ! Ergibt die Transformation von Vn im Nenner eines Vek-
	--------  torelementes Null, so wird -BASIS-1 zurueckgegeben.



			vecrlc( s1, s2, V1, V2 )

	"vector of rationals linear combination"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecrlc( s1, s2, V1, V2 ) rat s1, s2; vec V1, V2;
	V = vecrlc( s1, s2, V1, V2 );
	s1, s2 sind rationale Zahlen. V1, V2 sind Vektoren gleicher
	Laenge ueber Q.
	V ist ein Vektor der Laenge von V1 bzw. V2,
	fuer den gilt V = (s1*V1)+(s2*V2).



			vecrneg( V )                    (MACRO)

	"vector of rationals negation"
	Quellbibliothek: srclib.matr1
	Include-datei:   _matr1.h
	vec vecrneg( V ) vec V;
	W = vecrneg( V );
	V ist ein Vektor ueber Q.
	W = -V.



			vecrsmul( s, V )

	"vector of rationals scalar multiplication"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecrsmul( s, V );  rat s; vec V;
	W = vecrsmul( s, V );
	s ist eine rationale Zahl und V ein Vektor ueber Q.
	W = s*V.



			vecrsprod( V, W )

	"vector of rationals scalar product"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	rat vecrsprod(V,W)  vec V, W;
	s = vecrsprod(V,W);
	V und W sind Vektoren derselben Laenge ueber Q.
	s ist das Skalarprodukt von V und W.
	s = <V,W>.



			vecrsum( U, V )                 (MACRO)

	"vector of rationals sum"
	Quellbibliothek: srclib.matr1
	Include-datei:   _matr1.h
	vec vecrsum(U,V) vec U, V;
	W = vecrsum( U, V );
	U und V sind Vektoren gleicher Laenge ueber Q.
	W = U + V.



			vecrtovecmi( m, V )

	"vector of rationals to vector of modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecrtovecmi( m, V )  int m; vec V;
	X = vecrtovecmi( m, V );
	m ist positiv.
	Der Vektor V von rationalen Zahlen wird in den Vektor X von
	Zahlen aus Z/mZ umgewandelt, d.h. jede Komponente von V wird
	modulo m reduziert. Falls der ggt des Nenners eines Vektor-
	elements und m ungleich 1 ist, so wird ERROR zurueckgegeben.



			vecrtovecnf( V )

	"vector of rationals to vector of number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecrtovecnf(V)  vec V;
	L = vecrtovecnf(V);
	Dabei muss gelten:
	      - V ist ein Vektor von rationalen Zahlen.
	Der Vektor V ueber Q wird in den Vektor L von Elementen eines
	Zahlkoerpers umgewandelt.
	( siehe auch: rtonf )



			vecrtovecpr( r, V )

	"vector of rationals to vector of polynomials over rationals".
	Quellbibliothek: srclib.matr1
	Include- Datei: _matr1.h
	vec vecrtovecpr( r, V );  single r; vec V;
	X = vecrtovecpr( r, V );
	Der Vektor von rationalen Zahlen V wird in den Vektor von Poly-
	nomen in r Variablen ueber den rationalen Zahlen X umgewandelt.



			vecrtovnfs( V )

	"vector of rationals to vector of number field elements, sparse
	 representation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vecrtovnfs(V)  vec V;
	L = vecrtovnfs(V);
	Dabei muss gelten:
	      - V ist ein Vektor von rationalen Zahlen.
	Der Vektor V ueber Q wird in den Vektor L von Elementen eines
	Zahlkoerpers, in sparse-Darstellung, umgewandelt.
	( siehe auch: rtonfs )



			vecsum( U, V, sum, anzahlargs, arg1, arg2 )

	"vector sum"
	Quellbibliothek: srclib.matr1
	Include-datei:   _matr1.h
	vec vecsum(U,V,sum,anzahlargs,arg1,arg2)
	    vec U,V; obj (*sum)(); single anzahlargs; obj arg1,arg2;
	W = vecsum(U,V,sum,anzahlargs,arg1,arg2);
	U und V sind Vektoren gleicher Laenge ueber einem Ring R.
	sum ist die Additionsfunktion dieses Ringes.
	sum benoetigt ausser 2 Elementen aus R noch anzahlargs Argumente;
	arg1 und arg2 (maximal) sind diese Argumente.
	W = U + V.
	siehe auch vecisum, vecrsum, vecmssum, ...



			vecsumspec( U, V, sum, anzahlargs, arg1, ..., arg5 )

	"vector sum special"
	Quellbibliothek: srclib.matr1
	Include-datei:   _matr1.h
	vec vecsumspec(U,V,sum,anzahlargs,arg1,...,arg5)
	    vec U,V; obj (*sum)(); single anzahlargs; obj arg1,...,arg5;
	W = vecsumspec(U,V,sum,anzahlargs,arg1,...,arg5);
	Dabei muss gelten:
	      - U und V sind Vektoren gleicher Laenge ueber einem Ring R.
	      - sum ist die Additions - Funktion des Ringes R.
	      - sum benoetigt ausser 2 Elementen aus R noch anzahlargs
		Argumente; arg1, ..., arg5 (maximal) sind diese Argumente.
	W = U + V.
	siehe auch vecpgfssum.



			vecupmsunimt( p, V, W, i, pV1, pW1 )

	"vector of univariate polynomials over modular single prime
	unimodular transformation"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	single vecupmsunimt(p,V,W,i,pV1,pW1) single p,i; vec V,W,*pV1,*pW1;
	a = vecupmsunimt(p,V,W,i,pV1,pW1)
	V und W sind Vektoren der gleichen Laenge ueber dem Polynomring in
	einer Veraenderlichen ueber Z/pZ, wobei p eine single Primzahl ist.
	i ist eine positive ganze Zahl und ist kleiner gleich der Laenge
	von V bzw. W.
	Es sei v bzw. w jeweils das i - te Element von V bzw. W.
	*pV1 und *pW1 sind Linearkombinationen aus V und W, wobei die
	Skalare der entsprechenden Linearkombinationen Elemente des oben
	genannten Polynomrings sind.
	Desweiteren gilt: das i - te Element *pV1 ist gleich dem ggT(v,w)
	und das i - te Element von *pW1 ist gleich Null.
	a = 0, falls die Umformung durchgefuehrt werden kann.



			vecvpermut( r, V, PI )

	"vector of polynomials variable permutation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vecvpermut(r,V,PI)  single r; vec V; list PI;
	V1 = vecvpermut(r,V,PI);
	V ist ein Vektor von Polynomen in r (0<=r<BASIS) Variablen
	X1,...,Xr.
	Fuer r>0 ist PI eine Liste, die eine Permutation der Zahlen
	1,...,r enthaelt, d.h.  PI = ( pi(1) ,..., pi(r) )
	mit  1<=pi(i)<=r  fuer 1<=i<=r
	und  pi(i) != pi(j)  fuer i!=j.
	Im Fall r=0 ist PI die leere Liste.
	V1 = V, wobei fuer r>0 die Reihenfolge der Variablen X1,...,Xr
	so wie in PI angegeben permutiert wurde.



			vnftovudpr( F, V )

	"vector of number field elements to vector of univariate dense
	 polynomials over rationals"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vnftovudpr(F,V)  pol F; vec V;
	L = vnftovudpr(F,V);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V ist ein Vektor von Elementen aus k.
	Der Vektor V ueber k wird in den Vektor L von Polynomen in einer
	Variablen ueber Q, in dense-Darstellung, umgewandelt.
	( siehe auch: nfeltoudpr )



			vpgfssprod( r, p, AL, V, W )

	"vector of polynomials over Galois-field with single characteristic
	 scalar product"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	pol vpgfssprod(r,p,AL,V,W)  single r,p; list AL; vec V,W;
	s = vpgfssprod(r,p,AL,V,W);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
		G ist ein irreduzibles, normiertes Polynom in einer Vari-
		ablen ueber Z/pZ, das Grad n >= 1 hat.
	      - V und W sind Vektoren gleicher Laenge von Polynomen in r
		Variablen ueber GF(p^n).
	s = < V, W > ( das Skalarprodukt von V und W ) ist ein Polynom
	ueber GF(p^n).



			vpgfstovpmp( r, p, AL, P, V )

	"vector of polynomials over Galois-field with single 
	 characteristic to vector of polynomials modulo polynomial over 
	 Galois-field with single characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vpgfstovpmp(r, p, AL, P, V)  single r, p; list AL; pol P; 
		vec V;
	W = vpgfstovpmp(r, p, AL, P, V);
	V ist ein Vektor bestehend aus Polynomen in r (r >= 0) Variablen
	ueber GF(p^n) (p Primzahl).
	P ist ein Polynom in r Variablen ueber GF(p^n).
	AL = ( G, AL1 ) kann als Arithmetikliste fuer GF(p^n) 
	interpretiert werden (vgl. gfsalgen), wobei n = llength(AL1)+1.
	G  ist ein irreduzibles, normiertes Polynom in einer Variablen 
	ueber Z/pZ vom Grad n >= 1.
	W ist ein Vektor bestehend aus den Polynomen von V, reduziert
	modulo P.



			vpgfstransf( r1, p, AL, W1, V1, r2, P2, V2, Vn, pV3 )

	"vector of polynomials over Galois-field with single 
	 characteristic transformation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vpgfstransf(r1,p,AL,W1,V1,r2,P2,V2,Vn,pV3)
		single r1,p; list AL; vec W1; list V1; single r2; 
		pol P2; list V2,Vn,*pV3;
	W3 = vpgfstransf(r1,p,AL,W1,V1,r2,P2,V2,Vn,pV3);
	Dabei muss gelten:
	      - r1 >= 1.
	      - p ist Primzahl > 2.
	      - AL = ( G, AL1 ) kann als Arithmetikliste fuer GF(p^n)
		interpretiert werden. 
	      - W1 ist ein Vektor von Polynomen in r1 Variablen ueber 
		dem endlichen Koerper GF(p^n).
	      - V1 ist die zum Vektor W1 gehoerige Variablenliste.
	      - r2 >= 0.
	      - P2 ist ein Polynom in r2 Variablen ueber GF(p^n).
	      - V2 ist die zum Polynom P2 gehoerige Variablenliste.
	      - Vn ist eine Liste, die einen in V1 auftretenden 
		Variablennamen repraesentiert.
	      - In *pV3 ist die Vereinigung der Variablenlisten V1 und 
		V2 abgelegt und alphabetisch sortiert.
	W3 ist der Vektor, der entsteht, wenn in W1 die Variable Vn 
	durch das Polynom P2 ersetzt wird, und *pV3 ist die zum Vektor 
	W3 gehoerige Variablenliste.



			vpinfevalfvs( r, F, V )

	"vector of polynomials over integers number field element
         evaluation first variable special version"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vpinfevalfvs( r, F, V )  single r; pol F; vec V;
	W = vpinfevalfvs( r, F, V );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variablen ueber Z in dense-Darstellung.
	      - V ist ein Vektor von Polynomen in r >= 1 Variablen
                ueber Z.
        In den einzelnen Vektorelementen wird die erste Variable der
        zu V gehoerigen Variablenliste durch das erzeugende Element
	des durch F bestimmten Zahlkoerpers ersetzt.
	W ist ein Vektor von Polynomen in r-1 Variablen ueber diesem
        Zahlkoerper.



			vpmitransf( r1, m, W1, V1, r2, P2, V2, Vn, pV3 )

	"vector of polynomials over modular integers transformation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vpmitransf(r1,m,W1,V1,r2,P2,V2,Vn,pV3)
		single r1,r2; int m; vec W1; pol P2; list V1,V2,Vn,*pV3;
	W3 = vpmitransf(r1,m,W1,V1,r2,P2,V2,Vn,pV3);
	Dabei muss gelten:
	      - 1 <= r1 < BASIS.
	      - m > 0.
	      - W1 ist ein Vektor von Polynomen in r1 Variablen ueber 
		dem Restklassenring Z/mZ.
	      - V1 ist die zum Vektor W1 gehoerige Variablenliste.
	      - 0 <= r2 < BASIS.
	      - P2 ist ein Polynom in r2 Variablen ueber Z/mZ.
	      - V2 ist die zum Polynom P2 gehoerige Variablenliste.
	      - Vn ist eine Liste, die einen in V1 auftretenden Variab-
		lennamen repraesentiert.
	      - In *pV3 ist die Vereinigung der Variablenlisten V1 und 
		V2 abgelegt, und zwar alphabetisch sortiert.
	W3 ist der Vektor, der entsteht, wenn in W1 die Variable Vn 
	durch das Polynom P2 ersetzt wird, und *pV3 ist die zum Vektor
        W3 gehoerige Variablenliste.



			vpmstovpgfs( r, p, V )

	"vector of polynomials over modular singles to vector of
	 polynomials over Galois-field with single characteristic"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vpmstovpgfs(r,p,V)  single r,p; vec V;
	L = vpmstovpgfs(r,p,V);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - p ist eine Primzahl.
	      - V ist ein Vektor von Polynomen in r Variablen ueber Z/pZ.
	Dann gilt fuer eine beliebige natuerliche Zahl n aus [1,(BASIS-1)]:
	L = V (aufgefasst als Vektor ueber GF(p^n)).
	Das heisst, die Basiskoeffizienten der (Vektor-)Polynome werden von
	Z/pZ nach GF(p^n) eingebettet.
	( siehe auch: pmstopgfs )



			vpmstransf( r1, m, W1, V1, r2, P2, V2, Vn, pV3 )

	"vector of polynomials over modular singles transformation"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vpmstransf(r1,m,W1,V1,r2,P2,V2,Vn,pV3)
		single r1,m; vec W1; list V1; single r2; pol P2;
		list V2,Vn,*pV3;
	W3 = vpmstransf(r1,m,W1,V1,r2,P2,V2,Vn,pV3);
	Dabei muss gelten:
	      - 1 <= r1 < BASIS.
	      - 0 < m < BASIS.
	      - W1 ist ein Vektor von Polynomen in r1 Variablen ueber dem
		Restklassenring Z/mZ.
	      - V1 ist die zum Vektor W1 gehoerige Variablenliste.
	      - 0 <= r2 < BASIS.
	      - P2 ist ein Polynom in r2 Variablen ueber Z/mZ.
	      - V2 ist die zum Polynom P2 gehoerige Variablenliste.
	      - Vn ist eine Liste, die einen in V1 auftretenden Variablen-
		namen repraesentiert.
	      - In *pV3 ist die Vereinigung der Variablenlisten V1 und V2
		abgelegt und alphabetisch sortiert.
	W3 ist der Vektor, der entsteht, wenn in W1 die Variable Vn durch
	das Polynom P2 ersetzt wird, und *pV3 ist die zum Vektor W3 ge-
	hoerige Variablenliste.



			vpmstvrfmsp1( p, V )

	"vector of polynomials over modular singles to vector of rational
	 functions over modular single primes, transcendence degree 1"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vpmstvrfmsp1( p, V )  single p; vec V;
	X = vpmstvrfmsp1( p, V );
	Dabei muss gelten:
	  - p ist eine Primzahl.
	  - V ist ein Vektor von Polynomen in einer Variablen ueber Z/pZ.
	Der Vektor V wird in den Vektor X von rationalen Funktionen in
	einer Variablen ueber Z/pZ umgewandelt.



			vpnfsprod( r, F, V, W )

	"vector of polynomials over number field scalar product"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	pol vpnfsprod(r,F,V,W)  single r; pol F; vec V,W;
	s = vpnfsprod(r,F,V,W);
	Dabei muss gelten:
	      - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das den Zahlkoer-
		per k erzeugt.
	      - V und W sind Vektoren gleicher Laenge von Polynomen in r
		Variablen ueber k.
	s = < V, W > ( das Skalarprodukt von V und W ) ist ein Polynom
	ueber k.



			vpnftransf( r1, F, W1, V1, r2, P2, V2, Vn, pV3 )

	"vector of polynomials over number field transformation"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vpnftransf(r1,F,W1,V1,r2,P2,V2,Vn,pV3)
		single r1,r2; pol F; vec W1; pol P2; list V1,V2,Vn,*pV3;
	W3 = vpnftransf(r1,F,W1,V1,r2,P2,V2,Vn,pV3);
	Dabei muss gelten:
	      - 1 <= r1 < BASIS.
	      - F ist ein irreduzibles Polynom ueber Z in einer Variab-
	        len in dense-Darstellung, das einen Zahlkoerper K er-
		zeugt.	
	      - W1 ist ein Vektor von Polynomen in r1 Variablen ueber K.
	      - V1 ist die zum Vektor W1 gehoerige Variablenliste.
	      - 0 <= r2 < BASIS.
	      - P2 ist ein Polynom in r2 Variablen ueber K.
	      - V2 ist die zum Polynom P2 gehoerige Variablenliste.
	      - Vn ist eine Liste, die einen in V1 auftretenden Variab-
		lennamen repraesentiert.
	      - In *pV3 ist die Vereinigung der Variablenlisten V1 und
	        V2 abgelegt, und zwar alphabetisch sortiert.
	W3 ist der Vektor, der entsteht, wenn in W1 die durch Vn reprae-
	sentierte Variable durch das Polynom P2 ersetzt wird, und *pV3 
	ist die zum Vektor W3 gehoerige Variablenliste.



			vprnfevalfvs( r, F, V )

	"vector of polynomials over rationals number field element
         evaluation first variable special version"
	Quellbibliothek: srclib.matr3
	Include-Datei:   _matr3.h
	vec vprnfevalfvs( r, F, V )  single r; pol F; vec V;
	W = vprnfevalfvs( r, F, V );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variablen ueber Z in dense-Darstellung.
	      - V ist ein Vektor von Polynomen in r >= 1 Variablen
                ueber Q.
        In den einzelnen Vektorelementen wird die erste Variable der
        zu V gehoerigen Variablenliste durch das erzeugende Element
	des durch F bestimmten Zahlkoerpers ersetzt.
	W ist ein Vektor von Polynomen in r-1 Variablen ueber diesem
        Zahlkoerper.



			vudpitudpmi( V, M )

	"vector of univariate dense polynomials over integers to vector of
	 univariate dense polynomials over modular integers"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vudpitudpmi(V,M)  vec V; int M;
	L = vudpitudpmi(V,M);
	Dabei muss gelten:
	      - V ist ein Vektor von Polynomen in einer Variablen ueber Z
		in dense-Darstellung.
	      - 0 < M (!! Achtung: M kann hier >= BASIS sein !!).
	V wird in den Vektor L von Polynomen in einer Variablen ueber
	Z/M*Z in dense-Darstellung umgewandelt.
	(siehe auch: udpitoudpmi)



			vudpitvudpr( V )

	"vector of univariate dense polynomials over integers to vector of
	 univariate dense polynomials over rationals"
	Quellbibliothek: srclib.matr1
	Include-Datei:   _matr1.h
	vec vudpitvudpr(V)  vec V;
	L = vudpitvudpr(V);
	Dabei muss gelten:
	      - V ist ein Vektor von Polynomen in einer Variablen ueber Z
		in dense-Darstellung.
	V wird in den Vektor L von Polynomen in einer Variablen ueber Q
	in dense-Darstellung umgewandelt.
	(siehe auch: udpitoudpr)



			vudprtovnf( V )

	"vector of univariate dense polynomials over rationals to vector of
	 number field elements"
	Quellbibliothek: srclib.matr2
	Include-Datei:   _matr2.h
	vec vudprtovnf(V)  vec V;
	L = vudprtovnf(V);
        Dabei muss gelten:
	      - V ist ein Vektor von Polynomen in einer Variablen ueber Q,
		in dense-Darstellung.
	Der Vektor V wird in den Vektor L von Elementen eines Zahlkoerpers
	umgewandelt.
	( siehe auch: udprtonfel )



