static void scientific(double *x, int *sgn, int *kpower, int *nsig)
{
/* for a number x , determine
* sgn = 1_{x < 0} {0/1}
* kpower = Exponent of 10;
* nsig = min(R_print.digits, #{significant digits of alpha})
*
* where |x| = alpha * 10^kpower and 1 <= alpha < 10
*/
register double alpha;
register double r;
register int kp;
int j;
if (*x == 0.0) {
*kpower = 0;
*nsig = 1;
*sgn = 0;
} else {
if(*x < 0.0) {
*sgn = 1; r = -*x;
} else {
*sgn = 0; r = *x;
}
if (R_print.digits >= DBL_DIG + 1) {
format_via_sprintf(r, R_print.digits, kpower, nsig);
return;
}
kp = (int) floor(log10(r)) - R_print.digits + 1;/* r = |x|; 10^(kp + digits - 1) <= r */
#if SIZEOF_LONG_DOUBLE > SIZEOF_DOUBLE
long double r_prec = r;
/* use exact scaling factor in long double precision, if possible */
if (abs(kp) <= 27) {
if (kp > 0) r_prec /= tbl[kp]; else if (kp < 0) r_prec *= tbl[ -kp];
}
#ifdef HAVE_POWL
else
r_prec /= powl(10.0, (long double) kp);
#else
else if (kp <= R_dec_min_exponent)
r_prec = (r_prec * 1e+303)/pow(10.0, (double)(kp+303));
else
r_prec /= pow(10.0, (double) kp);
#endif
if (r_prec < tbl[R_print.digits - 1]) {
r_prec *= 10.0;
kp--;
}
/* round alpha to integer, 10^(digits-1) <= alpha <= 10^digits
accuracy limited by double rounding problem,
alpha already rounded to 64 bits */
alpha = (double) R_nearbyintl(r_prec);
#else
/* use exact scaling factor in double precision, if possible */
if (abs(kp) <= 22) {
if (kp >= 0) r /= tbl[kp]; else r *= tbl[ -kp];
}
/* on IEEE 1e-308 is not representable except by gradual underflow.
Shifting by 303 allows for any potential denormalized numbers x,
and makes the reasonable assumption that R_dec_min_exponent+303
is in range. Representation of 1e+303 has low error.
*/
else if (kp <= R_dec_min_exponent)
r = (r * 1e+303)/pow(10.0, (double)(kp+303));
else
r /= pow(10.0, (double)kp);
if (r < tbl[R_print.digits - 1]) {
r *= 10.0;
kp--;
}
/* round alpha to integer, 10^(digits-1) <= alpha <= 10^digits */
/* accuracy limited by double rounding problem, alpha already rounded to 53 bits */
alpha = R_nearbyint(r);
#endif
*nsig = R_print.digits;
for (j = 1; j <= R_print.digits; j++) {
alpha /= 10.0;
if (alpha == floor(alpha)) {
(*nsig)--;
} else {
break;
}
}
if (*nsig == 0) {
*nsig = 1;
kp += 1;
}
*kpower = kp + R_print.digits - 1;
}
static void
scientific(double *x, int *sgn, int *kpower, int *nsig, int *roundingwidens)
{
/* for a number x , determine
* sgn = 1_{x < 0} {0/1}
* kpower = Exponent of 10;
* nsig = min(R_print.digits, #{significant digits of alpha})
* roundingwidens = 1 if rounding causes x to increase in width, 0 otherwise
*
* where |x| = alpha * 10^kpower and 1 <= alpha < 10
*/
register double alpha;
register double r;
register int kp;
int j;
if (*x == 0.0) {
*kpower = 0;
*nsig = 1;
*sgn = 0;
*roundingwidens = 0;
} else {
if(*x < 0.0) {
*sgn = 1; r = -*x;
} else {
*sgn = 0; r = *x;
}
if (R_print.digits >= DBL_DIG + 1) {
format_via_sprintf(r, R_print.digits, kpower, nsig);
*roundingwidens = 0;
return;
}
kp = (int) floor(log10(r)) - R_print.digits + 1;/* r = |x|; 10^(kp + digits - 1) <= r */
#if defined(HAVE_LONG_DOUBLE) && (SIZEOF_LONG_DOUBLE > SIZEOF_DOUBLE)
long double r_prec = r;
/* use exact scaling factor in long double precision, if possible */
if (abs(kp) <= 27) {
if (kp > 0) r_prec /= tbl[kp+1]; else if (kp < 0) r_prec *= tbl[ -kp+1];
}
#ifdef HAVE_POWL
else
r_prec /= powl(10.0, (long double) kp);
#else
else if (kp <= R_dec_min_exponent)
r_prec = (r_prec * 1e+303)/pow(10.0, (double)(kp+303));
else
r_prec /= pow(10.0, (double) kp);
#endif
if (r_prec < tbl[R_print.digits]) {
r_prec *= 10.0;
kp--;
}
/* round alpha to integer, 10^(digits-1) <= alpha <= 10^digits
accuracy limited by double rounding problem,
alpha already rounded to 64 bits */
alpha = (double) R_nearbyintl(r_prec);
#else
double r_prec = r;
/* use exact scaling factor in double precision, if possible */
if (abs(kp) <= 22) {
if (kp >= 0) r_prec /= tbl[kp+1]; else r_prec *= tbl[ -kp+1];
}
/* on IEEE 1e-308 is not representable except by gradual underflow.
Shifting by 303 allows for any potential denormalized numbers x,
and makes the reasonable assumption that R_dec_min_exponent+303
is in range. Representation of 1e+303 has low error.
*/
else if (kp <= R_dec_min_exponent)
r_prec = (r_prec * 1e+303)/pow(10.0, (double)(kp+303));
else
r_prec /= pow(10.0, (double)kp);
if (r_prec < tbl[R_print.digits]) {
r_prec *= 10.0;
kp--;
}
/* round alpha to integer, 10^(digits-1) <= alpha <= 10^digits */
/* accuracy limited by double rounding problem,
alpha already rounded to 53 bits */
alpha = R_nearbyint(r_prec);
#endif
*nsig = R_print.digits;
for (j = 1; j <= R_print.digits; j++) {
alpha /= 10.0;
if (alpha == floor(alpha)) {
(*nsig)--;
} else {
break;
}
}
if (*nsig == 0 && R_print.digits > 0) {
*nsig = 1;
kp += 1;
}
*kpower = kp + R_print.digits - 1;
/* Scientific format may do more rounding than fixed format, e.g.
9996 with 3 digits is 1e+04 in scientific, but 9996 in fixed.
This happens when the true value r is less than 10^(kpower+1)
and would not round up to it in fixed format.
Here rgt is the decimal place that will be cut off by rounding */
int rgt = R_print.digits - *kpower;
/* bound rgt by 0 and KP_MAX */
rgt = rgt < 0 ? 0 : rgt > KP_MAX ? KP_MAX : rgt;
double fuzz = 0.5/(double)tbl[1 + rgt];
// kpower can be bigger than the table.
*roundingwidens = *kpower > 0 && *kpower <= KP_MAX && r < tbl[*kpower + 1] - fuzz;
}
