Return to frexp.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / libc / 68020

Annotation of lucent/sys/src/libc/68020/frexp.c, revision 1.1.1.1

1.1       root        1: #include <u.h>
                      2: #include <libc.h>
                      3: 
                      4: #define        MASK    0x7ffL
                      5: #define        SHIFT   20
                      6: #define        BIAS    1022L
                      7: 
                      8: typedef        union
                      9: {
                     10:        double  d;
                     11:        struct
                     12:        {
                     13:                long    ms;
                     14:                long    ls;
                     15:        };
                     16: } Cheat;
                     17: 
                     18: double
                     19: frexp(double d, int *ep)
                     20: {
                     21:        Cheat x;
                     22: 
                     23:        if(d == 0) {
                     24:                *ep = 0;
                     25:                return 0;
                     26:        }
                     27:        x.d = d;
                     28:        *ep = ((x.ms >> SHIFT) & MASK) - BIAS;
                     29:        x.ms &= ~(MASK << SHIFT);
                     30:        x.ms |= BIAS << SHIFT;
                     31:        return x.d;
                     32: }
                     33: 
                     34: double
                     35: ldexp(double d, int e)
                     36: {
                     37:        Cheat x;
                     38: 
                     39:        if(d == 0)
                     40:                return 0;
                     41:        x.d = d;
                     42:        e += (x.ms >> SHIFT) & MASK;
                     43:        if(e <= 0)
                     44:                return 0;       /* underflow */
                     45:        if(e >= MASK){          /* overflow */
                     46:                if(d < 0)
                     47:                        return Inf(-1);
                     48:                return Inf(1);
                     49:        }
                     50:        x.ms &= ~(MASK << SHIFT);
                     51:        x.ms |= (long)e << SHIFT;
                     52:        return x.d;
                     53: }
                     54: 
                     55: double
                     56: modf(double d, double *ip)
                     57: {
                     58:        Cheat x;
                     59:        int e;
                     60: 
                     61:        if(d < 1) {
                     62:                if(d < 0) {
                     63:                        x.d = modf(-d, ip);
                     64:                        *ip = -*ip;
                     65:                        return -x.d;
                     66:                }
                     67:                *ip = 0;
                     68:                return d;
                     69:        }
                     70:        x.d = d;
                     71:        e = ((x.ms >> SHIFT) & MASK) - BIAS;
                     72:        if(e <= SHIFT+1) {
                     73:                x.ms &= ~(0x1fffffL >> e);
                     74:                x.ls = 0;
                     75:        } else
                     76:        if(e <= SHIFT+33)
                     77:                x.ls &= ~(0x7fffffffL >> (e-SHIFT-2));
                     78:        *ip = x.d;
                     79:        return d - x.d;
                     80: }

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