//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//% Nullstellen-Verfahren im Vergleich                             %
//% Letzte Aenderung: 01.05.2003 W. Doerfler,                      %
//%                   19.05.2003 K. Feldhoff.                      %
//%                   29.05.2003 seth (www.bierdatenbank.de)       %
//%                    - umstrukturierung                          %
//%                    - implementierung der verfahren:            %
//%                      - regula falsi                            %
//%                      - sekanten                                %
//%                      - newton                                  %
//%                      - verbesserter newton                     %
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

// der kram ist noch lange nicht wirklich fertig, aber erfuellt die anforderungen der aufgabenstellungen einigermasen (soweit ich das beurteilen kann)
// - beim verbesserter newton verfahren wird einfach TOLfp auch fuer die zweite ableitung verwendet
// - wie die geplottete ausgabe ablaufen soll, habe ich noch nicht verstanden
// - teilweise werden ns gefunden, die ausserhalb des startintervalls liegen (aufgabenstellung spricht da aber imho nicht dagegen)
// - idiotensicherheit habe ich nicht ausgebaut. bspw. wird TOLfp nicht auf <0 getestet.

#include <iostream.h>
#include <math.h>
#include <float.h>
#include <iomanip.h>
/* #include "/usr/segment/include/MathPlot.h"
*/

const int MAXIT=50;
typedef int realfun(double*, double, double*);

// rueckgabe der ergebnisse
struct results{
	int errcode;		// error code
	int NoIters;		// number of iterations
	double x;				// x_n (ns-naeherung)
	double fval[3];	// naeherungen fuer f(x_n) und f'(x_n) und f''(x_n)
	double * kappa;	// eoc-kram
};

typedef void nsVerfahren(results&, realfun*, double, double, int=1, double=1.e-4, double=1.e-8, double=1.e-15);
nsVerfahren bisektion;
nsVerfahren regulaFalsi;
nsVerfahren sekanten;
nsVerfahren newton;
nsVerfahren subbaprima;
typedef int realfun(double*, double, double*);
realfun func1;
realfun func2;
realfun func3;
realfun func4;

// liefert func1(x) und func1'(x) fuer ein x
int func1(double *evalf, double x, double *mask){
	evalf[0]=(mask[0])?((((300*x-275)*x+100)*x-10)*x-0.5):DBL_MAX;
	evalf[1]=(mask[1])?(((1200*x-825)*x+200)*x-10):DBL_MAX;
	evalf[2]=(mask[2])?((3600*x-1650)*x+200):DBL_MAX;
	return 1;
}

// liefert func2(x) und func2'(x) fuer ein x
int func2(double *evalf, double x, double *mask){
	long double d=(x-0.3),e=(x-0.9);
	evalf[0]=(mask[0])?(long double) 1.0/(powl(d,2)+0.01)+1.0/(powl(e,2)+0.04)-6:DBL_MAX;
	evalf[1]=(mask[1])?(long double) -(2*d+0.01)/(powl(powl(d,2)+0.01,2))-(2*e+0.04)/(powl(powl(e,2)+0.04,2)):DBL_MAX;
	evalf[2]=(mask[2])?(long double) (d*(6*d+0.04)-0.02)/powl((powl(d,2)+0.01),3)-(e*(6*e+0.16)-0.08)/powl((powl(e,2)+0.04),3):DBL_MAX;
	return 1;
}

// liefert func3(x) und func3'(x) fuer ein x
int func3(double *evalf, double x, double *mask){
	evalf[0]=(mask[0])?(long double) ((((x-6)*x+11)*x-2)*x-12)*x+8:DBL_MAX;
	evalf[1]=(mask[1])?(long double) ((((5*x-24)*x+33)*x-4)*x-12):DBL_MAX;
	evalf[2]=(mask[2])?(long double) (((20*x-72)*x+66)*x-4):DBL_MAX;
	return 1;
}

// liefert func4(x) und func4'(x) fuer ein x
int func4(double *evalf, double x, double *mask){
	evalf[0]=(mask[0])?x-expl(-x/2):DBL_MAX;
	evalf[1]=(mask[1])?expl(-x/2)/2+1:DBL_MAX;
	evalf[2]=(mask[2])?-expl(-x/2)/4:DBL_MAX;
	return 1;
}

void eocPart(int it, results& res, int verbose, double *dist){
	// EOC (experimentelle konvergenz-ordnung)
	if(it>=2){
		double kvec[MAXIT], kappavec[MAXIT];
		//double kvec[it-1], kappavec[it-1]; stand vorher da, war mir aber suspekt
		for(int k=2;k<=it;k++){
			res.kappa[k] =log(dist[k]/dist[k-1]) / log(dist[k-1]/dist[k-2]);
			kvec[k-2]    =k;
			kappavec[k-2]=res.kappa[k];
			if(verbose){
				cout << "kappa(" << setw(3) << k << ")=" << setw(10) << res.kappa[k] << endl;
			}
		}
		// [ausgabe] stelle den EOC graphisch dar
/*
		MathPlot eocplot;
		eocplot.plot(kvec,kappavec,it-1);
		eocplot.XLabel("k");
		eocplot.YLabel("\kappa_k");
		eocplot.drawnow();
*/
	}
}

// [idiotentest] vorgegebene toleranzen negativ? linke intervallgrenze groesser als rechte? vertausche grenzen ggf.
int idiotentest(double &a, double &b, double TOLx, double TOLf, results& res, char *verfahren, int verbose){
	if(verbose) cout <<"\n" << verfahren << "-verfahren\n----------------------\n\n";
	int errorCode=0;
	if((TOLx<0) || (TOLf<0)){
		cout << "*** FEHLER *** " << verfahren << "-verfahren\n    negative toleranz!\n\n";
		res.errcode=-1;
		errorCode++;
	}
	if(b<a){
		double tmp;
		tmp=a; a=b; b=tmp;
		cout << "*** ACHTUNG *** " << verfahren << "-verfahren\n    vertausche a mit b.\n\n";
	}
	return errorCode;
}

// schliesst eine ns(f) via bisektions-verf. in kleinere teilintervalle ein und gibt nach erfolgr. iteration die intervallgrenze, die den vom betrag her kleineren fkt.swert liefert, zurueck.
void bisektion(results& res, realfun* func, double a, double b, int verbose, double TOLx, double TOLf, double TOLfp){
	char *verfahren="bisektions";
	int it=0;
	double x;
	double fa[3], fb[3], fx[3], mask[3], dist[MAXIT+1];
	mask[0]=1; mask[1]=0; mask[2]=0;
	// [ausgabe] acht signifikante stellen
	cout.setf(ios::fixed | ios::showpoint);
	cout.precision(8);
	if(idiotentest(a, b, TOLx, TOLf, res, verfahren, verbose)!=0) return;
	// erste fkts.werte
	func(fa,a,mask);
	func(fb,b,mask);
	dist[0]=b-a;
	// [idiotentest]
	if(fa[0]*fb[0]>0){
		cout << "*** FEHLER *** " << verfahren << "-verfahren\n		gleiche vorzeichen von f(a) und f(b)\n\n";
		res.errcode=-1;
		return;
	}
	// abbruchkriterien
	if((b-a<TOLx) || (fabs(fa[0])<TOLf) || (fabs(fb[0])<TOLf)){
		cout << endl;
		cout << "anfangswerte erfuellen kriterien:" << endl;
		cout << it << "   stellen: a=" << a << ", b=" << b << endl;
		cout << "   fkt.-werte: f(a)=" << fa[0] << ", f(b)=" << fb[0] << endl;
		cout << endl;
		res.errcode=0;
		return;
	}
	// bis b-a<=toleranz oder maximale anzahl an iterationen erreicht wurde
	do{
		if(verbose){
			// [ausgabe] aktuelles intervall, tabellenartig
			cout << setw(3) << it << "  a=" << setw(10) << a << ", b=" << setw(10) << b << ", f(a)=" << setw(10) << fa[0] << ", f(b)=" << setw(10) << fb[0] << endl;
		}
		it++; // inc iterationszaehler
		x=a+(b-a)/2; // neue intervall-mitte 'x' und zug. 'f(x)'
		func(fx,x,mask);
		dist[it]=b-x; // bestimme abstand
		// '|f(x)|' schon klein genug? belege ggf. die rueckgabewerte
		if(fabs(fx[0])<TOLf){
			cout << "\ntoleranz fuer |f(x)| erreicht!\n" << endl;
			res.NoIters=it; res.errcode=1;
			res.x=x; res.fval[0]=fx[0]; res.fval[1]=fx[1]; res.fval[2]=fx[2];
			break;
		}
		// def. neue ausgangssituation
		if(fa[0]*fx[0]<0){
			b=x; fb[0]=fx[0];
		}else{
			a=x; fa[0]=fx[0];
		}
	}while((b-a>TOLx) && (it<MAXIT));
	// [ausgabe] welches kriterium hat abgebrochen? belege rueckgabewerte
	if((b-a<=TOLx) || (it>=MAXIT)){
		res.NoIters=it; res.errcode=1;
		if(fa[0]<fb[0]){
			res.x=a; res.fval[0]=fa[0]; res.fval[1]=fa[1]; res.fval[2]=fa[2];
		}else{
			res.x=b; res.fval[0]=fb[0]; res.fval[1]=fb[1]; res.fval[2]=fb[2];
		}
		if(b-a<=TOLx) cout << "\ntoleranz fuer b-a erreicht!\n" << endl;
		if(it>=MAXIT){
			cout << "\nmaximale iterationszahl erreicht!" << "\n";
			cout << "   b-a=" << (b-a) << ", TOLx=" << TOLx << endl;
			cout << "   fx=" << fx[0] << ", TOLf=" << TOLf <<  "\n" << endl;
		}
	}
	eocPart(it, res, verbose, dist); // EOC (experimentelle konvergenz-ordnung)
	return;
}

void regulaFalsi(results& res, realfun* func, double a, double b, int verbose, double TOLx, double TOLf, double TOLfp){
	char *verfahren="regula falsi";
	int it=0;
	double x;
	double fa[3], fb[3], fx[3], mask[3], dist[MAXIT+1];
	mask[0]=1; mask[1]=0; mask[2]=0;
	// [ausgabe] acht signifikante stellen
	cout.setf(ios::fixed | ios::showpoint);
	cout.precision(8);
	if(idiotentest(a, b, TOLx, TOLf, res, verfahren, verbose)!=0) return;
	// erste fkts.werte
	func(fa,a,mask);
	func(fb,b,mask);
	dist[0]=b-a;
	// [idiotentest]
	if(fa[0]*fb[0]>0){
		cout << "*** FEHLER *** " << verfahren << "-verfahren\n		gleiche vorzeichen von f(a) und f(b)\n\n";
		res.errcode=-1;
		return;
	}
	// abbruchkriterien
	if((b-a<TOLx) || (fabs(fa[0])<TOLf) || (fabs(fb[0])<TOLf)){
		cout << endl;
		cout << "anfangswerte erfuellen kriterien:" << endl;
		cout << it << "   stellen: a=" << a << ", b=" << b << endl;
		cout << "   fkt.-werte: f(a)=" << fa[0] << ", f(b)=" << fb[0] << endl;
		cout << endl;
		res.errcode=0;
		return;
	}
	// bis b-a<=toleranz oder maximale anzahl an iterationen erreicht wurde
	do{
		if(verbose){
			// [ausgabe] aktuelles intervall, tabellenartig
			cout << setw(3) << it << "  a=" << setw(10) << a << ", b=" << setw(10) << b << ", f(a)=" << setw(10) << fa[0] << ", f(b)=" << setw(10) << fb[0] << endl;
		}
		it++; // inc iterationszaehler
		x=a-fa[0]*(b-a)/(fb[0]-fa[0]); // neues x und zug. f(x)
		func(fx,x,mask);
		dist[it]=b-x; // bestimme abstand
		// '|f(x)|' schon klein genug? belege ggf. die rueckgabewerte
		if(fabs(fx[0])<TOLf){
			cout << "\ntoleranz fuer |f(x)| erreicht!\n" << endl;
			res.NoIters=it; res.errcode=1;
			res.x=x; res.fval[0]=fx[0]; res.fval[1]=fx[1]; res.fval[2]=fx[2];
			break;
		}
		// def. neue ausgangssituation
		if(fa[0]*fx[0]<0){
			b=x; fb[0]=fx[0];
		}else{
			a=x; fa[0]=fx[0];
		}
	}while((b-a>TOLx) && (it<MAXIT));
	// [ausgabe] welches kriterium hat abgebrochen? belege rueckgabewerte
	if((b-a<=TOLx) || (it>=MAXIT)){
		res.NoIters=it; res.errcode=1;
		if(fa[0]<fb[0]){
			res.x=a; res.fval[0]=fa[0]; res.fval[1]=fa[1]; res.fval[2]=fa[2];
		}else{
			res.x=b; res.fval[0]=fb[0]; res.fval[1]=fb[1]; res.fval[2]=fb[2];
		}
		if(b-a<=TOLx) cout << "\ntoleranz fuer b-a erreicht!\n" << endl;
		if(it>=MAXIT){
			cout << "\nmaximale iterationszahl erreicht!" << "\n";
			cout << "   b-a=" << (b-a) << ", TOLx=" << TOLx << endl;
			cout << "   fx=" << fx[0] << ", TOLf=" << TOLf <<  "\n" << endl;
		}
	}
	eocPart(it, res, verbose, dist); // EOC (experimentelle konvergenz-ordnung)
	return;
}

void sekanten(results& res, realfun* func, double a, double b, int verbose, double TOLx, double TOLf, double TOLfp){
	char *verfahren="sekanten";
	int it=0;
	double x; // hier eigentlich nur hilfsvariable
	double fa[3], fb[3], mask[3], dist[MAXIT+1];
	mask[0]=1; mask[1]=0; mask[2]=0;
	// [ausgabe] acht signifikante stellen
	cout.setf(ios::fixed | ios::showpoint);
	cout.precision(8);
	if(idiotentest(a, b, TOLx, TOLf, res, verfahren, verbose)!=0) return;
	// erste fkts.werte
	func(fa,a,mask);
	func(fb,b,mask);
	dist[0]=b-a;
	// [idiotentest]
	if(fa[0]==fb[0] || (b-a)==0){
		cout << "*** FEHLER *** " << verfahren << "-verfahren\n		f(a)==f(b) oder a==b\n\n";
		res.errcode=-1;
		return;
	}
	// abbruchkriterien
	if((fabs(b-a)<TOLx) || (fabs(fa[0])<TOLf) || (fabs(fb[0])<TOLf)){
		cout << endl;
		cout << "anfangswerte erfuellen kriterien:" << endl;
		cout << it << "   stellen: a=" << a << ", b=" << b << endl;
		cout << "   fkt.-werte: f(a)=" << fa[0] << ", f(b)=" << fb[0] << endl;
		cout << endl;
		res.errcode=0;
		return;
	}
	do{
		if(verbose){
			// [ausgabe] aktuelles intervall, tabellenartig
			cout << setw(3) << it << "  a=" << setw(10) << a << ", b=" << setw(10) << b << ", f(a)=" << setw(10) << fa[0] << ", f(b)=" << setw(10) << fb[0] << endl;
		}
		if(fb[0]!=fa[0]) x=b-fb[0]*(b-a)/(fb[0]-fa[0]); // neues x und zug. f(x)
		dist[++it]=fabs(b-x); // bestimme abstand
		a=b; b=x;
		fa[0]=fb[0];
		func(fb,b,mask);
		if(fabs(fb[0])<TOLf || fabs(fb[0]-fa[0])<TOLfp){
			if(fabs(fb[0])<TOLf) cout << "\ntoleranz fuer |f(x)| erreicht!\n" << endl;
			else cout << "\ntoleranz fuer |f(x_k)-f(x_{k-1})| erreicht!\n" << endl;
			res.NoIters=it; res.errcode=1;
			res.x=x; res.fval[0]=fb[0]; res.fval[1]=fb[1]; res.fval[2]=fb[2];
			break;
		}
	}while((fabs(b-a)>TOLx) && (fabs(fb[0])>TOLf) && (it<MAXIT));
	// [ausgabe] welches kriterium hat abgebrochen? belege rueckgabewerte
	if((b-a<=TOLx) || (fabs(fb[0])<=TOLf)){
		res.NoIters=it; res.errcode=1;
		if(fa[0]<fb[0]){
			res.x=a; res.fval[0]=fa[0]; res.fval[1]=fa[1]; res.fval[2]=fa[2];
		}else{
			res.x=b; res.fval[0]=fb[0]; res.fval[1]=fb[1]; res.fval[2]=fb[2];
		}
		if(fabs(b-a)<=TOLx) cout << "\ntoleranz fuer |b-a|=" << fabs(b-a) << " erreicht!\n" << endl;
		if(it>=MAXIT){
			cout << "\nmaximale iterationszahl erreicht!" << "\n";
			cout << "   b-a=" << (b-a) << ", TOLx=" << TOLx << endl;
			cout << "   fx=" << fb[0] << ", TOLf=" << TOLf <<  "\n" << endl;
		}
	}
	eocPart(it, res, verbose, dist); // EOC (experimentelle konvergenz-ordnung)
	return;
}

void newton(results& res, realfun* func, double a, double b, int verbose, double TOLx, double TOLf, double TOLfp){
	char *verfahren="newton";
	int it=0;
	double x; // hier eigentlich nur hilfsvariable
	double fb[3], mask[3], dist[MAXIT+1]; // a, fa[3] werden nicht benoetigt, oder?
	mask[0]=1; mask[1]=1; mask[2]=0;
	// [ausgabe] acht signifikante stellen
	cout.setf(ios::fixed | ios::showpoint);
	cout.precision(8);
	a=b-1; // ;-)
	if(idiotentest(a, b, TOLx, TOLf, res, verfahren, verbose)!=0) return;
	// erste fkts.werte
	// brauche mer hier net: func(fa,a,mask);
	func(fb,b,mask);
	dist[0]=b;
	// abbruchkriterien
	if((fabs(fb[0])<TOLf) || (fabs(fb[1])<TOLfp)){
		cout << endl;
		cout << "anfangswerte erfuellen kriterien:" << endl;
		cout << it << "   stellen: b=" << b << endl;
		cout << "   fkt.-werte: f(b)=" << fb[0] << endl;
		cout << "   fkt.-werte: f'(b)=" << fb[1] << endl;
		cout << endl;
		res.errcode=0;
		return;
	}
	do{
		if(verbose){
			// [ausgabe] aktuelles intervall, tabellenartig
			cout << setw(3) << it << "  b=" << setw(10) << b << ", f(b)=" << setw(10) << fb[0] << ", f'(b)=" << setw(10) << fb[1] << endl;
		}
		if(fb[1]!=0) x=b-fb[0]/fb[1]; // neues x und zug. f(x)
		dist[++it]=fabs(b-x); // bestimme abstand
		b=x;
		func(fb,b,mask);
		if(fabs(fb[0])<TOLf || fabs(fb[1])<TOLfp){
			if(fabs(fb[0])<TOLf) cout << "\ntoleranz fuer |f(x)| erreicht!\n" << endl;
			else cout << "\ntoleranz fuer |f'(x)| erreicht!\n" << endl;
			res.NoIters=it; res.errcode=1;
			res.x=x; res.fval[0]=fb[0]; res.fval[1]=fb[1]; res.fval[2]=fb[2];
			break;
		}
	}while((dist[it]>TOLx) && (fabs(fb[0])>TOLf) && (fabs(fb[1])>TOLfp) && (it<MAXIT));
	// [ausgabe] welches kriterium hat abgebrochen? belege rueckgabewerte
	if((dist[it]<=TOLx) || (fabs(fb[0])<=TOLf) || (fabs(fb[1])<=TOLfp)){
		res.NoIters=it; res.errcode=1;
		res.x=b; res.fval[0]=fb[0]; res.fval[1]=fb[1]; res.fval[2]=fb[2];
		if(dist[it]<=TOLx) cout << "\ntoleranz fuer |b-a|=" << dist[it] << " erreicht!\n" << endl;
		if(it>=MAXIT){
			cout << "\nmaximale iterationszahl erreicht!" << "\n";
			cout << "   b-a=" << dist[it] << ", TOLx=" << TOLx << endl;
			cout << "   fx=" << fb[0] << ", TOLf=" << TOLf <<  "\n" << endl;
			cout << "  f'x=" << fb[1] << ", TOLf=" << TOLf <<  "\n" << endl;
		}
	}
	eocPart(it, res, verbose, dist); // EOC (experimentelle konvergenz-ordnung)
	return;
}

void subbaprima(results& res, realfun* func, double a, double b, int verbose, double TOLx, double TOLf, double TOLfp){
	char *verfahren="subbaprima"; // verbessertes newton-verfahren
	int it=0;
	double x; // hier eigentlich nur hilfsvariable
	double fb[3], mask[3], dist[MAXIT+1]; // a, fa[3] werden nicht benoetigt, oder?
	mask[0]=1; mask[1]=1; mask[2]=1;
	// [ausgabe] acht signifikante stellen
	cout.setf(ios::fixed | ios::showpoint);
	cout.precision(8);
	a=b-1; // ;-)
	if(idiotentest(a, b, TOLx, TOLf, res, verfahren, verbose)!=0) return;
	// erste fkts.werte
	// brauche mer hier net: func(fa,a,mask);
	func(fb,b,mask);
	dist[0]=b;
	// abbruchkriterien
	if((fabs(fb[0])<TOLf) || (fabs(fb[1])<TOLfp) || (fabs(fb[2])<TOLfp)){
		cout << endl;
		cout << "anfangswerte erfuellen kriterien:" << endl;
		cout << it << "   stellen: b=" << b << endl;
		cout << "   fkt.-werte: f(b)=" << fb[0] << endl;
		cout << "   fkt.-werte: f'(b)=" << fb[1] << endl;
		cout << "   fkt.-werte: f''(b)=" << fb[2] << endl;
		cout << endl;
		res.errcode=0;
		return;
	}
	do{
		if(verbose){
			// [ausgabe] aktuelles intervall, tabellenartig
			cout << setw(3) << it << "  b=" << setw(10) << b << ", f(b)=" << setw(10) << fb[0] << ", f'(b)=" << setw(10) << fb[1] << ", f''(b)=" << setw(10) << fb[2] << endl;
		}
		if(fb[1]!=0 && fb[2]!=0) x=b-fb[0]/fb[1]-0.5*(fb[2]*powl(fb[0],2))/powl(fb[1],3); // neues x und zug. f(x)
		dist[++it]=fabs(b-x); // bestimme abstand
		b=x;
		func(fb,b,mask);
		if(fabs(fb[0])<TOLf || fabs(fb[1])<TOLfp){
			if(fabs(fb[0])<TOLf) cout << "\ntoleranz fuer |f(x)| erreicht!\n" << endl;
			else cout << "\ntoleranz fuer |f'(x)| erreicht!\n" << endl;
			res.NoIters=it; res.errcode=1;
			res.x=x; res.fval[0]=fb[0]; res.fval[1]=fb[1]; res.fval[2]=fb[2];
			break;
		}
	}while((dist[it]>TOLx) && (fabs(fb[0])>TOLf) && (fabs(fb[1])>TOLfp) && (it<MAXIT));
	// [ausgabe] welches kriterium hat abgebrochen? belege rueckgabewerte
	if((dist[it]<=TOLx) || (fabs(fb[0])<=TOLf) || (fabs(fb[1])<=TOLfp)){
		res.NoIters=it; res.errcode=1;
		res.x=b; res.fval[0]=fb[0]; res.fval[1]=fb[1]; res.fval[2]=fb[2];
		if(dist[it]<=TOLx) cout << "\ntoleranz fuer |b-a|=" << dist[it] << " erreicht!\n" << endl;
		if(it>=MAXIT){
			cout << "\nmaximale iterationszahl erreicht!" << "\n";
			cout << "   b-a=" << dist[it] << ", TOLx=" << TOLx << endl;
			cout << "   fx=" << fb[0] << ", TOLf=" << TOLf <<  "\n" << endl;
			cout << "  f'x=" << fb[1] << ", TOLfp=" << TOLfp <<  "\n" << endl;
			cout << " f''x=" << fb[2] << ", TOLfp=" << TOLfp <<  "\n" << endl;
		}
	}
	eocPart(it, res, verbose, dist); // EOC (experimentelle konvergenz-ordnung)
	return;
}

// [ausgabe] alle relevanten daten
void endausgabe(results& res){
	cout << "resultat nach " << res.NoIters << " iterationen:" << endl;
	cout << "  iterierte x=" << res.x << endl;
	cout << "  fkt.wert: f(x)=" << res.fval[0] << endl;
	cout << "  kappa(" << res.NoIters << ") = " << res.kappa[res.NoIters] << endl;
	cout << endl;
}

int main(){
	int verbose=1;				// trace-ausgabe?
	int leaveProgram; 		// [test] nur zu testzwecken (siehe 3.letzte zeile)
	results res;
	res.kappa=new double[MAXIT+1];	// erzeuge vektor kappa dynamisch
	double a=0, b=1;			// intervall [0,1], [-1,1], [-4,4], [-1,1] je nach func
	realfun* func=func1;  // func1..func4 gibt es
	bisektion(res, func, a, b, verbose);		endausgabe(res);
	regulaFalsi(res, func, a, b, verbose);	endausgabe(res);
	sekanten(res, func, a, b, verbose);			endausgabe(res);
	newton(res, func, a, b,verbose);				endausgabe(res);
	subbaprima(res, func, a, b,verbose);		endausgabe(res);
	delete[] res.kappa;
	cin >>leaveProgram;
	return 0;
}