usr/src/usr.lib/libm/floor.c

/*
 * Copyright (c) 1985 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * All recipients should regard themselves as participants in an ongoing
 * research project and hence should feel obligated to report their
 * experiences (good or bad) with these elementary function codes, using
 * the sendbug(8) program, to the authors.
 */

#ifndef lint
static char sccsid[] = "@(#)floor.c     5.4 (Berkeley) 6/30/88";
#endif /* not lint */

#if defined(vax)||defined(tahoe)
#ifdef vax
#define _0x(A,B)        0x/**/A/**/B
#else   /* vax */
#define _0x(A,B)        0x/**/B/**/A
#endif  /* vax */
static long Lx[] = {_0x(0000,5c00),_0x(0000,0000)};     /* 2**55 */
#define L *(double *) Lx
#else   /* defined(vax)||defined(tahoe) */
static double L = 4503599627370496.0E0;         /* 2**52 */
#endif  /* defined(vax)||defined(tahoe) */

/*
 * floor(x) := the largest integer no larger than x;
 * ceil(x) := -floor(-x), for all real x.
 *
 * Note: Inexact will be signaled if x is not an integer, as is
 *      customary for IEEE 754.  No other signal can be emitted.
 */
double
floor(x)
double x;
{
        double y,ceil();

        if (
#if !defined(vax)&&!defined(tahoe)
                x != x ||       /* NaN */
#endif  /* !defined(vax)&&!defined(tahoe) */
                x >= L)         /* already an even integer */
                return x;
        else if (x < (double)0)
                return -ceil(-x);
        else {                  /* now 0 <= x < L */
                y = L+x;                /* destructive store must be forced */
                y -= L;                 /* an integer, and |x-y| < 1 */
                return x < y ? y-(double)1 : y;
        }
}

double
ceil(x)
double x;
{
        double y,floor();

        if (
#if !defined(vax)&&!defined(tahoe)
                x != x ||       /* NaN */
#endif  /* !defined(vax)&&!defined(tahoe) */
                x >= L)         /* already an even integer */
                return x;
        else if (x < (double)0)
                return -floor(-x);
        else {                  /* now 0 <= x < L */
                y = L+x;                /* destructive store must be forced */
                y -= L;                 /* an integer, and |x-y| < 1 */
                return x > y ? y+(double)1 : y;
        }
}

#ifndef national                        /* rint() is in ./NATIONAL/support.s */
/*
 * algorithm for rint(x) in pseudo-pascal form ...
 *
 * real rint(x): real x;
 *      ... delivers integer nearest x in direction of prevailing rounding
 *      ... mode
 * const        L = (last consecutive integer)/2
 *        = 2**55; for VAX D
 *        = 2**52; for IEEE 754 Double
 * real s,t;
 * begin
 *      if x != x then return x;                ... NaN
 *      if |x| >= L then return x;              ... already an integer
 *      s := copysign(L,x);
 *      t := x + s;                             ... = (x+s) rounded to integer
 *      return t - s
 * end;
 *
 * Note: Inexact will be signaled if x is not an integer, as is
 *      customary for IEEE 754.  No other signal can be emitted.
 */
double
rint(x)
double x;
{
        double s,t,one = 1.0,copysign();
#if !defined(vax)&&!defined(tahoe)
        if (x != x)                             /* NaN */
                return (x);
#endif  /* !defined(vax)&&!defined(tahoe) */
        if (copysign(x,one) >= L)               /* already an integer */
            return (x);
        s = copysign(L,x);
        t = x + s;                              /* x+s rounded to integer */
        return (t - s);
}
#endif  /* not national */