			Cfltofl( x )

	"C-floating point to floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating Cfltofl( x )  double x;
	f = Cfltofl ( x );    
	f ist die ( SIMATH- ) floating point Darstellung von x.
	Genauer gilt: 
	| ( x - f ) / x | < 1/2 * (2^30)^( 1 - FL_EPS ).



			Earith(  )

	"Essen arithmetic package"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	Funktionen, die es erlauben, innerhalb von SIMATH 
	das nachfolgend beschriebene Arithmetik-Paket
	(die sogenannte "Essener Arithmetik") zu benutzen.
	Um die Funktionen innerhalb von SIMATH
	benutzen zu koennen, muss statt dem Aufruf einer 
	Funktion aus dem Essener Arithmetikpaket
	    <functionsname>( parameter ); 
	der Aufruf 
	    E<functionsname>( parameter ); 
	geschrieben werden. 
	Also beispielsweise statt 
	    mult( a, b, c );
	muss im SIMATH-Programm
	    Emult( a, b, c );
	stehen.                      
	Alternativ kann der Header _essen.h eingebunden werden. 
	In diesem steht z.B. "#define mult Emult".    
!!	Ausnahme: Die Funktion "quad" muss explizit in "Equad"    !!
!!	umgenannt werden, da "quad" in /usr/include/sys/types.h   !!
!!	als Typ deklariert wird.                                  !!
	Die SIMATH-Funktionen itoE und Etoi stellen  
	Typumwandlungen von Zahlen in Essener Darstellung
	in Zahlen in SIMATH-Darstellung und umgekehrt
	zur Verfuegung.
	In SIMATH-Programmen, die die Essener Arithmetik benutzen, 
	muss zusaetzlich der Header _Earith.h eingebunden 
	werden (statt dem Essener Header arith.h). 
	Fuer naehere Informationen siehe auch das Handbuch 
	zur Essener Arithmetik.     
	Es folgt eine originale Kurzbeschreibung der Funktionen:
*****************************************************************
*								*
*	Paket zum Rechnen mit langen Zahlen, Version 2.1	*
*								*
*	Programmentwicklung und Copyright:			*
*								*
*	Reiner Staszewski					*
*	Institut fuer Experimentelle Mathematik			*
*	Universitaet Gesamthochschule Essen			*
*	Ellernstr. 29						*
*	4300 Essen 12						*
*	Tel.: (0201) 32064-44					*
*								*
*****************************************************************
   Beschreibung des Moduls :
   Lange Zahlen, z.B. a, sind vom Datentyp LONG a[LAENGE],
   LAENGE = 500 (in SIMATH). LAENGE kann im File _Earith.h veraendert 
   werden, allerdings muss dann SIMATH neu uebersetzt werden.
   Dabei steht in a[0] die genaue Laenge der Zahl. 
   Beispiel : a[0] = 3
	      a[1] = 1
	      a[2] = 2
	      a[3] = 3
	      Dann bezeichnet a die ganze Zahl 
		 1 + 2*2^32 + 3*(2^32)^2
   Auf diesen langen Zahlen sind folgende Funktionen definiert :
	ARITHMETIK :
	Addition       : add(zahl1,zahl2,ergebnis)
	Incrementieren : incr(zahl)
			 zahl := zahl + 1
	Subtraktion    : sub(zahl1,zahl2,ergebnis)
		Returncode  0  falls Subtraktion erfolgreich,
			   -1  falls zahl2 > zahl1.
			       In diesem Fall hat ergebnis keinen 
			       definierten Wert!!
	Decrementieren : decr(zahl)
			 zahl := zahl - 1
		Returncode  0  falls Decrementierung erfolgreich,
			   -1  falls der Eingabeparameter == 0 ist.
	Multiplikation : mult(zahl1,zahl2,ergebnis)
	Quadrieren     : quad(zahl,ergebnis)
	Shift          : shift(zahl,anzahl_shifts,ergebnis)
		Hier ist anzahl_shifts vom Typ LONGINT !!!
	Division       : div(divident,divisor,quotient,rest)
		Returncode  0  falls Division erfolgreich,
			   -1  falls Division durch 0 auftrat.
	Exponentiation : expo(zahl1,zahl2,ergebnis)
		Hier ist zahl2 vom Typ unsigned !!!
	Quadratwurzel : wurzel(zahl,ergebnis)
		Returncode  1,  falls zahl kein Quadrat ist. In diesem Fall 
				ist ergebnis gleich dem groessten Ganzen
				der Quadratwurzel von zahl,
			    0,  falls zahl ein Quadrat ist. In diesem Fall 
				ist ergebnis gleich der Quadratwurzel von 
				zahl.
	n-te Wurzel   : n_wurzel(zahl,n,ergebnis)
		Hier ist n vom Typ unsigned !!!
		Returncode  1,  falls zahl keine n-te Potenz ist. In diesem 
				Fall ist ergebnis gleich dem groessten 
				Ganzen der n-ten Wurzel von Zahl,
			    0,  falls zahl eine n-te Potenz ist. In diesem 
				Fall ist ergebnis gleich der n-ten Wurzel 
				von zahl.
	Logarithmus : LONGINT lb(zahl)
		Returncode >= 0 : Logarithmus von zahl zur Basis 2;
		Returncode = -1 : zahl == 0
	Quersumme : LONGINT quersumme(zahl)
		Returncode : Quersumme von zahl zur Basis 2^SHORTBITS
	alternierende Quersumme : LONGINT alt_quersumme(zahl)
		Returncode : alternierende Quersumme von zahl, d.h. 
			     zahl[0]-zahl[1]+zahl[2]-+...
	Jacobi-Symbol  : jacobi(arg,modul)
		Returncode : 1,  falls arg Jacobi-symbol  1 mod modul hat,
			    -1,  falls arg Jacobi-symbol -1 mod modul hat,
			     0,  falls ggt(arg,modul) != 1 .
		modul ist ungerade !!
		(Falls modul eine Primzahl ist, dann ist das Ergebnis 
		gleich dem Legendre-Symbol)
	Vergleich      : comp(zahl1,zahl2)
		Returncode -1 falls zahl1 > zahl2
			    0 falls zahl1 = zahl2
		           +1 falls zahl1 < zahl2
	Kopieren       : trans(zahl1,zahl2)
	Zuweisung      : zuweis(zahl1,zahl2)
			 zahl1 vom Typ SHORT, zahl2 lang
			 Zuweisung : zahl2 := zahl1	
			 zuweis_int(zahl1,zahl2)
			 zahl1 ist eine Lange Zahl, zahl2 ist vom Typ long 
			 unsigned.
			 Zuweisung : zahl2 := zahl1
		 Returncode 0, falls Zuweisung erfolgreich
			   -1, falls zahl1 zu gross ist; in diesem Fall ist 
			       zahl2 undefiniert
	Gerade         : even(zahl)				
		Returncode 1, falls zahl gerade ist
			   0, falls zahl ungerade ist
	Modulo4        : mod4(zahl)
		Returncode : zahl mod 4
	Modulo8        : mod8(zahl)
		Returncode : zahl mod 8
	Zufallszahlen  : zufall(zahl,anzahl_bits)
		Eingabe : anzahl_bits : LONGINT; Anzahl der Bits von Zahl
		Ausgabe : zahl vom Typ lange Zahl
	MODULOARITHMETIK :
	Moduloaddition       : madd(zahl1,zahl2,ergebnis,modul)
	Modulosubtraktion    : msub(zahl1,zahl2,ergebnis,modul)
	Modulomultiplikation : mmult(zahl1,zahl2,ergebnis,modul)
	Moduloquadrieren     : mquad(zahl,ergebnis,modul)
	Modulodivision       : mdiv(zahl1,zahl2,ergebnis,modul)
		Returncode  0 falls ggT(zahl2,modul) teilt zahl1
			   -1 falls Division nicht moeglich
	Moduloexponentiation : mexp(zahl1,zahl2,ergebnis,modul)
	GGT                  : GGT(zahl1,modul,ergebnis,invers)
		berechnet ergebnis = ggT(zahl1,modul)
		invers mod modul mit zahl1*invers = ergebnis mod modul
	EIN-/AUSGABE (dezimal):
	Einlesen : readue(text,zahl)
		   vreadue(text,zahl)
		   readuefile(eingabefile,zahl)
	Ausgabe  : writeue(text,zahl)
		   vwriteue(text,zahl)
		   writeuefile(ausgabefile,text,zahl)
	EIN-/AUSGABE (hexadezimal):
	Einlesen : readx(text,zahl)
		   readxfile(eingabefile,zahl)
		   read_long(eingabefile,zahl)  Darstellungsabh. Lesen 
	Ausgabe  : writex(text,zahl)
		   writexfile(ausgabefile,text,zahl)	
		   write_long(ausgabefile,zahl)  Darstellungsabh. Schreiben
	EIN-/AUSGABE (binaer)
	Einlesen : readb(text,zahl)
	Ausgabe  : writeb(text,zahl)



			Etoi( e )

	"Essen integer to SIMATH integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int Etoi( e )  LONG e[];
	A = Etoi( e );
	e ist eine positive ganze Zahl gemaess den
	Konventionen des Essener Arithmetikpakets.
	A ist die Darstellung dieser Zahl als 
	SIMATH-integer (Listendarstellung).  
	siehe auch: Etoineg, itoE, itoEb, itoEsb.



			Etoineg( e )

	"Essen integer to SIMATH integer negation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int Etoineg( e )  LONG e[];
	A = Etoineg( e );
	e ist eine positive ganze Zahl gemaess den
	Konventionen des Essener Arithmetikpakets.
	A ist die Darstellung von -e (minus e) als 
	SIMATH-integer (Listendarstellung).  
	siehe auch: Etoi, itoE, itoEb, itoEsb.



			HDiadd(  )

	"Heidelberg arithmetic package: integer addition"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	Funktionen der sog. Heidelberger Arithmetik, die 
	innerhalb von SIMATH genutzt werden koennen. 
	Es folgt eine Kurzbeschreibung der wichtigsten Funktionen 
	dieses Files (die uebergebenen Parameter sind vom Typ *Integer).
	IplasI(a, b)		a += b
	IasIplI(sum, a, b)	sum = a + b		
        ImiasI(a, b)		a -= b
	IasImiI(diff, a, b)     diff = a - b
	Iinc(a)                 a++
	Idec(a)                 a--
	Ineg(a)                 a = -a
	IeqI(a, b)              return (a == b)
	IgtI(a, b)              return (a > b)
	IneI(a, b)              return (a != b)
	IgeI(a, b)              return (a >= b)
	IltI(a, b)              return (a < b)
	IleI(a, b)              return (a <= b)
  	Ige0(a)                 return (a >= 0)
  	Igt0(a)                 return (a > 0)
  	Ile0(a)                 return (a <= 0)
	Ilt0(a)                 return (a < 0)
	Ieq0(a)                 return (a == 0)
	Ieq1(a)                 return (a == 1)
	Es ist zu beachten:
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe HDiutil).
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _HDarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    die Heidelberger Originalheader iint.h usw.
	Es folgt das Copyright des Autors:
                                LibI
-
                    (Library for Large Integers)
-
Arithmetic for integers of almost unlimited size for C and C++.
Copyright 1993 by
-
        Ralf Dentzer
        IWR, Universitaet Heidelberg
        Im Neuenheimer Feld 368
        D-6900 Heidelberg, Germany
-
(The functions of LibI are usually collected in a library called libI.a)
-
LibI can be copied and distributed freely for any non-commercial
purpose.
-
If you copy LibI for somebody else, you may ask this person for refund
of your expenses. This should cover cost of media, copying and shipping.
You are not allowed to ask for more than this. In any case you must give
a copy of this copyright notice along with the program.
-
If you obtain LibI please send us a short notice to that effect, e.g.,
an e-mail message to the address 'dentzer@kalliope.iwr.uni-heidelberg.de',
containing your full name and address. This allows us to keep track of
the number of LibI users.
-
If you publish a mathematical result that was partly obtained using
LibI, please cite LibI, just as you would cite another paper that you
used. Also we would appreciate it if you could inform us about such a
paper.
-
You are permitted to modify and redistribute LibI, but you are not
allowed to restrict further redistribution. That is to say proprietary
modifications will not be allowed. We want all versions of LibI to
remain free.
-
If you modify any part of LibI and redistribute it, you must supply a
'README' document. This should specify what modifications you made in
which files. We do not want to take credit or be blamed for your
modifications.
-
Of course we are interested in all of your modifications. In particular
we would like to see bug-fixes, improvements and new functions. So again
we would appreciate it if you would inform us about all modifications you
make.
-
If you use LibI as part of other software, you should make clear in the
documentation of this software, that and how LibI was used. If you
redistribute LibI as part of your software, the restrictions stated
in this document apply. 
-
LibI is distributed by us without any warranty, to the extent permitted
by applicable state law. We distribute LibI *as is* without warranty
of any kind, either expressed or implied, including, but not limited to,
the implied warranties of merchantability and fitness for a particular
purpose.
-
The entire risk as to the quality and performance of the program is with
you. Should LibI prove defective, you assume the cost of all necessary
servicing, repair or correction.
-
In no case unless required by applicable law will we, and/or any other
party who may modify and redistribute LibI as permitted above, be
liable to you for damages, including lost profits, lost monies or other
special, incidental or consequential damages arising out of the use or
inability to use LibI.



			HDidigit(  )

	"Heidelberg arithmetic package: digit functions"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	Funktionen der sog. Heidelberger Arithmetik, die 
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Benutzung der Heidelberger Arithmetik ist generell
	zu beachten:
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe HDiutil).
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _HDarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    die Heidelberger Header iint.h etc.
	4)  Das Copyright des Autors der Heidelberger Arithmetik befindet 
	    sich in der Dokumentation zu HDiadd. 



			HDidigitvec(  )

	"Heidelberg arithmetic package: vector functions"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	Funktionen der sog. Heidelberger Arithmetik, die 
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Benutzung der Heidelberger Arithmetik ist generell
	zu beachten:
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe HDiutil).
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _HDarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    die Heidelberger Originalheader iint.h usw.
	4)  Das Copyright des Autors der Heidelberger Arithmetik befindet 
	    sich in der Dokumentation zu HDiadd. 



			HDidiv(  )

	"Heidelberg arithmetic package: integer division"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	Funktionen der sog. Heidelberger Arithmetik, die 
	innerhalb von SIMATH genutzt werden koennen. 
	Es folgt eine Kurzbeschreibung der wichtigsten Funktionen 
	dieses Files. (Die uebergebenen Parameter sind vom Typ *Integer.) 
	Idiv(q, r, a, b) 	(a,b) => q,r so dass a = b * q + r 
	IasIdiI(q, a, b)  		q = a / b
	IdiasI(q, b)                    q = q / b
	IasIreI(r, a, b)                r = a % b
	IreasI(r, b)                    r = r % b
	Achtung! Im Gegensatz zur Division in SIMATH gilt hier immer 
	r >= 0. (In iqrem(a, b, &q, &r) gilt sgn(a) = sgn(r).)
	Es ist zu beachten:
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe HDiutil).
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _HDarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    die Heidelberger Originalheader iint.h usw.
	4)  Das Copyright des Autors der Heidelberger Arithmetik befindet 
	    sich in der Dokumentation zu HDiadd. 



			HDigcd(  )

	"Heidelberg arithmetic package: greatest common divisor"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	Funktionen der sog. Heidelberger Arithmetik, die 
	innerhalb von SIMATH genutzt werden koennen. 
	Es folgt eine Auflistung der Funktionen dieses Files. (Alle
 	Variablen sind vom Typ *Integer.):
	Idgcd(d, a, b)   	d = gcd(a, b);   Euklidischer 
				Algorithmus, Division mit Rest   
        Ibgcd(d, a, b)   	d = gcd(a, b);   binaerer Algorithmus, 
     	Ielba(d, u, v, a, b)	d = gcd(a, b) = ua + vb;   Euklid-Lenstra-
				Berlekamp
	Ibelba(d, u, v, a, b)	d = gcd(a, b) = u*a + v*b;  binaerer 
				Algorithmus              
	Ireduce(a, b)        	Kuerze gcd von a und b 
	Bei der Benutzung der Heidelberger Arithmetik ist generell
	zu beachten:
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe HDiutil). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _HDarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    die Heidelberger Originalheader iint.h usw.
	4)  Das Copyright des Autors der Heidelberger Arithmetik befindet 
	    sich in der Dokumentation zu HDiadd. 



			HDiio(  )

	"Heidelberg arithmetic package: I/O functions"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	Funktionen der sog. Heidelberger Arithmetik, die 
	innerhalb von SIMATH genutzt werden koennen. 
	Es folgt eine Auflistung der wichtigstens Funktionen dieses 
	Files. (a ist vom Typ *Integer, fp vom Typ FILE, s ein string.):
	fscanI(fp, a)
	fprintI(fp, a)
        Itoa(n, s)  
     	atoI(s, n)
	Bei der Benutzung der Heidelberger Arithmetik ist generell
	zu beachten:
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe HDiutil). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _HDarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    die Heidelberger Originalheader iint.h usw.
	4)  Das Copyright des Autors der Heidelberger Arithmetik befindet 
	    sich in der Dokumentation zu HDiadd. 



			HDimem(  )

	"Heidelberg arithmetic package: memory management"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	Funktionen der sog. Heidelberger Arithmetik, die 
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Benutzung der Heidelberger Arithmetik ist generell
	zu beachten:
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe HDiutil). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _HDarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    die Heidelberger Originalheader iint.h usw.
	4)  Das Copyright des Autors der Heidelberger Arithmetik befindet 
	    sich in der Dokumentation zu HDiadd. 



			HDimul(  )

	"Heidelberg arithmetic package: integer multiplication"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	Funktionen der sog. Heidelberger Arithmetik, die 
	innerhalb von SIMATH genutzt werden koennen. 
	Es folgt eine Kurzbeschreibung der wichtigsten Funktionen 
	diese Files. (Die uebergebenen Parameter sind vom Typ *Integer.):
	IasImuI (p, a, b)		p = a * b
	ImuasI(a, b)			a *= b
	IasIsrint(a, b, count)          a = b >> count
	Israsint(a, count)		a = a >> count
	IasIslint(a, b, count)          a = b << count
	Islasint(a, count) 		a = a << count
	Isr1( a )			a = a >> 1
	Ieven(a)                        return (a gerade?)
	Es ist zu beachten:
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe HDiutil). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _HDarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    die Heidelberger Originalheader iint.h etc.
	4)  Das Copyright des Autors der Heidelberger Arithmetik befindet 
	    sich in der Dokumentation zu HDiadd. 



			HDiutil(  )

	"Heidelberg arithmetic package: utilities"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	Funktionen der sog. Heidelberger Arithmetik, die 
	innerhalb von SIMATH genutzt werden koennen. 
	Es folgt eine Auflistung der wichtigstens Funktionen dieses 
	Files. (a, b ist vom Typ *Integer, i vom Typ single.):
	cI(a)		construction 
	dI(a)           destruction
	IasI(a, b)      a = b                              
	Iasint(a, i)	a = i                                   
	Ilog(a)		return (ganzzahliger Anteil von log2( |a| ), 
			bzw -1 falls a==0)
	longasI (a)     i = a (falls moeglich)
	siehe auch Dokumentation zu Itoi, itoI.
	Bei der Benutzung der Heidelberger Arithmetik ist generell
	zu beachten:
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe HDiutil).
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _HDarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    die Heidelberger Originalheader iint.h usw.
	4)  Das Copyright des Autors der Heidelberger Arithmetik befindet 
	    sich in der Dokumentation zu HDiadd. 



			Itoi( h )

	"( Heidelberg ) Integer to ( SIMATH ) integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	int Itoi(h)  Integer *h;
	A = Itoi(h);
	*h ist eine ganze Zahl gemaess den Konventionen des 
	Heidelberger Arithmetikpakets.
	A ist die Darstellung dieser Zahl als 
	SIMATH-integer (Listendarstellung).  
	siehe auch: itoI.



			KstrtoS( a )

	"Kant string to SIMATH"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	obj KstrtoS( a )  char *a;
	A = KstrtoS( a );
	a ist ein String gemaess den SIMATH-Kant-Konvertie-
	rungskonventionen (SDSD, s.u.). 
	A enthaelt den im String kodierten Wert als SIMATH-
	Variable.
	Bemerkung zur SDSD (string data storage definition): 
	Ein String gemaess SDSD ist von der Form 
		"[x]y[nn]#data"
	Dabei ist x = p, m; y = I, R, Q; nn die Angabe der 
	Kant-Praezision, falls y = R. 
	Fuer data gilt im Fall
	x = p:  data ist von der Form 
		a(n)*x^e(n)+...+a(0)*x^e(0), 
		a(i) ist vom Typ, der in y kodiert ist (im 
		folgenden mit T(y) bezeichnet), e(i) ist
		Integer. A ist in diesem Fall ein Polynom 
		ueber T(y).
	x = m:  data ist von der Form 
		m n  a11 a12... amn
		A ist eine m x n Matrix ueber T(y).
	y = I:  data wird als Integer interpretiert. 
	y = R:  data ist von der Form nnn.nnn und wird 
		als floating point interpretiert. 
		Entscheidend fuer die Genauigkeit ist nur 
		der Wert der SIMATH-Konstante FL_EPS (siehe 
		dazu flinit)!
		Die Angabe der Kant-Praezision hat auf A 
		keinen Einfluss.
	y = Q:  data ist von der Form nnn/nnn und wird 
		als rationale Zahl interpretiert. 



			KtoS( struc, data, type )

	"Kant to SIMATH"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	obj KtoS( a )  t_handle struc, data; single type;
	A = KtoS( struc, data, type );
	A hat den in struc und data kodierten Wert als  
	SIMATH-Variable.
	Soll A vom Typ matrix sein, so ist type = 32 zu 
	uebergeben. Sonst ist type = 0 zu waehlen.
	Zur Umwandlung wird ein String benoetigt (siehe KstrtoS),
	dessen Groesse durch die globale (veraenderbare) Variable 
	KS_MEM_MAX festgelegt ist. Bei sehr grossen Objekten D sollte 
	gegebenenfalls der Wert von KS_MEM_MAX heraufgesetzt werden. 
	Hinweis: Der Gebrauch dieser Funktion setzt die Installation des
	Computeralgebrasystems Kant auf Ihrem Rechner voraus!         



			PAFadd(  )

	"Papanikolaou floating point package: addition"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h, _HDarith.h
	    als auch den Originalheader ffloat.h
	Es folgt eine Beschreibung  der wichtigsten Funktionen nach 
	Th. Papanikolaou:
*
* filename        : add.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFplF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *sum, *x, *y
* return value    : void
* extern          : FasF(), Fnormalize(), Israsint(), Islasint()
*                   IasIplI()
* error messages  : none
* side effects    : none
* algorithm       : sum = x + y in time O(t) where t the precision
*
*****************************************************************
*
* filename        : add.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FplasF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *sum, *y
* return value    : void
* extern          : cFasF(), FasFplF(), dF()
* error messages  : none
* side effects    : none
* algorithm       : sum += y in time O(t) where t the precision
*
*****************************************************************
*
* filename        : add.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFplint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *sum,*x int i
* return value    : void
* extern          : cFasint(), FasFplF(), dF()
* error messages  : none
* side effects    : none
* algorithm       : sum = x + i in time O(t) where t the precision
*
*****************************************************************
*
* filename        : add.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fplasint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *sum, int i
* return value    : void
* extern          : cFasint(), FplasF(), dF()
* error messages  : none
* side effects    : none
* algorithm       : sum += i in time O(t) where t the precision
*
*****************************************************************
*
* filename        : add.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Finc
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *sum
* return value    : void
* extern          : Fplasint()
* error messages  : none
* side effects    : none
* algorithm       : sum++ in time O(t) where t the precision
*
*****************************************************************



			PAFassign(  )

	"Papanikolaou floating point package: assignments"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h
	Es folgt eine Beschreibung  der wichtigsten Funktionen nach 
	Th. Papanikolaou:    
*
* filename        : assign.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasF, FasI, Fasdbl, Fasint, Fas1, Fas0, IasF,
*                   dblasF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : see function declaration
* return value    : void
* extern          : cFmaxlength(), dF(), Feq0(), Fnorm(), Frndtoi(),
*                   IasI(), Iasint(), Islasint(), frexp()
* error messages  : dblasF: Impossible assignment double = Float!
* side effects    : none
* algorithm       : x = y in time O(log(t)) where t the precision
*                   of y
*



			PAFcomp(  )

	"Papanikolaou floating point package: comparisons"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h
	Es folgt eine Beschreibung der Funktionen nach Th. Papanikolaou:
*
* filename        : comp.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FeqF, FneF, FgtF, FgeF, FltF, FleF, Feq0,
*                   Fis0, Fne0, Fgt0, Fge0, Flt0, Fle0, FcompF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : see function declarations
* return value    : void
* extern          : Fnormalize(), Flength(), IeqI(), IgtI()
* error messages  : none
* side effects    : none
* algorithm       : comparisons of arguments in time O(log(t))
*                   where t the precision of the smallest argu
*                   ment
*



			PAFcon(  )

	"Papanikolaou floating point package: construction"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe unten).
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung  der wichtigsten Funktionen nach 
	Th. Papanikolaou:
*
* filename        : con.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): cF, cFasF, cFasI, cFasdbl, cFasint, cFasuint,
*                   cFaslong, cFasulong, cFmaxlength, dF, ncF,
*                   ncFasF, ncFasI, ncFasdbl, ncFmaxlength, ddF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : see function declarations
* return value    : void or Float *
* extern          :
* error messages  :
* side effects    : none
* algorithm       : construct x in time O(1)
*



			PAFdiv(  )

	"Papanikolaou floating point package: division"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung der Funktionen nach Th. Papanikolaou:
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFdiF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot, *x, *y
* return value    : void
* extern          : Fnormalize(), Israsint(), Islasint(),
*                   IasIdiI(), IdiasI(), ImuasI()
* error messages  : none
* side effects    : none
* algorithm       : quot = x / y in time O(t^log(3)) where t the
*                   precision
*
*****************************************************************
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFdiF1
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot, *x, *y
* return value    : void
* extern          : Fnormalize(), Israsint(), Islasint(),
*                   IasIdiI()
* error messages  : none
* side effects    : none
* algorithm       : quot = x / y in time O(t^log(3)) where t the
*                   precision
*
*****************************************************************
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFdiF1
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot, *x, *y
* return value    : void
* extern          : cFasF, FasFdiF(), dF()
* error messages  : none
* side effects    : none
* algorithm       : quot /= y in time O(t^log(3)) where t the
*                   precision
*
*****************************************************************
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFdiint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot,*x, int i
* return value    : void
* extern          : Fnormalize(), Islasint(), IasIdiD()
* error messages  : none
* side effects    : none
* algorithm       : quot = x / i in time O(t) where t the precision
*
*****************************************************************
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFdiint1
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot,*x, int i
* return value    : void
* extern          : Fnormalize(), Islasint(), IasIdiD()
* error messages  : none
* side effects    : none
* algorithm       : quot = x / i in time O(t) where t the precision
*
*****************************************************************
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fdiasint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot, int i
* return value    : void
* extern          : Fnormalize(), Islasint(), IdiasD()
* error messages  : none
* side effects    : none
* algorithm       : quot /= i in time O(t) where t the precision
*
*****************************************************************
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fdiasint1
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot, int i
* return value    : void
* extern          : Fnormalize(), Islasint(), IdiasD()
* error messages  : none
* side effects    : none
* algorithm       : quot /= i in time O(t) where t the precision
*
*****************************************************************
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasintdiF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot, int i, Float *x
* return value    : void
* extern          : Fnormalize(), cIasint(), Islasint(), IasIdiI()
*                   dI()
* error messages  : none
* side effects    : none
* algorithm       : quot = i / x in time O(t) where t the precision
*
*****************************************************************
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasintdiF1
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot, int i, Float *x
* return value    : void
* extern          : Fnormalize(), cIasint(), Islasint(), IasIdiI()
*                   dI()
* error messages  : none
* side effects    : none
* algorithm       : quot = i / x in time O(t) where t the precision
*
*****************************************************************
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fasintdiint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot, int s, int t
* return value    : void
* extern          : Fnormalize(), Iasint(), Islasint(), IdiasD()
* error messages  : none
* side effects    : none
* algorithm       : quot = s / t in time O(t) where t the precision
*
*****************************************************************
*
* filename        : div.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fasintdiint1
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *quot, int s, int t
* return value    : void
* extern          : Fnormalize(), Iasint(), Islasint(), IdiasD()
* error messages  : none
* side effects    : none
* algorithm       : quot = s / t in time O(t) where t the precision
*



			PAFglob(  )

	"Papanikolaou floating point package: globals"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h
	Es folgt eine Beschreibung der Funktionen nach 
	Th. Papanikolaou:
*
* filename        : glob.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fsetprec
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : long
* return value    : void
* extern          : ceil()
* error messages  : none
* side effects    : none
* algorithm       : sets the precision to t digits in time O(1)
*



			PAFio(  )

	"Papanikolaou floating point package: I/O-functions"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung der Funktionen nach Th. Papanikolaou:
*
* filename        : io.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Flog2
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *x
* return value    : int
* extern          : Ilog()
* error messages  : none
* side effects    : none
* algorithm       : return log2(x) in time O(log(t)) where t the
*                   precision of x
*
*****************************************************************
*
* filename        : io.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): atoF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : char s[], Float *n
* return value    : int
* extern          : Fnormalize(), Flength(), Israsint(), IdiasI(),
*                   Islasint(), ImuasD(), atoI(), cIasint(), dI(),
*                   isdigit(), malloc(), free(), atol(), strlen().
*                   abs()
* error messages  : none
* side effects    : none
* algorithm       : convert a string to Float in time O(t^2) where
*                   t the precision
*
*****************************************************************
*
* filename        : io.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Ftoa
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : char s[], Float *n
* return value    : int
* extern          : Fnormalize(), Fmuas10(), cFasF(), dF(),
*                   Israsint(), atoI(), Islasint(), Iinc(), Itoa(),
*                   cIasint(), dI(), strlen(), strcat(), abs()
* error messages  : none
* side effects    : none
* algorithm       : convert a Float to a string in time O(t) where
*                   t the precision
*
*****************************************************************
*
* filename        : io.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): fprintF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : FILE *fp, Float *a
* return value    : int
* extern          : Ftoa(), Ilog(), Ifree(), putc(), malloc(),
*                   free(), sizeof()
* error messages  : fprintF: no memory available
* side effects    : none
* algorithm       : writes a Float into a file in time O(t) where
*                   t the precision
*
*****************************************************************
*
* filename        : io.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): fscanF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : FILE *fp, Float *a
* return value    : int
* extern          : atoF(), getc(), malloc(), free(), sizeof(),
*                   fseek()
* error messages  : fprintF: no memory available
* side effects    : none
* algorithm       : writes a Float into a file in time O(t) where
*                   t the precision
*
*****************************************************************
*
* filename        : io.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): printF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : char *msg, Float *a
* return value    : int
* extern          : Flog2(), Ftoa(), malloc(), free(), sizeof(),
*                   printf()
* error messages  : fprintF: no memory available
* side effects    : none
* algorithm       : writes a Float into a file in time O(t) where
*                   t the precision
*



			PAFmul(  )

	"Papanikolaou floating point package: multiplication"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung der Funktionen nach Th. Papanikolaou:
*
* filename        : mul.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFmuF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *prod, *x, *y
* return value    : void
* extern          : Fnormalize(), Israsint(), Islasint(),
*                   IasImuI()
* error messages  : none
* side effects    : none
* algorithm       : prod = x * y in time O(t^log(3)) where t the
*                   precision
*
*****************************************************************
*
* filename        : mul.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FmuasF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *prod, *y
* return value    : void
* extern          : Fnormalize(), Israsint(), Islasint(), ImuasI()
* error messages  : none
* side effects    : none
* algorithm       : prod *= y in time O(t^log(3)) where t the
*                   precision
*
*****************************************************************
*
* filename        : mul.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFmuint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *prod,*x int i
* return value    : void
* extern          : Fnormalize(), IasImuD()
* error messages  : none
* side effects    : none
* algorithm       : prod = x * i in time O(t) where t the precision
*
*****************************************************************
*
* filename        : mul.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fmuasint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *prod, int i
* return value    : void
* extern          : Fnormalize(), ImuasD()
* error messages  : none
* side effects    : none
* algorithm       : prod *= i in time O(t) where t the precision
*
*****************************************************************
*
* filename        : mul.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFmu10
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *prod,*x int i
* return value    : void
* extern          : Fnormalize(), Ias1(), ImuasD(), ImuasI()
* error messages  : none
* side effects    : none
* algorithm       : prod = x * 10^i in time O(t^log(3)) where t
*                   the precision
*
*****************************************************************
*
* filename        : mul.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFmu10
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *prod, int i
* return value    : void
* extern          : ImuasD()
* error messages  : none
* side effects    : none
* algorithm       : prod *= 10^i in time O(t^log(3)) where t
*                   the precision
*



			PAFshift(  )

	"Papanikolaou floating point package: shiftings"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung der Funktionen nach Th. Papanikolaou:
*
* filename        : shift.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFslF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *res, *x, int i
* return value    : void
* extern          : IasI(), Islasint()
* error messages  : none
* side effects    : none
* algorithm       : res = x << i in time O(log(t)) where t the
*                   precision
*
*****************************************************************
*
* filename        : shift.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fslasint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *res, int i
* return value    : void
* extern          : Islasint()
* error messages  : none
* side effects    : none
* algorithm       : res <<= i in time O(log(t)) where t the
*                   precision
*
*****************************************************************
*
* filename        : shift.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFsrF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *res, *x, int i
* return value    : void
* extern          : IasI()
* error messages  : none
* side effects    : none
* algorithm       : res = x >> i in time O(log(t)) where t the
*                   precision
*
*****************************************************************
*
* filename        : shift.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fsrasint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *res, int i
* return value    : void
* extern          : none
* error messages  : none
* side effects    : none
* algorithm       : res >>= i in time O(1)
*



			PAFsub(  )

	"Papanikolaou floating point package: subtraction"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung der Funktionen nach Th. Papanikolaou:
*
* filename        : sub.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFmiF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *dif, *x, *y
* return value    : void
* extern          : FasFplF()
* error messages  : none
* side effects    : none
* algorithm       : dif = x - y in time O(t) where t the precision
*
*****************************************************************
*
* filename        : sub.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FmiasF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *dif, *y
* return value    : void
* extern          : cFasF(), FasFplF(), dF()
* error messages  : none
* side effects    : none
* algorithm       : dif -= y in time O(t) where t the precision
*
*****************************************************************
*
* filename        : sub.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFplint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *dif,*x int i
* return value    : void
* extern          : cFasint(), FasFplF(), dF()
* error messages  : none
* side effects    : none
* algorithm       : dif = x - i in time O(t) where t the precision
*
*****************************************************************
*
* filename        : sub.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fmiasint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *dif, int i
* return value    : void
* extern          : cFasint(), FplasF(), dF()
* error messages  : none
* side effects    : none
* algorithm       : dif -= i in time O(t) where t the precision
*
*****************************************************************
*
* filename        : sub.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fdec
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *dif
* return value    : void
* extern          : Fplasint()
* error messages  : none
* side effects    : none
* algorithm       : dif-- in time O(t) where t the precision
*



			PAFtofl( x )

	"Papanikolaou floating point to ( SIMATH ) floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	int PAFtofl(x)  Float *x;
	f = PAFtofl(x);
	*x ist eine floating point Zahl gemaess den Konventionen 
	des Papanikolaou floating point package. f ist die 
	Darstellung dieser Zahl als SIMATH-floating point 
	(Listendarstellung).  
	siehe auch: fltoPAF.



			PAFtrans1(  )

	"Papanikolaou floating point package: transcendental functions 1"    
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung der Funktionen nach Th. Papanikolaou:
*
* filename        : trans1.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fsqrt
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fsqrt needs real arguments!
*                   Fsqrt needs arguments >= 0!
* side effects    : none
* algorithm       : y = sqrt(x) in time O(log(t)) where t the
*                   precision using the Newton method for
*                   f(z) = z^2 - x (= 0)
*
*****************************************************************
*
* filename        : trans1.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fexp
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fexp needs a real argument
* side effects    : none
* algorithm       : y = exp(x) in time O(sqrt(t) t^log3) where t
*                   the precision using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans1.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Flog
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Flog needs a real argument!
*                   Flog needs an argument > 0!
* side effects    : none
* algorithm       : y = log(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans1.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fsqr
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *z, *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : z = x ^ 2 in time O(t^log3) where t
*                   the precision, using the trivial method.
*
*****************************************************************
*
* filename        : trans1.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FsqrF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *z
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : z = z ^ 2 in time O(t^log3) where t
*                   the precision, using the trivial method.
*
*****************************************************************
*
* filename        : trans1.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFpowF
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *z, *y, *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : z = x ^ y in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans1.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): FasFpowint
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *x, *a, int n
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : x = a ^ n in time O(log(n) t^log3) where t
*                   the precision,  using the binary method.
*



			PAFtrans2(  )

	"Papanikolaou floating point package: transcendental functions 2"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung der Funktionen nach Th. Papanikolaou:
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fe
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : x = e = exp(1) using the modified Taylor series 
*                   in time O(t) where t the precision
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fpi
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : x = pi using the Ramanujans series for
*                   1/(2 pi sqrt(2)) in time O(t) where t the
*                   precision
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fpi1
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : x = pi using Chudnovskys series for 1/pi,
*                   Lecture Notes in Pure and applied Mathematics,
*                   Vol. 113, Computer Algebra in time O(t) where
*                   t the precision
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Feuler
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : x = gamma using Brent's method in time O(t^2). See
*                   Some new Algorithms for High-Precision Calcu-
*                   lation of Euler's constant, Mathematics of
*                   Computation, Vol. 34, Number 149, Jan. 1980
*                   Pages 305-312
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fcatalan
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : x = catalan using Cauley Platform Method
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fbesselj
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x, int n
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : y = Jn(x) in time O(t^2) using the series
*                   expansion
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fsin
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fsin needs a real argument!
* side effects    : none
* algorithm       : y = sin(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fcos
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fcos needs a real argument!
* side effects    : none
* algorithm       : y = cos(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Ftan
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Ftan needs a real argument!
* side effects    : none
* algorithm       : y = tan(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fcot
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fcot needs a real argument!
* side effects    : none
* algorithm       : y = cot(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fsinh
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : y = sinh(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fcosh
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : y = cosh(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Ftanh
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : y = tanh(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans2.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fcoth
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : y = coth(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*



			PAFtrans3(  )

	"Papanikolaou floating point package: transcendental functions 3"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung der Funktionen nach Th. Papanikolaou:
*
* filename        : trans3.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fasin
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fasin needs a real argument!
* side effects    : none
* algorithm       : y = asin(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans3.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Facos
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fasin needs a real argument!
* side effects    : none
* algorithm       : y = acos(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans3.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fatan
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fasin needs a real argument!
* side effects    : none
* algorithm       : y = atan(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans3.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fatan2
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *z, *y, *x
* return value    : void
* extern          :
* error messages  : Fatan2 needs real arguments!
* side effects    : none
* algorithm       : z = atan2(y, x) in time O(sqrt(t) t^log3) where t
*                   the precision. (A four quadrant arctan function
*                   returns arctan of y/x in range from pi to -pi)
*
*****************************************************************
*
* filename        : trans3.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Facot
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fasin needs a real argument!
* side effects    : none
* algorithm       : y = acot(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans3.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fasinh
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fasinh needs a real argument!
* side effects    : none
* algorithm       : y = asinh(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans3.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Facosh
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Facosh needs a real argument!
* side effects    : none
* algorithm       : y = acosh(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans3.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fatanh
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Fatanh needs a real argument!
* side effects    : none
* algorithm       : y = atanh(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*
*****************************************************************
*
* filename        : trans3.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Facoth
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  : Facoth needs a real argument!
* side effects    : none
* algorithm       : y = acoth(x) in time O(sqrt(t) t^log3) where t
*                   the precision,  using Brent's method.
*                   The algorithm is described in: R.P. Brent, The
*                   Complexity of Multiple-Precision Arithmetic
*                   (in Complexity of Computational Problem Solving,
*                   Univ. of Queensland Press, Brisbane, 1976,
*                   126-165).
*



			PAFtype(  )

	"Papanikolaou floating point package: typer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith.h eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung der Funktionen nach Th. Papanikolaou:
*
* filename        : type.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fisint, Fisuint, Fislong, Fisulong, Fisdbl
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *x
* return value    : BOOLEAN
* extern          :
* error messages  :
* side effects    : none
* algorithm       : time O(1)
*



			PAFutil(  )

	"Papanikolaou floating point package: utilities"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	Funktionen der Arithmetik von Th. Papanikolaou, die
	innerhalb von SIMATH genutzt werden koennen. 
	Bei der Verwendung dieser Funktionen innerhalb von SIMATH 
	muessen folgende Punkte beachtet werden: 
	1)  Die verwendeten Datentypen entsprechen nicht SIMATH- 
	    Konventionen. Zur Speicherverwaltung muessen spezielle
	    Funktionen verwendet werden (siehe PAFcon). 
	2)  Der SIMATH-Datentyp 'vec' darf nicht verwendet werden;
	    als Ersatz koennen Vektoren als Objekt (obj) definiert
	    werden. 
	3)  In jedes Programm muss der Header _PAFarith eingebunden 
	    werden. Dieser Header umfasst sowohl _simath.h als auch 
	    den Originalheader ffloat.h sowie _HDarith.h.
	Es folgt eine Beschreibung der wichtigsten Funktionen nach 
	Th. Papanikolaou:
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fabs
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : x = |x| = abs(x) in time O(1)
*
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fneg
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : x = -x in time O(1)
*
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Ftrunc
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : y = integer part of x in time O(log(fractional
*                   part)
*
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Frndtoi
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : y = nearest integer of x in time O(log(t))
*
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fceil
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : y = round to ceil of x in time O(log(t))
*
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Ffloor
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : Float *y, *x
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : y = round to floor x in time O(log(t))
*
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fsign, Fsetsign, Fexpo, Fsetexpo, Ftype,
*                   Fsettype
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : see function declarations
* return value    : see function declarations
* extern          :
* error messages  :
* side effects    : none
* algorithm       : time O(1)
*
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Ferror
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : char *msg
* return value    : void
* extern          :
* error messages  :
* side effects    : none
* algorithm       : print msg ane exit in time O(1)
*
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Flead0s, Fleadzeros, Flength
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : see function declarations
* return value    : see function declarations
* extern          :
* error messages  :
* side effects    : none
* algorithm       : return the leading zeros of an int (of a Float)
*                   in time O(1), return the length of the mantisse
*
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fbinul, Fbinary
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : see ...
* return value    : see ...
* extern          :
* error messages  :
* side effects    : none
* algorithm       : print the binary representation of x in time
*                   O(log(t)) where t ist the length of x
*
*****************************************************************
*
* filename        : util.c
* author          : Papanikolaou Thomas
* date            : Mon Feb  8 21:02:40 MET 1993
* function name(s): Fnorm, Froundb, Fnormalize
* last change     : Mon Feb  8 21:02:40 MET 1993
* arguments       : see ...
* return value    : see ...
* extern          :
* error messages  :
* side effects    : none
* algorithm       : normalisation of x in time O(log(t))
*
*****************************************************************



			StoK( D, struc, data, type, digits )

	"SIMATH to Kant"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single StoK(D, struc, data, type, digits)  
		obj D; t_handle *struc, *data;  single type, digits; 
	s = StoK(D, struc, data, type, digits); 
	D ist ein SIMATH-Objekt und wird in das entsprechende 
	Kant-Objekt umgewandelt. digits ist die Kant-Praezision,  
	falls type einen floating-point repraesentiert, sonst beliebig.      
	Der Wert von type kann anhand folgender Tabelle ermittelt 
	werden. (Alternativ kann der Header str_to_kant.h benutzt
	werden, der mit Kant ausgeliefert wird):
	   type       	|   D wird interpretiert als
	    1  		|   Integer
	    2	   	|   Floating-point mit Kant-prezision prec
	    3           |   rationale Zahl    
	   16 + x       |   Polynom ueber den in x kodierten Typ 
			|   ( x = 1, 2 oder 3 )      
	   32 + x	|   Matrix ueber den in x kodierten Typ
			|   ( x = 1, 2 oder 3 )      
	Zur Umwandlung wird ein String benoetigt (siehe StoKstr),
	dessen Groesse durch die globale (veraenderbare) Variable 
	KS_MEM_MAX festgelegt ist. Bei sehr grossen Objekten D sollte 
	gegebenenfalls der Wert von KS_MEM_MAX heraufgesetzt werden. 
	Hinweis: Der Gebrauch dieser Funktion setzt die Installation des
	Computeralgebrasystems Kant auf Ihrem Rechner voraus!         
	s = 0. 



			StoKstr( str, D, typ, prec )

	"SIMATH to Kant string"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single StoKstr( str, D, typ, prec )  char *str; obj D; 
		single typ, prec;
	s = StoKstr( str, D, typ, prec );  
	str ist ein String, D ein SIMATH-Objekt, typ der Typ 
	diese Objektes (siehe unten), prec die Anzahl der
	ausgegebenen Nachkommastellen und der Kant-Praezision,  
	falls Typ einen floating-point repraesentiert.      
	D wird gemaess den SIMATH-Kant-Konvertierungskonventionen 
	(SDSD) auf den String str geschrieben (siehe dazu auch 
	die Dokumentation zu KstrtoS). 
	Der Wert von Typ kann anhand folgender Tabelle ermittelt 
	werden. (Alternativ kann der Header str_to_kant.h benutzt
	werden.)
	   typ       	|   D wird interpretiert als
	    1  		|   Integer
	    2	   	|   Floating-point mit Kant-prezision prec
	    3           |   rationale Zahl    
	   16 + x       |   Polynom ueber den in x kodierten Typ 
			|   ( x = 1, 2 oder 3 )      
	   32 + x	|   Matrix ueber den in x kodierten Typ
			|   ( x = 1, 2 oder 3 )      



			abnfrelcl( q, g )

	"abelian number field relative class number"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	int abnfrelcl(q,g)  single q,g;
	H = abnfrelcl(q,g);
	q ist eine ungerade Primzahlpotenz, g ein Teiler von phi(q).
	H ist die Relativklassenzahl h- des abelschen Zahlkoerpers vom
	Fuehrer q und Grad g, d.h. des Teilkoerpers K des q-ten
	Kreisteilungskoerpers vom Grad g ueber Q. (Dieser ist eindeutig
	bestimmt, weil (Z/qZ)* zyklisch ist. Der Fuehrer eines abelschen
	Zahlkoerpers ist genau dann eine Potenz von p, wenn p die 
	einzige verzweigte Primzahl ist.) 
	Falls K reell ist, dann ist H=1.
	Zur Berechnung wird die Resultante von X^(d/2)+1 und einem
	gewissen anderen Polynom gebildet (was dem Produkt gewisser
	Charaktersummen entspricht).
	Vgl. auch abnfrelclmp.
	Falls q keine Primzahlpotenz oder g kein Teiler von phi(q)
	ist, wird ERROR zurueckgeliefert.



			abnfrelclmp( m, q, g )

	"abelian number field relative class number modulo prime"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	int abnfrelclmp(m,q,g)  int m; single q,g;
	H = abnfrelclmp(m,q,g);
	m ist Primzahl mit ggT(m,q)=1.
	q ist eine ungerade Primzahlpotenz, g ein Teiler von phi(q).
	0 <= H < m.
	H ist die Relativklassenzahl mod m des abelschen Zahlkoerpers vom
	Fuehrer q und Grad g, d.h. des Teilkoerpers K des q-ten
	Kreisteilungskoerpers vom Grad g. (Dieser ist eindeutig
	bestimmt, weil (Z/qZ)* zyklisch ist.) Falls K reell ist,
	dann ist H=1.
	Zur Berechnung wird die Resultante von X^(d/2)+1 und einem
	gewissen anderen Polynom gebildet (was dem Produkt gewisser
	Charaktersummen entspricht).
	Falls q keine Primzahlpotenz oder g kein Teiler von phi(q)
	ist, wird ERROR zurueckgeliefert.



			affmsp1decl( p, F, P )

	"algebraic function field over modular single prime, transcendence 
	 degree 1, decomposition law"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	list affmsp1decl(p, F, P)  single p; pol F,P;
	L = affmsp1decl(p, F, P);
	p ist eine single Primzahl.
	R bezeichne den Polynomring (Z/pZ) [x], wobei x eine Unbestimmte
	ueber Z/pZ sei.
	K bezeichne den rationalen Funktionenkoerper (Z/pZ) (x).
	F ist ein normiertes, irreduzibles und separables Polynom
	in einer Unbestimmten ueber R mit Grad(F) > 1.
	P ist ein normiertes Primpolynom aus R.
	Sei z eine Nullstelle von F.
        L = (e_1, f_1, ..., e_r, f_r) ist eine Liste von singles (r > 0),
	so dass in O, dem Ring der ganzen Zahlen in K[z], das von P
	erzeugte Ideal die Zerlegung (P) = P_1 ^ e_1 * ... * P_r ^ e_r
	besitzt, wobei fuer 1 <= i <= r jeweils P_i ein Primideal in O ist.
        K_(P_i) ( der Restklassenkoerper O modulo P_i) hat Grad f_i ueber
        R / P * R, dem Koerper mit p^Grad(P) Elementen.
	M.a.W. ist L die Liste der Verzweigungsindizes und Restklassengrade
	von P in K[z].



			afmsp1coreal( p, F, P, Q, mp )

	"algebraic function over modular single primes, transcendence
	degree 1, core algorithm"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	list afmsp1coreal(p,F,P,Q,mp)  single p; pol F, P, Q, mp;
	M = afmsp1coreal(p,F,P,Q,mp);                       
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist, und y eine Unbestimmte ueber (Z/pZ) (x) - dem
        rationalen Funktionenkoerper ueber (Z/pZ).
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x), d.h. F ist ein normiertes, separables Polynom in y
	ueber dem Polynomring (Z/pZ) [x].
	P ist ein normiertes, irreduzibles Polynom aus (Z/pZ) [x] und
        Q ist eine Potenz von P.
	Das Produkt von Q mit einem beliebigen Element der P - maximalen
	Ueberordnung der Polynomordnung von F liegt in der Polynomordnung.
	Es muss u := y mod (F) P - primaer sein.
	mp ist das P - Minimalpolynom von u, d.h. der modulo P eindeutig
	bestimmte irreduzible Faktor des definierenden Polynoms F.
	Nun ist entweder M eine Liste, die aus einer CD - Matrix besteht,
	deren Zeilen CD - Polynome und diese wiederrum Elemente obiger
	Algebra repraesentieren ( siehe cdprfmsp1fcl und cdmarfmsp1id ),
	so dass diese Elemente eine (Z/pZ) [x] - Basis der P - maximalen
	Ueberordnung der Polynomordnung von F darstellen.
	Oder M ist eine Liste aus zwei Listen ( Lfac, Lort ), so dass
	Lfac = ( f1, f2 ) aus zwei normierten Polynomen in y ueber
	(Z/pZ) [x] besteht und Lort = ( e1, e2 ) aus zwei CD - Polynomen
	ueber (Z/pZ) (x) besteht, die Elemente der Algebra repraesentieren
	und es gilt:
	F = f1 * f2 mod ( Q^2 * (Z/pZ) [x] ) [y];
	e1 + e2 = 1 mod ( Q^2 * (Z/pZ) [x] ) [u];
	e1 * e2 = 0 mod ( Q^2 * (Z/pZ) [x] ) [u];
	e1 und e2 sind modulo ( Q^2 * (Z/pZ) [x] ) [u] idempotent.



			afmsp1expsp( p, F, a, e, M )

	"algebraic function over modular single prime, transcendence
	degree 1, exponentiation special"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	pol afmsp1expsp(p,F,a,e,M) single p; pol F,a; int e; pol M;
	c = afmsp1expsp(p,F,a,e,M);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x] und obige
	Algebra entstehe durch Adjunktion einer Nullstelle u von F.
	a ist ein Element dieser Algebra und wird durch ein CD - Polynom
	repraesentiert ( siehe cdprfmsp1fcl ). e ist eine nicht negative
	single. M ist ein Polynom in x ueber (Z/pZ).
	c ist gleich a^e in obiger Algebra und wird durch ein CD-Polynom
	repraesentiert.
	Fuer ein Polynom M ungleich dem Nullpolynom sind alle Produkte,
	die fuer die Berechnung von c gebildet werden, reduziert modulo
	( M * (Z/pZ)[x] ) [u] ( siehe afmsp1prodsp ).



			afmsp1idpval( p, F, P, a0, a2, wa, b2, wb, py, pwy )

	"algebraic function over modular single primes, transcendence
	degree 1, increasing the denominator of the P-star value"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	pol afmsp1idpval(p,F,P,a0,a2,wa,b2,wb,py,pwy)  single p; pol F,P;
        	        pol a0,a2,b2; single wa,wb; pol *py; single *pwy;
	a = afmsp1idpval(p,F,P,a0,a2,wa,b2,wb,py,pwy);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x].
	P ist ein normiertes, irreduzibles Polynom aus (Z/pZ) [x].
	a0 ist ein P-primaeres ganzes Element und a2 und b2 sind ganze
	Elemente dieser Algebra; a0, a2 und b2 werden durch CD - Polynome
	repraesentiert ( siehe cdprfmsp1fcl ).
	Sei m_P_a0 der modulo P eindeutig bestimmte irreduzible Faktor
	des Minimalpolynoms von a0, dann gilt: (v_P)* ( m_P_a0 (a0) ) =
	va / wa, va ist eine single groesser gleich 1, wa s.u.
	( Zur Definition der (v_P)* - Bewertung siehe iafmsp1psval ).
	a2 entsteht aus a0 durch die in afmsp1regul angewandte Methode
	( Bezeichnungen dort: a0 und *pa2 ).
	wa und wb sind positive singles, fuer die gilt: wb teilt nicht wa,
        *pwy := kgV(wa,wb), (v_P)* (a2) = 1 / wa und (v_P)* (b2) = 1 / wb.
	*py ist ein P-primaeres ganzes Element der Algebra, dessen (v_P)*
	Wert gleich 1 / *pwy ist. a ist ein P-primaeres ganzes Element der
	Algebra. a und *py sind durch CD - Polynome repraesentiert.
	Sei m der modulo P eindeutig bestimmte irreduzible Faktor des
	Minimalpolynoms von a, dann gilt: (v_p)* ( m(a) ) = 1 / kgV(wa,wb).



			afmsp1pptf( p, F, P, Q, Pp, a0, z )

	"algebraic function over modular single prime, transcendence
	degree 1, P-primality test and factorization of the defining
	polynomial or the minimal polynomial"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	list afmsp1pptf(p,F,P,Q,Pp,a0,z) single p; pol F,P,Q,Pp,a0,z;
	M = afmsp1pptf(p,F,P,Q,Pp,a0,z);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x].
	Die Algebra entstehe durch Adjunktion eines separablen Elementes
	an (Z/pZ) (x) und dieses Element sei mit u bezeichnet.
	P ist ein normiertes, irreduzibles Polynom aus (Z/pZ) [x] und
	Q bzw. Pp sind Potenzen von P.
	Das Produkt von Q mit einem beliebigen Element der P-maximalen
	Ueberordnung der Polynomordnung von F liegt in der Polynomordnung.
	a0 ist ein P-primaeres ganzes Element dieser Algebra, z ist ein
	ganzes Element dieser Algebra, beide werden repraesentiert durch
	CD - Polynome ( siehe cdprfmsp1fcl ).
	Falls z P-primaer ist, d.h. das Minimalpolynom von z modulo P
	keine voneinander verschiedenen irreduziblen Faktoren hat, dann 
        ist M eine Liste aus zwei Elementen M = ( mp, pzet ).
	Dabei ist mp dieser eindeutig bestimmte irreduzible Faktor, also
	ein Polynom in einer Unbestimmten ueber (Z/pZ) [x].
	pzet ist ein ganzes Element dieser Algebra und wird durch ein 
	CD - Polynom repraesentiert; das Minimalpolynom von pzet hat den
	gleichen Grad wie das definierende Polynom F.
	pzet = z + ( Pp * a0 * m ) modulo ( Pp * (Z/pZ) [x] ) [u],
	wobei m eine nicht negative ganze Zahl ist.
	Ist z nicht P-primaer, so ist M eine Liste aus drei Elementen
	M = ( pzet, Lfac, Lort ), dabei gilt fuer pzet obige Aussage.
        Lort = ( e1, e2 ) besteht aus zwei CD - Polynomen ueber (Z/pZ) (x),
        die jeweils Elemente der Algebra repraesentieren, fuer die gilt:
	e1 * e2 = 0 modulo ( Q^2 * (Z/pZ) [x] ) [u];
	e1 + e2 = 1 modulo ( Q^2 * (Z/pZ) [x] ) [u];
	e1 und e2 sind modulo ( Q^2 * (Z/pZ) [x] ) [u] idempotent.
	Lfac = ( f1, f2 ) besteht aus zwei Polynomen in einer Unbestimmten
	ueber (Z/pZ) [x]. Dabei sind f1 und f2 zusaetzlich normiert und es
	gilt: F = f1 * f2 modulo ( Q^2 * (Z/pZ) [x] ) [u].



			afmsp1prodsp( p, F, a, b, M )

	"algebraic function over modular single prime, transcendence
	degree 1, product special"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	pol afmsp1prodsp(p,F,a,b,M) single p; pol F,a,b,M;
	c = afmsp1prodsp(p,F,a,b,M);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x] und obige
	Algebra entstehe durch Adjunktion einer Nullstelle u von F.
	a und b sind Elemente dieser Algebra und werden durch CD -
        Polynome repraesentiert ( siehe cdprfmsp1fcl ).
	M ist ein Polynom in x ueber (Z/pZ).
	c ist das Produkt von a und b in obiger Algebra und wird durch
	ein CD - Polynom repraesentiert.
	Fuer ein Polynom M ungleich dem Nullpolynom ist c zusaetzlich
	modulo ( M * (Z/pZ)[x] ) [u] reduziert.



			afmsp1regul( p, F, P, Q, a0, mpa0, pa1, pa2 )

	"algebraic function over modular single primes, transcendence
	degree 1, regulation"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	rat afmsp1regul(p,F,P,Q,a0,mpa0,pa1,pa2)  single p; pol F,P,Q;
			                   pol a0,mpa0; pol *pa1,*pa2;
	v = afmsp1regul(p,F,P,Q,a0,mpa0,pa1,pa2);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x].
	P ist ein normiertes, irreduzibles Polynom aus (Z/pZ) [x] und
	Q ist eine Potenz von P.
	Das Produkt von Q mit einem beliebigen Element der P-maximalen
	Ueberordnung der Polynomordnung von F liegt in der Polynomordnung.
	a0 ist ein P-primaeres ganzes Element dieser Algebra und wird
	durch ein CD - Polynom repraesentiert ( siehe cdprfmsp1fcl ).
	Das Minimalpolynom von a0 hat den gleichen Grad wie F.
	mpa0 ist der modulo P eindeutig bestimmte irreduzible Faktor des
        Minimalpolynoms von a0 mit einem Grad kleiner als der Grad von F.
	*pa1 und *pa2 sind ganze Elemente der Algebra und werden durch
	CD - Polynome repraesentiert.
	*pa1 := mpa0( a0 ) und v := (v_P)* ( *pa1 ) ( siehe iafmsp1psval ).
        v = w1/v1 ist nach Konstruktion eine rationale Zahl groesser Null.
	(v_P)* ( *pa2 ) = 1 / v1.



			cabsv( z )

	"complex absolute value"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating cabsv(z)  complex z;
	r = cabsv(z);
	r ist der Absolutbetrag der komplexen Zahle z.
	r = |z|.



			cagm( a, b )

	"complex aritho-geometric mean"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cagm(a , b)  complex a, b ; 
	d = cagm(a , b);
	cagm berechnet das arithogeometrische Mittel d der komplexen
	Zahlen a und b (betragsmaessig auf 15 Nachkommastellen genau).
	Definiert man 2 Folgen a(n) und b(n), n in N, gemaess
           a(0) = a  und  b(0) = b
        sowie                                            _____________
           a(n+1) = [ a(n) + b(n) ] / 2  und  b(n+1) = \/ a(n) * b(n) ,
        Dann gilt
	    d  =  lim a(n)  =  lim b(n) .
	         n->oo	      n->oo



			ccomp( a, b )                   (MACRO)

	"complex comparison"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ccomp(a, b)  complex a,b;
	erg = ccomp(a, b);
	erg = 0, falls a = b,
	erg = 1, sonst.



			cconjug( v )

	"complex conjugation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cconjug(v)  complex v;
	z = cconjug(v);
	z das komplex Konjugierte der komplexen Zahl v.
	z = re - i*im  mit  v = re + i*im  und  i^2 = -1.



			ccri( re, im )                  (MACRO)

	"complex construction from real and imaginary part"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex ccri(re, im)  floating re,im;
	z = ccri(re, im);
	z ist die komplexe Zahl mit Realteil re und
	Imaginaerteil im.
	z = re + I*im.



			cdedeetas( q, ln_q )

	"complex Dedekind eta function special"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cdedeetas (q,ln_q)  complex q; double ln_q;
	etas = cdedeetas (q,ln_q);
	Es muss gelten:
	0 < |q| < 1.
	Fuer q = e^(2*pi*i*t)	mit i*i = -1
	ist ln_q Naeherung von Re (ln(q)) = Re (2*pi*i*t).
	etas = eta(q)*q^(-1/24), wobei eta() die Dedekindsche
	eta-Funktion bezeichnet.



			cdif( v, w )

	"complex difference"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cdif(v, w)  complex v, w;
	z = cdif(v, w);
	z ist die Differenz der komplexen Zahlen v und w.
	z = v - w;



			cexp( z )

	"complex exponential function"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cexp(z)	 complex z;
	w = cexp(z);
	w = e^z mit e Eulersche Zahl.



			cexpsv( z, n )

	"complex exponential function special version"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cexpsv(z, n)  complex z; int n
	w = cexpsv(z, n);
	w = e^(2*pi*i*z/n) mit e Eulersche Zahl.



			chartofl( A )

	"character to floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating chartofl( a )  char a;
	f = chartofl( a );
	f ist die interne Darstellung von a als floating point,
	wobei a eine Ziffer oder 'e' ist. Genauer gilt:
	| (  a - f ) / a | <  1/2 * (2^30)^( 1 - FL_EPS ).                                                          



			cimag( z )                      (MACRO)

	"complex imaginary part"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating cimag(z)  complex z;
	im = cimag(z);
	im ist der Imaginaerteil von z.
	im = Im(z).



			ciprod( v, i )

	"complex integer product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex ciprod(v, i)  complex v; int i;
	z = ciprod(v, i);
	z ist das Produkt der komplexen Zahlen v mit
	der ganzen Zahl i.
	z = v*i.



			ciquot( v, i )

	"complex integer quotient"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex ciquot(v, i)  complex v; int i;
	z = ciquot(v, i);
	z = v/i.



			cmodinv( q, ln_q )

	"complex modular invariant j"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cmodinv (q,ln_q)  complex q; double ln_q;
	J = cmodinv (q,ln_q);
	Es muss gelten:
	0 < |q| < 1.
	Fuer q = e^(2*pi*i*t)	mit i*i = -1
	ist ln_q Naeherung von Re (ln(q)) = Re (2*pi*i*t).
	Es wird die q-Entwicklung der Modulinvarianten j angenaehert,
	d.h. J ist eine Naeherung fuer j.



			cornaccia( m, q, x0, pX, pY )

	"determine a solution of the diophantine equation x^2+q*y^2=m
	using the algorithm of cornaccia"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	int cornaccia (m,q,x0, pX, pY)  int m,q,x0,*pX,*pY;
	ex =  cornaccia (m,q,x0, pX, pY);
        Es muss gelten:
		1. m >  0
		2. q ist aus Z/mZ \ {0}
		3.x0^2 = -q mod m , 0 <= x0 < m
	Ist ex  = 0, so gilt (*pX)^2 + q*(*pY)^2 = m
	Ist ex != 0, so existiert keine Loesung von x^2 + q*y^2 = m
!!!	Ist x0 nicht bekannt, so setzt man x0 = 0, und x0 wird dann
	innerhalb von cornaccia korrekt bestimmt.



			cprod( v, w )

	"complex product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cprod(v, w)  complex v,w;
	z = cprod(v, w);
	z ist das Produkt der komplexen Zahlen v und w.
	z = v*w.



			cquot( v, w )

	"complex quotient"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cquot(v, w)  complex v,w;
	z = cquot(v, w);
	z ist der Quotient der komplexen Zahlen v und w.
	z = v/w.



			creal( z )                      (MACRO)

	"complex real part"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating creal(z)  complex z;
	re = creal(z);
	re ist der Realteil von z.
	re = Re(z).



			csetinter( S, T )

	"characteristic set intersection"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	obj csetinter(S,T)  obj S,T;
	U = csetinter(S,T);
	S und T sind Charakteristische Mengen. U ist deren Schnittmenge.



			csetpart( L )

	"characteristic set from partition"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	obj csetpart(L)  list L;
	S = csetpart(L);
	L = ( L(1),...,L(n) ) ist eine Liste nicht-negativer einfach-
	genauer Zahlen. S ist eine Charakteristische Menge, wobei k aus
	S genau dann, wenn eine Indexmenge I aus {1,...,n} existiert
	mit  k = Summe { L(i) | i aus I }.



			csetunion( S, T )

	"characteristic set union"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	obj csetunion(S,T)  obj S,T;
	U = csetunion(S,T);
	S und T sind Charakteristische Mengen. U ist deren Vereinigung.



			csexp( v, n )

	"complex single exponentiation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex csexp (v,n)  complex v;	single n;
	z = csexp(v, n);
	n >= 0.
	z ist die n-te Potenz der komplexen Zahl v.
	z = v^n.



			csqr( v )

	"complex square"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex csqr(v)  complex v;
	z = csqr(v);
	z ist das Quadrat der komplexen Zahl v.
	z = v * v.



			csqrt( z )

	"complex square root"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex csqrt(z)  complex z;
	r = csqrt(z);
	r ist eine Quadratwurzel der komplexen Zahl z.
	Es gilt : Re (r) >= 0.
	r^2 = z.



			csum( v, w )

	"complex sum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex csum(v,w)  complex v, w;
	z = csum(v, w);
	z ist die Summe der komplexen Zahlen v und w.
	z = v + w.



			cweberf( z )

	"complex Weber function f"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cweberf (z)  complex z;
	w = cweberf (z);
	Es muss gelten: Imag(z) > 0.
	w = f(z), wobei f die Webersche f-Funktion ist.



			cweberf1( z )

	"complex Weber function f1"
	Quellbibliothek: srclib.arith1
	Include-Datei: _arith1.h
	complex cweberf1 (z)	complex z;
	w = cweberf1 (z);
	Es muss gelten: Imag(z) > 0.
	w = f1(z), wobei f1 die Webersche f1-Funktion ist.



			cweberf2( z )

	"complex Weber function f2"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	complex cweberf2 (z)  complex z;
	w = cweberf2 (z);
	Es muss gelten: Imag(z) > 0.
	w = f2(z), wobei f2 die Webersche f2-Funktion ist.



			divs( A, B )                    (MACRO)

	"division with reference to SIMATH"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single divs( A,B )  single A,B;
	C = divs( A,B );
	Es muss gelten: B ist ungleich Null.
	ACHTUNG: C = A / B gemaess der SIMATH-Konvention, d.h. so wie "/"
	-------- auf MX2(+) realisiert ist. Dies stimmt fuer den Fall
		 A * B < 0, B teilt nicht A nicht mit dem allgemeinen
		 Standard nach Kernighan-Ritchie ueberein, der auf SUN
		 und Apollo gilt. Sei A / B standardmaessig. Dann ist
		 im obigen Fall
			  C = ( A / B ) - 1.



			dpipds( a, N )

	"double precision integer prime divisor search"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list dpipds(a,N)  single a; int N;
	L = dpipds(a,N);
	Es muss gelten : 
	1  <= N < 2^60,	N enthaelt keine Primfaktoren < a. 
	L = (q1,...,qr) mit q1 >= ... >= qr > 0 ist die absteigend 
	sortierte Liste aller Primfaktoren von N, d.h. N = q1 * ... * qr.



			elcfds( N, b, e )

	"elliptic curve fast divisor search"
        Quellbibliothek: srclib.arith1    
	Include-Datei:   _arith1.h
	int elcfds(N, b, e)  int N; single b, e;
	D = elcfds( N, b, e); 
        N > 1 sollte keine Primzahl sein;       
	b sollte moeglichst zufaellig gewaehlt werden.
	e >= 0 (zur Erklaerung von e siehe unten).        
	empfohlener Wert: e = 50000.
	Falls N >= 2^320 ist, wird D = 0 zurueckgegeben, d.h. N ist zu 
	gross. Sonst ist D ein Teiler von N ( bei Misserfolg D = 1 oder 
	D = N).         
	Falls N nicht faktorisiert worden ist, kann der Versuch mit 
	einem anderen b und/oder einem groesserem e wiederholt werden. 
	Zu Details des Algorithmus siehe z.B.: "Some integer factorization 
	algorithms using elliptic curves" von Richard P. Brent, September 
	1985. 
	Es wird gleichzeitig mit 40 Kurven getestet. Dabei wird zu jedem 
	Punkt P auf einer dieser Kurven der Punkt E * P berechnet, wobei 
	E ein Produkt von Primzahlen < e ist. Insbesondere kann durch 
	e die maximale Laufzeit von elcfds beeinflusst werden. 
	Die obigen Konstanten "32" und "2^320" koennen fuer spezielle 
	Anwendungen innerhalb des Programmquelltextes leicht veraendert
	werden.
	elcfds hat NICHTS mit den ec...-Funktionen zu tun.



			elcpds( N, a, z )

	"elliptic curve pure divisor search"
        Quellbibliothek: srclib.arith1    
	Include-Datei:   _arith1.h
	int elcpds(N,a,z)  int N; single a,z;
	P = elcpds(N,a,z); 
        N > 1 sollte keine Primzahl sein;
        a > 0 sollte moeglichst zufaellig sein und nicht so gross 
	(z.B.: a < 1000).
        z >= 0  ist die maximale Anzahl der benutzten elliptischen 
	Kurven, 
        P ist ein Teiler von N ( bei Misserfolg P = 1 oder P = N).         
	siehe z.B.: "Some integer factorization algorithms using elliptic
		     curves" von Richard P. Brent, September 1985.
	elcpds hat NICHTS mit den ec...-Funktionen zu tun.



			elcpdssum( N, x1, y1, x2, y2, px3, py3, a )

	"elliptic curve prime divisor search sum "
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int elcpdssum( N, x1, y1, x2, y2, px3, py3, a ) 
		int N, x1, y1, x2, y2, *px3, *py3;  single a;
	P = elcpdssum( N, x1, y1, x2, y2, px3, py3, a ); 
	Es muss gelten :
		N > a > 0 
		( x1, y1 ), ( x2, y2 ) liegen auf 'elliptischer Kurve'
		y^2 = x^3 + a*x + b ueber Z/NZ, wobei b durch a und 
		( x1, y1 ) eindeutig bestimmt wird.
		0 <= x1, y1, x2, y2 < N.
                Ausnahme: Falls x1 = -1 und y1 = -1, wird ( x1, y1 ) 
		als Fernpunkt interpretiert, analog fuer x2 und y2.   
	Es wird versucht, (px3,py3) = (x1,y1) + (x2,y2) zu berechnen:
	                 bei Erfolg : P = 1, 
	                 sonst      : 1 < P ist Teiler von N.    
	elcpdssum hat NICHTS mit den ec...-Funktionen zu tun;
	es wird von elcpds benutzt und dient zur Faktorisierung von N.



			fgetfl( pf )

	"file get floating point" 
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating fgetfl( pf )  FILE *pf;
	f = fgetfl( pf );
	f wird von der Eingabedatei *pf gelesen.
	Laeuft fgetfl fehlerhaft ab, so wird f = ERROR geliefert.  
	Es werden folgende Darstellungen von f akzeptiert:
        - als ganze Zahl;
	- als Bruch;
	- in folgenden Formaten ( n und m seien beliebige 
	  Ziffernfolgen, b und d positive singles ) :
	    [+-]m.n e [+-]d 
	    [+-]m.n E [+-]d
	    [+-]m.n * b ^ [+-]d 
	    [+-]m.n * b ** [+-]d    
	    b^[+-]d 
	    b**[+-]d   
	    [+-]m.n                      
	    [+-]m.n * b
	  Dabei entspricht 'e' bzw. 'E' dem Ausdruck "* 10 ^". 
	  Statt eines Punktes kann auch ein Komma stehen, 
	  entweder m oder .n koennen fehlen;
	- als Liste, die einen korrekten floating point 
	  darstellt ( interne Darstellung von f );      
	- Der character 'e' wird als Eulersche Zahl
	  interpretiert.
	- Die character-Folge "Pi" wird als 3.14... interpretiert.
	Ist a der genaue Wert, der einzulesen ist, so gilt :
	| ( a - f ) / a | <  1/2 * (2^30)^( 1 - FL_EPS ).                                                          



			fgetgf2el( G, V, pf )

	"file get Galois-field with characteristic 2 element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el fgetgf2el(G,V,pf)  obj G; list V; FILE *pf; 
	a = fgetgf2el(G,V,pf);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n >= 1 in der speziellen
		Bit-Darstellung (vgl. udpm2tosb). 
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -	V ist eine 1-elementige Variablenliste.
	Von der Eingabedatei *pf wird ein Polynom in der durch V gegebenen
	Variable ueber Z eingelesen. Die Koeffizienten werden modulo 2
	reduziert. Dieses Polynom wird in die spezielle Bit-Darstellung 
	konvertiert. Danach wird es modulo G reduziert.
	Bei korrektem Verlauf ist a dann ein Element aus GF(2^n), 
	das als Polynom in einer Variablen ueber Z/2Z vom Grad < n
	in spezieller Bit-Notation dargestellt wird.
	Ansonsten ist a = ERROR.



			fgetgfsel( p, AL, V, pf )

	"file get Galois-field with single characteristic element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel fgetgfsel(p,AL,V,pf)  single p; list AL,V; FILE *pf;
	a = fgetfgsel(p,AL,V,pf);
	Es muss gelten : p ist eine Primzahl.
	  AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) interpretiert
	  werden (siehe gfsalgen), wobei n = llength(AL1) + 1.
	  G ist ein irreduzibles, normiertes Polynom in einer Variable
	  ueber Z/pZ, das Grad n >= 1 hat.
	  V ist eine 1-elementige Variablenliste.
	Von der Eingabedatei *pf wird ein Polynom in der durch V gegebenen
	Variable ueber Z eingelesen. Dieses Polynom wird modulo G reduziert
	und seine Koeffizienten modulo p.
	Bei korrektem Verlauf steht dieses Resultat in a, ansonsten ist
	a = ERROR.



			fgeti( pf )

	"file get integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int fgeti(pf)  FILE *pf;
	A = fgeti( pf );
	A wird von der Eingabedatei *pf gelesen.
	Laeuft fgeti fehlerhaft ab, so wird A = ERROR geliefert.



			fgetli( pf )

	"file get list of integers"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list fgetli(pf)  FILE *pf;
	L = fgetli ( pf );
	Von der Eingabedatei *pf wird eine Liste, bestehend aus ganzen
	Zahlen, nach L eingelesen.
	Laeuft fgetli fehlerhaft ab, so ist L = ERROR.



			fgetlr( pf )

	"file get list of rational numbers"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list fgetlr( pf )  FILE *pf;
	L = fgetlr( pf );
	Von der Datei *pf wird eine Liste, bestehend aus rationalen
	Zahlen, in gekuerzter Darstellung nach L eingelesen.
	Laeuft fgetlr fehlerhaft ab, so ist L = ERROR.



			fgetmi( M, pf )

	"file get modular integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int fgetmi(M,pf)  int M; FILE *pf;
	A = fgetmi(M,pf);
	Es muss gelten : M > 0.
	Von der Eingabedatei *pf wird ein integer eingelesen und modulo M
	reduziert.
	Das Ergebnis ist A aus Z/M*Z bei korrektem Verlauf und A = ERROR
	bei fehlerhaftem Verlauf.



			fgetms( m, pf )

	"file get modular single"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fgetms(m,pf)  single m; FILE *pf;
	a = fgetms(m,pf);
	Es muss gelten : m > 0.
	Von der Eingabedatei *pf wird ein integer eingelesen und modulo m
	reduziert.
	Das Ergebnis ist a aus Z/mZ bei korrektem Verlauf und a = ERROR
	bei fehlerhaftem Verlauf.



			fgetnfel( F, V, pf )

	"file get number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel fgetnfel( F, V, pf )     pol F; list V; FILE *pf;
	a = fgetnfel( F, V, pf );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom vom Grad n >= 1 in einer
		Variablen ueber Z in dense-Darstellung.
	      - V ist eine 1-elementige Variablenliste.
	Von der Eingabedatei *pf wird ein Polynom in der durch V gegebe-
	nen Variable ueber den rationalen Zahlen eingelesen. Dieses Poly-
	nom wird modulo F reduziert und anschliessend in die Form eines
	Elements des von F erzeugten ZK. gebracht.
	Bei korrektem Verlauf steht dieses Resultat in a, sonst ist a =
	ERROR.



			fgetnfels( F, V, pf )

	"file get number field element, sparse representation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel fgetnfels(F,V,pf)  pol F; list V; FILE *pf;
	a = fgetnfels(F,V,pf);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		V ist eine 1-elementige Variablenliste.
	Von der Eingabedatei *pf wird ein Polynom in der durch V gegebenen
	Variable ueber den rationalen Zahlen eingelesen. Dieses Polynom
	wird modulo F reduziert.
	Bei korrektem Verlauf steht dieses Resultat in a (sparse-Dar-
	stellung), ansonsten ist a = ERROR.



			fgetpfel( p, pf )

	"file get p-adic field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel fgetpfel( p,pf )  single p; FILE *pf;
	a = fgetpfel( p,pf );
	Von der Eingabedatei *pf wird ein Element aus Qp in approximier-
	ter Reihenentwicklung eingelesen und in eines vom Typ pfel um-
	geformt.
	Dabei gelte:
	      - p ist single-prime.
	      - a sei die Approximation zu A aus Qp vom Grad d, fuer die
		bzgl. der additiven p-adischen Bewertung vp gilt:
		      vp( A - a ) >= d
	      - A habe die Darstellung
		A = c_vp( A ) * p^vp( A ) + ... + c_d * p^d + ...
		=>  a = 0                  ,falls A = 0 oder alle c_i = 0
			( d, vp( A ), c_vp( A ), ..., c_d ),        sonst
	Fuer die Eingabe von p-adischen Elementen gelten folgende Richt-
	linien:
	      1)  Das Elementende muss mit '#' markiert sein.
	      2)  Es sind nur nichtnegative ganze Koeffizienten c_i < p
		  zugelassen. Fuer c_i = 0 kann die Angabe unterbleiben,
		  sofern ein c_j != 0 mit j > i folgt.
	      3)  Die Exponenten werden durch vorangestelltes '^' ge-
		  gekennzeichnet und sind in aufsteigender Reihenfolge
		  angegeben.
	      4)  Der Summen- bzw. Exponentenoperator kann durch Blanks
		  vom Koeffizienten bzw. Exponenten getrennt werden.
	fgetpfel ist insbesondere in der Lage, von fputpfel geschriebene
	p-adische Elemente zu lesen.
	fgetpfel liefert den Ergebniswert
		a          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.
	ACHTUNG: Die Elemente muessen bereits approximiert sein. Wird
	-------  die ziffernweise Darstellung als Eingabeformat gewuenscht,
		 so muss fgetspfel aufgerufen werden.



			fgetqnfel( D, pf )

	"file get quadratic number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel fgetqnfel( D, pf )  int D; FILE *pf;
	a = fgetqnfel( D, pf );
	D ist aus Z\{0,1} und quadratfrei.
	Ein Element des quadratischen Zahlkoerpers Q( D^(1/2) ) wird von 
	der Datei *pf gelesen.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	Dabei sind folgende Eingaben erlaubt:
	     a1, a1/aN, ( a1  a2 ), ( a1/aN  a2 ), ( a1  a2/aN ), 
	     ( a1/aN  a2/aN ), ( aN  0  a1 ), ( aN  1  a2  a1 ) 
        mit ganzen Zahlen a1, a2, aN.
	a = 0, falls die Eingabe die Zahl 0 darstellt,
            ( aN  0  a1 ), falls die Eingabe das Zahlkoerperelement 
		       a1/aN ( + 0 * D^(1/2) ) darstellt,
            ( aN  1  a2  a1 ), falls die Eingabe das Zahlkoerperelement 
		       a1/aN + a2/aN * D^(1/2) darstellt,
            ERROR sonst.



			fgetr( pf )

	"file get rational number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat fgetr(pf)  FILE *pf;
	R = fgetr( pf );
	R wird von der Datei *pf gelesen und, falls notwendig, in die
	gekuerzte Darstellung umgewandelt.
	Bei Fehler wird R = ERROR geliefert.



			fgetrfmsp1( p, V, pf )

	"file get rational function over modular single primes,
	 transcendence degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc fgetrfmsp1(p,V,pf)  single p; list V; FILE *pf;
	R = fgetrfmsp1(p,V,pf);
	p ist eine Primzahl kleiner BASIS.
	V ist eine Liste, die den Variablennamen repraesentiert, und zwar
	in der Form
		V = ( ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ) ),
	falls der Variablenname aus den n alphanumerischen Zeichen
		Bu , BZ2 , ... , BZn
	besteht; das erste Zeichen muss immer ein Buchstabe sein.
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	fgetrfmsp1 liest eine rationale Funktion R in einer Variablen
	ueber Z/pZ von der Datei *pf. 
	Fuer die Eingabe von rationalen Funktionen gelten folgende 
	Richtlinien:
		1)  Eine rationale Funktion R muss in der Form
			P1 / P2    oder    P1
		    dargestellt werden, wobei P1 und P2 Polynome sind
		    und die Angabe des Nenners P2 = 1 unterbleiben kann.
		    fgetrfmsp1 wandelt den Bruch, falls noetig, in die
		    gekuerzte Darstellung um. Der Bruchstrich '/' muss
		    in derselben Zeile wie das Polynomende-Zeichen '#'
		    von P1 eingegeben werden.
		2)  Fuer die Darstellung von Polynomen gelten die in
		    fgetpms angegebenen Richtlinien; insbesondere muss
		    das Polynomende immer mit einem '#' markiert sein.
	fgetrfmsp1 ist insbesondere in der Lage, von fputrfmsp1
	geschriebene rationale Funktionen zu lesen.
	fgetrfmsp1 liefert den Ergebniswert
		R          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fgetrfr( r, V, pf )

	"file get rational function over rationals"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc fgetrfr(r,V,pf)  single r; list V; FILE *pf;
	R = fgetrfr(r,V,pf);
	r ist eine ganze Zahl mit 0<=r<BASIS.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	fgetrfr liest eine rationale Funktion in r Variablen V1,...,Vr
	ueber den rationalen Zahlen von der Datei *pf. 
	Fuer die Eingabe von rationalen Funktionen gelten folgende 
	Richtlinien:
		1)  Eine rationale Funktion R muss in der Form
			P1 / P2    oder    P1
		    dargestellt werden, wobei P1 und P2 Polynome in den
		    r Variablen V1,...,Vr sind und die Angabe des Nenners
		    P2 = 1 unterbleiben kann. fgetrfr wandelt den Bruch,
		    falls noetig, in die gekuerzte Darstellung um.
		    Der Bruchstrich '/' muss in derselben Zeile wie das
		    Polynomende-Zeichen '#' von P1 eingegeben werden.
		2)  Fuer die Darstellung von Polynomen gelten die in
		    fgetpr angegebenen Richtlinien; insbesondere muss
		    das Polynomende immer mit '#' markiert sein.
	fgetrfr ist insbesondere in der Lage, von fputrfr geschriebene
	rationale Funktionen zu lesen.
	fgetrfr liefert den Ergebniswert
		R          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fgetsi( pf )

	"file get single"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fgetsi( pf )
	n = fgetsi( pf );
	n wird von der Datei *pf gelesen.
	Bei Fehler wird n = ERROR geliefert.



			fgetspfel( p, pf )

	"file get special p-adic field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel fgetspfel( p,pf )  single p; FILE *pf;
	a = fgetspfel( p,pf );
	Von der Eingabedatei *pf wird ein Element aus Qp in ziffernwei-
	ser Darstellung der Reihenentwicklung eingelesen und in eines vom
	vom Typ pfel umgewandelt.
	Dabei gelte:
	      - p ist single-prime.
	      - a sei die Approximation zu A aus Qp vom Grad d, fuer
		die bzgl. der additiven p-adischen Bewertung vp gilt:
		      vp( A - a ) >= d
	      - A habe die Darstellung
		A = c_vp( A ) * p^vp( A ) + ... + c_d * p^d + ...
		=>  a = 0                  ,falls A = 0 oder alle c_i = 0
			( d, vp( A ), c_vp( A ), ..., c_d ),        sonst
	Fuer die Eingabe von p-adischen Elementen gelten folgende Richt-
	linien:
	      1)  Das Elementende muss mit '#' markiert sein.
	      2)  Es sind nur nichtnegative ganze Koeffizienten c_i < p
		  zugelassen. Fuer c_i = 0 kann die Angabe unterbleiben,
		  sofern ein c_j != 0 mit j > i folgt.
	      3)  Die Koeffizienten sind durch '_' voneinander getrennt.
	      4)  Die Koeffizienten werden in a u f s t e i g e n d e r
		  Weise bzgl. ihrer Exponenten aus der Reihendarstellung
		  aufgeschrieben, d. h.
			c_vp( A )_...
		  Dabei wird zur Markierung vom Uebergang negativer Ex-
		  ponenten zu nichtnegativen
			'.' anstatt '_'
		  gesetzt, d.h. z.B.
			    c_-1.c_0       oder     .c_0
	fgetspfel ist insbesondere in der Lage, von fputspfel geschrie-
	bene p-adische Elemente zu lesen.
	fgetspfel liefert den Ergebniswert
		a          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.
	ACHTUNG: Die Elemente muessen bereits approximiert sein. Wird
	-------  die Reihenentwicklung als Eingabeformat gewuenscht, so
		 muss fgetpfel aufgerufen werden.



			flPAFfu( func, anzahlargs, arg1, arg2 )

	"floating point using Papanikolaou floating point functions"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	floating flPAFfu(func, anzahlargs, arg1, arg2)
	       void (*func)(); single anzahlargs; floating arg1, arg2;
	f = flPAFfu(func, anzahlargs, arg1, arg2);       
	Es muss gelten: 
	func ist eine der (z.B. unten aufgelisteten) Funktionen des 
	Papanikolaou floating point package. anzahlargs ist die Anzahl 
	der Argumente, die fuer diese Funktion uebergeben werden muessen. 
	flPAFfu konvertiert die Eingabeparameter arg1 und arg2 
	gemaess den Konventionen des Papanikoloau floating pont package
	und wendet die Funktion func auf diese an. 
	Die Praezision, mit der gerechnet wird, ist die durch die SIMATH-
	Variable FL_EPS vorgegebene, das heisst die Praezizion der 
	PAF-Arithmetik wird an FL_EPS angepasst. 
	Es folgt eine Auswahl von Werten fuer func. Detaillierte 
	Angaben ueber die Funktion und eventuelle Einschraenkungen der
	Eingabeparameter koennen in der Dokumentaion des in der Spalte 
	file angebenen Files nachgeschlagen werden. 
	Funktion     |    anzahlargs   |   file 
	-------------+-----------------+--------------  
	  Fsqrt      |        1        |   PAFtrans1
	  Fexp       |        1        |   PAFtrans1
   	  Flog       |        1        |   PAFtrans1
	  FsqrF      |        1        |   PAFtrans1
	  FasFpowF   |        2        |   PAFtrans1   
	  Fe         |        0        |   PAFtrans2   
	  Fpi        |	      0        |   PAFtrans2   
	  Feuler     |        0        |   PAFtrans2   
	  Fcatalan   |        0        |   PAFtrans2   
	  Fsin       |        1        |   PAFtrans2   
	  Fcos       |        1        |   PAFtrans2   
	  Ftan       |        1        |   PAFtrans2   
	  Fcot       |        1        |   PAFtrans2   
	  Fsinh      |        1        |   PAFtrans2   
	  Fcosh      |        1        |   PAFtrans2   
	  Ftanh      |        1        |   PAFtrans2   
	  Fcoth      |        1        |   PAFtrans2   
	  Fasin      |        1        |   PAFtrans3
	  Facos	     |        1        |   PAFtrans3
	  Fatan      |        1        |   PAFtrans3
	  Facot      |        1        |   PAFtrans3
	  Fasinh     |        1        |   PAFtrans3
	  Facosh     |        1        |   PAFtrans3
	  Fatanh     |        1        |   PAFtrans3
	  Facoth     |        1        |   PAFtrans3
	  Fasin      |        1        |   PAFtrans3
	  Facos      |        1        |   PAFtrans3
	  Fatan      |        1        |   PAFtrans3
	  Facot      |        1        |   PAFtrans3
	  Fasinh     |        1        |   PAFtrans3
	  Facosh     |        1        |   PAFtrans3
	  Fatanh     |        1        |   PAFtrans3
	  Facoth     |        1        |   PAFtrans3
	Beispiele: 
	Berechnug von g = asin( f ): 	g = flPAFfu( Fasin, 1, f, 0 ); 
	Berechnug von Pi: 		g = flPAFfu( Fpi, 0, 0, 0 ); 
	Berechnug von g = f^e:  	g = flPAFfu( FasFpowF, 2, f, e );



			flPi(  )

	"floating point Pi"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flPi( )  
	f = flPi ( );    
	f ist die floating point Darstellung von Pi (= 3.14...). 
	Genauer gilt:
	| ( Pi - f ) / Pi | < 1/2 * (2^30)^( 1 - FL_EPS ).



			flabs( f )                      (MACRO)

	"floating point absolute value"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flabs( f )  floating f;
	g = flabs( f );
	g = | f |.
	Die Berechnung wird exakt ausgefuehrt, d.h.
	unabhaengig von FL_EPS.



			flagm( a, b )

	"floating point aritho-geometric mean"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flagm(a , b)  floating a, b ; 
	d = flagm(a , b);
	flagm berechnet das arithogeometrische Mittel d der beiden
	positiven reellen Zahlen a und b (bis auf 15 Nachkommatellen genau).
	Definiert man 2 Folgen a(n) und b(n), n in N, gemaess
           a(0) = a  und  b(0) = b
        sowie                                            _____________
           a(n+1) = [ a(n) + b(n) ] / 2  und  b(n+1) = \/ a(n) * b(n) ,
        Dann gilt
	    d  =  lim a(n)  =  lim b(n) .
	         n->oo	      n->oo



			flath_sp( f )

	"floating point area tangens hyperbolicus special version"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flath_sp( f )  floating f;
	h = flath_sp( f ); 
	Es muss gelten | f | < 1.
	h = area tan hyp ( f ).
	Warnung! h wird ( nur ) durch Reihenentwicklung berechnet, 
	daher ist der Algorithmus fuer | f | nahe an 1 sehr langsam.



			flatn_sp( f )

	"floating point arcus tangens special version"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flatn_sp( f )  floating f;
	h = flatn_sp( f ); 
	Es muss gelten | f | < 1.
	h = arc tan ( f ).     
	Warnung! h wird (nur) durch Reihenentwicklung berechnet, 
	daher ist der Algorithmus fuer | f | nahe an 1 sehr langsam.



			flcomp( f, g )

	"floating point comparison"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single flcomp(f,g)   floating f, g;
	n = flcomp( f, g );
	n ist das Signum von f-g.



			flcons( A, e, lA )

	"floating point construction"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flcons(A, e, lA)  obj A; single e, lA;
	f = flcons( A, e, lA);    
	A ist integer, eventuell auch single, 
	oder A = ( a ), d.h. einelementige Liste,
	wobei a ein single ungleich 0 ist.   
	lA ist die Listenlaenge von A, bzw. lA = 1, falls
	A single ist.
	f ist die interne Darstellung von A * BASIS^e, 
	bzw. a * BASIS^e.
	Fuer diese Darstellung von f wird eine Liste mit 
	hoechstens FL_EPS+1 Eintraegen benutzt. An der ersten Stelle
	steht dabei der Exponent, der uebrige Teil der Liste stellt 
	die Mantisse dar. FL_EPS ist eine ( veraenderbare ) globale 
	Konstante.    
	Ist x der exakte Wert, und f die floating point Darstellung 
	von x, so gilt: 
	| ( x - f ) / x | <  1/2 * BASIS^( 1 - FL_EPS ).                                                          



			flcos( a )

	"floating point cosinus"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flcos( a )  floating a;
	h = flcos( a );    
	Es muss gelten: -2^15 < a < 2^15, 
	h = cos ( a ).
	a wird als Winkel im Bogenmass interpretiert.



			flcos_sp( f )

	"floating point cosinus special version"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flcos_sp( f )  floating f;
	h = flcos_sp( f );        
	h = cos ( f ).
	Achtung: f wird nur durch Reihenentwicklung berechnet, 
	dadurch ist der Algorithmus fuer grosses f langsam. 



			flcut( A, e, lA )

	"floating point construction by cutting"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flcut(A, e, lA)  obj A; single e, lA;
	f = flcut( A, e, lA);    
	A ist integer, eventuell auch single, 
	oder A = ( a ), d.h. einelementige Liste,
	wobei a ein single ungleich 0 ist.   
	lA ist die Listenlaenge von A, bzw. lA = 1, falls
	A single ist.
	f ist die interne Darstellung von A * BASIS^e, 
	bzw. a * BASIS^e.
	Fuer diese Darstellung von f wird eine Liste mit 
	hoechstens FL_EPS+1 Eintraegen benutzt. An der ersten Stelle
	steht dabei der Exponent, der uebrige Teil der Liste stellt 
	die Mantisse dar. FL_EPS ist eine ( veraenderbare ) globale 
	Konstante.    
	Ist x der exakte Wert, und f die floating point Darstellung 
	von x, so gilt: 
	| ( x - f ) / x | <  1/2 * BASIS^( 1 - FL_EPS ).    
	Warnung!!! Falls A Liste ist, wird A veraendert. flcons erzielt
	das gleiche Ergebnis, ohne dass A als Liste veraendert wird.



			fldif( f, g )                   (MACRO)

	"floating point difference"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating fldif( f, g )   floating f,g;
	h = fldif( f, g );
	h = f - g.



			flerr(  )                       (MACRO)

	"floating point overflow error handling"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single flerr()    
	a = flerr();    
	WARNUNG! flerr darf NUR im Hauptprogramm
	aufgerufen werden. 
	flerr bietet eine Moeglichkeit zum Umgang mit
	overflow errors, wie sie bei floating point 
	Rechnungen vorkommen.       
	Wird flerr() aufgerufen, so ist a=0.
	Tritt im Laufe der Rechnung ein overflow auf, wird 
	das Programm an der Stelle fortgesetzt, an der 
	flerr() zuletzt aufgerufen wurde. 
	a hat in diesem Fall einen Wert groesser 0. 
	Mit Ausnahme von FL_EPS haben alle Variablen den Wert,
	den sie zum Zeitpunkt des overflow erorrs hatten.
	ACHTUNG! FL_EPS kann einen anderen Wert haben.
	Sollten also weitere floating point Rechnungen
	nach einem overflow error folgen, so muss FL_EPS 
	ein wohldefinierter Wert zugewiesen werden. 
	Wird flerr() nicht aufgerufen,
	so wird das Programm bei einem overflow error 
	mit einer Fehlermeldung verlassen.    
	Beispiele fuer die Verwendung von flerr():
	Das folgende SIMATH - Programm soll x einlesen
	und e^x berechnen.
	Falls bei der Rechnung ein overflow auftritt,
	soll "unendlich" ausgegeben werden.
		#include<_simath.h>
		main()
		{
			floating x, ergebnis;
			init( x, ergebnis );
			x = getfl();
			if ( flerr() == 0 ) {
				ergebnis = flexp( x );
				printf(" e^%p = %p\n",x,ergebnis);
				}
			else printf("unendlich\n");
		}
	Tritt also in flexp( x ) ein overflow auf, wird zu der 
	Stelle if ( flerr() == ... ) so zurueckgesprungen, als
	ob flerr() aufgerufen wurde und einen Wert groesser
	als 0 zuruecklieferte. Die if - Bedingung ist also 
	nicht erfuellt.  
	Das folgende SIMATH - Programm soll solange x einlesen
	und e^x berechnen, bis x = 0 eingegeben wird. 
	Die Berechnung soll mit mindestens 10 Dezimalstellen
	ausgefuehrt werden. Bei einem overflow soll kommentarlos
	auf die naechste Eingabe gewartet werden. 
		#include<_simath.h>
		main()
		{
			floating x, ergebnis;
			single rette_eps;
			init( x, ergebnis );
			rette_eps = flinit( 10 );
			if ( flerr() != 0 ) FL_EPS = rette_eps;
			while ( (x = getfl()) != 0 ) {
				ergebnis = flexp( x );
				printf(" e^%p = %p\n",x,ergebnis);
				}
		}
	Man beachte, dass in rette_eps der Wert von FL_EPS 
	abgespeichert wird. Statt 
		rette_eps = flinit( 10 ); 
	wuerde auch die Befehlsfolge
		flinit( 10 );
		rette_eps = FL_EPS;         
        zum gleichen Ergebnis fuehren.



			flexp( f )

	"floating point exponential function"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flexp(f)  floating f;
	h = flexp(f); 
	h = e^f, wobei e die Eulersche Zahl bedeutet.



			flexpo( f )                     (MACRO)

	"floating point exponent"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single flexpo( f )   floating f;
	e = flexpo( f );                  
	Es muss gelten: f ungleich 0.
	Ist f = a * (2^30)^d, wobei a ganzzahlig ist und nicht 
	von 2^30 geteilt wird ( normierte Darstellung ), dann 
	ist e = d.



			flfloor( f )

	"floating point floor"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int flfloor( f )    floating f;
	A = flfloor( f );
	A ist die groesste ganze Zahl, die kleiner 
	oder gleich f ist.



			flinit( k )

	"floating point initialization"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single flinit( k )  single k;
	a = flinit( k );     
	Fuer k >= 0 wird die globale Konstante FL_EPS
	so veraendert, dass gilt:
	1/2 * (2^30)^( 1 - FL_EPS ) < 1/2 * 10^( 1 - k ).  
	d.h. die floating point Rechnungen werden mit   
	einer Genauigkeit von mindestens k Dezimalstellen 
	ausgefuehrt.    
	Fuer k < 0 ist FL_EPS = -k.
	a hat den Wert FL_EPS.    
	FL_EPS+1 ist die maximale Laenge der Liste, die 
	intern zur Darstellung eines floating point 
	benutzt wird ( eine Stelle fuer den Exponent
	und FL_EPS Stellen fuer die Mantisse ).



			fllog( f )

	"floating point natural logarithm" (rekursiv)
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating fllog( f )  floating f;
	h = fllog( f ); 
	Es muss gelten: f > 0.
	h ist der natuerliche Logarithmus von f.      



			flmant( f )                     (MACRO)

	"floating point mantissa"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int flmant( f )  floating f;
	A = flmant( f );   
	Ist f = a * (2^30)^d, wobei a ganzzahlig ist und nicht 
	von 2^30 geteilt wird ( normierte Darstellung ), dann 
	ist A = a. 
	Ist f = 0, dann ist A = 0.



			flneg( f )

	"floating point negation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flneg(A)   floating A;
	g = flneg( f );
	g = -f.                    
	Die Negation wird exakt ausgefuehrt, d.h.
	unabhaengig von FL_EPS.



			floverflow( a )

	"floating point overflow error"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	void floverflow( a )  single a;
	floverflow( a );    
        Falls flerr() im Hauptprogramm nicht 
	aufgerufen wurde, wird die Fehlermeldung     
	"floating point overflow (a)" auf stderr
	ausgegeben, und mit exit(1) das Programm 
	verlassen. Wurde flerr() im Hauptprogramm
	aufgerufen, wird das Programm fortgesetzt,
	als ob gerade flerr() abgearbeitet wurde,
	und den Wert a zuruecklieferte. Siehe
	dazu auch die Dokumentation zu flerr().	



			flpow( f, g )

	"floating point power"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flpow( f, g )  floating f,g;
	h = flpow( f, g );     
	Es muss gelten: f >= 0.
	h = f^g mit den Konventionen 0^0 = 1 und 0^g = 0 
	fuer g ungleich 0.



			flprod( f, g )

	"floating point product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flprod( f, g )  floating f,g;
	h = flprod( f, g );
	h = f * g.



			flqrem( A, B, pQ, pR )

	"floating quotient and remainder"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int flqrem(A, B, pQ, pR)  floating A, B, *pR; int *pQ;
	C = flqrem(A, B, pQ, pR);
	Berechnet *pQ und *pR so, dass
	*pR = A mod B und
	*pQ = [A/B], falls B != 0, das heisst
	mit 0 <= *pR < B, falls B > 0
	    0 >= *pR > B, falls B < 0
	und *pR = A     , falls B  = 0.
	C hat den Wert 0.



			flquot( f, g )

	"floating point quotient"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flquot( f, g )  floating f,g;
	h = flquot( f, g );     
	Es muss gelten: g ungleich 0.
	h = f / g. 



			flround( f )

	"floating point round"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int flround( f )    floating f;
	A = flround( f );
	A ist die ganze Zahl, fuer die gilt:
	-1/2 <= f - A < 1/2.



			flsetprec( k, N )

	"floating point set precision"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single flsetprec( k, N )  single k; int N;
	a = flsetprec( k, N );       
	Fuer N > 0 wird die globale Konstante FL_EPS so veraendert, dass
	gilt: 1/2 * (2^30)^( 1 - FL_EPS ) <  1 / ( N * 2^k ).
	Man erhaelt somit bei floating point Operationen die Fehlerab-
	schaetzung: | ( x - f ) / x | < 1 / ( N * 2^k ).
	Dabei ist x der exakte Wert und f der SIMATH floating point.
	Fuer N <= 0 ist FL_EPS = |k|.
	a hat den Wert FL_EPS.    
	FL_EPS+1 ist die maximale Laenge der Liste, die intern zur Dar-
	stellung eines floating point benutzt wird (eine Stelle fuer den
	Exponent und FL_EPS Stellen fuer die Mantisse).
	siehe auch Dokumentation zu flinit.



			flsexp( f, n )

	"floating point single exponentiation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flsexp( f, n )  floating f; single n;
	h = flsexp( f, n );    
	Es muss gelten: f ungleich 0, falls n < 0.
	h = f^n, dabei ist 0^0 = 1.     



			flsign( f )                     (MACRO)

	"floating point sign"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single flsign( f )   floating f;
	n = flsign ( f );
	n ist das Vorzeichen von f.



			flsin( a )

	"floating point sinus"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flsin( a )  floating a;
	h = flsin( a );    
	Es muss gelten: -2^15 < a < 2^15.
	h = sin ( a ).
	a wird als Winkel im Bogenmass interpretiert.



			flsin_sp( f )

	"floating point sinus special version"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flsin_sp( f )  floating f;
	h = flsin_sp( f );        
	h = sin ( f ).
	Achtung: f wird nur durch Reihenentwicklung berechnet, 
	der Algorithmus ist daher fuer grosses f langsam. 



			flsqrt( f )

	"floating point square root"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flsqrt( f )  floating f;
	g = flsqrt( f );    
	f >= 0.
	g ist die ( positive ) Quadratwurzel von f.



			flsquot( f, n )

	"floating point single quotient"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating flsquot( f, g )   floating f; single n;
	h = flsquot( f, n );     
	Es muss gelten: n ungleich 0.
	h = f / n.  



			flsum( f, g )

	"floating point sum"
	Quellbibliothek: srclib.arith1
	Include-Datei:  _arith1.h
	floating flsum( f, g )   floating f,g;
	h = flsum( f, g );
	h = f + g.   



			fltoCfl( f )

	"floating point to C-floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	double fltoCfl( f )  floating f;
	x = fltoCfl ( f );  
	Es sollte gelten: -2^1000 < f < +2^1000.
	x ist die C - floating point Darstellung von f. 



			fltoPAF( f, x )

	"( SIMATH ) floating point to Papanikolaou floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _PAFarith.h
	single fltoPAF(f, x)  floating f; Float *x;
	s = fltoPAF(f, x)
	*x = f, wobei *x gemaess den Konventionen des Papanikolaou 
	floating point package dargestellt wird.
	s ist gleich 0.
	siehe auch PAFtofl.



			fltofl( f )                     (MACRO)

	"floating point to floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating fltofl( f )  floating f;
	g = fltofl( f );
	g = f, wobei g die floating Darstellung von f ist,
	jedoch mit dem aktuellen Wert FL_EPS berechnet. 
	Genauer gilt: 
	| ( g - f ) / f | < 1/2 * (2^30)^( 1 - FL_EPS ). 
	Der Sinn von fltofl liegt darin, floating points,
	die intern mit mehr als FL_EPS + 1 Listenelementen
	dargestellt werden, mit einer Liste hoechstens 
	der Laenge FL_EPS + 1 darzustellen.



			fltor( f )

	"floating point to rational number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat fltor( f )  floating f;
	r = fltor ( f );    
	r ist die Bruchdarstellung von f.
	Der Nenner ist dabei immer eine Potenz von 2.



			fltrig( Ffunc, f )              (MACRO)

	"floating point trigonometric functions"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h (oder _PAFarith.h, s.u.)
	floating fltrig(Ffunc, f)  void (*Ffunc)(); floating f;
	g = fltrig(Ffunc, f);       
	Es muss gelten: 
	func ist eine der folgenden (trigonometrischen) Funktionen: 
	  Fsin, Fcos, Ftan, Fcot, Fsinh, Fcosh, Ftanh, Fcoth, Fasin, 
	  Facos, Fatan, Facot, Fasinh, Facosh, Fatanh, Facoth, Fasin, 
	  Facos, Fatan, Facot, Fasinh, Facosh, Fatanh, Facoth   
	f muss im Definitionsbereich von Ffunc liegen (vgl. Bemerkung 2).
	g hat den Wert Ffunc( f ).                  
	Bemerkungen: 
	     1) Die Funktion func muss als externe Funktion mit 
		Rueckgabewert void deklariert werden. Wird statt 
		_arith1.h der Header _PAFarith.h benutzt, so darf 
		die Funktion func nicht deklariert werden, da
		dies schon in _PAFarith.h geschieht; m.a.W.
		entweder:   
			#include<_arith1.h>
			void Fcosh();  
			...
			g = fltrig( Fcosh, f ); 
			...
		oder: 
			#include<_PAFarith.h>
			...
			g = fltrig( Fcosh, f ); 
			...                            
	     2) Die Funktionen werden mit Hilfe des Papanikolaou 
		floating point package (PAF) realisiert. Das hat 
		beispielsweise zur Konsequenz, dass ein overflow-
		handling mit der SIMATH-Funktion flerr() bei 
		Benutzung dieser Funktionen nicht moeglich ist.
		Desweiteren entsprechen eventuell auftretende 
		Fehlermeldungen nicht SIMATH-Standard. 
		Der Bereich der erlaubten Werte fuer f, die 
		noch akzeptiert werden, richtet sich natuerlich 
		auch nach der Implementierumg der entsprechenden
		Funktion im PAF. Innerhalb von PAF wird mit der 
		Praezision gerechnet, die durch die SIMATH-Konstante 
		FL_EPS bestimmt wird (siehe dazu flinit).
		Siehe dazu auch die Dokumentationen 
		zu flPAFfu, PAFtrans1, PAFtrans2 und PAFtrans3.       
	     3) Fuer "normale" Werte von f kann Bemerkung 2 ignoriert
		werden.



			fputcn( a, v, n, pf )

	"file put complex number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h 
	single fputcn( a, v, n, pf )  complex a; single v, n; FILE *pf;
	s = fputcn( a, v, n, pf );
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        a ist eine komplexe Zahl.
	Sei Re(a)=x und Im(a)=y, also a = x+y*i (x,y reell).
        fputcn schreibt a in der Form "x + y i" auf die Datei *pf. x und 
	y werden dabei mit --> fputflfx ausgegeben, wobei v die Anzahl 
	der Vorkommastellen und n die Anzahl der Nachkommastellen angibt. 
	Falls x = 0 oder y = 0, so wird "x + " bzw. " + y i" nicht aus-
	gegeben. Falls y = +/- 1, so wird nur "i" bzw. "-i" ausgegeben. 
	Beispiele (mit v = n = 1, in der Form
	  von a dargestellte komplexe Zahl: "Ausgabe"): 
	4+3*i: "4.0 + 3.0 i",     0: "0",       -i: "-i",
	-3*i :      "-3.0 i",     i: "i",     12.5: "12.5".
	Rueckgabe: 0 bei Erfolg, ERROR sonst.



			fputfactl( L, pf )

	"file put factor list"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputfactl(L, pf)  list L; FILE *pf;
	s = fputfactl(L, pf);
	Dabei muss gelten:
	 - L = ( p_1  e_1  p_2  e_2  ...  p_n  e_n ) 
	       int p_1, p_2, ..., p_n; single e_1, e_2, ..., e_n;
	   ist eine Liste, wie sie von 'ifel' erzeugt wird.
	 - *pf ist eine zum Schreiben geoeffnete Datei.
	fputfactl gibt die Liste L folgendermassen auf die Datei *pf aus:
	      e_1      e_2   ...      e_n
	   p_1    * p_2    *     * p_n    
	Rueckgabe: s = 0 bei Erfolg, s = ERROR sonst



			fputfl( f, n, pf )

	"file put floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputfl( f, n, pf )  floating f; single n; FILE *pf;
	t = fputfl( f, n, pf );
	f wird in der gerundeten Form [-]0.z...ze[-]z...z auf die
	Datei *pf ausgegeben. Dabei steht 'e' fuer "10^...". Die 'z'
	bezeichnen einzelne Ziffern zwischen 0 und 9. |n| ist die Anzahl
	der Ziffern, die hinter dem Punkt ausgegeben werden. Ist n negativ,
	werden Nullen am Mantissenende nicht ausgegeben.     
	Beispiele: f = 4/99, n =  6  liefert 0.404040e-1
		   f = 4/99, n = -6  liefert 0.40404e-1    
		   f = e,    n = -14 liefert 0.2718281828459e1
		   f = e,    n = 14  liefert 0.27182818284590e1
		   f = e,    n = 11  liefert 0.27182818285e1
	t = 0 bei Erfolg, ERROR sonst.     



			fputflfx( f, vk, nk, pf )

	"file put floating point by fix point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputflfx( f, vk, nk, pf )
		floating f; single vk,nk; FILE *pf;
	t = fputflfx( f, vk, nk, pf );
	vk ist nicht negativ.     
	f wird dezimal in der gerundeten Form [-]zzz.zzz auf 
	die Datei *pf ausgegeben. Die einzelnen 'z' bezeichnen
	dabei beliebige Ziffern zwischen 0 und 9. 
	vk+1 ist die Laenge des Strings vor dem Punkt ( vk Stellen 
	fuer Ziffern und eine fuer ein eventuelles Vorzeichen ). 
	Falls weniger als vk Vorkommastellen vorhanden sind, werden 
	Blanks vorangestellt, bei mehr als vk Vorkommastellen 
	werden alle Vorkommastellen ausgedruckt.  
	| nk | ist die Anzahl der Nachkommatellen, die 
	ausgegeben werden. Ist nk < 0, werden Nullen am 
	Ende nicht ausgegeben.                          
	Beispiele ( '|' bezeichne den Anfang der Ausgabe ):
	    f = 4/99, vk = 3, nk =  3 liefert |   0.040       
	    f = 4/99, vk = 3, nk = -3 liefert |   0.04       
    	    f = e,    vk = 6, nk =  4 liefert |      2.7183 
	    f = e,    vk = 6, nk =  0 liefert |      3        
	    f = -123  vk = 3, nk =  1 liefert |-123.0
	    f =  123  vk = 3, nk =  1 liefert | 123.0
	    f =  123  vk = 2, nk =  1 liefert |123.0
	    f = 2^30, vk = 3, nk =  4 liefert |1073741824.0000
	    f = 2^30, vk = 3, nk = -4 liefert |1073741824
	t = 0 bei Erfolg, ERROR sonst.     



			fputgf2el( G, a, V, pf )

	"file put Galois-field with characteristic 2 element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single fputgf2el(G,a,V,pf)  obj G; gf2el a; list V; FILE *pf;
	t = fputgf2el(G,a,V,pf);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n >= 1 in der speziellen
		Bit-Darstellung (vgl. udpm2tosb). 
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a ist ein Element aus GF(2^n), das als Polynom in einer 
		Variablen ueber Z/2Z vom Grad < n in spezieller Bit-
		Notation dargestellt wird.
	     -	V ist eine 1-elementige Variablenliste.
	a wird in Polynomdarstellung (sparse) konvertiert und auf die 
	Datei *pf ausgegeben.
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.



			fputgfsel( p, AL, a, V, pf )

	"file put Galois-field with single characteristic element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single fputgfsel(p,AL,a,V,pf)
		single p; list AL,V; gfel a; FILE *pf;
	t = fputgfsel(p,AL,a,V,pf);
	Es muss gelten : p ist eine Primzahl.
	  AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) interpretiert
	  werden (siehe gfsalgen), wobei n = llength(AL1) + 1.
	  a ist aus GF(p^n).
	  V ist eine 1-elementige Variablenliste.
	a wird auf die Datei *pf ausgegeben.
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.



			fputi( A, pf )

	"file put integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputi(A,pf)  int A; FILE *pf;
	t = fputi( A,pf );
	A wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputifel( L, pf )

	"file put integer factor exponent list"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputifel( L, pf )  list L; FILE *pf;
	Es muss gelten : L ist die Faktor-Exponenten-Liste einer posi-
		tiven ganzen Zahl n. L enthaelt somit die Primfaktori-
		sierung von n.
	fputifel gibt die in L enthaltene Primfaktorisierung von n auf
	die Datei *pf aus. Bei erfolgreicher Ausgabe gibt fputifel 0 
	zurueck, sonst ERROR.



			fputli( L, pf )

	"file put list of integers"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputli(L,pf)  list L; FILE *pf;
	t = fputli( L,pf );
	L ist eine Liste ganzer Zahlen.
	L wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputlr( L, pf )

	"file put list of rationals"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputlr(L,pf)  list L; FILE *pf;
	t = fputlr( L,pf );
	L ist eine Liste rationaler Zahlen.
	*pf ist ein zum Schreiben geoeffnetes File.
	L wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputmi( M, A, pf )

	"file put modular integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	sing|e fputmi(M,A,pf)  int M,A; FILE *pf;
	t = fputmi(M,A,pf);
	Es muss gelten : M > 0, A aus Z/M*Z.
	A wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputms( m, a, pf )

	"file put modular single"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputms(m,a,pf)  single m,a; FILE *pf;
	t = fputms(m,a,pf);
	Es muss gelten : m > 0, a aus Z/mZ.
	a wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputnfel( F, a, V, pf )

	"file put number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single fputnfel( F, a, V, pf )  pol F; nfel a; list V; FILE *pf;
	t = fputnfel( F, a, V, pf);
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		in dense-Darstellung, das einen Zahlkoerper K erzeugt.
	      - a ist ein Element von K und hat folgende Form (falls
		a != 0):
			( HNa, r, ar, ..., a0 ).
		Dabei ist
		      - HNa positive ganze Zahl;
		      - A := ( r, ar, ..., a0 ) Polynom in einer Variablen 
			ueber Z in dense-Darstellung;
		      - ggT( HNa, ar, ..., a0 ) = 1;
		      - a = 1/HNa * A.
	      - V ist 1-elementige Variablenliste.
	a wird als Polynom ueber Q in der in V angegebenen Variablen auf 
	die Datei *pf ausgegeben.
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.
	HINWEIS: Eine andere Ausgabemoeglichkeit liefert -> fputonfel.



			fputnfels( F, a, V, pf )

	"file put number field element, sparse representation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single fputnfels (F,a,V,pf)  pol F; nfel a; list V; FILE *pf;
	t = fputnfels (F,a,V,pf);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		a ist ein Element aus dem durch F gegebenen Zahlkoerper,
		das als Polynom vom Grad < Grad(F) in einer Variable ueber
		den rationalen Zahlen dargestellt ist (sparse-Darstellung).
		V ist eine 1-elementige Variablenliste.
	a wird auf die Datei *pf ausgegeben.
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.



			fputonfel( F, a, V, pf )

	"file put original number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single fputonfel( F, a, V, pf)  pol F; nfel a; list V; FILE *pf;
	t = fputonfel( F, a, V, pf);
	Dabei muss gelten:
	      _ F ist ein irreduzibles Polynom ueber Z in einer Variablen
		in dense-Darstellung, das einen Zahlkoerper K erzeugt.
	      - a ist ein Element von K und hat dabei folgende Form:
		a = 0                     ,falls a = 0.
		a = ( HNa, r, ar, ...,a0 ),sonst.
	      - Falls a ungleich 0 ist, gilt:
		      - HNa ist positive ganze Zahl.
		      - ( r, ar, ..., a0 ) ist univariates Polynom ueber
			Z in dense-Darstellung.
		      - ggt( HNa, ar, ..., a0 ) = 1.
	      - V ist einelementige Variablenliste.
	a wird seinem Aufbau entsprechend auf die Datei *pf ausgegeben.
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.
	HINWEIS: Eine uebersichtlichere aber zeitintensivere Darstellung
	-------  fuer a ungleich 0 liefert fputnfel( F, a, V, pf ).



			fputpfel( p, a, pf )

	"file put p-adic field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel fputpfel( p, a, pf )            single p; pfel a; FILE *pf;
	t = fputpfel( p, a, pf );
	Dabei muss gelten:
	      - p ist single-prim.
	      - A sei Element des p-adischenn Zahlkoerpers Qp mit einer
		Approximation a aus Qp, fuer die bzgl. der additiven p-
		adischen Bewertung vp gilt:
			vp( A - a ) >= d
		und     a = 0                        , falls d < vp( A )
		sonst   a = vp_( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei   a_vp( A ) != 0     und
			0 <= a_i <= p - 1
	      - a = 0,                   , falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d )          , sonst
	Bei korrektem Verlauf ist t = 0.
	ACHTUNG: a wird als Reihenentwicklung dargestellt. Wird die
	-------  kuerzere Zifferndarstellung als Ausgabeformat gewuenscht,
		 so muss fputspfel aufgerufen werden.



			fputqnfel( D, a, pf )

	"file put quadratic number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h 
	single fputqnfel( D, a, pf )  int D; nfel a; FILE *pf;
	s = fputqnfel( D, a, pf );
        D ist aus Z\{0,1} und quadratfrei.
        a ist ein Element von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	*pf ist eine zum Schreiben geoeffnete Datei.
	fputqnfel schreibt das von a dargestellte Zahlkoeperelement
	in die Datei *pf.
	Rueckgabe: bei Erfolg 0, sonst ERROR.



			fputqnffel( D, L, pf )

	"file put quadratic number field element factor exponent list"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single fputqnffel( D, L, pf )  int D; list L; FILE *pf; 
	s = fputqnffel( D, L, pf )
	Es muss gelten:
	 - D ist aus Z\{0,1} und quadratfrei.
	 - L ist die Faktor-Exponenten-Liste eines Elements n des
	   quadratischen Zahlkoerpers Q(D^(1/2)), d.h. von der Form
           ( P_1  f_1  pi_1  z_1 ...   P_k  f_k  pi_k  z_k)  
	     list P_i; single f_i, z_i; nfel pi_i;
             mit Primidealen P_i, den zugehoerigen Potenzen f_i, 
	     einer zu P_i gehoerigen Ortsuniformisierenden pi_i
	     und dem Zerlegungsgesetz z_i.
	     (z_i = 0, 1 oder 2, falls die Primzahl, die von P_i auf K
	     fortgesetzt wird, traege, verzweigt bzw. zerlegt ist.)
	   Es gilt also: (n) = P_1^f_1 * ... * P_k^f_k.
	fputqnffel gibt diese in L enthaltene Faktorisierung von n in
	Primideale auf die Datei *pf aus. 
	Rueckgabe: 0 bei Erfolg, ERROR sonst.



			fputqnfid( D, A, pf )

	"file put quadratic number field ideal"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single fputqnfid( D, A, pf )  int D; list A; FILE *pf; 
	s = fputqnfid( D, A, pf );
	Es muss gelten:
	 - D ist aus Z\{0,1} und quadratfrei.
	 - A ist ein Ideal des Ganzheitsrings O_D von Q(D^(1/2)).
	fputqnfid gibt das durch A repraesentierte Ideal auf die Datei
	*pf aus. Zur Darstellung von Idealen siehe qnfidprod. Ein 
	Ideal 
		A = ( a b c s )  int a,b,c; single s; 
	wird folgendermassen ausgegeben: 
		(0), falls A das Nullodeal darstellt,
                [b/s, (c+D^(1/2))/s], falls a == 1,
	    {(a)[b/s, (c+D^(1/2))/s]} sonst.
	Rueckgabe: 0 bei Erfolg, ERROR sonst.



			fputr( R, pf )

	"file put rational number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputr(R,pf)  rat R; FILE *pf;
	t = fputr( R,pf );
	R wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputrd( R, n, pf )

	"file put rational number decimal"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputrd(R,n,pf)  rat R; single n; FILE *pf;
	t = fputrd( R,n,pf );
	n ist nicht negativ.
	R wird dezimal auf die Datei *pf ausgegeben, gerundet auf n
	Nachkommastellen. Der Rundungsfehler betraegt hoechstens
	(1/2) * 10^-n. Wird der Absolutbetrag von R aufgerundet, so
	folgt der letzten Dezimalziffer ein "-", wird der Absolutbetrag
	abgerundet, so folgt ein "+".
	t = 0 bei Erfolg, ERROR sonst.



			fputrfmsp1( p, R, V, pf )       (MACRO)

	"file put rational function over modular single prime,
	transcendence degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	single fputrfmsp1(p,R,V,pf) single p; rfunc R; list V; FILE *pf;
	a = fputrfmsp1(p,R,V,pf);
	R ist eine rationale Funktion in einer Variablen ueber Z/pZ,
	p Primzahl kleiner BASIS.
	V ist eine Liste, die den Variablennamen repraesentiert, und zwar
	in der Form:
		V = ( ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ) )
	falls der Variablenname aus den n alphanumerischen Zeichen
		Bu , BZ2 , ... , BZn
	besteht; das erste Zeichen muss immer ein Buchstabe sein.
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputrfmsp1 schreibt R auf die Datei *pf und liefert den
	Ergebniswert
		0          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fputrfr( r, R, V, pf )

	"file put rational function over rationals"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	single fputrfr(r,R,V,pf)  single r; rfunc R; list V; FILE *pf;
	a = fputrfr(r,R,V,pf);
	R ist eine rationale Funktion in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputrfr schreibt eine rationale Funktion in r Variablen
	ueber den rationalen Zahlen auf die Datei *pf.
	fputrfr liefert den Ergebniswert
		0          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fputsi( n, pf )

	"file put single precision"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single fputsi(n,pf)  single n; FILE *pf;
	t = fputsi( n,pf );
	n wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputspfel( p, a, pf )

	"file put special p-adic field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel fputspfel( p, a, pf )           single p; pfel a; FILE *pf;
	t = fputspfel( p, a, pf );
	Dabei muss gelten:
	      - p ist single-prime.
	      - A sei Element des p-adischenn Zahlkoerpers Qp mit einer
		Approximation a aus Qp, fuer die bzgl. der additiven p-
		adischen Bewertung vp gilt:
			vp( A - a ) >= d
		und     a = 0                        , falls d < vp( A )
		sonst   a = vp_( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei   a_vp( A ) != 0     und
			0 <= a_i <= p - 1
	      - a = 0,                   , falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d )          , sonst
	Bei korrektem Verlauf ist t = 0.
	a wird ziffernweise ausgegeben gemaess aufsteigender Exponenten
	von p. Die Koeffizienten sind durch _ voneinander getrennt. Dabei
	wirds zur Markierung vom Uebergang negativer Exponenten zu nicht-
	negativen
		. anstatt _
	gesetzt, d. h. z.B.
		c_-1.c_0        oder    .c_0
	ACHTUNG: Wird die Reihenentwicklung als Ausgabeformat gewuenscht,
	-------  so muss fputpfel aufgerufen werden.



			getfl(  )                       (MACRO)

	"get floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating getfl( ) 
	f = getfl( );
	f wird von stdin gelesen.
	Laeuft getfl fehlerhaft ab, so wird f = ERROR geliefert.    
 	Es werden folgende Darstellungen von f akzeptiert:
        - als ganze Zahl;
	- als Bruch;
	- in folgenden Formaten ( n und m seien beliebige 
	  Ziffernfolgen, b und d positive singles ) :
	    [+-]m.n e [+-]d 
	    [+-]m.n E [+-]d
	    [+-]m.n * b ^ [+-]d 
	    [+-]m.n * b ** [+-]d    
	    b^[+-]d 
	    b**[+-]d   
	    [+-]m.n                      
	    [+-]m.n * b
	  Dabei entspricht 'e' bzw. 'E' dem Ausdruck "* 10 ^". 
	  Statt eines Punktes kann auch ein Komma stehen, 
	  entweder m oder .n koennen fehlen;
	- als Liste, die einen korrekten floating point 
	  darstellt ( interne Darstellung von f );      
	- Der character 'e' wird als Eulersche Zahl
	  interpretiert.
	- Die character-Folge "Pi" wird als 3.14... interpretiert.
	Ist a der genaue Wert, der einzulesen ist, so gilt :
	| ( a - f ) / a | <  1/2 * (2^30)^( 1 - FL_EPS ).                                                          



			getgf2el( G, V )                (MACRO)

	"get Galois-field with characteristic 2 element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el getgf2el(G,V)  obj G; list V;
	a = getgf2el(G,V);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n >= 1 in der speziellen
		Bit-Darstellung (vgl. udpm2tosb). 
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -	V ist eine 1-elementige Variablenliste.
	Von stdin wird ein Polynom in der durch V gegebenen Variable ueber
	Z eingelesen. Die Koeffizienten werden modulo 2 reduziert. 
	Dieses Polynom wird in die spezielle Bit-darstellung konvertiert 
	(siehe udpm2tosb). Danach wird es modulo G reduziert. 
	Bei korrektem Verlauf ist a dann ein Element aus GF(2^n), 
	das als Polynom in einer Variablen ueber Z/2Z vom Grad < n
	in spezieller Bit-Notation dargestellt wird.
	Ansonsten ist a = ERROR.



			getgfsel( p, AL, V )            (MACRO)

	"get Galois-field with single characteristic element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel getgfsel(p,AL,V)  single p; list AL,V;
	a = getgfsel(p,AL,V);
	Es muss gelten : p ist eine Primzahl.
	  AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) interpretiert
	  werden (siehe gfsalgen), wobei n = llength(AL1) + 1.
	  G ist ein irreduzibles, normiertes Polynom in einer Variable
	  ueber Z/pZ, das Grad n >= 1 hat.
	  V ist eine 1-elementige Variablenliste.
	Von stdin wird ein Polynom in der durch V gegebenen Variable ueber
	Z eingelesen. Dieses Polynom wird modulo G reduziert und seine
	Koeffizienten modulo p.
	Bei korrektem Verlauf steht dieses Resultat in a, ansonsten ist
	a = ERROR.



			geti(  )                        (MACRO)

	"get integer".
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int geti();
	A = geti( );
	A wird von stdin eingelesen.
	Laeuft geti fehlerhaft ab, so wird A = ERROR geliefert.



			getli(  )                       (MACRO)

	"get list of integers"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list getli(pf);
	L = getli ( );
	Von der Standardeingabe wird eine Liste, bestehend aus ganzen
	Zahlen, nach L eingelesen.
	Laeuft getli fehlerhaft ab, so ist L = ERROR.



			getlr(  )                       (MACRO)

	"get list of rational numbers"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list getlr( );
	L = getlr( );
	Von der Standardeingabe wird eine Liste, bestehend aus rationalen
	Zahlen, nach L eingelesen.
	Laeuft getlr fehlerhaft ab, so ist L = ERROR.



			getmi( M )                      (MACRO)

	"get modular integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int getmi(M)  int M;
	A = getmi(M);
	Es muss gelten : M > 0.
	Von stdin wird ein integer eingelesen und modulo M reduziert.
	Das Ergebnis ist A aus Z/M*Z bei korrektem Verlauf und A = ERROR
	bei fehlerhaftem Verlauf.



			getms( m )                      (MACRO)

	"get modular single"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single getms(m)  single m;
	a = getms(m);
	Es muss gelten : m > 0.
	Von stdin wird ein integer eingelesen und modulo m reduziert.
	Das Ergebnis ist a aus Z/mZ bei korrektem Verlauf und a = ERROR
	bei fehlerhaftem Verlauf.



			getnfel( F, V )                 (MACRO)

	"get number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel getnfel( F,V )     pol F; list V;
	a = getnfel( F,V );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom vom Grad n >= 1 in einer
		Variablen ueber Z in dense-Darstellung.
	      - V ist eine 1-elementige Variablenliste.
	Von stdin wird ein Polynom in der durch V gegebenen Variablen
	ueber den rationalen Zahlen eingelesen. Dieses Polynom wird mo-
	dulo F reduziert und anschliessend in die Form eines Elements
	von F erzeugten Zk gebracht.
	Bei korrektem Verlauf steht dieses Resultat in a, sonst ist a =
	ERROR.



			getnfels( F, V )                (MACRO)

	"get number field element, sparse representation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel getnfels(F,V)  pol F; list V;
	a = getnfels(F,V);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		V ist eine 1-elementige Variablenliste.
	Von stdin wird ein Polynom in der durch V gegebenen Variable
	ueber den rationalen Zahlen eingelesen. Dieses Polynom wird
	modulo F reduziert.
	Bei korrektem Verlauf steht dieses Resultat in a (sparse-Dar-
	stellung), ansonsten ist a = ERROR.



			getpfel( p )                    (MACRO)

	"get p-adic field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel getpfel( p )  single p;
	a = getpfel( p );
	Von der Standardeingabe wird ein Element aus Qp in approximier-
	ter Reihenentwicklung eingelesen und in eines vom Typ pfel um-
	geformt.
	Dabei gelte:
	      - p ist single-prime.
	      - a sei die Approximation zu A aus Qp vom Grad d, fuer
		die bzgl. der additiven p-adischen Bewertung vp gilt:
		      vp( A - a ) >= d
	      - A habe die Darstellung
		A = c_vp( A ) * p^vp( A ) + ... + c_d * p^d + ...
		=>  a = 0                  ,falls A = 0 oder alle c_i = 0
			( d, vp( A ), c_vp( A ), ..., c_d ),        sonst
	Fuer die Eingabe von p-adischen Elementen gelten folgende Richt-
	linien:
	      1)  Das Elementende muss mit '#' markiert sein.
	      2)  Es sind nur nichtnegative ganze Koeffizienten c_i < p
		  zugelassen. Fuer c_i = 0 kann die Angabe unterbleiben,
		  sofern ein c_j != 0 mit j > i folgt.
	      3)  Die Exponenten werden durch vorangestelltes '^' ge-
		  gekennzeichnet und sind in aufsteigender Reihenfolge
		  angegeben.
	      4)  Der Summen- bzw. Exponentenoperator kann durch Blanks
		  vom Koeffizienten bzw. Exponenten getrennt werden.
	getpfel ist insbesondere in der Lage, von putpfel geschriebene
	p-adische Elemente zu lesen.
	getpfel liefert den Ergebniswert
		a          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.
	ACHTUNG: Die Elemente muessen bereits approximiert sein. Wird
	-------  die ziffernweise Darstellung als Eingabeformat gewuenscht,
		 so muss getspfel aufgerufen werden.



			getqnfel( D )                   (MACRO)

	"get quadratic number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel getqnfel( D )  int D;
	a = getqnfel( D );
	D ist aus Z\{0,1} und quadratfrei.
	Ein Element des quadratischen Zahlkoerpers Q(D^(1/2)) wird von 
	stdin gelesen.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	Dabei sind folgende Eingaben erlaubt:
	     a1, a1/aN, ( a1  a2 ), ( a1/aN  a2 ), ( a1  a2/aN ), 
	     ( a1/aN  a2/aN ), ( aN  0  a1 ), ( aN  1  a2  a1 ) 
        mit ganzen Zahlen a1, a2, aN.
	a = 0, falls die Eingabe die Zahl 0 darstellt,
            ( aN  0  a1 ), falls die Eingabe das Zahlkoerperelement 
		       a1/aN ( + 0 * D^(1/2) ) darstellt,
            ( aN  1  a2  a1 ), falls die Eingabe das Zahlkoerperelement 
		       a1/aN + a2/aN * D^(1/2) darstellt,
            ERROR sonst.



			getr(  )                        (MACRO)

	"get rational number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat getr()
	R = getr( );
	R wird von stdin gelesen und, falls notwendig, in die gekuerzte
	Darstellung umgewandelt.
	Bei Fehler wird R = ERROR geliefert.



			getrfmsp1( p, V )               (MACRO)

	"get rational function over modular single primes, 
	 transcendence degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc getrfmsp1(p,V)  single p; list V;
	R = getrfmsp1(p,V);
	p ist eine Primzahl kleiner BASIS.
	V ist eine Liste, die den Variablennamen repraesentiert, und zwar
	in der Form
		V = ( ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ) ),
	falls der Variablenname aus den n alphanumerischen Zeichen
		Bu , BZ2 , ... , BZn
	besteht; das erste Zeichen muss immer ein Buchstabe sein.
	getrfmsp1 liest eine rationale Funktion R in einer Variablen
	ueber Z/pZ von stdin. 
	Fuer die Eingabe von rationalen Funktionen gelten folgende 
	Richtlinien:
		1)  Eine rationale Funktion R muss in der Form
			P1 / P2    oder    P1
		    dargestellt werden, wobei P1 und P2 Polynome sind
		    und die Angabe des Nenners P2 = 1 unterbleiben kann.
		    fgetrfmsp1 wandelt den Bruch, falls noetig, in die
		    gekuerzte Darstellung um. Der Bruchstrich '/' muss
		    in derselben Zeile wie das Polynomende-Zeichen '#'
		    von P1 eingegeben werden.
		2)  Fuer die Darstellung von Polynomen gelten die in
		    fgetpms angegebenen Richtlinien; insbesondere muss
		    das Polynomende immer mit '#' markiert sein.
	getrfmsp1 liefert den Ergebniswert
		R          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			getrfr( r, V )                  (MACRO)

	"get rational function over rationals"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc getrfr(r,V)  single r; list V;
	R = getrfr(r,V);
	r ist eine ganze Zahl mit 0<=r<BASIS.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	getrfr liest eine rationale Funktion in r Variablen V1,...,Vr
	ueber den rationalen Zahlen von stdin. 
	Fuer die Eingabe von rationalen Funktionen gelten folgende 
	Richtlinien:
		1)  Eine rationale Funktion R muss in der Form
			P1 / P2    oder    P1
		    dargestellt werden, wobei P1 und P2 Polynome in den
		    r Variablen V1,...,Vr sind und die Angabe des Nenners
		    P2 = 1 unterbleiben kann. getrfr wandelt den Bruch,
		    falls noetig, in die gekuerzte Darstellung um.
		    Der Bruchstrich '/' muss in derselben Zeile wie das
		    Polynomende-Zeichen '#' von P1 eingegeben werden.
		2)  Fuer die Darstellung von Polynomen gelten die in
		    getpr angegebenen Richtlinien; insbesondere muss
		    das Polynomende immer mit '#' markiert sein.
	getrfr liefert den Ergebniswert
		R          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			getsi(  )                       (MACRO)

	"get single precision"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single getsi( )
	n = getsi( );
	n wird von stdin gelesen. Bei Fehler wird n = ERROR geliefert.



			getspfel( p )                   (MACRO)

	"get special p-adic field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel getspfel( p )  single p;
	a = getspfel( p,pf );
	Von der Eingabedatei *pf wird ein Element aus Qp in ziffernwei-
	ser Darstellung der Reihenentwicklung eingelesen und in eines vom
	vom Typ pfel umgewandelt.
	Dabei gelte:
	      - p ist single-prime.
	      - a sei die Approximation zu A aus Qp vom Grad d, fuer
		die bzgl. der additiven p-adischen Bewertung vp gilt:
		      vp( A - a ) >= d
	      - A habe die Darstellung
		A = c_vp( A ) * p^vp( A ) + ... + c_d * p^d + ...
		=>  a = 0                  ,falls A = 0 oder alle c_i = 0
			( d, vp( A ), c_vp( A ), ..., c_d ),        sonst
	Fuer die Eingabe von p-adischen Elementen gelten folgende Richt-
	linien:
	      1)  Das Elementende muss mit '#' markiert sein.
	      2)  Es sind nur nichtnegative ganze Koeffizienten c_i < p
		  zugelassen. Fuer c_i = 0 kann die Angabe unterbleiben,
		  sofern ein c_j != 0 mit j > i folgt.
	      3)  Die Koeffizienten sind durch '_' voneinander getrennt.
	      4)  Die Koeffizienten werden in a u f s t e i g e n d e r
		  Weise bzgl. ihrer Exponenten aus der Reihendarstellung
		  aufgeschrieben, d. h.
			c_vp( A )_...
		  Dabei wird zur Markierung vom Uebergang negativer Ex-
		  ponenten zu nichtnegativen
			'.' anstatt '_'
		  gesetzt, d.h. z.B.
			    c_-1.c_0       oder     .c_0
	getspfel ist insbesondere in der Lage, von putspfel geschriebene
	p-adische Elemente zu lesen.
	getspfel liefert den Ergebniswert
		a          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.
	ACHTUNG: Die Elemente muessen bereits approximiert sein. Wird
	-------  die Reihenentwicklung als Eingabeformat gewuenscht, so
		 muss getpfel aufgerufen werden.



			gf2algen( n, H )

        "Galois-field with characteristic 2 arithmetic list generator"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list gf2algen(n,H)  single n; pol H;
	AL = gf2algen(n,H);
	Es muss gelten : 
	        n ist positiv.
	        H ist entweder  a) 0
		      oder      b) ein irreduzibles, normiertes Polynom in
				   einer Variablen ueber Z/2Z vom Grad n
				   in dense-Darstellung.
	AL = ( G , AL1 ) ist die Arithmetikliste fuer GF(2^n), den end-
	lichen Koerper mit 2^n Elementen, genauer :
	In Fall a) gilt :
	   G ist ein zufaellig erzeugtes, irreduzibles, normiertes Polynom
	   in einer Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   Darstellung (vgl. udpm2tosb).
	In Fall b) gilt :
	   G ist das Polynom H, dargestellt in der speziellen Bit-Notation.
	   In diesem Fall ist das Programm nur eine Konvertierungsroutine.
	Fuer AL1 gilt in beiden Faellen folgendes :
	Sei z aus HF(2^n) Nullstelle von G, so dass z^0,z^1,...,z^(n-1)
	eine Basis von HF(2^n) ueber Z/2Z bilden.
	AL1 = (l(2n-2),...,ln) ist eine Liste der Laenge n-1. Fuer alle
	i = n,...,2n-2 gilt : li ist die Darstellung von z^i als Linear-
	kombination von z^0,...,z^(n-1). Dabei ist jedes li als Polynom
	in einer Variablen ueber Z/2Z mit Grad(li) < n  in der 
	speziellen Bit-Notation repraesentiert.



			gf2dif( G, a, b )               (MACRO)

	"Galois-field with characteristic 2 difference"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2dif(G,a,b)  obj G; gf2el a, b;
	c = gf2dif(G,a,b);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a und b sind Elemente aus GF(2^n), die als Polynome in 
		einer Variablen ueber Z/2Z vom Grad < n in spezieller 
		Bit-Notation dargestellt werden.
	Ergebnis: c ist die Differenz von a und b in GF(2^n).



			gf2efe( GmtoGn, gm )

	"Galois-field with characteristic 2 embedding in field extension"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	gf2el gf2efe(GmtoGn, gm)  list GmtoGn; gf2el gm;
	gn = gf2efe(GmtoGn, gm);
	    Die Liste GmtoGn "beschreibt" die Einbettung eines
	endlichen Koerpers der Charakteristik 2 mit 2^m Elementen in
	einen Erweiterungskoerper mit 2^n (m|n) Elementen. GmtoGn wird
	mit Hilfe des Programmes gf2ies erzeugt.
	    (Dabei ist GmtoGn = ( Gn, re ) ist zweielementige
	Liste, deren erster Eintrag Gn ein irreduzibles Polynom in
	einer Veraenderlichen in spezieller Bit-Darstellung ist, das
	den Erweiterungskoerper erzeugt, und deren zweiter Eintrag die
	Einbettung einer Nullstelle des den Grundkoerper definierenden
	irreduziblen Polynoms in den Erweiterungskoerper ist.)
	   gf2efe liefert die isomorphe Einbettung gn eines Elementes
	gm des Grundkoerpers in den Erweiterungskoerper. (gm ist ein
	Element des durch Gm erzeugten Koerpers (und wird entsprechend
	dargestellt), und gn ist ein Element des durch Gn erzeugten
	Koerpers (und wird entsprechend dargestellt).



			gf2elrand( G )

	"Galois-field with characteristic 2 element randomize"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2elrand(G)  obj G;
	a = gf2elrand(G);
	Dabei muss gelten:
                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).
	gf2elrand liefert ein "zufaellig" ausgewaehltes, von 0 verschie-
	denes Element a aus dem durch G definierten Koerper GF(2^n) in 
	spezieller Bit-Darstellung.



			gf2eltogfsel( G, a )            (MACRO)

	"Galois-field with characteristic 2 element to Galois-field 
	 with single characteristic element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gf2eltogfsel(G,a)  obj G; gf2el a;
	b = gf2eltogfsel( G,a );
	G ist ein irreduzibles, normiertes Polynom in einer Variablen 
	ueber Z/2Z vom Grad n in der speziellen Bitdarstellung 
	(vgl. udpm2tosb). G kann als ein erzeugendes Polynom fuer GF(2^n)
	interpretiert werden. 
	a ist als Element aus GF(2^n) dargestellt als Polynom in einer 
	Variablen ueber Z/2Z vom Grad < n in spezieller Bit-Notation
	(Typ gf2el).
	b ist die Darstellung von a als sparse-Polynom ueber Z/2Z (Typ 
	gfel).



			gf2eltoudpm2( G, a )

	"Galois-field with characteristic 2 element to univariate 
	dense polynomial over modular 2"	
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol gf2eltoudpm2(G,a)  obj a; gf2el a;
	P = gf2eltoudpm2(G,a);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a ist ein Element aus GF(2^n), das als Polynom in einer 
		Variablen ueber Z/2Z vom Grad < n in spezieller Bit-
		Notation dargestellt wird.	
	Ergebnis: P ist die Darstellung von a als dense-Polynom in 
		einer Variablen ueber Z/2Z[X].



			gf2exp( G, a, m )

	"Galois-field with characteristic 2 exponentiation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2exp(G,a,m)  obj G; gf2el a; single m;
	c = gf2exp(G,a,m);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a ist ein Element aus GF(2^n), das als Polynom in einer 
		Variablen ueber Z/2Z vom Grad < n in spezieller Bit-
		Notation dargestellt wird.
	     -  0 <= m < BASIS
	Ergebnis: c = a^m in Gf(2^n). 		



			gf2ies( Gm, Gn, n )

	"Galois field with characteristic 2 isomorphic embedding of
	 subfield"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	list gf2ies(Gm, Gn, n)  obj Gm, Gn; single n;
	L = gf2ies(Gm, Gn, n);
	    Gm ist ein irreduzibles normiertes Polynom in einer
	Veraenderlichen ueber Z/2Z in spezieller Bit-Darstellung (vgl.
	udpm2tosb) als erzeugendes Polynom fuer den endlichen Koerper
	GF(2^m).
	    Gn ist entweder ein irreduzibles normiertes Polynom in
	einer Veraenderlichen ueber Z/2Z in spezieller Bit-Darstellung
	(vgl. udpm2tosb) als erzeugendes Polynom fuer den endlichen
	Koerper GF(2^n) oder das Nullpolynom.
	    n ist eine einfach genaue natuerliche Zahl.
	    Ist Gn das Nullpolynom, so wird n (m|n) als Grad einer
	Koerpererweiterung ueber Z/2Z interpretiert. Es wird dann
	zunaechst ein irreduzibles Polynom (in spezieller
	Bit-Darstellung) konstruiert, das einen Erweiterungskoerper von
	GF(2^m) vom Grade n ueber Z/2Z erzeugt.
	    Ist Gn bereits ein irreduzibles Polynom in spezieller
	Bit-Darstellung, so wird dieses Polynom als erzeugendes Polynom
	des Koerpers GF(2^n) interpretiert, und der Uebergabewert der
	Variablen n wird ignoriert.
	    gf2ies liefert eine Liste L = ( Gns, re )
	bestehend aus zwei Eintraegen:
	    Gns ist ein irreduzibles Polynom vom Grad n ueber Z/2Z.
	Falls Gn nicht das Nullpolynom ist (falls also ein
	definierendes Polynom Gn des Erweiterungskoerpers bereits
	angegeben war), ist Gns = Gn. Ansonsten wird Gn erzeugt. Gn ist
	vom Typ obj (vgl udom2tosb).
	    re ist die Darstellung einer Nullstelle des irreduziblen
	Polynoms Gm in dem durch Gn gegebenen Erweiterungskoerper. re
	ist vom Typ gf2el. Das Programm gf2efe benutzt diese
	Darstellung, um Einbettungen beliebiger Elemente des
	Grundkoerpers in den Erweiterungskoerper zu berechnen (siehe
	also auch gf2efe).



			gf2impsbgen( n, H )

        "Galois-field with characteristic 2 irreducible and monic 
	polynomial in special bit-representation generator"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	obj gf2impsbgen(n,H)  single n; pol H;
	G = gf2impsbgen(n,H);
	Voraussetzungen : 
	     -	n ist positiv.
	     -	H ist entweder a) 0
		      oder     b) ein irreduzibles, normiertes Polynom in
				   einer Variablen ueber Z/2Z vom Grad n
				   in dense-Darstellung.
	In Fall a) gilt :
	   G ist ein zufaellig erzeugtes, irreduzibles, normiertes Polynom
	   in einer Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   Darstellung (vgl. udpm2tosb).
	In Fall b) gilt :
	   G ist das Polynom H, dargestellt in der speziellen Bit-Notation.
	   In diesem Fall ist das Programm nur eine Konvertierungsroutine.
	In beiden Faellen kann G als erzeugendes Polynom fuer Gf(2^n)
	interpretiert werden.



			gf2inv( G, a )

	"Galois-field with characteristic 2 inverse"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2inv(G,a)  obj G; gf2el a;
	c = gf2inv(G,a);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a ist ein Element ungleich 0 aus GF(2^n), das als Polynom 
		in einer Variablen ueber Z/2Z vom Grad < n in spezieller
		Bit-Notation dargestellt wird.
	Ergebnis: c ist das multiplikativ inverse Element zu a in GF(2^n).



			gf2neg( G, a )                  (MACRO)

	"Galois-field with characteristic 2 negation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2neg(G,a)  obj G; gf2el a;
	c = gf2neg(G,a);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a ist ein Element aus GF(2^n), das als Polynom in einer 
		Variablen ueber Z/2Z vom Grad < n in spezieller Bit-
		Notation dargestellt wird.
	Ergebnis: c ist das additiv inverse Element zu a in GF(2^n).



			gf2prod( G, a, b )

	"Galois-field with characteristic 2 product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2prod(G,a,b)  obj G; gf2el a, b;
	c = gf2prod(G,a,b);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a und b sind Elemente aus GF(2^n), die als Polynome in 
		einer Variablen ueber Z/2Z vom Grad < n in spezieller 
		Bit-Notation dargestellt werden.
	Ergebnis: c ist das Produkt von a und b in GF(2^n).
	HINWEIS: Es existiert noch eine Alternativversion fuer das
		 Produkt, naemlich gf2prodAL, in der eine Arithmetik-
		 liste verwendet wird (vgl. gf2algen). gf2prodAL
		 arbeitet analog zum bisherigen gfsprod.
		 In den meisten Faellen ist gf2prod schneller und
		 benoetigt wesentlich weniger Speicher. 



			gf2prodAL( AL, a, b )

	"Galois-field with characteristic 2 product with arithmetic
	list"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2prodAL(AL,a,b)  list AL; gf2el a,b;
	c = gf2prodAL(AL,a,b);
	Voraussetzungen:
	     -  AL = (G,AL1) kann als Arithmetikliste fuer GF(2^n) 
		interpretiert werden (siehe gf2algen), wobei
			n=llength(AL1)+1.
	     -  a und b sind Elemente aus GF(2^n), die als Polynome in
		einer Variablen ueber Z/2Z vom Grad < n in spezieller
		Bit-Notation dargestellt werden.
	Ergebnis: c ist das Produkt von a und b in GF(2^n).
	HINWEIS: Die eigentliche Version des Produkts heisst gf2prod.
		 In den meisten Faellen ist gf2prod schneller und
		 benoetigt wesentlich weniger Speicher. 



			gf2quot( G, a, b )

	"Galois-field with characteristic 2 quotient"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2quot(G,a,b)  obj G; gf2el a, b;
	c = gf2quot(G,a,b);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a und b sind Elemente aus GF(2^n), die als Polynome in 
		einer Variablen ueber Z/2Z vom Grad < n in spezieller 
		Bit-Notation dargestellt werden. b ist ungleich 0.
	Ergebnis: c ist das Quotient von a und b in GF(2^n).



			gf2squ( G, a )

	"Galois-field with characteristic 2 square"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2squ(G,a)  obj G; gf2el a;
	c = gf2squ(G,a);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a ist ein Element aus GF(2^n), das als Polynom in einer 
		Variablen ueber Z/2Z vom Grad < n in spezieller Bit-
		Notation dargestellt wird.
	Ergebnis: c = a^2 in GF(2^n).
	HINWEIS: Es existiert noch eine Alternativversion fuer das
		 Quadrat, naemlich gf2squAL, in der eine Arithmetik-
		 liste verwendet wird (vgl. gf2algen). 
		 In den meisten Faellen ist gf2squ schneller und
		 benoetigt wesentlich weniger Speicher. 



			gf2squAL( AL, a )

	"Galois-field with characteristic 2 square with arithmetic
	list"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2squAL(AL,a)  list AL; gf2el a;
	c = gf2squAL(AL,a);
	Voraussetzungen:
	     -  AL = (G,AL1) kann als Arithmetikliste fuer GF(2^n) 
		interpretiert werden (siehe gf2algen), wobei
			n=llength(AL1)+1.
	     -	a ist ein Element aus GF(2^n), das als Polynom in einer 
		Variablen ueber Z/2Z vom Grad < n in spezieller Bit-
		Notation (vgl. udpm2tosb) dargestellt wird.		
	Ergebnis: c = a^2 in GF(2^n).
	HINWEIS: Die eigentliche Version des Quadrats heisst gf2squ.
		 In den meisten Faellen ist gf2squ schneller und
		 benoetigt wesentlich weniger Speicher. 



			gf2sum( G, a, b )

	"Galois-field with characteristic 2 sum"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gf2sum(G,a,b)  obj G; gf2el a, b;
	c = gf2sum(G,a,b);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a und b sind Elemente aus GF(2^n), die als Polynome in 
		einer Variablen ueber Z/2Z vom Grad < n in spezieller 
		Bit-Notation dargestellt werden.
	Ergebnis: c ist die Summe von a und b in GF(2^n).



			gfsalgen( p, n, G )

        "Galois-field with single characteristic arithmetic list generator"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list gfsalgen(p,n,G)  single p,n; pol G;
	AL = gfsalgen(p,n,G);
	Es muss gelten: 
	      - p ist Primzahl.
	      - n ist positiv.
	      - G ist entweder  a) 0
		      oder      b) ein irreduzibles, normiertes Polynom in
				   einer Variablen ueber Z/pZ vom Grad n.
	AL = ( H , AL1 ) ist die Arithmetikliste fuer GF(p^n), den end-
	lichen Koerper mit p^n Elementen, genauer:
	In Fall a) gilt:
	   H ist ein zufaellig erzeugtes, irreduzibles, normiertes Polynom
	   in einer Variablen ueber Z/pZ und hat Grad n.
	In Fall b) gilt:
	   H = G.
	Fuer AL1 gilt in beiden Faellen folgendes:
	Sei z aus GF(p^n) Nullstelle von H, so dass z^0, z^1, ..., z^(n-1)
	eine Basis von GF(p^n) ueber Z/pZ bilden.
	AL1 = (l(2n-2), ..., ln) ist eine Liste der Laenge n-1. Fuer alle
	i = n, ..., 2n-2 gilt: li ist die Darstellung von z^i als Linear-
	kombination von z^0, ..., z^(n-1). Dabei ist jedes li dense-Polynom
	in einer Variablen ueber Z/pZ mit Grad(li) < n.
!!!     HINWEIS: Das Polynom H und die Listen l(i) haben Koeffizienten 
                 vom Typ "modular single", also zwischen 0 und p-1!
                 Insbesondere ist also H kein Polynom ueber GF(p)!    



			gfsalgenies( p, m, n, ALn )

        "Galois-field with single characteristic arithmetic list generator
	 isomorphic embedding of subfield"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	list gfsalgenies(p,m,n,ALn)  single p,m,n; list ALn;
        L = gfsalgenies(p,m,n,ALn);
        Es wird die Arithmetikliste des endlichen Koerpers GF(p^m) ueber 
        GF(p) erzeugt (vgl. gfsalgen, 1<p<BASIS, 1<=m<BASIS). 
        ZUSAETZLICH wird eine isomorphe Einbettung des durch die Arith-
        metikliste ALn gegebenen Teilkoerpers GF(p^n) < GF(p^m) in GF(p^m)
        gegeben. Dabei wird vorausgesetzt:
                 GF(p^n) := GF(p)(t), 
                 GF(p^m) := GF(p)(s), 
                 n teilt echt m,
                 m = m0 * n und 
                 f(X) := Irr(t, Z/pZ) aus Z/pZ[X] (vom Typ pms !).
        Dann gilt:
        Es wird zufallsmaessig ein irreduzibles Polynom ueber Z/pZ vom
        Grad m bestimmt und anschliessend f(X) in GF(p^m)[X] faktorisiert.
        f(X) zerfaellt dabei in n verschiedene Linearfaktoren, die den n
        konjugierten Nullstellen t, t^p, t^(p^2), ..., t^(p^(n-1)) ent-
        sprechen. Eine beliebige Nullstelle (als Linearkombination von 
        s-Potenzen) entspricht dem Bild von t unter einer isomorphen Ein-
        bettung; es wird die Nullstelle von kleinstem Grad (in s) ge-
        sucht und uebergeben.
        Es ist L = ( ALm, P ), wobei ALm die Arithmetikliste von GF(p^m) 
        ist und einem Ergebnis von "gfsalgen" entspricht. Das Polynom P
        stellt das Bild von t unter der isomorphen Einbettung dar, also
        als Linearkombination von s-Potenzen vom Grad kleiner m:
        P = a(0) + a(1)*s + ... + a(m-1)*s^(m-1), a(i) = gfel, P = upgfs.
!!!     HINWEIS:          P ist vom Typ gfel !



			gfsdif( p, AL, a, b )           (MACRO)

	"Galois-field with single characteristic difference"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gfsdif(p,AL,a,b)  single p;  list AL;  gfel a,b;
	c = gfsdif(p,AL,a,b);
	Es muss gelten : p ist Primzahl.
		AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n=llength(AL1)+1.
		a und b sind Elemente aus GF(p^n), die als Polynome vom
		Grad < n in einer Variable ueber Z/pZ dargestellt sind.
	c ist die Differenz von a und b in GF(p^n).



			gfsefe( p, ALm, a, g )

        "Galois-field with single characteristic embedding in field
	 extension"
        Quellbibliothek: srclib.arith2
        Include-Datei:   _arith2.h
        gfel gfsefe(p,ALm,a,g)  single p; list ALm; gfel a,g;
        b = gfsefe(p,ALm,a,g);           
        Es wird das Element a aus GF(p^n) dargestellt als Element 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 in gfsalgenies gefundenen isomorphen
        Einbettung von GF(p^n) in GF(p^m).
	(vgl. gfsalgen, gfsalgenies)
        b ist die Darstellung von a als Element aus GF(p^m).
!!!     HINWEIS: g ist vom Typ "gfel", d.h. ein sparse-Polynom in einer
                 Unbestimmten mit Koeffizienten aus Z/pZ.



			gfselrand( p, AL )

	"Galois-field with single characteristic, element randomize"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gfselrand( p, AL )  single p; list AL; 
	a = gfselrand( p, AL );
	p ist eine Primzahl < BASIS.
        AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) interpretiert
        werden (siehe gfsalgen), wobei n = llength(AL1) + 1.
	a ist ein zufaellig erzeugtes Element aus GF(p^n).



			gfseltogf2el( G, a )

	"Galois-field with single characteristic element to 
	 Galois-field with characteristic 2 element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gf2el gfseltogf2el(G, a)  obj G; gfel a;
	b = gfseltogf2el( G, a );
	G ist ein irreduzibles, normiertes Polynom in einer Variablen 
	ueber Z/2Z vom Grad n in der speziellen Bitdarstellung 
	(vgl. udpm2tosb). G kann als ein erzeugendes Polynom fuer 
	GF(2^n) interpretiert werden.
	a ist als Element von GF(2^n) dargestellt als sparse-Polynom vom 
	Grad < n ueber Z/2Z (Typ gfel).
	b ist die Darstellung von a als Polynom in einer Variablen ueber 
	Z/2Z vom Grad < n in spezieller Bit-Notation (Typ gf2el).



			gfsexp( p, AL, a, m )

	"Galois-field with single characteristic exponentiation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gfxp(p,AL,a,m)  single p; list AL; gfel a; single m;
	b = gfsexp(p,AL,a,m);
	Es muss gelten : p Primzahl, 1<p<BASIS
                         AL Arithmetikliste fuer GF(p^n) 
                            (vgl. gfsalgen, 1<=n<BASIS)
                         a ist Element aus GF(p^n)
                         0<=m<BASIS
        b = a^m als Element aus GF(p^n)



			gfsinv( p, AL, a )

	"Galois-field with single characteristic inverse"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gfsinv(p,AL,a)  single p;  list AL;  gfel a;
	c = gfsinv(p,AL,a);
	Es muss gelten : p ist Primzahl.
		AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n=llength(AL1)+1.
		a ist ein Element ungleich 0 aus GF(p^n), das als Polynom
		vom Grad < n in einer Variable ueber Z/pZ dargestellt ist.
	c ist das multiplikativ inverse Element zu a in GF(p^n).



			gfsneg( p, AL, a )              (MACRO)

	"Galois-field with single characteristic negation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gfsneg(p,AL,a)  single p;  list AL;  gfel a;
	c = gfsneg(p,AL,a);
	Es muss gelten : p ist Primzahl.
		AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n=llength(AL1)+1.
		a ist ein Element aus GF(p^n), das als Polynom vom
		Grad < n in einer Variable ueber Z/pZ dargestellt ist.
	c ist das additiv inverse Element zu a in GF(p^n).



			gfsnegf( p, AL, a )

	"Galois-field with single characteristic negation as function"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gfsnegf(p,AL,a)  single p; list AL; gfel a;
	c = gfsnegf(p,AL,a);
	Es muss gelten : p ist Primzahl.
		AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n=llength(AL1)+1.
		a ist ein Element aus GF(p^n), das als Polynom vom
		Grad < n in einer Variable ueber Z/pZ dargestellt ist.
	c ist das additiv inverse Element zu a in GF(p^n).
	Liefert das gleiche Ergebnis wie das Macro gfsneg.



			gfsprod( p, AL, a, b )

	"Galois-field with single characteristic product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gfsprod(p,AL,a,b)  single p;  list AL;  gfel a,b;
	c = gfsprod(p,AL,a,b);
	Es muss gelten : p ist Primzahl.
		AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n=llength(AL1)+1.
		a und b sind Elemente aus GF(p^n), die als Polynome vom
		Grad < n in einer Variable ueber Z/pZ dargestellt sind.
	c ist das Produkt von a und b in GF(p^n).



			gfsquot( p, AL, a, b )

	"Galois-field with single characteristic quotient"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gfsquot(p,AL,a,b)  single p;  list AL;  gfel a,b;
	c = gfsquot(p,AL,a,b);
	Es muss gelten : p ist Primzahl.
		AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n=llength(AL1)+1.
		a und b sind Elemente aus GF(p^n), die als Polynome vom
		Grad < n in einer Variable ueber Z/pZ dargestellt sind.
		b ungleich 0.
	c ist der Quotient von a und b in GF(p^n).



			gfssum( p, AL, a, b )           (MACRO)

	"Galois-field with single characteristic sum"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gfssum(p,AL,a,b)  single p;  list AL;  gfel a,b;
	c = gfssum(p,AL,a,b);
	Es muss gelten : p ist Primzahl.
		AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n=llength(AL1)+1.
		a und b sind Elemente aus GF(p^n), die als Polynome vom
		Grad < n in einer Variable ueber Z/pZ dargestellt sind.
	c ist die Summe von a und b in GF(p^n).



			gfssumf( p, AL, a, b )

	"Galois-field with single characteristic sum as function"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	gfel gfssumf(p,AL,a,b)  single p; list AL; gfel a,b;
	c = gfssumf(p,AL,a,b);
	Es muss gelten : p ist Primzahl.
		AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
		pretiert werden (siehe gfsalgen), wobei n=llength(AL1)+1.
		a und b sind Elemente aus GF(p^n), die als Polynome vom
		Grad < n in einer Variable ueber Z/pZ dargestellt sind.
	c ist die Summe von a und b in GF(p^n).
	Liefert das gleiche Ergebnis wie das Macro gfssum.



			i22prod( A, B )

	"integer 2x2 product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int i22prod(A,B)  int A, B;
	C = i22prod( A, B );
	Es muss gelten: 
		2^30 <= |A| < 2^60.
		2^30 <= |B| < 2^60.
	C = A * B.          



			iHDfu( func, anzahlargs, arg1, arg2 )

	"integer using Heidelberg arithmetic functions"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	int iHDfu(func, anzahlargs, arg1, arg2)
	       void (*func)(); single anzahlargs; integer arg1, arg2;
	f = iHDfu( func, anzahlargs, arg1, arg2);       
	Es muss gelten: 
	func ist eine der Funktionen des Heidelberger integer package.
	anzahlargs ist die Anzahl der Argumente, die fuer diese Funktion 
	uebergeben werden muessen. 
	Das Programm konvertiert die Eingabeparameter arg1 und arg2 
	gemaess den Konventionen der Heidelbeger Arithmetik und wendet die    
	Funktion func auf diese an. Das Ergebnis wird als SIMATH-Datentyp
	zurueckgegeben. 
	Detailliertere Angaben ueber die erlaubten Funktionen 
	koennen in der Dokumentaion der Files HD..., die die 
	Heidelberger Arithmetik enthalten, nachgeschlagen werden. 



			iabs( A )                       (MACRO)

	"integer absolute value"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iabs(A)  int A;
	B = iabs(A);
	B = |A|.



			iafmsp1psval( p, P, A )

	"integral algebraic function over modular single prime,
	transcendence degree 1, P-star valuation"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	rat iafmsp1psval(p,P,A) single p; pol P, A;
	v = iafmsp1psval(p,P,A);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single
	Primzahl ist.
	P ist ein irreduzibles Polynom in x ueber Z/pZ und A ein
	normiertes irreduzibles Polynom in einer Unbebestimmten
	ueber (Z/pZ) [x] - dem Polynomring in x ueber Z/pZ.
	A wird aufgefasst als das Minimalpolynom eines ganzen
	algebraischen Elementes I einer separablen Algebra ueber
	dem rationalen Funktionenkoerper (Z/pZ) (x).
	v ist der Wert der P-star Bewertung des Elementes I.
	Dabei ist der P-star Wert eines Elementes I gleich dem
	Minimum aller Werte von I bezueglich aller Fortsetzungs-
	bewertungen der P-adischen Bewertung des Funktionenkoer-
	pers (Z/pZ) (x) auf die separable Algebra.
	(Der P-star Wert ist aus dem Minimalpolynom zu berechnen
	und das Element I muss von daher nicht angegeben sein.)



			iaval( m, A )

	"integer additive m-adic value"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single iaval( m, A )  single m; int A;
	w = iaval( m, A );
	Es muss gelten: m >= 2.
			A != 0.
	w ist der additive m-adische Wert von A, d.h.
	w ist maximal mit der Eigenschaft m^w | A.



			iavalint( M, I )

	"integer additive value with respect to integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single iavalint(M,I)  int M,I;
	w = iavalint(M,I);
	M ist > 1.
	I ist ungleich Null.
	w ist der additive M-adische Wert von I, d.h.
	w ist maximal mit der Eigenschaft M^w | I.



			ibinom( n, k )

	"integer binomial coefficient"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int ibinom( n,k )  int n,k;
	B = ibinom( n,k );
	Es muss gelten: n ist eine nichtnegative ganze Zahl.
		k ist eine nichtnegative ganze Zahl, die kleiner oder
		gleich n ist.
	b ist der Binomialkoeffizient n ueber k, also die Anzahl der
	ungeordneten k-elementigen Teilmengen einer n-elementigen Menge.



			icomp( A, B )

	"integer comparison".
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single icomp(A,B)   int A, B;
	n = icomp( A, B );
	n ist das Signum von A-B.



			idif( A, B )

	"integer difference"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int idif(A,B)  int A,B;
	C = idif(A,B);
	C = A - B.



			iecfindp( p, a, b )

	"integer elliptic curve find point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list iecfindp(p, a, b)	int p, a, b;
	P = iecfindp(p, a, b);
	Es muss gelten:
	p > 2 sollte Primzahl sein.
	a, b sind aus Z/pZ, d.h. 0 <= a,b < p.
	Es wird versucht, einen Punkt P auf der elliptischen Kurve
	E: y^2 = x^3 + ax + b (mod p)
	zu finden.
	Bei Erfolg: P = (Xp, Yp) liegt auf E, und P ist nicht der
	Fernpunkt.
	Bei Misserfolg: P = (), das heisst es wurde erkannt, dass
	p nicht prim ist.
	Warnung: iecfindp wird zum Primzahltesten benutzt. Bei der 
	Kombination mit den Programmen "ecmp..." zu elliptischen Kurven 
	ist Vorsicht geboten, da die Punkte auf elliptischen Kurven hier
	affin dargestellt sind.



			iecgnpj( p, m, h1, h2, D )

	"integer elliptic curve of given number of points, j-invariant"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list iecgnpj (p,m,h1,h2,D)  int p,m,D; single h1,h2;
	J = iecgnpj (p,m,h1,h2,D);
	Es muss gelten:
	p > 3 sollte Primzahl sein.
	0 <= h1 und 0 <= h2.
	D <= 0.
	Ist m != p+1, so wird eine Liste aller j-Invarianten
	von elliptischen Kurven	ueber GF(p) bestimmt,
	die genau m rationale Punkte besitzen.
	Ist m = p+1, so besteht J nur aus einem Element.
!!!	Die Laufzeit ist drastisch von der Idealklassenzahl h der
	Maximalordnung des imaginaerquadratischen Zahlkoerpers
	Q(sqrt(D)) mit D = (p+1-m)^2 -4p abhaengig.
	Ist der quadratfreie Anteil von D bekannt, so kann dieser
	zur Beschleunigung der Berechnung angegeben werden.
	Ansonsten setzt man D = 0.
	Ist J = (), so ist h < h1 oder h > h2
	(h2 = 0 wird als unendlich interpretiert), oder
	es existiert keine elliptische Kurve mit
	#E(GF(p)) = m.
!!!	Wird erkannt, dass p nicht prim ist, so ist J = -1.



			iecjtoeq( p, j )

	"integer elliptic curve j-invariant to equation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list iecjtoeq (p,j)  int p,j;
	L  = iecjtoeq (p,j);
	Es muss gelten:
	p > 3 sollte Primzahl sein, und
	j ist in Z/pZ, d.h. 0 <= j < p.
	Es wird eine Liste L = (a,b,a',b') mit a,b,a',b' in Z/pZ 
	(d.h. in {0,1,...,p-1}) mit folgender Eigenschaft erzeugt:
	1. E : y^2 = x^3 + a x + b		und
	   E': y^2 = x^3 + a'x + b'
	   sind elliptische Kurven ueber Z/pZ mit j-Invariante j.
	2. Falls E nicht supersingulaer ist, so sind 
	   E und E' nicht isomorph ueber Z/pZ.
	3. #E + #E' = 2p + 2 ueber Z/pZ.
!!!	Wird erkannt, dass p nicht prim ist, so wird L = () geliefert.		



			iecjtoeqsv( p, j, pi )

	"integer elliptic curve j-invariant to equation special version"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list iecjtoeqsv (p,j,pi)  int p,j;  list pi;
	L  = iecjtoeqsv (p,j,pi);
	Es muss gelten:
	p > 3 sollte Primzahl sein und
	j = 0 oder 1728 mod p, also ein Wert aus {0,1,...,p-1}.
	pi = (A,B) mit A und B in Z wird interpretiert
	als pi = A+B*exp(2*Pi*i/f) wobei i*i = -1, Pi = 3.1415...
	und f = 6, falls j =    0 mod p,
	    f = 4, falls j = 1728 mod p.
	p = Norm (pi), d.h.
	fuer f = 4 ist pi = A+B*i, also Norm (pi) = (A+B*i)*(A-B*i) 
						  =  A^2 + B^2;
	fuer f = 6 ist pi = A+B*zeta, also Norm (pi) = (A+B*zeta)*(A+B*zeta')
						     =  A^2 + AB + B^2.
	(Dabei sind zeta  = 1/2 + 1/2*i*3^(1/2)
	        und zeta' = 1/2 - 1/2*i*3^(1/2)
	die primitven 6. Einheitswurzeln.)
	Es wird eine Liste L = (a,b) mit a,b in Z/pZ (also in {0,1,...,p-1})
	mit folgender Eigenschaft erzeugt:
	1. E : y^2 = x^3 + a x + b
	   ist eine elliptische Kurven ueber Z/pZ mit j-Invariante j.
	2. #E(Z/pZ) = Norm (1-pi)
	3. j =    0 mod p => a = 0
	   j = 1728 mod p => b = 0
!!!	Wird erkannt, dass p nicht prim ist, so wird L = () geliefert.



			iecpprod( p, E, P, a )

	"integer elliptic curve point product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list iecpprod(p, m, P, a)  int p, m, a; list P;
	Q = iecpprod(p, m, P, a);
	Es muss gelten:
	p > 3 sollte Primzahl sein.
	a ist aus Z/pZ.
	m >= 0.
        P = (Xp, Yp) ist ein Punkt auf der elliptischen Kurve
	E: y^2 = x^3 + ax + b (mod p),
	wobei b durch den Punkt P eindeutig bestimmt ist.
	Der Fernpunkt wird durch das Atom 0 repraesentiert.
	Das Programm versucht,
		Q = m * P = P + P + P + ... + P 
	auf der elliptischen Kurve zu berechnen.
	Bei Erfolg: Q = m * P.
	Bei Misserfolg: Q = (), das heisst, es wurde erkannt, dass
	p nicht prim ist.	
	Warnung: iecpprod wird zum Primzahltesten benutzt. Bei der 
	Kombination mit den Programmen "ecmp..." zu elliptischen Kurven 
	ist Vorsicht geboten, da die Punkte auf elliptischen Kurven hier
	affin dargestellt sind.



			iecpsum( p, P, Q, a )

	"integer elliptic curve point sum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list iecpsum(p, P, Q, a)  int p,a; list P,Q;
	R = iecpsum(p, P, Q, a);
	Es muss gelten:
	p > 3 sollte Primzahl sein.
	a ist aus Z/pZ, d.h. 0 <= a < p.
        P  = (Xp, Yp) und Q = (Xq, Yq) sind Punkte auf der elliptischen 
	Kurve
		E: y^2 = x^3 + ax + b (mod p),
	wobei b durch die Punkte P und Q eindeutig bestimmt ist.
	Der Fernpunkt wird durch das Atom 0 repraesentiert.
	iecpsum versucht, R = P + Q auf E zu berechnen.
	Bei Erfolg: R = P + Q.
	Bei Misserfolg: R = (), das heisst es wurde erkannt, dass
	p nicht prim ist.	
	Warnung: iecpsum wird zum Primzahltesten benutzt. Bei der 
	Kombination mit den Programmen "ecmp..." zu elliptischen Kurven 
	ist Vorsicht geboten, da die Punkte auf elliptischen Kurven hier
	affin dargestellt sind.



			iecpt( n, m, lp, a, b, anz )

	"integer elliptic curve primality test"
	Quellbibliothek : srclib.arith1
	Include-Datei	: _arith1.h
	single iecpt(n, m, lp, a, b, anz)  int n, m, a, b; list lp; single anz;
	erg = iecpt(n, m, lp, a, b, anz);
        Es muss gelten:
	n > 3
	m > 0
	anz > 0
	a, b sind aus Z/nZ.
	Fuer alle P auf der elliptischen Kurve E gilt m*P = 0 mit
	E: y^2 = x^3 + a*x + b mod p.
	lp ist Liste der Primfaktoren von m.
	erg =  1: n ist Primzahl.
	erg =  0: n ist nicht prim.
	erg = -1: Es konnte nicht entschieden werden, ob n prim ist
		  oder nicht.
	anz gibt die maximale Anzahl der unternommenen Versuche an,
	die unternommen werden um nachzuweisen, dass n Primzahl ist.



			iegcd( A, B, pU, pV )

	"integer extended greatest common divisor"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iegcd(A,B,pU,pV)   int A, B, *pU, *pV;
	C = iegcd( A, B, pU, pV );
	C ist der groesste gemeinsame Teiler von A und B.
	Berechnet werden *pU, *pV, wobei C = *pU * A + *pV * B.
	Sind dabei A und B ungleich 0, so gilt
	|*pU| <= |B|/2*C und |*pV| <= |A|/2*C,
	sonst ist *pU das Signum von A und *pV das Signum von B.



			ieven( A )

	"integer even"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ieven(A)  int A;
	n = ieven(A);
	n ist 1, falls A gerade ist,
	  und 0, falls A ungerade ist.



			iexp( A, n )

	"integer exponentiation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iexp(A,n)   int A; single n;
	B = iexp( A , n );
	n >= 0.
	B = A ^ n.



			ifact( [-brk, ][-imp, ][-elc, ][-rho, ]N )

	"integer factorization" (rekursiv)
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list ifact( [ -brk ,] [ -imp ,] [ -elc ,] [ -rho ,] N )  
		int N;  single brk, imp, elc, rho;
	L = ifact( [ -brk ,] [ -imp ,] [ -elc ,] [ -rho ,] N );
        N wird faktorisiert. brk, imp, elc, rho sind optional.  
	In der Regel reicht der Aufruf "L = ifact( N );" aus. 
	Fuer sehr spezielle Awendungen koennen optional Parameter 
	mit uebergeben werden. 
	HINWEIS: Ab Version 3.6 ist ein explizites Setzen der Parameter
	imp, elc und rho nicht mehr sinnvoll, da ifact intern optimiert ist.  
	Aeltere Programme, die ifact mit diesen Optionen aufrufen, laufen 
	natuerlich weiterhin korrekt.
	Erklaerung der Parameter:
        brk :   Ist brk = 1, so bricht das Programm ggf. (s.u.) ab,  
		ist brk = 0, laeuft das Programm solange, bis alle 
		Primfaktoren gefunden sind (u.U. ewig). 
                Voreinstellung : brk  = 0.
        imp :   Fuer  0 < p < imp wird p als Primfaktor probiert.
                Voreinstellung : imp = 5000.  
	elc :   elc gibt an, wieviele elliptische Kurven maximal 
		getestet werden (siehe Dokumentation zu elcpds und elcfds). 
          	Fuer N < 2^320 ist die Anzahl der getesteten Kurven immer 
          	ein Vielfaches von 32 (z.B. elc = 40 => Anzahl benutzter 
		Kurven = 32).
                Voreinstellung : elc = 2^25, falls brk = 0,
                                 elc = 200, falls brk = 1.            
                Wird elc gesetzt, so  m u s s  auch imp gesetzt werden.
	rho :   rho ist die maximale Anzahl an Iterationen bei 
		Pollard's rho-Methode (siehe Dokumentation zu rhopds).
                Voreinstellung : rho = 2500.                             
		Wird rho gesetzt, muessen auch elc und imp gesetzt werden.
	Es muss gelten : N > 0, 0 <= brk <= 1, imp > 997, elc >= 0, 
		rho >= 0.
	L = ( [err], q1,..., qr ) mit 0 < q1 <=...<= qr, N = q1 *...* qr, 
	err <= 0 bzw. fehlt ( dazu Abfrage: lfirst(L) <= 0 ? ).
	Fehlt err, dann sind q1,...,qr Primfaktoren (gilt stets, falls 
	brk = 0). 
	Ist err angegeben, dann wurde irgendwo abgebrochen, d.h. im 
	Einzelnen:
	err = -1 : Die Suche mit rhopds und elcpds/elcfds war erfolglos.
	      -2 : Beim Test, ob qi Primzahl ist, konnte qi - 1 nicht 
		   faktorisiert werden fuer ein i (siehe Dokumentation 
		   zu ispt.
	      -3 : Mit rhopds oder elcpds wurde ein Faktor gefunden,
		   der nicht faktorisiert werden konnte.      
	      -4 : Der Primzahltest konnte nicht entscheiden, ob qi 
		   Primzahl ist fuer ein i ( ispt(qi,..) = 0, siehe 
		   Dokumentation zu ispt). 
	Die Abbruchstellen sind im Source - Programm gekennzeichnet. 
	Unabhaengig von imp werden manchmal auch groessere Primfaktoren 
	gefunden (z.B. falls N < 2^60).    
	siehe auch: ifactpp, isiprime, isipprime, ifactcfe.



			ifact60( N )

	"integer factorization, N < 2^60"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list ifact60(N)  int N;
	L = ifact60(N);
	Es muss gelten : 1 <= N < 2^60.
	L = (p1,...,pr) ist die aufsteigend sortierte Liste aller Primfak-
	toren von N, d.h. N = p1*...*pr.



			ifact_o( N )

	"integer factorization, old version" (rekursiv)
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list ifact_o(N)  int N;
	L = ifact_o(N);
	Es muss gelten : N > 0.
	L = (q1,...,qr) mit q1 <= ... <= qr ist die Liste der Primfaktoren
	von N, d.h. N = q1 * ... * qr.



			ifactcfe( n, Large_P, K, mode )

	"integer factorization continued fraction expansion"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list ifactcfe(n, Large_P, K, mode)  int n; single Large_P, K, mode;
	N = ifactcfe(n, Large_P, K, mode);
	Beispiel: N = ifactcfe(n, 0, 0, 0);
        Es muss gelten:
		n ist positiv.
		Large_P = 0 oder 1.
	Es wird versucht, n in seine Primfaktoren zu zerlegen.
	ifactcfe ist fuer grosses n gedacht, etwa n > 1E25, mit wenigen,
	grossen Faktoren.
        N = ([error], n1, n2, ... , nk)
	mit 0 < n1 <= n2 <= ... <= nk und n = n1 * n2 * ... * nk.
 	Ist n = 1, so ist N = _0.
	error ist < 0  bzw. fehlt.
	error fehlt   : Die ni sind Primfaktoren von n.
	error	= -1  : Von mindestens einem ni (u.U. n selbst) konnte nicht
		        festgestellt werden, ob es prim ist.
	error	= -2  : ifactcfe war erfolglos, d.h. mindestens ein Faktor
		        ni ist nicht prim.
	Weiterhin gilt:
	Large_P = 1   : large-prime Variante.
	Large_P	= 0   : Faktorisiering ohne Verwendung der large-prime
		        Variante.
		Wird mit large-prime Variante faktorisiert, so ergeben sich
		kuerzere Laufzeiten. Der externe Speicherbedarf ist jedoch
		wesentlich groesser.
!!!	K	      : ifactcfe legt Dateien auf Platte an. Die Kennung K
		        wird vom Benutzer vorgegeben und dient dazu,
		        diese Dateien zu unterscheiden, falls mehrere
		        ifactcfe-Prozesse laufen sollten.
		        Die Dateien stehen unter cfe_`K' im aktuellen Ver-
			zeichnis.
	mode ist Bitweise codiert:
	mode & 1 = 1  : Wurde ifactcfe gestoppt, so werden die bereits
		        vorhandenen Daten wieder verwendet und gehen
		        nicht verloren. Hierzu ist es notwendig, dass
		        der neue Aufruf mit dem alten in n und K ueber-
		        einstimmt. Die verbleibenden Parameter duerfen
		        abweichen.
	mode & 1 = 0  : Eventuell vorhandene Daten werden ignoriert.
	mode & 2 = 2  : Konnte von einem oder mehreren Faktoren von n
			nicht entschieden werden, ob sie prim sind, so
			wird auch nicht versucht, diese weiter zu zerlegen.
	mode & 2 = 0  : Konnte von einem oder mehreren Faktoren von n
			nicht entschieden werden, ob sie prim sind, so
			wird dennoch versucht, diese weiter zu zerlegen.
	mode & 4 = 0  : Es wird getestet, ob n prim ist.
	mode & 4 = 4  : Es wird angenommen, dass n nicht prim ist.
	Die Grundlage fuer ifactcfe bildet folgender Artikel:
		Refined Analysis and Improvements
		on some Factoring Algorithms
		C. P. Schnorr
		Fachbereich Mathematik
		Universitaet Frankfurt
		Dezember 1980



			ifactl( a )

	"integer factorial"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int ifactl(a)   single a;
	A = ifactl( a );
	a >= 0.
	A ist die Fakultaet von a.



			ifactlf( n, G, p, quot )

	"integer factorization large factor"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list ifactlf(n, G, p, quot)  int n, G; single p, quot;
	L = ifactlf(n, G, p, quot);
        Es muss gelten:
	0 < n
	0 < G <= n
	0 < p < 100
	quot > 0
	Dann gilt:
	L ist Liste aller Primfaktoren (mit Vielfachheit) von n oder
	die leere Liste.
	ifactlf ist in der Regel dann erfolgreich, wenn n einen 
	grossen Primfaktor oder nur kleine Faktoren hat.
	Besitzt n einen grossen Primfaktor p und ist
	n/p < quot, so wird L = () zurueckgeliefert.
	Standarteinstellung: quot = 1.
	Zur Bedeutung der Parameter G und p siehe -> irds.
	L ist in der Regel nicht geordnet.



			ifactpp( N )

	"integer factorization into pseudoprimes" (rekursiv)
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list ifactpp( N )  int N;
	L = ifactpp( N );
	Es muss gelten: N > 0. 
        N wird faktorisiert.  
	L = ( q1,..., qr ) mit 0 < q1 <=...<= qr, N = q1 *...* qr. 
	q1,...,qr sind Pseudoprimzahlen, das heisst sie bestehen den 
	Miller-Rabin Primzahltest zu 10 zufaellig ausgewaehlten Basen 
	(zehnmaliger Aufruf von isipprime mit zufaelligen Basen, siehe
	Dokumentation zu isipprime).
	siehe auch: ifact, isiprime, isipprime, ifactcfe.



			ifel( LP )

	"integer factor exponent list"
	Quellbibliothek: srclib.arith1
	Include_Datei:   _arith1.h
	list ifel( LP )  list LP;
	L = ifel( LP );
	LP ist die Liste der aufsteigend sortierten Primfaktoren 
	einer positiven ganzen Zahl n.
	L = ( p1, e1, ..., pk, ek ), wobei die pi die Primfaktoren
	von n sind mit zugehoerigen Exponenten ei. Die pi sind in
	absteigender Reihenfolge geordnet.



			ifelprod( a, b )

	"integer factor exponent list product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list ifelprod( a,b )  list a,b;
	c = ifelprod( a,b );
	Es muss gelten : a und b sind Faktor-Exponenten Listen von gan-
		zen Zahlen A und B, die beide verschieden von Null sind.
	c ergibt sich aus dem Produkt der Zahlen A und B, dargestellt in
	Faktor-Exponenten-Schreibweise.



			ifrl( N, pm )

	"integer Fermat residue list"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list ifrl(N,pm)  int N;  single *pm;
	L = ifrl(N,pm);
	Es muss gelten : N > 0.
			 N hat keine Primteiler < 17.
	*pm ist positive einfachgenaue Zahl, und L ist eine Liste von Ele-
	menten aus Z/(*pm)Z, so dass folgendes gilt :
	Falls fuer ein x aus Z x*x-n ein Quadrat in Z ist, dann ist x kon-
	gruent a modulo *pm fuer ein a aus L.



			iftpt( n, L, anz )

	"integer Fermat's theorem primality test"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single iftpt(n, L, anz)	 int n; list L; single anz;
	erg = iftpt(n, L, anz);
        Es muss gelten:
	    n > 3.
	    anz > 0.
	    L ist Liste der Primfaktoren von n-1.
	Ist erg =  1, so ist n Primzahl.
	Ist erg =  0, so ist n keine Primzahl.
	Ist erg = -1, so konnte nicht entschieden werden, ob n prim ist
		      oder nicht.
	iftpt sucht ein Element der Ordnung > sqrt(n) in (Z/nZ)*.
	anz ist die maximale Anzahl von Versuchen, die unternommen werden,
	um ein solches Element zu finden (d.h. zu zeigen, dass n prim ist).
	Standard: anz etwa 100 - 1000.
	Siehe auch -> ispt, isiprime, isipprime, isispprime.
	Zur Erzeugung von L siehe -> ifact, ifactlf, ... .



			igcd( A, B )

	"integer greatest common divisor"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int igcd(A,B)  int A, B;
	C = igcd( A, B );
	C ist der groesste gemeinsame Teiler von A und B.



			igcd_lo( A, B )

	"integer greatest common divisor, lists only"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int igcd_lo(A,B)  int A, B;
	C = igcd_lo( A, B );
	C ist der groesste gemeinsame Teiler von A und B.      
	Es wird nur innerhalb der SIMATH-Speicherverwaltung 
	gearbeitet, d.h. ohne Essener Arithmetik.



			igcdcf( A, B, pU, pV )

	"integer greatest common divisor and cofactors"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int igcdcf(A,B,pU,pV)    int A, B, *pU, *pV;
	C = igcdcf( A, B, pU, pV );
	C ist der groesste gemeinsame Teiler von A und B.
	Berechnet werden *pU und *pV mit
	*pU = A / C und *pV = B / C.



			igkapt( n, msg )

	"integer Goldwasser Kilian Atkin primality test" (rekursiv)
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single igkapt(n, msg)  int n; single msg;
	erg = igkapt(n, msg);
        Es muss gelten: n > 0.
	Ist erg =  1, so ist n Primzahl.
	Ist erg =  0, so ist n keine Primzahl.
	Ist erg = -1, so konnte nicht entschieden werden, ob n prim
		      ist oder nicht. n ist mit grosser Wahrschein-
		      lichkeit prim.
	Ist msg  = 0, so werden keine Meldungen auf stdout ausgegeben.
	Ist msg != 0, so werden Meldungen auf stdout ausgegeben, falls
	n > 2^30 ist.
	Die ausgegebenen Meldungen bedeuten folgendes:
	-  2274719854621 is pseudoprime:
	   2274719854621 hat mehrere Miller-Rabin Pseudoprimzahl-
	   tests bestanden, und es wird nun versucht, die
	   Primalitaet von 2274719854621 zu beweisen.
	-  2274719854621 is prime (p-1):
	   2274719854621 ist Primzahl. Dies wurde gezeigt mit Hilfe
	   der Faktorisierung von 2274719854621-1.
	-  2274719854621 is prime (p+1):
	   2274719854621 ist Primzahl. Dies wurde gezeigt mit Hilfe
	   der Faktorisierung von 2274719854621+1.
	-  6220506277488749 is prime, h(-15) = 2:
	   6220506277488749 ist Primzahl. Dies wurde gezeigt unter
	   Zuhilfenahme der Faktorisierung der Punktordnung einer
	   elliptischen Kurve ueber Z/nZ, die komplexe Multiplikation
	   hat und deren Endomorphismenring eine Ordnung im imaginaer-
	   quadratischen Zahlkoerper Q(sqrt(-15)) ist. Die Ideal-
	   klassenzahl dieses Zahlkoerpers ist h(-15) = 2.
	-  135892632733466791644089: no conclusion (too few discriminants):
	   Es gelang nicht, zu entscheiden, ob die angegebene Zahl
	   Primzahl ist oder nicht.
	-  155221024733 is NOT prime:
	   Die Zahl bestand mehrere Pseudoprimtests. Es stellte sich
	   jedoch spaeter heraus, dass sie nicht prim ist.
	Die Grundlage fuer igkapt bildet folgender Artikel:
		Implementation of the
		Goldwasser-Kilian-Atkin
		primality testing algorithm
	Francois Morain
	University of Limoges
	INRIA
	July 1st, 1988



			ihegcd( A, B, pV )

	"integer half extended greatest common divisor"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int ihegcd(A,B,pV)  int A, B, *pV;
	C = ihegcd( A, B, pV );
	C ist der groesste gemeinsame Teiler von A und B.
	Berechnet wird *pV: wobei *pV das Signum von B ist, falls A = 0,
	oder *pV * B - C ist Vielfaches von A, mit |*pV| <= |A|/2*C sonst.



			ijacsym( A, B )

	"integer Jacobi-symbol"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ijacsym( A , B )  int A,B;
	n = ijacsym( A , B );
	B ist eine ungerade, positive Zahl und ggT( A , B ) = 1.
	n ist das Jacobi-Symbol ( A / B ).
	Ist B = 1, so ist n = 1.



			ijacsym_lo( A, B )

	"integer Jacobi-symbol ( lists only )"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ijacsym_lo( A , B )  int A,B;
	n = ijacsym_lo( A , B );
	B ist eine ungerade, positive Zahl und ggT( A , B ) = 1.
	n ist das Jacobi-Symbol ( A / B ).
	Ist B = 1, so ist n = 1.
	Es wird nur innerhalb der SIMATH-Speicherverwaltung
	(also nur mit Listen) gearbeitet.



			ilcm( A, B )

	"integer least common multiple"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int ilcm(A,B)   int A, B;
	C = ilcm( A, B );
	C ist das kleinste gemeinsame Vielfache von A und B.



			ilcomb( A, B, m, n )

	"integer linear combination"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int ilcomb(A,B,m,n)    int A, B; single m, n;
	C = ilcomb( A, B, m, n );
	A, B, m, n, so dass A*m + B*n >= 0.
	C = A*m + B*n.



			ilkprime(  )

	"integer largest known prime"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int ilkprime()
	P = ilkprime();
	P ist die zur Zeit (Stand: 07.10.1992) groesste 
	bekannte Primzahl.



			ilog10( n )

	"integer logarithm, base 10"
	Quellbibliothek: srclib.arith1
	Include-Datei:	 _arith1.h
	single ilog10 (n)  int n;
	l = ilog10 (n);
	l ist 0, falls n gleich 0.
	Sonst ist l der um 1 vermehrte ganzzahlige Anteil von log10 (|n|),
	also die Anzahl der Dezimalstellen von n.



			ilog2( A )

	"integer logarithm, base 2"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ilog2(A)   int A;
	n = ilog2( A );
	n ist 0, falls A gleich 0.
	Sonst ist n der um 1 vermehrte ganzzahlige Anteil von log2(|A|).



			ilpds( N, A, B, pP, pN1 )

	"integer large prime divisor search"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int ilpds(N,A,B,pP,pN1)  int N,A,B,*pP,*pN1;
	P = ilpds(N,A,B,pP,pN1);
	Es muss gelten : N hat keinen Primteiler < 17.
			 2 <= A <= B <= N.
			 B <= isqrt(N).
			 A * B < N.
	Falls N mindestens einen Teiler in [A,B] hat, ist *pP der kleinste
	solche, und *pN1 ist N / *pP. Andernfalls ist *pP = 1 und *pN1 = N.
	P hat denselben Wert wie *pP.



			imax( A, B )                    (MACRO)

	"integer maximum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int imax(A,B)  int A,B;
	C = imax(A,B);
	C ist das Maximum von A und B.



			imin( A, B )                    (MACRO)

	"integer minimum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int imin(A,B)  int A,B;
	C = imin(A,B);
	C ist das Minimum von A und B.



			imp2d( A )

	"integer maximal power of 2 divisibility"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single imp2d( A )   int A;
	n = imp2d( A );
	n ist der maximale Exponent derart, dass 2^n | A.
	n = BASIS - 1 , falls A = 0 ist.



			impds( N, A, B, pP, pQ )

	"integer medium prime divisor search"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int impds(N,A,B,pP,pQ)  int N,A,B,*pP,*pQ;
	P = impds(N,A,B,pP,pQ);
	Es muss gelten : 2 <= A <= B <= N.
	Falls N einen Primteiler >= 13 in [A,B] und keinen Teiler
	in [13,A[ hat, ist *pP der kleinste Primteiler in [A,B].
	Besitzt N keinen Primteiler in [13,B], ist *pP = 1. 
	Ansonsten ist *pP irgendein Teiler (ggf. wieder *pP = 1).
        *pQ = N / *pP.
	P hat denselben Wert wie *pP.



			imspds( N, a, b )

	"integer medium single prime divisor search"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single imspds( N, a, b )  int N, a, b;
	p = imspds( N, a, b );
	Es muss gelten : 2 <= a <= b <= N
	Falls N einen Primteiler >= 13 in [a,b] und keinen Teiler
	in [13,a[ hat, ist p der kleinste Primteiler in [a,b].
	Besitzt N keinen Primteiler in [13,b], ist p = 1. 
	Ansonsten ist p irgendein Teiler (ggf. wieder p = 1).



			inearesttor( r )

	"integer nearest to rational number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int inearesttor(r)  rat r;
	A = itor(r);
	A ist die ganze Zahl, die den geringsten Abstand zur
	rationalen Zahl r hat. Sollte diese Zahl nicht eindeutig
	bestimmt sein, so ist A die betragsmaessig kleinere Zahl
	der beiden Zahlen, die in diesem Fall moeglich waeren. 



			ineg( A )

	"integer negation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int ineg(A)   int A;
	B = ineg( A );
	B = -A.



			infepptfact( F, p, Q, ppot, a0, z )

	"integral number field element p-primality test and factorization
	of the defining polynomial or the minimal polynomial"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol infepptfact(F,p,Q,ppot,a0,z)  pol F,a0,z; single p; int Q,ppot;
	M = infepptfact(F,p,Q,ppot,a0,z);
	F ist das definierende Polynom einer separablen Algebra ueber den 
	rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
        in einer Veraenderlichen ueber den ganzen Zahlen.
        Die Algebra entstehe durch Adjunktion eines separablen Elementes
	an die rationalen Zahlen; dieses Element sei mit u bezeichnet.
	p ist eine single Primzahl und ppot eine Potenz von p (s.u.).
	Q ist ebenfalls eine p - Potenz; das Produkt von Q und einem
        beliebigen Element einer p - maximalen Ueberordnung der Polynom-
        ordnung von F liegt in der Polynomordnung.
	z ist ein ganzes Element dieser Algebra, a0 ist ein p - primaeres
	ganzes Element dieser Algebra; beide werden repraesentiert durch
	CD - Polynome ( siehe cdprfcl ).
	Falls z p - primaer ist, d.h. das Minimalpolynom von z modulo p
	keine voneinander verschiedenen irreduziblen Faktoren hat, dann 
        ist M eine Liste aus zwei Elementen M = ( mp, pzet ), wobei mp 
	dieser eindeutig bestimmte irreduzible Faktor ist, also ein 
	Polynom in einer Veraenderlichen ueber Z/pZ.     
	pzet ist ein ganzes Element dieser Algebra und wird durch ein 
	CD - Polynom repraesentiert; das Minimalpolynom von pzet hat den
	gleichen Grad wie das definierende Polynom F.
	pzet ist modulo ( ppot * Z[x] ) kongruent zu z + ppot * a0 * m,  
	wobei m eine nicht negative ganze Zahl ist.
	Ist z nicht p - primaer, so ist M eine Liste aus vier Elementen
	M = (0, pzet, Lfac, Lort).
	pzet s.o.
        Lort = (e1,e2) besteht aus zwei CD - Polynomen ueber den 
        rationalen Zahlen, die Elemente der Algebra repraesentieren, 
        fuer die gilt:
	e1 * e2 = 0 modulo Q^2 * Z[u];
	e1 + e2 = 1 modulo Q^2 * Z[u];
	e1 und e2 sind modulo Q^2 * Z[u] idempotent.
	Lfac = (f1,f2) besteht aus zwei Polynomen in einer Veraender -
	lichen ueber den ganzen Zahlen. Dabei sind f1 und f2 zusaetzlich
	normiert und es gilt: F = f1 * f2 modulo Q^2.
	( Siehe dazu Construction of Maximal Orders over a Dedekind Domain,
	  von D.J. Ford p. 7-8 in Journal of Symbolic Computation 1985;
	  sowie Diplomarbeit von R. Boeffgen p.80/103 . )



			infepptfip( F, p, Q, ppot, a0, z )

	"integral number field element p-primality test and factorization
	of the defining polynomial or the minimal polynomial with respect
	to integer primes"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol infepptfip(F,p,Q,ppot,a0,z)  pol F,a0,z; int p,Q,ppot;
	M = infepptfip(F,p,Q,ppot,a0,z);
	F ist das definierende Polynom einer separablen Algebra ueber den 
	rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
        in einer Veraenderlichen ueber den ganzen Zahlen.
        Die Algebra entstehe durch Adjunktion eines separablen Elementes
	an die rationalen Zahlen; dieses Element sei mit u bezeichnet.
	p ist eine Primzahl und ppot eine Potenz von p (s.u.).
	Q ist ebenfalls eine p - Potenz; das Produkt von Q und einem
        beliebigen Element einer p - maximalen Ueberordnung der Polynom-
        ordnung von F liegt in der Polynomordnung.
	z ist ein ganzes Element dieser Algebra, a0 ist ein p - primaeres
	ganzes Element dieser Algebra; beide werden repraesentiert durch
	CD - Polynome ( siehe cdprfcl ).
	Falls z p - primaer ist, d.h. das Minimalpolynom von z modulo p
	keine voneinander verschiedenen irreduziblen Faktoren hat, dann 
        ist M eine Liste aus zwei Elementen M = ( mp, pzet ), wobei mp 
	dieser eindeutig bestimmte irreduzible Faktor ist, also ein 
	Polynom in einer Veraenderlichen ueber Z/pZ.     
	pzet ist ein ganzes Element dieser Algebra und wird durch ein 
	CD - Polynom repraesentiert; das Minimalpolynom von pzet hat den
	gleichen Grad wie das definierende Polynom F.
	pzet ist modulo ( ppot * Z[x] ) kongruent zu z + ppot * a0 * m,  
	wobei m eine nicht negative ganze Zahl ist.
	Ist z nicht p - primaer, so ist M eine Liste aus vier Elementen
	M = (0, pzet, Lfac, Lort).
	pzet s.o.
        Lort = (e1,e2) besteht aus zwei CD - Polynomen ueber den 
        rationalen Zahlen, die Elemente der Algebra repraesentieren, 
        fuer die gilt:
	e1 * e2 = 0 modulo Q^2 * Z[u];
	e1 + e2 = 1 modulo Q^2 * Z[u];
	e1 und e2 sind modulo Q^2 * Z[u] idempotent.
	Lfac = (f1,f2) besteht aus zwei Polynomen in einer Veraender -
	lichen ueber den ganzen Zahlen. Dabei sind f1 und f2 zusaetzlich
	normiert und es gilt: F = f1 * f2 modulo Q^2.
	( Siehe dazu Construction of Maximal Orders over a Dedekind Domain,
	  von D.J. Ford p. 7-8 in Journal of Symbolic Computation 1985;
	  sowie Diplomarbeit von R. Boeffgen p.80/103 . )



			infepstarval( p, A )

	"integral number field element p-star valuation"
	Quellbibliothek : srclib.arith2
	Include - Datei : _arith2.h
	rat infepstarval(p,A) single p; pol A;
	v = infepstarval(p,A);
	p ist eine single Primzahl, A ist ungleich dem Nullpolynom und
	ist das Minimalpolynom einer ganzen algebraischen Zahl I einer
	separablen Algebra ueber den rationalen Zahlen, d.h
	A ist ein normiertes Polynom in einer Veraenderlichen ueber Z.
	v ist der Wert der p - star Bewertung des Elementes I.
	(Da sich der p - star Wert aus dem Minimalpolynom berechnet, muss
	das Element I nicht angegeben sein.)
	Zur Definition der p - star Bewertung siehe Diplomarbeit von
	R. Boeffgen p. 8-9 bzw. Dissertation von D.J. Ford p. 38-39.



			infepstarvip( P, A )

	"integral number field element p-star valuation with respect
	to integer primes"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	rat infepstarvip(P,A)  int P; pol A;
	v = infepstarvip(P,A);
	P ist eine Primzahl.
	A ist ungleich dem Nullpolynom und ist das Minimalpolynom
	einer ganzen algebraischen Zahl I einer separablen Algebra
	ueber den rationalen Zahlen, d.h
	A ist ein normiertes Polynom in einer Veraenderlichen ueber Z.
	v ist der Wert der P - star Bewertung des Elementes I.
	(Da sich der P - star Wert aus dem Minimalpolynom berechnet, muss
	das Element I nicht angegeben sein.)
	Zur Definition der P - star Bewertung siehe Diplomarbeit von
	R. Boeffgen p. 8-9 bzw. Dissertation von D.J. Ford p. 38-39.



			intpp( p, m )

	"integer p-part"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int intpp( p,m )  single p; int m;
	n = intpp( p,m );
	Es muss gelten: p ist Primzahl.
		m ist ungleich Null.
	n ist die groesste p-Potenz, die m teilt, d.h. n = p^wp(m).



			intppint( P, A )

	"integer P-part with respect to an integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int intppint(P,A)  int P,A;
	N = intppint(P,A);
	P ist eine positive ganze Zahl groesser als 1.
	A ist eine von Null verschiedene ganze Zahl.
	N ist die groesste P-Potenz, die A teilt.



			iodd( A )                       (MACRO)

	"integer odd"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single iodd(A) int A;
	n = iodd(A);
	n ist 1, falls A ungerade ist
	  und 0, falls A gerade ist.



			ip2prod( A, n )

	"integer power of 2 product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int ip2prod(A,n)  int A; single n;
	B = ip2prod( A, n );
	n >= 0.
	B = A * 2^n.



			ip2quot( A, n )

	"integer power of 2 quotient"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int ip2quot(A,n)  int A; single n;
	B = ip2quot( A, n );
	n >= 0.
	B ist der ganzzahlige Anteil von A / 2^n.



			ipgen( u, o )

	"integer prime generator"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list ipgen(u,o)  int u,o;
	L = ipgen(u,o);
	Es muss gelten : 0 < u <= o.
	L = (p1,...,pr) mit p1<...<pr ist die Liste aller Primzahlen p
	mit u <= p <= o.



			iphi( N )

	"integer eulerian phi-value"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iphi(N)  int N;
	M = iphi(N);
	Es muss gelten : N > 0.
	M ist der Wert der Eulerschen phi-Funktion an der Stelle N.
	Benoetigt wird die Include-Datei <_arith1.h>.
	VORSICHT !!!  Die Zahl N wird faktorisiert. Bei grossen Zahlen
        kann es daher zu langen Laufzeiten kommen.



			ipjacsym( a, p )

	"integer prime Jacobi-symbol ( Legendre-symbol )"
 	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ipjacsym (a,p)  int a,p;
	n = ipjacsym (a,p);
        1 <= p sollte Primzahl sein.
	Berechnet wird das Jacobi-Symbol n = (a|p) fuer primes p.
	Ist a mod p = 0, so ist n = 0.
!!!	Fuer spezielle Anwendungen ist n = -2, falls erkannt wird, dass
	p nicht prim ist. Man kann ipjacsym also als einfachen Pseudoprim-
	test verwenden: Man berechnet n = (a|p) fuer mehrere, zufaellige
	a. Ist mindestens einmal n = -2, so ist p nicht prim. Ist immer
	n != -2, so ist p wahrscheinlich prim.



			ippnfecalip( F, P, Q, mp )

	"integral P-primary number field element, core algorithm with
	respect to integer primes"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list ippnfecalip(F,P,Q,mp)  pol F; int P,Q; pol mp;
	M = ippnfecalip(F,P,Q,mp);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
	in einer Veraenderlichen ueber den ganzen Zahlen.
	P ist eine Primzahl und Q eine P - Potenz.
	Das Produkt von Q mit einem beliebigen Element einer P - maximalen
	Ueberordnung der Polynomordnung von F liegt in der Polynomordnung.
	Die Unbestimmte von F heisse x.
	Dann muss u = x mod (F) P - primaer sein.
	mp ist das P - Minimalpolynom von u, d.h. der modulo P eindeutig
	bestimmte Primpolynomteiler des Minimalpolynoms von u.
	Nun ist entweder M eine Liste, die nur aus einem einzigen Element
	besteht. Dieses Element ist eine CD - Matrix, deren Zeilen jeweils
	als "coefficient list" CD - Polynomen entsprechen;
	die CD - Polynome wiederrum repraesentieren Elemente obiger Algebra
	( siehe cdprfcl und cdmarid ), so dass die Elemente der Algebra
	eine Ganzheitsbasis der P - maximalen Ueberordnung der 
	Polynomordnung von F darstellen;
	oder M ist eine Liste aus zwei Listen ( Lfac, Lort );	    	 	   
	Lfac = ( f1, f2 ) besteht aus zwei normierten Polynomen in einer
	Veraenderlichen ueber den ganzen Zahlen und
	Lort = ( e1, e2 ) besteht aus zwei CD - Polynomen ueber den
	rationalen Zahlen, die Elemente der Algebra repraesentieren,
	und es gilt:
	F = f1 * f2 mod (Q^2);
	e1 + e2 = 1 mod Q^2 * Z[u];
	e1 * e2 = 0 mod Q^2 * Z[u];
	e1 und e2 sind modulo Q^2 * Z[u] idempotent.
	( siehe dazu auch Diplomarbeit von R.Boeffgen p.72 bzw
	  Dissertation von D.J.Ford p.45-49 ).



			ippnfecoreal( F, p, Q, mp )

	"integral p-primary number field element, core algorithm"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list ippnfecoreal(F,p,Q,mp)  pol F; single p; int Q; pol mp;
	M = ippnfecoreal(F,p,Q,mp);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
	in einer Veraenderlichen ueber den ganzen Zahlen.
	p ist eine single Primzahl und Q eine p - Potenz.
	Das Produkt von Q mit einem beliebigen Element einer p - maximalen
	Ueberordnung der Polynomordnung von F liegt in der Polynomordnung.
	Die Unbestimmte von F heisse x.
	Dann muss u = x mod (F) p - primaer sein.
	mp ist das p - Minimalpolynom von u, d.h. der modulo p eindeutig
	bestimmte Primpolynomteiler des Minimalpolynoms von u.
	Nun ist entweder M eine Liste, die nur aus einem einzigen Element
	besteht. Dieses Element ist eine CD - Matrix, deren Zeilen jeweils
	als "coefficient list" CD - Polynomen entsprechen;
	die CD - Polynome wiederrum repraesentieren Elemente obiger Algebra
	( siehe cdprfcl und cdmarid ), so dass die Elemente der Algebra
	eine Ganzheitsbasis der p - maximalen Ueberordnung der 
	Polynomordnung von F darstellen;
	oder M ist eine Liste aus zwei Listen ( Lfac, Lort );	    	 	   
	Lfac = ( f1, f2 ) besteht aus zwei normierten Polynomen in einer
	Veraenderlichen ueber den ganzen Zahlen und
	Lort = ( e1, e2 ) besteht aus zwei CD - Polynomen ueber den
	rationalen Zahlen, die Elemente der Algebra repraesentieren,
	und es gilt:
	F = f1 * f2 mod (Q^2);
	e1 + e2 = 1 mod Q^2 * Z[u];
	e1 * e2 = 0 mod Q^2 * Z[u];
	e1 und e2 sind modulo Q^2 * Z[u] idempotent.
	( siehe dazu auch Diplomarbeit von R.Boeffgen p.72 bzw
	  Dissertation von D.J.Ford p.45-49 ).



			ippnfeidpval( F, p, a0, a2, wa, b2, wb, py, pwy )

	"integral p-primary number field element, increasing the
	denominator of the p-star value"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol ippnfeidpval(F,p,a0,a2,wa,b2,wb,py,pwy)  pol F; single p;
		    pol a0,a2,b2; single wa,wb; pol *py; single *pwy;
	a = ippnfeidpval(F,p,a0,a2,wa,b2,wb,py,pwy);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom 
        in einer Veraenderlichen ueber den ganzen Zahlen. 
        p ist eine single Primzahl.
	a0, a2 und b2 sind p - primaere ganze Elemente dieser Algebra und 
	werden durch CD - Polynome repraesentiert ( siehe cdprfcl ).
	a2 entsteht aus a0 durch die in ippnferegul angewandte Methode
	( Bezeichnungen dort: a0 und *pa2 ).
	wa und wb sind positive singles, wb teilt nicht wa und es gilt:
	(v_p)* (a2) = 1 / wa   und  (v_p)* (b2) = 1 / wb.
	*py ist ein p - primaeres ganzes Element der Algebra, dessen (v_p)*
	Wert gleich 1 / *pwy ist; *pwy ist gleich kgV(wa,wb).
	a ist ein p - primaeres ganzes Element der Algebra.
	a und *py sind durch CD - Polynome repraesentiert.
	Sei m der modulo p eindeutig bestimmte irreduzible Faktor des
	Minimalpolynoms von a, dann gilt: (v_p)* ( m(a) ) = 1 / kgV(wa,wb).



			ippnfeidpvip( F, p, a0, a2, wa, b2, wb, py, pwy )

	"integral p-primary number field element, increasing the
	denominator of the p-star value with respect to integer primes"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol ippnfeidpvip(F,p,a0,a2,wa,b2,wb,py,pwy)  pol F; int p;
		 pol a0,a2,b2; single wa,wb; pol *py; single *pwy;
	a = ippnfeidpvip(F,p,a0,a2,wa,b2,wb,py,pwy);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom 
        in einer Veraenderlichen ueber den ganzen Zahlen. 
        p ist eine Primzahl.
	a0, a2 und b2 sind p - primaere ganze Elemente dieser Algebra und 
	werden durch CD - Polynome repraesentiert ( siehe cdprfcl ).
	a2 entsteht aus a0 durch die in ippnferegul angewandte Methode
	( Bezeichnungen dort: a0 und *pa2 ).
	wa und wb sind positive singles, wb teilt nicht wa und es gilt:
	(v_p)* (a2) = 1 / wa   und  (v_p)* (b2) = 1 / wb.
	*py ist ein p - primaeres ganzes Element der Algebra, dessen (v_p)*
	Wert gleich 1 / *pwy ist; *pwy ist gleich kgV(wa,wb).
	a ist ein p - primaeres ganzes Element der Algebra.
	a und *py sind durch CD - Polynome repraesentiert.
	Sei m der modulo p eindeutig bestimmte irreduzible Faktor des
	Minimalpolynoms von a, dann gilt: (v_p)* ( m(a) ) = 1 / kgV(wa,wb).



			ippnferegip( F, p, Q, a0, mpa0, pa1, pa2 )

	"integral p-primary number field element regulation with respect
	to integer primes"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	rat ippnferegip(F,p,Q,a0,mpa0,pa1,pa2)  pol F; int p,Q;
				      pol a0,mpa0; pol *pa1,*pa2;
	v = ippnferegip(F,p,Q,a0,mpa0,pa1,pa2);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
        in einer Veraenderlichen ueber den ganzen Zahlen.
	p ist eine Primzahl und Q eine p - Potenz.
	Das Produkt von Q mit einem beliebigen Element einer p - maximalen
	Ueberordnung der Polynomordnung von F liegt in der Polynomordnung.
	a0 ist ein p - primaeres ganzes Element dieser Algebra und wird
	durch ein CD - Polynom repraesentiert ( siehe cdprfcl ).
	Das Minimalpolynom von a0 hat den gleichen Grad wie F.
	mpa0 ist der modulo p eindeutig bestimmte Primpolynomteiler des
	Minimalpolynoms von a0 ueber den ganzen Zahlen, also ein normiertes
	irreduzibles Polynom in einer Veraenderlichen ueber Z/pZ.
	Der Grad von mpa0 muss kleiner sein als der Grad von F.
	*pa1 und *pa2 sind ganze Elemente der Algebra und werden durch
	CD - Polynome repraesentiert.
	*pa1 entsteht durch Einsetzen von a0 in mpa0.
	v ist der p - star Wert von *pa1 ( siehe infepstarval ).
        v ist eine rationale Zahl und nach Konstruktion groesser als Null.
	Sei v1 der Nenner von v, dann hat *pa2 den p - star Wert 1 / v1.
	( Siehe auch Diplomarbeit R.Boeffgen p.60 und Dissertation von
	  D.J Ford pp.45-46 ). 



			ippnferegul1( F, p, Q, a0, mpa0, pa1, pa2 )

	"integral p-primary number field element regulation, version1"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	rat ippnferegul1(F,p,Q,a0,mpa0,pa1,pa2)   pol F; single p; int Q;
				              pol a0,mpa0; pol *pa1,*pa2;
	v = ippnferegul1(F,p,Q,a0,mpa0,pa1,pa2);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
        in einer Veraenderlichen ueber den ganzen Zahlen.
	p ist eine single Primzahl und Q eine p - Potenz.
	Das Produkt von Q mit einem beliebigen Element einer p - maximalen
	Ueberordnung der Polynomordnung von F liegt in der Polynomordnung.
	a0 ist ein p - primaeres ganzes Element dieser Algebra und wird
	durch ein CD - Polynom repraesentiert ( siehe cdprfcl ).
	Das Minimalpolynom von a0 hat den gleichen Grad wie F.
	mpa0 ist der modulo p eindeutig bestimmte Primpolynomteiler des
	Minimalpolynoms von a0 ueber den ganzen Zahlen, also ein normiertes
	irreduzibles Polynom in einer Veraenderlichen ueber Z/pZ.
	Der Grad von mpa0 muss kleiner sein als der Grad von F.
	*pa1 und *pa2 sind ganze Elemente der Algebra und werden durch
	CD - Polynome repraesentiert.
	*pa1 entsteht durch Einsetzen von a0 in mpa0.
	v ist der p - star Wert von *pa1 ( siehe infepstarval ).
        v ist eine rationale Zahl und nach Konstruktion groesser als Null.
	Sei v1 der Nenner von v, dann hat *pa2 den p - star Wert 1 / v1.
	( Siehe auch Diplomarbeit R.Boeffgen p.60 und Dissertation von
	  D.J Ford pp.45-46 ). 
	Im Unterschied zu ippnferegul2 arbeitet Version1 mit nfespecmpc1
	d.h. das Minimalpolynom wird auf jeden Fall exakt nach Collins 
	berechnet.



			ippnferegul2( F, p, Q, a0, mpa0, pa1, pa2 )

	"integral p-primary number field element regulation, version2"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	rat ippnferegul2(F,p,Q,a0,mpa0,pa1,pa2)   pol F; single p; int Q;
				              pol a0,mpa0; pol *pa1,*pa2;
	v = ippnferegul2(F,p,Q,a0,mpa0,pa1,pa2);              
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
        in einer Veraenderlichen ueber den ganzen Zahlen.
	p ist eine single Primzahl und Q eine p - Potenz.
	Das Produkt von Q mit einem beliebigen Element einer p - maximalen
	Ueberordnung der Polynomordnung von F liegt in der Polynomordnung.
	a0 ist ein p - primaeres ganzes Element dieser Algebra und wird
	durch ein CD - Polynom repraesentiert ( siehe cdprfcl ).
	Das Minimalpolynom von a0 hat den gleichen Grad wie F.
	mpa0 ist der modulo p eindeutig bestimmte Primpolynomteiler des
	Minimalpolynoms von a0 ueber den ganzen Zahlen, also ein normiertes
	irreduzibles Polynom in einer Veraenderlichen ueber Z/pZ.
	Der Grad von mpa0 muss kleiner sein als der Grad von F.
	*pa1 und *pa2 sind ganze Elemente der Algebra und werden durch
	CD - Polynome repraesentiert.
	*pa1 entsteht durch Einsetzen von a0 in mpa0.
	v ist der p - star Wert von *pa1 ( siehe infepstarval ).
        v ist eine rationale Zahl und nach Konstruktion groesser als Null.
	Sei v1 der Nenner von v, dann hat *pa2 den p - star Wert 1 / v1.
	( Siehe auch Diplomarbeit R.Boeffgen p.60 und Dissertation von
	  D.J Ford pp.45-46 ). 
	Im Unterschied zu ippnferegul1 arbeitet Version2 mit nfespecmpc2
	und infeminpmpp, d.h. das Minimalpolynom wird eventuell nur
	modulo einer gewissen p - Potenz bestimmt ( siehe nfespecmpc2 ).



			iprimeconstr( bits, f, pL, n )

	"integer prime construction"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iprimeconstr(bits, f, pL, n)  single bits, (*f)(), n; list *pL;
	p = iprimeconstr(bits, f, pL, n);
	bits ist >= 0.
	f ist eine parameterlose Funktion mit Werten in N.
	Sinnvoll ist die Wahl einer (Pseudo-) Zufallsfunktion fuer f,
	etwa f = rand.
	Es gilt:
	- p ist Primzahl
	- p > 2^bits
	- Ist n = 1, so hat p-1 einen Primfaktor in der Groessenordnung 
	  von p.
	- Ist n = 2, so hat p-1 zwei Primfaktoren in der Groessenordnung 
          von sqrt(p).
	- Ist n = 0, so hat p-1 nur Primfaktoren < M, und es ist
          p < M * 2^bits. Dabei ist M = Min{1000, (Max(f)+1)-te Primzahl}.
	- *pL ist aufsteigend geordnete Liste der Primfaktoren von p-1.



			iprniqf( p, D )

	"integer prime representation as a norm in an imaginary quadratic 
	 field"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list iprniqf(p, D)  int p,D;
	Pi = iprniqf(p, D);
        Es muss gelten:
	p > 2 sollte Primzahl sein.
	D < 0 ist Diskriminante des imaginaer-quadratischen Zahlkoerpers K.    
	Es wird versucht, p als Norm eines Elementes pi aus dem Ganzheits-
	ring O(K) von K darzustellen, d.h. p = Norm_K (pi).
	Pi = ( pi1, pi2, ... ) ist die Liste aller Loesungen bis auf Kon-
	jugierte ueber C.
	Ausnahme: Ist Pi = 0, so wurde erkannt, dass p keine Primzahl ist.
	Ein Element pi aus O(K) ist hierbei
	pi = (A,B) = A + B*w mit
	w =    sqrt(D) /2, falls D = 0 mod 4,
	w = (1+sqrt(D))/2, falls D = 1 mod 4.



			iprod( A, B )

	"integer product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iprod(A,B)  int A, B;
	C = iprod( A, B );
	C = A * B.



			iprod_lo( A, B )

	"integer product, lists only"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iprod_lo( A, B )  int A, B;
	C = iprod_lo( A, B );
	C = A * B.
	Es wird nur innerhalb der SIMATH-Speicherverwaltung 
	gearbeitet, d.h. ohne Essener Arithmetik.



			iprpdbqf( D, h1, h2 )

	"integer primitive reduced positive definite binary
	 quadratic forms"
	Quellbibliothek: srclib.arith1	
	Include-Datei:	 _arith1.h
	list iprpdbqf (D,h1,h2)  int D; single h1,h2;
	L = iprpdbqf (D,h1,h2);
	Es muss gelten:	D<0
	L ist Liste von primitiven, reduzierten, positiv-definiten,
	binaeren quadratischen Formen der Diskriminante D.
	Sei h die Anzahl dieser Formen.
	Ist h<h1 oder h>h2 oder D = 2,3 mod 4, dann ist L = ().
	h2 = 0 wird als unendlich interpretiert.
	Ansonsten ist L = (L1,L2). Ist die Form (a,b,c)	in der 
	Liste L2 enthalten, so ist (a,-b,c) ebenfalls reduziert.
	Fuer alle Formen (a,b,c) in L1 und L2 gilt a,b,c >= 0.
	Es ist also h = #L1 + 2 * #L2.



			iqnfdif( D, a, b )              (MACRO)

	"integer, quadratic number field element, difference"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel iqnfdif( D, a, b )  int D, a; nfel b;
	c = iqnfdif( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist aus Z,
	b ist ein Element aus Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a - b, die Differenz von a und b (als Zahlkoerperelemente).



			iqnfquot( D, a, b )

	"integer, quadratic number field element, quotient"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel iqnfquot( D, a, b )  int D, a; nfel b;
	c = iqnfquot( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist aus Z,
        b ist ein Element aus Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = ERROR, falls b = 0,
	    a/b, der Quotient von a und b als Zahlkoerperelemente, sonst.



			iqrem( A, B, pQ, pR )

	"integer quotient and remainder"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iqrem( A, B, pQ, pR )  int A, B, *pQ, *pR;
	C = iqrem( A, B, pQ, pR );
	B ist ungleich Null.
	Berechnet werden *pQ als der ganzzahlige Anteil von A / B und
	*pR = A - (*pQ) * B.
	C hat den Wert 0.                



			iqrem_2( A, B, pQ, pR )

	"integer quotient and remainder, old version"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iqrem_2( A, B, pQ, pR )  int A, B, *pQ, *pR;
	C = iqrem_2( A, B, pQ, pR );
	B ist ungleich Null.
	Berechnet werden *pQ als der ganzzahlige Anteil von A / B und
	*pR = A - (*pQ) * B.
	C hat den Wert 0.     
	Es wird - im Gegensatz zu iqrem - kein Speicherplatz ausserhalb
	des SIMATH-Listensystems verwendet.



			iqrem_3( A, B, pQ, pR )

	"integer quotient and remainder special version 3"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h                        
	int iqrem_3( A, B, pQ, pR )  int A, B, *pQ, *pR;
	C = iqrem_3( A, B, pQ, pR );
	A und B duerfen keine singles sei, d.h. |A|, |B| >= BASIS.
	Berechnet werden *pQ als der ganzzahlige Anteil von A / B und
	*pR = A - (*pQ) * B.
	C hat den Wert 0.     
	Zur Ausfuehrung der Division wird in gewissen Faellen die 
	Heidelberger Arithmetik benutzt. 



			iqrem_lo( A, B, pQ, pR )

	"integer quotient and remainder, lists only"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iqrem_lo( A, B, pQ, pR )  int A, B, *pQ, *pR;
	C = iqrem_lo( A, B, pQ, pR );
	B ist ungleich Null.
	Berechnet werden *pQ als der ganzzahlige Anteil von A / B und
	*pR = A - (*pQ) * B.
	C hat den Wert 0.
	Es wird nur innerhalb der SIMATH-Speicherverwaltung 
	gearbeitet, d.h. ohne Essener Arithmetik.



			iquot( A, B )                   (MACRO)

	"integer quotient"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iquot(A,B)  int A,B;
	C = iquot(A,B);
	Es muss gelten : B ungleich 0.
	C ist der ganzzahlige Anteil von A / B.



			irand( G )

	"integer randomize"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int irand(G)  int G;
	Z = irand(G);
	G ist eine natuerliche Zahl.
	irand liefert eine ganze Zufallszahl Z mit 0 <= Z < G.



			irand_2( u )

	"integer randomize, alternative version"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int irand_2(u)  single u;
	Z = irand_2(u);   
	Es muss gelten: u > 0    
	Z ist eine zufaellige Zahl mit BASIS^(u-1) <= |Z| < BASIS^u. 
	Zur Erzeugung von Z wird ausschliesslich die C-Funktion rand()
	benutzt. Der Zufallszahlengenerator kann also mit der Funktion 
	srand(a) initialisiert werden, so dass die Ergebnisse, die
	irand_2 liefert, reproduzierbar sind.
	siehe auch: irand und die C-Funktionen rand, srand



			irandprime( a1, a2, n )

	"integer random prime"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	int irandprime(a1, a2, n)  int a1, a2; single n;
	p = irandprime (a1, a2, n);
	Es muss gelten: 0 < a1 < a2 und n >= 0.
	- Ist n = 0, so ist p ungerade Primzahl    mit a1 <= p <= a2.
	- Ist n > 0, so ist p ungerade ganze Zahl  mit a1 <= p <= a2.
	  Die Wahrscheinlichkeit, dass p nicht prim ist betraegt etwa 4^(-n).
	irandprime laeuft langsamer als iprimeconstr



			irds( n, G, p )

	"integer random divisor search" (rekursiv)
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list irds (n, G, p)  int n; single G, p;
	N = irds(n, G, p);	
        Es muss gelten:
		0 < n
		0 < p < 100
		0 < G <= n
	Dann ist:
	N = ( n1 , n2 , ... , nk )	mit n = n1 * n2 *...* nk.
	Mittels Pollards rho-Methode werden Faktoren ni von n gesucht.
	Die ni sind in der Regel weder prim noch geordnet.
	Die Wahrscheinlichkeit, dass ein Faktor der Groesse G gefunden
	wird, ist p Prozent. irds ist dazu geeignet, kleine Faktoren von
	n zu finden. Es ist also zweckmeassig, G << sqrt (n) zu waehlen.
	Ist T die Laufzeit von irds, so gilt etwa:
		T   ~ log (n) 
		T^2 ~ G
		T^2 ~ -log (1-p/100)



			irem( A, B )                    (MACRO)

	"integer remainder"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int irem(A,B)  int A,B;
	C = irem(A,B);
	Es muss gelten : B ungleich 0.
	C = A - Q*B, wobei Q der ganzzahlige Anteil von A / B ist.



			iroot( A, n, ps )

	"integer root"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int iroot(A,n,ps)   int A; single n, *ps;
	B = iroot( A, n, ps );
	n positiv, A groesser oder gleich Null.
	B ist der ganzzahlige Anteil der n-ten Wurzel aus A.
	Berechnet wird *ps als das Signum von A - B^n.



			irshift( A )

	"integer right shift"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int irshift(A)  int A;
	B = irshift( A );
	A >= 0.
	B = A/2.    
	(entspricht dem Befehl B = iquot( A, 2 ), ist 
	aber wesentlich schneller als dieser)
	siehe auch ip2prod, ip2quot, iquot.



			isbasilllred( bas )

	"is basis over the integers LLL - reduced ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isbasilllred(bas)  list bas;
	t = isbaslllred(bas);
	bas = ( b_1, ..., b_n) ist eine Liste der Laenge n ( n > 0 ),
	wobei jedes Listenelement von bas ebenfalls eine Liste ist,
	bestehend aus n rationalen Zahlen.
	Diese Listen repraesentieren n ueber den ganzen	Zahlen linear
	unabhaengige Vektoren aus Q^n.
	t > 0 , falls diese Basis ( bzgl. obiger Reihenfolge) nicht
		LLL - reduziert ist.
	t = 0 , sonst.
	Zum Begriff LLL - reduziert siehe Math.Ann. 261, 515-524 (1982).



			iscinball( z, r, eps )

	"is complex number in ball ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single iscinball(z, m, r)  complex z,m; floating r;
	erg = iscinball(z, m, r);
	erg = sign (r - |z - m|), d.h. erg gibt an, ob z im
	Kreis um m mit Radius r liegt; genauer:
	Komplexe Zahlen im Kreis liefern Wert 1,
	komplexe Zahlen auf dem Rand liefern 0,
	und komplexe Zahlen ausserhalb des Kreises liefern -1.



			isfloat( A )

	"is floating point ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single isfloat(A)  obj A;
	s = isfloat(A);
	s hat den Wert 1, falls A ein floating point ist,
		   und 0, sonst.



			isfp( A )

	"integer squarefree part"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int isfp(A)  int A;
	A1 = isfp(A);
	Fuer A = 0 ist A1 = 0.
	Sonst ist A1 der quadratfreie Anteil von A, d.h. A1 ist
	quadratfrei, und der Quotient A/A1 ist ein Quadrat.
	A1 hat das gleiche Vorzeichen wie A.



			isgf2el( G, a )                 (MACRO)

	"is Galois-field with characteristic 2 element ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isgf2el(G,a)  obj G, a;
	n = isgf2el(G,a);
	Voraussetzung:
	        G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden. 
	n = 1,  falls a als ein Element aus GF(2^n) interpretiert werden 
		kann, d.h. als Polynom in einer Variablen ueber Z/2Z vom 
		Grad < n in spezieller Bit-Notation. 
	    0, sonst.



			isgf2impsb( G )

	"is Galois-field with characteristic 2 irreducible and monic
	polynomial in special bit-representation ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isgf2impsb(G)  obj G;
	s = isgf2impsb(G);
	s = 1,  falls G als erzeugendes Polynom fuer einen endlichen
		Koerper der Charakteristik 2 interpretiert werden kann,
		d.h. als irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad >=1 in spezieller Bit-
	   	Darstellung (vgl. udpm2tosb).
	s = 0, sonst.



			isgfsal( p, AL )

	"is Galois-field with single characteristic arithmetic list ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isgfsal(p,AL)  single p; list AL;
	s = isgfsal(p,AL);
	Es muss gelten : p ist Primzahl.
	s = 1, falls AL = (G,AL1) als Arithmetikliste fuer GF(p^n)
	       interpretiert werden kann (siehe gfsalgen), wobei
	       n = llength(AL1) + 1,
	s = 0, sonst.



			isgfsel( p, AL, a )

	"is Galois-field with single characteristic element ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isgfsel(p,AL,a)  single p; list AL; obj a;
	n = isgfsel(p,AL,a);
	Es muss gelten : p ist Primzahl.
	       AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) inter-
	       pretiert werden (siehe gfsalgen), wobei n = llength(AL1)+1.
	n = 1, falls a Polynom vom Grad < n in einer Variable ueber Z/pZ
	       ist und somit als Element von GF(p^n) interpretiert werden
	       kann,
	    0, sonst.



			isgfsone( p, AL, a )

        "is Galois-field with single characteristic element one ?"
        Quellbibliothek: srclib.arith2
        Include-Datei:   _arith2.h
        single isgfsone(p,AL,a)  single p; list AL; gfel a;
        s = isgfsone(p,AL,a);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
	      - a ist ein Element aus GF(p^n), das als Polynom vom
		Grad < n in einer Variable ueber Z/pZ dargestellt
		ist.
        s=1, wenn a = 1,
        s=0, sonst.



			isign( A )

	"integer sign"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single isign(A)  int A;
	n = isign ( A );
	n ist das Vorzeichen von A.



			isint( A )

	"is integer ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single isint(A)  obj A;
	s = isint(A);
	s hat den Wert 1, falls A ein integer ist,
		   und 0, falls A kein integer ist.



			isipprime( n, a )

	"is integer pseudo prime ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single isipprime(n, a)  int n,a;
	erg = isipprime(n, a);	
        Es muss gelten: 0 < n.
			a ist aus Z/nZ.
	Ist n       pseudoprim zur Basis a, so ist erg = 1.
	Ist n nicht pseudoprim zur Basis a, so ist erg = 0.
	Fuehrt man isipprime fuer die Zahl n mit k verschiedenen
	Werten a1,...,ak durch, und ist mindestens einmal erg = 0,
	so ist n keine Primzahl. Ist immer erg = 1, so ist die
	Wahrscheinlichkeit, dass n nicht prim ist, kleiner 4^(-k).



			isiprime( n )

	"is integer prime ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isiprime(n)  int n;
	erg = isiprime(n);
        Es muss gelten: n > 0.
	Ist erg =  1, so ist n Primzahl.
	Ist erg =  0, so ist n keine Primzahl.
	Ist erg = -1, so konnte nicht entschieden werden, ob n prim
		      ist oder nicht. n ist mit grosser Wahrschein-
		      lichkeit prim.



			isiprimemsg( n )                (MACRO)

	"is integer prime, printing messages"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isiprimemsg(n)  int n;
	erg = isiprimemsg(n);
        Es muss gelten: n > 0.
	Ist erg =  1, so ist n Primzahl.
	Ist erg =  0, so ist n keine Primzahl.
	Ist erg = -1, so konnte nicht entschieden werden, ob n prim
		      ist oder nicht. n ist mit grosser Wahrschein-
		      lichkeit prim.
	Es werden Meldungen auf stdout ausgegeben, falls n > 2^30 ist.
	Die ausgegebenen Meldungen bedeuten folgendes:
	-  2274719854621 is pseudoprime
	   2274719854621 hat mehrere Miller-Rabin Pseudoprimzahl-
	   tests bestanden, und es wird nun versucht, die
	   Primalitaet von 2274719854621 zu beweisen.
	-  2274719854621 is prime (p-1)
	   2274719854621 ist Primzahl. Dies wurde gezeigt mit Hilfe
	   der Faktorisierung von 2274719854621-1.
	-  2274719854621 is prime (p+1):
	   2274719854621 ist Primzahl. Dies wurde gezeigt mit Hilfe
	   der Faktorisierung von 2274719854621+1.
	-  6220506277488749 is prime, h(-15) = 2
	   6220506277488749 ist Primzahl. Dies wurde gezeigt unter
	   Zuhilfenahme der Faktorisierung der Punktordnung einer
	   elliptischen Kurve ueber Z/nZ, die komplexe Multiplikation
	   hat und deren Endomorphismenring eine Ordnung im imaginaer-
	   quadratischen Zahlkoerper Q(sqrt(-15)) ist. Die Ideal-
	   klassenzahl dieses Zahlkoerpers ist h(-15) = 2.
	-  135892632733466791644089: no conclusion (too few discriminants)
	   Es gelang nicht, zu entscheiden, ob die angegebene Zahl
	   Primzahl ist oder nicht.
	-  155221024733 is NOT prime
	   Die Zahl bestand mehrere Pseudoprimtests. Es stellte sich
	   jedoch spaeter heraus, dass sie nicht prim ist.



			isispprime( n, k )

	"is integer strong pseudo prime ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:  _arith1.h
	single isispprime(n,k)  int n; single k;
	erg = isispprime(n,k);	
        Es muss gelten:
	n > 1
	k > 0
	Ist erg = 0, so ist n keine Primzahl.
	Ist erg = 1, so ist die Wahrscheinlichkeit, dass
	n nicht prim ist etwa 4^(-k).
	Siehe auch -> isiprime, issprime, isipprime



			isisqr( A )

	"is integer square ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single isisqr(A)  int A;
	n = isisqr( A );
	n ist  1, wenn A ein Quadrat ist;
	n ist  0, wenn A kein Quadrat ist;
	n ist -1, wenn A negativ ist.



			islistgf2( G, L )

	"is list of Galois-field with characteristic 2 elements ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single islistgf2(G,L)  obj G,L;
	s = islistgf2(G,L);
	Voraussetzung:
	        G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden. 
	s hat den Wert 1, falls L als eine Liste mit Elementen aus 
			  GF(2^n) interpretiert werden kann.
		   und 0, sonst.
	Die leere Liste liefert den Wert 1.



			islistgfs( p, AL, L )

	"is list of Galois-field with single characteristic elements ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single islistgfs(p,AL,L)  obj p,AL,L;
	s = islistgfs(p,AL,L);
	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 eine Liste mit
			  Elementen aus GF(p^n) ist.
		   und 0, sonst.
	Die leere Liste liefert den Wert 1, falls p und AL die geforderten
	Voraussetzungen erfuellen.



			islisti( L )

	"is list of integers ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single islisti (L)  obj L;
	n = islisti (L);	
	n = 1, falls L Liste von integers ist,
	n = 0, sonst.
	Die leere Liste liefert den Wert 1.



			islistmi( M, A )

	"is list of modular integers ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single islistmi(M,A)  obj M,A;
	s = islistmi(M,A);
	s hat den Wert 1, falls M positive ganze Zahl ist und
			  A Liste von Elementen aus Z / M*Z,
		   und 0, sonst.
	Die leere Liste liefert den Wert 1, falls M positive
	ganze Zahl ist.



			islistms( m, A )

	"is list of modular singles ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single islistms(m,A)  obj m,A;
	s = islistms(m,A);
	s hat den Wert 1, falls m positive single ist und A Liste von
			  Elementen aus Z/mZ,
		   und 0, sonst.
	Die leere Liste liefert den Wert 1, falls m positive single ist.



			islistnns( A )

	"is list of non negative singles ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single islistnns(A)  obj A;
	s = islistnns(A);
	s hat den Wert 	1, falls A eine Liste aus nicht negativen 
			   singles ist,
                   	0 sonst.
        Die leere Liste liefert den Wert 1.



			islists( A )

	"is list of singles ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single islists(A)  obj A;
	s = islists(A);
	s hat den Wert 1, falls A eine Liste aus singles ist,
		   und 0, falls A entweder keine Liste ist oder eine
			    Liste, die nicht nur aus singles besteht.
	Die leere Liste liefert Wert 1.



			ismi( m, a )

	"is modular integer ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ismi(m,a) obj m, a;
	n = ismi(m,a);
	n =  1, falls  0 < m und a aus Z/mZ;
	     0, sonst.



			ismifr( M, A, B )

	"is modular integer Fermat residue ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	int ismifr(M,A,B)  int M,A,B;
	S = ismifr(M,A,B);
	M ist eine positive ganze Zahl, A und B sind aus Z / M*Z.
        s = -1, falls B^2 - A kein Quadrat in Z / M*Z ist, sonst
	s = W mit 0 <= W < M, so dass W^2 = B^2 - A.



			ismisquare( M, A )

	"is modular integer square ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	int ismisquare(M,A)  int M,A;
	S = ismisquare(M,A);
	M ist eine positive ganze Zahl, A ist aus Z / M*Z.
        s = -1, falls A kein Quadrat in Z / M*Z ist, sonst
	s = W mit 0 <= W < M, so dass W^2 = A.



			ismiunit( M, A )

	"is modular integer unit"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ismiunit(M,A)  int M,A;
	s = ismiunit(M,A);
	M ist eine positive ganze Zahl. A ist ein Element aus Z / M*Z.
	s = 1, falls A eine Einheit in Z / M*Z ist, s = 0 sonst.



			isms( m, a )

	"is modular single ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single isms(m,a) obj m, a;
	n = isms(m,a);
	n =  1, falls  0 < m < BASIS und a aus Z/mZ;
	     0, sonst.



			isnf3eqnf3( F, P, pFD, pPD, pQ )

	"is number field of degree 3 equal to number field of degree 3"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel isnf3eqnf3(F,P,pFD,pPD,pQ)  pol F,P; int *pFD,*pPD,*pQ;
	Fel = isnf3eqnf3(F,P,pFD,pPD,pQ);
	Dabei muss gelten:
	      - F ist ein normiertes irreduzibles Polynom in einer
		Variablen ueber Z vom Grad 3 in dense-Darstellung,
		das den Zahlkoerper k erzeugt.
	      - P ist ein irreduzibles Polynom in einer Variablen
		ueber Z vom Grad 3 in dense-Darstellung.
	isnf3eqnf3 ueberprueft, ob die beiden Polynome F und P den
	gleichen Zahlkoerper k erzeugen.
	Fel ist die Darstellung von P bzgl. der von F erzeugten
	Koerperbasis, falls F und P den gleichen Zahlkoerper erzeu-
	gen; ansonsten ist Fel die leere Liste.
	Ausserdem gilt:
	      - *pFD ist die Polynomdiskriminante von F.
	      - *pPD ist die Polynomdiskriminante von P.
	      - *pQ ist der quadratische Faktor, um den sich *pFD
		und *pPD unterscheiden, falls F und P den gleichen
		Zahlkoerper erzeugen, d.h.: *pFD = *pQ * *pPD.
		*pQ = 0 sonst.
	!! ACHTUNG !!
	isnf3eqnf3 funktioniert nicht, wenn sowohl F als auch P durch 
	rein kubische Gleichungen gegeben sind, d.h. zum Beispiel fuer
	F = x^3 - 5 und P = y^3 + 4 liefert isnf3eqnf3 kein Ergebnis.



			isnfel( F, a )

	"is number field element?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isnfel( F,a )     pol F;nfel a;
	s = isnfel( F,a );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variablen ueber Z.
	s = 1,  falls a ein Element des von F erzeugten Zahlkoerpers
		ist, das folgende Form hat:
		a = 0, falls a = 0 und sonst
		a = ( HNa, r, ar,...,a0 ), wobei gilt:
		      - HNa ist positive ganze Zahl.
		      - ( r, ar,..., a0 ) ist Polynom in einer Variablen
			vom Grad r < Grad F ueber Z in dense-Darstellung.
		      - ggt( HNa, ar,...,a0 ) = 1.
	s = 0,  sonst.



			isnfels( F, a )

	"is number field element, sparse representation ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isnfels(F,a)  pol F; obj a;
	s = isnfels(F,a);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
	       einer Variable ueber den rationalen Zahlen.
	s = 1, falls a Element des von F erzeugten Zahlkoerpers ist,
	       das als Polynom vom Grad < Grad(F) in einer Variable ueber
	       den rationalen Zahlen dargestellt ist (sparse-Darstellung),
	s = 0, sonst.



			isnfone( F, A )

        "is number field element one"
        Quellbibliothek: srclib.arith2
        Include-Datei:   _arith2.h
        single isnfone(F,A)  pol F; nfel A;
        s = isnfone(F,A);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber
		Z vom Grad >= 1 in dense-Darstellung, das einen Zahl-
		koerper k erzeugt.
              - A ist ein Element aus k.
        s=1, wenn A = 1,
        s=0, sonst.



			ispd( N, pM )

	"integer small prime divisors search"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list ispd(N,pM)  int N,*pM;
	F = ispd(N,pM);
	Es muss gelten : N > 0.
	F = (q1,...,qh), h>=0, q1<=...<=qh, ist eine Liste von Primzahlen,
	so dass N = *pM * q1 * ... * qh.
	*pM ist durch keine Primzahl aus LIST_SP teilbar, ist also entweder
	1 oder > 10^6.



			ispd_lo( N, pM )

	"integer small prime divisors ( lists only )"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list ispd_2(N,pM)  int N,*pM;
	F = ispd_2(N,pM);
	Es muss gelten : N > 0.
	F = (q1,...,qh), h>=0, q1<=...<=qh, ist eine Liste von Primzahlen,
	so dass N = *pM * q1 * ... * qh.
	*pM ist durch keine Primzahl aus LIST_SP teilbar, ist also entweder
	1 oder > 10^6.  
	Im Gegensatz zu ispd werden keine arrays verwendet, d.h. es wird
	nur innerhalb der SIMATH-Speicherverwaltung (also nur mit Listen)
	gearbeitet.



			ispfel( p, a )

	"is p-adic field element?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single ispfel( p,a )     single p; obj a;
	s = ispfel( p,a );
	Dabei muss gelten:
	      - p ist single-prime.
	s = 1,  falls a folgenden Bedingungen genuegt:
		A sei Element des p-adischen Zahlkoepers Qp mit einer
		Approximation a aus Qp, fuer die bzgl der additiven
		p-adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0       und
			  0 <= a_i <= p - 1
		Fuer a ergibt sich dann folgende Form:
		a = 0                     ,falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d )          ,sonst.
	s = 0,  sonst.



			isprod( A, b )

	"integer single-precision product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int isprod(A,b)  int A; single b;
	C = isprod( A, b );
	C = A * b.



			ispt( M, M1, F )

	"integer Selfridge primality test"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ispt(M, M1, F)  int M, M1; list F;
	s = ispt(M, M1, F);
	Es muss gelten :
	  M >= 3
	  M1 = M - 1
	  F = ( Q1, ..., Qk ), Q1 <= ... <= Qk, ist die Liste der
	  Primfaktoren von M1, also M1 = Q1 * ... * Qk.
	Ist s = 1, so ist M ist Primzahl.
	Ist s =-1, so ist M keine Primzahl.
	Ist s = 0, so konnte nicht entschieden werden,
	ob M Primzahl ist oder nicht.
	Siehe auch -> iftpt, ->isiprime.



			isqnfidone( D, A )

	"is quadratic number field ideal one?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isqnfidone( D, A )  int D; list A;
	s = isqnfidone( D, A );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei,
	A ist ein Ideal des Ganzheitsrings O_D von Q(D^(1/2)).
	Zur Darstellung von Idealen siehe qnfidprod.
	s = 1, falls A das Eins-Ideal, also O_D, ist; s = 0 sonst.



			isqnfiel( D, a )

	"is quadratic number field element integral element?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isqnfiel( D, a )  int D; nfel a;
	i = isqnfiel( D, a );
	D ist aus Z\{0,1} und quadratfrei. 
	a ist ein Element von Q(D^(1/2)), das in minimaler Darstellung 
	gegeben ist (siehe qnfminrep).
	i = 1, falls a im Ganzheitsring O_D von Q(D^(1/2)) liegt,
            0  sonst.



			isqnfint( D, a )                (MACRO)

	"is quadratic number field element integer?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isqnfint( D, a )  int D; nfel a;
	i = isqnfint( D, a );
	D ist aus Z\{0,1} und quadratfrei.
	a ist Element von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	i = 1, falls a eine ganze Zahl (a in Z) darstellt,
	    0  sonst.



			isqnfone( D, a )                (MACRO)

	"is quadratic number field element one?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isqnfone( D, a )  int D; nfel a;
	s = isqnfone( D, a );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei,
	a ist ein Element aus Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	s = 1, falls a das Zahlkoerperelement 1 darstellt, s = 0 sonst.



			isqnfppihom0( D, P, k, pi, z, a )

	"is quadratic number field element power of prime ideal
	 homomorphism zero?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
        single isqnfppihom0( D, P, k, pi, z, a ) 
	       int D; list P; single k, z; nfel pi, a;    
	s = isqnfppihom0( D, P, k, pi, z, a );
	D ist aus Z\{0,1} und quadratfrei.
	P ist ein Primideal von O_D, dem Ganzheitsring von K = Q(D^(1/2)).
	Zur Darstellung von Idealen siehe qnfidprod.
	k > 0.
	pi ist eine zu P gehoerige Ortsuniformisierende.
	z gibt das Zerlegungsgesetz von p in K an: z = 0, 1 oder 2, 
	falls p in K traege, verzweigt bzw. zerlegt ist. 
	a ist ein Element von K, das bzgl. P ganz ist, d.h. v_P(a) >= 0.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	s = 1, falls a == 0 modulo (P^k), d.h. v_P(a) >= k,
            0, sonst (0 <= v_P(a) < k).



			isqnfrat( D, a )                (MACRO)

	"is quadratic number field element rational"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isqnfrat( D, a )  int D; nfel a;
	i = isqnfrat( D, a );
	D ist aus Z\{0,1} und quadratfrei.
	a ist Element von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	i = 1, falls a eine rationale Zahl darstellt,
	    0  sonst.



			isqrem( A, b, pQ, pr )

	"integer single-precision quotient and remainder"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int isqrem(A,b,pQ,pr)  int A, *pQ; single b, *pr;
	C = isqrem( A, b, pQ, pr );
	b ist einfachgenaue Zahl ungleich Null.
	Berechnet werden *pQ als der ganzzahlige Anteil von A / b
	und *pr = A - (*pQ) * b.
	C hat den Wert 0.



			isqrt( A )

	"integer square root"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int isqrt(A)  int A;
	B = isqrt( A );
	A >= 0.
	B ist der ganzzahlige Anteil der Quadratwurzel von A.



			isqrt_lo( A )

	"integer square root ( lists only )"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int isqrt_lo(A)  int A;
	B = isqrt_lo( A );
	A >= 0.
	B ist der ganzzahlige Anteil der Quadratwurzel von A.
	Es wird nur innerhalb der SIMATH-Speicherverwaltung
	(also nur mit Listen) gearbeitet.



			isquot( A, b )                  (MACRO)

	"integer single-precision quotient"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int isquot(A,b)  int A; single b;
	C = isquot(A,b);
	Es muss gelten : b != 0 .
	C ist der ganzzahlige Anteil des Quotienten aus A und b.



			israt( R )

	"is rational number ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single israt(R)  obj R;
	n = israt(R);
	n hat den Wert 1, falls R eine rationale Zahl ist,
		   und 0, falls R keine rationale Zahl ist.



			isrem( A, b )                   (MACRO)

	"integer single-precision remainder"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single isrem(A,b)  int A; single b;
	C = isrem(A,b);
	Es muss gelten : b != 0 .
	C = A - Q*b, wobei Q der ganzzahlige Anteil von A / b ist.



			isrfmsp1( p, R )

	"is rational function over modular single prime, transcendence
	degree 1 ?"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	single isrfmsp1(p,R) obj p,R;
	a = isrfmsp1(p,R);
	a = 1, falls R als rationale Funktion in einer Variablen ueber
		Z/pZ, p Primzahl kleiner BASIS, interpretiert werden kann;
	    0, sonst.



			isrfr( r, R )

	"is rational function over the rationals ?"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	single isrfr(r,R) obj r,R;
	a = isrfr(r,R);
	a =  1,  falls R als rationale Funktion in r (0<=r<BASIS)
		 Variablen ueber Q interpretiert werden kann;
	     0,  sonst.



			isrfrone( r, A )

        "is rational function over rationals one"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
        single isrfrone(r,A)  single r; rfunc A;
        s = isrfrone(r,A);
        A ist eine rationale Funktion in r (0 <= r < BASIS) 
	Variablen ueber Q.
        s=1, wenn A = 1,
        s=0, sonst.



			isrone( A )

        "is rational number one ?"
        Quellbibliothek: srclib.arith1
        Include-Datei:   _arith1.h
        single isrone(A)  rat A;
        s = isrone(A);
        s=1, wenn A = 1,
        s=0, sonst.



			isrsqr( R )

	"is rational number square ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single isrsqr( R )  rat R;
	n = isrsqr( R );
	n ist 1, wenn R ein Quadrat ist;
	n ist 0, wenn R kein Quadrat ist;
	n ist -1, wenn R negativ ist.



			issortls( A )

	"is sorted list of singles ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single issortls(A)  obj A;
	s = issortls(A);
	s hat den Wert 1, falls A eine aufsteigend sortierte Liste aus
			    singles ist,
		   und 0, andernfalls.
	Die leere Liste liefert Wert 1.



			isspprime( a, pc )

	"is single power of a prime ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h     
	single isspprime(a,pc)  single a, *pc;
	s = isspprime(a,pc);
	Es muss gelten: a > 1.
	s = 1,  falls a Potenz einer Primzahl ist, 
	s = 0,  sonst.  
	*pc ist die kleinste Primzahl, die a teilt.



			issprime( a, pc )

	"is single prime ?"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single issprime(a,pc)  obj a,*pc;
	s = issprime(a,pc);
	     ( -1,    falls (1) a keine single in [2,BASIS-1] ist,
	s =  (  0,    falls (2) a in [2,BASIS-1] liegt, aber keine PZ ist,
	     (  1,    falls (3) a Primzahl aus [2,BASIS-1] ist.
	In Fall (2) ist *pc die kleinste Primzahl, die a teilt,
	in Fall (1) und (3) ist *pc = a.



			isudpm2sb( A )

	"is univariate dense polynomial over modular 2 in special
	bit-representation ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isudpm2sb(A)  obj A;
	s = isudpm2sb(A);
	s hat den Wert 1, falls A eine Liste von nicht negativen singles
	ist, die ein dense-Polynom in einer Variablen in spezieller 
	Bit-Notation darstellt (vgl. udpm2tosb).
	Sonst hat s den Wert 0.
	A=0 liefert den Wert 1.



			isum( A, B )

	"integer sum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int isum(A,B)  int A, B;
	C = isum( A, B );
	C = A + B.



			isupid4real( P )

	"is univariate polynomial over integers of degree 4 real ?"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single isupid4real( P )  list P;
	s = isupid4real( P );
	Dabei muss gelten:
		- P ist ein irreduzibles normiertes Polynom vom Grad 4
                  in einer Veraenderlichen ueber Z.
	Das Programm berechnet, ob ein Polynom vom Grad 4 in der Form 
	x^4 - s*x^3 + p*x^2 - q*x + n  mit ganzen Koeffizienten s, p, q 
	und n die Bedingungen
        R1)  p - 3/8*s^2  < 0
        R2)  p^2 - s^2*p + 3/16*s^4 + s*q - 4*n > 0
        R3)  4*(p^2 - 3*s*q + 12*n)^3 
             - (2*p^3 - 72*p*n + 27*s^2*n - 9*s*p*q + 27*q^2)^2 > 0
        erfuellt, d.h. ob das Polynom 4 reelle Nullstellen hat und somit
	Erzeuger eines reell-quartischen Zahlkoerpers K ist.
	Die Funktion gibt als Ergebnis
        s = 0 fuer K nicht-reell
        s = 1 fuer K reell
        zurueck.
	Literatur: B.N. Delone and D.K. Faddeev:
                   The Theory of Irrationalities of the third degree, p.184   



			itoE( A, e )

	"( SIMATH ) integer to Essen integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single itoE( A, e )  int A; LONG e[];
	s = itoE( A, e );  
	Es muss gelten A >= 0.   
	Falls A < 2^(32 * (LAENGE-1) ) ist, ist s = 1 und  
	e = A, wobei e gemaess den Essener Konventionen 
	dargestellt wird.
	Sonst ist s = 0. A ist dann zu gross, um in 
	Essener Darstellung umgewandelt zu werden.   
	siehe auch: Etoi, Etoineg, itoEb, itoEsb.



			itoEb( A, e, grenze )

	"( SIMATH ) integer to Essen integer with upper bound"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single itoEb( A, e, grenze )  int A; LONG e[]; single grenze;
	s = itoEb( A, e );      
	Es muss gelten: grenze <= LAENGE, A > 0.
	Falls A < 2^(32 * (grenze-1) ) ist, so ist s = 0 und e = A, 
	wobei e gemaess den Essener Konventionen dargestellt wird.
	Sonst ist s = 1; e ist in diesem Fall nicht definiert. 
	siehe auch: Etoi, Etoineg, itoE, itoEsb.



			itoEsb( A, e, grenze )

	"( SIMATH ) integer to Essen integer, sign and upper bound"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single itoEsb( A, e, grenze )  int A; LONG e[]; single grenze;
	s = itoEsb( A, e );      
	Es muss gelten: grenze <= LAENGE.
	Falls |A| < 2^(32 * (grenze-1) ) ist, so ist 
	s das Signum von A und e = |A|, wobei e gemaess 
	den Essener Konventionen dargestellt wird.
	Sonst ist s = 2, e ist in diesem Fall nicht definiert. 
	siehe auch: Etoi, Etoineg, itoE, itoEb.



			itoI( A, h )

	"( SIMATH ) integer to ( Heidelberg ) Integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	single itoI(A, h)  int A; Integer *h;
	s = itoI(A, h)
	*h = A, wobei *h gemaess den Heidelberger Konventionen 
	dargestellt wird; s = 0.
	siehe auch Itoi.



			itoI_sp( A, lA, h )

	"( SIMATH ) integer to ( Heidelberg ) Integer special version"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _HDarith.h
	single itoI_sp(A, lA, h)  int A; single lA; Integer *h; 
	s = itoI_sp(A, lA, h);
	Es muss gelten: lA = llength(A), falls A kein single ist. 
	*h = A, wobei *h gemaess den Heidelberger Konventionen 
	dargestellt wird; s = 0.
	siehe auch Itoi.



			itofl( A )                      (MACRO)

	"integer to floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating itofl( A )  int A;
	f = itofl ( A );    
	f ist die floating point Darstellung von A. Genauer gilt:
	| (  A - f ) / A | <  1/2 * (2^30)^( 1 - FL_EPS ).                                                          



			itonf( A )                      (MACRO)

	"integer to number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel itonf( A )  int A;
	a = itonf( A );
	a ist die Darstellung der ganzen Zahl A als Element eines Zahl-
	koerpers, d.h.:
	a = ( 1, 0, A ) fuer A != 0 und
	a = 0           fuer A = 0.



			itonfs( A )

	"integer to number field element, sparse representation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel itonfs(A)  int A;
	a = itonfs(A);
	a ist die Darstellung der ganzen Zahl A als Polynom in einer
	Variable ueber den rationalen Zahlen (sparse-Darstellung).



			itopfel( p, d, A )

	"integer to p-adic field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel itopfel( p, d, A )         single p,d; int A;
	c = itopfel( p, d, A );
	Dabei muss gelten:
	      - p ist single-prime.
	c ist die Approximation zu A aus Qp vom Grad d, fuer die bzgl.
	der additiven p-adischen Bewertung vp gilt:
		      vp( A - c ) >= d
	      und     c = 0                           ,falls d < vp( A )
	      sonst   c = c_vp( A ) * p^vp( A ) + ... + c_d * p^d,
	      wobei   c_vp( A ) != 0     und
		      0 <= c_i <= p - 1
	  =>  c = 0                       ,falls A = 0 oder alle c_i = 0
		  ( d, vp( A ), c_vp( A ), ..., c_d )



			itoqnf( D, a )                  (MACRO)

	"integer to quadratic number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel itoqnf( D, a )  int D, a;
	b = itoqnf( D, a );
	D ist aus Z\{0,1} und quadratfrei, a eine ganze Zahl.
	b = 0, falls a = 0, 
	b = ( 1  0  a ) sonst.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)



			itor( A )

	"integer to rational number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat itor(A)  int A;
	R = itor(A);
	Die ganze Zahl A wird in die rationale Zahl R umgewandelt.



			itrunc( A, n )                  (MACRO)

	"integer truncation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int itrunc(A,n)  int A; single n;
	B = itrunc(A,n);
	B ist der ganzzahlige Wert von A / 2^n .



			libsort( L )

	"list of integers bubble sort"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single libsort(L)  list L;
	n = libsort( L );
	L ist eine Liste von ganzen Zahlen (evtl. leer).
	L wird in aufsteigender Ordnung umsortiert (vgl lsbsort).
	L wird veraendert.
	n hat den Wert 0.



			limerge( L1, L2 )

	"list of integers merge"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list limerge(L1,L2)  list L1, L2;
	L = limerge( L1, L2 );
	L1 und L2 sind Listen ganzer Zahlen, die aufsteigend sortiert sind.
	L ist die aufsteigend geordnete Konkatenation von L1 und L2.



			liprod( L1, L2 )

	"list of integers product"
	Quellbibliothek: srclib.arith1
	include-Datei:   _arith1.h
	list liprod(L1, L2)  list L1, L2;
	L = liprod(L1, L2);
	L1 und L2 sind Listen von ganzen Zahlen. liprod berechnet eine
	Liste L, die aus allen Produkten der Eintraege der Listen L1
	und L2 besteht.
	Beispiel: Fuer L1 = ( a1  a2 ) und L2 = ( b1  b2  b3 ) ist
	L = liprod( L1, L2 ) = (a2*b3  a2*b2  a2*b1  a1*b3  a1*b2  a1*b1).   



			liprodoe( L )

	"list of integers product over all entries"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int liprodoe( L )  list L;
	A = liprodoe( L );
	Dabei muss gelten:
	   - L ist eine Liste von ganzen Zahlen. L ist ungleich der 
	     leeren Liste.
        liprodoe berechnet das Produkt ueber alle Listeneintraege.



			m4hom( a )                      (MACRO)

	"modular 4 homomorphism"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
        single m4hom( a )  int a;
	s = m4hom( a );
	s = a modulo 4 (im Restsystem {0, 1, 2, 3}).



			marlllred( bas )

	"matrix of rationals, LLL reduction"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list marlllred(bas)  list bas;
	L = marlllred(bas);
	bas ist eine n x n Matrix ueber Q mit n > 0, so dass
	die Zeilen von bas n ueber Z linear unabhaengige
	Vektoren aus Q^n darstellen.
	L ist eine n x n Matrix ueber Q, so dass die Zeilen
	von L denselben Z-Modul	erzeugen.
	Die Basis in L ist LLL - reduziert.
	Vorsicht, die urspruengliche Matrix wird veraendert!
	Siehe Math. Ann. 261, 515-534 (1982).



			micra( M1, M2, N1, A1, A2 )

	"modular integer chinese remainder algorithm"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int micra(M1,M2,N1,A1,A2)  int M1,M2,N1,A1,A2;
	A = micra(M1,M2,N1,A1,A2);
	Es muss gelten : M1,M2 positiv
			 gcd(M1,M2) = 1
			 N1 ist das Inverse von M1 modulo M2 in Z/M2*Z.
			 A1 ist aus Z/M1*Z, A2 ist aus Z/M2*Z.
	A ist das eindeutige Element aus Z/(M1*M2)Z, das kongruent
	A1 modulo M1 und kongruent A2 modulo M2 ist.



			micran( n, LM, LA )

	"modular integer chinese remainder algorithm, n arguments"
	(rekursiv)
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int micran(n,LM,LA)  single n;  list LM,LA;
	A = micran(n,LM,LA);
	n ist positiv.
	LM = (M1,...,Mn) ist eine n-elementige Liste aus positiven, paar-
	weise teilerfremden mehrfach-genauen Zahlen.
	LA = (A1,...,An) ist eine n-elementige Liste, wobei Ai aus Z/Mi*Z
	ist fuer alle i=1,...,n.
	A ist das eindeutige Element aus Z/MZ, das kongruent Ai modulo Mi
	ist fuer alle i=1,...,n.



			midif( M, A, B )

	"modular integer difference"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int midif(M,A,B)  int M,A,B;
	C = midif(M,A,B);
	M ist positiv, A und B sind aus Z/MZ.
	C = A - B.



			miexp( M, A, E )

	"modular integer exponentiation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int miexp(M,A,E)  int M,A,E;
	B = miexp(M,A,E);
	Es muss gelten : M > 0, A aus Z/MZ, E >= 0.
	B = A^N.



			miexp_lo( M, A, E )

	"modular integer exponentiation ( lists only )"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int miexp_lo(M,A,E)  int M,A,E;
	B = miexp_lo(M,A,E);
	Es muss gelten: M > 0, A aus Z/MZ, E >= 0.
	B = A^N.                                  
	Es wird nur innerhalb der SIMATH-Speicherverwaltung
	(also nur mit Listen) gearbeitet.



			mihom( M, A )

	"modular integer homomorphism"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int mihom(M,A)    int M,A ;
	B = mihom( M, A );
	M ist positive ganze Zahl.
	B = A modulo M, im kleinsten positiven Restsystem.



			mihoms( M, A )

	"modular integer homomorphism, symmetric remainder system"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int mihoms(M,A)  int M, A;
	B = mihoms( M, A );
	M ist positive ganze Zahl.
	B = A modulo M, im symmetrischen Restsystem.



			miinv( M, A )

	"modular integer inverse"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int miinv( M , A )  int M,A;
	R = miinv( M , A );
	M ist positive ganze Zahl. 
	R ist aus Z/MZ, so dass gilt: 
        R * A = 1 mod M      falls  A und M teilerfremd,
        R = 0                falls  nicht.



			miinv_lo( M, A )

	"modular integer inverse, lists only"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int miinv_lo( M , A )  int M,A;
	R = miinv_lo( M , A );
	M ist positive ganze Zahl. 
	R ist aus Z/MZ, so dass gilt : 
        R * A = 1 mod M      falls  A und M teilerfremd,
        R = 0                falls  nicht.
	Es wird nur innerhalb der SIMATH-Speicherverwaltung 
	gearbeitet, d.h. ohne Essener Arithmetik.



			milcra( m1, m2, L1, L2 )

	"modular integer list chinese remainder algorithm"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list milcra(m1,m2,L1,L2)  int m1,m2; list L1,L2;
	L = milcra(m1,m2,L1,L2);
	m1 und m2 sind positive teilerfremde ganze Zahlen.
	L1 = (a(1),...,a(m)) ist eine Liste von Elementen aus Z / m1*Z,
	L2 = (b(1),...,b(n)) ist eine Liste von Elementen aus Z / m2*Z.
	Dann ist L = ( c(1,1),...,c(1,n),...,c(m,1),...,c(m,n) ) eine
	Liste, so dass c(k,l) jeweils das eindeutige Element aus
	Z / (m1 * m2)*Z ist, das kongruent a(k)	modulo m1 und kongruent
	b(l) modulo m2 ist.



			mineg( M, A )                   (MACRO)

	"modular integer negation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int mineg(M,A)  int M,A;
	B = mineg(M,A);
	M ist positiv, A aus Z/MZ.
	B = -A.



			minegf( M, A )

	"modular integer negation as function"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int minegf(M,A)  int M, A;
	B = minegf(M,A);
	M > 0,  A aus Z/MZ.
	B = -A.
	minegf liefert das gleiche Ergebnis wie das Macro mineg.



			mipfnsquare( p )

	"modular integer prime find non square"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int mipfnsquare (p)  int p;
	c = mipfnsquare (p);
        Es muss gelten: 2 < p
	p sollte Primzahl sein.
	Ist p prim, so ist c!=0 quadratischer Nichtrest mod p.
	c ist aus Z/pZ.
	Eine von mipfnsquare erzeugte Folge c1,c2,c3,... mod p ist
	nichtkonstant fuer p>3.
!!!	Fuer spezielle Anwendungen ist c=-1, falls erkannt wird, dass
	p nicht prim ist. Wird dies nicht erkannt, so ist c nicht
	notwendig Nichtquadrat mod p.



			mipfsquare( p )

	"modular integer prime find square"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int mipfsquare (p)  int p;
	c = mipfsquare (p);
        Es muss gelten: 2 < p
	p sollte Primzahl sein.
	Ist p prim, so ist c!=0 quadratischer Rest mod p.
	c ist aus Z/pZ.
	Eine von mipfsquare erzeugte Folge c1,c2,c3,... mod p ist
	nichtkonstant fuer p>3.
!!!	Fuer spezielle Anwendungen ist c=-1, falls erkannt wird, dass
	p nicht prim ist. Wird dies nicht erkannt, so ist c nicht
	notwendig Quadrat mod p.



			miprod( M, A, B )

	"modular integer product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int miprod(M,A,B)  int M,A,B;
	C = miprod(M,A,B);
	M ist positiv, -M <= A <= M, -M <= B <= M.
	C = A * B (modulo M).



			miprodf( M, A, B )

	"modular integer product as function"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int miprodf(M,A,B)  int M,A,B;
	C = miprodf(M,A,B);
	M ist positiv, A und B sind aus Z/MZ.
	C = A * B.
	miprodf liefert das gleiche Ergebnis wie das Macro miprod.



			miproot( Q )

	"modular integer primitive root"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int miproot(Q)  int Q;
	A = miproot(Q);
	Q ist positiv und so, dass eine Primitivwurzel mod Q existiert.
	A ist eine Primitivwurzel mod Q, 1 < A < Q.
        Warnung!!!
	Besitzt Q keine Primitivwurzel, so endet die Prozedur nicht !!!



			mipsqrt( p, r )

	"modular integer prime square root"
 	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int mipsqrt (p,r)  int p,r;
	w = mipsqrt (p,r);
        1 < p sollte Primzahl sein.
	r ist aus Z/pZ.
	Geloest wird die Gleichung   (*)   w*w = r mod p.
	Ist (*) loesbar, so ist w aus Z/pZ eine Loesung von (*).
	Ist (*) nicht loesbar, so ist w = -1.
!!!	Falls p nicht prim ist, so kann zweierlei geschehen:
	1. Dies wird erkannt, und es ist w = -2.
	   (Der wahrscheinlichste Fall!)
	2. Dies wird nicht erkannt. In diesem Falle ist w = -1 oder eine
	   Loesung von (*).



			miquot( M, A, B )               (MACRO)

	"modular integer quotient"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int miquot(M,A,B)  int M,A,B;
	C = miquot(M,A,B);
	M ist positiv, A ist aus Z/MZ, B ist Einheit aus Z/MZ.
	C = A / B.



			miscra( M, m, m1, A, a )

	"modular integer single chinese remainder algorithm"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int miscra(M,m,m1,A,a)  int M,A; single m,m1,a;
	B = miscra(M,m,m1,A,a);
	Es muss gelten : M ist positiv
			 m ist positiv und ungerade
			 m1 ist das Inverse modulo m von M mod m.
			 gcd(M,m) = 1
			 A ist Einheit aus Z/MZ, a ist aus Z/mZ.
	B ist das eindeutige Element aus der Einheitengruppe von Z/(M*m)Z,
	das kongruent A modulo M und kongruent a modulo m ist.



			misqrt( m, a )

	"modular integer square root"
 	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	int misqrt (m,a)  int m, a;
	x = misqrt (m,a);
	misqrt berechnet eine Loesung der Kongruenz
		x^2 - a = 0 (mod m),
	falls eine solche Loesung existiert. 
	misqrt liefert -1, falls keine Loesung existiert. 
	Ist m = p eine Primzahl, so sollte man die schnellere 
	Funktion mpsqrt verwenden.



			misqrtas( N, r )

	"modular integer square root all solutions"
 	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list misqrtas (N,r)  list N; int r;
	X = misqrtas (N,r);
	Es muss gelten:
	N ist die Faktor-Exponent-Liste einer ganzen Zahl n>1, d.h.
	N = (p1,e1,p2,e2,...,pk,ek) mit ei>=1, pi prim und paarweise
	verschieden (1<=i<=k) und n = p1^e1 * p2^e2 *...* pk^ek.
	(N erhaelt man aus n etwa mittels -> ifact und -> ifel.)
	r ist aus Z/nZ.
	Geloest wird die Gleichung (*)	x*x = r mod n  nach x.
	X ist die Liste aller Loesungen von (*).
	X ist in der Regel nicht geordnet. 



			misqrtsrch( m, a )

	"modular integer square root search"
 	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int misqrtsrch(m, a)  int m, a;
	x = misqrtsrch(m, a);
	misqrtsrch berechnet eine Loesung der Kongruenz
		x^2 - a = 0 (mod m),
	falls eine solche Loesung existiert. 
	misqrtsrch liefert -1, falls keine Loesung existiert. 
	misqrt ist schneller als misqrtsrch.
	Ist m = p eine Primzahl, so sollte man die noch
	schnellere Funktion mpsqrt verwenden.



			misum( M, A, B )                (MACRO)

	"modular integer sum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int misum(M,A,B)  int M,A,B;
	C = misum(M,A,B);
	M ist positiv, A und B sind aus Z/MZ.
	C = A + B.



			misumf( M, A, B )

	"modular integer sum as function"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int misumf(M,A,B)  int M, A, B;
	C = misumf(M,A,B);
	M > 0,  A und B aus Z/MZ.
	C = A + B.
	misumf liefert das gleiche Ergebnis wie das Macro misum.



			mitos( M, A )

	"modular integer to symmetric remainder system"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int mitos(M,A)  int M, A;
	B = mitos(M,A);
	M ist nicht negativ, A ist aus dem positiven Restsystem mod M.
	B ist aus dem symmetrischen Restsystem mod M, kongruent zu A mod M.



			modielemtest( B, a )

	"module over the integers element test"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single modielemtest(B,a)  list B; pol a;
	t = modielemtest(B,a);
	Sei A eine separable Algebra ueber den rationalen Zahlen.
        B ist eine Liste von CD - Polynomen ueber den rationalen Zahlen,
	deren Grade streng absteigend sind.
	Diese CD - Polynome repraesentieren Elemente obiger Algebra,
	die eine Z - Basis eines Z - Moduls in A repraesentieren
	( siehe cdprfcl ).
	a ist ein Element dieser Algebra und wird durch ein CD - Polynom
	repraesentiert.
	t = 1,  falls a in dem durch die Polynome von B erzeugten
		Z - Modul liegt.
	t = 0,  sonst.



			modilllred( bas )

	"module over the integers, LLL reduction"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list modilllred(bas)  list bas;
	L = modilllred(bas);
	bas = ( b_1, ..., b_n ) ist eine Liste der Laenge n ( n > 0 ),
	wobei jedes Listenelement von bas ebenfalls eine Liste ist,
	bestehend aus n rationalen Zahlen.
	Diese Listen repraesentieren n ueber den ganzen	Zahlen linear
	unabhaengige Vektoren aus Q^n.
	L ist eine Liste von n Vektoren der Laenge n ueber Q, die den-
	selben Z-Modul erzeugen wie b_1, ..., b_n. Die Basis in L ist
	LLL - reduziert.
	Siehe Math. Ann. 261, 515-534 (1982).



			modiorthobas( bas )

	"module over the integers, orthogonalized basis"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list modiorthobas(bas)  list bas;
	L = modiorthobas(bas);
	bas = ( b_1, ..., b_n ) ist eine Liste der Laenge n ( n > 0 ),
	wobei jedes Listenelement von bas ebenfalls eine Liste ist,
	bestehend aus n rationalen Zahlen.
	Diese Listen repraesentieren n ueber den ganzen	Zahlen linear
	unabhaengige Vektoren aus Q^n.
	L = ( basstar, Nq, mij ) ist eine Liste;
	dabei ist basstar = ( bs_1, ..., bs_n ) die zu bas gemaess
	dem Gram-Schmidt'schen Orthogonalisierungsverfahren bestimmte
	orthogonale Basis;
	Nq = ( N_1, ..., N_n ) ist eine Liste, so dass N_i das Skalar-
	produkt von bs_i mit bs_i ist;
	mij = ( m_i,j ) ist eine (n-1) x (n-1) Matrix ueber Q, so dass
	gilt: bs_i = b_i  -  ( m_i,1 * bs_1 + ... + m_i,i-1 * bs_i-1 ).



			modprmsp1elt( B, p, a )

	"module over polynomial ring over modular single primes,
	transcendence degree 1, element test"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	single modprmsp1elt(B,p,a)  list B; single p; pol a;
	t = modprmsp1elt(B,p,a);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
        B ist eine Liste von CD-Polynomen in einer Unbestimmten
	ueber (Z/pZ) (x) - dem rationalen Funktionenkoerper in x
	ueber Z/pZ.
	Die Grade dieser Polynome sind streng absteigend; die
	Polynome repraesentieren Elemente aus einer separablen
	Algebra A ueber (Z/pZ) (x) ( siehe cdprfmsp1fcl ).
	Diese Elemente erzeugen ueber (Z/pZ) [x] einen Modul M
	in A.
	a ist ein Element obiger Algebra und wird ebenfalls
	durch ein CD-Polynom dargestellt.
	t = 1,  falls a in M liegt.
	t = 0,  sonst.



			mods( A, B )                    (MACRO)

	"modulo with reference to SIMATH"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single mods( A,B )  single A,B;
	C = mods( A,B );
	Es muss gelten: B ist ungleich Null.
	ACHTUNG: C = A % B gemaess der SIMATH-Konvention, d.h. so wie "%"
	-------- auf MX2(+) realisiert ist. Dies stimmt fuer den Fall
		 A * B < 0, B teilt nicht A nicht mit dem allgemeinen
		 Standard nach Kernighan-Ritchie ueberein, der auf SUN
		 und Apollo gilt. Sei A % B standardmaessig. Dann ist
		 im obigen Fall
			  C = ( A % B ) + B.



			mppsqrt( p, n, r, xk, k )

	"modular prime power square root"
 	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list mppsqrt (p,n,r,xk,k)  int p,r,xk; single n,k;
	X = mppsqrt (p,n,r,xk,k);
	Es muss gelten:
        	0 <= k < n < BASIS
        	p  ist Primzahl.
		r  ist aus Z/p^nZ.
		xk ist aus Z/p^kZ.
	Geloest wird die Gleichung   (*)   x*x = r mod p^n	nach x.
	X ist die Liste aller Loesungen von (*).
	Die Elemente von X sind aus Z/p^nZ.
	Ist bereits ein xk bekannt mit xk*xk = r mod p^k, so gibt man
	xk und k an, um die Berechnung zu beschleunigen.
	Ist kein solches xk bekannt, so setzt man k = 0.



			mpsqrt( p, a )

	"modular primes square root"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int mpsqrt(p, a)  int p, a;
	x = mpsqrt(p, a);
	Dabei muss gelten:
		- p >= 3 ist eine ungerade Primzahl,
		- a ist quadratischer Rest modulo p.
	mpsqrt berechnet eine Loesung der Kongruenz
		x^2 - a = 0 (mod p).
	Literatur: Neal Koblitz, A Course in Number Theory and
		Cryptography, Springer 1987, pp 47, 48.



			mscra( m1, m2, n1, a1, a2 )

	"modular single chinese remainder algorithm"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single mscra(m1,m2,n1,a1,a2)  single m1,m2,n1,a1,a2;
	a = mscra(m1,m2,n1,a1,a2);
	Es muss gelten : m1,m2 positiv
			 gcd(m1,m2) = 1
			 m1 * m2 < BASIS
			 n1 ist das Inverse von m1 modulo m2 in Z/m2*Z.
			 a1 ist aus Z/m1*Z, a2 ist aus Z/m2*Z.
	a ist das eindeutige Element aus Z/(m1*m2)Z, das kongruent a1
	modulo m1 und kongruent a2 modulo m2 ist.



			mscran( n, Lm, La )

	"modular single chinese remainder algorithm, n arguments"
	(rekursiv)
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single mscran(n,Lm,La)  single n;  list Lm,La;
	a = mscran(n,Lm,La);
	n ist positiv.
	Lm = (m1,...,mn) ist eine n-elementige Liste aus positiven, paar-
	weise teilerfremden singles mit m=m1*...*mn < BASIS.
	La = (a1,...,an) ist eine n-elementige Liste, wobei ai aus Z/mi*Z
	ist fuer alle i=1,...,n.
	a ist das eindeutige Element aus Z/mZ, das kongruent ai modulo mi
	ist fuer alle i=1,...,n.



			msdif( m, a, b )                (MACRO)

	"modular single difference"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single msdif(m,a,b) single m, a, b;
	c = msdif(m,a,b);
	m > 0,  a und b aus Z/mZ.
	c = a - b.



			msexp( m, a, n )

	"modular single exponentiation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single msexp(m,a,n)  single m,a,n;
	b = msexp(m,a,n);
	Es muss gelten : m > 0, a aus Z/mZ, n >= 0.
	b = a^n.



			msfrl( m, a )

	"modular single Fermat residue list"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list msfrl(m,a)  single m,a;
	L = msfrl(m,a);
	Es muss gelten : m > 0, a aus Z/mZ.
	L ist die Liste aller verschiedenen b aus Z/mZ, so dass b*b-a
	Quadrat in Z/mZ ist.



			mshom( m, A )

	"modular single homomorphism"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single mshom(m,A)  single m; int A;
	b = mshom( m, A );
	m ist positiv.
	b = A modulo m im kleinsten positiven Restsystem.



			mshoms( m, A )                  (MACRO)

	"modular single-precision homomorphism, symmetric remainder system"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single mshoms(m,A)  single m; int A;
	b = mshoms(m,A);
	m ist positiv.
	b = A modulo m, im symmetrischen Restsystem.



			msinv( m, a )

	"modular single inverse"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single msinv(m,a)  single m, a;
	b = msinv(m,a);
	m > 0, a ist aus Z/mZ.      
	Falls m und a nicht teilerfremd sind, ist b=0,
	sonst ist b = a ^ (-1).



			mslcra( m1, m2, L1, L2 )

	"modular single list chinese remainder algorithm"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list mslcra(m1,m2,L1,L2)  single m1,m2; list L1,L2;
	L = mslcra(m1,m2,L1,L2);
	Es muss gelten : m1,m2 > 0
			 gcd(m1,m2) = 1
			 m=m1*m2 < BASIS
			 L1=(a(1),...,a(m)) ist Liste von El. aus Z/m1*Z,
			 L2=(b(1),...,b(n)) ist Liste von El. aus Z/m2*Z.
	L = ( c(1,1),...,c(1,n),...,c(m,1),...,c(m,n) ), wobei jeweils
	c(k,l) das eindeutige Element aus Z/mZ ist, das kongruent a(k)
	modulo m1 und kongruent b(l) modulo m2 ist.



			msneg( m, a )                   (MACRO)

	"modular single negation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single msneg(m,a) single m, a;
	b = msneg(m,a);
	m > 0,  a aus Z/mZ.
	b = -a.



			msnegf( m, a )

	"modular single negation as function"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single msnegf(m,a)  single m, a;
	b = msnegf(m,a);
	m > 0,  a aus Z/mZ.
	b = -a.
	msnegf liefert das gleiche Ergebnis wie das Macro msneg.



			msprod( m, a, b )

	"modular single product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single msprod(m,a,b)  single m, a, b;
	c = msprod(m,a,b);
	m > 0, a und b aus Z/mZ.
	c = a * b.



			msquot( m, a, b )               (MACRO)

	"modular single quotient".
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single msquot(m,a,b) single m, a, b;
	c = msquot(m,a,b);
	m > 0,  a und b aus Z/mZ, b Einheit aus Z/mZ.
	c = a / b.



			mssum( m, a, b )                (MACRO)

	"modular single sum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single mssum(m,a,b) single m, a, b;
	c = mssum(m,a,b);
	m > 0,  a und b aus Z/mZ.
	c = a + b.



			mssumf( m, a, b )

	"modular single sum as function"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single mssumf(m,a,b)  single m, a, b;
	c = mssumf(m,a,b);
	m > 0,  a und b aus Z/mZ.
	c = a + b.
	mssumf liefert das gleiche Ergebnis wie das Macro mssum.



			msunits( m )

	"modular single units"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list msunits(m)  single m;
	L = msunits(m);
	Es muss gelten : m > 0.
	L ist die aufsteigend sortierte Liste aller Einheiten in Z/mZ.



			nepousppmsp1( p, F, a )

	"norm of an element of the polynomial order of an univariate
	separable polynomial over the polynomial ring over modular
	single prime, transcendence degree 1"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	pol nepousppmsp1(p, F, a) single p; pol F, a;
	N = nepousppmsp1(p, F, a);               
	p ist eine single Primzahl.
        R bezeichne den Polynomring (Z/pZ) [x], wobei x eine Unbestimmte
        ueber Z/pZ sei.
        K bezeichne den rationalen Funktionenkoerper (Z/pZ) (x).
	F ist ein normiertes, separables Polynom in einer Unbestimmten
        ueber R mit einem Grad > 1.
	z sei eine Nullstelle von F.
	a sei ein Element der Polynomordnung R[z] und durch ein Polynom
	in einer Unbestimmten ueber R mit einem Grad kleiner als dem
	von F repraesentiert.
	N ist die Norm von a als Element der Algebrenerweiterung K[z]
	ueber K und als solche aus R.



			nf3chpol( F, el )

	"number field of degree 3 characteristic polynomial" 
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol nf3chpol(F,el)  pol F; nfel el;
	chP = nf3chpol(F,el);
	Dabei muss gelten:
	      - F ist ein normiertes irreduzibles Polynom in einer
		Variablen ueber Z vom Grad 3 in dense-Darstellung,
		das den Zahlkoerper k erzeugt.
	      - el ist ein beliebiges Element aus k\{0}.
	chP ist das charakteristische Polynom von el, das als Polynom
	vom Grad 3 ueber Q in sparse-Darstellung vorliegt.



			nf3sqrt( F, el )

	"number field of degree 3 square root"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nf3sqrt(F,el)  pol F; nfel el;
	sqrtel = nf3sqrt(F,el);
	Dabei muss gelten:
	      - F ist ein normiertes irreduzibles Polynom in einer
		Variablen ueber Z vom Grad 3 in dense-Darstellung,
		das den Zahlkoerper k erzeugt.
	      - el ist ein beliebiges Element aus k.
	sqrtel ist:
	      - die Quadratwurzel von el, falls el ein Quadrat in k ist,
	      - die leere Liste sonst.



			nfdif( F, a, b )

	"number field element difference"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfdif( F, a, b )     pol F; nfel a,b;
	c = nfdif F, a, b );
	Es muss gelten:
	      - F ist ein irreduzibles Polynom ueber Z in einer Variablen
		in dense-Darstellung, das einen Zahlkoerper K erzeugt.
	      - a und b sind als Elemente von K von der Form:
		a = ( HNa, r, ar, ..., a0 )
		a = 0, falls a = 0.
		b = ( HNb, s, bs, ..., b0 )
		b = 0, falls b = 0.
	      - HNa und Hnb sind ganze positive Zahlen.
	      - ( r,ar, ..., a0 ) und ( s,b0, ..., bs ) sind Polynome
		ueber Z in einer Variablen vom Grad r bzw s in dense-
		Darstellung.
	      - ggt( Hna, ar, ..., a0 ) = 1 und
		ggt( HNb, bs, ..., b0 ) = 1
	c = a - b, die Differenz von a und b.



			nfeexpspec( F, a, e, M )

	"number field element exponentiation special"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol nfeexpspec(F,a,e,M) pol F,a; single e; int M;
	b = nfeexpspec(F,a,e,M);
	F ist das definierende Polynom einer separablen Algebra ueber den
	rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
	in einer Veraenderlichen ueber den ganzen Zahlen.
	a ist ein Element dieser Algebra und wird repraesentiert durch ein
	CD - Polynom ( siehe cdprfcl ).
	M ist eine nicht negative ganze Zahl und e eine nicht negative
	single.
	b ist ein CD - Polynom, das a^e repraesentiert.
	Dabei werden fuer positives M die Produkte, die zur Berechnung von
	b gebildet werden, modulo M * Z[x] reduziert ( siehe nfeprodspec ).



			nfeliprod( F, a, i )

	"number field element integer product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfeliprod( F, a, i )  pol F; nfel a; int i;
	c = nfeliprod( F, a, i );
	Dabei muss gelten:
	      _ F ist ein irreduzibles Polynom ueber Z in einer Variablen
		in dense-Darstellung, das einen Zahlkoerper K erzeugt.
	      - a ist Element von K und hat folgende Form:
		a = 0,                       ,falls a = 0.
		a = ( HNa, r, ar, ..., a0 )  ,sonst.
	      - Fuer a ungleich 0 muss gelten:
		      - HNa ist positive ganze Zahl.
		      - ( r, ar, ..., a0 ) ist Polynom in einer
			Variable ueber Z in dense-Darstellung.
		      - ggt( HNa, ar, ..., a0 ) = 1
       c = i * a.



			nfelmodi( F, a, M )

	"number field element modulo integer"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfelmodi( F, a, M )  pol F; nfel a; int M;
	c = nfelmodi( F, a, M );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom ueber Z in einer Variablen
		in dense-Darstellung, das einen Zahlkoerper K rezeugt.
	      - a ist Element von K und von folgender Form:
		a = 0                      ,falls a = 0.
		a = ( HNa, r, ar, ..., a0 ),sonst.
	      - Fuer a ungleich 0 muss gelten:
		      - HNa ist positive ganze Zahl.
		      - ( r, ar, ..., a0 ) ist Polynom in einer
			Variable ueber Z in dense-Darstellung.
		      - ggt( HNa, ar, ..., a0 ) = 1.
	      - M ist positive ganze Zahl.
	      - Fuer a ungleich 0 muss gelten:
			ggt( M,HNa ) = 1.
			-----------------
	c = a mod M.



			nfelnormal( L )

	"number field element normalized representation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfelnormal(L)  list L;
	a = nfelnormal(L);
	L hat eine der folgenden beiden Formen:
	    1) (A,0)
	    2) (A,r,lr,...,l0),
	wobei A eine ganze Zahl ungleich Null ist, 0 <= r < BASIS-1 und
	(r,lr,...,l0) die dense-Darstellung eines Polynoms P in einer
	Variable ueber den ganzen Zahlen.
	a ist die zu L gehoerige gekuerzte Darstellung eines Zahlkoerper-
	elements, d.h.:
	in Fall 1) ist a = 0,
	in Fall 2) ist a = (HNa,r,ar,...,a0), wobei HNa eine positive ganze
	Zahl ist und (r,ar,...,a0) die dense-Darstellung eines Polynoms P1
	in einer Variable ueber den ganzen Zahlen mit
	    ggT(HNa,ggT(ar,...,a0)) = 1  und
	    1/A * P  =  1/HNa * P1.



			nfelrprod( F, a, R )

	"number field element rational number product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfelrprod( F, a, R )  pol F; nfel a; rat R;
	c = nfelrprod( F, a, R );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom ueber Z in einer Variablen
		in dense-Darstellung, das einen Zahlkoerper K erzeugt.
	      - a ist Element von K und hat folgende Form:
		a = 0                           ,falls a = 0.
		a = ( HNa, r, ar, ..., a0 )     ,sonst
	      - Fuer a ungleich Null muss gelten:
		      - HNa ist positive ganze Zahl.
		      - ( r, ar, ..., a0 ) ist Polynom in einer
			Variable ueber Z in dense-Darstellung.
		      - ggt( HNa, ar, ..., a0 ) = 1;
	c = R * a.



			nfeltomaln( n, a )

	"number field element to matrix line"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list nfeltomaln(n,a)  single n; nfel a;
	L = nfeltomaln(n,a);
	Es muss gelten: n >= r+1.
	L hat immer die Laenge n + 1.
	Fuer a = 0 ist L = (1,0,...,0).
	Fuer a = (HN,r,ar,...,a0) ist L = (HN,0,...,0,ar,...,a0),
	wobei zwischen HN und ar (n-(r+1)) Nullen stehen.



			nfeltoudpr( a )

	"number field element to univariate dense polynomial over 
	rationals"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol nfeltoudpr( a )  nfel a;
	b = nfeltoudpr( a );
	Dabei muss gelten:
	      - a ist als Zahlkoerperelement von der Form
		a = ( HNa, r, ar, ..., a0 ) oder a = 0.
	      - HNa ist positive ganze Zahl.
	      - ( r, ar, ..., a0 ) ist univariates Polynom ueber Z vom
		Grad r in dense-Darstellung.
	      - ggT( HNa, ar, ..., a0 ) = 1.
	b = 0, falls a = 0. Sonst ist b das a entsprechende univariate
	Polynom ueber Q vom Grad r in dense-Darstellung, also
		b = ( r, br, ..., b0 )
	mit
		bi = ai / HNa.



			nfeprodspec( F, a, b, M )

	"number field element product special"
	Quellbibliothek : srclib.arith2
	Include - Datei : _arith2.h
	pol nfeprodspec(F,a,b,M) pol F,a,b; int M;
	c = nfeprodspec(F,a,b,M);
	F ist das definierende Polynom einer separablen Algebra ueber den
	rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
	in einer Veraenderlichen ueber den ganzen Zahlen.
	a und b sind Elemente dieser Algebra und werden repraesentiert
	durch CD - Polynome ( siehe cdprfcl ).
	M ist eine nicht negative ganze Zahl.
	c ist ein CD - Polynom, das das Produkt von a und b repraesentiert.
	Dabei ist c fuer positives M modulo M * Z[x] reduziert.



			nfexp( F, a, n )

	"number field element exponentiation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfexp( F, a, n )   pol F;nfel a; single n;
	C = nfexp( F, a, n );
	Dabei muss gelten:
	      - F ist ein irreduzibles univariates Polynom ueber Z in
		dense-Darstellung vom Grad n > 1.
	      - a ist ein Element des von F erzeugten Zk. und ist von
		folgender Form:
		a = 0                           ,falls a = 0.
		a = ( HNa, r, ar, ..., a0 )     ,sonst.
	      - Fuer a ungleich 0 muss gelten:
		      - HNa ist positive ganze Zahl.
		      - ( r, ar, ..., a0 ) ist univariates Polynom vom
			Grad r < n ueber Z.
		      - ggt( HNa, ar, ..., a0 ) = 1.
	ACHTUNG: Bei a = 0 ist n < 0 nicht erlaubt!
	-------
	C = a^n , berechnet wird also a^n in dem von F erzeugten Zk..



			nffielddiscr( F )

	"number field, field discriminant"	
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list nffielddiscr(F)  pol F;
	L = nffielddiscr(F);
	F ist ein normiertes, irreduzibles Polynom in einer Veraenderlichen
	ueber den ganzen Zahlen mit einem Grad groesser als 1.
	F muss in dense Darstellung gegeben sein.
	Sei z eine Nullstelle von F und K = Q(z) entstehe durch Adjunktion
	von z an den Koerper der rationalen Zahlen.
	L = ( p_1, e_1, ..., p_r, e_r ) ist die Faktor-Exponent-Liste der
	Koerperdiskriminante d_K von K, d.h. d_K = p_1^e_1 * ... * p_r^e_r.
	Speziell bei Koerperdiskriminante 1 ist L die leere Liste.



			nfinv( F, a )

	"number field inverse"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfinv(F,a)         pol F; nfel a;
	b = nfinv(F,a);
	Dabei muss gelten:
	      - F ist ein univariates irreduzibles Polynom ueber Z in
		dense-Darstellung vom Grad r >= 1, das den Zk K erzeugt.
	      - a wird als Element von K repraesentiert durch ein Poly-
		nom ueber Z in einer Variablen vom Grad < r in dense-
		Darstellung sowie durch einen positiven ganzen Haupt-
		nenner HNa.
	      - a ist ungleich 0!
	Damit hat a folgende Gestalt:
		  a = ( HNa, s, as, ..., a0 )
			mit HNa , as, ...,as aus Z und HNa > 0;
			    ggt( HNa, as, ..., a0 ) = 1,
			    s < r.
	b = a^(-1), das multiplikativ Inverse von a in K und ist genau-
	so dargestellt wie a.



			nfipdeclaw( F, P )

	"number field, integer prime decomposition law"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list nfipdeclaw( F, P )  pol F; int P;
	L = nfipdeclaw( F, P );
	F ist ein normiertes, irreduzibles Polynom in einer Veraenderlichen
	ueber den ganzen Zahlen mit einem Grad groesser als 1.
	F muss in dense-Darstellung gegeben sein.
	P ist eine Primzahl.
	Sei z eine Nullstelle von F, und K = Q(z) entstehe durch Adjunktion
	von z an den Koerper der rationalen Zahlen.
	L = (e_1, f_1, ..., e_r, f_r ) ist eine Liste von singles (r > 0),
	so dass in O, dem Ring der ganzen Zahlen in K, das von P erzeugte
	Ideal die Zerlegung (P) = P_1 ^ e_1 * ... * P_r ^ e_r besitzt,
	wobei fuer 1 <= i <= r jeweils P_i ein Primideal in O ist.
	K_(P_i) (der Restklassenkoerper O modulo P_i) hat Grad f_i ueber
	dem Primkoerper der Charakteristik P.
	M.a.W. ist L die Liste der Verzweigungsindizes und der zugehoerigen
	Restklassengrade.



			nfneg( F, a )

	"number field element negation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfneg( F,a )               pol F; nfel a;
	c = nfneg( F,a );
	Es muss gelten :
	      _ F ist ein irreduzibles Polynom ueber Z in einer Variablen
		in dense-Darstellung, das einen Zahlkoerper K erzeugt.
	      - a hat als Element von K die Form:
		a = ( HNa,r, ar, ...,a0 )
		a = 0, falls a = 0
	      - HNa ist ganze positive Zahl.
	      - ( r,ar, ...,a0 ) ist Polynom in dense-Darstellung ueber
		Z in einer Variablen vom Grad r.
	      - ggt( HNa, ar, ..., a0 ) = 1
	c = -a, das additiv Inverse von a.



			nfnorm( F, a )

	"number field element norm"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	rat nfnorm( F, a )  pol F; nfel a;
	N = nfnorm( F, a );
        F ist ein normiertes irreduzibles Polynom ueber Z in einer
	Variablen in dense-Darstellung.
	Sei z eine Nullstelle dieses Polynoms und K := Q(z) = Q[z] der
	Zahlkoerper, der durch Adjunktion der Nullstelle z an Q entsteht.
	a repraesentiert ein Element aus K. Dabei ist a das Nullatom, falls
	die Null darzustellen ist; sonst ist a = ( h, r, ar, ..., a0 ),
	wobei h	eine positive ganze Zahl und ( r, ar, ..., a0 ) ein dense-
	Polynom ueber Z	ist mit r < Grad(F). Weiterhin gilt
	ggT( h, ar, ..., a0 ) = 1. a repraesentiert in diesem Fall das
	Zahlkoerperelement (1/h) * ( ar * z^r + ..... + a1 * z + a0 ).
	N ist eine rationale Zahl und entspricht der Norm von a bzgl. K/Q.



			nfprod( F, a, b )

	"number field element product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfprod( F, a, b )     pol F; nfel a,b;
	c = nfprod( F, a, b );
	Es muss gelten:
	      - F ist ein irreduzibles Polynom ueber Z in einer Variab-
		len vom Grad r >= 1 in dense-Darstellung, das einen Zk.
		K erzeugt.
	      - a und b sind als Elemente des Zk. K von der Form:
		a = ( HNa, s, as, ..., a0 )
		a = 0, falls a = 0.
		b = ( HNb, t, bt, ..., b0 )
		b = 0, falls b = 0.
	      - HNa und HNb sind ganze positive Zahlen.
	      - (s,as, ..., a0) und (t,bt, ..., b0) sind Polynome ueber
		Z in einer Variablen vom Grad s, t in dense-Darstellung.
	      - ggt( HNa, as, ..., a0 ) = 1 und
		ggt( HNb, bt, ..., b0 ) = 1
	      - s,t < r.
	c ist das Produkt von a und b.



			nfquot( F, a, b )

	"number field quotient"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfquot( F, a, b )  pol F; nfel a,b;
	c = nfquot( F, a, b );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom ueber Z in einer Variab-
		len vom Grad r >= 1 in dense-Darstellung, das den ZK
		K erzeugt.
	      - a und b werden als Elemente von K repraesentiert durch
		Polynome ueber Z in einer Variablen vom Grad < r in
		dense-Darstellung und durch positive ganze Hauptnenner
		HNa bzw. HNb.
		a = ( HNa, s, as, ..., a0 )
		      mit HNa, as, ..., a0 aus Z,
			  HNa > 0
			  ggt( HNa, as, ..., a0 ) = 1,
			  s < r.
		a = 0, falls a = 0.
		b analog, aber:
	      - b ist ungleich 0!
	c = a * b^( -1 ) ist der Quotient von a und b im ZK K, und wird
	auch genauso wie a und b dargestellt.



			nfsdif( F, a, b )               (MACRO)

	"number field, sparse representation, difference"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfsdif(F,a,b)  pol F; nfel a,b;
	c = nfsdif(F,a,b);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		a und b sind Elemente aus dem durch F gegebenen Zahl-
		koerper, die als Polynome vom Grad < Grad(F) in einer
		Variable ueber den rationalen Zahlen dargestellt sind
		(sparse-Darstellung).
	c ist die Differenz von a und b in dem durch F gegebenen
	Zahlkoerper und ist genauso dargestellt wie a und b.



			nfsinv( F, a )

	"number field, sparse representation, inverse"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfsinv(F,a)  pol F; nfel a;
	b = nfsinv(F,a);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		a ist ein Element ungleich 0 aus dem durch F gegebenen
		Zahlkoerper, das als Polynom ungleich 0 vom Grad < Grad(F)
		in einer Variable ueber den rationalen Zahlen dargestellt
		ist (sparse-Darstellung).
	b ist das multiplikativ Inverse von a in dem durch F gegebenen
	Zahlkoerper und ist genauso dargestellt wie a.



			nfsneg( F, a )                  (MACRO)

	"number field, sparse representation, negation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfsneg(F,a)  pol F; nfel a;
	b = nfsneg(F,a);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		a ist ein Element aus dem durch F gegebenen Zahlkoerper,
		das als Polynom vom Grad < Grad(F) in einer Variable ueber
		den rationalen Zahlen dargestellt ist (sparse-Darstellung).
	b ist das additiv Inverse von a in dem durch F gegebenen
	Zahlkoerper und ist genauso dargestellt wie a.



			nfsnegf( F, a )

	"number field, sparse representation, negation as function"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfsnegf(F,a)  pol F; nfel a;
	b = nfsnegf(F,a);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		a ist ein Element aus dem durch F gegebenen Zahlkoerper,
		das als Polynom vom Grad < Grad(F) in einer Variable ueber
		den rationalen Zahlen dargestellt ist (sparse-Darstellung).
	b ist das additiv Inverse von a in dem durch F gegebenen
	Zahlkoerper und ist genauso dargestellt wie a.
	Liefert das gleiche Ergebnis wie das Macro nfsneg.



			nfspdeclaw( F, p )

	"number field, single prime decomposition law"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list nfspdeclaw( F, p )  pol F; single p;
	L = nfspdeclaw( F, p );
	F ist ein normiertes, irreduzibles Polynom in einer Veraenderlichen
	ueber den ganzen Zahlen mit einem Grad groesser als 1.
	F muss in dense-Darstellung gegeben sein.
	p ist eine single Primzahl.
	Sei z eine Nullstelle von F und K = Q(z) entstehe durch Adjunktion
	von z an den Koerper der rationalen Zahlen.
	L = (e_1, f_1, ..., e_r, f_r ) ist eine Liste von singles (r > 0),
	so dass in O, dem Ring der ganzen Zahlen in K, das von p erzeugte
	Ideal die Zerlegung (p) = P_1 ^ e_1 * ... * P_r ^ e_r besitzt,
	wobei fuer 1 <= i <= r jeweils P_i ein Primideal in O ist.
	K_(P_i) (der Restklassenkoerper O modulo P_i) hat Grad f_i ueber
	dem Primkoerper der Charakteristik p.
	M.a.W. ist L die Liste der Verzweigungsindizes und der zugehoerigen
	Restklassengrade.



			nfsprod( F, a, b )

	"number field, sparse representation, product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfsprod(F,a,b)  pol F; nfel a,b;
	c = nfsprod(F,a,b);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		a und b sind Elemente aus dem durch F gegebenen Zahl-
		koerper, die als Polynome vom Grad < Grad(F) in einer
		Variable ueber den rationalen Zahlen dargestellt sind
		(sparse-Darstellung).
	c ist das Produkt von a und b in dem durch F gegebenen Zahlkoerper
	und ist genauso dargestellt wie a und b.



			nfsquot( F, a, b )

	"number field, sparse representation, quotient"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfsquot(F,a,b)  pol F; nfel a,b;
	c = nfsquot(F,a,b);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		a und b sind Elemente aus dem durch F gegebenen Zahl-
		koerper, die als Polynome vom Grad < Grad(F) in einer
		Variable ueber den rationalen Zahlen dargestellt sind
		(sparse-Darstellung).
		b ist ungleich 0.
	c ist der Quotient von a und b in dem durch F gegebenen Zahl-
	koerper und ist genauso dargestellt wie a und b.



			nfssum( F, a, b )               (MACRO)

	"number field, sparse representation, sum"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfssum(F,a,b)  pol F; nfel a,b;
	c = nfssum(F,a,b);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		a und b sind Elemente aus dem durch F gegebenen Zahl-
		koerper, die als Polynome vom Grad < Grad(F) in einer
		Variable ueber den rationalen Zahlen dargestellt sind
		(sparse-Darstellung).
	c ist die Summe von a und b in dem durch F gegebenen Zahlkoerper
	und ist genauso dargestellt wie a und b.



			nfssumf( F, a, b )

	"number field, sparse representation, sum as function"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfssumf(F,a,b)  pol F; nfel a,b;
	c = nfssumf(F,a,b);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		a und b sind Elemente aus dem durch F gegebenen Zahl-
		koerper, die als Polynome vom Grad < Grad(F) in einer
		Variable ueber den rationalen Zahlen dargestellt sind
		(sparse-Darstellung).
	c ist die Summe von a und b in dem durch F gegebenen Zahlkoerper
	und ist genauso dargestellt wie a und b.
	Liefert das gleiche Ergebnis wie das Macro nfssum.



			nfsum( F, a, b )

	"number field element sum"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel nfsum( F, a, b )           pol F; nfel a,b;
	c = nfsum( F, a, b );
	Es muss gelten:
	      - F ist ein irreduzibles Polynom ueber Z in einer Variablen
		in dense-Darstellung, das einen Zk. K erzeugt.
	      - a und b sind als Elemente aus K von der Form:
		a = ( HNa, r, ar, ..., a0 )
		a = 0, falls a = 0.
		b = ( HNb, r', br', ..., b0 )
		b = 0, falls b = 0.
	      - HNa und HNb sind ganze positive Zahlen.
	      - (r,ar, ..., a0) und (r',br', ..., b0) sind Polynome ueber Z
		in einer Variablen vom Grad r bzw. r' in dense-Darstellung.
	      - ggt( HNa, ar, ..., a0 ) = 1 und
		ggt( HNb, br', ..., b0 ) = 1
	c = a+b, die Summe von a und b.



			nftrace( F, a )

	"number field element trace"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	rat nfnorm( F, a )  pol F; nfel a;
	S = nfnorm( F, a );
        F ist ein normiertes irreduzibles Polynom ueber Z in einer
	Variablen in dense-Darstellung.
	Sei z eine Nullstelle dieses Polynoms und K := Q(z) = Q[z] der
	Zahlkoerper, der durch Adjunktion der Nullstelle z an Q entsteht.
	a repraesentiert ein Element aus K. Dabei ist a das Nullatom, falls
	die Null darzustellen ist; sonst ist a = ( h, r, ar, ..., a0 ),
	wobei h	eine positive ganze Zahl und ( r, ar, ..., a0 ) ein dense-
	Polynom ueber Z	ist mit r < Grad(F). Weiterhin gilt
	ggT( h, ar, ..., a0 ) = 1. a repraesentiert in diesem Fall das
	Zahlkoerperelement (1/h) * ( ar * z^r + ..... + a1 * z + a0 ).
	S ist eine rationale Zahl und entspricht der Spur von a bzgl. K/Q.



			normelpruspi( P, a )

	"norm of an element of the polynomial ring of an univariate
	separable polynomial over the integers"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	int normelpruspi( P, a )  pol P, a;
	N = normelpruspi( P, a );
	P ist ein normiertes, separables Polynom in einer Veraenderlichen
	ueber den ganzen Zahlen von positivem Grad.
	Sei z eine Nullstelle dieses Polynoms und K := Q(z) = Q[z] sei die
	separable Algebra ueber den rationalen Zahlen, die durch Adjunktion
	dieser Nullstelle an die rationalen Zahlen entsteht.
	a sei ein Element des Polynomrings Z[z] in K und wird durch ein
	Polynom in einer Veraenderlichen ueber den ganzen Zahlen mit
	einem Grad kleiner als der Grad des definierenden Polynoms P
	repraesentiert.
	N ist eine ganze Zahl und entspricht der Norm von a bzgl. K / Q.



			oibasisfgen( F, L )

	"order over the integers basis from generators"
	Quellbibliothek : srclib.arith2
	Include - Datei : _arith2.h
	list oibasisfgen(F,L) pol F; list L;
	M = oibasisfgen(F,L);
	F ist das definierende Polynom einer separablen Algebra ueber 
        den rationalen Zahlen, d.h. F ist ein normiertes, separables
        Polynom in einer Veraenderlichen ueber den ganzen Zahlen.
	L ist eine nicht leere Liste von CD - Polynomen ueber den
	rationalen Zahlen, die Elemente dieser Algebra repraesentieren
	( siehe cdprfcl ).
	Sei n der Grad des definierenden Polynoms und a das Element, das
	dem ersten Polynom der Liste L entspricht, dann muessen die 
	Elemente 1, a, a^2, ..., a^(n-1) linear unabhaengig ueber Z sein.
	M ist eine CD - Matrix ueber den rationalen Zahlen.
	Die Zeilen von M entsprechen als "coefficient list" Elementen
	der Algebra.
	Diese Elemente bilden eine Basis in Hermite - Normal - Form
	der Z - Ordnung, die von den Elementen, die den Polynomen aus L
	entsprechen, ueber Z erzeugt wird ( siehe cdmarid ).



			oprmsp1basfg( p, F, L )

	"order over polynomial ring over modular single prime,
	transcendence degree 1, basis from generators"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	list oprmsp1basfg(p,F,L) single p; pol F; list L;
	M = oprmsp1basfg(p,F,L);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x].
	L ist eine nicht leere Liste von CD-Polynomen ueber (Z/pZ)(x)
	( siehe	cdprfmsp1fcl ), die Elemente aus dieser Algebra
	repraesentieren.
	MOD sei der von diesen Elementen ueber (Z/pZ)[x] erzeugte Modul.
	Sei n der Grad des definierenden Polynoms F und a das Element,
	das dem ersten CD - Polynom der Liste L entspricht, dann muessen
	die Elemente 1, a, a^2, ..., a^(n-1) linear unabhaengig ueber
	(Z/pZ)[x] sein.
	M repraesentiert als CD-Matrix eine (Z/pZ)[x] - Basis in Hermite-
	Normal-Form von MOD ( siehe cdmarfmsp1id ).



			oupidedekmt( M, P )

	"order of an univariate polynomial over the integers, Dedekind
	maximality test"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single oupidedekmt(M,P)  int M; pol P;
	a = oupidedekmt(M,P);
	M ist eine Primzahl.
	P ist ein Polynom in einer Variablen ueber den ganzen Zahlen.
	a = 0,  falls die Polynomordnung von P M - maximal ist.
	a = 1,  falls die Polynomordnung echt enthalten ist in der
		m - maximalen Ordnung.
	(Zu Definitionen und Algorithmus siehe Diplomarbeit von
	Rudolf Boeffgen Seite 2 und 22.)



			ouspiapfgmic( p, P, k )

	"order of an univariate separable polynomial over the integers
	approximation of p-adic factorization of the defining polynomial,
	generators of p-maximal orders of the p-adic divisors of the
	defining polynomial and p-minimal polynomials of the generators"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list ouspiapfgmic( p, P, k )  single p; pol P; single k;
	L = ouspiapfgmic( p, P, k );
	Z bezeichne die ganzen und Q die rationalen Zahlen, x sei eine
	Unbestimmte ueber Q.
	p ist eine single Primzahl.
	P ist ein normiertes, separables Polynom in der Unbestimmten x
	mit Koeffizienten aus Z und Grad(P) > 1.
	k ist eine ganze Zahl > 1, so dass die kleinste Zweierpotenz
	groesser gleich 2*k noch eine single ist.
	p^k teilt nicht die reduzierte Diskriminante von P ( siehe
	upireddiscc ).
	Dann ist L eine Liste der Form ( L_1, ... , L_r), r eine positive
	ganze Zahl.
	Im Weiteren ist _i jeweils als Laufindex von 1 bis r benutzt.
	L_i sind Listen der Form ( F_i, a_i, mp_i ).
	Die F_i sind Polynome in der Unbestimmten x ueber Z mit positiven
	Graden und es gilt: P = F_1 * ... * F_r mod p^(2*k).
	Die Koeffizienten von F_i liegen in [0,p^(2*k)-1].
	Sei P = P_1 * ... * P_s die Faktorisierung von P ueber den
	p-adischen ganzen Zahlen, dann ist r = s und bei geeigneter
	Numerierung ist P_i kongruent zu F_i modulo p^(2*k).
	Es sei K_i := Q(x) / ( F_i * Q(x) ).           
	a_i bezeichne jeweils ein Element aus K_i, so dass Z[a_i] eine
	p-maximale Ordnung in K_i ist, dabei wird a_i durch ein CD-Polynom
	repraesentiert ( siehe cdprfcl ).
	Seien m_i die Minimalpolynome von a_i ueber Z, dann gilt nach
	Konstruktion der a_i, dass m_i normiert ist, Grad(m_i) = Grad(F_i),
	m_i = (mp_i)^e_i mod ( p * Z[x] ) mit positiven ganzen Zahlen e_i.
	mp_i ist dabei ein normiertes irreduzibles Polynom in einer
	Veraenderlichen ueber Z/pZ.
	Nach Konstruktion gilt: e_i = Grad(F_i) / Grad(mp_i).
!!!!!   Sei (p) das von der Primzahl p in O - dem Ring der ganzen Zahlen
	in K := Q(x) / ( P * Q(x) ) - erzeugte Hauptideal, dann besitzt
	(p) in O eine Zerlegung in r verschiedene Primideale A_i der Form:
	(p) = p * O = (A_1)^e_1 * ... (A_r)^e_r mit r und e_i wie oben.
	D.h. die zu p gehoerigen Verzweigungsindizes sind gleich e_i, die
	entsprechenden Restklassengrade f_i sind gleich Grad(mp_i).



			ouspibasisic( F, pL )

	"order of an univariate separable polynomial over the integers
	basis of the integral closure ( ORDMAX, Ordmax, ordmax, integral
	basis )"	
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list ouspibasisic(F,pL)  pol F; list *pL;
	M = ouspibasisic(F,pL);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
	in einer Veraenderlichen ueber den ganzen Zahlen.
	Der Grad von F muss groesser gleich 2 sein.
	Dann ist M eine Liste von Polynomen in einer Veraenderlichen ueber
	den rationalen Zahlen, die Elemente dieser Algebra repraesentieren.
	Diese Elemente bilden eine Z - Basis des ganzrationalen 
	Abschlusses der Polynomordung von F in der Algebra.
	*pL ist eine Liste, die leer ist genau dann, wenn die 
	Polynomordnung von F maximal ist, d.h. mit dem ganzrationalen 
	Abschluss uebereinstimmt.
	Ansonsten hat *pL die Form (p_1,e_1, ..., p_r,e_r), wobei r eine
	positive ganze Zahl ist und fuer 1 <= i <= r ist p_i eine Primzahl
	und e_i eine positive ganze Zahl, so dass p_1 ^ e_1 * ... p_r ^ e_r
	gleich dem Index der Polynomordnung in dem ganzrationalen Abschluss
	ist.
	Angewandt wird der FORD / ZASSENHAUS - Algorithmus ROUND 4
	( siehe dazu Diplomarbeit von R. Boeffgen ).



			ouspibaslmo( F, p, Q, pk )

	"order of an univariate separable polynomial over the integers
	 basis of a local maximal over-order"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list ouspibaslmo(F,p,Q,pk)  pol F; single p; int Q; single *pk;
	M = ouspibaslmo(F,p,Q,pk);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
	in einer Veraenderlichen ueber den ganzen Zahlen.
	p ist eine single Primzahl, so dass die Polynomordnung von F
	nicht p - maximal ist. Q ist eine p - Potenz; das Produkt von Q
	mit einem beliebigen Element einer p - maximalen Ueberordnung der
	Polynomordnung von F liegt in der Polynomordnung.
	M ist eine CD - Matrix, deren Zeilen jeweils als "coefficient list"
	CD - Polynomen ueber den rationalen Zahlen entsprechen.
	Die CD - Polynome wiederrum repraesentieren Elemente obiger Algebra
	( siehe cdprfcl und cdmarid ).
	Diese Elemente bilden eine Z - Basis der p - maximalen Ueberordnung
	der Polynomordung von F in der Algebra.
	Der Index der Polynomordnung in der p - maximalen Ueberordnung ist
	gleich p ^ (*pk), d.h. *pk ist eine positive single.	
	Angewandt wird der FORD / ZASSENHAUS - Algorithmus ROUND4
	( siehe dazu Diplomarbeit von R. Boeffgen ).



			ouspibaslmoi( F, P, Q, pk )

	"order of an univariate separable polynomial over the integers
	basis of a local maximal over-order with respect to integer primes"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list ouspibaslmoi(F,P,Q,pk)  pol F; int P,Q; single *pk;
	M = ouspibaslmoi(F,P,Q,pk);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
	in einer Veraenderlichen ueber den ganzen Zahlen.
	P ist eine Primzahl, so dass die Polynomordnung von F
	nicht P - maximal ist. Q ist eine P - Potenz; das Produkt von Q
	mit einem beliebigen Element einer P - maximalen Ueberordnung der
	Polynomordnung von F liegt in der Polynomordnung.
	M ist eine CD - Matrix, deren Zeilen jeweils als "coefficient list"
	CD - Polynomen ueber den rationalen Zahlen entsprechen.
	Die CD - Polynome wiederrum repraesentieren Elemente obiger Algebra
	( siehe cdprfcl und cdmarid ).
	Diese Elemente bilden eine Z - Basis der P - maximalen Ueberordnung
	der Polynomordung von F in der Algebra.
	Der Index der Polynomordnung in der P - maximalen Ueberordnung ist
	gleich P ^ (*pk), d.h. *pk ist eine positive single.	
	Angewandt wird der FORD / ZASSENHAUS - Algorithmus ROUND4
	( siehe dazu Diplomarbeit von R. Boeffgen ).



			ouspprmsp1bl( p, F, P, Q, pk )

	"order of an univariate separable polynomial over polynomial
	ring over modular single prime, transcendence degree 1, basis
	of a local maximal over-order"	
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	list ouspprmsp1bl(p,F,P,Q,pk)  single p; pol F,P,Q; single *pk;
	M = ouspprmsp1bl(p,F,P,Q,pk);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x].
	P ist ein normiertes, irreduzibles Polynom aus (Z/pZ) [x] und
        Q ist eine Potenz von P.
	Das Produkt von Q mit einem beliebigen Element der P - maximalen
	Ueberordnung der Polynomordnung von F liegt in der Polynomordnung.
	Die Polynomordnung von F ist nicht P - maximal.
	M ist eine CD - Matrix, deren Zeilen CD - Polynome und diese
	wiederrum Elemente obiger Algebra repraesentieren ( siehe
	cdprfmsp1fcl und cdmarfmsp1id ), so dass diese Elemente eine
	(Z/pZ) [x] - Basis der P - maximalen Ueberordnung der Polynomordung
	von F darstellen.
	Der Index der Polynomordnung in der P - maximalen Ueberordnung ist
	gleich P ^ (*pk), d.h. *pk ist eine positive single.	
	Angewandt wird der FORD / ZASSENHAUS - Algorithmus ROUND4.



			ouspprmsp1dl( p, F, P, k )

	"order of a univariate separable polynomial over polynomial
	ring over modular single prime, transcendence degree 1, 
	decomposition law"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	list ouspprmsp1dl(p, F, P, k)  single p; pol F,P; single k;
	L = ouspprmsp1dl(p, F, P, k);
	p ist eine single Primzahl.
	R bezeichne den Polynomring (Z/pZ) [x], wobei x eine Unbestimmte
	ueber Z/pZ sei.
	K bezeichne den rationalen Funktionenkoerper (Z/pZ) (x).
	F ist ein normiertes, separables Polynom in der Unbestimmten y
	ueber R mit Grad(F) > 1.
	P ist ein normiertes Primpolynom aus R.
	k ist eine ganze Zahl > 1; sei t die kleinste Zweierpotenz
	groesser gleich 2*k, so muss t * deg(P) noch single sein.
	P^k teilt nicht die reduzierte Diskriminante von F
	(siehe upprmsp1redd).
	L = (L_1, ..., L_r) ist eine Liste mit einer positiven single r.
	Im Weiteren ist _i jeweils als Laufindex von 1 bis r benutzt.
	L_i sind Listen der Form ( F_i, a_i, mp_i ).
	Die F_i sind normierte Polynome in der Unbestimmten y ueber R
	mit positiven Graden, und es gilt: F = F_1 * ... * F_r mod P^(2*k).
	Die Koeffizienten der F_i haben Grade, die kleiner sind als
	2 * k * deg(P).
	Ueber der vollstaendigen Huelle von K bezueglich der durch
	die P-adische Bewertung v_P gegebenen Abstandsfunktion sei
	F = P_1 * ... * P_s in normierte irreduzible Polynome faktorisiert,
	dann ist r = s und bei geeigneter Numerierung ist P_i kongruent
	zu F_i modulo P^(2*k), genauer gesagt hat die Differenz aus P_i
	und dem homomorphen Bild von F_i in der vollstaendigen Huelle
	v_P - Wert groesser gleich 2 * k.
	Sei nun K_i := K[y] / ( F_i * K[y] ).           
	a_i bezeichne jeweils ein Element aus K_i, so dass R[a_i] eine
	P-maximale Ordnung in K_i ist, dabei wird a_i durch ein CD-Polynom
	repraesentiert (siehe cdprfmsp1fcl).
	Seien m_i die Minimalpolynome von a_i ueber R, dann gilt nach
	Konstruktion der a_i, dass m_i normiert ist, Grad(m_i) = Grad(F_i),
	m_i = (mp_i)^e_i mod ( P * R[y] ) mit positiven ganzen Zahlen e_i.
	mp_i ist dabei ein normiertes irreduzibles Polynom in y ueber
	R / ( P * R ) [ isomorph zu GF( p^( Grad(P)) ) ].
	Nach Konstruktion gilt: e_i = Grad(F_i) / Grad(mp_i).
	Sei (P) das von dem Primpolynom P in O - dem Ring der ganzen
	Elemente in K[y] / ( F * K[y] ) - erzeugte Hauptideal, dann besitzt
	(P) in O eine Zerlegung in r verschiedene Primideale A_i der Form:
	(P) = P * O = (A_1)^e_1 * ... (A_r)^e_r mit r und e_i wie oben.
!!!!!!  Die Verzweigungsindizes von P in K[y] / ( F * K[y] ) sind gleich
	e_i und die Restklassengrade f_i sind gleich Grad(mp_i).



			ouspprmsp1dm( p, P, F )

	"order of an univariate separable polynomial over polynomial ring
	over modular single prime, transcendence degree 1, Dedekind
	maximality test"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	single ouspprmsp1dm(p,P,F) single p; pol P,F;
	a = ouspprmsp1dm(p,P,F);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	P ist ein irreduzibles, normiertes Polynom positiven Grades
	aus (Z/pZ) [x] - dem Polynomring in x ueber Z/pZ.
	F ist ein normiertes, separables Polynom in einer Unbestimmten
	ueber (Z/pZ) [x] vom Grad groesser 1.
	a = 0,  falls die Polynomordnung von F ueber (Z/pZ) [x]
		P - maximal ist.
	a = 1,  falls die Polynomordnung echt enthalten ist in der
		P - maximalen Ordnung.



			ouspprmsp1ib( p, F, pL )

	"order of an univariate separable polynomial over the polynomial
	ring over modular single prime, transcendence degree 1, integral
	basis"	
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	list ouspprmsp1ib(p,F,pL) single p; pol F; list *pL;
	M  = ouspprmsp1ib(p,F,pL);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x].
	Sei I der ganzrationale Abschluss der Polynomordnung von F in
	obiger Algebra.
	M ist eine Liste von Polynomen in einer Unbestimmten ueber
	(Z/pZ) (x), deren Grade kleiner sind als der Grad von F und die
	Elemente der Algebra repraesentieren, so dass diese Elemente
	eine (Z/pZ) [x] - Basis von I bilden. *pL ist die leere Liste,
	wenn die Polynomordnung von F maximal ist, d.h. gleich I ist.
	Ansonsten ist *pL = ( P_1, e_1, ..., P_r, e_r ), wobei r eine
	positive ganze Zahl ist, fuer 1 <= i <= r ist P_i ein Primpolynom
	aus (Z/pZ) [x] und e_i eine positive ganze Zahl,
	so dass (P_1)^(e_1) * ... * (P_r)^(e_r) gleich dem Index der
	Polynomordnung in I ist.
	Angewandt wird der FORD / ZASSENHAUS - Algorithmus ROUND 4



			pfaval( p, a )

	"p-adic field additive valuation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	int pfaval( p,a )       single p; pfel a;
	w = pfaval( p,a );
	Es muss gelten :
	      - p ist single-prime.
	      - a ist ungleich Null, wobei gilt:
	      - A sei Element des p-adischen Zahlkoepers Qp mit einer
		Approximation a vom Grad d aus Qp, fuer die bzgl der
		additiven p-adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0       und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d )          ,sonst.
	w = vp( A ) = vp( a ).



			pfdif( p, a, b )

	"p-adic field element difference"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel pfdif( p, a, b )   single p; pfel a,b;
	c = pfdif( p, a, b );
	Es muss gelten :
	      - p ist single-prime.
	      - A bzw B sei Element des p-adischen Zahlkoepers Qp mit
		einer Approximation a bzw b vom Grad d bzw. d' aus Qp,
		fuer die bzgl der additiven p-adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0       und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d )          ,sonst.
		bzw analog fuer
			  vp( B - b ) >= d'
	      - b = 0                     ,falls b = 0 oder alle b_i = 0
		    ( d',vp( B ), b_vp( B ), ..., b_d')          ,sonst.
	c = a - b ist die Differenz von a und b, die fuer A - B den er-
		sten min( d,d' ) + 1 - vp( A - B ) Stellen entspricht.



			pfeliprod( p, a, i )

	"p-adic field element integer product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel pfeliprod( p, a, i )  single p; pfel a; int i;
	c = pfeliprod( p, a, i );
	Es muss gelten :
	      - p ist Primzahl.
	      - A sei Element des p-adischen Zahlkoepers Qp mit einer
		Approximation a aus Qp, fuer die bzgl der additiven
		p-adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0       und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		( d, vp( A ), a_vp( A ), ..., a_d )              ,sonst.
	c = a * i.



			pfelrprod( p, a, R )

	"p-adic field element rational number product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel pfelrprod( p, a, R )  single p; pfel a; rat R;
	c = pfelrprod( p, a, R );
	Es muss gelten :
	      - p ist Primzahl.
	      - A sei Element des p-adischen Zahlkoepers Qp mit einer
		Approximation a aus Qp, fuer die bzgl der additiven
		p-adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0       und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		( d, vp( A ), a_vp( A ), ..., a_d )              ,sonst.
	c = a * R.



			pfexp( p, a, n )

	"p-adic field element exponentiation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel pfexp( p, a, n )        single p,n; pfel a;
	c = pfexp( p, a, n );
	Dabei muss gelten:
	      - p ist single-prime.
	      - A sei Element des p-adischen Zahlkoerpers Qp mit einer
		Approximation a aus Qp, fuer die bzgl. der additiven p-
		adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0      und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d ),          sonst.
	c = a^n ist die n-te Potenz von a in Qp, die Approximation der
		 n-ten Potenz von A.
	ACHTUNG: a = 0 und n < 0 nicht erlaubt!
	-------  Bei a = 0 und n < 0 fuer die p-Approximation von A kann
		 die n-te Potenz von a nicht berechnet werden.



			pfinv( p, a )

	"p-adic field element inverse"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel pfinv( p,a )                single p; pfel a;
	c = pfinv( p,a );
	Dabei muss gelten:
	      - p ist single-prime.
	      - A sei Element des p-adischen Zahlkoerpers Qp mit einer
		Approximation a aus Qp, fuer die bzgl. der additiven p-
		adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0      und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_i, ..., a_d ),                sonst.
	c = a^-1 ist das multiplikative Inverse von a in Qp mit Genauig-
		 keit( sgrad ) d.
	ACHTUNG: Bei a = 0 fuer die p-Approximation von A kann die Ap-
	-------  proximation fuer 1/A nicht berechnet werden.



			pfneg( p, a )

	"p-adic field element negation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel pfneg( p,a )       single p; pfel a;
	c = pfneg( p,a );
	Es muss gelten :
	      - p ist single-prime.
	      - A sei Element des p-adischen Zahlkoepers Qp mit einer
		Approximation a vom Grad d aus Qp, fuer die bzgl. der
		additiven p-adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0       und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d )          ,sonst.
	c = -a ist das additiv Inverse von a, das ebenfalls fuer d >=
	      vp( A ) den ersten d+1-vp(A) Stellen von -A entspricht.



			pfpprod( p, a, i )

	"p-adic field element prime power product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel pfpprod( p, a, i )         single p,i; pfel a;
	c = pfpprod( p, a, i );
	Dabei muss gelten:
	      - A sei Element eines p-adischen Zahlkoerpers Qp mit einer
		Approximation a aus Qp, fuer die bzgl. der additiven
		p-adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0      und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d ),         sonst.
	c = p^i * a ist das Produkt von a und p^i in Qp, als Approxima-
		tion von p^i * A.



			pfprod( p, a, b )

	"p-adic field element product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel pfprod( p,a , b )          single p; pfel a,b;
	c = pfprod( p, a, b );
	Es muss gelten :
	      - p ist single-prime.
	      - A bzw B sei Element des p-adischen Zahlkoepers Qp mit
		einer Approximation a bzw b aus Qp, fuer die bzgl der
		additiven p-adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0       und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d )          ,sonst.
		bzw analog fuer
			  vp( B - b ) >= d'
		b = 0                     ,falls b = 0 oder alle b_i = 0
		    ( d',vp( B ), b_vp( B ), ..., b_d')          ,sonst.
	c = a * b ist das Produkt von a und b, die fuer A * B den ersten
		vp( A ) + vp( B ) + min( d - vp( A ), d' - vp( B ) )
		Stellen entspricht.



			pfquot( p, a, b )

	"p-adic field quotient"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel pfquot( p, a, b )        single p; pfel a,b;
	c = pfquot( p, a, b );
	Dabei muss gelten:
	      - p ist single-prime.
	      - A bzw. B sei Element des p-adischen Zahlkoerpers Qp mit
		einer Approximation a bzw. b aus Qp, fuer die bzgl. der
		additiven p-adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0      und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d ),         sonst.
		bzw. analog fuer
			  vp( B - b ) >= d'
		b = 0                     ,falls b = 0 oder alle b_i = 0
		    ( d',vp( B ), b_vp( B ), ..., b_d'),          sonst.
	c = a / b ist der Quotient von a und b in Qp, als Approximation
		von A/B.
	ACHTUNG: b = 0 nicht erlaubt!
	-------  Bei b = 0 fuer die p-Approximation von B kann der Quo-
		 tient von a und b nicht berechnet werden.



			pfsum( p, a, b )

	"p-adic field element sum"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel pfsum( p, a, b )    single p; pfel a,b;
	c = pfsum( p, a, b );
	Es muss gelten :
	      - p ist single-prime.
	      - A bzw B sei Element des p-adischen Zahlkoepers Qp mit
		einer Approximation a bzw b aus Qp, fuer die bzgl der
		additiven p-adischen Bewertung vp gilt:
			  vp( A - a ) >= d
		und       a = 0                       ,falls d < vp( A )
		sonst     a = a_vp( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei     a_vp( A ) != 0       und
			  0 <= a_i <= p - 1
	      - a = 0                     ,falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d )          ,sonst.
		bzw analog fuer
			  vp( B - b ) >= d'
		b = 0                     ,falls b = 0 oder alle b_i = 0
		    ( d',vp( B ), b_vp( B ), ..., b_d')          ,sonst.
	c = a + b ist die Summe von a und b, die fuer A + B den ersten
		min( d,d' ) + 1 - vp( A + B ) Stellen entspricht.



			pirtransf( r1, P1, V1, r2, R2, V2, Vn, pV3 )

	"polynomial over the integers rational transformation"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc pirtransf(r1,P1,V1,r2,R2,V2,pV3) single r1; pol P1;   list V1;
					       single r2; rfunc R2; list V2;
					       list Vn; list *pV3;
	R3 = pirtransf(r1,P1,V1,r2,R2,V2,Vn,pV3);
	P1 ist ein Polynom in r1 (1<=r1<BASIS) Variablen ueber den
	ganzen Zahlen; 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.
	R3 ist die rationale Funktion, die entsteht, wenn in P1 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.)



			pitorfr( r, P )

	"polynomial over integers to rational function over the rationals"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc pitorfr(r,P) single r; pol P;
	R = pitorfr(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den ganzen
	Zahlen.
	R = P aufgefasst als rationale Funktion ueber den rationalen
	Zahlen.



			pmstorfmsp1( p, P )             (MACRO)

	"polynomial over modular singles to rational function over
	modular single prime, transcendence degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc pmstorfmsp1(p,P) single p; pol P;
	R = pmstorfmsp1(p,P);
	P ist ein Polynom in einer Variablen ueber Z/pZ, p Primzahl
	kleiner BASIS.
	R = P aufgefasst als rationale Funktion ueber Z/pZ.



			prrtransf( r1, P1, V1, r2, R2, V2, Vn, pV3 )

	"polynomial over the rationals rational transformation"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc prrtransf(r1,P1,V1,r2,R2,V2,pV3) single r1; pol P1; list V1;
					       single r2; rfunc R2; list V2;
					       list Vn; list *pV3;
	R3 = prrtransf(r1,P1,V1,r2,R2,V2,Vn,pV3);
	P1 ist ein Polynom in r1 (1<=r1<BASIS) Variablen ueber den
	rationalen Zahlen; 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.
	R3 ist die rationale Funktion, die entsteht, wenn in P1 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.)



			prtorfr( r, P )

	"polynomial over the rationals to rational function over the
	rationals"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc prtorfr(r,P) single r; pol P;
	R = prtorfr(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den rationalen
	Zahlen.
	R = P aufgefasst als rationale Funktion ueber den rationalen
	Zahlen.



			putcn( a, v, n )                (MACRO)

	"put complex number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h 
	single putcn( a, v, n )  complex a; single v, n;
	s = putcn( a, v, n );
        a ist eine komplexe Zahl.
	Sei Re(a)=x und Im(a)=y, also a = x+y*i (x,y reell).
        fputcn schreibt a in der Form "x + y i" auf stdout. x und y 
	werden dabei mit --> putflfx ausgegeben, wobei v die Anzahl der 
	Vorkommastellen und n die Anzahl der Nachkommastellen angibt. 
	Falls x = 0 oder y = 0, so wird "x + " bzw. " + y i" nicht aus-
	gegeben. Falls y = +/- 1, so wird nur "i" bzw. "-i" ausgegeben. 
	Beispiele (mit v = n = 1, in der Form
	  von a dargestellte komplexe Zahl: "Ausgabe"): 
	4+3*i: "4.0 + 3.0 i",     0: "0",       -i: "-i",
	-3*i :      "-3.0 i",     i: "i",     12.5: "12.5".
	Rueckgabe: 0 bei Erfolg, ERROR sonst.



			putfactl( L )                   (MACRO)

	"put factor list"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single putfactl(L)  list L;
	s = putfactl(L);
	Dabei muss gelten:
	 - L = ( p_1  e_1  p_2  e_2  ...  p_n  e_n ) 
	       int p_1, p_2, ..., p_n; single e_1, e_2, ..., e_n;
	   ist eine Liste, wie sie von 'ifel' erzeugt wird.
	putfactl gibt die Liste L folgendermassen auf stdout aus:
	      e_1      e_2   ...      e_n
	   p_1    * p_2    *     * p_n    
	Rueckgabe: s = 0 bei Erfolg, s = ERROR sonst



			putfl( f, n )                   (MACRO)

	"put floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single putfl( f, n )  floating f; single n;
	t = putfl( f, n );                              
	f wird in der gerundeten Form [-]0.z...ze[-]z...z auf stdout
	ausgegeben. Dabei steht 'e' fuer den Ausdruck "10^...". Die 'z'
	bezeichnen einzelne Ziffern zwischen 0 und 9. |n| ist die Anzahl
	der Ziffern, die hinter dem Punkt ausgegeben werden. Ist n
	negativ, werden Nullen am Mantissenende nicht ausgegeben.
	Beispiele: f = 4/99, n =  6  liefert 0.404040e-1
		   f = 4/99, n = -6  liefert 0.40404e-1    
		   f = e,    n = -14 liefert 0.2718281828459e1
		   f = e,    n = 14  liefert 0.27182818284590e1
		   f = e,    n = 11  liefert 0.27182818285e1
	t = 0 bei Erfolg, ERROR sonst.     



			putflfx( f, vk, nk )            (MACRO)

	"put floating point by fix point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single putflfx( f, vk, nk )  floating f; single vk,nk;
	t = putflfx( f, vk, nk );
	vk ist nicht negativ.     
	f wird dezimal in der gerundeten Form [-]zzz.zzz auf 
	stdout ausgegeben. Die einzelnen 'z' bezeichnen
	dabei beliebige Ziffern zwischen 0 und 9. 
	vk+1 ist die Laenge des Strings vor dem Punkt ( vk Stellen 
	fuer Ziffern und eine fuer ein eventuelles Vorzeichen ). 
	Falls weniger als vk Vorkommastellen vorhanden sind, werden 
	Blanks vorangestellt, bei mehr als vk Vorkommastellen 
	werden alle Vorkommastellen ausgedruckt.  
	| nk | ist die Anzahl der Nachkommatellen, die 
	ausgegeben werden. Ist nk < 0, werden Nullen am 
	Ende nicht ausgegeben.                          
	Beispiele ( '|' bezeichne den Anfang der Ausgabe ):
	    f = 4/99, vk = 3, nk =  3 liefert |   0.040       
	    f = 4/99, vk = 3, nk = -3 liefert |   0.04       
    	    f = e,    vk = 6, nk =  4 liefert |      2.7183 
	    f = e,    vk = 6, nk =  0 liefert |      3        
	    f = -123  vk = 3, nk =  1 liefert |-123.0
	    f =  123  vk = 3, nk =  1 liefert | 123.0
	    f =  123  vk = 2, nk =  1 liefert |123.0
	    f = 2^30, vk = 3, nk =  4 liefert |1073741824.0000
	    f = 2^30, vk = 3, nk = -4 liefert |1073741824
	t = 0 bei Erfolg, ERROR sonst.     



			putgf2el( G, a, V )             (MACRO)

	"put Galois-field with characteristic 2 element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single putgf2el(G,a,V)  obj G; gf2el a; list V;
	t = putgf2el(G,a,V);
	Voraussetzungen:
	     -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n >= 1 in der speziellen
		Bit-Darstellung (vgl. udpm2tosb). 
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	     -  a ist ein Element aus GF(2^n), das als Polynom in einer 
		Variablen ueber Z/2Z vom Grad < n in spezieller Bit-
		Notation dargestellt wird.
	     -	V ist eine 1-elementige Variablenliste.
	a wird in Polynomdarstellung (sparse) konvertiert und auf stdout
	ausgegeben.
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.



			putgfsel( p, AL, a, V )         (MACRO)

	"put Galois-field with single characteristic element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single putgfsel(p,AL,a,V)  single p; list AL,V; gfel a;
	t = putgfsel(p,AL,a,V);
	Es muss gelten : p ist eine Primzahl.
	  AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) interpretiert
	  werden (siehe gfsalgen), wobei n = llength(AL1) + 1.
	  a ist aus GF(p^n).
	  V ist eine 1-elementige Variablenliste.
	a wird auf stdout ausgegeben.
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.



			puti( A )                       (MACRO)

	"put integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single puti(A)  int A;
	t = puti( A );
	Die Zahl A wird auf stdout ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			putifel( L )                    (MACRO)

	"put integer factor exponent list"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single putifel( L )  list L;
	Es muss gelten: L ist die Faktor-Exponenten-Liste einer posi-
		tiven ganzen Zahl n. L enthaelt somit die Primfaktori-
		sierung von n.
	putifel gibt die in L enthaltene Primfaktorisierung von n auf
	die stdout aus. Bei erfolgreicher Ausgabe gibt putifel 0 zu-
	rueck, sonst ERROR.



			putli( L )                      (MACRO)

	"put list of integers"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single putli(L)  list L;
	t = putli( L );
	L ist eine Liste ganzer Zahlen.
	L wird auf stdout ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			putmi( M, A )                   (MACRO)

	"put modular integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single putmi(M,A)  int M,A;
	t = putmi(M,A);
	Es muss gelten : M > 0, A aus Z/M*Z.
	A wird auf stdout ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			putms( m, a )                   (MACRO)

	"put modular single"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single putms(m,a)  single m,a;
	t = putms(m,a);
	Es muss gelten : m > 0, a aus Z/mZ.
	a wird auf stdout ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			putnfel( F, a, V )              (MACRO)

	"put number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single putnfel( F, a, V )       pol F; nfel a; list V;
	t = putnfel( F, a, V );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		in dense-Darstellung, das einen Zahlkoerper K erzeugt.
	      - a ist ein Element von K und hat dabei folgende Form:
		a = 0                     ,falls a = 0.
		a = ( HNa, r, ar, ...,a0 ),sonst.
	      - Falls a ungleich 0 ist, gilt:
		      - HNa ist positive ganze Zahl.
		      - ( r, ar, ..., a0 ) ist univariates Polynom ueber
			Z in dense-Darstellung.
		      - ggt( HNa, ar, ..., a0 ) = 1.
	      - V ist einelementige Variablenliste.
	a wird mit gekuerzten Bruechen als Koeffizienten auf stdout aus-
	gegeben.
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.
	HINWEIS: Eine schnellere aber unuebersichtlichere Darstellung
	-------  fuer a ungleich 0 liefert putonfel( F, a, V ).



			putnfels( F, a, V )             (MACRO)

	"put number field element, sparse representation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single putnfels(F,a,V)  pol F; nfel a; list V;
	t = putnfels(F,a,V);
	Es muss gelten : F ist ein irreduzibles Polynom vom Grad >= 1 in
		einer Variable ueber den rationalen Zahlen.
		a ist ein Element aus dem durch F gegebenen Zahlkoerper,
		das als Polynom vom Grad < Grad(F) in einer Variable ueber
		den rationalen Zahlen dargestellt ist (sparse-Darstellung).
		V ist eine 1-elementige Variablenliste.
	a wird auf stdout ausgegeben.
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.



			putonfel( F, a, V )             (MACRO)

	"put original number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single putonfel( F, a, V )     pol F; nfel a; list V;
	t = putonfel( F, a, V );
	Dabei muss gelten:
	      _ F ist ein irreduzibles Polynom ueber Z in einer Variablen
		in dense-Darstellung, das einen Zahlkoerper K erzeugt.
	      - a ist ein Element von K und hat dabei folgende Form:
		a = 0                     ,falls a = 0.
		a = ( HNa, r, ar, ...,a0 ),sonst.
	      - Falls a ungleich 0 ist, gilt:
		      - HNa ist positive ganze Zahl.
		      - ( r, ar, ..., a0 ) ist univariates Polynom ueber
			Z in dense-Darstellung.
		      - ggt( HNa, ar, ..., a0 ) = 1.
	      - V ist einelementige Variablenliste.
	a wird seinem Aufbau entsprechend auf stdout ausgegeben.
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.
	HINWEIS: Eine uebersichtlichere aber zeitintensivere Darstellung
	-------  fuer a ungleich 0 liefert putnfel( F, a, V ).



			putpfel( p, a )                 (MACRO)

	"put p-adic field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel putpfel( p,a )  single p; pfel a;
	t = putpfel( p,a );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - A sei Element des p-adischenn Zahlkoerpers Qp mit einer
		Approximation a aus Qp, fuer die bzgl. der additiven p-
		adischen Bewertung vp gilt:
			vp( A - a ) >= d
		und     a = 0                        , falls d < vp( A )
		sonst   a = vp_( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei   a_vp( A ) != 0     und
			0 <= a_i <= p - 1
	      - a = 0,                   , falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d )          , sonst
	Bei korrektem Verlauf ist t = 0, ansonsten ERROR.
	ACHTUNG: a wird als Reihenentwicklung dargestellt. Wird die kuer-
	-------  zere Zifferndarstellung als Ausgabeformat gewuenscht, so
		 muss putspfel aufgerufen werden.



			putqnfel( D, a )                (MACRO)

	"put quadratic number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h 
	single putqnfel( D, a )  int D; nfel a;
	s = putqnfel( D, a );
	D ist aus Z\{0,1} und quadratfrei.
	a ist ein Element von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	putqnfel schreibt das von a dargestellte Zahlkoeperelement
	nach stdout.
	Rueckgabe: bei Erfolg 0, sonst ERROR.



			putqnffel( D, L )               (MACRO)

	"put quadratic number field element factor exponent list"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single putqnffel( D, L )  int D; list L;
	s = putqnffel( D, L )
	Es muss gelten:
	 - D ist aus Z\{0,1} und quadratfrei.
	 - L ist die Faktor-Exponenten-Liste eines Elements n des
	   quadratischen Zahlkoerpers Q(D^(1/2)), d.h. von der Form
           ( P_1  f_1  pi_1  z_1 ...   P_k  f_k  pi_k  z_k)  
	     list P_i; single f_i, z_i; nfel pi_i;
             mit Primidealen P_i, den zugehoerigen Potenzen f_i, 
	     einer zu P_i gehoerigen Ortsuniformisierenden pi_i
	     und dem Zerlegungsgesetz z_i.
	     (z_i = 0, 1 oder 2, falls die Primzahl, die von P_i auf K
	     fortgesetzt wird, traege, verzweigt bzw. zerlegt ist.)
	   Es gilt also: (n) = P_1^f_1 * ... * P_k^f_k.
	putqnffel gibt diese in L enthaltene Faktorisierung von n in
	Primideale auf stdout aus.
	Rueckgabe: 0 bei Erfolg, ERROR sonst.



			putqnfid( D, A )                (MACRO)

	"put quadratic number field ideal"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single putqnfid( D, A )  int D; list A; 
	s = putqnfid( D, A );
	Es muss gelten:
	 - D ist aus Z\{0,1} und quadratfrei.
	 - A ist ein Ideal des Ganzheitsrings O_D von Q(D^(1/2)).
        Zur Darstellung von Idealen siehe qnfidprod.
	putqnfid gibt das durch A repraesentierte Ideal auf stdout aus.
	Rueckgabe: 0 bei Erfolg, ERROR sonst.



			putr( R )                       (MACRO)

	"put rational number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single putr(R)  rat R;
	t = putr( R );
	Die Zahl R wird auf stdout ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			putrd( R, n )                   (MACRO)

	"put rational number decimal"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single putrd(R,n)  rat R; single n;
	t = putrd( R,n );
	n ist nicht negativ.
	Die Zahl R wird dezimal auf stdout ausgegeben, gerundet auf n
	Nachkommastellen. Der Rundungsfehler betraegt hoechstens
	(1/2) * 10^-n. Wird der Absolutbetrag von R aufgerundet, so
	folgt der letzten Dezimalziffer ein "-", wird der Absolutbetrag
	abgerundet, so folgt ein "+".
	t = 0 bei Erfolg, ERROR sonst.



			putrfmsp1( p, R, V )            (MACRO)

	"put rational function over modular single prime, transcendence
	degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	single putrfmsp1(p,R,V) single p; rfunc R; list V;
	a = putrfmsp1(p,R,V);
	R ist eine rationale Funktion in einer Variablen ueber Z/pZ,
	p Primzahl kleiner BASIS.
	V ist eine Liste, die den Variablennamen repraesentiert, und zwar
	in der Form:
		V = ( ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ) )
	falls der Variablenname aus den n alphanumerischen Zeichen
		Bu , BZ2 , ... , BZn
	besteht; das erste Zeichen muss immer ein Buchstabe sein.
	putrfmsp1 schreibt R auf stdout und liefert den Ergebniswert
		0          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			putrfr( r, R, V )               (MACRO)

	"put rational function over rationals"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	single putrfr(r,R,V) single r; rfunc R; list V;
	a = putrfr(r,R,V);
	R ist eine rationale Funktion in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	putrfr schreibt eine rationale Funktion in r Variablen
	ueber den rationalen Zahlen auf stdout.
	putrfr liefert den Ergebniswert
		0          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			putsi( n )                      (MACRO)

	"put single precision"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single putsi(n)  single n;
	t = putsi( n );
	n wird auf stdout ausgegeben. t = 0 bei Erfolg, ERROR sonst.



			putspfel( p, a )                (MACRO)

	"put special p-adic field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel putspfel( p,a )  single p; pfel a;
	t = putspfel( p,a );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - A sei Element des p-adischenn Zahlkoerpers Qp mit einer
		Approximation a aus Qp, fuer die bzgl. der additiven p-
		adischen Bewertung vp gilt:
			vp( A - a ) >= d
		und     a = 0                        , falls d < vp( A )
		sonst   a = vp_( A ) * p^vp( A ) + ... + a_d * p^d,
		wobei   a_vp( A ) != 0     und
			0 <= a_i <= p - 1
	      - a = 0,                   , falls a = 0 oder alle a_i = 0
		    ( d, vp( A ), a_vp( A ), ..., a_d )          , sonst
	Bei korrektem Verlauf ist t = 0.
	a wird ziffernweise ausgegeben gemaess aufsteigender Exponenten
	von p. Die Koeffizienten sind durch _ voneinander getrennt. Dabei
	wirds zur Markierung vom Uebergang negativer Exponenten zu nicht-
	negativen
		. anstatt _
	gesetzt, d. h. z.B.
		c_-1.c_0        oder    .c_0
	ACHTUNG: Wird die Reihenentwicklung als Ausgabeformat gewuenscht,
	-------  so muss putpfel aufgerufen werden.



			qffmsdcn( m, P )

	"quadratic function field over modular singles divisor 
	class number"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	int qffmsdcn(m,P)  single m; pol P;
	A = qffmsdcn(m,P);
	P ist ein quadratfreies Polynom aus Z/mZ[X], und m ist eine
	Primzahl aus [3,BASIS].
	A ist die Divisorklassenzahl des Koerpers Z/mZ(X,P^(1/2)).



			qffmsdcns1( m, P )

	"quadratic function field over modular singles divisor 
	class number subroutine 1"      
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	int qffmsdcns1(m,P)  single m; pol P;
	A = qffmsdcns1(m,P);
	P ist ein quadratfreies Polynom aus Z/mZ[X] ungleich 0 von
	ungeradem Grad, und m ist eine Primzahl aus [3,BASIS].
	A ist die Divisorklassenzahl des Koerpers Z/mZ(X,P^(1/2)).



			qffmsdcns2( m, P )

	"quadratic function field over modular singles divisor 
	class number subroutine 2"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	int qffmsdcns2(m,P)  single m; pol P;
	A = qffmsdcns2(m,P);
	P ist ein quadratfreies Polynom aus Z/mZ[X] ungleich 0 von
	geradem Grad, dessen fuehrender Koeffizient kein Quadrat in
	Z/mZ ist, und m ist eine Primzahl aus [3,BASIS].
	A ist die Divisorklassenzahl des Koerpers Z/mZ(X,P^(1/2)).



			qffmsdcns3( m, P )

	"quadratic function field over modular singles divisor
	class number subroutine 3"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	int qffmsdcns3(m,P)  single m; pol P;
	A = qffmsdcns3(m,P);
	P ist ein quadratfreies Polynom aus Z/mZ[X] ungleich 0 von
	geradem Grad, dessen fuehrender Koeffizient ein Quadrat in
	Z/mZ ist, und m ist eine Primzahl aus [3,BASIS].
	A ist die Divisorklassenzahl des Koerpers Z/mZ(X,P^(1/2)).



			qffmsfubs( m, D )

	"quadratic function field over modular singles fundamental
	unit, baby step version"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	list qffmsfubs(m,D)  single m; pol D;
	L = qffmsfubs(m,D);
	D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
	(1<m<BASIS) mit geradem Grad. m muss eine Primzahl ungleich
	2 sein.
	L ist eine Liste von zwei Polynomen E1 und E2 aus Z/mZ[X],
	fuer die E1 + E2 * D^(1/2) eine Fundamentaleinheit des reell-
	quadratischen Kongruenzfunktionenkoerpers Z/mZ(X,D^(1/2)) ist.
	Diese wird mit Hilfe des verbesserten baby step - Algorithmus
	(Kettenbruchentwicklung) mit Ausnutzung von Symmetrieeigenschaf-
	ten berechnet. Man muss nur die Haelfte der Quasi-Periode durch-
	laufen. Beendet werden kann der Algorithmus, sobald einmal zwei
	aufeinanderfolgende Pi oder normierte Qi (= QQi) gleich sind.
	HINWEIS: Eine langsamere Version des baby-step-Algorithmus
	======== ist in qffmsfuobs gegeben. 



			qffmsfuobs( m, D )

	"quadratic function field over modular singles fundamental
	unit, original version"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	list qffmsfuobs(m,D)  single m; pol D;
	L = qffmsfuobs(m,D);
	D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
	(1<m<BASIS) mit geradem Grad. m muss eine Primzahl ungleich
	2 sein.
	L ist eine Liste von zwei Polynomen E1 und E2 aus Z/mZ[X],
	fuer die E1 + E2 * D^(1/2) eine Fundamentaleinheit des reell-
	quadratischen Kongruenzfunktionenkoerpers Z/mZ(X,D^(1/2)) ist.
	Diese wird mit Hilfe des Orginal - baby step - Algorithmus
	(Kettenbruchentwicklung) ohne Ausnutzung von Symmetrien be-
	rechnet. Beendet werden kann der Algorithmus, sobald der Grad
	von Qi Null wird. Dies ist zum ersten Mal an der Quasi-Periode.
	HINWEIS: Eine schnellere Version des baby-step-Algorithmus
	======== unter Ausnutzung von Symmetrien ist in qffmsfubs
		 gegeben. 



			qffmsicggii( m, D, H, L, pIT )

        "quadratic function field over modular singles ideal class group
	generators and isomorphy type, imaginary case" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	list qffmsicggii(m, D, H, L, pIT)  single m; pol D; int H; 
				           list L, *pIT;
	LG = qffmsicggii(m, D, H, L, pIT);
	Vorausstzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein quadratfreies Polynom aus Z/mZ[X] ;
	. entweder ist Grad(D) ungerade
	  oder Grad(D) gerade und der fuehrende Koeffizient von D ist
	  kein Quadrat in der multiplikativen Gruppe von (Z/mZ), d.h. 
	  Z/mZ(X,D^(1/2)) ist ein imaginaer-quadratischer Kongruenz-
	  funktionenkoerper;
	. L =  ( (Q1,P1) , ... , (Ql,Pl) ) mit Qj, Pj aus Z/mZ[X]
	  stellt ein Repraesentantensystem der Idealklassengruppe dar.
	  ( vgl. qffmsicgri ) 
	  Dabei sind die k[x]-Erzeugnisse 
	  [ Qj, Pj + D^(1/2) ] fuer j = 1, ... , l
	  saemtliche reduzierte Ideale mit den Bedingungen: 
	  Qj | ( D - Pj^2 ) ,  sign(Qj) = 1 und
	  Grad(Pj) < Grad(Qj) <= Grad(D)/2,
	. H = Idealklassenzahl von Z/mZ(X,D^(1/2));
	Ergebnis:
	a) Falls H = 1 :  LG = L und *pIT = ();
	   Dann ist die Idealklassengruppe isomorph zu Z;
	b) Falls 1 < H = p1^m1 * p2^m2 * ... * pk^mk 
	   mit p1 < ... < pk  und mj > 0 fuer 1 <= j <= k;
	. LG = ( L1 , L2, ... , Lk ) , wobei Lj Erzeugende der Ideal-
	  klassengruppe und deren Ordnung fuer jede Primzahl pj darstellt,
	  die die Idealklassenzahl teilt, und zwar der Groesse nach 
	  geordnet. D.h. fuer 1 <= j <= k ist Lj eine Liste
	  Lj = ( ( ( - pj , - pj^mj ) I_1mj , ... , I_kmj ) , 
			 .
			 .
		 ( ( - pj , - pj^1 )  I_11  , ... , I_l1  )   )   ;
	  Dabei sind I_1mj, ... , I_k_mj, ... , I_11, ..., I_l1 reduzierte
	  Ideale, also Repraesentanten der Idealklassengruppe (vgl. qffmsicgrr
	  und qffmsicgstr ) und sind Erzeugende der zyklischen Untergruppen 
	  mit jeweils entsprechender ( und zwar positiver ) Primpotenzordnung
	  	pj^mj, ... , pj^mj, ... , pj^1, ... , pj^1 . 
	  Hinweis: Die negativen Vorzeichen wurden in den Submodulen als 
	    Markierung eingefuehrt und haben mathematisch gesehen keine
	    Bedeutung. 
	. *pIT = ( n1 , ... , ni ) stellt den Isomorphietyp der Idealklassen-
	  gruppe dar, d.h. nj sind fuer j = 1 , ... , i , ganze Zahlen, 
	  sodass die Idealklassengruppe isomorph ist zu
		( Z / n1 Z ) x ( Z / n2 Z ) x ... x ( Z / ni Z ) ,
	  und n1 <= n2 <= ... <= ni ;
	  ( insbesondere sind Mehrfachnennungen moeglich )
	Hinweis: siehe auch Diplomarbeit Bosco Weis, SB, 1986.



			qffmsicggir( m, D, d, H, L, pIT )

        "quadratic function field over modular singles ideal class group
	generators and isomorphy type, real case" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	list qffmsicggir(m, D, d, H, L, pIT)  single m; pol D,d; int H; 
		list L, *pIT;
	LG = qffmsicggir(m, D, d, H, L, pIT);
	Vorausstzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D aus Z/mZ[X] ist normiert, quadratfrei und hat geraden Grad,
	  d.h. Z/mZ(X,D^(1/2)) ist ein reell-quadratischer Kongruenz-
	  funktionenkoerper;
	. d = Hauptteil(D);
	. L = ( Ic_1, Ic_2, ... , Ic_hid ) ist ein minimales 
	  Repraesentantensystem der Idealklassengruppe;
	  ( mit Klasseneinteilung );
	  Jedes Ic_k , 1 <=k <= hid, stellt dann eine ganze Idealklasse
	  dar, wobei jedes Ic_k eine Liste ist, und es gilt:
	  Ic_k =  ( ( Q_k1 , P_k1 ) , ... , ( Q_kn , P_kn ) ) ist eine 
	  Teilmenge des gesamten Repraesentantensystems;
	  ( vgl. qffmsicgstr und qffmsicgrr )
	  Dabei sind Q_kj, P_kj Polynome aus Z/mZ[X] fuer 1 <= j <= n;
	  Es ist jedes der k[x]-Erzeugnisse 
	  [ Q_j, P_j + D^(1/2) ] fuer j = k1, ... , kn
	  ein reduziertes Ideal mit den Bedingungen: 
	  Q_j | ( D - P_j^2 ) , Grad(Q_j) < Grad(D)/2, und zudem gilt noch 
	  sign(Qj) = 1;
	. H = Idealklassenzahl von Z/mZ(X,D^(1/2));
	Ergebnis:
	a) Falls H = 1 :  LG = L und *pIT = ();
	   Dann ist die Idealklassengruppe isomorph zu Z;
	b) Falls 1 < H = p1^m1 * p2^m2 * ... * pk^mk 
	   mit p1 < ... < pk  und mj > 0 fuer 1 <= j <= k;
	. LG = ( L1 , L2, ... , Lk ) , wobei Lj Erzeugende der Ideal-
	  klassengruppe und deren Ordnung fuer jede Primzahl pj darstellt,
	  die die Idealklassenzahl teilt, und zwar der Groesse nach 
	  geordnet. D.h. fuer 1 <= j <= k ist Lj eine Liste
	  Lj = ( ( ( - pj , - pj^mj ) I_1mj , ... , I_kmj ) , 
			 .
			 .
		 ( ( - pj , - pj^1 )  I_11  , ... , I_l1  )   )   ;
	  Dabei sind I_1mj, ... , I_k_mj, ... , I_11, ..., I_l1 reduzierte
	  Ideale, also Repraesentanten der Idealklassengruppe (vgl. qffmsicgrr
	  und qffmsicgstr ) und sind Erzeugende der zyklischen Untergruppen 
	  mit jeweils entsprechender ( und zwar positiver ) Primpotenzordnung
	  	pj^mj, ... , pj^mj, ... , pj^1, ... , pj^1 . 
	  Hinweis: Die negativen Vorzeichen wurden in den Submodulen als 
	    Markierung eingefuehrt und haben mathematisch gesehen keine
	    Bedeutung. 
	. *pIT = ( n1 , ... , ni ) stellt den Isomorphietyp der Idealklassen-
	  gruppe dar, d.h. nj sind fuer j = 1 , ... , i , ganze Zahlen, 
	  sodass die Idealklassengruppe isomorph ist zu
		( Z / n1 Z ) x ( Z / n2 Z ) x ... x ( Z / ni Z ) ,
	  und n1 <= n2 <= ... <= ni ;
	  (insbesondere sind Mehrfachnennungen moeglich)
	Hinweis: siehe auch Diplomarbeit Bosco Weis, SB, 1986.



			qffmsicgrep( m, D, pHid )

        "quadratic function field over modular singles ideal 
	class group system of representatives" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	list qffmsicgrep(m,D,pHid)  single m; pol D; int *pHid;
	L = qffmsicgrep(m,D,pHid);
	Voraussetzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D aus Z/mZ[X] ist quadratfrei und hat positiven Grad, d.h. 
	  Z/mZ(X,D^(1/2)) ist ein quadratischer Kongruenzfunktionen-
	  koerper;
	Ergebnis:
 	. L =  ( ( Q1 , P1 ) , ... , ( Ql , Pl ) );
	  Qj, Pj sind Polynome aus Z/mZ[X]  fuer j = 1, ... , l;
	  L stellt ein Repraesentantensystem der Idealklassengruppe dar;
	  ( mit Klasseneinteilung )
	  Dabei sind die k[x]-Erzeugnisse 
	  [ Qj, Pj + D^(1/2) ] fuer j = 1, ... , l
	  saemtliche reduzierten Ideale mit sign(Qj) = 1;
	. *pHid = Idealklassenzahl von Z/mZ(X,D^(1/2));
	Hinweis: siehe auch Diplomarbeit Bosco Weis, SB, 1986.



			qffmsicgri( m, D, pHid )

        "quadratic function field over modular singles ideal 
	class group system of representatives, imaginary case" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	list qffmsicgri(m,D,pHid)  single m; pol D; int *pHid;
	L = qffmsicgri(m,D,pHid);
	Voraussetzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein quadratfreies Polynom aus Z/mZ[X] ;
	. entweder ist Grad(D) ungerade
	  oder Grad(D) gerade und der fuehrende Koeffizient von D ist
	  kein Quadrat in der multiplikativen Gruppe von (Z/mZ), d.h. 
	  Z/mZ(X,D^(1/2)) ist ein imaginaer-quadratischer Kongruenz-
	  funktionenkoerper;
	Ergebnis:
 	. L =  ( ( Q1 , P1 ) , ... , ( Ql , Pl ) ) ;
	  Qj, Pj sind Polynome aus Z/mZ[X]  fuer j = 1, ... , l;
	  L stellt ein Repraesentantensystem der Idealklassengruppe dar.
	  Dabei sind die k[x]-Erzeugnisse 
	  [ Qj, Pj + D^(1/2) ] fuer j = 1, ... , l
	  saemtliche reduzierten Ideale mit den Bedingungen: 
	  Qj | ( D - Pj^2 ) ,  sign(Qj) = 1 und
	  Grad(Pj) < Grad(Qj) <= Grad(D)/2,
	  Ein volles Repraesentantensystem der Idealklassengruppe ist 
	  gegeben durch alle reduzierten Ideale bei vorgeschriebener 
	  Diskriminante D ( mit obigen Bedingungen );
	. *pHid = Idealklassenzahl von Z/mZ(X,D^(1/2)); 
	Hinweis: siehe auch Diplomarbeit Bosco Weis, SB, 1986.



			qffmsicgrr( m, D, d )

        "quadratic function field over modular singles ideal 
	class group system of representatives, real case" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	list qffmsicgrr(m,D,d)  single m; pol D, d;
	L = qffmsicgrr(m,D,d);
	Voraussetzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X] mit
	  geradem Grad, d.h. Z/mZ(X,D^(1/2)) ist ein reell-quadratischer 
	  Kongruenzfunktionenkoerper;
	. d = Hauptteil(D) ist ein Polynom aus Z/mZ[X];
	Ergebnis:
 	. L =  ( ( Q1 , P1 ) , ... , ( Ql , Pl ) ) ;
	  Qj, Pj sind Polynome aus Z/mZ[X]  fuer j = 1, ... , l;
	  L stellt ein Repraesentantensystem der Idealklassengruppe dar.
	  ( ohne Klasseneinteilung ) 
	  Dabei sind die k[x]-Erzeugnisse 
	  [ Qj, Pj + D^(1/2) ] fuer j = 1, ... , l
	  saemtliche reduzierten Ideale mit den Bedingungen: 
	  Qj | ( D - Pj^2 ) , Grad(Qj) < Grad(D)/2, und zudem gilt noch 
	  sign(Qj) = 1;
	  Ein volles Repraesentantensystem der Idealklassengruppe ist 
	  gegeben durch alle reduzierten Ideale bei vorgeschriebener 
	  Diskriminante D ( mit obigen Bedingungen );
	Hinweis: siehe auch Diplomarbeit Bosco Weis, SB, 1986.



			qffmsicgsti( m, D, L )

        "quadratic function field over modular singles ideal
	class group structure, imaginary case" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	list qffmsicgsti(m, D, L)  single m; pol D; list L;
	L1 = qffmsicgsti(m, D, L);
	Vorausstzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein quadratfreies Polynom aus Z/mZ[X] ;
	. entweder ist Grad(D) ungerade
	  oder Grad(D) gerade und der fuehrende Koeffizient von D ist
	  kein Quadrat in der multiplikativen Gruppe von (Z/mZ), d.h. 
	  Z/mZ(X,D^(1/2)) ist ein imaginaer-quadratischer Kongruenz-
	  funktionenkoerper;
	. LG =  ( (Q1,P1) , ... , (Ql,Pl) ) mit Qj, Pj aus Z/mZ[X]
	  stellt ein Repraesentantensystem der Idealklassengruppe dar.
	  ( vgl. qffmsicgri ) 
	  Dabei sind die k[x]-Erzeugnisse 
	  [ Qj, Pj + D^(1/2) ] fuer j = 1, ... , l
	  saemtliche reduzierte Ideale mit den Bedingungen: 
	  Qj | ( D - Pj^2 ) ,  sign(Qj) = 1 und
	  Grad(Pj) < Grad(Qj) <= Grad(D)/2,
 	Ergebnis:
	. L = ( Ic_1, Ic_2, ... , Ic_r ) ist dann ein minimales 
	  Repraesentantensystem der Idealklassengruppe;
	  Jedes Ic_k , 1 <=k <= r, stellt dann eine ganze Teilklasse
	  dar, wobei jedes Ic_k eine Liste ist, und es gilt:
	  Ic_k =  ( ( Q_k1 , P_k1 ) , ... , ( Q_kn , P_kn ) ) ist eine 
	  Teilmenge des durch LG dargestellten Repraesentantensystems;
	  Also ist auch jedes der k[x]-Erzeugnisse 
	  [ Q_j, P_j + D^(1/2) ] fuer j = k1, ... , kn
	  ein reduziertes Ideal mit den Bedingungen: 
	  Q_j | ( D - P_j^2 ) ,  sign(Qj) = 1 und
	  Grad(Pj) < Grad(Q_j) <= Grad(D)/2, 
	Hinweis: siehe auch Diplomarbeit Bosco Weis, SB, 1986.



			qffmsicgstr( m, D, d, LG, pHid )

        "quadratic function field over modular singles ideal
	class group structure, real case" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	list qffmsicgstr(m,D,d,LG,pHid)  single m; pol D,d; 
					list LG; int *pHid;
	L = qffmsicgstr(m,D,d,LG,pHid);
	Vorausstzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X] mit
	  geradem Grad, d.h. Z/mZ(X,D^(1/2)) ist ein reell-quadratischer 
	  Kongruenzfunktionenkoerper;
	. d = Hauptteil(D) ist ein Polynom aus Z/mZ[X];
 	. LG =  ( ( Q1 , P1 ) , ... , ( Ql , Pl ) );
	  Qj, Pj sind Polynome aus Z/mZ[X]  fuer j = 1, ... , l;
	  LG stellt ein Repraesentantensystem der Idealklassengruppe dar.
	  ( ohne Klasseneinteilung, vgl. qffmsicgrr ) 
	  Dabei sind die k[x]-Erzeugnisse 
	  [ Qj, Pj + D^(1/2) ] fuer j = 1, ... , l
	  saemtliche reduzierte Ideale mit den Bedingungen: 
	  Qj |( D - Pj^2 ) , Grad(Qj) < Grad(D)/2, und zudem gilt noch 
	  sign(Qj) = 1;
 	Ergebnis:
	. L = ( Ic_1, Ic_2, ... , Ic_hid ) ist dann ein minimales 
	  Repraesentantensystem der Idealklassengruppe;
	  ( mit Klasseneinteilung );
	  Jedes Ic_k , 1 <=k <= hid, stellt dann eine ganze Idealklasse
	  dar, wobei jedes Ic_k eine Liste ist, und es gilt:
	  Ic_k =  ( ( Q_k1 , P_k1 ) , ... , ( Q_kn , P_kn ) ) ist eine 
	  Teilmenge des durch LG dargestellten Repraesentantensystems;
	  Also ist auch jedes der k[x]-Erzeugnisse 
	  [ Q_j, P_j + D^(1/2) ] fuer j = k1, ... , kn
	  ein reduziertes Ideal mit den Bedingungen: 
	  Q_j | ( D - P_j^2 ) , Grad(Q_j) < Grad(D)/2, und zudem gilt noch 
	  sign(Qj) = 1;
	. *pHid = Idealklassenzahl von Z/mZ(X,D^(1/2));
	Hinweis: siehe auch Diplomarbeit Bosco Weis, SB, 1986.



			qffmsicn( m, P )

	"quadratic function field over modular singles ideal 
	class number"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	int qffmsicn(m,P)  single m; pol P;
	A = qffmsicn(m,P);
	P ist ein quadratfreies Polynom aus Z/mZ[X], und m ist eine
	Primzahl aus [3,BASIS].
	A ist die Idealklassenzahl des Koerpers Z/mZ(X,P^(1/2)).



			qffmsipidred( m, D, Q, P, pQr, pPr )

        "quadratic function field over modular singles, imaginary 
	case, primitive ideal reduction" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	single qffmsipidred(m,D,Q,P,pQr,pPr)  single m; pol D,Q,P;
					pol *pQr,*pPr;
	a = qffmsipidred(m,D,Q,P,pQr,pPr);
	Voraussetzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein quadratfreies Polynom aus Z/mZ[X] in dense-Darstellung;
	. entweder ist Grad(D) ungerade
	  oder Grad(D) gerade und der fuehrende Koeffizient von D ist
	  kein Quadrat in der multiplikativen Gruppe von (Z/mZ), d.h. 
	  Z/mZ(X,D^(1/2))ist ein imaginaer-quadratischer Kongruenz-
	  funktionenkoerper;
	. Q, P sind Polynome aus Z/mZ[X] in dense-Darstellung, sodass das 
	  k[x]-Erzeugnis [ Q, P + D^(1/2) ] ein primitives Ideale ist. 
	  Dies bedeutet Q | ( D - P^2 );
	. sign(Q) = 1; 
	Ergebnis:
	. *pQr, *pPr sind Polynome aus Z/mZ[X] in dense-Darstellung,
	  sodass das k[x]-Erzeugnis [ *pQr , *pPr + D^(1/2) ] dann 
	  ein (primitives) reduziertes Ideal ist.
	a hat den Wert 0.



			qffmsiselic( m, D, L, Q, P )

        "quadratic function field over modular singles is element 
	of an ideal class" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	single qffmsiselic(m,D,L,Q,P)  single m; list L; pol D,Q,P;
 	a = qffmsiselic(m,D,L,Q,P);
	Voraussetzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X] mit
	  geradem Grad, d.h. Z/mZ(X,D^(1/2)) ist ein reell-quadratischer 
	  Kongruenzfunktionenkoerper;
	. Q, P sind Polynome aus Z/mZ[X], sodass das 
	  k[x]-Erzeugnis [ Q, P + D^(1/2) ] ein primitives Ideal ist, 
	  gegeben in adaptierter Form. Dies bedeutet 
	  Q | ( D - P^2 )  und  Grad(P) < Grad(Q);
	. sign(Q) = 1;
 	. L =  ( ( Q1 , P1 ) , ... , ( Ql , Pl ) ) ;
	  Qj, Pj sind Polynome aus Z/mZ[X]  fuer j = 1, ... , l;
	  L stellt eine Idealklasse dar. Dabei sind die k[x]-Erzeugnisse
	  [ Qj, Pj + D^(1/2) ] fuer j = 1, ... , l
	  primitive Ideale. Dies bedeutet Qj | ( D - Pj^2 ) , 
	  und zudem gilt: sign(Qj) = 1;
	Ergebnis:
	. a = 1, wenn die Idealgleichheit 
		 [ Q, P + D^(1/2) ] = [ Qj, Pj + D^(1/2) ] 
	         fuer ein 1 <= k <= l gilt;
	  a = 0, sonst;



			qffmsiseqids( m, D, Q1, P1, Q2, P2 )

        "quadratic function field over modular singles is equal 
	ideal special" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	single qffmsiseqids(m,D,Q1,P1,Q2,P2)  single m; pol D;
					      pol Q1,P1,Q2,P2;
	a = qffmsiseqids(m,D,Q1,P1,Q2,P2);
	Voraussetzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein quadratfreies Polynom aus Z/mZ[X], sodass 
	  Z/mZ(X,D^(1/2)) ein quadratischer Kongruenzfunktionen-
	  koerper ist;
	. Q1, P1, Q2, P2 sind Polynome aus Z/mZ[X]; 
	  die k[x]-Erzeugnisse
	  I1 = [ Q1, P1 + D^(1/2) ] und I2 = [ Q2, P2 + D^(1/2) ] 
	  sind primitive Ideale. Dies bedeutet
		Q1 | ( D - P1^2 ) und Q2 | ( D - P2^2 ) ;
	. sign(Q1) = 1 = sign(Q2); 
	. I1 ist in adaptierter Form gegeben, also
	  Grad(P1) < Grad(Q1); 
	a = 1 , wenn I1 = I2; ( Idealgleichheit )
	  = 0 , sonst;



			qffmsispidrd( m, D, Q, P, pQr, pPr )

        "quadratic function field over modular singles, imaginary
	case, sparse representation, reduction of a primitive ideal" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	single qffmsispidrd(m,D,Q,P,pQr,pPr)  single m; pol D,Q,P;
					      pol *pQr,*pPr;
	a = qffmsispidrd(m,D,Q,P,pQr,pPr);
	Voraussetzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein quadratfreies Polynom aus Z/mZ[X] ;
	. entweder ist Grad(D) ungerade
	  oder Grad(D) gerade und der fuehrende Koeffizient von D ist
	  kein Quadrat in der multiplikativen Gruppe von (Z/mZ), d.h. 
	  Z/mZ(X,D^(1/2)) ist ein imaginaer-quadratischer Kongruenz-
	  funktionenkoerper;
	. Q, P sind Polynome aus Z/mZ[X], sodass das 
	  k[x]-Erzeugnis [ Q, P + D^(1/2) ] ein primitives Ideal ist. 
	  Dies bedeutet Q | ( D - P^2 );
	. sign(Q) = 1; 
	Ergebnis:
	. *pQr, *pPr sind Polynome aus Z/mZ[X], sodass das 
	  k[x]-Erzeugnis [ *pQr , *pPr + D^(1/2) ] dann ein (primitives) 
	  reduziertes Ideal ist.
	a hat den Wert 0.



			qffmsordsici( m, D, Q, P, OS )

        "quadratic function field over modular singles
	order of one single ideal class, imaginary case" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	int qffmsordsici(m, D, Q, P, OS)  single m; pol D, Q, P; int OS;
	E = qffmsordsici(m, D, Q, P, OS);
	Voraussetzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. das k[x]-Erzeugnis [ Q, P + D^(1/2) ] ein (primitives) 
	  reduziertes Ideal, gegeben in adaptierter Form. Dies bedeutet 
	  Q | ( D - P^2 )  und  Grad(P) < Grad(Q);
	. sign(Q) = 1;
	. OS gibt eine obere Grenze fuer die Bestimmung der Ordnung der
	  Idealklasse an; 	  
	Ergebnis:
	. Ist ORD minimal mit: 
		    [ Q, P + D^(1/2) ] ^ ORD  ist aequivalent zu (1) ,
	  dann ist E = min { ORD , OS } ; 



			qffmsordsicr( m, D, d, LE, ID, OS )

        "quadratic function field over modular singles
	order of one single ideal class, real case" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	int qffmsordsicr(m,D,d,LE,ID,OS)  single m; pol D,d;
					  list LE,ID; int OS;
	E = qffmsordsicr(m,D,d,LE,ID,OS);
	Voraussetzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X] mit
	  geradem Grad, d.h. Z/mZ(X,D^(1/2)) ist ein reell-quadratischer 
	  Kongruenzfunktionenkoerper;
	. d = Hauptteil(D) ist ein Polynom aus Z/mZ[X];
	. ID = ( Q , P ) mit Q, P aus Z/mZ[X], sodass das 
	  k[x]-Erzeugnis [ Q, P + D^(1/2) ] ein (primitives) reduziertes
	  Ideal ist, gegeben in adaptierter Form. Dies bedeutet 
	  Q | ( D - P^2 )  und  Grad(P) < Grad(Q);
	. sign(Q) = 1;
 	. LE =  ( ( Q1 , P1 ) , ... , ( Ql , Pl ) );
	  Qj, Pj sind Polynome aus Z/mZ[X]  fuer j = 1, ... , l;
	  LE stellt alle  Mitglieder der Eins der Idealklassengruppe dar; 
	  Dabei sind die k[x]-Erzeugnisse 
	  [ Qj, Pj + D^(1/2) ] fuer j = 1, ... , l
	  reduzierte Ideale. Dies bedeutet 
	  Qj |( D - Pj^2 ) , Grad(Pj) < Grad(Qj), und zudem sign(Qj) = 1;
	  Die Eins wird also repraesentiert durch eine Kette von ganzen,
	  reduzierten Idealen, die alle zu (1) aequivalent sind;
	  (vgl. qffmsicggr)
	. OS gibt eine obere Grenze fuer die Bestimmung der Ordnung der
	  Idealklasse an; 	  
	Ergebnis:
	. Ist ORD minimal mit: 
		    [ Q, P + D^(1/2) ] ^ ORD  ist aequivalent zu (1) ,
	  dann ist E = min { ORD , OS } ; 



			qffmspidgenr( m, D, Q, P, G, pB )

        "quadratic function field over modular singles, principal
	ideal generating element, real case," 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmspidgenr(m, D, Q, P, G, pB)  single m; pol D, Q, P, G, *pB;
	A = qffmspidgenr(m, D, Q, P, G, pB);
	Voraussetzungen:
        . m ist Primzahl mit 2 < m < BASIS; 
	. D aus Z/mZ[X] ist normiert, quadratfrei und hat geraden Grad,
	  d.h. Z/mZ(X,D^(1/2)) ist ein reell-quadratischer Kongruenz-
	  funktionenkoerper;
	. Q, P und G sind Polynome aus Z/mZ[X], sodass das k[x]-Erzeugnis
		 I = [ Q, P + G * D^(1/2) ] 
	  ein gnzes Hauptideal ist. Dies bedeutet:
	  	(i) I ist ein Ideal, und es gibt dann Q1, P1 aus Z/mZ[X] mit
			I = (G) [ Q1, P1 + D^(1/2) ] und 
			Q1 teilt ( D - P1^2 )  .
		(ii) I = ( a )  mit a aus Z/mZ[X,D^(1/2)]
	Ergebnis:
	. A und *pB sind  Polynome aus Z/mZ[X], derart dass 
	  a = A + (*pB) * D^(1/2)  das Hauptideal I erzeugt, also
		I = ( a ) .
	Dieses Element aus Z/mZ[X,D^(1/2)] wird mittels Pseudorestzahlen
	berechnet (vgl. Diplomarbeit Bosco Weis, SB, 1986, S.121ff und 215ff).



			qffmspidpr( m, D, Q1, P1, Q2, P2, pQ, pP )

	"quadratic function field over modular singles primitive
	ideal product" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmspidpr(m,D,Q1,P1,Q2,P2,pQ,pP)  single m; pol D,Q1,P1,Q2,P2;
					pol *pQ,*pP;
        G = qffmspidpr(m,D,Q1,P1,Q2,P2,pQ,pP);
        D ist ein Polynom aus Z/mZ[X] (1<m<BASIS) in dense-Darstellung. 
	m muss eine Primzahl ungleich 2 sein, d.h. Z/mZ(X,D^(1/2)) ist
	ein quadratischer Kongruenzfunktionenkoerper. Q1,P1,Q2,P2 sind 
	Polynome aus Z/mZ[X] in dense-Darstellung.
	Die k[x]-Erzeugnisse
		 I1 = [ Q1, P1 + D^(1/2) ] 
		 I2 = [ Q2, P2 + D^(1/2) ] 
	sind primitive Ideale. Dies bedeutet
		Q1 teilt ( D - P1^2 )  und
		Q2 teilt ( D - P2^2 )  .
	G,*pQ,*pP sind dann Polynome aus Z/mZ[X] in dense-Darstellung mit
 		 I1 * I2 = (G) [ *pQ, *pP + D^(1/2) ] 
	einem ganzen Ideal. Das k[x]-Erzeugnis [*pQ,*pP+D^(1/2)] ist
	ein primitives Ideal, gegeben in adaptierter Form, und es gelten:
		- Q teilt ( D - P^2 ) ,
                - Grad(*pP) < Grad(*pQ) , 
		- sign(*pQ) = 1, d.h *pQ ist normiert ,
		- sign(G) = 1 , d.h G ist normiert.   
	Hinweis: Eine andere Version liegt durch qffmspidprs vor. Diese 
	======== eignet sich bei mehrmaligem Anwenden des Idealprodukts
		 auf das gleiche Ideal. Auch gibt es Programme zum 
		 Quadrieren eines Ideals, d.h. Idealprodukt mit sich 
		 selbst, naemlich qffmspidsqu, qffmspidsqus.



			qffmspidprs( m, D, C1, Q1, P1, Q2, P2, pQ, pP )

	"quadratic function field over modular singles primitive ideal
	product, special version"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmspidprs(m,D,C1,Q1,P1,Q2,P2,pQ,pP)  single m; pol D,C1;
					pol Q1,P1,Q2,P2; pol *pQ,*pP;
        G = qffmspidprs(m,D,C1,Q1,P1,Q2,P2,pQ,pP);
        D ist ein Polynom aus Z/mZ[X] (1<m<BASIS) in dense-Darstellung 
	m muss eine Primzahl ungleich 2 sein, d.h. Z/mZ(X,D^(1/2)) ist
	ein quadratischer Kongruenzfunktionenkoerper. C1,Q1,P1,Q2,P2  
	sind Polynome aus Z/mZ[X] in dense-Darstellung. 
 	Die k[x]-Erzeugnisse
		 I1 = [ Q1, P1 + D^(1/2) ] 
		 I2 = [ Q2, P2 + D^(1/2) ] 
	sind primitive Ideale, gegeben in adaptierter Form. Dies bedeutet
		- Q1 teilt ( D - P1^2 ) , Q2 teilt ( D - P2^2 )  
		- Grad(P1) < Grad(Q1) , Grad(P2) < Grad(Q2) , 
		- sign(Q1) = 1 = sign(Q2)
	Dabei ist
		C1 = ( D - P1^2 ) / Q1 
	ein Element aus k[x] und wurde schon vorberechnet.
	G,*pQ,*pP sind Polynome aus Z/mZ[X] in dense-Darstellung, sodass
 		 I1 * I2 = (G) [ *pQ, *pP + D^(1/2) ] 
	ein ganzes Ideal ist. Das k[x]-Erzeugnis [*pQ,*pP+D^(1/2)] ist
	ein primitives Ideal gegeben in adaptierter Form, und es gelten:
		- Q teilt ( D - P^2 ) ,
                - Grad(*pP) < Grad(*pQ) , 
		- sign(*pQ) = 1, d.h *pQ ist normiert ,
		- sign(G) = 1 , d.h G ist normiert.   
	Hinweis: Eine allgemeinere Version liegt durch qffmspidpr vor. 
 	======== Auch gibt es Programme zum Quadrieren eines Ideals,
		 d.h. Idealprodukt mit sich selbst, naemlich qffmspidsqu
		 und qffmspidsqus.



			qffmspidsqu( m, D, Q1, P1, pQ, pP )

	"quadratic function field over modular singles primitive
	ideal square" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmspidsqu(m,D,Q1,P1,pQ,pP)  single m; pol D,Q1,P1;
					pol *pQ,*pP;
        G = qffmspidsqu(m,D,Q1,P1,pQ,pP);
        D ist ein Polynom aus Z/mZ[X] (1<m<BASIS) in dense-Darstellung. 
	m muss eine Primzahl ungleich 2 sein, d.h. Z/mZ(X,D^(1/2)) ist
	ein quadratischer Kongruenzfunktionenkoerper. Q1,P1 sind 
	Polynome aus Z/mZ[X] in dense-Darstellung.
	Das k[x]-Erzeugnis
		 I1 = [ Q1, P1 + D^(1/2) ] 
	ist ein primitives Ideal. Dies bedeutet
		Q1 teilt ( D - P1^2 ) .  
	G,*pQ,*pP sind dann Polynome aus Z/mZ[X] in dense-Darstellung mit
 		 I1 * I1 = (G) [ *pQ, *pP + D^(1/2) ] 
	einem ganzen Ideal. Das k[x]-Erzeugnis [*pQ,*pP+D^(1/2)] ist
	ein primitives Ideal gegeben in adaptierter Form, und es gelten:
		- Q teilt ( D - P^2 ) ,
                - Grad(*pP) < Grad(*pQ) , 
		- sign(*pQ) = 1, d.h *pQ ist normiert ,
		- sign(G) = 1 , d.h G ist normiert.   
	Hinweis: Eine andere Version liegt durch qffmspidsqus vor. 
	=======  Allgemeinere Programme zum Idealprodukt sind gegeben
		 durch qffmspidpr, qffmspidprs.



			qffmspidsqus( m, D, C1, Q1, P1, pQ, pP )

	"quadratic function field over modular singles primitive ideal
	square, special version"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmspidsqus(m,D,C1,Q1,P1,pQ,pP)  single m;pol D,C1,Q1,P1;
					pol *pQ,*pP;
        G = qffmspidsqus(m,D,C1,Q1,P1,pQ,pP);
        D ist ein Polynom aus Z/mZ[X] (1<m<BASIS) in dense-Darstellung. 
	m muss eine Primzahl ungleich 2 sein, d.h. Z/mZ(X,D^(1/2)) ist
	ein quadratischer Kongruenzfunktionenkoerper. C1,Q1,P1 sind 
	Polynome aus Z/mZ[X] in dense-Darstellung.  Das k[x]-Erzeugnis
		 I1 = [ Q1, P1 + D^(1/2) ] 
	ist ein primitives Ideal, gegeben in adaptierter Form, also
		- Q1 teilt ( D - P1^2 ) 
		- Grad(P1) < Grad(Q1) 
		- sign(Q1) = 1 .
	Dabei ist
		C1 = ( D - P1^2 ) / Q1 
	ein Element aus k[x] und wurde schon vorberechnet. G,*pQ,*pP 
	sind dann Polynome aus Z/mZ[X] in dense-Darstellung, sodass
 		 I1 * I1 = (G) [ *pQ, *pP + D^(1/2) ] 
	ein ganzes Ideal ist. Das k[x]-Erzeugnis [*pQ,*pP+D^(1/2)] ist
	ein primitives Ideal gegeben in adaptierter Form, und es gelten:
		- Q teilt ( D - P^2 ) ,
                - Grad(*pP) < Grad(*pQ) , 
		- sign(*pQ) = 1, d.h *pQ ist normiert ,
		- sign(G) = 1 , d.h G ist normiert.   
	Hinweis: Eine andere Version liegt durch qffmspidsqus vor. 
	=======  Allgemeinere Programme zum Idealprodukt gibt es in
		 den Programmen qffmspidpr und qffmspidprs.



			qffmsreg( m, P )

	"quadratic function field over modular singles regulator"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	int qffmsreg(m,P)  single m; pol P;
	A = qffmsreg(m,P);
	P ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
	(1<m<BASIS) mit geradem Grad. m muss eine Primzahl ungleich
	2 sein.
	A ist der Regulator von Z/mZ[X,P^(1/2)].
	HINWEIS: Uraltversion. Es existieren wesentlich effizientere
		 Versionen, naemlich qffmsregbg, qffmsregbs, qffmsregobg
		 und qffmsregobs.



			qffmsregbg( m, D )

	"quadratic function field over modular singles regulator,
	baby step - giant step version" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	int qffmsregbg(m,D)  single m; pol D;
        R = qffmsregbg(m,D);
        D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
        (1<m<BASIS) mit geradem Grad. m muss eine Primzahl ungleich
        2 sein.
	Es wird der Regulator R des reell-quadratischen Kongruenz-
	funktionenkoerpers Z/mZ(X,D^(1/2)) mit Hilfe des verbesser-
	ten baby step - giant step - Algorithmus unter Ausnutzung-
	von Symmetrien berechnet. Dieser Algorithmus ist stark
	speicherabhaengig. Man berechnet etwas mehr als
		s = q^[Grad(D)/4]  / 2
	baby steps und die dazugehoerigen Ideale. Diese muessen dann
	gespeichert werden. Die Speicherung erfolgt im Hauptspeicher. 
	Man benoetigt Speicherplatz fuer ca. 
	4 * s Polynome vom Grad  <= 1/2 * Grad(D) und s ganze Zahlen.
	Dabei muss s < BASIS sein, da sonst sicherlich die Rechner-
        kapazitaet ueberschritten wird. Als Maximalwert von s wurde
	deshalb 10000 gewaehlt. m muss < 10000 sein.



			qffmsregbg1( m, D, s )

	"quadratic function field over modular singles regulator,
	baby step - giant step version, first case"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	int qffmsregbg1(m,D)  single m; pol D;
        R = qffmsregbg1(m,D);
        D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
        (1<m<BASIS) mit geradem Grad. m muss eine Primzahl ungleich
        2 sein.
	Es wird der Regulator R des reell-quadratischen Kongruenz-
	funktionenkoerpers Z/mZ(X,D^(1/2)) mit Hilfe des
	baby step - giant step - Algorithmus berechnet. Es werden
	dabei Symmetrien ausgenutzt.  
	Die natuerliche Zahl s gibt die Anzahl der baby steps an und
	sollte in der Groessenordnung	
		s = q^[Grad(D)/4]  / 2
	liegen. Einen Maximalwert von ca. 10000 sollte s fuer grosse
	Regulatoren nicht ueberschreiten, da man im Hauptspeicher 
	Speicherplatz fuer ca. 4s Polynome vom Grad  <= 1/2 * Grad(D)
	und s ganze Zahlen benoetigt. 
	Fuer diesen Fall wird vorausgesetzt, dass
		entweder 100 < m < 10000
		oder  Grad(D) <= 8 
	ist. Denn zu Beginn des Algorithmus wird ein Feld der Groesse
	10000 errichtet und m Felder davon initialisiert. 



			qffmsregbg2( m, D, s )

	"quadratic function field over modular singles regulator,
	baby step - giant step version, second case"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	int qffmsregbg2(m,D)  single m; pol D;
        R = qffmsregbg2(m,D);
        D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
        (1<m<BASIS) mit geradem Grad. m muss eine Primzahl ungleich
        2 sein.
	Es wird der Regulator R des reell-quadratischen Kongruenz-
	funktionenkoerpers Z/mZ(X,D^(1/2)) mit Hilfe des
	baby step - giant step - Algorithmus berechnet. Es werden
	dabei Symmetrien ausgenutzt.  
	Die natuerliche Zahl s gibt die Anzahl der baby steps an und
	sollte in der Groessenordnung	
		s = q^[Grad(D)/4]  / 2
	liegen. Einen Maximalwert von ca. 10000 sollte s fuer grosse
	Regulatoren nicht ueberschreiten, da man im Hauptspeicher 
	Speicherplatz fuer ca. 4s Polynome vom Grad  <= 1/2 * Grad(D)
	und s ganze Zahlen benoetigt. 
	Fuer diesen Fall wird vorausgesetzt, dass
		entweder 20 < m < 100 und  Grad(D) > 12
		oder m < 100 und 8 < Grad(D) <= 12
	ist. Denn zu Beginn des Algorithmus wird ein Feld
	der Groesse m * ( m + 1 ) initialisiert. 



			qffmsregbg3( m, D, s )

	"quadratic function field over modular singles regulator,
	baby step - giant step version, third case"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	int qffmsregbg3(m,D)  single m; pol D;
        R = qffmsregbg3(m,D);
        D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
        (1<m<BASIS) mit geradem Grad. m muss eine Primzahl ungleich
        2 sein.
	Es wird der Regulator R des reell-quadratischen Kongruenz-
	funktionenkoerpers Z/mZ(X,D^(1/2)) mit Hilfe des
	baby step - giant step - Algorithmus berechnet. Es werden
	dabei Symmetrien ausgenutzt.  
	Die natuerliche Zahl s gibt die Anzahl der baby steps an und
	sollte in der Groessenordnung	
		s = q^[Grad(D)/4]  / 2
	liegen. Einen Maximalwert von ca. 10000 sollte s fuer grosse
	Regulatoren nicht ueberschreiten, da man im Hauptspeicher 
	Speicherplatz fuer ca. 4s Polynome vom Grad  <= 1/2 * Grad(D)
	und s ganze Zahlen benoetigt. 
	Fuer diesen Fall wird vorausgesetzt, dass
		entweder 3 <= m <= 19 und  14 <= Grad(D) <= 18
		oder 11 <= m <= 19 und  Grad(D) >= 20 
	ist. Denn zu Beginn des Algorithmus wird ein Feld
	der Groesse m * ( m + 1 )^2 initialisiert. 



			qffmsregbg4( m, D, s )

	"quadratic function field over modular singles regulator,
	baby step - giant step version, fourth case"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	int qffmsregbg4(m,D)  single m; pol D;
        R = qffmsregbg4(m,D);
        D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
        (1<m<BASIS) mit geradem Grad. m muss eine Primzahl ungleich
        2 sein.
	Es wird der Regulator R des reell-quadratischen Kongruenz-
	funktionenkoerpers Z/mZ(X,D^(1/2)) mit Hilfe des
	baby step - giant step - Algorithmus berechnet. Es werden
	dabei Symmetrien ausgenutzt.  
	Die natuerliche Zahl s gibt die Anzahl der baby steps an und
	sollte in der Groessenordnung	
		s = q^[Grad(D)/4]  / 2
	liegen. Einen Maximalwert von ca. 10000 sollte s fuer grosse
	Regulatoren nicht ueberschreiten, da man im Hauptspeicher 
	Speicherplatz fuer ca. 4s Polynome vom Grad  <= 1/2 * Grad(D)
	und s ganze Zahlen benoetigt. 
	Fuer diesen Fall wird vorausgesetzt, dass
		3 <= m <= 7 und  Grad(D) >= 20 
	ist. Denn zu Beginn des Algorithmus wird ein Feld
	der Groesse m * ( m + 1 )^3 initialisiert. 



			qffmsregbs( m, D )

	"quadratic function field over modular singles regulator,
	baby step version" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	int qffmsregbs(m,D)  single m; pol D;
        R = qffmsregbs(m,D);
        D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
        (1<m<BASIS) mit geradem Grad. m muss eine Primzahl ungleich
        2 sein.
	Es wird der Regulator R des reell-quadratischen Kongruenz-
	funktionenkoerpers Z/mZ(X,D^(1/2)) mit Hilfe des baby step-
	Algorithmus (Kettenbruchentwicklung) berechnet. Dabei werden
	Symmetrien ausgenutzt. Man muss nur die Haelfte der Quasi-
	Periode	durchlaufen. Beendet werden kann der Algorithmus, 
	sobald einmal zwei aufeinanderfolgende Pi oder normierte 
	Qi (= QQi) gleich sind.
	HINWEIS: Eine langsamere Version des baby-step-Algorithmus
	======== ist durch qffmsregobs gegeben. Ausserdem sind in 
		 Zeitkomplexitaet bessere Algorithmen implementiert
		 mit qffmsregobg und qffmsregbg.



			qffmsregobg( m, D )

	"quadratic function field over modular singles regulator,
	original baby step - giant step version" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	int qffmsregobg(m, D)  single m; pol D;
        R = qffmsregobg(m, D);
        D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
        (1 < m < BASIS) mit geradem Grad. m muss eine Primzahl ungleich
        2 sein.
	Es wird der Regulator R des reell-quadratischen Kongruenz-
	funktionenkoerpers Z/mZ(X,D^(1/2)) mit Hilfe des Orginal-
	baby step - giant step - Algorithmus berechnet.
	Dieser Algorithmus ist stark speicherabhaengig. Man berechnet
		s = 3 * q^[Grad(D)/4]  / 2
	baby steps und die dazugehoerigen Ideale. Diese muessen dann
	gespeichert werden. Die Speicherung erfolgt im Hauptspeicher. 
	Man benoetigt Speicherplatz fuer 
	4 * s Polynome vom Grad  <= 1/2 * Grad(D) und s ganze Zahlen.
	Dabei muss s < BASIS sein, da sonst sicherlich die Rechner-
        kapazitaet ueberschritten wird. Als Maximalwert von s wurde
	deshalb 10000 gewaehlt.	m muss <= 100 sein, denn zu Beginn 
	des Algorithmus wird ein Feld der Groesse 100 * 100 errichtet,
	und m * ( m + 1 ) Felder werden	initialisiert. Falls man an 
	noch groesseren Regulatoren interessiert ist, sollte man 
	virtuellen Speicher verwenden oder die Festplatte benutzen.
	HINWEIS: Eine schnellerer baby step - giant step-Algorithmus
	======== unter Ausnutzung von Symmetrien ist mit qffmsregbg
		 gegeben. Ausserdem sind in Komplexitaet schlechtere
		 baby step - Algorithmen implementiert in den
		 Programmen qffmsregobs und qffmsregbs.



			qffmsregobs( m, D )

	"quadratic function field over modular singles regulator,
	original baby step version" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	int qffmsregobs(m,D)  single m; pol D;
        R = qffmsregobs(m,D);
        D ist ein normiertes, quadratfreies Polynom aus Z/mZ[X]
        (1<m<BASIS) mit geradem Grad. m muss eine Primzahl ungleich
        2 sein.
	Es wird der Regulator R des reell-quadratischen Kongruenz-
	funktionenkoerpers Z/mZ(X,D^(1/2)) mit Hilfe des Orginal-
	baby step - Algorithmus (Kettenbruchentwicklung) berechnet.
	Man muss dabei die ganze Quasi-Periode einmal durchlaufen.
	Beendet werden kann der Algorithmus, sobald der Grad von Qi
	Null wird. Dies ist zum ersten Mal an der Quasi-Periode.
	HINWEIS: Eine schnellere Version des baby step-Algorithmus
	======== unter Ausnutzung von Symmetrien ist mit qffmsregbs
		 gegeben. Ausserdem sind in Komplexitaet bessere
		 baby step - giant step - Algorithmen implementiert
		 mit qffmsregobg und qffmsregbg.



			qffmsrpidred( m, D, d, Q, P, pQr, pPr )

        "quadratic function field over modular singles, real case, 
	reduction of a primitive ideal" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	single qffmsrpidred(m,D,d,Q,P,pQr,pPr)  single m; pol D,d,Q,P;
					pol *pQr,*pPr;
	rd = qffmsrpidred(m,D,d,Q,P,pQr,pPr);
        D ist ein normiertes Polynom aus Z/mZ[X] (1<m<BASIS) in dense-
	Darstellung mit geradem Grad. m muss eine Primzahl ungleich 2 
	sein, d.h. Z/mZ(X,D^(1/2)) ist ein reell-quadratischer
	Kongruenzfunktionenkoerper. d, Q und P sind Polynome aus 
	Z/mZ[X] in dense-Darstellung, sodass das k[x]-Erzeugnis
		 I = [ Q, P + D^(1/2) ] 
	ein nichtreduziertes primitives Ideal ist. Dies bedeutet, dass
			Q teilt ( D - P^2 )  und
			Grad(Q) >= Grad( D^(1/2) ). 
	Dabei ist das Element a aus Z/mZ(X,D^(1/2))
			a = ( P + D^(1/2) ) / Q 
	eine nichtreduzierte reell-quadratische Irrationalitaet.
	d ist der Hauptteil von D^(1/2).
	Die Reduktion wird mit Hilfe des Kettenbruchalgorithmus
	berechnet. Beendet werden kann der Algorithmus,	sobald einmal 
		Grad(Ql) < Grad(D^(1/2)) fuer ein l aus N, wobei
		I(l+1) = [ Ql, Pl + D^(1/2) ]  ,
	und I(l+1) ist das erste reduzierte und zu I aequivalente Ideal
	in der Kettenbruchfolge von a.
	*pQr, *pPr sind Polynome aus Z/mZ[X] in dense-Darstellung mit
		*pQr := Ql und *pPr := Pl .
	rd ist der Reduktionsfaktor, also
		rd = Grad(a1)+Grad(a2)+...+Grad(al)+Grad(Ql)-Grad(Q0) 	



			qffmsrqired( m, D, d, Q, P, pPr )

	"quadratic function field over modular singles reduction of a
	real quadratic irrational" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmsrqired(m,D,d,Q,P,pPr)  single m; pol D,d,Q,P; pol *pPr;
        Qr = qffmsrqired(m,D,d,Q,P,pPr);
        D ist ein normiertes Polynom aus Z/mZ[X] (1<m<BASIS) in dense-
	Darstellung mit geradem Grad. m muss eine Primzahl ungleich 2
	sein. d, Q und P sind Polynome aus Z/mZ[X] in dense-Darstellung,
	sodass das Element
		a = ( P + D^(1/2) ) / Q 
	eine nichtreduzierte reell-quadratische Irrationalitaet ist.
	D.h. a ist ein Element aus Z/mZ(X,D^(1/2)) mit:
		Q teilt ( D - P^2 )  und
	Grad(P - D^(1/2)) >= Grad(Q) oder Grad(P + D^(1/2)) <=  Grad(Q). 
	d ist der Hauptteil von D^(1/2).
	Die Reduktion wird mit Hilfe des Kettenbruchalgorithmus
	berechnet. Beendet werden kann der Algorithmus,	sobald einmal 
		Grad(Ql) < Grad(D^(1/2)) fuer ein l aus N.
	Dann ist die Restzahl
		al = ( Pl + D^(1/2) ) / Ql
	die erste reduzierte Restzahl in der Kettenbruchfolge von a, d.h.
		Grad(Pl - D^(1/2)) < Grad(Ql) < Grad(Pl + D^(1/2)) .
	Qr, *pPr sind dann Polynome aus Z/mZ[X] in dense-Darstellung mit
		Qr := Ql und *pPr := Pl .



			qffmsrspidrd( m, D, d, Q, P, pQr, pPr )

        "quadratic function field over modular singles, real case, 
	sparse representation, reduction of a primitive ideal" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	single qffmsrspidrd(m,D,d,Q,P,pQr,pPr)  single m; pol D,d,Q,P;
					        pol *pQr,*pPr;
	rd = qffmsrspidrd(m,D,d,Q,P,pQr,pPr);
        D ist ein normiertes Polynom aus Z/mZ[X] (1<m<BASIS) mit 
	geradem Grad. m muss eine Primzahl ungleich 2 sein, d.h. 
	Z/mZ(X,D^(1/2)) ist ein reell-quadratischer Kongruenz-
	funktionenkoerper. d, Q und P sind Polynome aus
	Z/mZ[X] , sodass das k[x]-Erzeugnis
		 I = [ Q, P + D^(1/2) ] 
	ein nichtreduziertes primitives Ideal ist. Dies bedeutet, dass
			Q teilt ( D - P^2 )  und
			Grad(Q) >= Grad( D^(1/2) ). 
	Dabei ist das Element a aus Z/mZ(X,D^(1/2))
			a = ( P + D^(1/2) ) / Q 
	eine nichtreduzierte reell-quadratische Irrationalitaet.
	d ist der Hauptteil von D^(1/2).
	Die Reduktion wird mit Hilfe des Kettenbruchalgorithmus
	berechnet. Beendet werden kann der Algorithmus,	sobald einmal 
		Grad(Ql) < Grad(D^(1/2)) fuer ein l aus N, wobei
		I(l+1) = [ Ql, Pl + D^(1/2) ]  ,
	und I(l+1) ist das erste reduzierte und zu I aequivalente Ideal
	in der Kettenbruchfolge von a.
	*pQr, *pPr sind dann Polynome aus Z/mZ[X] mit
		*pQr := Ql und *pPr := Pl .
	rd ist der Reduktionsfaktor, also
		rd = Grad(a1)+Grad(a2)+...+Grad(al)+Grad(Ql)-Grad(Q0). 	



			qffmsspidpr( m, D, Q1, P1, Q2, P2, pQ, pP )

	"quadratic function field over modular singles, sparse 
	representation, primitive ideal product" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmsspidpr(m,D,Q1,P1,Q2,P2,pQ,pP)  single m; pol D,Q1,P1,Q2,P2;
					        pol *pQ,*pP;
        G = qffmsspidpr(m,D,Q1,P1,Q2,P2,pQ,pP);
        D ist ein Polynom aus Z/mZ[X] (1<m<BASIS). 
	m muss eine Primzahl ungleich 2 sein, d.h. Z/mZ(X,D^(1/2)) ist
	ein quadratischer Kongruenzfunktionenkoerper. Q1, P1, Q2, P2 sind 
	Polynome aus Z/mZ[X].
	Die k[x]-Erzeugnisse
		 I1 = [ Q1, P1 + D^(1/2) ] 
		 I2 = [ Q2, P2 + D^(1/2) ] 
	sind primitive Ideale. Dies bedeutet
		Q1 teilt ( D - P1^2 )  und
		Q2 teilt ( D - P2^2 )  .
	G, *pQ, *pP sind dann Polynome aus Z/mZ[X] mit
 		 I1 * I2 = (G) [ *pQ, *pP + D^(1/2) ] 
	einem ganzen Ideal. Das k[x]-Erzeugnis [*pQ,*pP+D^(1/2)] ist
	ein primitives Ideal, gegeben in adaptierter Form, und es gelten:
		- Q teilt ( D - P^2 ) ,
                - Grad(*pP) < Grad(*pQ) , 
		- sign(*pQ) = 1, d.h *pQ ist normiert ,
		- sign(G) = 1 , d.h G ist normiert.   
	Hinweis: Eine andere Version liegt durch qffmsspidprs vor. Diese 
	======== eignet sich bei mehrmaligem Anwenden des Idealprodukts
		 auf das gleiche Ideal. Auch gibt es Programme zum 
		 Quadrieren eines Ideals, d.h. Idealprodukt mit sich 
		 selbst, naemlich qffmsspidsqu, qffmsspidsqs.



			qffmsspidprs( m, D, C1, Q1, P1, Q2, P2, pQ, pP )

	"quadratic function field over modular singles, sparse 
	representation, primitive ideal product, special version"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmsspidprs(m,D,C1,Q1,P1,Q2,P2,pQ,pP)  single m; pol D,C1;
					  pol Q1,P1,Q2,P2; pol *pQ,*pP;
        G = qffmsspidprs(m,D,C1,Q1,P1,Q2,P2,pQ,pP);
        D ist ein Polynom aus Z/mZ[X] (1<m<BASIS).  
	m muss eine Primzahl ungleich 2 sein, d.h. Z/mZ(X,D^(1/2)) ist
	ein quadratischer Kongruenzfunktionenkoerper. C1, Q1, P1, Q2, P2  
	sind Polynome aus Z/mZ[X]. 
 	Die k[x]-Erzeugnisse
		 I1 = [ Q1, P1 + D^(1/2) ] 
		 I2 = [ Q2, P2 + D^(1/2) ] 
	sind primitive Ideale, gegeben in adaptierter Form. Dies bedeutet
		- Q1 teilt ( D - P1^2 ) , Q2 teilt ( D - P2^2 )  
		- Grad(P1) < Grad(Q1) , Grad(P2) < Grad(Q2) , 
		- sign(Q1) = 1 = sign(Q2)
	Dabei ist
		C1 = ( D - P1^2 ) / Q1 
	ein Element aus k[x] und wurde schon vorberechnet.
	G, *pQ, *pP sind Polynome aus Z/mZ[X], sodass
 		 I1 * I2 = (G) [ *pQ, *pP + D^(1/2) ] 
	ein ganzes Ideal ist. Das k[x]-Erzeugnis [*pQ,*pP+D^(1/2)] ist
	ein primitives Ideal gegeben in adaptierter Form, und es gelten:
		- Q teilt ( D - P^2 ) ,
                - Grad(*pP) < Grad(*pQ) , 
		- sign(*pQ) = 1, d.h *pQ ist normiert ,
		- sign(G) = 1 , d.h G ist normiert.   
	Hinweis: Eine allgemeinere Version liegt durch qffmsspidpr vor. 
 	======== Auch gibt es Programme zum Quadrieren eines Ideals,
		 d.h. Idealprodukt mit sich selbst, naemlich qffmsspidsqu
		 und qffmsspidsqs.



			qffmsspidsqs( m, D, C1, Q1, P1, pQ, pP )

	"quadratic function field over modular singles, sparse
	representation, primitive ideal square, special version"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmsspidsqs(m,D,C1,Q1,P1,pQ,pP)  single m; pol D,C1,Q1,P1;
					      pol *pQ,*pP;
        G = qffmsspidsqs(m,D,C1,Q1,P1,pQ,pP);
        D ist ein Polynom aus Z/mZ[X] (1<m<BASIS). 
	m muss eine Primzahl ungleich 2 sein, d.h. Z/mZ(X,D^(1/2)) ist
	ein quadratischer Kongruenzfunktionenkoerper. C1, Q1, P1 sind 
	Polynome aus Z/mZ[X].  Das k[x]-Erzeugnis
		 I1 = [ Q1, P1 + D^(1/2) ] 
	ist ein primitives Ideal, gegeben in adaptierter Form, also
		- Q1 teilt ( D - P1^2 ) 
		- Grad(P1) < Grad(Q1) 
		- sign(Q1) = 1 .
	Dabei ist
		C1 = ( D - P1^2 ) / Q1 
	ein Element aus k[x] und wurde schon vorberechnet. G, *pQ, *pP 
	sind dann Polynome aus Z/mZ[X], sodass
 		 I1 * I1 = (G) [ *pQ, *pP + D^(1/2) ] 
	ein ganzes Ideal ist. Das k[x]-Erzeugnis [*pQ,*pP+D^(1/2)] ist
	ein primitives Ideal gegeben in adaptierter Form, und es gelten:
		- Q teilt ( D - P^2 ) ,
                - Grad(*pP) < Grad(*pQ) , 
		- sign(*pQ) = 1, d.h *pQ ist normiert ,
		- sign(G) = 1 , d.h G ist normiert.   
	Hinweis: Eine andere Version liegt durch qffmsspidsqs vor. 
	=======  Allgemeinere Programme zum Idealprodukt gibt es in
		 den Programmen qffmsspidpr und qffmsspidprs.



			qffmsspidsqu( m, D, Q1, P1, pQ, pP )

	"quadratic function field over modular singles, sparse 
	representation, primitive ideal square" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmsspidsqu(m,D,Q1,P1,pQ,pP)  single m; pol D,Q1,P1;
					   pol *pQ,*pP;
        G = qffmsspidsqu(m,D,Q1,P1,pQ,pP);
        D ist ein Polynom aus Z/mZ[X] (1<m<BASIS). 
	m muss eine Primzahl ungleich 2 sein, d.h. Z/mZ(X,D^(1/2)) ist
	ein quadratischer Kongruenzfunktionenkoerper. Q1, P1 sind 
	Polynome aus Z/mZ[X] .
	Das k[x]-Erzeugnis
		 I1 = [ Q1, P1 + D^(1/2) ] 
	ist ein primitives Ideal. Dies bedeutet
		Q1 teilt ( D - P1^2 ) .  
	G, *pQ, *pP sind dann Polynome aus Z/mZ[X]  mit
 		 I1 * I1 = (G) [ *pQ, *pP + D^(1/2) ] 
	einem ganzen Ideal. Das k[x]-Erzeugnis [*pQ,*pP+D^(1/2)] ist
	ein primitives Ideal gegeben in adaptierter Form, und es gelten:
		- Q teilt ( D - P^2 ) ,
                - Grad(*pP) < Grad(*pQ) , 
		- sign(*pQ) = 1, d.h *pQ ist normiert ,
		- sign(G) = 1 , d.h G ist normiert.   
	Hinweis: Eine andere Version liegt durch qffmsspidsqus vor. 
	=======  Allgemeinere Programme zum Idealprodukt sind gegeben
		 durch qffmsspidpr, qffmsspidprs.



			qffmssrqired( m, D, d, Q, P, pPr )

        "quadratic function field over modular singles, sparse
	representation,	reduction of a real quadratic irrational" 
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	pol qffmssrqired(m,D,Q,P,pPr)  single m; pol D,Q,P; pol *pPr;
        Qr = qffmssrqired(m,D,Q,P,pPr);
        D ist ein normiertes Polynom aus Z/mZ[X] (1<m<BASIS) mit geradem 
	Grad. m muss eine Primzahl ungleich 2 sein. Q und P sind Polynome 
	aus Z/mZ[X], sodass das Element
		a = ( P + D^(1/2) ) / Q 
	eine nichtreduzierte reell-quadratische Irrationalitaet ist.
	D.h. a ist ein Element aus Z/mZ(X,D^(1/2)) mit:
		Q teilt ( D - P^2 )  und
	Grad(P - D^(1/2)) >= Grad(Q) oder Grad(P + D^(1/2)) <=  Grad(Q). 
	Die Reduktion wird mit Hilfe des Kettenbruchalgorithmus
	berechnet. Beendet werden kann der Algorithmus,	sobald einmal 
		Grad(Ql) < Grad(D^(1/2)) fuer ein l aus N.
	Dann ist die Restzahl
		al = ( Pl + D^(1/2) ) / Ql
	die erste reduzierte Restzahl in der Kettenbruchfolge von a, d.h.
		Grad(Pl - D^(1/2)) < Grad(Ql) < Grad(Pl + D^(1/2)) .
	Qr, *pPr sind dann Polynome aus Z/mZ[X] mit
		Qr := Ql und *pPr := Pl .



			qffmszcgiti( m, D, LG, IT )

        "quadratic function field over modular singles zero class group 
	isomorphy type, imaginary case"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	list qffmszcgiti(m, D, LG, IT)  single m; pol D; list LG, IT;
	L = qffmszcgiti(m, D, LG, IT);
	Vorausstzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D ist ein quadratfreies Polynom aus Z/mZ[X] ;
	. entweder ist Grad(D) ungerade
	  oder Grad(D) gerade und der fuehrende Koeffizient von D ist
	  kein Quadrat in der multiplikativen Gruppe von (Z/mZ), d.h. 
	  Z/mZ(X,D^(1/2)) ist ein imaginaer-quadratischer Kongruenz-
	  funktionenkoerper;
	. (vgl. qffmsicggii)
	  a) Falls H = 1 :  LG = L und *pIT = ();
	  Dann ist die Idealklassengruppe isomorph zu Z;
	  b) Falls 1 < H = p1^m1 * p2^m2 * ... * pk^mk 
	  mit p1 < ... < pk  und mj > 0 fuer 1 <= j <= k;
	  LG = ( L1 , L2, ... , Lk ) , wobei Lj Erzeugende der Ideal-
	  klassengruppe und deren Ordnung fuer jede Primzahl pj darstellt,
	  die die Idealklassenzahl teilt, und zwar der Groesse nach 
	  geordnet. D.h. fuer 1 <= j <= k ist Lj eine Liste
	  Lj = ( ( ( - pj , - pj^mj ) I_1mj , ... , I_kmj ) , 
			 .
			 .
		 ( ( - pj , - pj^1 )  I_11  , ... , I_l1  )   )   ;
	  Dabei sind I_1mj, ... , I_k_mj, ... , I_11, ..., I_l1 reduzierte
	  Ideale, also Repraesentanten der Idealklassengruppe (vgl. qffmsicgrr
	  und qffmsicgstr ) und sind Erzeugende der zyklischen Untergruppen 
	  mit jeweils entsprechender ( und zwar positiver ) Primpotenzordnung
	  	pj^mj, ... , pj^mj, ... , pj^1, ... , pj^1 . 
	. IT = ( n1 , ... , ni ) stellt den Isomorphietyp der Idealklassen-
	  gruppe dar, d.h. nj sind fuer j = 1 , ... , i , ganze Zahlen, 
	  sodass die Idealklassengruppe isomorph ist zu
		( Z / n1 Z ) x ( Z / n2 Z ) x ... x ( Z / ni Z ) ,
	  und n1 <= n2 <= ... <= ni ;
	  ( insbesondere sind Mehrfachnennungen moeglich )
	Ergebnis:
	. L = ( m1 , ... , ml ) stellt den Isomorphietyp der Nullklassen-
	  gruppe dar, d.h. mj sind fuer j = 1 , ... , l , ganze Zahlen, 
	  sodass die Nullklassengruppe isomorph ist zu
		( Z / m1 Z ) x ( Z / m2 Z ) x ... x ( Z / ml Z ) ,
	Hinweis: siehe auch Diplomarbeit Bosco Weis, SB, 1986.



			qffmszcgitr( m, D, d, H, LG, R, IT )

        "quadratic function field over modular singles zero class 
	group isomorphy type, real case"
        Quellbibliothek: srclib.arith3
        Include-Datei:   _arith3.h
	list qffmszcgitr(m, D, d, H, LG, R, IT)  single m; pol D, d; int H, R;
					         list LG, IT;
	L = qffmszcgitr(m, D, d, H, LG, R, IT);
	Vorausstzungen:
	. m ist Primzahl mit 2 < m < BASIS; 
	. D aus Z/mZ[X] ist normiert, quadratfrei und hat geraden Grad,
	  d.h. Z/mZ(X,D^(1/2)) ist ein reell-quadratischer Kongruenz-
	  funktionenkoerper;
	. d = Hauptteil(D);
	. H = Idealklassenzahl von Z/mZ(X,D^(1/2));
	. R = Regulator von Z/mZ(X,D^(1/2));
	  (vgl. Ausgabe von qffmsicggir)
	. LG = ( L1 , L2, ... , Lk ) , wobei Lj Erzeugende der Ideal-
	  klassengruppe und deren Ordnung fuer jede Primzahl pj darstellt,
	  die die Idealklassenzahl teilt, und zwar der Groesse nach 
	  geordnet. 
	  a) Falls H = 1 :  LG = L und IT = ();
	  Dann ist die Idealklassengruppe isomorph zu Z;
	  b) Falls 1 < H = p1^m1 * p2^m2 * ... * pk^mk 
	  mit p1 < ... < pk  und mj > 0 fuer 1 <= j <= k ist, so
	  ist Lj eine Liste
	  Lj = ( ( ( - pj , - pj^mj ) I_1mj , ... , I_kmj ) , 
			 .
			 .
		 ( ( - pj , - pj^1 )  I_11  , ... , I_l1  )   )   ;
	  Dabei sind I_1mj, ... , I_k_mj, ... , I_11, ..., I_l1 reduzierte
	  Ideale, also Repraesentanten der Idealklassengruppe (vgl. qffmsicgrr
	  und qffmsicgstr ) und sind Erzeugende der zyklischen Untergruppen 
	  mit jeweils entsprechender ( und zwar positiver ) Primpotenzordnung
	  	pj^mj, ... , pj^mj, ... , pj^1, ... , pj^1 . 
	. IT = ( n1 , ... , ni ) stellt den Isomorphietyp der Idealklassen-
	  gruppe dar, d.h. nj sind fuer j = 1 , ... , i , ganze Zahlen, 
	  sodass die Idealklassengruppe isomorph ist zu
		( Z / n1 Z ) x ( Z / n2 Z ) x ... x ( Z / ni Z ) ,
	  und n1 <= n2 <= ... <= ni ;
	  ( insbesondere sind Mehrfachnennungen moeglich )
	Ergebnis:
	. L = ( m1 , ... , ml ) stellt den Isomorphietyp der Nullklassen-
	  gruppe dar, d.h. mj sind fuer j = 1 , ... , l , ganze Zahlen, 
	  sodass die Nullklassengruppe isomorph ist zu
		( Z / m1 Z ) x ( Z / m2 Z ) x ... x ( Z / ml Z ) ,
	Hinweis: siehe auch Diplomarbeit Bosco Weis, SB, 1986.



			qnfaval( D, p, a )

	"quadratic number field additive valuation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list qnfaval( D, p, a )  int D; single p; nfel a;
	W = qnfaval( D, p, a );
	D ist aus Z\{0,1} und quadratfrei.
	p ist Primzahl, also Primstelle von Q.
	a ist Element von K = Q(D^(1/2)) und ungleich 0.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	Die additive p-adische Bewertung wp von Q hat entweder eine Fort-
	setzung wP oder zwei Fortsetzungen wP1 und wP2 auf K.
	wP bzw. wP1 und wP2 seien jeweils normiert.
	W = ( wP(a) ) bzw. W = ( wP1(a), wP2(a) ), wobei im letzteren
	Fall zu beachten ist:
	Achtung: Existiert fuer wPi( a ) nur eine ">=" Abschaetzung, so
	-------- hat W die Form ( ab1, ab2, w ) mit wPi( a ) >= abi.
		 w = wP1( a ) + wP2( a ) = wp( Norm(K/Q)( a ) ).



			qnfconj( D, a )

	"quadratic number field conjugate element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfconj( D,a )  int D; nfel a;
	c = qnfconj( D,a );
	D ist aus Z\{0,1} und quadratfrei.
	a ist Element von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c ist das Konjugierte von a bzgl. Q(D^(1/2)) / Q.



			qnfdegrescf( D, p )

	"quadratic number field degrees of the residue class fields"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list qnfdegrescf( D,p )  int D; single p;
	L = qnfdegrescf( D,p );
	D ist aus Z\{0,1} und quadratfrei.
	p ist Primzahl, also Primstelle von Q.
	Falls p nur eine Fortsetzung P auf Q(D^(1/2)) hat, ist L = (f),
	wobei f der Restklassengrad von P/p ist (also f aus {1,2}).
	Falls p zwei Fortsetzungen P1 und P2 auf Q(D^(1/2)) hat, so dass
	die Restklassengrade fi von Pi/p gleich 1 sind, ist L = (1,1).
	L ist also die Liste der Restklassengrade.



			qnfdif( D, a, b )               (MACRO)

	"quadratic number field element difference"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfdif( D, a, b )  int D; nfel a,b;
	c = qnfdif( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei,
	                a und b sind Elemente aus Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a - b, die Differenz von a und b.



			qnfdirchar( D, z )

	"quadratic number field Dirichlet character"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	single qnfdirchar( D, z )  int D; int z;
	s = qnfdirchar( D, z );
	D ist aus Z\{0,1} und quadratfrei.
	z ist ungleich Null.
	s ist der Wert des Dirichlet' schen Charakters bzgl. des
	quadratischen Zahlkoerpers K = Q(D^(1/2)) an der Stelle z,
	d.h. s ist der Wert des Kronecker-Symbols von der Diskriminante
	des Zahlkoerpers K ueber z.



			qnfdisc( D )

	"quadratic number field discriminant"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	int qnfdisc( D )  int D;
	d = qnfdisc( D );
	D ist aus Z\{0,1} und quadratfrei.
	d ist die Diskriminante von Q(D^(1/2)) / Q, also:
	d = 4D  fuer D kongruent 2 oder 3 modulo 4,
	d =  D  fuer D kongruent 1 modulo 4.



			qnfelcomp( D, A, B )

        "quadratic number field element comparison"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
        single qnfelcomp( D, a, b )  int D; nfel a, b;
        s = qnfelcomp( D, a, b );
        D ist aus Z\{0,1} und quadratfrei. 
	a und b sind Elemente des quadratischen Zahlkoerpers Q(D^(1/2)).
	Zur Darstellung von Zahlkoerperelementen siehe fputqnfel.
	Rueckgabe: 0, falls a = b.
		   1, sonst.



			qnfexp( D, a, e )

	"quadratic number field element exponentiation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfexp( D, a, e )  int D; nfel a; single e;
	c = qnfexp( D, a, e );
	D ist aus Z\{0,1} und quadratfrei. a ist ein Element 
	von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a^e ist die e-te Potenz von a, wobei 0^0 = 1, 0^e = 0 
	fuer e > 0, sowie a^e = (1/a)^|e|, falls a != 0 und e < 0.
	c = ERROR, falls a = 0 und e < 0.



			qnfidcomp( D, A, B )

        "quadratic number field ideal comparison"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
        single qnfidcomp( D, A, B )  int D; list A, B;
        s = qnfidcomp( D, A, B );
        D ist aus Z\{0,1} und quadratfrei. 
	A und B sind Ideale des Ganzheitsrings O_D von K = Q(D^(1/2)).
	Zur Darstellung von Idealen siehe qnfidprod. 
	Rueckgabe: 0, falls A und B dasselbe Ideal in O_D darstellen,
		   1, sonst.



			qnfidexp( D, A, e )

        "quadratic number field ideal exponentiation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
        list qnfidexp( D, A, e )  int D; list A; single e;
        B = qnfidexp( D, A, e );
        D ist aus Z\{0,1} und quadratfrei. e >= 0.
	A ist ein Ideal des Ganzheitsrings O_D von Q(D^(1/2)). 
	Zur Darstellung von Idealen siehe qnfidprod.
        qnfidexp berechnet das Idealprodukt 
	     B = A^e = A * A *...* A (e mal).



			qnfidif( D, a, b )              (MACRO)

	"quadratic number field element, integer, difference"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfidif( D, a, b )  int D, b; nfel a;
	c = qnfidif( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist ein 
	Element aus Q(D^(1/2)), b ist eine ganze Zahl.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a - b, die Differenz von a und b (als Zahlkoeperelemente).



			qnfidone( D )                   (MACRO)

	"quadratic number field ideal one"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list qnfidone( D )  int D;
	I = qnfidone( D, A );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei,
	qnfidone erzeugt das Eins-Ideal 1 * O_D (O_D = Ganzheitsring
	von Q^(D^1/2)). Zur Darstellung von Idealen siehe qnfidprod.
	Rueckgabe:         /  ( 1, 1, 0, 1 ), falls D = 2, 3 mod 4
	              I = <
	                   \  ( 1, 2, 1, 2 ), falls D = 1 mod 4



			qnfidprod( D, A, B )

        "quadratic number field ideal product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
        list qnfidprod( D, A, B )  int D; list A, B;
        C = qnfidprod( D, A, B );
        D ist aus Z\{0,1} und quadratfrei. 
	A und B sind Ideale des Ganzheitsrings O_D von K = Q(D^(1/2)). 
	Ideale sind wie folgt dargestellt: 
	   A = ( a, b, c, s )  int a, b, c; single s;
           mit s = 1, falls D = 2 oder 3 mod 4 ist, und s = 2 sonst;
	   und A = (a) * ( b/s * Z + (c+D^(1/2))/s * Z ).
           Dabei gilt: 
	     a in N, 
	     b = min{ n in N : n liegt in (b/s * Z + (c+D^(1/2))/s * Z) }, 
	     0 <= c < b.
	Rueckgabe: Liste C = A * B = ( n_C, a_C, b_C, s_C ).
	Literatur: A.J. Stephens and H.C. Williams: "Some Computational
		   Results on a Problem Concerning Powerful Numbers", 
		   Math. Comp. V. 50, #182 (April 1988), pp 619-632.



			qnfidsquare( D, A )

        "quadratic number field ideal square"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
        list qnfidsquare( D, A )  int D; list A;
        B = qnfidsquare( D, A );
        D ist aus Z\{0,1} und quadratfrei. 
	A ist ein Ideal des Ganzheitsrings O_D von Q(D^(1/2)). 
	Zur Darstellung von Idealen siehe qnfidprod.
	qnfidsquare gerechnet das Idealprodukt B = A^2 = A * A.



			qnfielpifacts( D, a, L )

	"quadratic number field integral element prime ideal 
	 factorization, special version"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list qnfielpifacts( D, a, L )  int D; nfel a; list L;
	M = qnfielpifacts( D, a, L );
	D ist aus Z\{0,1} und quadratfrei.
	a ist ein Element des Ganzheitsrings O_D des quadratischen Zahl-
	koerpers Q(D^(1/2)). a ist ungleich 0 und keine Einheit in O_D.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	L = ( p_1 e_1 ... p_k e_k )  int p_i; single e_i; 
	ist die Liste mit allen Primteilern der Norm von a und den zuge-
	hoerigen Exponenten e_i ( 1 <= i <= k ), also 
		| Norm(a) | = p_1^e_1 * ... * p_k^e_k.
	qnfielpifacts berechnet die Faktorisierung von (a) in Primideale 
	P_j in O_D.
	Zur Darstellung von Idealen siehe qnfidprod.
        Rueckgabe: 
		Liste M = ( P_1  f_1  pi_1  z_1 ...  P_l  f_l  pi_l  z_l ),
		so dass (a) = P_1^f_1 * ... * P_l^f_l und
		pi_j Ortsuniformisierende von P_j sowie
	 	       / 0, falls p_j traege   : (p_j) = P_j
	        z_j = <  1, falls p_j verzweigt: (p_j) = P_j^2
		       \ 2, falls p_j zerlegt  : (p_j) = P_j * P_j'.



			qnfielpiord( D, P, pi, z, a )

        "quadratic number field, integral element, prime ideal order"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
        single qnfielpiord(D,P,pi z,a)  int D; list P; nfel pi,a; single z;
        e = qnfielpiord( D, P, pi, z, a );
        Dabei muss gelten: 
 	  - D ist aus Z\{0,1} und quadratfrei,
	  - P ist Primideal in O_D, dem Ganzheitsring von K = Q(D^(1/2)),
	    das eine Primzahl p auf K fortsetzt, 
	    (zur Darstellung von Idealen siehe qnfidprod)
	  - pi ist eine zu P gehoerige Ortsuniformisierende,
	  - z gibt das Zerlegungsgesetz von p in K an: z = 0, 1 oder
	    2, falls p in K traege, verzweigt bzw. zerlegt ist,
          - a ist aus O_D. 
	    (zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
        qnfielpiord berechnet das maximale e >= 0 mit 
	    ( a ) = 0 modulo P^e.
        Dabei steht e = ERROR fuer Unendlich (im Fall a = 0).



			qnfintbas( D )

	"quadratic number field integral basis"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list qnfintbas( D )  int D;
	B = qnfintbas( D );
	D ist aus Z\{0,1} und quadratfrei.
	B = ( a1, a2 ) enthaelt 2 Elemente vom Typ nfel, die eine
	Ganzheitsbasis fuer Q(D^(1/2)) / Q bilden, genauer:
	a1 = 1 und
	a2 = D^(1/2)                fuer D kongruent 2 oder 3 modulo 4,
	a2 = 1/2 * (D^(1/2) + 1)    fuer D kongruent 1 modulo 4.



			qnfinv( D, a )

	"quadratic number field element inverse element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfinv( D, a )  int D; nfel a;
	c = qnfinv( D, a );
	D ist aus Z\{0,1} und quadratfrei.
	a ist ein Element von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	b = ERROR, falls a = 0,
	    1/a, das multiplikativ Inverse von a, sonst.



			qnfiprod( D, a, b )

	"quadratic number field element, integer, product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfiprod( D, a, b )  int D, b; nfel a;
	c = qnfiprod( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist ein
	Element aus Q(D^(1/2)), b ist eine ganze Zahl.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a * b, das Produkt von a und b (als Zahlkoerperelemente).



			qnfiquot( D, a, b )

	"quadratic number field element, integer, quotient"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfiquot( D, a, b )  int D, b; nfel a;
	c = qnfiquot( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist ein
	Element aus Q(D^(1/2)), b ist eine ganze Zahl.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = ERROR, falls b = 0,
	    a/b, der Quotient von a und b (als Zahlkoeperelemente), sonst.



			qnfisum( D, a, b )

	"quadratic number field element, integer, sum"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfisum( D, a, b )  int D, b; nfel a;
	c = qnfisum( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist ein
	Element aus Q(D^(1/2)), b ist eine ganze Zahl.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a + b, die Summe von a und b (als Zahlkoerperelemente).



			qnfminrep( D, a )

	"quadratic number field element minimal representation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfminrep( D, a )  int D; nfel a;
	c = qnfminrep( D, a );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei.
	                a ist ein Element aus Q(D^(1/2)).
        a ist entweder von der Form
	                    0, falls a = 0.
	        ( aN  0  a1 ), falls a = a1/aN in Q\{0}; int aN, a1.
	    ( aN  1  a2  a1 ), falls a = a1/aN + (a2/aN) * D^(1/2)
	                       in Q(D^(1/2))\Q; int aN, a1, a2.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	qnfminrep gibt die minimale Darstellung fuer a zurueck, d.h. 
	   c = 0, falls a = 0,
	   c = ( N  0  c1 )  int N, c1; mit N > 0 und gcd( N, c1 ) = 1,
	       falls a eine rationale Zahl ungleich Null darstellt,
	   c = ( N  1  c2  c1 )  int N, c1, c2; mit gcd( N, c1, c2 ) = 1
	        und N > 0, falls a ein Element aus Q(D^(1/2))\Q darstellt.



			qnfneg( D, a, b )

	"quadratic number field element negation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfneg( D, a )  int D; nfel a;
	b = qnfneg( D, a );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei.
	                a ist ein Element aus Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	b = -a, das additive Inverse von a.



			qnfnorm( D, a )

	"quadratic number field norm of an element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	rat qnfnorm( D,a )  int D; nfel a;
	R = qnfnorm( D,a );
	D ist aus Z\{0,1} und quadratfrei.
	a ist Element von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	R ist die Norm von a bzgl. Q(D^(1/2)) / Q.



			qnfpifact( D, a )

	"quadratic number field element prime ideal factorization"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
        list qnfpifact( D, a )  int D; nfel a;
	L = qnfpifact( D, a );
	D ist aus Z\{0,1} und quadratfrei. a ist ein Element des
	quadratischen Zahlkoerpers K = Q(D^(1/2)). Zur Darstellung 
	von Zahlkoerperelementen siehe fputnfel.
	qnfpifact berechnet die Faktorisierung von a - eigentlich des
	Hauptideals (a) - in Primideale: (a) = Prod(1<=j<=k) P_j^f_j. 
	Zur Darstellung von Idealen siehe qnfidprod.
	Rueckgabe: ERROR, falls a = 0;
           ( 1 ), falls a eine Einheit im Ganzheitsring von K ist,
           ( P_1  f_1  pi_1  z_1 ...   P_k  f_k  pi_k  z_k)  
	     list P_i; single f_i, z_i; nfel pi_i;
             mit Primidealen P_i, den zugehoerigen Potenzen f_i, 
	     einer zu P_i gehoerigen Ortsuniformisierenden pi_i
	     und dem Zerlegungsgesetz z_i, sonst.
	     z_i = 0, 1 oder 2, falls die Primzahl, die von P_i auf K
	     fortgesetzt wird, traege, verzweigt bzw. zerlegt ist.



			qnfpihom( D, P, pi, z, a )

        "quadratic number field prime ideal homomorphism"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
        nfel qnfpihom(D, P, pi, z, a)  int D; list P; nfel pi, a; single z;
        b = qnfpihom( D, P, pi, z, a );
        D ist aus Z\{0,1} und quadratfrei. 
        P ist Primideal in O_D dem Ganzheitsring von K = Q(D^(1/2)), 
	das die Primzahl p auf K fortsetzt. Zur Darstellung von Idealen
	siehe qnfidprod.
	pi ist eine zu P gehoerige Ortsuniformisierende.
	z gibt das Zerlegungsgesetz von p in K an:  z = 0, 1 oder 2,
	falls p in K traege, verzweigt bzw. zerlegt ist.
	a ist ein Element aus dem Ganzheitsring O_D von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
        qnfpihom berechnet einen Vertreter b von a modulo P in dem 
        Restsystem 
           {0, 1, ..., p-1}, falls p zerlegt oder verzweigt ist,
           {x + y * w | x, y in {0, 1,..., p-1}}, falls p traege ist.
        Dabei ist {1, w} eine Ganzheitsbasis von O_D mit
                   /   D^(1/2),       falls D = 2 oder 3 mod 4,
	      w = <
		   \   [1+D^(1/2)]/2, falls D = 1 mod 4.



			qnfpiord( D, P, pi, z, a )

        "quadratic number field element prime ideal order"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
        single qnfpiord(D,P,pi,z,a)  int D; list P; nfel pi, a; single z;
        n = qnfpiord( D, P, pi, z, a );
        D ist aus Z\{0,1} und quadratfrei.
        P ist Primideal in O_D, dem Ganzheitsring von K = Q(D^(1/2)),
	das eine Primzahl p auf K fortsetzt. Zur Darstellung von Idealen
	siehe qnfidprod.
	pi ist eine zu P gehoerige Ortsuniformisierende,
	z gibt das Zerlegungsgesetz von p in K an:
	z = 0, 1 oder 2, falls p in K traege, verzweigt bzw. zerlegt ist.
	a ist ein Element aus dem Ganzheitsring O_D von K.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
        qnfpiord berechnet die Ordnung n, mit der das Primideal P
	die Zahl a (resp. das Hauptideal (a) = a * O_D) teilt.
	Rueckgabe: ERROR, falls a = 0 (ERROR als Symbol fuer Unendlich),
		   max{ n in N | P^n teilt a }, sonst.



			qnfprod( D, a, b )

	"quadratic number field element product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfprod( D, a, b )  int D; nfel a, b;
	c = qnfprod( D, a, b );
	D ist aus Z\{0,1} und quadratfrei.
	a und b sind Elemente von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a * b ist das Produkt von a und b.



			qnfquot( D, a, b )              (MACRO)

	"quadratic number field element quotient"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfquot( D, a, b )  int D; nfel a, b;
	c = qnfquot( D, a, b );
	D ist aus Z\{0,1} und quadratfrei.
	a und b sind Elemente von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = ERROR, falls b = 0,
	    a/b, der Quotient von a und b, sonst.



			qnframind( D, p )

	"quadratic number field ramification indices"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list qnframind( D,p )  int D; single p;
	L = qnframind( D,p );
	D ist aus Z\{0,1} und quadratfrei.
	p ist Primzahl, also Primstelle von Q.
	Falls p nur eine Fortsetzung P auf Q(D^(1/2)) hat, ist L = (e),
	wobei e der Verzweigungsindex von P/p ist (also e aus {1,2}).
	Falls p zwei Fortsetzungen P1 und P2 auf Q(D^(1/2)) hat, so dass
	die Verzweigungsindizes ei von Pi/p gleich 1 sind, ist L = (1,1).
	L ist also die Liste der Verzweigungsindizes.



			qnfrdif( D, a, b )              (MACRO)

	"quadratic number field element, rational number, difference"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfrdif( D, a, b )  int D; nfel a; rat b;
	c = qnfrdif( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist ein 
	Element aus Q(D^(1/2)), b ist eine rationale Zahl.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a - b, die Differenz von a und b (als Zahlkoerperelemente).



			qnfrprod( D, a, b )

	"quadratic number field element, rational number, product"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfrprod( D, a, b )  int D; nfel a; rat b;
	c = qnfrprod( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist ein 
	Element aus Q(D^(1/2)), b ist eine rationale Zahl.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a * b, das Produkt von a und b (als Zahlkoerperelemente).



			qnfrquot( D, a, b )             (MACRO)

	"quadratic number field element, rational number, quotient"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfrquot( D, a, b )  int D; nfel a; rat b;
	c = qnfrquot( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist ein 
	Element aus Q(D^(1/2)), b ist eine rationale Zahl.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = ERROR, falls b = 0,
	    a/b, der Quotient von a und b, sonst.



			qnfrsum( D, a, b )

	"quadratic number field element, rational number, sum"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfrsum( D, a, b )  int D; nfel a; rat b;
	c = qnfrsum( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist ein
	Element aus Q(D^(1/2)), b ist eine rationale Zahl.
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a + b, die Summe von a und b (als Zahlkoerperelemente).



			qnfsquare( D, a )

	"quadratic number field element square"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfsquare( D, a )  int D; nfel a;
	b = qnfsquare( D, a );
	D ist aus Z\{0,1} und quadratfrei.
	a ist ein Element von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	b = a^2, das Quadrat von a.



			qnfsum( D, a, b )

	"quadratic number field element sum"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel qnfsum( D, a, b )  int D; nfel a, b;
	c = qnfsum( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a und b
	sind Elemente aus Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a + b, die Summe von a und b.



			qnfsysrmodpi( D, P, pi, z, k )

        "quadratic number field system of representatives modulo a prime 
	 ideal"
        Quellbibliothek: srclib.arith2
        Include-Datei:   _arith2.h
        list qnfsysrmodpi( D, P, pi, z, k )  int D; list P; nfel pi; 
		single z, k;
        L = qnfsysrmodpi( D, P, pi, z, k );
        D ist aus Z\{0,1} und quadratfrei. 
        P ist Primideal in O_D, dem Ganzheitsring von K = Q(D^(1/2)), 
	das eine Primzahl p auf K fortsetzt. Zur Darstellung von Idealen
	siehe qnfidprod.
	pi ist eine zu P gehoerige Ortsuniformisierende.
	z gibt das Zerlegungsgesetz von p in K an: z = 0, 1 oder 2, 
	falls p in K traege, verzweigt bzw. zerlegt ist.
        qnfsysrmodpi bestimmt ein komplettes Vertretersystem modulo P^k:
	     { x + y * w | 0 <= x < a, 0 <= y < b },
        wobei {1, w} mit 
	     w = D^(1/2), falls D = 2, 3 mod 4,
	     w = [1+D^(1/2)]/2, falls D = 1 mod 4,
        eine Ganzheitsbasis von Q(D^(1/2)) ist.
        Rueckgabe: ( a, b ).



			qnftrace( D, a )

	"quadratic number field trace of an element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	rat qnftrace( D,a )  int D; nfel a;
	R = qnftrace( D,a );
	D ist aus Z\{0,1} und quadratfrei.
	a ist Element von Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	R ist die Spur von a bzgl. Q(D^(1/2)) / Q.



			qnfunit( D )

	"quadratic number field unit group"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list qnfunit( D )  int D;
	L = qnfunit( D );
	D ist aus Z\{0,1} und quadratfrei.
	Die Liste L enthaelt Erzeuger der Einheitengruppe U von Q(D^(1/2))
	(Elemente vom Typ nfel), genauer:
	    L = (ew)    und   U = <ew>          fuer D<0,
	    L = (ew,fe) und   U = <ew>x<fe>     fuer D>0,
	wobei ew Einheitswurzel ist (also von endlicher Ordnung) und
	fu Fundamentaleinheit (also von unendlicher Ordnung).
	Fuer D>0 wird die Fundamentaleinheit mit Kettenbruchentwicklung be-
	rechnet. Dabei wird |D|^(1/2) als maximale Periodenlaenge gewaehlt.
	Wenn die tatsaechliche Periodenlaenge groesser als |D|^(1/2) ist,
	so ist fe = _0.
	(vgl. Programm rqnffu)



			rabs( R )                       (MACRO)

	"rational number absolute value"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rabs(R)  rat R;
	S = rabs(R);
	S = |R|.



			rabsheight( r )

	"rational number absolute height"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating rabsheight( r )  rat r;
	h = rabsheight( r );
	r = s/t mit (s, t) = 1 ist eine rationale Zahl.
	Es wird die absolute Hoehe 
	    h( r ) = log max{ |s|, |t| }
        von r zurueckgegeben.



			raval( m, R )

	"rational additive m-adic value"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single raval( m, R )  single m; rat R;
	w = raval( m, R );
	Es muss gelten: m >= 2.
			R != 0.
	w ist der additive m-adische Wert von R, d.h.
	w = iaval(m,Zaehler(R)) - iaval(m,Nenner(R)).



			ravalint( M, R )

	"rational additive value with respect to integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ravalint( M, R )  int M; rat R;
	w = ravalint( M, R );
	M ist > 1.
	R ist ungleich Null.
	w ist der additive M-adische Wert von R, d.h.
	w = iavalint(M,Zaehler(R)) - iavalint(M,Nenner(R)).



			rceil( R )

	"rational number ceiling"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int rceil(R); rat R;
	A = rceil( R );
	A ist die kleinste ganze Zahl, die groessergleich R ist.



			rcomp( R, S )

	"rational number comparison"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single rcomp(R,S)  rat R, S;
	n = rcomp( R, S );
	n ist das Signum von R - S.



			rcons( A, B )

	"rational number construction"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rcons(A,B)    int A, B;
	R = rcons( A, B );
	B ist ungleich Null.
	R ist die gekuerzte Bruchdarstellung von A und B.



			rden( R )                       (MACRO)

	"rational number denominator"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int rden(R)  rat R;
	A = rden(R);
	A ist der Nenner von R.



			rdif( R, S )                    (MACRO)

	"rational number difference"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rdif(R,S)  rat R,S;
	T = rdif(R,S);
	T = R - S .



			rdiscupifact( rd, c, pL )

	"reduced discriminant and discriminant of an univariate polynomial
	over the integers factorization"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list rdiscupifact(rd,c,pL)  int rd,c; list *pL;
	Lr = rdiscupifact(rd,c,pL);
	rd bezeichne die reduzierte Diskriminante eines Polynoms in einer
	Veraenderlichen ueber den ganzen Zahlen.
	c sei der Inhalt der zugehoerigen Resultantengleichung, m.a.W.
	c ist gleich dem Quotienten aus der klassischen Diskriminante
	und der reduzierten Diskriminante.
	Dann ist ist Lr eine Liste aus positiven ganzen Zahlen in folgender
	Form: Lr = ( p0,1,p1,m1, ... , pt,mt) oder
	      Lr = (      p1,m1, ... , pt,mt).
	Dabei besitzt p0 keinen Primfaktor, der p0 im Quadrat teilt,
	fuer 1 <= i <= t ist pi eine Primzahl und mi eine positive ganze
	Zahl, pi < pj falls 0 < i < j.
	rd = p0 * (p1)^m1 * ... * (pt)^mt.
	Fuer *pL gelten die Aussagen analog, wenn man anstelle der
	reduzierten Diskriminante die klassische Diskriminante nimmt.



			rexp( R, n )

	"rational number exponentiation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rexp(R,n); rat R; single n;
	R = rexp( R, n );
	Berechnet wird R hoch n, wobei n groesser oder gleich Null ist.



			rfloor( R )

	"rational number floor"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int rfloor(R)    rat R;
	A = rfloor( R );
	A ist die groesste ganze Zahl, die kleinergleich R ist.



			rfmsp1cons( p, P1, P2 )

	"rational function over modular single prime construction,
	transcendence degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfmsp1cons(p,P1,P2) single p; pol P1,P2;
	R = rfmsp1cons(p,P1,P2);
	P1 und P2 sind Polynome in einer Variablen ueber Z/pZ, mit p
	Primzahl kleiner BASIS. P2 muss ungleich 0 sein.
	R ist die gekuerzte Bruchdarstellung von P1/P2.



			rfmsp1dif( p, R1, R2 )

	"rational function over modular single prime difference,
	transcendence degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfmsp1dif(p,R1,R2) single p; rfunc R1,R2;
	R3 = rfmsp1dif(p,R1,R2);
	R1 und R2 sind Elemente des rationalen Funktionenkoerpers
	in einer Variablen ueber Z/pZ, p Primzahl kleiner BASIS.
	R3 = R1-R2.



			rfmsp1inv( p, R )

	"rational function over modular single primes, transcendence
	 degree 1, inverse"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfmsp1inv(p,R)  single p; rfunc R;
	R1 = rfmsp1inv(p,R);
	R ist ein von 0 verschiedenes Element des rationalen Funktionen-
	koerpers in einer Variablen ueber Z/pZ, p Primzahl kleiner BASIS.
	R1 = R^(-1).



			rfmsp1neg( p, R )

	"rational function over modular single prime negation,
	transcendence degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfmsp1neg(p,R) single p; rfunc R;
	R1 = rfmsp1neg(p,R);
	R ist ein Element des rationalen Funktionenkoerpers in einer
	Variablen ueber Z/pZ, p Primzahl kleiner BASIS.
	R1 = -R.



			rfmsp1prod( p, R1, R2 )

	"rational function over modular single prime product,
	transcendence degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfmsp1prod(p,R1,R2) single p; rfunc R1,R2;
	R3 = rfmsp1prod(p,R1,R2);
	R1 und R2 sind Elemente des rationalen Funktionenkoerpers
	in einer Variablen ueber Z/pZ, p Primzahl kleiner BASIS.
	R3 = R1*R2.



			rfmsp1quot( p, R1, R2 )

	"rational function over modular single prime quotient,
	transcendence degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfmsp1quot(p,R1,R2) single p; rfunc R1,R2;
	R3 = rfmsp1quot(p,R1,R2);
	R1 und R2 sind Elemente des rationalen Funktionenkoerpers
	in einer Variablen ueber Z/pZ, p Primzahl kleiner BASIS, mit
	R2 ungleich 0.
	R3 = R1/R2.



			rfmsp1sum( p, R1, R2 )

	"rational function over modular single prime sum,
	transcendence degree 1"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfmsp1sum(p,R1,R2) single p; rfunc R1,R2;
	R3 = rfmsp1sum(p,R1,R2);
	R1 und R2 sind Elemente des rationalen Funktionenkoerpers
	in einer Variablen ueber Z/pZ, p Primzahl kleiner BASIS.
	R3 = R1+R2.



			rfrcons( r, P1, P2 )

	"rational function over the rationals construction"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfrcons(r,P1,P2) single r; pol P1,P2;
	R = rfrcons(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen mit P2 ungleich 0.
	R ist die gekuerzte Bruchdarstellung von P1/P2.



			rfrdif( r, R1, R2 )

	"rational function over the rationals difference"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfrdif(r,R1,R2) single r; rfunc R1,R2;
	R3 = rfrdif(r,R1,R2);
	R1 und R2 sind Elemente des rationalen Funktionenkoerpers
	in r (0<=r<BASIS) Variablen ueber dem Koerper der rationalen
	Zahlen.
	R3 = R1-R2.



			rfrinv( r, R )

	"rational function over the rationals inverse"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfrinv(r,R) single r; rfunc R;
	R1 = rfrinv(r,R);
	R ist ein von 0 verschiedenes Element des rationalen Funktionen-
	koerpers in r (0<=r<BASIS) Variablen ueber dem Koerper der
	rationalen Zahlen.
	R1 = R^(-1).



			rfrneg( r, R )

	"rational function over the rationals negation"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfrneg(r,R) single r; rfunc R;
	R1 = rfrneg(r,R);
	R ist ein Element des rationalen Funktionenkoerpers in r
	(0<=r<BASIS) Variablen ueber dem Koerper der rationalen
	Zahlen.
	R1 = -R.



			rfrprod( r, R1, R2 )

	"rational function over the rationals product"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfrprod(r,R1,R2) single r; rfunc R1,R2;
	R3 = rfrprod(r,R1,R2);
	R1 und R2 sind Elemente des rationalen Funktionenkoerpers
	in r (0<=r<BASIS) Variablen ueber dem Koerper der rationalen
	Zahlen.
	R3 = R1*R2.



			rfrquot( r, R1, R2 )

	"rational function over the rationals quotient"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfrquot(r,R1,R2) single r; rfunc R1,R2;
	R3 = rfrquot(r,R1,R2);
	R1 und R2 sind Elemente des rationalen Funktionenkoerpers
	in r (0<=r<BASIS) Variablen ueber dem Koerper der rationalen
	Zahlen mit R2 ungleich 0.
	R3 = R1/R2.



			rfrsum( r, R1, R2 )

	"rational function over the rationals sum"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfrsum(r,R1,R2) single r; rfunc R1,R2;
	R3 = rfrsum(r,R1,R2);
	R1 und R2 sind Elemente des rationalen Funktionenkoerpers
	in r (0<=r<BASIS) Variablen ueber dem Koerper der rationalen
	Zahlen.
	R3 = R1+R2.



			rfrtransf( r1, R1, V1, r2, R2, V2, Vn, pV3 )

	"rational function over the rationals transformation"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rfrtransf(r1,R1,V1,r2,R2,V2,pV3) single r1; rfunc R1; list V1;
					       single r2; rfunc R2; list V2;
					       list *pV3;
	R3 = rfrtransf(r1,R1,V1,r2,R2,V2,Vn,pV3);
	R1 ist eine rationale Funktion 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.
	R3 ist die rationale Funktion, die entsteht, wenn in R1 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 von R1 0,
	so wird -BASIS-1 als Ergebnis geliefert.



			rhofrpds( N, b, z )

	"rho- method ( fast reduction ) by Pollard divisor search"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h  
	int rhofrpds(N, b, z)  int N; single b, z;
	P = rhofrpds(N, b, z);
        N > 1 sollte keine Primzahl sein,
        b < N sollte moeglichst zufaellig sein und nicht so gross 
	(z.B.: |b| < 1000),
	z ist die maximale Anzahl der Iterationen.
	P ist ein Teiler von N, schlimmstenfalls P = 1 oder P = N.    
	Es wird mit dem Polynom x^2 - |b| iteriert.
	rhofrpds besitzt eine spezielle Reduktion modulo N, 
	die schneller ist, als die Reduktion, die in rhopds 
	verwendet wird, falls N > 2^60 ist. 		
	zum Algorithnus des rho-Verfahrens siehe z.B.: N. Koblitz,
	"A course of Number Theory and cryptography", Springer 1987, Kap.5.



			rhopds( N, b, z )

	"rho- method by Pollard divisor search" 
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h  
	int rhopds (N, b, z)  int N;  single b, z;
	P = rhopds (N, b, z);
	N > 1 sollte keine Primzahl sein.
	b > 0 sollte moeglichst zufaellig sein und nicht so gross 
	(z.B.: b < 1000).
	z ist die maximale Anzahl der Iterationen.
	P ist ein Teiler von N, schlimmstenfalls P = 1 oder P = N.    
	Es wird mit dem Polynom x^2 + b iteriert.
	siehe z.B.: N. Koblitz,
	"A course of Number Theory and cryptography", 
	Springer 1987, Kap. 5.



			rhopds_lo( N, b, z )

	"rho- method by Pollard divisor search ( lists only )"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h  
        int rhopds (N, b, z)  int N; single b, z;
	P = rhopds (N, b, z);
        N > 1 sollte keine Primzahl sein,
        b > 0 sollte moeglichst zufaellig sein und nicht so gross 
	(z.B.: b < 1000),
	z ist die maximale Anzahl der Iterationen.
	P ist ein Teiler von N, schlimmstenfalls P = 1 oder P = N.    
	Es wird mit dem Polynom x^2 + b iteriert.
	siehe z.B.: N. Koblitz,
	"A course of Number Theory and cryptography", 
	Springer 1987, Kap. 5.         
	Es wird nur innerhalb der SIMATH-Speicherverwaltung (also
	nur mit Listen) gearbeitet.



			rinv( R )

	"rational number inverse"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rinv(R)    rat R;
	S = rinv( R );
	R muss ungleich 0 sein.
	S = R ^ -1.



			rlog2( R )

	"rational number logarithm, base 2"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single rlog2(R)    rat R;
	n = rlog2( R );
	R ist ungleich Null.
	n ist die kleinste ganze Zahl groessergleich log2( |R| ).



			rmax( R, S )                    (MACRO)

	"rational number maximum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rmax(R,S)  rat R,S;
	T = rmax(R,S);
	T ist das Maximum von R und S.



			rmin( R, S )                    (MACRO)

	"rational number minimum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rmin(R,S)  rat R,S;
	T = rmin(R,S);
	T ist das Minimum von R und S.



			rneg( R )

	"rational number negation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rneg(R)  rat R;
	S = rneg(R);
	S = -R .



			rnum( R )                       (MACRO)

	"rational number numerator"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int rnum(R)  rat R;
	A = rnum(R);
	A ist der Zaehler von R.



			rp2( n )

	"rational number power of 2"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rp2(n)    single n;
	R = rp2( n );
	R ist das n-fache Produkt von 2.



			rprod( R, S )

	"rational number product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rprod(R,S)    rat R, S;
	T = rprod( R, S );
	T = R * S.



			rqnfdif( D, a, b )              (MACRO)

	"rational number, quadratic number field element, difference"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel rqnfdif( D, a, b )  int D; rat a; nfel b;
	c = rqnfdif( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist eine 
	rationale Zahl, b ist ein Element aus Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = a - b, die Differenz von a und b (als Zahlkoerperelemente).



			rqnffu( D, pl )

	"real quadratic number field fundamental unit"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel rqnffu( D,pl )  int D; single pl;
	e = rqnffu( D,pl );
	D ist > 1 und quadratfrei, erzeugt also einen reell-quadratischen
	Zahlkoerper K.
	Mittels des Kettenbruchalgorithmus wird die Fundamentaleinheit
	e = e1 + e2*D^(1/2) von K berechnet.
	pl ist die maximale Periodenlaenge. Ist die Periodenlaenge
	groesser als pl, so ist e = _0.



			rqnfquot( D, a, b )

	"rational number, quadratic number field element, quotient"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel rqnfquot( D, a, b )  int D; rat a; nfel b;
	c = rqnfquot( D, a, b );
	Es muss gelten: D ist aus Z\{0,1} und quadratfrei, a ist eine 
	rationale Zahl, b ist ein Element aus Q(D^(1/2)).
	(zur Darstellung von Zahlkoerperelementen siehe z.B. fputnfel)
	c = ERROR, falls b = 0,
	    a/b, der Quotient von a und b als Zahlkoerperelemente, sonst.



			rquot( R, S )                   (MACRO)

	"rational number quotient"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rquot(R,S)  rat R,S;
	T = rquot(R,S);
	Es muss gelten : S!=0 .
	T = R / S.



			rsign( R )                      (MACRO)

	"rational number signum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single rsign(R)  rat R;
	n = rsign(R);
	n ist das Vorzeichen von R.



			rsum( R, S )

	"rational number sum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat rsum(R,S)   rat R, S;
	T = rsum( R, S );
	T = R + S.



			rtofl( r )

	"rational number to floating point"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating rtofl( r )  rat r;
	f = rtofl ( r );    
	f ist die floating point Darstellung von r. Genauer gilt:
	| ( r - f ) / r | < 1/2 * (2^30)^( 1 - FL_EPS ).                                                          



			rtomi( R, M )

	"rational number to modular integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int rtomi( R, M )  rat R, int M;
	A = rtomi( R, M );
	Die rationale Zahl R wird modulo M reduziert, 
	das heisst, ist R = Z/N, dann ist 
	A = Z * N^(-1) modulo M. 
	Ist der Nenner N nicht invertierbar modulo M, 
	so wird Ergebnis 0 zurueckgeliefert.



			rtonf( R )

	"rational number to number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel rtonf( R )         rat R;
	a = rtonf( R );
	a ist die Darstellung der rationalen Zahl R als Element eines
	ZK. vom Typ nfel. a wird als Polynom in einer Variablen in dense-
	Darstellung ueber Q vom Grad 0 mit Hauptnenner ( falls R ungleich
	0 ) dargestellt.
	a = 0                ,falls R = 0.
	a = ( r2, 0, r1 )    ,falls R = ( r1,r2 ) ungleich 0.



			rtonfs( R )

	"rational number to number field element, sparse representation"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel rtonfs(R)  rat R;
	a = rtonfs(R);
	a ist die Darstellung der rationalen Zahl A als Polynom in einer
	Variable ueber den rationalen Zahlen (sparse-Darstellung).



			rtopfel( p, d, R )

	"rational to p-adic field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pfel rtopfel( p, d, R )         single p,d; rat R;
	c = rtopfel( p, d, R );
	Dabei muss gelten:
	      - p ist single-prime.
	c ist die Approximation zu R aus Qp vom Grad d, fuer die bzgl.
	der additiven p-adischen Bewertung vp gilt:
		      vp( R - c ) >= d
	      und     c = 0                           ,falls d < vp( R )
	      sonst   c = c_vp( R ) * p^vp( R ) + ... + c_d * p^d,
	      wobei   c_vp( R ) != 0     und
		      0 <= c_i <= p - 1
	  =>  c = 0                       ,falls R = 0 oder alle c_i = 0
		  ( d, vp( R ), c_vp( R ), ..., c_d )



			rtoqnf( D, A )                  (MACRO)

	"rational number to quadratic number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel rtoqnf( D, A )  int D; rat A;
	c = rtoqnf( D, A );
	D ist aus Z\{0,1} und quadratfrei.
	c = 0, falls A = 0,
	c = ( b  0  a ), falls A = a/b mit gcd(a,b) = 1, b > 0,
	d.h. c ist die Darstellung von A als Zahlkoerperelement.



			rtorfr( r, R )

	"rational number to rational function over rationals"
	Quellbibliothek: srclib.arith3
	Include-Datei:   _arith3.h
	rfunc rtorfr( r, R )  single r; rat R;
	f = rtorfr( r, R );
	f ist die Darstellung der rationalen Zahl R als rationale Funktion
	ueber Q in r Variablen ( 0 <= r < BASIS ).
	f = 0, falls R = 0.



			sabs( a )                       (MACRO)

	"single-precision absolute value"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single sabs(a)  single a;
	n = sabs(a);
	n = |a|.



			sbtoudpm2( a )                  (MACRO)

	"special bit-representation to univariate dense polynomial 
	 over modular 2"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol sbtoudpm2(a)  obj a;
	P = sbtoudpm2(a);
	a ist die spezielle Bit-Darstellung eines Polynoms in einer 
	Variable ueber Z/2Z; P ist das zugehoerige dense-Polynom in 
	einer Variable ueber Z/2Z.
	Das Programm stellt die Umkehrfunktion zu --> udpm2tosb dar.



			sdisccleq( D, L )

	"single discriminant class equation"
	Quellbibliothek: srclib.arith2
	Include-Datei:	 _arith2.h
	pol sdisccleq (D,L)  single D; list L;
	H = sdisccleq (D,L);
	Berechnet wird die Klassengleichung zur Diskriminante
	D<0. L ist eine Liste von primitiven, reduzierten,
	binaeren quadratischen Formen der Diskriminante D wie
	mit -> iprpdbqf erzeugt.
	H ist ein Polynom ueber Z.



			segcd( a, b, pu, pv )

	"single-precision extended greatest common divisor"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single segcd(a,b,pu,pv)
	single a, b; single *pu, *pv;
	c = segcd( a, b, pu, pv );
	a,b >= 0.
	c ist der groesste gemeinsame Teiler von a und b.
	Falls a = b = 0, ist c = 0.
	Berechnet werden *pu, *pv, so dass
	*pu * a + *pv * b = c.



			seven( a )                      (MACRO)

	"single-precision even"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single seven(a)  single a;
	n = seven(a);
	n ist 1, falls a gerade ist,
	  und 0, falls a ungerade ist.



			sexp( a, n )                    (MACRO)

	"single-precision exponentiation"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single sexp(a,n)  single a,n;
	b = sexp(a,n);
	Es muss gelten : n>=0 ; |a^n|<BASIS .
	b = a ^ n.



			sfact( n )

	"single factorization"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list sfact(n)  single n;
	L = sfact(n);
	Es muss gelten : n > 0.
	L = (p1,...,pn) mit p1<=...<=pn ist die Liste der Primfaktoren 
	von n, d.h. n = p1 * ... * pn.



			sfactors( n )

	"single factors"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list sfactors(n)  single n;
	L = sfactors(n);
	Es muss gelten : n > 0.
	L = (p1,...,pn) mit p1<...<pn ist die Liste der verschiedenen 
	Primfaktoren von n.



			sfel( n )

	"single factor exponent list"
	Quellbibliothek: srclib.arith1
	Include_Datei:   _arith1.h
	list sfel(n)  single n;
	L = ifel(n);
	n ist positiv.
	L = (p1,e1, ... ,pr,er) mit r >= 0, p1 > ... > pr > 1 und ei > 0
	ist die Liste der Primfaktoren und zugehoerigen Exponenten von n,
	d.h. n = p1^e1 * ... * pr^er.



			sgcd( a, b )

	"single-precision greatest common divisor".
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single sgcd ( a, b )   single a, b;
	c = sgcd( a , b );
	a,b >= 0.
	c ist der groesste gemeinsame Teiler von a und b.
	Falls a = b = 0, wird Wert 0 geliefert.



			sgetfl( ps )

	"string get floating point" 
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating sgetfl( ps )  char **ps;
	f = sgetfl( ps );
	f wird vom String *ps gelesen.
	*ps zeigt anschliessend auf das Zeichen hinter dem zuletzt 
	gelesenen Zeichen. 
	Laeuft sgetfl fehlerhaft ab, so wird f = ERROR geliefert.  
	Es werden folgende Darstellungen von f akzeptiert:
        - als ganze Zahl;
	- als Bruch;
	- in folgenden Formaten (n und m seien beliebige 
	  Ziffernfolgen, b und d positive singles) :
	    [+-]m.n e [+-]d 
	    [+-]m.n E [+-]d
	    [+-]m.n * b ^ [+-]d 
	    [+-]m.n * b ** [+-]d    
	    b^[+-]d 
	    b**[+-]d   
	    [+-]m.n                      
	  Dabei entspricht 'e' bzw. 'E' dem Ausdruck "* 10 ^". 
	  Statt eines Punktes kann auch ein Komma stehen, 
	  entweder m oder .n koennen fehlen;
	- als Liste, die einen korrekten floating point 
	  darstellt (interne Darstellung von f);      
	- Der character 'e' wird als Eulersche Zahl
	  interpretiert.
	- Die character-Folge "Pi" wird als 3.14... interpretiert.
	Ist a der genaue Wert, der einzulesen ist, so gilt :
	| ( a - f ) / a | <  1/2 * (2^30)^( 1 - FL_EPS ).     



			sgetflsp( ps )

	"string get floating point special version" 
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating sgetflsp( ps )  char **ps;
	f = sgetflsp( ps );
	f wird vom String *ps gelesen.
	*ps zeigt anschliessend auf das Zeichen hinter dem zuletzt 
	gelesenen Zeichen. 
	Laeuft sgetflsp fehlerhaft ab, so wird f = ERROR geliefert.  
	Es werden folgende Darstellungen von f akzeptiert
	(n und m seien beliebige Ziffernfolgen, b und d positive 
	singles):
	    [+-]m.ne[+-]d 
	    [+-]m.n                      
	  Dabei entspricht 'e' dem Ausdruck "* 10 ^". 
	  Entweder m oder .n koennen fehlen.
	Ist a der genaue Wert, der einzulesen ist, so gilt :
	| ( a - f ) / a | <  1/2 * (2^30)^( 1 - FL_EPS ).    
	Siehe auch sgetfl.    
	(Der Sinn von sgetflsp liegt darin, beim Einlesen von 
	Matrizen bzw. Polynomen ueber floating points Missver-
	staendnisse bezueglich der Zeichen ',', 'e', 'E', '*', 
	'^' zu vermeiden.) 



			sgeti( ps )

	"string get integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	int sgeti(ps)  char **ps;
	A = sgeti( ps );
	A wird vom String *ps gelesen.
	*ps zeigt anschliessend auf das Zeichen hinter dem zuletzt 
	gelesenen Zeichen. 
	Laeuft sgeti fehlerhaft ab, so wird A = ERROR geliefert.



			sgetr( ps )

	"string get rational number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	rat sgetr(ps)  char **ps;
	R = sgetr( ps );
	R wird vom String *ps gelesen und, falls notwendig, in die
	gekuerzte Darstellung umgewandelt.
	*ps zeigt anschliessend auf das Zeichen hinter dem zuletzt 
	gelesenen Zeichen. 
	Bei Fehler wird R = ERROR geliefert.



			sgetsi( ps )

	"string get single"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single sgetsi( ps )  char **ps;
	n = sgetsi( ps );
	n wird vom String *ps gelesen.
	*ps zeigt anschliessend auf das Zeichen hinter dem zuletzt 
	gelesenen Zeichen. 
	Bei Fehler wird n = ERROR geliefert.



			slog2( a )

	"single-precision logarithm, base 2"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single slog2(a) single a;
	b = slog2( a );
	b ist 0, falls a gleich 0.
	Sonst ist b der um 1 vermehrte ganzzahlige Anteil von log2(|a|).



			smax( a, b )                    (MACRO)

	"single-precision maximum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single smax(a,b)  single a,b;
	c = smax(a,b);
	c ist das Maximum von a und b.



			smin( a, b )                    (MACRO)

	"single-precision minimum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single smin(a,b)  single a,b;
	c = smin(a,b);
	c ist das Minimum von a und b.



			sodd( a )                       (MACRO)

	"single-precision odd"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single sodd(a)  single a;
	n = sodd(a);
	n ist 1, falls a ungerade ist,
	  und 0, falls a gerade ist.



			spgen( a, b )

	"single prime generator"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	list spgen(a,b)  single a,b;
	L = spgen(a,b);
	Es muss gelten : a,b > 0.
			 a+2*b <= BASIS.
	L = (p1,...,pr) mit p1<...<pr ist die Liste aller Primzahlen p mit
	a <= p < a+2*b.
	ACHTUNG !!!  Ein character-array der Laenge b+1 wird benoetigt.
	Falls spgen fehlerhaft verlaeuft, ist L = ERROR.



			sprod( a, b, pc, pd )

	"single-precision product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single sprod( a, b, pc, pd )  single a, b, *pc, *pd;
	f = sprod( a, b, pc, pd );
	Berechnet werden *pc, *pd, wobei
	*pc der ganzzahlige Anteil von (a*b)/BASIS ist und *pd, so dass
		1.) (*pc) * (*pd) >= 0 und
		2.) (*pc) * BASIS + (*pd) = a * b.
	f hat den Wert 0.



			sputflsp( prec, f, str )

	"string put floating point special version"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	char *sputflsp(prec, f, str)  single prec; floating f; char *str;
	ptr = sputflsp( prec, f, str );                             
	Es muss gelten: prec >= 0. 
	Die Zahl f wird in der Form nnn.nnn auf den String str 
	geschrieben. sputflsp ueberprueft nicht, ob der Bereich, 
	auf den str zeigt, fuer das Ergebnis lang genug ist. 
	prec gibt die maximale Anzahl der ausgegebenen  
	Nachkommastellen an. 
	ptr liefert den Zeiger auf die Ergebniszeichenreihe.



			sputi( A, str )

	"string put integer"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	char *sputi(A,str)  int A; char *str;
	ptr = sputi( A,str);
	A wird auf den Bereich geschrieben, auf den str zeigt.
	!!! sputi ueberprueft nicht, ob der Bereich, auf den str zeigt,
	    fuer das Ergebnis lang genug ist !!!
	ptr liefert den Zeiger auf die Ergebniszeichenreihe.



			sputr( R, str )

	"string put rational number"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	char *sputr(R,str)  rat R; char *str;
	ptr = sputr( R,str );
	Die Zahl R wird auf den Bereich geschrieben, auf den str zeigt.
	!!! sputr ueberprueft nicht, ob der Bereich, auf den str zeigt,
	    fuer das Ergebnis lang genug ist !!!
	ptr liefert den Zeiger auf die Ergebniszeichenreihe.



			sqrem( a, b, d, pq, pr )

	"single-precision quotient and remainder"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single sqrem( a, b, d, pq, pr )  single a, b, d, *pq, *pr;
	c = sqrem( a, b, d, pq, pr );
	Es muss gelten: a*b nicht-negativ und |a|<|d|.
	Sei A := (a*BASIS + b).
	Berechnet werden *pq als der ganzzahlige Anteil von A/d
	und *pr = A - (*pq) * d.
	ACHTUNG: Entgegen den Divisionszeichen '/', '%' der Sprache C
	gilt also hier:  sign(Rest) == sign(Dividend) !!
	c hat den Wert 0.



			ssign( a )                      (MACRO)

	"single-precision signum"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ssign(a)  single a;
	n = ssign(a);
	n ist das Vorzeichen von a.



			ssqrt( n )

	"single-precision square root"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single ssqrt(n)  single n;
	m = ssqrt(n);
	Es muss gelten : n>=0.
	m ist der ganzzahlige Anteil der Quadratwurzel von n.



			sxprod( a, b, pc, pd )

	"single XOR product"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single sxprod(a,b,pc,pd)  single a, b;  single *pc, *pd;
 	f = sxprod( a, b, pc, pd );
	sxprod arbeitet wie sprod, allerdings mit dem Unterschied,
	dass beim Addieren zweier 32-Bit-Worte Uebertraege einfach
	ignoriert werden, d.h. es wird anstatt mit '+' mit dem XOR-
	Operator '^' gearbeitet.
	Wenn ERG das (spezielle) Gesamtprodukt bezeichnet, so 
	werden *pc und *pd bestimmt, wobei
	*pc der ganzzahlige Anteil von ERG / BASIS ist und 
	*pd, so dass
		(*pc) * BASIS + (*pd) = ERG.
	f hat den Wert 0.



			sxprods( a, b )

	"single XOR product special"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single sxprods(a,b)  single a, b; 
 	f = sxprod( a, b );
	a und b sind singles kleiner als 2^15.
	sxprods arbeitet so, wie in sxprod beschrieben (siehe Doku
	von sxprod). Da hier a und b kleiner als 2^15 sind, kann man
	das Ergebnis in  e i n e m  32-Bit-Wort (naemlich in f)
        ablegen.



			sxsqu( a, pc, pd )

	"single XOR square"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	single sxsqu(a,pc,pd)  single a;  single *pc, *pd;
 	f = sxsqu( a, pc, pd );
	sxsqu(a,pc,pd) liefert dasselbe Ergebnis wie sxprod(a,a,pc,pd)
	(siehe Doku von sxprod), allerdings wird effizienter gerechnet.
	Wenn ERG das (spezielle) Quadrat bezeichnet, so werden *pc und
	*pd bestimmt, wobei 
	*pc der ganzzahlige Anteil von ERG / BASIS ist und 
	*pd, so dass
		(*pc) * BASIS + (*pd) = ERG.
	f hat den Wert 0.



			udprtonfel( P )

	"univariate dense polynomial over rationals to number field 
	element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel udprtonfel( P )  pol P;
	a = udprtonfel( P );
	P ist dense-Polynom in einer Variablen ueber Q.
	a = 0, falls P = 0. 
	Sonst ist a das P entsprechende dense-Polynom in einer Variablen 
	ueber Z mit vorangestelltem Hauptnenner.
	a kann also als Zahlkoerperelement interpretiert werden.



			upgf2gen( G, m )

	"univariate polynomial over Galois-field with characteristic 2,
        random generator"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol upgf2gen( G, m )  obj G; single m;
	P = upgf2gen( G, m );
        Dabei muss gelten:
        - 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).
	- m ist nicht-negativ.
	P ist ein zufaellig erzeugtes Polynom in einer Variablen ueber 
        GF(2^n) vom Grad <= m mit Koeffizienten in der speziellen Bit-
        Darstellung, P != Nullpolynom.



			upid4cubres( P )

	"univariate polynomial over integers of degree 4 cubic resolvent"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	pol upid4cubres( P )  pol P;
	L = upid4cubres( P );
	Dabei muss gelten: P ist ein irreduzibles normiertes Polynom
                           vom Grad 4 in einer Veraenderlichen ueber Z.
	Das Programm berechnet zu einem Polynom vom Grad 4 in der Form
        x^4 - s*x^3 + p*x^2 - q*x + n  mit ganzen Koeffizienten s, p, q 
	und n die kubische Resolvente nach der Formel:
            L(y) = y^3 - p*y^2 + (s*q - 4*n)*y + (-s^2*n + 4*p*n - q^2).     
	Literatur: J. Buchmann and D. Ford:
                   On the computation of totally real quartic fields of 
		   small discriminant, M. o. C. V.52.  p.161-174.



			upinfeevals( F, P, a )

	"univariate polynomial over the integers number field element
	evaluation special"
	Quellbibliothek : srclib.arith2
	Include - Datei : _arith2.h
	pol upinfeevals(F,P,a) pol F,P,a;
	b = upinfeevals(F,P,a);
	F ist das definierende Polynom einer separablen Algebra ueber den
	rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
	in einer Veraenderlichen ueber den ganzen Zahlen.
	P ist ein Polynom in einer Veraenderlichen ueber den ganzen Zahlen.
	a ist ein Element obiger Algebra und wird repraesentiert durch ein
	CD - Polynom ( siehe cdprfcl ).
	b ist ein CD - Polynom, das dem Element der Algebra entspricht, das
	durch Einsetzen von a in P entsteht.



			upprmsp1afes( p, F, P, a )

	"univariate polynomial over polynomial ring over modular single
	prime, transcendence degree 1, algebraic function over modular
	single prime, transcendence degree 1, evaluation special"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	pol upprmsp1afes(p,F,P,a) single p; pol F,P,a;
	b = upprmsp1afes(p,F,P,a);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x].
	P ist ein Polynom in einer Unbestimmten ueber (Z/pZ) [x].
	a ist ein Element dieser Algebra und wird durch ein CD - Polynom
	repraesentiert ( siehe cdprfmsp1fcl ).
	b ist gleich P(a) und wird durch ein CD - Polynom repraesentiert.



			uprtonfel( F, P )

	"univariate polynomial over rationals to number field element"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	nfel uprtonfel( F, P )  pol F, P;
	a = uprtonfel( F, P );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variablen ueber Z in dense-Darstellung.
	      - P ist Polynom in einer Variablen ueber Q.
	a = 0, falls P = 0.
        Sonst ist a das reduzierte und P entsprechende Zahlkoerperele-
        ment aus dem durch F gegebenen Zahlkoerper,



			uspprmsp1apf( p, P, F, k )

	"univariate separable polynomial over polynomial ring over
	modular single prime, transcendence degree 1, approximation
	of P-adic factorization"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	list uspprmsp1apf(p, P, F, k)  single p; pol P, F; single k;
	L1 = uspprmsp1apf(p, P, F, k);
	p ist eine single Primzahl.
	P ist ein normiertes Primpolynom aus (Z/pZ) [x], wobei x
	eine Unbestimmte ueber Z/pZ ist.
	F ist ein normiertes, separables Polynom in einer Unbestimmten
	ueber dem Polynomring (Z/pZ) [x] mit Grad(F) > 1.
	k ist eine ganze Zahl > 1; sei t die kleinste Zweierpotenz
	groesser gleich 2*k, dann muss t * deg(P) noch single sein.
	P^k teilt nicht die reduzierte Diskriminante von F
	(siehe upprmsp1redd).
	L1 = (f_1, ... ,f_r) ist eine Liste von Polynomen in einer
	Unbestimmten ueber (Z/pZ) [x] mit positiven Graden.
	F = f_1 * ... * f_r mod M mit M = P^(2*k).
	(Z/pZ) (x) sei der rationale Funktionenkoerper in x ueber Z/pZ.
	Ueber der vollstaendigen Huelle von (Z/pZ) (x) bezueglich der
	durch die P-adische Bewertung v_P gegebenen Abstandsfunktion sei
	F = P_1 * ... * P_s in normierte irreduzible Polynome faktorisiert,
	dann ist r = s, und bei geeigneter Numerierung ist P_i kongruent
	zu f_i modulo P^(2*k) fuer 1 <= i <= r, genauer gesagt hat die
	Differenz aus P_i und dem homomorphen Bild von f_i in der
	vollstaendigen Huelle v_P - Wert groesser gleich 2 * k.
	Die Koeffizienten der f_i haben Grade, die kleiner sind als
	(2 * k) * deg(P).



			vepepuspmsp1( p, F, a, P, k, v )

	"values of the extensions of the P-adic valuation of an element
	of the polynomial order of a univariate separable polynomial
	over the polynomial ring over modular single prime, transcendence
	degree 1"
	Quellbibliothek: srclib.arith4
	Include-Datei:   _arith4.h
	list vepepuspmsp1( p, F, a, P, k, v )  pol F, a, P; single p, k, v;
	L = vepepuspmsp1( p, F, a, P, k, v );
	p ist eine single Primzahl.
	R bezeichne den Polynomring (Z/pZ) [x], wobei x eine Unbestimmte
	ueber Z/pZ sei.
	K bezeichne den rationalen Funktionenkoerper (Z/pZ) (x).
	F ist ein normiertes, separables Polynom in der Unbestimmten y
	ueber R mit Grad(F) > 1.
	a ist ein Element aus der Polynomordnung R[y] / ( F * R[y] ) und
	wird durch ein Polynom in einer Unbestimmten ueber R mit Grad 
	kleiner als dem Grad von F repraesentiert.           
	P ist ein normiertes Primpolynom aus R.
	k ist eine ganze Zahl > 1; sei t die kleinste Zweierpotenz
	groesser gleich 2*k, so muss t * Grad(P) noch single sein.
	P^k teilt nicht die reduzierte Diskriminante von F
	(siehe upprmsp1redd).
	v ist eine nicht negative ganze Zahl, so dass die kleinste Zahl z 
	groesser gleich v, fuer die z / k eine Zweierpotenz ist, 
	noch single ist.  Zur Bedeutung von v s.u.
	Dann ist L eine Liste der Form ( L1, L2 ). Dabei ist L1 eine
	Liste ( F_1, k_1, ... F_r, k_r ) mit einer positiven single r.
	F_i bezeichne jeweils ein normiertes Polynom in y ueber R
	mit positivem Grad, so dass gilt: F = F_1 * ... * F_r mod P^(2*k).
	Die Koeffizienten von F_i haben Grade, die kleiner als t * Grad(P)
	sind.
	Sei F = A_1 * ... * A_s die Faktorisierung von F ueber der
	vollstaendigen Huelle von K bezueglich der durch die P-adische
	Bewertung v_P gegebenen Abstandsfunktion in normierte irreduzible
	Polynome A_i, dann ist r = s und bei geeigneter Numerierung ist
	A_i kongruent zu F_i modulo P^(2*k).
        Sei (P) das von dem Primpolynom P in O - dem Ring der ganzen
	Elemente in K[y] / ( F * K[y] ) - erzeugte Hauptideal, dann besitzt
	(P) in O eine Zerlegung in r verschiedene Primideale P_i der Form:
	(P) = P * O = (P_1)^e_1 * ... (P_r)^e_r mit obigem r.
	Bei geeigneter Numerierung ist in O_i - dem Ring der ganzen
	Elemente von K_i := K[y] / ( F_i * K[y] ) - das von P erzeugte
	Haupideal P * O_i = (R_i)^e_i, wobei R_i ein Primideal in O_i ist.
	Die k_i sind positive ganze Zahlen, so dass die e_i sich aus der
	Gleichung k_i * e_i = Grad(F_i) = Grad(A_i) ergeben. M.a.W. sind
	die k_i die Restklassengrade der zugehoerigen Primideale P_i.
	L2 ist eine Liste der Form ( v_1, ... , v_r ), wobei v_i eine
	ganze Zahl groesser gleich -2 ist.
	Sei V_(P_i) die normierte Fortsetzungsbewertung der P-adischen
	Bewertung v_P, die durch das Primideal P_i gegeben ist.
	Sei K* die Menge der Nichtnullteiler von (K[y] / (F * K[y])) \ {0},
	dann gilt also V_(P_i) ( K* ) = Z.
	Falls v gleich Null ist, so ist v_i nicht gleich -1, und es ist -2,
	wenn V_(P_i) (a) unendlich ist, sonst gilt V_(P_i) (a) = v_i.
	Falls v > 0, so gilt fuer v_i ungleich -1 obige Aussage.
	Fuer v_i = -1 gilt V_(P_i) (a) >= ( s / k_i ), wobei s die 
	kleinste Zahl groesser gleich v ist, fuer die s / k eine
	Zweierpotenz ist.
	Sollte also nur eine untere Schranke S fuer die V_(P_i) - Werte
	noetig sein, so kann v = S * Grad(F) gewaehlt werden, denn es gilt
	k_i <= Grad(F_i) <= Grad(F) und 
	V_(P_i) (a) >= (s / k_i) >= (v / k_i) >= (v / Grad(F)) = S.



			vepvelpruspi( F, a, p, k, v )

	"values of the extensions of the p-adic valuation of an element
	of the polynomial ring of an univariate separable polynomial
	over the integers"
	Quellbibliothek: srclib.arith2
	Include-Datei:   _arith2.h
	list vepvelpruspi(F, a, p, k, v)  pol F, a; single p, k, v;
	L = vepvelpruspi(F, a, p, k, v);
	Z bezeichne die ganzen und Q die rationalen Zahlen, x sei eine
	Unbestimmte ueber Q.
	F ist ein normiertes, separables Polynom in x ueber Z mit 
	Grad(F) > 1.
	a ist ein Element aus R := Z[x] / ( F * Z[x] ) und wird durch
	ein Polynom in einer Veraenderlichen ueber Z mit Grad kleiner
	als dem Grad von F repraesentiert.           
	p ist eine single Primzahl.	
	k ist eine ganze Zahl > 1, so dass die kleinste Zweierpotenz
	groesser gleich 2*k noch eine single ist.
	p^k teilt nicht die reduzierte Diskriminante von F
	(siehe upireddiscc).
	v ist eine nicht negative ganze Zahl, so dass die kleinste Zahl z
	groesser gleich v, fuer die z / k eine Zweierpotenz ist, 
	noch single ist. Zur Bedeutung von v s.u.
	Dann ist L eine Liste der Form ( L1, L2 ). Dabei ist L1 eine
	Liste ( F_1, k_1, ... F_r, k_r ) mit einer positiven single r.
	F_i bezeichne jeweils ein normiertes Polynom in x ueber Z
	mit positivem Grad, so dass gilt: F = F_1 * ... * F_r mod p^(2*k).
	Die Koeffizienten von F_i liegen in [0,p^t-1], wobei t die kleinste
	Zweierpotenz groesser gleich 2*k ist.
	Sei F = A_1 * ... * A_s die Faktorisierung von F ueber den
	p-adischen ganzen Zahlen in normierte irreduzible Polynome A_i, 
	dann ist r = s und bei geeigneter Numerierung ist 
	A_i kongruent zu F_i modulo p^(2*k).
        Sei (p) das von der Primzahl p in O - dem Ring der ganzen Zahlen
	in K := Q(x) / ( F * Q(x) ) - erzeugte Hauptideal, dann besitzt
	(p) in O eine Zerlegung in r verschiedene Primideale P_i der Form:
	(p) = p * O = (P_1)^e_1 * ... (P_r)^e_r mit obigem r.
	Bei geeigneter Numerierung ist in O_i - dem Ring der ganzen Zahlen
	von K_i := Q(x) / ( A_i * Q(x) ) - das von p erzeugte Haupideal
	p * O_i = (R_i)^e_i, wobei R_i ein Primideal in O_i ist.
	Die k_i sind positive ganze Zahlen, so dass die e_i sich aus der
	Gleichung k_i * e_i = Grad(F_i) = Grad(A_i) ergeben. M.a.W. sind
	die k_i die Restklassengrade der zugehoerigen Primideale P_i.
	L2 ist eine Liste der Form ( v_1, ... , v_r ), wobei v_i eine
	ganze Zahl groesser gleich -2 ist.
	Sei V_(P_i) die normierte Fortsetzungsbewertung der p-adischen
	Bewertung v_P, die durch das Primideal P_i gegeben ist.
	Sei K* die Menge der Nichtnullteiler von K \ {0}, dann gilt also
	V_(P_i) ( K* ) = Z.
	Falls v gleich Null ist, so ist v_i nicht gleich -1 und es ist -2,
	wenn V_(P_i) (a) unendlich ist, sonst gilt V_(P_i) (a) = v_i.
	Falls v > 0, so gilt fuer v_i ungleich -1 obige Aussage.
	Fuer v_i = -1 gilt V_(P_i) (a) >= ( s / k_i ), wobei s die 
	kleinste Zahl groesser gleich v ist, fuer die s / k eine
	Zweierpotenz ist.
	Sollte also nur eine untere Schranke S fuer die V_(P_i) - Werte
	noetig sein, so kann v = S * Grad(F) gewaehlt werden, denn es gilt
	k_i <= Grad(F_i) <= Grad(F) und
 	V_(P_i) (a) >= (s / k_i) >= (v / k_i) >= (v / Grad(F)) = S.



			volunitball( r )

	"volume of the unit ball"
	Quellbibliothek: srclib.arith1
	Include-Datei:   _arith1.h
	floating volunitball( n )  single n;       
        c = volunitball( n );
	n ist positiv.
	volunitball berechnet das Volumen c(n) der 
	n-ten Einheitskugel im R^n. Es ist 
		         n/2
                       Pi 
                    ----------  , falls n gerade
                     ( n/2 )! 
        c =                    (n-1)/2
                     2 * (2 Pi)
                    --------------------- , falls n ungerade
	               (n-1)/2
		        ----
		         ||   (2k + 1)
                        k = 0



