void print_spectrum(int L, int M, int N, int precision, rsn_spectrum spectrum, const char* file) {
int z,y,x,i,l,padding = 0;
double max,min;
max = min = spectrum[0];
for(i = 0; i < L*M*N; i++) {
if((l = log10f(spectrum[i])) > padding) padding = l;
if(spectrum[i] < min) min = spectrum[i];
else if(spectrum[i] > max) max = spectrum[i];
}
printf("Minimum frequency: %f\nMaximum frequency: %f\n",(double)min,(double)max);
padding += precision + 2;
char p[padding+1];
FILE* f = fopen(file,"w");
for(z = 0; z < L; z++) {
fprintf(f,"Plane %d\n",z);
for(y = 0; y < M; y++) {
for(x = 0; x < N; x++) {
#if RSN_PRECISION == QUAD
quadmath_snprintf(p,padding+1,"%*.*"RSN_PRECISION_FORMAT,padding,precision,spectrum[z*M*N+y*N+x]);
#else
snprintf(p,padding+1,"%*.*"RSN_PRECISION_FORMAT,padding,precision,spectrum[z*M*N+y*N+x]);
#endif
fputs(p,f);
}
fputc('\n',f);
}
fputc('\n',f);
}
fclose(f);
}
ostream& operator<<( ostream& os, const Quad& alpha )
{
char str[128];
quadmath_snprintf( str, 128, "%Qe", alpha );
os << str;
return os;
}
// Imprimir coeficientes
void TDMA::printCoefficients(void)
{
std::cout<<std::endl<<std::endl;
std::cout<<std::endl<<std::setfill('-')<<std::setw(5+4*OUT_FLOAT_WIDTH)<<""<<std::setfill(' ');
std::cout<<std::endl<<std::setw(5)<<std::right<<"p";
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<std::right<<"ap";
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<std::right<<"aw";
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<std::right<<"ae";
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<std::right<<"bp";
std::cout<<std::endl<<std::setfill('-')<<std::setw(5+4*OUT_FLOAT_WIDTH)<<""<<std::setfill(' ');
std::cout.precision(OUT_FLOAT_PRECISION);
std::cout<<std::scientific;
#ifdef QUAD_PRECISION
char str[1000];
for(tInteger i=0;i<neq;i++){
std::cout<<std::endl;
std::cout<<std::setw(5)<<i;
quadmath_snprintf(str, 1000, Q_FORMAT,equation[i][0]);
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<str;
quadmath_snprintf(str, 1000, Q_FORMAT,equation[i][1]);
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<str;
quadmath_snprintf(str, 1000, Q_FORMAT,equation[i][2]);
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<str;
quadmath_snprintf(str, 1000, Q_FORMAT,equation[i][3]);
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<str;
}
std::cout<<std::endl<<std::setfill('-')<<std::setw(5+4*OUT_FLOAT_WIDTH)<<""<<std::setfill(' ');
#else
for(tInteger i=0;i<neq;i++){
std::cout<<std::endl;
std::cout<<std::setw(5)<<i;
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<equation[i][0];
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<equation[i][1];
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<equation[i][2];
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<equation[i][3];
}
std::cout<<std::endl<<std::setfill('-')<<std::setw(5+4*OUT_FLOAT_WIDTH)<<""<<std::setfill(' ');
#endif
}
std::string str(std::streamsize digits, std::ios_base::fmtflags f)const
{
#ifndef BOOST_MP_USE_QUAD
char buf[100];
boost::scoped_array<char> buf2;
std::string format = "%";
if(f & std::ios_base::showpos)
format += "+";
if(f & std::ios_base::showpoint)
format += "#";
format += ".*";
if(digits == 0)
digits = 36;
format += "Q";
if(f & std::ios_base::scientific)
format += "e";
else if(f & std::ios_base::fixed)
format += "f";
else
format += "g";
int v = quadmath_snprintf (buf, 100, format.c_str(), digits, m_value);
if((v < 0) || (v >= 99))
{
int v_max = v;
buf2.reset(new char[v+3]);
v = quadmath_snprintf (&buf2[0], v_max + 3, format.c_str(), digits, m_value);
if(v >= v_max + 3)
{
BOOST_THROW_EXCEPTION(std::runtime_error("Formatting of float128_type failed."));
}
return &buf2[0];
}
return buf;
#else
return boost::multiprecision::detail::convert_to_string(*this, digits ? digits : 37, f);
#endif
}
static PyObject *
pyquad_repr(PyObject *self)
{
char str[128];
int st;
qdouble q = PyQuad_AsQuad(self);
st = quadmath_snprintf(str, sizeof(str), "%#.*Qf", FLT128_DIG, q);
if (st < 0) {
fprintf(stderr, "BAD\n");
}
return PyString_FromString(str);
}
// Imprime solução na tela
void TDMA::printSolution(void)
{
std::cout<<std::endl;
std::cout<<std::endl<<std::setfill('-')<<std::setw(5+3*OUT_FLOAT_WIDTH)<<""<<std::setfill(' ');
std::cout<<std::endl<<std::setw(5)<<std::right<<"p";
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<std::right<<"Pp";
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<std::right<<"Qp";
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<std::right<<"Tp";
std::cout<<std::endl<<std::setfill('-')<<std::setw(5+3*OUT_FLOAT_WIDTH)<<""<<std::setfill(' ');
std::cout.precision(OUT_FLOAT_PRECISION);
std::cout<<std::scientific;
#ifdef QUAD_PRECISION
char str[1000];
for(tInteger i=0;i<neq;i++){
std::cout<<std::endl;
std::cout<<std::setw(5)<<i;
quadmath_snprintf(str, 1000, Q_FORMAT,P[i]);
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<str;
quadmath_snprintf(str, 1000, Q_FORMAT,Q[i]);
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<str;
quadmath_snprintf(str, 1000, Q_FORMAT,T[i]);
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<str;
}
std::cout<<std::endl<<std::setfill('-')<<std::setw(5+3*OUT_FLOAT_WIDTH)<<""<<std::setfill(' ');
#else
for(tInteger i=0;i<neq;i++){
std::cout<<std::endl;
std::cout<<std::setw(5)<<i;
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<P[i];
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<Q[i];
std::cout<<std::setw(OUT_FLOAT_WIDTH)<<T[i];
}
std::cout<<std::endl<<std::setfill('-')<<std::setw(5+3*OUT_FLOAT_WIDTH)<<""<<std::setfill(' ');
#endif
}
/* print out a longdouble to a std::string */
std::string print_longdouble(const longdouble &ld)
{
char buf[1024];
#ifdef LONGDOUBLE_IS_FLOAT128
quadmath_snprintf(buf,1024, "%Qg", ld);
#endif
#ifdef LONGDOUBLE_IS_IEEE754
ld_sprintf(buf, "%Lg", ld);
#endif
#ifdef LONGDOUBLE_IS_DDREAL
ld.write(buf);
#endif
return std::string(buf);
}
std::string print2(tFloat value)
{
char str[1000];
quadmath_snprintf(str, 1000, "%.3Qe",value);
return std::string(str);
}
std::string print(tFloat value)
{
char str[1000];
quadmath_snprintf(str, 1000, Q_FORMAT,value);
return std::string(str);
}
int main()
{
/*------ declarations --------------------------------------------------*/
int i;
gauss_method gsmethod,gsmethod2;
solution u,u2;
toptions options,options2;
parameters params;
ode_sys system;
solver_stat thestat,thestat2;
clock_t clock0, clock1;
time_t wtime0,wtime1;
params.rpar =(val_type *)malloc(MAXPARAM*sizeof(val_type));
params.ipar =(int *)malloc(MAXPARAM*sizeof(int));
u.uu = (val_type *)malloc(MAXNEQ*sizeof(val_type));
u.ee = (val_type *)malloc(MAXNEQ*sizeof(val_type));
u2.uu = (val_type *)malloc(MAXNEQ*sizeof(val_type));
u2.ee = (val_type *)malloc(MAXNEQ*sizeof(val_type));
options.rtol=malloc(MAXNEQ*sizeof(val_type));
options.atol=malloc(MAXNEQ*sizeof(val_type));
# if PREC ==2 //QUADRUPLEPRECISION
int n;
int width = 46;
char buf[128];
# endif
/* ----------- implementation ---------------------------------------*/
/* ----------- integration parameters---------------------------------*/
gsmethod.ns = 6; // Stages.
options.h = POW(2,-7); // Stepsize.
options.sampling=1; //
system.f = Ode1; // Odefun (GaussUserProblem.c: OdePendulum,OdeNBody)
system.ham= Ham1; // Hamiltonian (GaussUserProblem.c: HamPendulum,HamNBody)
system.problem =1; // Initial values (GaussInitData.c).
options.approximation=1; // Approximation: Y^[0] (GaussCommon.c/Yi_init()).
strncpy(thestat.filename, "AllSolve1.bin",STRMAX); // Output filename.
options.algorithm=1; // 1=Jacobi; 11=Seidel;
options.rdigits=0;
options2.rdigits=3;
/* ----------- execution ------------------------------------------*/
printf("Begin execution \n");
printf("method=%i, problem=%i, algorithm=%i\n",gsmethod.ns,system.problem,options.algorithm);
printf("approximation=%i,sampling=%i\n",options.approximation,options.sampling);
#if PREC ==2 //QUADRUPLEPRECISION
printf("options.h=");
n = quadmath_snprintf(buf, sizeof buf, "%+-#*.30Qe", width, options.h);
if ((size_t) n < sizeof buf) printf("%s\n",buf);
#else //DOUBLEPRECISION
printf("options.h=%lg\n", options.h);
#endif
printf("----------------\n");
InitialData (&options,&u,¶ms,&system);
system.params.rpar=¶ms.rpar[0];
system.params.ipar=¶ms.ipar[0];
for (i=0; i<system.neq; i++)
{
options.rtol[i]=RTOL;
options.atol[i]=ATOL;
}
if (options.rdigits>0) options.mrdigits=pow(2,options.rdigits);
if (options2.rdigits>0) options2.mrdigits=pow(2,options2.rdigits);
GaussCoefficients(&gsmethod,&options);
InitStat(&system,&gsmethod,&thestat);
print_u(system.neq, u.uu);
wtime0= time(NULL);
clock0= clock();
select_gauss(&gsmethod, &gsmethod2, &u, &u2,&system,
&options, &options2, &thestat, &thestat2);
clock1=clock();
wtime1= time(NULL);
printf("End execution \n");
if (thestat.convergence==SUCCESS)
{
printf("Execution Correct\n");
printf("convergence=%i. (=0 correct;=-1 incorrect)\n",thestat.convergence);
print_u (system.neq,u.uu);
#if PREC ==2 //QUADRUPLEPRECISION
printf("Max-DE");
n = quadmath_snprintf(buf, sizeof buf, "%+-#*.30Qe", width, thestat.MaxDE);
if ((size_t) n < sizeof buf) printf("%s\n",buf);
#else // DOUBLEPRECISION
printf("Energy MaxDE=%.20lg\n",thestat.MaxDE);
#endif
printf ("\nCPU time:%lg\n", (double) (clock1 - clock0)/CLOCKS_PER_SEC);
printf ("Elapsed wall clock time: %ld\n", (wtime1 - wtime0));
printf ("Elapsed wall clock time: %lg\n", difftime(wtime1, wtime0));
printf("\n");
printf("stepcount=%i\n",thestat.stepcount);
printf("nout=%i\n",thestat.nout);
printf("fixed-point iterations=%i\n",thestat.totitcount);
printf("max fixed-point iterations=%i\n",thestat.maxitcount);
printf("deltaZero iterations=%i\n",thestat.itzero);
printf("\n");
printf ("function ebaluations\n");
printf("fcn=%i\n",thestat.fcn);
printf ("\n");
}
else
{
printf("Execution InCorrect\n");
printf("convergence=%i. (=0 correct;=-1 incorrect)\n",thestat.convergence);
}
free(params.rpar); free(params.ipar);
free(u.uu); free(u.ee);
free(u2.uu); free(u2.ee);
exit(0);
}
int ld_vsprintf(char *buf, const char *__format, va_list args){
char fmt[BUFSIZE];
char qfmt[BUFSIZE];
va_list oargs;
const char *c;
const char *e;
char* o=buf;
c=__format;
do {
if (*c!='%'){
*o=*c;
++o;
continue;
}
e=c+1;
do {
if (*e=='%'){
*o='%';
++o;
++c;
break;
}
if (*e=='L' && (*(e+1)=='f' || *(e+1)=='g' || *(e+1) == 'e')){
longdouble ld = va_arg(args,longdouble);
size_t n=e-c;
++e;
memcpy(qfmt,c,n);
qfmt[n]='Q';
qfmt[n+1]=*e;
qfmt[n+2]='\0';
quadmath_snprintf(o,BUFSIZE-(o-buf),qfmt, ld);
while(*(++o)!='\0'){
continue;
}
c+=n+1;
break;
}
if ( *e=='u' || *e=='d' || *e=='x' || *e=='X' || *e=='o' || *e=='i' || *e=='c'){
size_t n=e-c;
memcpy(qfmt,c,n+1);
qfmt[n+1]='\0';
if(*(e-1)=='l' && *(e-2)=='l'){
long long int str = va_arg(args,long long int);
sprintf(o,qfmt,str);
} else {
int str = va_arg(args,int);
sprintf(o,qfmt,str);
}
--c;
while(*(++o)!='\0'){
continue;
}
c+=n+1;
break;
}
if ( *e=='f' || *e=='g' || *e=='e') {
size_t n=e-c;
memcpy(qfmt,c,n+1);
qfmt[n+1]='\0';
double str = va_arg(args,double);
sprintf(o,qfmt,str);
--c;
while(*(++o)!='\0'){
continue;
}
c+=n+1;
break;
}
template<> std::string toString<float128>(const float128& f) {
char buf[128];
quadmath_snprintf(buf,sizeof(buf),"%." stringize(FLT128_DIG) "Qf",f);
return (const char*)buf;
}
