Return to ecvt.c CVS log

Up to [Research Unix] / researchv10dc / libI77 / notused

Annotation of researchv10dc/libI77/notused/ecvt.c, revision 1.1

1.1     ! root        1: /*     @(#)ecvt.c      2.7     */
        !             2: /*     3.0 SID #       1.2     */
        !             3: /*LINTLIBRARY*/
        !             4: /*
        !             5:  *     ecvt converts to decimal
        !             6:  *     the number of digits is specified by ndigit
        !             7:  *     decpt is set to the position of the decimal point
        !             8:  *     sign is set to 0 for positive, 1 for negative
        !             9:  *
        !            10:  */
        !            11: #include <nan.h>
        !            12: #include <values.h>
        !            13: #define        NMAX    ((DSIGNIF * 3 + 19)/10) /* restrict max precision */
        !            14: #define        NDIG    80
        !            15: 
        !            16: extern char *cvt();
        !            17: 
        !            18: char *
        !            19: ecvt(value, ndigit, decpt, sign)
        !            20: double value;
        !            21: int    ndigit, *decpt, *sign;
        !            22: {
        !            23:        return (cvt(value, ndigit, decpt, sign, 0));
        !            24: }
        !            25: 
        !            26: char *
        !            27: fcvt(value, ndigit, decpt, sign)
        !            28: double value;
        !            29: int    ndigit, *decpt, *sign;
        !            30: {
        !            31:        return (cvt(value, ndigit, decpt, sign, 1));
        !            32: }
        !            33: 
        !            34: static char buf[NDIG];
        !            35: 
        !            36: static char *
        !            37: cvt(value, ndigit, decpt, sign, f_flag)
        !            38: double value;
        !            39: int    ndigit, *sign, f_flag;
        !            40: register int   *decpt;
        !            41: {
        !            42:        register char *p = &buf[0], *p_last = &buf[ndigit];
        !            43: 
        !            44:        KILLNaN(value); /* raise exception on Not-a-Number (3b only) */
        !            45:        if (*sign = (value < 0.0))
        !            46:                value = -value;
        !            47:        buf[0] = '\0';
        !            48:        *decpt = 0;
        !            49:        if (value != 0.0) { /* rescale to range [1.0, 10.0) */
        !            50:                /* in binary for speed and to minimize error build-up */
        !            51:                /* even for the IEEE standard with its high exponents,
        !            52:                   it's probably better for speed to just loop on them */
        !            53:                static struct s { double p10; int n; } s[] = {
        !            54:                        1e32,   32,
        !            55:                        1e16,   16,
        !            56:                        1e8,    8,
        !            57:                        1e4,    4,
        !            58:                        1e2,    2,
        !            59:                        1e1,    1,
        !            60:                };
        !            61:                register struct s *sp = s;
        !            62: 
        !            63:                ++*decpt;
        !            64:                if (value >= 2.0 * MAXPOWTWO) /* can't be precisely integral */
        !            65:                        do {
        !            66:                                for ( ; value >= sp->p10; *decpt += sp->n)
        !            67:                                        value /= sp->p10;
        !            68:                        } while (sp++->n > 1);
        !            69:                else if (value >= 10.0) { /* convert integer part separately */
        !            70:                        register double pow10 = 10.0, powtemp;
        !            71: 
        !            72:                        while ((powtemp = 10.0 * pow10) <= value)
        !            73:                                pow10 = powtemp;
        !            74:                        for ( ; ; pow10 /= 10.0) {
        !            75:                                register int digit = value/pow10;
        !            76:                                *p++ = digit + '0';
        !            77:                                value -= digit * pow10;
        !            78:                                ++*decpt;
        !            79:                                if (pow10 <= 10.0)
        !            80:                                        break;
        !            81:                        }
        !            82:                } else if (value < 1.0)
        !            83:                        do {
        !            84:                                for ( ; value * sp->p10 < 10.0; *decpt -= sp->n)
        !            85:                                        value *= sp->p10;
        !            86:                        } while (sp++->n > 1);
        !            87:        }
        !            88:        if (f_flag)
        !            89:                p_last += *decpt;
        !            90:        if (p_last >= buf) {
        !            91:                if (p_last > &buf[NDIG - 2])
        !            92:                        p_last = &buf[NDIG - 2];
        !            93:                for ( ; ; ++p) {
        !            94:                        if (value == 0 || p >= &buf[NMAX])
        !            95:                                *p = '0';
        !            96:                        else {
        !            97:                                register int intx; /* intx in [0, 9] */
        !            98:                                *p = (intx = (int)value) + '0';
        !            99:                                value = 10.0 * (value - (double)intx);
        !           100:                        }
        !           101:                        if (p >= p_last) {
        !           102:                                p = p_last;
        !           103:                                break;
        !           104:                        }
        !           105:                }
        !           106:                if (*p >= '5') /* check rounding in last place + 1 */
        !           107:                        do {
        !           108:                                if (p == buf) { /* rollover from 99999... */
        !           109:                                        buf[0] = '1'; /* later digits are 0 */
        !           110:                                        ++*decpt;
        !           111:                                        if (f_flag)
        !           112:                                                ++p_last;
        !           113:                                        break;
        !           114:                                }
        !           115:                                *p-- = '0';
        !           116:                        } while (++*p > '9'); /* propagate carries left */
        !           117:                *p_last = '\0';
        !           118:        }
        !           119:        return (buf);
        !           120: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.