mp_real mpe2gausstheo(mp_real x0_, mp_real g)
{
static mp_real SQRTpi = sqrt(mppic) ;
// double gd = 1.0; /* gd = 1/2 gamma !!!; hier gamma = 0.5 */
double x0d = dble(x0_);
double gd = dble(g);
mp_real fac = g/SQRTpi;
double h = 1E-04;
int n = 100000;
double yd_ = trapez(kerngauss,x0d,gd,x0d,h,n);
mp_real y_ = fac * mp_real(yd_);
return y_;
}
mp_real mpe2gauss(mp_real x0_, mp_real g)
{
static mp_real SQRTpi = sqrt(mppic) ;
//double gd = 1.0; /* gd = 1/2 gamma !!!; hier gamma = 0.5 */
double x0d = dble(x0_);
// double xi = Xi4(x0d); /*Rauschen*/
double xi = 0.0; /*Rauschen*/
double gd = dble(g);
mp_real fac = g/SQRTpi;
double h = 1E-04;
int n = 100000;
double yd_ = trapez(kerngauss,x0d,gd,x0d,h,n);
mp_real y_ = fac * mp_real(yd_);
//y_ = y_ * (mp_real(1.0) + mp_real(0.0) * xi);
return y_;
}
int main()
{
cout << setiosflags(ios::uppercase);
ofstream fout("Data.out");
fout << setiosflags(ios::uppercase);
mp_init();
double x1_in, x2_in;
int m;
mp_real b, x0, step, x1, x2;
cin >> x1_in >> x2_in >> m;
x1 = mp_real(x1_in);
x2 = mp_real(x2_in);
step = (x2 - x1)/m;
cout << "+++ Precision = " << mpipl << " +++" << endl;
cout << "x1 = " << x1;
cout << "x2 = " << x2;
cout << "m = " << m << endl;
for(int j = 0; j <= m; j++)
{
x0 = x1 + j * step;
mp_real datamp = mpe2(x0);
mp_real fexaktmp = mpe2exakt(x0);
mp_real Errormp = datamp - fexaktmp;
mp_real Errorrelmp = 100.0 * (abs(Errormp)/abs(fexaktmp));
double data = dble(datamp);
double fexakt = dble(fexaktmp);
double Error = dble(Errormp);
double Errorrel = dble(Errorrelmp);
double xd0 = dble(x0);
(ostream&) fout << xd0 << '\t' << fexakt << '\t' << data << '\t' << Error << '\t' << Errorrel << endl;
}
return 0;
}
void hdaf_filter_kernel ( double *& kernel, int & w, double L, int n, int m, double k )
{
mp_real sigma = sqrt( mp_2*m+ mp_1)/k;
ml_poly<mp_real > P;
make_hdaf_ml_poly(P,m );
w = (int)ceil(hdaf_truncate_point (1E-16, 4E-16, m, dble(sigma), 0 )/(L/n));
if (kernel != 0) ml_free( kernel );
kernel = ml_alloc<double > (2*w+1);
double * p = &(kernel[w]);
mp_real h = ((mp_real)L)/n;
mp_real s = h/(mp_sqrt2*sigma);
mp_real ss = s*s;
mp_real f = pow(mp_sqrt2*sigma,-1)*(h/n);
for (int k=-w; k<=w; k++ )
p[k] = dble( exp(-ss*(k*k)) *P( dble(s*k) ) *f );
}
int main()
{
cout << setiosflags(ios::uppercase);
ofstream out1("Daten_Gauss.out");
out1 << setiosflags(ios::uppercase);
ofstream out("LIP.out");
out << setiosflags(ios::uppercase);
ofstream outs("Y2D.out");
outs << setiosflags(ios::uppercase);
ofstream rout("REGLIP_Gauss.out");
rout << setiosflags(ios::uppercase);
cout << "*** Imaginaerteilgleichung ***" << endl;
cout << "*** Filter: Gauss ***" << endl;
mp_init();
cout << "*** Precision = " << mpipl << " ***" << endl;
int M, N, MD;
double xa, xb, x1, x2, xr1, xr2, h, step, step2, b1, dfactor, dpi;
mp_real b, mpx1, mpx2, mpstep, mpx;
dpi = 4.0 * atan(1.0);
mp_real pi = mppic; // pi aus der Bibliothek !!!
mp_real pi2 = pi * pi;
static mp_real factor;
cin >> b1;
cin >> xa >> xb >> MD;
cin >> x1 >> x2 >> M;
cin >> xr1 >> xr2 >> N ;
cout << '\v';
/* KERNELARRY ANFANG */
mp_real* const mpregKern = new mp_real [M+1];
b = mp_real(b1);
mpx1 = mp_real(x1);
mpx2 = mp_real(x2);
mpstep = (mpx2 - mpx1)/mp_real(M);
/* Vorfaktor */
factor = mp_real(2.0)*b/power(pi,mp_real(1.5));
factor *= exp(mp_real(0.25) * pi2 * b * b);
dfactor = 2.0 * (b1/pow(dpi,1.5)) * exp(b1*b1*dpi*dpi*.25);
cout << "*** Begin: Init. Kernel *** " << endl;
cout << "b1 = " << b1 << endl;
cout << "b = " << b ;
cout << "x1 = " << x1 << endl; /* Anfangs-/Endpunkt der Regularisierung */
cout << "x2 = " << x2 << endl;
cout << "M = " << M << endl;
cout << "h = " << mpstep;
cout << "factor = " << factor ;
cout << "dfactor = " << dfactor << endl;
for(int i = 0; i <= M; i++)
{
mpx = mpx1 + i * mpstep;
mpregKern[i] = mpregkerne2(mpx, b);
}
cout << "*** End: Init. Kernel *** " << endl;
/* KERNELARRY ENDE */
double x0, datlinpol, Error_splint, DataError, e2core;
/* Index der Vektoren beginnt mit 1 und *nicht* mit 0 */
double* y2d = dvector(1,MD); /* 2.Ableitung der SPL-Funktion */
double* data = dvector(1,MD); /* Datenvektor */
double* x = dvector(1,MD); /* x-Vektor */
/* Datenarrays fuellen */
h = (xb - xa)/(MD - 1);
double rho = MD/(xb -xa);
cout << '\v';
cout << "*** Begin: Init. Data-Array ***" << endl;
cout << "xa = " << xa << endl; /* Anfangs-/Endpunkte der Daten */
cout << "xb = " << xb << endl;
cout << "MD = " << MD << endl; /* Zahl der Datenpunkte */
cout << "h = " << h << endl;
cout << "rho = " << rho << endl;
x[1] = xa;
data[1] = e2data(xa);
for(int i = 2; i <= MD ; i++)
{
x[i] = xa + (i-1) * h;
data[i] = e2data(x[i]);
}
x[MD] = xb;
data[MD] = e2data(xb);
cout << "*** End: Init. Data-Array ***" << endl;
cout << '\v' ;
/* Kontrollausgabe, Datenausgabe */
for(int i = 1; i <= MD; i++)
{
DataError = fabs(data[i] - e2(x[i]))/fabs(e2(x[i]));
DataError *= 100.0;
out1 << i << '\t' << x[i] << '\t' << data[i] << '\t' << e2(x[i]) << '\t' << DataError << endl;
}
cout << "*** Begin: Interpol. *** " << endl;
intlinear(x,data,MD,y2d);
for(int i = 1; i <= MD; i++) outs << i << '\t' << y2d[i] << endl;
cout << "*** End: Interpol. *** " << endl;
cout << '\v';
for(int j = 0; j <= M; j++)
{
step = dble(mpstep);
x0 = x1 + j * step;
datlinpol = linint(x,data,y2d,MD,x0);
e2core = e2(x0);
Error_splint = fabs(datlinpol - e2core)/fabs(e2core);
Error_splint *= 100.0;
out << x0 << '\t' << datlinpol << '\t' << e2core << '\t' << Error_splint << endl;
}
/* REGULARISIERUNG */
double xi;
mp_real mp_regsum, mpdata, mpError, mpreg;
double regsum, Error, Reg;
step2 = (xr2 - xr1)/N;
cout <<"*** Begin: Regularisation ***" << endl;
cout << "b1 = " << b1 << endl;
cout << "b = " << b ;
cout << "x1 = " << xr1 << endl;
cout << "x2 = " << xr2 << endl;
cout << "N = " << N << endl;
cout << "h = " << step2 << endl;
cout << '\v' ;
for(int jj = 0; jj <= N; jj++)
{
mp_regsum = mp_real(0.0);
x0 = xr1 + jj * step2;
for(int j = 0; j <= M; j++)
{
xi = x1 + j * step;
xi = x0 - xi;
datlinpol = linint(x,data,y2d,MD,xi);
mpdata = mp_real(datlinpol);
mp_regsum += mpregKern[j] * mpdata;
}
mp_regsum *= mpstep;
mp_regsum *= factor;
mpreg = mpRegexakt(mp_real(x0),b);
mpError = abs(mp_regsum - mpreg)/abs(mpreg);
mpError *= mp_real(100.0);
regsum = dble(mp_regsum);
Error = dble(mpError);
Reg = dble(mpreg);
cout << x0 << endl;
cout << mpreg << mp_regsum << mpError << endl;
rout << x0 << '\t' << Reg << '\t' << regsum << '\t' << Error << '\t' << b1 << endl;
}
cout <<"*** End: Regularisation ***" << endl;
free_dvector(y2d,1,MD);
free_dvector(data,1,MD);
free_dvector(x,1,MD);
delete [] mpregKern;
return 0;
}
int main()
{
mp_init();
// const mp_complex I = mp_complex(0.0,1.0);
static mp_real pi = mppic;
static mp_real pi2 = mppic * mppic;
static mp_real Sqrtpi = sqrt(mppic);
cout << setiosflags(ios::uppercase);
ofstream out("REGSOLC.out");
out << setiosflags(ios::uppercase);
ofstream kout("KERNELCMP.out");
kout << setiosflags(ios::uppercase);
ofstream dout("DATACMP.out");
dout << setiosflags(ios::uppercase);
int M, N;
double bd;
double x1d, x2d, xad, xbd;
cin >> bd;
cin >> xad >> xbd >> N;
cin >> x1d >> x2d >> M;
cout << "*** Precision = " << mpipl << " ***" << endl;
cout << "b = " << bd << endl;
cout << "xa = " << xad << endl;
cout << "xb = " << xbd << endl;
cout << "x1 = " << x1d << endl;
cout << "x2 = " << x2d << endl;
cout << "N = " << N << endl;
cout << "M = " << M << endl;
mp_real xa = mp_real(xad);
mp_real xb = mp_real(xbd);
mp_real x1 = mp_real(x1d);
mp_real x2 = mp_real(x2d);
mp_real b = mp_real(bd);
mp_real factor;
factor = b/power(pi,mp_real(1.5))*exp(mp_real(1.25)*pi2*b*b);
mp_real h = (xb - xa)/mp_real(N);
cout << "h = " << h ;
mp_real step = (x2 - x1)/mp_real(M);
cout << "h2 = " << step;
cout << "Faktor = " << factor << endl;
mp_real mpx0;
// mp_real mpx, mpx0;
// mp_complex regkern, data;
// double Realregkern, Imaregkern;
// double RealData, ImaData;
/*
cout << " *** write Kernel and Data *** " << endl;
for(int i = 0; i <= N; i++)
{
mpx0 = mp_real(0.0);
mpx = xa + i * h;
regkern = mpregkernc(mpx,mpx0,b);
// cout << mpx << regkern << endl;
Realregkern = dble(MP_REAL(regkern));
Imaregkern = dble(aimag(regkern));
// data = E_data(mpx);
// cout << mpx << data << endl;
// RealData = dble(MP_REAL(data));
// ImaData = dble(aimag(data));
kout << dble(mpx) << '\t' << Realregkern << '\t' << Imaregkern << '\t' << bd<< endl;
// dout << dble(mpx) << '\t' << RealData << '\t' << ImaData << endl;
}
*/
mp_complex mpregsum;
mp_real mpReg, RelError;
double RealReg, ImaReg, Error;
cout << " *** Begin: Regularisation *** " << endl;
for(int j = 0; j <= M; j++)
{
mpx0 = x1 + j * step;
mpregsum = mptrapez(RegIntegrand,mpx0,b,mpx0,.5*h,N);
mpregsum *=factor;
mpReg = Regtheo(mpx0,b);
RelError = abs(mpregsum - mpReg)/abs(mpReg);
RelError *= mp_real(100.0);
cout << mpx0 << mpregsum << endl;
cout << mpReg << RelError << endl;
RealReg = dble(MP_REAL(mpregsum));
ImaReg = dble(aimag(mpregsum));
Error = dble(RelError);
out << dble(mpx0) << '\t' << dble(mpReg) << '\t' << RealReg << '\t' << ImaReg << '\t' << Error << '\t' << bd << endl;
}
cout << " *** End: Regularisation *** " << endl;
return 0;
}
int
main (int argc, char **argv)
{
int i,l; /* non-descript indices */
char c; /* non-descript character storage */
if (pledge("stdio rpath wpath cpath tty exec", NULL) == -1)
err(1, "pledge");
signal(SIGINT, getout); /* trap interrupts */
/* use whole screen for text */
begscr = 0;
getarg(argc, argv);
initcurses();
/* check if restored game and save flag for later */
if ((rfl = rflag)) {
if (pledge("stdio rpath wpath cpath tty", NULL) == -1)
err(1, "pledge");
wrboard(); /* print board */
/* if new game, pretend to be a non-restored game */
if (cturn == 0)
rflag = 0;
} else {
rscore = wscore = 0; /* zero score */
if (aflag) { /* print rules */
addstr(rules);
if (yorn(0)) {
endwin();
execl(TEACH, "teachgammon", (char *)NULL);
err(1, "%s", noteach);
} else {/* if not rules, then instructions */
addstr(need);
if (yorn(0)) { /* print instructions */
clear();
text(instruct);
}
}
}
if (pledge("stdio rpath wpath cpath tty", NULL) == -1)
err(1, "pledge");
init(); /* initialize board */
if (pnum == 2) {/* ask for color(s) */
printw("\n%s", askcol);
while (pnum == 2) {
c = readc();
switch (c) {
case 'R': /* red */
pnum = -1;
break;
case 'W': /* white */
pnum = 1;
break;
case 'B': /* both */
pnum = 0;
break;
case 'P': /* Control the dice */
iroll = 1;
addstr("\nDice controlled!\n");
addstr(askcol);
break;
default: /* error */
beep();
}
}
}
wrboard(); /* print board */
move(18, 0);
}
/* limit text to bottom of screen */
begscr = 17;
for (;;) { /* begin game! */
/* initial roll if needed */
if ((!rflag) || raflag)
roll();
/* perform ritual of first roll */
if (!rflag) {
move(17, 0);
while (D0 == D1) /* no doubles */
roll();
/* print rolls */
printw("%s%d%s%d", rollr, D0, rollw, D1);
/* winner goes first */
if (D0 > D1) {
addstr(rstart);
cturn = 1;
} else {
addstr(wstart);
cturn = -1;
}
}
/* initialize variables according to whose turn it is */
if (cturn == 1) { /* red */
home = 25;
bar = 0;
inptr = &in[1];
inopp = &in[0];
offptr = &off[1];
offopp = &off[0];
Colorptr = &color[1];
colorptr = &color[3];
colen = 3;
} else { /* white */
home = 0;
bar = 25;
inptr = &in[0];
inopp = &in[1];
offptr = &off[0];
offopp = &off[1];
Colorptr = &color[0];
colorptr = &color[2];
colen = 5;
}
/* do first move (special case) */
if (!(rflag && raflag)) {
if (cturn == pnum) /* computer's move */
domove(0);
else { /* player's move */
mvlim = movallow();
/* reprint roll */
move(cturn == -1 ? 18 : 19, 0);
proll();
getmove(); /* get player's move */
}
}
move(17, 0);
clrtoeol();
begscr = 18;
/* no longer any difference between normal and recovered game. */
rflag = 0;
/* move as long as it's someone's turn */
while (cturn == 1 || cturn == -1) {
/* board maintainence */
moveplayers(); /* fix board */
/* do computer's move */
if (cturn == pnum) {
domove(1);
/* see if double refused */
if (cturn == -2 || cturn == 2)
break;
/* check for winning move */
if (*offopp == 15) {
cturn *= -2;
break;
}
continue;
}
/* (player's move) */
/* clean screen if safe */
if (hflag) {
move(20, 0);
clrtobot();
hflag = 1;
}
/* if allowed, give him a chance to double */
if (dflag && dlast != cturn && gvalue < 64) {
move(cturn == -1 ? 18: 19, 0);
addstr(*Colorptr);
c = readc();
/* character cases */
switch (c) {
case 'R': /* reprint board */
wrboard();
break;
case 'S': /* save game */
raflag = 1;
save(1);
break;
case 'Q': /* quit */
quit();
break;
case 'D': /* double */
dble();
break;
case ' ': /* roll */
case '\n':
roll();
printw(" rolls %d %d. ", D0, D1);
/* see if he can move */
if ((mvlim = movallow()) == 0) {
/* can't move */
printw("%s%s%s", toobad1, *colorptr, unable);
if (pnum) {
moveplayers();
sleep(MVPAUSE);
}
nexturn();
break;
}
getmove();
/* okay to clean screen */
hflag = 1;
break;
default: /* invalid character */
/* print help message */
move(20, 0);
text(helpm);
move(cturn == -1 ? 18 : 19, 0);
/* don't erase */
hflag = 0;
}
} else {/* couldn't double */
/* print roll */
roll();
move(cturn == -1 ? 18: 19, 0);
proll();
/* can he move? */
if ((mvlim = movallow()) == 0) {
/* he can't */
printw("%s%s%s", toobad2, *colorptr, cantmv);
moveplayers();
sleep(MVPAUSE);
nexturn();
continue;
}
getmove();
}
}
/* don't worry about who won if quit */
if (cturn == 0)
break;
/* fix cturn = winner */
cturn /= -2;
/* final board pos. */
moveplayers();
/* backgammon? */
mflag = 0;
l = bar + 7 * cturn;
for (i = bar; i != l; i += cturn)
if (board[i] * cturn)
mflag++;
/* compute game value */
move(20, 0);
if (*offopp == 15) {
if (mflag) {
addstr(bgammon);
gvalue *= 3;
}
else if (*offptr <= 0) {
addstr(gammon);
gvalue *= 2;
}
}
/* report situation */
if (cturn == -1) {
addstr("Red wins ");
rscore += gvalue;
} else {
addstr("White wins ");
wscore += gvalue;
}
printw("%d point%s.\n", gvalue, (gvalue > 1) ? "s":"");
/* write score */
wrscore();
/* see if he wants another game */
addstr(again);
if ((i = yorn('S')) == 0)
break;
init();
if (i == 2) {
addstr(" Save.\n");
cturn = 0;
save(0);
}
/* yes, reset game */
wrboard();
}
/* give him a chance to save if game was recovered */
if (rfl && cturn) {
addstr(svpromt);
if (yorn(0)) {
/* re-initialize for recovery */
init();
cturn = 0;
save(0);
}
}
/* leave peacefully */
getout(0);
/* NOT REACHED */
}
int main()
{
cout << setiosflags(ios::uppercase);
ofstream out("GAUSS.out");
out << setiosflags(ios::uppercase);
ofstream dout("GAUSSMOD.out");
dout << setiosflags(ios::uppercase);
mp_init();
double s_in, h_in , b_in, dfactor, dpi, x1_in, x2_in;
int N, m, Control;
dpi = 4.0 * atan(1.0);
mp_real pi = mppic; // pi aus der Bibliothek !!!
mp_real pi2 = pi * pi;
static mp_real factor;
mp_real a, b, x0, s, h, x1, x2;
/* Parameter als doubles einlesen */
cin >> b_in >> Control;
cin >> s_in >> h_in >> N;
cin >> x1_in >> x2_in >> m;
/* Konversion: double -> mp_real */
b = mp_real(b_in);
s = mp_real(s_in);
h = mp_real(h_in);
x1 = mp_real(x1_in);
x2 = mp_real(x2_in);
a = 1/(mp_real(2.0)*b);
/* Vorfaktor */
factor = mp_real(2.0)*b/power(pi,mp_real(1.5));
factor *= exp(mp_real(0.25) * pi2 * b * b);
dfactor = 2.0 * (b_in/pow(dpi,1.5)) * exp(b_in*b_in*dpi*dpi*.25);
cout << "+++ Precision = " << mpipl << " +++" << endl;
cout << "b = " << b ;
cout << "a = " << a;
cout << "h = " << h;
cout << "N = " << N << endl;
cout << '\v' ;
cout << "x1 = " << x1;
cout << "x2 = " << x2;
cout << "m = " << m << endl;
cout << "xmax = " << h * N << endl;
cout << "dfaktor = " <<dfactor << endl;
cout << "Faktor = " <<factor << endl;
mp_real mp_E2_Gauss, mp_E2_Gausstheo, mp_Reg, mp_Regtheo, mp_ModGauss, step;
mp_real mp_diffrel, mp_diffrelreg;
double E2, E2_Gauss, E2_Gausstheo, Reg, Reg_theod, ModGauss, diffrel, x0d;
double diffrelreg;
step = (x2 -x1)/mp_real(m);
if(Control == 1)
{
cout << "*** Begin: Read Data ***" << endl;
for(int j = 0; j <= m; j++)
{
x0 = x1 + j * step;
mp_E2_Gauss = mpe2gauss(x0);
mp_E2_Gausstheo = mpe2gausstheo(x0);
mp_real mpdeltarel = abs(mp_E2_Gauss - mp_E2_Gausstheo)/abs(mp_E2_Gausstheo);
mpdeltarel *= mp_real(100.0);
x0d = dble(x0);
E2 = e2(x0d);
E2_Gauss = dble(mp_E2_Gauss);
E2_Gausstheo = dble(mp_E2_Gausstheo);
double deltarel = dble(mpdeltarel);
cout << x0 << mp_E2_Gausstheo << mp_E2_Gauss << mpdeltarel << endl;;
(ostream&) dout << x0d << '\t' << E2 << '\t' << E2_Gausstheo <<'\t' << E2_Gauss << '\t' << deltarel << endl;
}
cout << "*** End: Read Data ***" << endl;
}
cout << "*** Begin: Regularisation ***" << endl;
for(int jj = 0; jj <= m; jj++)
{
x0 = x1 + jj * step;
s = x0;
mp_Reg = mptrapez(mpkern,x0,b,s,h,N);
mp_Reg *= factor;
mp_Regtheo = Regtheo(x0, a); //reine Regularisierte
mp_ModGauss = GaussDichte(x0); //Gaussdichte als Modell
mp_diffrel = abs(mp_Reg - mp_Regtheo)/abs(mp_Regtheo);
mp_diffrel *= mp_real(100.0);
mp_diffrelreg = abs(mp_Reg - mp_ModGauss)/abs(mp_ModGauss);
mp_diffrelreg *= mp_real(100.0);
Reg_theod = dble(mp_Regtheo);
Reg = dble(mp_Reg);
ModGauss = dble(mp_ModGauss);
diffrel = dble(mp_diffrel);
diffrelreg = dble(mp_diffrelreg);
x0d = dble(x0);
cout << mp_Reg << mp_Regtheo << mp_ModGauss << mp_diffrel << mp_diffrelreg<< endl;
(ostream&) out << b_in << '\t' << x0d << '\t' << ModGauss << '\t' << Reg << '\t' << Reg_theod<< '\t' << diffrel <<'\t' << diffrelreg << endl;
}
cout << "*** End: Regularisation ***" << endl;
return 0;
}
int main()
{
cout << setiosflags(ios::uppercase);
ofstream out("LIPGauss.out");
out << setiosflags(ios::uppercase);
ofstream out1("DATENGaussLip.out");
out1 << setiosflags(ios::uppercase);
ofstream outs("Y2D.out");
outs << setiosflags(ios::uppercase);
ofstream rout("RegGaussLIP.out");
rout << setiosflags(ios::uppercase);
cout << "*** Filter: Gauss *** " << endl;
cout << "*** Imaginaerteil *** " << endl;
mp_init();
cout << "*** Precision = " << mpipl << " ***" << endl;
// pi aus der Bibliothek !!!
mp_real pi = mppic;
mp_real pi2 = pi * pi;
static mp_real factor;
static double dpi = 4.0 * atan(1.0);
static double dfactor;
int M, MD, N;
double b1, xa, xb, h, x1, x2, hreg;
mp_real b;
/* Parameter einlesen */
cin >> b1;
cin >> xa >> xb >> MD;
cin >> hreg >> N;
cin >> x1 >> x2 >> M;
b = mp_real(b1);
/* Vorfaktor */
factor = mp_real(2.0)*b/power(pi,mp_real(1.5));
factor *= exp(mp_real(0.25) * pi2 * b * b);
dfactor = 2.0 * (b1/pow(dpi,1.5)) * exp(b1*b1*dpi*dpi*.25);
/* DATEN UND SPLINE-ROUTINE */
/* 1. Ableitung der Funktion an den Eckpunkten */
double yp1, ypn;
double x0, dataspl, Error_splint, DataError, e2core;
/* Index der Vektoren beginnt mit 1 und *nicht* mit 0 */
double* y2d = dvector(1,MD); /* 2.Ableitung der SPL-Funktion */
double* data = dvector(1,MD); /* Datenvektor */
double* x = dvector(1,MD); /* x-Vektor */
/* Nebenbedingung natuerliche Splinefunktion setzen */
yp1 = ypn = 1E30;
// yp1 = ypn = 0.0 ;
/* Datenarrays fuellen */
h = (xb - xa)/(MD - 1);
double rho = MD/(xb - xa);
cout << '\v';
cout << "*** Begin: Init. Data-Array ***" << endl;
cout << "xa = " << xa << endl; /* Anfangs-/Endpunkte der Daten */
cout << "xb = " << xb << endl;
cout << "MD = " << MD << endl; /* Zahl der Datenpunkte */
cout << "h = " << h << endl;
cout << "rho = " << rho << endl;
x[1] = xa;
data[1] = e2data(xa);
for(int i = 2; i <= MD ; i++)
{
x[i] = xa + (i-1) * h;
data[i] = e2data(x[i]);
//cout << i << '\t' << x[i] << '\t' << data[i] << '\t' << e2data(x[i]) << endl;
}
x[MD] = xb;
data[MD] = e2data(xb);
cout << "*** End: Init. Data-Array ***" << endl;
cout << '\v' ;
/* Kontrollausgabe, Datenausgabe */
for(int i = 1; i <= MD; i++)
{
DataError = fabs(data[i] - e2(x[i]))/fabs(e2(x[i]));
DataError *= 100.0;
out1 << i << '\t' << x[i] << '\t' << data[i] << '\t' << e2(x[i]) << '\t' << DataError << endl;
}
cout << "*** Begin: LinInt. *** " << endl;
intlinear(x,data,MD,y2d);
for(int i = 1; i <= MD; i++) outs << i << '\t' << y2d[i] << endl;
cout << "*** End: LinInt *** " << endl;
cout << '\v';
// static double step = (xb - xa)/MD;
double xmax = N * hreg ;
for(int j = 0; j <= (2 * N); j++)
{
x0 = j * hreg - xmax ;
dataspl = linint(x,data,y2d,MD,x0);
e2core = e2(x0);
Error_splint = fabs(dataspl - e2core)/fabs(e2core);
Error_splint *= 100.0;
// cout << x0 << '\t' << dataspl << '\t' << e2core << '\t' << Error_splint << endl;
out << x0 << '\t' << dataspl << '\t' << e2core << '\t' << Error_splint << endl;
}
/* REGULARISATION */
mp_real mp_regsum, mpdataup, mpdatadown , fu, fd, mpx0, zu, zd;
mp_real mpx1, mpx2;
mp_real mp_theoreg, mp_Error;
double theoreg, Errorel;
static mp_real mph = mp_real(hreg);
static mp_real mprstep;
double dregsum, x0d, dzu, dzd;
mpx1 = mp_real(x1);
mpx2 = mp_real(x2);
mprstep = (mpx2 - mpx1)/mp_real(M);
cout <<"*** Begin: Regularisation ***" << endl;
cout << "b = " << b1 << endl;
cout << "N = " << N << endl;
cout << "h = " << hreg << endl;
cout << "xmax = " << N * hreg << endl;
cout << "hreg = " << mph << endl;
cout << "x1 = " << x1 << endl;
cout << "x2 = " << x2 << endl;
cout << "h = " << mprstep << endl;
cout << "dFaktor = " << dfactor << endl;
cout << "Faktor = " << factor << endl;
for(int jj = 0; jj <= M; jj++)
{
mpx0 = mpx1 + jj * mprstep;
x0d = dble(mpx0);
mpdataup = mp_real(linint(x,data,y2d,MD,x0d));
mp_regsum = mpregkerne2(mpx0, mpx0 , b) * mpdataup;
for(int j = 1; j <= N; j++)
{
zu = mpx0 + j * mph;
dzu = dble(zu);
zd = mpx0 - j * mph;
dzd = dble(zd);
mpdataup = mp_real(linint(x,data,y2d,MD,dzu));
fu = mpregkerne2(zu,mpx0,b) * mpdataup;
mpdatadown = mp_real(linint(x,data,y2d,MD,dzd));
fd = mpregkerne2(zd,mpx0,b) * mpdatadown;
mp_regsum += (fu + fd) ;
}
mp_regsum *= mph;
mp_regsum *= factor;
mp_theoreg = mpRegexakt(mpx0, b);
mp_Error = abs(mp_regsum - mp_theoreg)/abs(mp_theoreg);
mp_Error *= mp_real(100.0);
dregsum = dble(mp_regsum);
theoreg = dble(mp_theoreg);
Errorel = dble(mp_Error);
cout << mpx0 << mp_theoreg << mp_regsum << mp_Error << endl;
rout << x0d << '\t' << theoreg << '\t' << dregsum << '\t' << Errorel << '\t' << b1 << endl;
}
cout <<"*** End: Regularisation ***" << endl;
return 0;
}
/* zero if first move */
void
move(int okay)
{
int i; /* index */
int l; /* last man */
l = 0;
if (okay) {
/* see if comp should double */
if (gvalue < 64 && dlast != cturn && dblgood()) {
writel(*Colorptr);
dble(); /* double */
/* return if declined */
if (cturn != 1 && cturn != -1)
return;
}
roll();
}
race = 0;
for (i = 0; i < 26; i++) {
if (board[i] < 0)
l = i;
}
for (i = 0; i < l; i++) {
if (board[i] > 0)
break;
}
if (i == l)
race = 1;
/* print roll */
if (tflag)
curmove(cturn == -1 ? 18 : 19, 0);
writel(*Colorptr);
writel(" rolls ");
writec(D0 + '0');
writec(' ');
writec(D1 + '0');
/* make tty interruptable while thinking */
if (tflag)
cline();
fixtty(noech);
/* find out how many moves */
mvlim = movallow();
if (mvlim == 0) {
writel(" but cannot use it.\n");
nexturn();
fixtty(raw);
return;
}
/* initialize */
for (i = 0; i < 4; i++)
cp[i] = cg[i] = 0;
/* strategize */
trymove(0, 0);
pickmove();
/* print move */
writel(" and moves ");
for (i = 0; i < mvlim; i++) {
if (i > 0)
writec(',');
wrint(p[i] = cp[i]);
writec('-');
wrint(g[i] = cg[i]);
makmove(i);
}
writec('.');
/* print blots hit */
if (tflag)
curmove(20, 0);
else
writec('\n');
for (i = 0; i < mvlim; i++)
if (h[i])
wrhit(g[i]);
/* get ready for next move */
nexturn();
if (!okay) {
buflush();
sleep(3);
}
fixtty(raw); /* no more tty interrupt */
}
int main()
{
cout << setiosflags(ios::uppercase);
//ofstream dout("RegE2_MP.out");
//dout << setiosflags(ios::uppercase);
mp_init();
double s_in, h_in, b1_in, b2_in, db, dfactor, dpi, x1_in, x2_in, dxi;
int N, m, Nb;
dpi = 4.0 * atan(1.0);
mp_real pi = mppic; // pi aus der Bibliothek !!!
mp_real pi2 = pi * pi;
static mp_real factor;
mp_real b, b1, b2, bstep, x0, s, h, x1, x2, xi;
/* Parameter als doubles einlesen */
cin >> b1_in >> b2_in >> Nb;
cin >> s_in >> h_in >> N;
cin >> x1_in >> x2_in >> m >> dxi;
/* Konversion: double -> mp_real */
b1 = mp_real(b1_in);
b2 = mp_real(b2_in);
s = mp_real(s_in);
h = mp_real(h_in);
x1 = mp_real(x1_in);
x2 = mp_real(x2_in);
xi = mp_real(dxi);
mp_real step = (x2 - x1)/m;
bstep = (b2 -b1)/mp_real(Nb);
cout << "+++ Precision = " << mpipl << " +++" << endl;
cout << "b1 = " << b1 ;
cout << "b2 = " << b2 ;
cout << "hb = " << bstep;
cout << "s = " << s;
cout << "h = " << h;
cout << "N = " << N << endl;
cout << '\v' ;
cout << "x1 = " << x1;
cout << "x2 = " << x2;
cout << "m = " << m << endl;
cout << "xi = " << dxi << endl;
cout << "xh = " << step;
cout << "xmax = " << h * N << endl;
//cout << "dfaktor = " <<dfactor << endl;
//cout << "Faktor = " <<factor << endl;
String data = "Data-N" ;
data = data + strdup(fix3(N)) + "-xb" +strdup(fix3(h_in*N)) + ".out";
ofstream fout(data());
cout << "*** Begin: Write Data ***" << endl;
for(int j = 0; j <= m; j++)
{
x0 = (j * h) - (h*N);
mp_real datamp = mpe2(x0,xi);
mp_real fexaktmp = mpe2exakt(x0);
mp_real Errormp = datamp - fexaktmp;
mp_real Errorrelmp = 100.0 * (abs(Errormp)/abs(fexaktmp));
double data = dble(datamp);
double fexakt = dble(fexaktmp);
double Error = dble(Errormp);
double Errorrel = dble(Errorrelmp);
double xd0 = dble(x0);
(ostream&) fout << xd0 << '\t' << fexakt << '\t' << data << '\t' << Error << '\t' << Errorrel << endl;
}
cout << "*** End : Write Data ***" << endl;
mp_real Regtheo_mp;
mp_real RegSol_mp, RelError_mp;
double xod, RegSol, Regtheo, RelError;
/*
if(Control == 1)
{
cout << " *** Beginn Testrechnung *** " << endl;
x0 = x1;
s = x0;
Regpure_mp = mptrapez(mpkernpurereg,x0,b,s,h,N);
Regpure_mp *= factor;
Regtheo_mp = mpRegexakt(x0,b);
RelNumerror_mp = abs(Regpure_mp - Regtheo_mp)/abs(Regtheo_mp);
RelNumerror_mp *= 100.0;
cout << "x0 = " << x0;
cout << Regpure_mp << Regtheo_mp << RelNumerror_mp;
x0 = mp_real(0.0);
s = x0;
Regpure_mp = mptrapez(mpkernpurereg,x0,b,s,h,N);
Regpure_mp *= factor;
Regtheo_mp = mpRegexakt(x0,b);
RelNumerror_mp = abs(Regpure_mp - Regtheo_mp)/abs(Regtheo_mp);
RelNumerror_mp *= 100.0;
cout << "x0 = " << x0;
cout << Regpure_mp << Regtheo_mp << RelNumerror_mp;
x0 = x2;
s = x0;
Regpure_mp = mptrapez(mpkernpurereg,x0,b,s,h,N);
Regpure_mp *= factor;
Regtheo_mp = mpRegexakt(x0,b);
RelNumerror_mp = abs(Regpure_mp - Regtheo_mp)/abs(Regtheo_mp);
RelNumerror_mp *= 100.0;
cout << "x0 = " << x0;
cout << Regpure_mp << Regtheo_mp << RelNumerror_mp;
cout << " *** End Testrechnung *** " << endl;
}
*/
cout << '\v' ;
cout << " *** Beginn PureRegularisation *** " << endl;
for(int jj=0; jj <=Nb; jj++)
{
b = b1 + jj * bstep;
db = dble(b);
String reg = "RegGaussE2_MP-N" ;
reg = reg + strdup(fix3(N)) + "-xb" + strdup(fix3(x2_in)) + "-b" + strdup(fix3(db)) + ".out";
ofstream out(reg());
/* Vorfaktor */
factor = mp_real(2.0)*b/power(pi,mp_real(1.5));
factor *= exp(mp_real(0.25) * pi2 * b * b);
dfactor = 2.0 * (db/pow(dpi,1.5)) * exp(db*db*dpi*dpi*.25);
cout << " +++ b = " << db << " ; j = " << jj << " +++" << endl;
cout << '\v' ;
for(int j = 0; j <= m; j++)
{
x0 = x1 + j * step;
s = x0;
RegSol_mp = mptrapezxi(mpkern,x0,b,xi,s,h,N);
RegSol_mp *= factor;
Regtheo_mp = mpRegexakt(x0,b);
RelError_mp = abs(RegSol_mp - Regtheo_mp)/abs(Regtheo_mp);
RelError_mp *= 100.0;
/* Konversion mp_real -> double */
xod = dble(x0);
RegSol = dble(RegSol_mp);
Regtheo = dble(Regtheo_mp);
RelError = dble(RelError_mp);
cout << x0 << Regtheo_mp << RegSol_mp << RelError_mp << endl;
(ostream&) out << xod << '\t' << Regtheo << '\t' << RegSol << '\t' << RelError << endl;
}
}
return 0;
}
void
domove(int okay)
{
int i; /* index */
int l = 0; /* last man */
bestmove = -9999999.;
if (okay) {
/* see if comp should double */
if (dflag && gvalue < 64 && dlast != cturn && dblgood()) {
addstr(*Colorptr);
dble(); /* double */
/* return if declined */
if (cturn != 1 && cturn != -1)
return;
}
roll();
}
race = 0;
for (i = 0; i < 26; i++) {
if (board[i] < 0)
l = i;
}
for (i = 0; i < l; i++) {
if (board[i] > 0)
break;
}
if (i == l)
race = 1;
/* print roll */
move(cturn == -1 ? 18 : 19, 0);
printw("%s rolls %d %d", *Colorptr, D0, D1);
clrtoeol();
/* find out how many moves */
mvlim = movallow();
if (mvlim == 0) {
addstr(" but cannot use it.\n");
nexturn();
return;
}
/* initialize */
for (i = 0; i < 4; i++)
cp[i] = cg[i] = 0;
/* strategize */
trymove(0, 0);
pickmove();
/* print move */
addstr(" and moves ");
for (i = 0; i < mvlim; i++) {
if (i > 0)
addch(',');
printw("%d-%d", p[i] = cp[i], g[i] = cg[i]);
makmove(i);
}
addch('.');
/* print blots hit */
move(20, 0);
for (i = 0; i < mvlim; i++)
if (h[i])
wrhit(g[i]);
/* get ready for next move */
nexturn();
if (!okay) {
refresh();
sleep(3);
}
}
void apply_hdaf_reg(
int m,
double sigma,
int diff_order,
double h,
double eps_min,
double eps_max,
double * in,
double * & out,
int length,
int in_stride,
int out_stride)
{
//if (out == 0) out = ml_alloc<double> (length*out_stride);
static vector<int > m_list;
static vector<double > sigma_list;
static vector<int > diff_order_list;
static vector<int > length_list;
static vector<double > h_list;
static vector<complex<double> * > kernel_fft_list;
// not dealing with eps_range for now, fix later !!
static int I = 0;
bool found = 0;
// look for existing parameter combination
if (I)
if (m_list[I] == m && sigma_list[I] == sigma && diff_order_list[I] == diff_order && length_list[I] == length && h_list[I] == h )
found = true;
if (!found)
for ( I = 0; I<m_list.size(); I++)
if ( m_list[I] == m && sigma_list[I] == sigma && diff_order_list[I] == diff_order && length_list[I] == length && h_list[I] == h )
{
found = true;
break;
}
if (!found)
{
// new parameter combination
I = m_list.size();
m_list.push_back( m );
sigma_list.push_back( sigma );
diff_order_list.push_back( diff_order );
length_list.push_back( length );
h_list.push_back( h );
complex<double > *kernel_fft = 0;
double * kernel = ml_alloc<double > (length);
for (int k=0; k<length; k++)
kernel[k] = 0.0;
double x_max = hdaf_truncate_point (eps_min, eps_max, m, sigma, diff_order );
int k_max = (int)ceil(x_max/h);
if ( k_max >= length )
{
std::cout << "error: bad combination of hdaf parameters; truncate point exceeds data length in apply_hdaf_reg:\n";
std::cout << "(eps1,eps2) = (" << eps_min << ", " << eps_max << "),\tm= " << m << ",\tsigma:" << sigma << ",\tdiff_order: " << diff_order << ",\tdata_length: " << length << ",\tx_max: " << x_max << ",\tk_max: " << k_max << std::endl;
std_exit();
}
mp::mp_init(30);
ml_poly<mp_real > P;
make_hdaf_ml_poly( P, m );
differentiate_hdaf_poly( P, diff_order );
static mp_real sqrt2 = pow((mp_real)2.0,0.5);
mp_real p = (pow(sqrt2*sigma,-diff_order)/(sqrt2*sigma))*h;
for (int k=0; k<=k_max; k++)
{
mp_real r = (((mp_real)k)*h)/(sqrt2*sigma);
kernel[k] = dble(exp(-r*r)*P(r)*p);
}
for (int k=1; k<=k_max; k++)
{
mp_real r = -(((mp_real)k)*h)/(sqrt2*sigma);
kernel[length-k] = dble(exp(-r*r)*P(r)*p);
}
FFT(kernel,kernel_fft, length, 1,1 );
kernel_fft_list.push_back(kernel_fft);
ml_free( kernel );
}
// run
complex<double> * q=0;
complex<double> * ker_fft = kernel_fft_list[I];
FFT(in, q, length, in_stride,1);
for (int k=0; k<div_up(length,2); k++)
q[k] *= ker_fft[k]/((double)length);
IFFT(q,out,length,1,out_stride);
}
/* zero if first move */
void
move(struct move *mm, int okay)
{
int i; /* index */
int l; /* last man */
l = 0;
if (okay) {
/* see if comp should double */
if (gvalue < 64 && dlast != cturn && dblgood()) {
writel(*Colorptr);
dble(); /* double */
/* return if declined */
if (cturn != 1 && cturn != -1)
return;
}
roll(mm);
}
race = 0;
for (i = 0; i < 26; i++) {
if (board[i] < 0)
l = i;
}
for (i = 0; i < l; i++) {
if (board[i] > 0)
break;
}
if (i == l)
race = 1;
/* print roll */
if (tflag)
curmove(cturn == -1 ? 18 : 19, 0);
writel(*Colorptr);
writel(" rolls ");
writec(mm->D0 + '0');
writec(' ');
writec(mm->D1 + '0');
/* make tty interruptable while thinking */
if (tflag)
cline();
fixtty(&noech);
/* find out how many moves */
mm->mvlim = movallow(mm);
if (mm->mvlim == 0) {
writel(" but cannot use it.\n");
nexturn();
fixtty(&raw);
return;
}
/* initialize */
for (i = 0; i < 4; i++)
cp[i] = cg[i] = 0;
/* strategize */
trymove(mm, 0, 0);
pickmove(mm);
/* print move */
writel(" and moves ");
for (i = 0; i < mm->mvlim; i++) {
if (i > 0)
writec(',');
wrint(mm->p[i] = cp[i]);
writec('-');
wrint(mm->g[i] = cg[i]);
makmove(mm, i);
/*
* This assertion persuades gcc 4.5 that the loop
* doesn't result in signed overflow of i. mvlim
* isn't, or at least shouldn't be, changed by makmove
* at all.
*/
assert(mm->mvlim >= 0 && mm->mvlim <= 5);
}
writec('.');
/* print blots hit */
if (tflag)
curmove(20, 0);
else
writec('\n');
for (i = 0; i < mm->mvlim; i++)
if (mm->h[i])
wrhit(mm->g[i]);
/* get ready for next move */
nexturn();
if (!okay) {
buflush();
sleep(3);
}
fixtty(&raw); /* no more tty interrupt */
}
int main()
{
cout << setiosflags(ios::uppercase);
/*
ofstream out("GAUSS.out");
out << setiosflags(ios::uppercase);
ofstream dout("GAUSSMOD.out");
dout << setiosflags(ios::uppercase);
*/
mp_init();
cout << "+++ Precision = " << mpipl << " +++" << endl;
double s_in, h_in , b1_in, b2_in, db, g_in, dpi, x1_in, x2_in;
int N, Nb, m, Control;
dpi = 4.0 * atan(1.0);
mp_real pi = mppic; // pi aus der Bibliothek !!!
mp_real pi2 = pi * pi;
static mp_real factor;
mp_real b, b1, b2, bstep, g, x0, s, h, x1, x2;
/* Parameter als doubles einlesen */
cin >> b1_in >> b2_in >> Nb;
cin >> g_in >> Control;
cin >> s_in >> h_in >> N;
cin >> x1_in >> x2_in >> m;
/* Konversion: double -> mp_real */
b1 = mp_real(b1_in);
b2 = mp_real(b2_in);
g = mp_real(g_in);
s = mp_real(s_in);
h = mp_real(h_in);
x1 = mp_real(x1_in);
x2 = mp_real(x2_in);
// a = 1/(mp_real(2.0)*b1);
bstep = (b2 - b1)/mp_real(Nb);
/* Vorfaktor */
// factor = mp_real(2.0)*b/power(pi,mp_real(1.5));
// factor *= exp(mp_real(0.25) * pi2 * b * b);
//dfactor = 2.0 * (b_in/pow(dpi,1.5)) * exp(b_in*b_in*dpi*dpi*.25);
cout << "*** Parameter ***" << endl;
cout << "b1 = " << b1 ;
cout << "b2 = " << b2 ;
cout << "bstep = " << bstep ;
//cout << "a = " << a;
cout << "g = " << g;
cout << "h = " << h;
cout << "N = " << N << endl;
cout << '\v' ;
cout << "x1 = " << x1;
cout << "x2 = " << x2;
cout << "m = " << m << endl;
cout << "xmax = " << h * N << endl;
// cout << "dfaktor = " <<dfactor << endl;
// cout << "Faktor = " <<factor << endl;
/* Datendatei */
String data = "GAUSSMOD-N" ;
data = data + N + "-xb" + x2_in + "-beta" + strdup(fix3(g_in)) + ".out";
ofstream dout(data());
mp_real mp_E2_Gauss, mp_E2_Gausstheo, mp_Reg, mp_Regtheo, mp_ModGauss, step;
mp_real mp_diffrel, mp_diffrelreg;
double E2, E2_Gauss, E2_Gausstheo, Reg, Reg_theod, ModGauss, diffrel, x0d;
double diffrelreg;
step = (x2 -x1)/mp_real(m);
if(Control == 1)
{
cout << "*** Begin: Read Data ***" << endl;
for(int j = 0; j <= m; j++)
{
x0 = x1 + j * step;
mp_E2_Gauss = mpe2gauss(x0,g);
mp_E2_Gausstheo = mpe2gausstheo(x0,g);
mp_real mpdeltarel = abs(mp_E2_Gauss - mp_E2_Gausstheo)/abs(mp_E2_Gausstheo);
mpdeltarel *= mp_real(100.0);
x0d = dble(x0);
E2 = e2(x0d);
E2_Gauss = dble(mp_E2_Gauss);
E2_Gausstheo = dble(mp_E2_Gausstheo);
double deltarel = dble(mpdeltarel);
cout << x0 << mp_E2_Gausstheo << mp_E2_Gauss << mpdeltarel << endl;;
(ostream&) dout << x0d << '\t' << E2 << '\t' << E2_Gausstheo <<'\t' << E2_Gauss << '\t' << deltarel << endl;
}
cout << "*** End: Read Data ***" << endl;
}
cout << "*** Begin: Regularisation Scan ***" << endl;
for(int i = 0; i <= Nb; i++)
{
b = b1 + i * bstep;
db = dble(b);
factor = mp_real(2.0)*b/power(pi,mp_real(1.5));
factor *= exp(mp_real(0.25) * pi2 * b * b);
/* RegDatei */
String reg = "GAUSSREG-N" ;
reg = reg + N + "-xb" + x2_in + "-beta" + strdup(fix3(g_in)) + "-b" + strdup(fix3(db)) + ".out";
ofstream out(reg());
cout << " +++ i = " << i << ", " << " b = " << db << " +++ " << endl;
cout << '\v' ;
for(int jj = 0; jj <= m; jj++)
{
x0 = x1 + jj * step;
s = x0;
mp_Reg = mptrapez(mpkern,x0,b,g,s,h,N);
mp_Reg *= factor;
mp_Regtheo = Regtheo(x0,b,g); //reine Regularisierte
mp_ModGauss = GaussDichte(x0,g); //Gaussdichte als Modell
mp_diffrel = abs(mp_Reg - mp_Regtheo)/abs(mp_Regtheo);
mp_diffrel *= mp_real(100.0);
mp_diffrelreg = abs(mp_Reg - mp_ModGauss)/abs(mp_ModGauss);
mp_diffrelreg *= mp_real(100.0);
Reg_theod = dble(mp_Regtheo);
Reg = dble(mp_Reg);
ModGauss = dble(mp_ModGauss);
diffrel = dble(mp_diffrel);
diffrelreg = dble(mp_diffrelreg);
x0d = dble(x0);
cout << x0 << mp_Reg << mp_Regtheo << mp_ModGauss << mp_diffrel << mp_diffrelreg<< endl;
(ostream&) out << x0d << '\t' << ModGauss << '\t' << Reg << '\t' << Reg_theod<< '\t' << diffrel <<'\t' << diffrelreg << endl;
}
}
cout << "*** End: Regularisation Scan ***" << endl;
return 0;
}
