1 /* $NetBSD: compat_modf_ieee754.c,v 1.6 2024/01/20 14:52:45 christos 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 #include <math.h>
34
35 /*
36 * double modf(double val, double *iptr)
37 * returns: f and i such that |f| < 1.0, (f + i) = val, and
38 * sign(f) == sign(i) == sign(val).
39 *
40 * Beware signedness when doing subtraction, and also operand size!
41 */
42 double
modf(double val,double * iptr)43 modf(double val, double *iptr)
44 {
45 union ieee_double_u u, v;
46 u_int64_t frac;
47
48 /*
49 * If input is +/-Inf or NaN, return +/-0 or NaN.
50 */
51 u.dblu_d = val;
52 if (u.dblu_dbl.dbl_exp == DBL_EXP_INFNAN) {
53 *iptr = u.dblu_d;
54 return (0.0 / u.dblu_d);
55 }
56
57 /*
58 * If input can't have a fractional part, return
59 * (appropriately signed) zero, and make i be the input.
60 */
61 if ((int)u.dblu_dbl.dbl_exp - DBL_EXP_BIAS > DBL_FRACBITS - 1) {
62 *iptr = u.dblu_d;
63 v.dblu_d = 0.0;
64 v.dblu_dbl.dbl_sign = u.dblu_dbl.dbl_sign;
65 return (v.dblu_d);
66 }
67
68 /*
69 * If |input| < 1.0, return it, and set i to the appropriately
70 * signed zero.
71 */
72 if (u.dblu_dbl.dbl_exp < DBL_EXP_BIAS) {
73 v.dblu_d = 0.0;
74 v.dblu_dbl.dbl_sign = u.dblu_dbl.dbl_sign;
75 *iptr = v.dblu_d;
76 return (u.dblu_d);
77 }
78
79 /*
80 * There can be a fractional part of the input.
81 * If you look at the math involved for a few seconds, it's
82 * plain to see that the integral part is the input, with the
83 * low (DBL_FRACBITS - (exponent - DBL_EXP_BIAS)) bits zeroed,
84 * the fractional part is the part with the rest of the
85 * bits zeroed. Just zeroing the high bits to get the
86 * fractional part would yield a fraction in need of
87 * normalization. Therefore, we take the easy way out, and
88 * just use subtraction to get the fractional part.
89 */
90 v.dblu_d = u.dblu_d;
91 /* Zero the low bits of the fraction, the sleazy way. */
92 frac = ((u_int64_t)v.dblu_dbl.dbl_frach << 32) + v.dblu_dbl.dbl_fracl;
93 frac >>= DBL_FRACBITS - (u.dblu_dbl.dbl_exp - DBL_EXP_BIAS);
94 frac <<= DBL_FRACBITS - (u.dblu_dbl.dbl_exp - DBL_EXP_BIAS);
95 v.dblu_dbl.dbl_fracl = (unsigned int)(frac & 0xffffffffULL);
96 v.dblu_dbl.dbl_frach = (unsigned int)(frac >> 32);
97 *iptr = v.dblu_d;
98
99 u.dblu_d -= v.dblu_d;
100 u.dblu_dbl.dbl_sign = v.dblu_dbl.dbl_sign;
101 return (u.dblu_d);
102 }
103