// Zahlen.cpp : Definiert den Einsprungpunkt für die Konsolenanwendung.
//

#include "stdafx.h"
#include <iostream.h>
#include <fstream.h>
#include "koerper.h"
#include "polynom.h"
#include "frommer.h"
#include "Parameterliste.h"
#include <stdlib.h>
#include "KoeffListe.h"
#include "Statistik.h"
#include <time.h>



//kbhit
#ifdef WIN32
	#include <conio.h> // für _kbhit()
	int kbhit()
	{
		return _kbhit();
	}
#else
	#include <sgtty.h>
	#include <curses.h> // für _kbhit()
	int kbhit()
	{
		static unsigned i;

		ioctl(0, FIONREAD, &i);
		return i;
	}

#endif

/* note #undef's at end of file */
#define IA 16807
#define IM 2147483647
#define AM (1.0/IM)
#define IQ 127773
#define IR 2836
#define NTAB 32
#define NDIV (1+(IM-1)/NTAB)
#define EPS 1.2e-7
#define RNMX (1.0-EPS)

float ran1(long *idum)
{
	int j;
	long k;
	static long iy=0;
	static long iv[NTAB];
	float temp;

	if (*idum <= 0 || !iy) {
		if (-(*idum) < 1) *idum=1;
		else *idum = -(*idum);
		for (j=NTAB+7;j>=0;j--) {
			k=(*idum)/IQ;
			*idum=IA*(*idum-k*IQ)-IR*k;
			if (*idum < 0) *idum += IM;
			if (j < NTAB) iv[j] = *idum;
		}
		iy=iv[0];
	}
	k=(*idum)/IQ;
	*idum=IA*(*idum-k*IQ)-IR*k;
	if (*idum < 0) *idum += IM;
	j=iy/NDIV;
	iy=iv[j];
	iv[j] = *idum;
	if ((temp=(float)(AM*iy)) > RNMX) return (float) RNMX;
	else return temp;
}
#undef IA
#undef IM
#undef AM
#undef IQ
#undef IR
#undef NTAB
#undef NDIV
#undef EPS
#undef RNMX

unsigned short random (long *seed, unsigned short max) // liefert eine Zufallszahl zwischen 0 und max (ganze Zahlen)
{
	float zahl = 1;

	while (zahl == 1)
		zahl = ran1(seed);

	// zahl ist zwischen 0 (eingeschl.) und 1 (ausgeschlossen)
	zahl = zahl * (max+1);
	// zahl ist zwischen 0 (eingeschl.) und max+1 (ausgeschlossen)

	//also muß zahl nur noch abgerundet werden (HC)
	
	return  (unsigned short) (zahl - 0.0);
}


zahl readnextwert(char* str,  int* offKl, unsigned int* stelle, koerper* k, int* isAll, int* isRandom)
{
	zahl z(0);
	char zahlstr[100];
	unsigned int i = 0;
	int status = 0;

	while ((*stelle<=strlen(str))&&(status <2))
	{
		if (str[*stelle] == '{') (*offKl)++;
		else
		if (str[*stelle] == '}') (*offKl)--;
		else
		if ((*offKl==4)&&((str[*stelle] == '0')||(str[*stelle] == '1')||(str[*stelle] == '2')||(str[*stelle] == '3')||(str[*stelle] == '4')||
			(str[*stelle] == '5')||(str[*stelle] == '6')||(str[*stelle] == '7')||(str[*stelle] == '8')||(str[*stelle] == '9')||
			(str[*stelle] == 'A')||(str[*stelle] == '?')||
			(str[*stelle] == '-')||(str[*stelle] == '*')||(str[*stelle] == 'e')||(str[*stelle] == '+')))
		{
			zahlstr[i] = str[*stelle];
			zahlstr[i+1] = '\0';
			i++;
			status = 1;
		}
		else
			if (status==1) status = 2;
		
		(*stelle) ++;
	}

	(*isAll)=0;
	(*isRandom)=0;
	if (strcmp(zahlstr, "A") == 0) // A steht für alle; * ist dummerweise schon für die Multiplikation belegt
	{
		(*isAll)=1;
		return 0;
	}
	if (strcmp(zahlstr, "?") == 0) // ? steht für zufälliges befüllen
	{
		(*isRandom)=1;
		return 0;
	}
		

	int zz=0;
	int neg = 0;
	int eps = 0;
	char zzz[100];
	int zaehler=0;
	int schoneinzeichen = 0;
	for (i=0; i< strlen(zahlstr); i++)
	{
		if ((zahlstr[i] =='-')&&(schoneinzeichen==0)) neg=1;
		else if (zahlstr[i] =='e') {eps=1;}
		else if ((zahlstr[i] =='+')||(zahlstr[i] =='-'))
		{
			if (eps==0)
			{
				zz=atoi(zzz);
				z.x = zz;eps=1;zz=0;
				zaehler=0;
				zzz[zaehler]='\0';
			}
			else
			{
				zz=atoi(zzz);
				z.eps = zz;eps=0;zz=0;
				zaehler=0;
				zzz[zaehler]='\0';
			}
			if (neg==1) z = k->negativ(z);
			neg =0;
			schoneinzeichen = 0;
			if ((zahlstr[i] =='-')&&(schoneinzeichen==0)) neg=1;
		}
		else if (zahlstr[i] != '*')
		{
			zzz[zaehler]=zahlstr[i];
			zzz[++zaehler] = '\0';
			schoneinzeichen ++;
		}	
	}
	zz=atoi(zzz);
	if (neg==1) z = k->negativ(z); // erst mal mit -1, damit nachher beim -1-nehmen das x wieder stimmt
	if (eps==0)
	{
		z.x = zz;eps=1;zz=0;
	}
	else
	{
		z.eps = zz;eps=0;zz=0;
	}
	if (neg==1) z = k->negativ(z); //jetzt beide komponenten mal -1


	return z;
}

void ausgabestart(Parameterliste *p, char *ausgabedatei)
{
	ofstream datei;

	//datei.open("C:\\projekte\\HC\\Zahlen\\Zahlen\\Ausgabe.txt", ios::out);
	datei.open(ausgabedatei, ios::out);

	char buffer[MAXZEILE];

	datei << p->strOutputParameter("p", buffer) << "-- rechne ueber F_" << p->readParameter("p") << endl;
	datei << "-- Koerper definieren" << endl;
	datei << "Fp = ZZ/p;" << endl;
	datei << "-- Ring Definieren (damit Macaulay die epsilon Notation versteht)" << endl;
	datei << "S = Fp[e]; " << endl;
	datei << p->strOutputParameter("maxStrudel", buffer) << "-- berechne maximal " << p->readParameter("maxStrudel") << " Strudelgroessen" << endl;
	datei << p->strOutputParameter("minNullen", buffer) << "-- gib nur Beispiele aus, deren ersten " << p->readParameter("minNullen") << " Strudelgroessen = 0 sind" << endl;
	datei << p->strOutputParameter("grad", buffer) << "-- Grad der Polynome " << endl;
	datei << p->strOutputParameter("epsilon", buffer);
	if (strcmp(p->readParameter("epsilon"), "true") == 0)
		datei << "-- mit Epsilon-Berechnung" << endl;
	else
		datei << "-- ohne Epsilon-Berechnung" << endl;

	datei << p->strOutputParameter("rechneBisMaxStrudel", buffer);
	if (strcmp(p->readParameter("rechneBisMaxStrudel"), "true") == 0)
		datei << "-- es werden immer maxStrudel  Strudelgroessen berechnet " << endl;
	else
		datei << "-- es wird bis zur ersten Strudelgroesse ungleich 0 gerechnet " << endl;

	datei << p->strOutputParameter("jacobi", buffer);
	if (strcmp(p->readParameter("jacobi"), "true") == 0)
		datei << "-- mit Jacobi-Matrizen " << endl;
	else
		datei << "-- ohne Jacobi-Matrizen " << endl;
	
	datei << p->strOutputParameter("anzZufall", buffer) << "-- rechne mit " << p->readParameter("anzZufall") << " zufaelligen Parametersets" << endl;
	datei << p->strOutputParameter("zufallInit", buffer) << "-- Initialisierung des Zufallszahlengenerators (gleicher Start ertgibt gleiche Werte)" << endl;
	datei << p->strOutputParameter("zeitAlsZufall", buffer);
	if (strcmp(p->readParameter("zeitAlsZufall"), "true") == 0)
		datei << "-- Zeit als Zufalls-Seed verwenden " << endl;
	else
		datei << "-- Eingabewert als Zufalls-Seed verwenden " << endl;

	datei << p->strOutputParameter("benutzeFormel1", buffer);
	if (strcmp(p->readParameter("benutzeFormel1"), "true") == 0)
		datei << "-- berechne den Wert p(3,0) so, dass die erste Strudelgroesse 0 ist" << endl;
	else
		datei << "-- der Wert p (3,0) wird aus dem Eingabefile 1:1 uebernommen " << endl;

	datei << p->strOutputParameter("benutzeFormel2", buffer);
	if (strcmp(p->readParameter("benutzeFormel2"), "true") == 0)
		datei << "-- berechne den Wert q(3,0) so, dass die zweite Strudelgroesse 0 ist" << endl;
	else
		datei << "-- der Wert q (3,0) wird aus dem Eingabefile 1:1 uebernommen " << endl;

	datei << p->strOutputParameter("hamilton", buffer);
	datei << "-- Punkte auf Hamilton-Komponente ";
	if (strcmp(p->readParameter("hamilton"), "false") == 0)
		datei << "nicht ";
	datei << "ausgeben" << endl;

	/* HC: ausgeben,dass zufallszahlen korregiert sind */

	datei << "equalWeights = true; -- Fehler in Zufallszahlenerzeugung korregiert;" << endl;
	
	datei << "---- bisher nicht verwendete Parameter" << endl;

	char *z;
	z = p->strOutputParameter("L", buffer);
	z = p->strOutputParameter("Fp", buffer);
	z = p->strOutputParameter("S", buffer);
	z = p->strOutputParameterNotYet (buffer);
	while (z!=0)
	{
		datei << z << endl;
		z = p->strOutputParameterNotYet (buffer);
	}


	datei << endl << "--Ergebnisse: " << endl;
	datei << "L = { " << endl;
	datei.close();

}

void ausgabevorJacobi(Frommer *f, polynomxy *p, polynomxy *q, int *anzahl, int *maxstrudel, char *ausgabedatei, int immerbismaxstrudel)
{
	ofstream datei;

	//datei.open("C:\\projekte\\HC\\Zahlen\\Zahlen\\Ausgabe.txt", ios::app);
	datei.open(ausgabedatei, ios::app);
	
	if (*anzahl>0)
		datei << "," << endl;
	datei << "{ { " << endl;

	int mitKomma = 1;
	int i;

	for (i = 2; i<= p->getGrad(); i ++)
	{
		p->Output(&datei, i, 1);
		if (i==p->getGrad())
			mitKomma=0;
		q->Output(&datei, i, mitKomma);
	}

	datei << "}, " << f->azNullen() << ", -- Anzahl Strudelgroessen = 0 " << endl;

	// jetzt für alle Strudelgrößen die Werte antragen
	//es werden f->azNullen() + 1 Studelgrößen angetragen, maximal jedoch maxstrudel Werte eingetragen
	datei << " {";
	
	int anzahlstrudelgroessen;
	if (immerbismaxstrudel == 0)
		anzahlstrudelgroessen = f->azNullen() + 1;
	else
		anzahlstrudelgroessen = *maxstrudel;

	if (anzahlstrudelgroessen > *maxstrudel)
		anzahlstrudelgroessen = *maxstrudel;

	zahl z;

	for (i=1; i<=anzahlstrudelgroessen; i++)
	{
		if (i>1)
			datei << ", ";

		z = f->getStrudelGroesse(i);

		datei << z.x << "+" << z.eps <<"*e" ;
	}
	
	datei << " } -- Strudelgroessen " << endl;

	//ende Strudelgrößen

	datei.close();

	(*anzahl)++;
}

void ausgabenachJacobi( char *ausgabedatei)
{
	ofstream datei;

	//datei.open("C:\\projekte\\HC\\Zahlen\\Zahlen\\Ausgabe.txt", ios::app);
	datei.open(ausgabedatei, ios::app);
	datei << "}" <<endl;
	datei.close();
}

void ausgabestatistik(Statistik* st, char *ausgabedatei)
{
	ofstream datei;

	//datei.open("C:\\projekte\\HC\\Zahlen\\Zahlen\\Ausgabe.txt", ios::app);
	datei.open(ausgabedatei, ios::app);

	datei << "};" << endl;

	datei << "statistik={";

	for (int i=st->getStartWert(); i<= st->getEndWert(); i++)
	{
		if (i>st->getStartWert())
			datei << ", ";
		datei << st->getStatistikWert (i);
	}
		
	datei << "}; -- erste Zahl: Anzahl Berechnungen, i.te Zahl: Anzahl Ergebnisse mit mind. i Strudelgroessen = 0 " << endl;
}


void einhaengen(int p_oder_q, int j, int aktuellergrad, KoeffListe **einhaengeliste, KoeffListe *bufferliste)
{

	bufferliste = new KoeffListe;
	bufferliste->porq = p_oder_q; //p
	bufferliste->xkoeff = aktuellergrad-j;
	bufferliste->ykoeff = j;
	//in die Liste einhängen
	if (*einhaengeliste==0)
	{
		*einhaengeliste = bufferliste;
	}
	else
	{
		KoeffListe* list2;
		list2 = *einhaengeliste;
		while (list2->next != 0) list2 = list2->next;
		list2->next = bufferliste;
	}
}


int main(unsigned short argc, unsigned short* argv[])
{
	unsigned short n;
	Parameterliste params;

	/* 
		prunsigned shortf("Bitte geben Sie die Zahl des Körpers ein (Anzahl Elemente): ");
		scanf("%i", &n); 
	*/

	ifstream datei;

	char eingabedatei[1000];
	int jj;
	if (argc<2)
		jj = sprintf(eingabedatei , "Eingabe.txt");
	else
		jj = sprintf(eingabedatei , (char*)(argv)[1]);

	/* Ausgabedatei wird erst geschrieben, wenn ZufallsSeed vorhanden ist, da dies evtl. in der Ausgabedatei mit eingefügt wird */

	//datei.open("C:\\projekte\\HC\\Zahlen\\Zahlen\\Eingabe2.txt", ios::in);
	datei.open(eingabedatei, ios::in);

	char inp[MAXZEILE];
	int ende=0;
	if (datei)
	{
      while((!datei.eof())&&(ende==0))
        {
          datei.getline(inp,1000);
		  params.loadParam(inp);
		  cout << inp << endl;
		  if (strcmp(params.getLastParameter() , "L") == 0) ende=1;
        }
	}

	cout.flush();
	//cout << "Bitte geben Sie die Zahl des Körpers ein (Anzahl Elemente): ";
	//if (datei) 
	//	datei >> n;
	//else
	//	cin >> n;

	int eps=0;	
	try
	{
		n = atoi(params.readParameter("p"));
		if (strcmp(params.readParameter("epsilon"), "true") == 0) 
			eps=1;
		else
			params.SetParameter("epsilon", "false");

		if (n<2) throw("Die Zahl muß groesser als zwei sein!");
	}
	catch(char* str)
	{
		cout << "Fehler aufgetreten: " << str << "\n";
		cout << "Bei der Eingabe der Anzahl der Elemente ist ein Fehler aufgetreten\n";
		cout << "Das Programm interpretiert " << params.readParameter("p") << " als Anzahl Elemente = " << n << "\n";
		cout << "Die Abfrage auf Epsilon liefert " << params.readParameter("epsilon") << "\n";
		return 0;
	}

	koerper k(n, eps);

	cout <<"Gerechnet wird ueber dem Koerper " << n;
	if (eps==1)
		cout << " mit ";
	else
		cout << " ohne ";
	cout << " Epsilon-Rechnung \n";

	cout.flush();

	int immerbismaxstrudel = 0; // Default = Nein, nur bis zur ersten Strudelgröße ungleich 0
	if (strcmp(params.readParameter("rechneBisMaxStrudel"), "true") == 0) 
		immerbismaxstrudel = 1;
	else
		params.SetParameter("rechneBisMaxStrudel", "false");

	int mitjacobi = 0; // Default = Nein, ohne Jacobi-Matrix
	if (strcmp(params.readParameter("jacobi"), "true") == 0) 
		mitjacobi = 1;
	else
		params.SetParameter("jacobi", "false");

	int benutzeFormel1 = 0; // Default Formel 1 nicht verwenden
	if (strcmp(params.readParameter("benutzeFormel1"), "true") == 0) 
		benutzeFormel1 = 1;
	else
		params.SetParameter("benutzeFormel1", "false");

	int benutzeFormel2 = 0; // Default Formel 2 nicht verwenden
	if (strcmp(params.readParameter("benutzeFormel2"), "true") == 0) 
		benutzeFormel2 = 1;
	else
		params.SetParameter("benutzeFormel2", "false");

	int hamilton = 1; //Default Punkte auf Hamilton-Komponente ausgeben
	if (strcmp(params.readParameter("hamilton"), "false") == 0) 
		hamilton = 0;
	else
		params.SetParameter("hamilton", "true");

	/*
	unsigned short a;
	unsigned short b;
	unsigned short c;
	unsigned short d;
	cout << "Bitte geben Sie 4 Zahlen für die Addition ein: ";
	cin >> a >> b >> c >> d;

	zahl x = zahl(a,b);
	zahl y = zahl(c,d);

	zahl z = k.addiere(x, y);
	
	cout << "\nErgebnis: " << a << ',' << b << "+" << c << ',' << d << "=" << z.x << "," << z.eps <<endl;
	z=k.multipliziere(x,y);
	cout << "\nErgebnis: " << a << ',' << b << "*" << c << ',' << d << "=" << z.x << "," << z.eps <<endl;
	z = k.invers(x);
	cout << "\nErgebnis: " << a << ',' << b << "^-1  = "  << z.x << " " << z.eps <<endl;
	z = k.invers(y);
	cout << "\nErgebnis: " << c << ',' << d << "^-1  = "  << z.x << " " << z.eps <<endl;
*/

	int maxStrudel;
	try
	{
		maxStrudel = atoi(params.readParameter("maxStrudel"));
		if (maxStrudel ==0) throw("Die Zahl muß groesser als 0 sein!");
	}
	catch(char* str)
	{
		cout << "Fehler aufgetreten: " << str << "\n";
		cout << "Das Programm interpretiert " << params.readParameter("maxStrudel") << " als maxStrudel = " << maxStrudel << "\n";
		return 0;
	}

	if (maxStrudel >= (n-1)/2)
	{
		cout << "maxStrudel " << maxStrudel << " ist zu gross fuer den betrachteten Koerper! (Grenze (p-1)/2 -1)" << endl;
		maxStrudel = (n-1)/2-1;
		cout << "maxStrudel wurde gesetzt auf : " << maxStrudel << endl;
		cout.flush();

		char zzz[1000];
		int h;
		h = sprintf(zzz, "%d" , maxStrudel);
		params.SetParameter("maxStrudel", zzz);
	}
	int maxGrad;
	maxGrad = maxStrudel *2 + 3;

	Frommer f(maxStrudel, &k);


	//erstes Beispiel
	/*
	polynomxy p(2);
	p.SetKoeff(1,0,1);
	p.SetKoeff(2,0,4);
	p.SetKoeff(0,2, 1);
	polynomxy q(2);
	q.SetKoeff(0,1,1);
	q.SetKoeff(2,0,1);
	q.SetKoeff(0,2, k.negativ(2));
	//1.Strudelgröße = -4
	*/

	//zweites Beispiel
	/*
	polynomxy p(2);
	p.SetKoeff(1,0, 1);
	polynomxy q(2);
	q.SetKoeff(0,1,1);
	p.SetKoeff(2,0, 1);
	p.SetKoeff(1,1, 2);
	p.SetKoeff(0,2, k.negativ(1));
	q.SetKoeff(1,1, k.negativ(2));
	q.SetKoeff(0,2, 1);
	//2.Strudelgröße = -14/15
	*/

	//drittes Beispiel
	/*
	polynomxy p(3);
	p.SetKoeff(1,0, 1);
	p.SetKoeff(2,0, 4);
	p.SetKoeff(0,2, 1);
	p.SetKoeff(3,0, 2);
	p.SetKoeff(0,3, k.negativ(2));
	polynomxy q(3);
	q.SetKoeff(0,1, 1);
	q.SetKoeff(2,0, 1);
	q.SetKoeff(0,2, k.negativ(2));
	q.SetKoeff(3,0, 2);
	q.SetKoeff(0,3, k.negativ(2));
	*/
	//alle Strudelgrößen = 0
	

	//viertes Beispiel
	/*
	polynomxy p(3);
	p.SetKoeff(1,0, 1);
	p.SetKoeff(3,0, 2);
	p.SetKoeff(0,3, 1);
	polynomxy q(3);
	q.SetKoeff(0,1, 1);
	q.SetKoeff(2,1, 1);
	q.SetKoeff(0,3, 1);
	*/
	//1. Strudelgröße = -1

	//viertes Beispiel
	/*
	polynomxy p(3);
	p.SetKoeff(1,0, 1);
	p.SetKoeff(2,1, 4);
	p.SetKoeff(0,3, 1);
	polynomxy q(3);
	q.SetKoeff(0,1, 1);
	q.SetKoeff(3,0, 2);
	q.SetKoeff(1,2, 1);
	*/
	//1. Strudelgröße = 44/35

	//fünftes Beispiel
	/*
	polynomxy p(5);
	p.SetKoeff(1,0, 1);
	p.SetKoeff(2,1, 4);
	p.SetKoeff(0,3, 1);
	p.SetKoeff(3,2, 2);
	polynomxy q(5);
	q.SetKoeff(0,1, 1);
	q.SetKoeff(3,0, 2);
	q.SetKoeff(1,2, 1);
	q.SetKoeff(4,1, 2);
	*/
	//alle Strudelgrößen = 0

	//sechstes Beispiel
	/*
	polynomxy p(11);
	p.SetKoeff(1,0, 1);
	p.SetKoeff(7,0, 1);
	p.SetKoeff(8,1, 2);
	p.SetKoeff(0,11, k.negativ(1));
	polynomxy q(11);
	q.SetKoeff(0,1, 1);
	q.SetKoeff(10,1, k.negativ(2));
	q.SetKoeff(0,11, 1);
	//1. Strudelgröße = -2/9
	*/

	Statistik st(maxStrudel);

	unsigned int gradderpolynome = 0;
	try
	{
		gradderpolynome = atoi(params.readParameter("grad"));
		if (gradderpolynome <2) throw("Die Zahl muß groesser als 1 sein!");
	}
	catch(char* str)
	{
		cout << "Fehler aufgetreten: " << str << "\n";
		cout << "Das Programm interpretiert " << params.readParameter("grad") << " als grad = " << gradderpolynome << "\n";
		return 0;
	}

	int minNullen = 0;
	try
	{
		minNullen = atoi(params.readParameter("minNullen"));
		if (minNullen == 0)
			params.SetParameter("minNullen", "0");
	}
	catch(char* str)
	{
		cout << "Fehler aufgetreten: " << str << "\n";
		cout << "Das Programm interpretiert " << params.readParameter("minNullen") << " als minNullen = " << minNullen << "\n";
		return 0;
	}

	int azZufallszahlen = 1;
	try
	{
		azZufallszahlen = atoi(params.readParameter("anzZufall"));
		if (azZufallszahlen ==0)
			params.SetParameter("anzZufall", "0");
	}
	catch(char* str)
	{
		cout << "Fehler aufgetreten: " << str << "\n";
		cout << "Das Programm interpretiert " << params.readParameter("anzZufall") << " als azZufallszahlen = " << azZufallszahlen << "\n";
		return 0;
	}

	long zufallSeed = 548; 
	int ZeitAlsZufallSeed = 0; // Default ZufallsSeed ist angegeben
	if (strcmp(params.readParameter("zeitAlsZufall"), "true") == 0) 
	{
		ZeitAlsZufallSeed = 1;
		time_t tt;

		time(&tt);

		zufallSeed = (tt);

		char zzz[1000];
		int h;
		h = sprintf(zzz, "%d" , zufallSeed);
		params.SetParameter("zufallInit", zzz);
	}
	else
	{
		params.SetParameter("zeitAlsZufall", "false");
		try
		{
			zufallSeed = atoi(params.readParameter("zufallInit"));
			if (zufallSeed == 0)
				params.SetParameter("zufallInit", "0");
		}
		catch(char* str)
		{
			cout << "Fehler aufgetreten: " << str << "\n";
			cout << "Das Programm interpretiert " << params.readParameter("zufallInit") << " als zufallSeed = " << zufallSeed << "\n";
			return 0;
		}

	}
	//Name der Ausgabedatei über seed verändern:
	char ausgabedatei[1000];
	if (argc<3)
		jj = sprintf(ausgabedatei , "Ausgabe.txt");
	else
		jj = sprintf(ausgabedatei , (char*)(argv)[2], zufallSeed);
	if (zufallSeed>0) zufallSeed=-zufallSeed;

	polynomxy p(gradderpolynome);
	polynomxy q(gradderpolynome);
	int offeneKlammern = 0;
	unsigned int j;
	for (j=0; j<strlen(params.readParameter("L")); j++)
		if (params.readParameter("L")[j] == '{') offeneKlammern++;
	unsigned int aktuellergrad=2;
	zahl w;
	unsigned int stelle;

	int az = 0;
	ausgabestart(&params, ausgabedatei);

	int isAlle;
	int containsAlle;
	int isZufall;
	int containsZufall;
	KoeffListe* alleList;
	KoeffListe* zufallList;
	KoeffListe* list;
	alleList = 0;
	zufallList = 0;

	while ((!datei.eof())&&(!kbhit()))
	{
		//pirsche dich heran, bis du auf die zeile mit dem ersten grad für p stößt
		if (offeneKlammern==3) 
			ende=1; 
		else 
			ende=0;
		while ((!datei.eof())&&(ende==0))
		{
			//lies bis zu den nächsten Polynomen
			datei.getline(inp,1000);
			stelle=0;
			for (;stelle<strlen(inp); stelle++)
			{
				if (inp[stelle] == '{') offeneKlammern++;
				if (inp[stelle] == '}') offeneKlammern--;
			}
			if (offeneKlammern == 3) ende=1;
		}

		//initialisiere alles, was für ein Polynom notwendig ist:
		//lösche die Listen für Alle und Zufall
		if (alleList != 0) 
			delete (alleList);
		if (zufallList != 0) 
			delete (zufallList);

		containsAlle = 0;
		containsZufall = 0;
		alleList = 0;
		zufallList = 0;
		//lies aus der Datei die Informationen für die nächsten Polynome
		p.SetKoeff(1,0,1);
		q.SetKoeff(0,1,1);
		aktuellergrad=2;
		while (aktuellergrad<=gradderpolynome)
		{
			datei.getline(inp,1000);
			stelle = 0;
			for (j=0; j<=aktuellergrad; j++)
			{
				w = readnextwert(inp, &offeneKlammern, &stelle, &k, &isAlle, &isZufall);
				p.SetKoeff(aktuellergrad-j, j, w);
				if (isAlle==1)
				{
					//merke Dir diese Position als Position, bei der alle Zahlen verwendet werden müssen
					einhaengen(1, j, aktuellergrad, &alleList, list);
					//void einhaengen(int p_oder_q, int j, int aktuellergrad, KoeffListe *einhaengeliste, KoeffListe *bufferliste)
					containsAlle=1;
				}
				if (isZufall==1)
				{//merke Dir diese Position als Position, bei der ZufallsZahlen verwendet werden müssen
					einhaengen(1, j, aktuellergrad, &zufallList, list);
					containsZufall=1;
				}
			}
			for (;stelle<strlen(inp); stelle++)
			{
				if (inp[stelle] == '{') offeneKlammern++;
				if (inp[stelle] == '}') offeneKlammern--;
			}
			datei.getline(inp,1000);
			stelle = 0;
			for (j=0; j<=aktuellergrad; j++)
			{
				w = readnextwert(inp, &offeneKlammern, &stelle, &k, &isAlle, &isZufall);
				q.SetKoeff(aktuellergrad-j, j, w);
				if (isAlle==1)
				{//merke Dir diese Position als Position, bei der alle Zahlen verwendet werden müssen
					einhaengen(2, j, aktuellergrad, &alleList, list);
					containsAlle=1;
				}
				if (isZufall==1)
				{//merke Dir diese Position als Position, bei der ZufallsZahlen verwendet werden müssen
					einhaengen(2, j, aktuellergrad, &zufallList, list);
					containsZufall=1;
				}
			}
			for (;stelle<strlen(inp); stelle++)
			{
				if (inp[stelle] == '{') offeneKlammern++;
				if (inp[stelle] == '}') offeneKlammern--;
			}
			aktuellergrad++;
		}

		//starte Algorithmus

		//die so definierten Polynome müssen mehrfach ausgeführt werden

		int zufallszaehler;
		zahl wert;

		long anzahl=0;

		ende=0;
		for (zufallszaehler =0; zufallszaehler <= containsZufall*(azZufallszahlen-1); zufallszaehler ++)
		{
			if (containsZufall>0)
			{
				/* Zufallszahlen setzen */
				list = zufallList;
				wert = 0;

				while (list != 0) // durchlaufe die komplette Liste
				{
					//cout << zufallSeed;
					wert = random(&zufallSeed, n-1); /* Zufallszahl ! */
/*					for (int zz=0; zz<100; zz++)
					{
						cout << "Zufall " << random(&zufallSeed, n-1) << endl;
					}*/
					
					if (list->porq == 1)
						p.SetKoeff(list->xkoeff, list->ykoeff, wert);
					else
						q.SetKoeff(list->xkoeff, list->ykoeff, wert);

					list = list -> next;
				}
			}

			ende = 0;
			if (kbhit())
			{
				cout << "Taste wurde gedrueckt -- Berechnung wird abgebrochen" << endl;
				ende=1;
				zufallszaehler = containsZufall*(azZufallszahlen-1) + 1;
			}
			while (ende==0)
			{

				//Formel 1 berechnet q(3,0)!
				/*q(3,0) = -1/3*p(2,0)*p(1,1)		.
						 + -1/3*p(1,1)*p(0,2)		.
						 + 2/3*p(2,0)*q(2,0)		.
						 + 1/3*q(2,0)*q(1,1)		.		
						 + -2/3*p(0,2)*q(0,2)		.
						 + 1/3*q(1,1)*q(0,2)		.
						 + 1/3*p(2,1)				.
						 + p(0,3)					.
						 + -1/3*q(1,2)				.*/			
				if (benutzeFormel1==1)
				{
					zahl formel1erg;
					zahl formel1zw;
					zahl drittel;
					zahl zweidrittel;
					drittel = k.invers(3);
					zweidrittel = k.multipliziere(2, drittel);
					formel1zw = k.multipliziere(drittel, p.GetKoeff(2,0), p.GetKoeff(1,1));
					formel1erg = k.negativ(formel1zw);
					formel1zw = k.multipliziere(drittel, p.GetKoeff(1,1), p.GetKoeff(0,2));
					formel1erg = k.addiere(formel1erg, k.negativ(formel1zw));
					formel1zw = k.multipliziere(zweidrittel, p.GetKoeff(2,0), q.GetKoeff(2,0));
					formel1erg = k.addiere(formel1erg, formel1zw);
					formel1zw = k.multipliziere(drittel, q.GetKoeff(2,0), q.GetKoeff(1,1));
					formel1erg = k.addiere(formel1erg, formel1zw);
					formel1zw = k.multipliziere(zweidrittel, p.GetKoeff(0,2), q.GetKoeff(0,2));
					formel1erg = k.addiere(formel1erg, k.negativ(formel1zw));
					formel1zw = k.multipliziere(drittel, q.GetKoeff(1,1), q.GetKoeff(0,2));
					formel1erg = k.addiere(formel1erg, formel1zw);
					formel1zw = k.multipliziere(drittel, p.GetKoeff(2,1));
					formel1erg = k.addiere(formel1erg, formel1zw, p.GetKoeff(0,3));
					formel1zw = k.negativ(k.multipliziere(drittel, q.GetKoeff(1,2)));
					formel1erg = k.addiere(formel1erg, formel1zw);

					q.SetKoeff(3,0, formel1erg);

				}

				if (benutzeFormel2 == 1)
				{
					//Setze p(3,0) (x^3y^0) auf 0+1*eps und berechne die zweite Sturdelgröße
					zahl eps1(0,1);
					p.SetKoeff(3,0, eps1);
					f.setPolynome (&p, &q);
					f.setMaxStrudel(2);
					f.doit (1);
					f.setMaxStrudel(maxStrudel);
					zahl str2;
					str2 = f.getStrudelGroesse(2);
					//der Koeeffizient von p(3,0) soll -a/b sein, wenn die zweite Strudelgröße = a+b*eps ist
					//das geht natürlich nur, wenn b <> 0 ; wenn es nicht geht, setzen wir es auf 0
					zahl koeff(0,0); 
					if (str2.eps != 0)
					{
						koeff.x = (k.negativ(k.dividiere(str2.x, str2.eps))).x;
					}
					p.SetKoeff(3,0, koeff);
					//cout << "2.strudelgröße: " << str2.x << " + e*" << str2.eps << endl;
					//cout.flush;
				}

				f.setPolynome(&p, &q); // übergib die Polynome an Frommer
				f.doit(immerbismaxstrudel); // starte Frommer

				anzahl++;

				if (anzahl%10000 == 1)
					cout << anzahl << ". Berechnung durchgefuehrt" << endl;

				/* werte Ergebnisse von Frommer aus */
				st.addStatistik(f.azNullen());

				int jac_azNullen = f.azNullen(); // alle auszuprobierenden Polynome haben auch so viele Strudelgroessen = 0

				int istHamilton = 0;

				if (jac_azNullen >= minNullen)
				{
					if (hamilton == 0) // Punkte auf der Hamilton-Komponente sollen nicht ausgegeben werden
					{
						//überprüfe, ob Punkt auf Hamilton-Komponente liegt
						istHamilton = 1;
						//dazu sind 6 Bedingungen notwendig, d.h. wenn eine nicht erfüllt ist, liegt der Punkt nicht drauf
						if ((p.GetKoeff(1,1)).fastgleich(k.multipliziere(2, q.GetKoeff(2,0))) == 0) 
							istHamilton = 0;
						if ((istHamilton == 1) && (q.GetKoeff(1,1).fastgleich(k.multipliziere(2, p.GetKoeff(0,2))) ==0))
							istHamilton = 0;
						if ((istHamilton == 1) && (p.GetKoeff(2,1).fastgleich(k.multipliziere(3, q.GetKoeff(3,0))) ==0))
							istHamilton = 0;
						if ((istHamilton == 1) && (p.GetKoeff(1,2).fastgleich(q.GetKoeff(2,1)) ==0))
							istHamilton = 0;
						if ((istHamilton == 1) && (q.GetKoeff(1,2).fastgleich(k.multipliziere(3, p.GetKoeff(0,3))) ==0))
							istHamilton = 0;

					}
					if (istHamilton == 1)
					{
						//ofstream xxdatei;
						//xxdatei.open(ausgabedatei, ios::app);
		
						//xxdatei << "-- nächster Punkt liegt auf Hamilton-Komponente" << endl;
					}
					else
						ausgabevorJacobi(&f, &p, &q, &az, &maxStrudel, ausgabedatei, immerbismaxstrudel);
				}


				/* Jacobi-Matrix nur wenn minnullen erfüllt */
				if ((jac_azNullen >= minNullen)&&(mitjacobi==1)&&(istHamilton==0))
				{
					ofstream jac_datei;
					jac_datei.open(ausgabedatei, ios::app);

					//cout << "es muß Jacobi gerechnet werden " << endl;
					jac_datei << ", {";

					int jac_i = 0;
					
					// für jeden Parameterwert +1*e setzen, Frommer aufrufen (und +1*e wieder weg machen)
					unsigned int jac_aktuellergrad;
					unsigned int jac_j = 0;
					zahl w_mit_eps;
					zahl jac_str;
					polynomxy *jac_poderq_poly;
					int erster = 1;
					int jac_poderq = 0;
					for (jac_poderq = 0; jac_poderq <=1; jac_poderq++)
					{
						if (jac_poderq==0)
							jac_poderq_poly = &p;
						else
							jac_poderq_poly = &q;
						jac_aktuellergrad=2;
						while (jac_aktuellergrad<=gradderpolynome)
						{
							for (jac_j=0; jac_j<=jac_aktuellergrad; jac_j++)
							{
								w = jac_poderq_poly->GetKoeff(jac_aktuellergrad-jac_j, jac_j);
								w_mit_eps.x = w.x; 
								w_mit_eps.eps = 1;
								jac_poderq_poly->SetKoeff(jac_aktuellergrad-jac_j, jac_j, w_mit_eps);

								f.setPolynome(&p, &q); // übergib die Polynome an Frommer
								f.doit(immerbismaxstrudel); // starte Frommer

								if (erster==1)
									erster = 0;
								else
									jac_datei << ",";

								jac_datei << "{";
								for (jac_i=1; jac_i <= jac_azNullen; jac_i++)
								{
									jac_str = f.getStrudelGroesse(jac_i);
									if (jac_str.x != 0)
										jac_datei << "FEHLER!!! Strudelgroesse bei Jacobi ist nicht fast 0 !!!" << endl;
									if (jac_i>1)
										jac_datei << ", ";
									jac_datei << jac_str.eps;
								}
								jac_datei << "}";
								
								jac_poderq_poly->SetKoeff(jac_aktuellergrad-jac_j, jac_j, w);
							}

							jac_aktuellergrad++;
						}
					}
					jac_datei << "} -- Jacobi-Matrix" << endl;
					jac_datei.close();

				}
				/* Ende Jacobi-Matrix */

				if ((jac_azNullen >= minNullen)&&(istHamilton==0))
					ausgabenachJacobi(ausgabedatei);

				
				if (containsAlle==0)
					ende=1;
				else
				{
					//nächste Zahl ermitteln
					list = alleList;
					wert = 0;

					while ((wert.x==0)&&(wert.eps==0)&&(ende==0)) /* zähle ersten wert hoch, wenn der 0, dann zweiten, wenn der 0, dann dritten , ... */
					{
						if (list->porq == 1)
							wert = p.GetKoeff(list->xkoeff, list->ykoeff);
						else
							wert = q.GetKoeff(list->xkoeff, list->ykoeff);
						wert = k.naechsteZahl(wert);
						if (list->porq == 1)
							p.SetKoeff(list->xkoeff, list->ykoeff, wert);
						else
							q.SetKoeff(list->xkoeff, list->ykoeff, wert);

						if ((wert.x == 0)&&(wert.eps==0)) 
						{//nimm die nächste Zahl und addiere sie hoch. Wenn du bei der letzten bist, sind wir fertig
							list = list->next;
							if (list==0)
								ende=1;
						}
					}
				}
				if (kbhit())
				{
					cout << "Taste wurde gedrueckt -- Berechnung wird abgebrochen" << endl;
					ende=1;
					zufallszaehler = containsZufall*(azZufallszahlen-1) + 1;
				}

			} //weiter mit den Zufallszahlen

		}

		ende=0;
		if (kbhit())
		{
			cout << "Taste wurde gedrueckt -- Berechnung wird abgebrochen" << endl;
			zufallszaehler = containsZufall*(azZufallszahlen-1) + 1;
			ende=1;
		}
		while ((!datei.eof())&&(ende==0))
		{
			//lies bis zu den nächsten Polynomen
			datei.getline(inp,1000);
			stelle=0;
			for (;stelle<strlen(inp); stelle++)
			{
				if (inp[stelle] == '{') offeneKlammern++;
				if (inp[stelle] == '}') offeneKlammern--;
			}
			if (offeneKlammern == 3) ende=1;
		}
	}

	ausgabestatistik(&st, ausgabedatei);


	return 0;
}