Lines Matching +full:ulp +full:- +full:0
5 Copyright (C) 1998-2001 by Lucent Technologies
49 static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128,
50 9007199254740992.*9007199254740992.e-256
75 rv = ulp(x);
76 if (!scale || (i = 2*P + 1 - ((word0(x) & Exp_mask) >> Exp_shift)) <= 0)
77 return rv; /* Is there an example where i <= 0 ? */
79 word1(&u) = 0;
111 char *decimalpoint = localeconv_l(loc)->decimal_point;
118 s0 = localeconv_l(loc)->decimal_point;
138 case FE_TOWARDZERO: Rounding = 0; break;
145 sign = nz0 = nz = decpt = 0;
146 dval(&rv) = 0.;
148 case '-':
155 case 0:
168 if (*s == '0') {
171 static FPI fpi = { 53, 1-1023-53+1, 2046-1023-53+1, 1, SI };
187 sign = 0;
195 ULtod(((U*)&rv)->L, bits, exp, i);
202 while(*++s == '0') ;
207 y = z = 0;
208 for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++)
210 y = 10*y + c - '0';
212 z = 10*z + c - '0';
227 for(; c == '0'; c = *++s)
229 if (c > '0' && c <= '9') {
232 nz = 0;
237 for(; c >= '0' && c <= '9'; c = *++s) {
240 if (c -= '0') {
251 nz = 0;
256 e = 0;
262 esign = 0;
264 case '-':
269 if (c >= '0' && c <= '9') {
270 while(c == '0')
272 if (c > '0' && c <= '9') {
273 L = c - '0';
275 while((c = *++s) >= '0' && c <= '9')
276 L = 10*L + c - '0';
277 if (s - s1 > 8 || L > 19999)
285 e = -e;
288 e = 0;
299 { 52, 1-1023-53+1, 2046-1023-53+1, 1, SI };
305 --s;
308 word0(&rv) = 0x7ff00000;
309 word1(&rv) = 0;
320 word0(&rv) = 0x7ff80000 | bits[1];
321 word1(&rv) = bits[0];
336 sign = 0;
340 e1 = e -= nf;
343 * decimal point, followed by nd-nd0 digits. The number we're
356 dval(&rv) = tens[k - 9] * dval(&rv) + z;
358 bd0 = 0;
369 if (e > 0) {
377 rv.d = -rv.d;
378 sign = 0;
385 i = DBL_DIG - nd;
393 rv.d = -rv.d;
394 sign = 0;
397 e -= i;
404 word0(&rv) -= P*Exp_msk1;
407 > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
417 else if (e >= -Ten_pmax) {
421 rv.d = -rv.d;
422 sign = 0;
425 /* rv = */ rounded_quotient(dval(&rv), tens[-e]);
431 e1 += nd - k;
440 scale = 0;
445 Rounding = Rounding == 2 ? 0 : 2;
448 Rounding = 0;
455 if (e1 > 0) {
456 if ( (i = e1 & 15) !=0)
465 case 0: /* toward 0 */
466 case 3: /* toward -infinity */
472 word1(&rv) = 0;
476 word1(&rv) = 0;
501 for(j = 0; e1 > 1; j++, e1 >>= 1)
505 word0(&rv) -= P*Exp_msk1;
508 > Exp_msk1*(DBL_MAX_EXP+Bias-P))
510 if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) {
520 else if (e1 < 0) {
521 e1 = -e1;
522 if ( (i = e1 & 15) !=0)
530 for(j = 0; e1 > 0; j++, e1 >>= 1)
533 if (scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask)
534 >> Exp_shift)) > 0) {
537 word1(&rv) = 0;
541 word0(&rv) &= 0xffffffff << (j-32);
544 word1(&rv) &= 0xffffffff << j;
547 for(j = 0; e1 > 1; j++, e1 >>= 1)
559 dval(&rv) = 0.;
573 /* Now the hard part -- adjusting rv to the correct value.*/
580 bd = Balloc(bd0->k);
585 if (e >= 0) {
586 bb2 = bb5 = 0;
590 bb2 = bb5 = -e;
591 bd2 = bd5 = 0;
593 if (bbe >= 0)
596 bd2 -= bbe;
604 Lsb1 = 0;
605 j = bbe - scale;
606 i = j + bbbits - 1; /* logb(rv) */
607 j = P + 1 - bbbits;
609 i = Emin - i;
610 j -= i;
614 Lsb1 = Lsb << (i-32);
619 j = 1 + 4*P - 3 - bbbits + ((bbe + bbbits - 1) & 3);
621 j = P + 1 - bbbits;
625 i = j + bbbits - 1; /* logb(&rv) */
627 j += P - Emin;
629 j = P + 1 - bbbits;
640 if (i > 0) {
641 bb2 -= i;
642 bd2 -= i;
643 bs2 -= i;
645 if (bb5 > 0) {
651 if (bb2 > 0)
653 if (bd5 > 0)
655 if (bd2 > 0)
657 if (bs2 > 0)
660 dsign = delta->sign;
661 delta->sign = 0;
665 if (i < 0) {
666 /* Error is less than an ulp */
667 if (!delta->x[0] && delta->wds <= 1) {
670 inexact = 0;
681 dval(&adj) = -1.;
692 if (cmp(delta, bs) <= 0)
693 dval(&adj) = -0.5;
700 word0(&adj) += (2*P+1)*Exp_msk1 - y;
706 dval(&rv) += adj*ulp(&rv);
707 word0(&rv) -= P*Exp_msk1;
712 dval(&rv) += adj.d*ulp(&rv);
719 if (adj.d <= 0x7ffffffe) {
730 word0(&adj) += (2*P+1)*Exp_msk1 - y;
735 dval(&adj) *= ulp(&rv);
739 dval(&rv) -= adj;
740 word0(&rv) -= P*Exp_msk1;
745 dval(&adj) *= ulp(&rv);
752 dval(&rv) -= adj.d;
757 if (i < 0) {
758 /* Error is less than half an ulp -- check for
771 if (!delta->x[0] && delta->wds <= 1)
772 inexact = 0;
776 if (!delta->x[0] && delta->wds <= 1) {
779 inexact = 0;
784 if (cmp(delta, bs) > 0)
788 if (i == 0) {
789 /* exactly half-way between */
795 ? (0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) :
797 0xffffffff)) {
798 /*boundary case -- increment exponent*/
807 word1(&rv) = 0;
809 dsign = 0;
816 /* boundary case -- decrement exponent */
829 L -= Exp_msk1;
844 L = (word0(&rv) & Exp_mask) - Exp_msk1;
847 word1(&rv) = 0xffffffff;
871 dval(&rv) += ulp(&rv);
876 dval(&rv) -= sulp(&rv, scale);
878 dval(&rv) -= ulp(&rv);
886 dsign = 1 - dsign;
900 dval(&aadj1) = -1.;
903 /* special case -- power of FLT_RADIX to be */
910 dval(&aadj1) = -aadj;
915 dval(&aadj1) = dsign ? aadj : -aadj;
919 dval(&aadj1) -= 0.5;
921 case 0: /* towards 0 */
922 case 3: /* towards -infinity */
926 if (Flt_Rounds == 0)
934 if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
936 word0(&rv) -= P*Exp_msk1;
937 dval(&adj) = dval(&aadj1) * ulp(&rv);
940 Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
953 if (aadj <= 0x7fffffff) {
954 if ((z = aadj) <= 0)
957 dval(&aadj1) = dsign ? aadj : -aadj;
959 word0(&aadj1) += (2*P+1)*Exp_msk1 - y;
961 dval(&adj) = dval(&aadj1) * ulp(&rv);
968 dval(&adj) = dval(&aadj1) * ulp(&rv);
984 word0(&rv) -= P*Exp_msk1;
987 dval(&adj) = dval(&aadj1) * ulp(&rv);
992 * correctly round rv + dval(&adj) in some half-way cases.
993 * If rv * ulp(&rv) is denormalized (i.e.,
994 * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
996 * example: 1.2e-307 .
998 if (y <= (P-1)*Exp_msk1 && aadj > 1.) {
1001 dval(&aadj1) = -dval(&aadj1);
1003 dval(&adj) = dval(&aadj1) * ulp(&rv);
1016 aadj -= L;
1041 word1(&rv0) = 0;
1050 word0(&rv0) = Exp_1 - 2*P*Exp_msk1;
1051 word1(&rv0) = 0;
1058 if (word0(&rv) == 0 && word1(&rv) == 0)
1067 dval(&rv0) = 1e-300;
1074 return sign ? -dval(&rv) : dval(&rv);