mp_real Regtheo(mp_real x_, mp_real a_)
{
mp_real Sqrtpi = sqrt(mppic);
mp_real a2 = a_ * a_ + mp_real(0.25); // a^2 + g^2
mp_real a = mp_real(2.0) * sqrt(a2);
mp_real b_ = 1/a;
mp_real y_ = b_/Sqrtpi * exp(- b_ * b_ * x_ * x_);
return y_ ;
}
mp_real mpe2gausstheo(mp_real x0_)
{
static mp_real SQRTpi = sqrt(mppic) ;
double gd = 1.0; /* gd = 1/2 gamma !!!; hier gamma = 0.5 */
double x0d = dble(x0_);
mp_real g = mp_real(gd);
mp_real fac = g/SQRTpi;
double h = 1E-03;
int n = 10000;
double yd_ = trapez(kerngauss,x0d,gd,x0d,h,n);
mp_real y_ = fac * mp_real(yd_);
return y_;
}
mp_real mpe2gauss(mp_real x0_)
{
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*/
mp_real g = mp_real(gd);
mp_real fac = g/SQRTpi;
double h = 1E-03;
int n = 10000;
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_;
}
mp_real mpe2(mp_real x_)
{
mp_real p;
mp_real q;
p = exp(- x_) ;
q = mp_real(1.0) + exp(- 2.0 * x_);
mp_real y_ = p/q;
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;
}
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()
{
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;
}
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 calculator::run()
{
abort = false;
if( (mprec == 0) | (mpar == 0) )
return;
qDebug() << "Parameter" << mpar << "Precision" << mprec << "Mode" << mmode;
mp::mp_init(mprec+2);
mp::mpsetprec(mprec);
mp::mpsetoutputprec(mprec);
time.start();
switch( mmode ) {
case montecarlo : {
mpar = pow(10, mpar);
quint64 walk = mpar/1000;
quint64 hits = 0;
double x,y;
if( walk == 0 ) walk = 1;
for(quint64 current=1;current<=mpar;current++) {
x=genrand_real3();
y=genrand_real3();
if( x*x+y*y <= 1 )
hits++;
if( current % walk == 0 )
emit update(1000*current/mpar);
if( abort )
break;
}
mp_real pi = mp_real(hits)/mp_real(mpar)*4;
mresult = QString::fromStdString(pi.to_string());
break;
}
case montemin1 : {
mpar = pow(10, mpar)-1;
quint64 walk = mpar/1000;
quint64 hits = 0;
double x,y;
if( walk == 0 ) walk = 1;
for(quint64 current=1;current<=mpar;current++) {
x=genrand_real3();
y=genrand_real3();
if( x*x+y*y <= 1 )
hits++;
if( current % walk == 0 )
emit update(1000*current/mpar);
if( abort )
break;
}
mp_real pi = mp_real(hits)/mp_real(mpar)*4;
mresult = QString::fromStdString(pi.to_string());
break;
}
case subdivide : {
mp_real x, a;
mpar = pow(10, mpar);
quint64 walk = mpar/1000;
quint64 current = 0;
a=0;
mp_real real_par(mpar);
x=1/(real_par*0.5);
while( x < 1 ) {
current++;
a+=1*sqrt(1-(x*x))/real_par;
x+=(1/real_par);
if( current % walk == 0)
emit update(current/walk);
if( abort )
break;
}
mp_real pi = a*4;
mresult = QString::fromStdString(pi.to_string());
break;
}
case grid : {
quint64 res = pow(10, mpar);
quint32 walk = res/1000+1;
quint64 hits = 0;
quint64 x = 0, y = res;
while( y > 0 )
{
while( x*x+y*y <= res )
x++;
hits += x;
if( y % walk == 0 ) emit update((res-y)/(walk+1));
y--;
if( abort )
break;
}
mp_real pi = mp_real(hits)/mp_real(res)*4;
mresult = QString::fromStdString(pi.to_string());
break;
}
case bbp : {
mp_real pi;
for(quint32 step=0;step<=mpar;step++) {
pi += ((mp_real(4)/mp_real(8*step+1))-(mp_real(2)/mp_real(8*step+4))-(mp_real(1)/mp_real(8*step+5))-(mp_real(1)/mp_real(8*step+6)))/(pow(mp_real(16),(int)step));
emit update(1000*step/mpar);
if( abort )
break;
}
mresult = QString::fromStdString(pi.to_string());
break;
}
case chudnovsky : {
mp_real temp;
for(quint32 step=0;step<=mpar;step++) {
mp_real upper = fak(6*step)*(13591409+545140134*mp_real(step))*pow(-1,step);
mp_real lower = pow(640320,mp_real(3*step)+1.5)*(fak(3*step)*pow(fak(step),3)+0.0);
temp += upper/lower;
emit update(1000*step/mpar);
if( abort )
break;
}
mp_real pi = mp_real(1)/(temp*12);
mresult = QString::fromStdString(pi.to_string());
break;
}
case polygon : {
mp_real pi_min = mp_real(mpar)/2*sin(2*mp_real::_pi/mp_real(mpar));
mp_real pi_max = mp_real(mpar)*tan(mp_real::_pi/mp_real(mpar));
mp_real pi_mid = (pi_min+pi_max)/2;
mresult = QString::fromStdString(pi_min.to_string())+" < Pi < "+QString::fromStdString(pi_max.to_string()) +"\nPi = "+QString::fromStdString(pi_mid.to_string());
break;
}
}
duration = time.elapsed();
mp::mp_finalize();
}
int main(int argc, char **argv)
{
unsigned digits;
double start, end;
extern char *optarg;
extern int optind;
int arg;
WhichAlg alg = AlgSeries;
const char *method = "Series";
bool needConsts = false;
if (argc < 2) {
usage(argv);
}
while ((arg = getopt(argc, argv, "lrh")) != -1) {
switch (arg) {
case 'l':
alg = AlgLimit;
method = "Limit";
needConsts = 1; // need to precalculate pi, etc.
break;
case 'r':
alg = AlgNewton;
method = "Newton-Raphson";
needConsts = 1; // need to precalculate pi, etc.
break;
default:
usage(argv);
}
}
if (optind != (argc - 1)) {
usage(argv);
}
digits = atoi(argv[optind]);
if (digits == 0) {
usage(argv);
}
printf("Calculating e to %d digits using %s...", digits, method);
fflush(stdout);
start = currentTime();
// Note the series algorithm does not need consts like pi precalculated
mp::mp_init(digits + 2, needConsts);
mp::mpsetoutputprec(digits);
mp_real e;
mp_real eps = pow(mp_real(10.0), -((int)digits));
switch(alg) {
case AlgLimit:
eViaLimit(eps, e);
break;
case AlgSeries:
eViaSeries(eps, e);
break;
case AlgNewton:
eViaNewtonRaphson(eps, e);
break;
}
end = currentTime();
std::cout << "\ne = " << e << "\n";
std::cout << "Algorithm : " << method << "\n";
std::cout << "total elapsed time : " << (end - start) << " seconds\n";
return 0;
}
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;
}
