bool num_limits(void)
{ bool ok = true;
ok &= check_epsilon();
ok &= check_min();
ok &= check_max();
ok &= check_nan();
return ok;
}
void
Main_GUI::set_defaults()
{
min_box->setValue(hinting_range_min);
max_box->setValue(hinting_range_max);
fallback_box->setCurrentIndex(latin_fallback);
limit_box->setValue(hinting_limit ? hinting_limit : hinting_range_max);
// handle command line option `--hinting-limit=0'
if (!hinting_limit)
{
hinting_limit = max_box->value();
no_limit_box->setChecked(true);
}
increase_box->setValue(increase_x_height ? increase_x_height
: TA_INCREASE_X_HEIGHT);
// handle command line option `--increase-x-height=0'
if (!increase_x_height)
{
increase_x_height = TA_INCREASE_X_HEIGHT;
no_increase_box->setChecked(true);
}
snapping_line->setText(x_height_snapping_exceptions_string);
if (windows_compatibility)
wincomp_box->setChecked(true);
if (pre_hinting)
pre_box->setChecked(true);
if (hint_with_components)
hint_box->setChecked(true);
if (symbol)
symbol_box->setChecked(true);
if (!no_info)
info_box->setChecked(true);
if (gray_strong_stem_width)
gray_box->setChecked(true);
if (gdi_cleartype_strong_stem_width)
gdi_box->setChecked(true);
if (dw_cleartype_strong_stem_width)
dw_box->setChecked(true);
run_button->setEnabled(false);
check_min();
check_max();
check_limit();
check_no_limit();
check_no_increase();
check_number_set();
}
int
main (int argc, char *argv[])
{
tests_start_mpfr ();
check_nans ();
check_exact ();
check_float ();
check53("6.9314718055994530941514e-1", "0.0", MPFR_RNDZ, "0.0");
check53("0.0", "6.9314718055994530941514e-1", MPFR_RNDZ, "0.0");
check_sign();
check53("-4.165000000e4", "-0.00004801920768307322868063274915", MPFR_RNDN,
"2.0");
check53("2.71331408349172961467e-08", "-6.72658901114033715233e-165",
MPFR_RNDZ, "-1.8251348697787782844e-172");
check53("2.71331408349172961467e-08", "-6.72658901114033715233e-165",
MPFR_RNDA, "-1.8251348697787786e-172");
check53("0.31869277231188065", "0.88642843322303122", MPFR_RNDZ,
"2.8249833483992453642e-1");
check("8.47622108205396074254e-01", "3.24039313247872939883e-01", MPFR_RNDU,
28, 45, 2, "0.375");
check("8.47622108205396074254e-01", "3.24039313247872939883e-01", MPFR_RNDA,
28, 45, 2, "0.375");
check("2.63978122803639081440e-01", "6.8378615379333496093e-1", MPFR_RNDN,
34, 23, 31, "0.180504585267044603");
check("1.0", "0.11835170935876249132", MPFR_RNDU, 6, 41, 36,
"0.1183517093595583");
check53("67108865.0", "134217729.0", MPFR_RNDN, "9.007199456067584e15");
check("1.37399642157394197284e-01", "2.28877275604219221350e-01", MPFR_RNDN,
49, 15, 32, "0.0314472340833162888");
check("4.03160720978664954828e-01", "5.854828e-1"
/*"5.85483042917246621073e-01"*/, MPFR_RNDZ,
51, 22, 32, "0.2360436821472831");
check("3.90798504668055102229e-14", "9.85394674650308388664e-04", MPFR_RNDN,
46, 22, 12, "0.385027296503914762e-16");
check("4.58687081072827851358e-01", "2.20543551472118792844e-01", MPFR_RNDN,
49, 3, 2, "0.09375");
check_max();
check_min();
check_regression ();
test_generic (2, 500, 100);
data_check ("data/mulpi", mpfr_mulpi, "mpfr_mulpi");
valgrind20110503 ();
tests_end_mpfr ();
return 0;
}
int
main (void)
{
tests_start_mpfr ();
mpfr_test_init ();
#ifndef MPFR_DOUBLE_SPEC
printf ("Warning! The MPFR_DOUBLE_SPEC macro is not defined. This means\n"
"that you do not have a conforming C implementation and problems\n"
"may occur with conversions between MPFR numbers and standard\n"
"floating-point types. Please contact the MPFR team.\n");
#elif MPFR_DOUBLE_SPEC == 0
/*
printf ("The type 'double' of your C implementation does not seem to\n"
"correspond to the IEEE-754 double precision. Though code has\n"
"been written to support such implementations, tests have been\n"
"done only on IEEE-754 double-precision implementations and\n"
"conversions between MPFR numbers and standard floating-point\n"
"types may be inaccurate. You may wish to contact the MPFR team\n"
"for further testing.\n");
*/
printf ("The type 'double' of your C implementation does not seem to\n"
"correspond to the IEEE-754 double precision. Such particular\n"
"implementations are not supported yet, and conversions between\n"
"MPFR numbers and standard floating-point types may be very\n"
"inaccurate.\n");
printf ("FLT_RADIX = %ld\n", (long) FLT_RADIX);
printf ("DBL_MANT_DIG = %ld\n", (long) DBL_MANT_DIG);
printf ("DBL_MIN_EXP = %ld\n", (long) DBL_MIN_EXP);
printf ("DBL_MAX_EXP = %ld\n", (long) DBL_MAX_EXP);
#endif
if (check_denorms ())
exit (1);
check_inf_nan ();
check_min();
check_max();
check_get_d_2exp_inf_nan ();
tests_end_mpfr ();
return 0;
}
/******************************************************************************
Trace the scalar variables located in cell center
******************************************************************************/
int trace_scalar(PARA_DATA *para, REAL **var, int var_type, REAL *d, REAL *d0,
int **BINDEX)
{
int i, j, k;
int it;
int itmax = 20000; // Max number of iterations for backward tracing
int imax = para->geom->imax, jmax = para->geom->jmax;
int kmax = para->geom->kmax;
int IMAX = imax+2, IJMAX = (imax+2)*(jmax+2);
REAL x_1, y_1, z_1;
REAL dt = para->mytime->dt;
REAL u0, v0, w0;
REAL *x = var[X], *y = var[Y], *z = var[Z];
REAL *gx = var[GX], *gy = var[GY], *gz = var[GZ];
REAL *u = var[VX], *v = var[VY], *w = var[VZ];
REAL *flagp = var[FLAGP];
REAL Lx = para->geom->Lx, Ly = para->geom->Ly, Lz = para->geom->Lz;
int COOD[3], LOC[3];
REAL OL[3];
int OC[3];
FOR_EACH_CELL
// Do not trace for boundary cells
if(flagp[IX(i,j,k)]>=0) continue;
/*-------------------------------------------------------------------------
| Step 1: Tracing Back
-------------------------------------------------------------------------*/
// Get velocities at the location of scalar variable
u0 = 0.5 * (u[IX(i,j,k)]+u[IX(i-1,j,k )]);
v0 = 0.5 * (v[IX(i,j,k)]+v[IX(i,j-1,k )]);
w0 = 0.5 * (w[IX(i,j,k)]+w[IX(i,j ,k-1)]);
// Find the location at previous time step
OL[X] = x[IX(i,j,k)] - u0*dt;
OL[Y] = y[IX(i,j,k)] - v0*dt;
OL[Z] = z[IX(i,j,k)] - w0*dt;
// Initialize the coordinates of previous step
OC[X] = i;
OC[Y] = j;
OC[Z] = k;
// Initialize the signs for tracing process
// Completed: 0; In process: 1
COOD[X] = 1;
COOD[Y] = 1;
COOD[Z] = 1;
// Initialize the signs for recording if the tracing back hits the boundary
// Hit the boundary: 0; Not hit the boundary: 1
LOC[X] = 1;
LOC[Y] = 1;
LOC[Z] = 1;
//Initialize the number of iterations
it=1;
// Trace back more if the any of the trace is still in process
while(COOD[X]==1 || COOD[Y] ==1 || COOD[Z] == 1)
{
it++;
// If trace in X is in process and donot hit the boundary
if(COOD[X]==1 && LOC[X]==1)
set_x_location(para, var, flagp, x, u0, i, j, k, OL, OC, LOC, COOD);
// If trace in Y is in process and donot hit the boundary
if(COOD[Y]==1 && LOC[Y]==1)
set_y_location(para, var, flagp, y, v0, i, j, k, OL, OC, LOC, COOD);
// If trace in Z is in process and donot hit the boundary
if(COOD[Z]==1 && LOC[Z]==1)
set_z_location(para, var, flagp, z, w0, i, j, k, OL, OC, LOC, COOD);
if(it>itmax)
{
printf("Error: advection.c, can not track the location for Temperature(%d, %d,%d)",
i, j, k);
printf("after %d iterations.\n", it);
return 1;
}
} // End of while() for backward tracing
// Set the coordinates of previous location if it is as boundary
if(u0>=0 && LOC[X]==0) OC[X] -=1;
if(v0>=0 && LOC[Y]==0) OC[Y] -=1;
if(w0>=0 && LOC[Z]==0) OC[Z] -=1;
// Fixme: Do not understand here. Should it be
// if(u0<0 && LOC[X] = 0) OC[X] += 1;
if(u0<0 && LOC[X]==1) OC[X] -=1;
if(v0<0 && LOC[Y]==1) OC[Y] -=1;
if(w0<0 && LOC[Z]==1) OC[Z] -=1;
//Store the local minium and maximum values
var[LOCMIN][IX(i,j,k)]=check_min(para, d0, OC[X], OC[Y], OC[Z]);
var[LOCMAX][IX(i,j,k)]=check_max(para, d0, OC[X], OC[Y], OC[Z]);
/*-------------------------------------------------------------------------
| Interpolate
-------------------------------------------------------------------------*/
x_1 = (OL[X]- x[IX(OC[X],OC[Y],OC[Z])])
/ ( x[IX(OC[X]+1,OC[Y], OC[Z] )] - x[IX(OC[X],OC[Y],OC[Z])]);
y_1 = (OL[Y]- y[IX(OC[X],OC[Y],OC[Z])])
/ ( y[IX(OC[X], OC[Y]+1, OC[Z] )] - y[IX(OC[X],OC[Y],OC[Z])]);
z_1 = (OL[Z]- z[IX(OC[X],OC[Y],OC[Z])])
/ ( z[IX(OC[X], OC[Y], OC[Z]+1)] - z[IX(OC[X],OC[Y],OC[Z])]);
d[IX(i,j,k)] = interpolation(para, d0, x_1, y_1, z_1, OC[X], OC[Y], OC[Z]);
END_FOR // End of loop for all cells
/*---------------------------------------------------------------------------
| Define the b.c.
---------------------------------------------------------------------------*/
set_bnd(para, var, var_type, d, BINDEX);
return 0;
} // End of trace_scalar()