Return to floor.c CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.lib / libm

Annotation of 43BSD/usr.lib/libm/floor.c, revision 1.1

1.1     ! root        1: /*     @(#)floor.c     4.2     9/11/85 */
        !             2: 
        !             3: /*
        !             4:  * floor and ceil-- greatest integer <= arg
        !             5:  * (resp least >=)
        !             6:  */
        !             7: 
        !             8: double modf();
        !             9: 
        !            10: double
        !            11: floor(d)
        !            12: double d;
        !            13: {
        !            14:        double fract;
        !            15: 
        !            16:        if (d<0.0) {
        !            17:                d = -d;
        !            18:                fract = modf(d, &d);
        !            19:                if (fract != 0.0)
        !            20:                        d += 1;
        !            21:                d = -d;
        !            22:        } else
        !            23:                modf(d, &d);
        !            24:        return(d);
        !            25: }
        !            26: 
        !            27: double
        !            28: ceil(d)
        !            29: double d;
        !            30: {
        !            31:        return(-floor(-d));
        !            32: }
        !            33: 
        !            34: /*
        !            35:  * algorithm for rint(x) in pseudo-pascal form ...
        !            36:  *
        !            37:  * real rint(x): real x;
        !            38:  *     ... delivers integer nearest x in direction of prevailing rounding
        !            39:  *     ... mode
        !            40:  * const       L = (last consecutive integer)/2
        !            41:  *       = 2**55; for VAX D
        !            42:  *       = 2**52; for IEEE 754 Double
        !            43:  * real        s,t;
        !            44:  * begin
        !            45:  *     if x != x then return x;                ... NaN
        !            46:  *     if |x| >= L then return x;              ... already an integer
        !            47:  *     s := copysign(L,x);
        !            48:  *     t := x + s;                             ... = (x+s) rounded to integer
        !            49:  *     return t - s
        !            50:  * end;
        !            51:  *
        !            52:  * Note: Inexact will be signaled if x is not an integer, as is
        !            53:  *     customary for IEEE 754.  No other signal can be emitted.
        !            54:  */
        !            55: #ifdef VAX
        !            56: static long Lx[] = {0x5c00,0x0};               /* 2**55 */
        !            57: #define L *(double *) Lx
        !            58: #else  /* IEEE double */
        !            59: static double L = 4503599627370496.0E0;                /* 2**52 */
        !            60: #endif
        !            61: double
        !            62: rint(x)
        !            63: double x;
        !            64: {
        !            65:        double s,t,one = 1.0,copysign();
        !            66: #ifndef VAX
        !            67:        if (x != x)                             /* NaN */
        !            68:                return (x);
        !            69: #endif
        !            70:        if (copysign(x,one) >= L)               /* already an integer */
        !            71:            return (x);
        !            72:        s = copysign(L,x);
        !            73:        t = x + s;                              /* x+s rounded to integer */
        !            74:        return (t - s);
        !            75: }

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