lib/libc/compat/gen/compat_modf_ieee754.c

   1 /* $NetBSD: compat_modf_ieee754.c,v 1.4 2010/04/23 19:04:54 drochner Exp $ */
   2
   3 /*
   4  * Copyright (c) 1994, 1995 Carnegie-Mellon University.
   5  * All rights reserved.
   6  *
   7  * Author: Chris G. Demetriou
   8  *
   9  * Permission to use, copy, modify and distribute this software and
  10  * its documentation is hereby granted, provided that both the copyright
  11  * notice and this permission notice appear in all copies of the
  12  * software, derivative works or modified versions, and any portions
  13  * thereof, and that both notices appear in supporting documentation.
  14  *
  15  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  16  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  17  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  18  *
  19  * Carnegie Mellon requests users of this software to return to
  20  *
  21  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  22  *  School of Computer Science
  23  *  Carnegie Mellon University
  24  *  Pittsburgh PA 15213-3890
  25  *
  26  * any improvements or extensions that they make and grant Carnegie the
  27  * rights to redistribute these changes.
  28  */
  29
  30 #include <sys/types.h>
  31 #include <machine/ieee.h>
  32 #include <errno.h>
  33
  34 double modf(double, double *);
  35
  36 /*
  37  * double modf(double val, double *iptr)
  38  * returns: f and i such that |f| < 1.0, (f + i) = val, and
  39  *      sign(f) == sign(i) == sign(val).
  40  *
  41  * Beware signedness when doing subtraction, and also operand size!
  42  */
  43 double
  44 modf(double val, double *iptr)
  45 {
  46         union ieee_double_u u, v;
  47         u_int64_t frac;
  48
  49         /*
  50          * If input is +/-Inf or NaN, return +/-0 or NaN.
  51          */
  52         u.dblu_d = val;
  53         if (u.dblu_dbl.dbl_exp == DBL_EXP_INFNAN) {
  54                 *iptr = u.dblu_d;
  55                 return (0.0 / u.dblu_d);
  56         }
  57
  58         /*
  59          * If input can't have a fractional part, return
  60          * (appropriately signed) zero, and make i be the input.
  61          */
  62         if ((int)u.dblu_dbl.dbl_exp - DBL_EXP_BIAS > DBL_FRACBITS - 1) {
  63                 *iptr = u.dblu_d;
  64                 v.dblu_d = 0.0;
  65                 v.dblu_dbl.dbl_sign = u.dblu_dbl.dbl_sign;
  66                 return (v.dblu_d);
  67         }
  68
  69         /*
  70          * If |input| < 1.0, return it, and set i to the appropriately
  71          * signed zero.
  72          */
  73         if (u.dblu_dbl.dbl_exp < DBL_EXP_BIAS) {
  74                 v.dblu_d = 0.0;
  75                 v.dblu_dbl.dbl_sign = u.dblu_dbl.dbl_sign;
  76                 *iptr = v.dblu_d;
  77                 return (u.dblu_d);
  78         }
  79
  80         /*
  81          * There can be a fractional part of the input.
  82          * If you look at the math involved for a few seconds, it's
  83          * plain to see that the integral part is the input, with the
  84          * low (DBL_FRACBITS - (exponent - DBL_EXP_BIAS)) bits zeroed,
  85          * the fractional part is the part with the rest of the
  86          * bits zeroed.  Just zeroing the high bits to get the
  87          * fractional part would yield a fraction in need of
  88          * normalization.  Therefore, we take the easy way out, and
  89          * just use subtraction to get the fractional part.
  90          */
  91         v.dblu_d = u.dblu_d;
  92         /* Zero the low bits of the fraction, the sleazy way. */
  93         frac = ((u_int64_t)v.dblu_dbl.dbl_frach << 32) + v.dblu_dbl.dbl_fracl;
  94         frac >>= DBL_FRACBITS - (u.dblu_dbl.dbl_exp - DBL_EXP_BIAS);
  95         frac <<= DBL_FRACBITS - (u.dblu_dbl.dbl_exp - DBL_EXP_BIAS);
  96         v.dblu_dbl.dbl_fracl = (unsigned int)frac & 0xffffffff;
  97         v.dblu_dbl.dbl_frach = (unsigned int)(frac >> 32);
  98         *iptr = v.dblu_d;
  99
 100         u.dblu_d -= v.dblu_d;
 101         u.dblu_dbl.dbl_sign = v.dblu_dbl.dbl_sign;
 102         return (u.dblu_d);
 103 }