Print this page
11210 libm should be cstyle(1ONBLD) clean
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libm/common/C/sin.c
+++ new/usr/src/lib/libm/common/C/sin.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 +
21 22 /*
22 23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
23 24 */
25 +
24 26 /*
25 27 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
26 28 * Use is subject to license terms.
27 29 */
28 30
29 31 #pragma weak __sin = sin
30 32
31 -/* INDENT OFF */
33 +
32 34 /*
33 35 * sin(x)
34 36 * Accurate Table look-up algorithm by K.C. Ng, May, 1995.
35 37 *
36 38 * Algorithm: see sincos.c
37 39 */
38 40
39 41 #include "libm.h"
40 42
41 43 static const double sc[] = {
42 -/* ONE = */ 1.0,
44 +/* ONE = */
45 + 1.0,
43 46 /* NONE = */ -1.0,
47 +
44 48 /*
45 49 * |sin(x) - (x+pp1*x^3+pp2*x^5)| <= 2^-58.79 for |x| < 0.008
46 50 */
47 -/* PP1 = */ -0.166666666666316558867252052378889521480627858683055567,
48 -/* PP2 = */ .008333315652997472323564894248466758248475374977974017927,
51 +/* PP1 = */-0.166666666666316558867252052378889521480627858683055567,
52 +/* PP2 = */.008333315652997472323564894248466758248475374977974017927,
53 +
49 54 /*
50 55 * |(sin(x) - (x+p1*x^3+...+p4*x^9)|
51 56 * |------------------------------ | <= 2^-57.63 for |x| < 0.1953125
52 57 * | x |
53 58 */
54 -/* P1 = */ -1.666666666666629669805215138920301589656e-0001,
55 -/* P2 = */ 8.333333332390951295683993455280336376663e-0003,
56 -/* P3 = */ -1.984126237997976692791551778230098403960e-0004,
57 -/* P4 = */ 2.753403624854277237649987622848330351110e-0006,
59 +/* P1 = */ -1.666666666666629669805215138920301589656e-0001,
60 +/* P2 = */ 8.333333332390951295683993455280336376663e-0003,
61 +/* P3 = */ -1.984126237997976692791551778230098403960e-0004,
62 +/* P4 = */ 2.753403624854277237649987622848330351110e-0006,
63 +
58 64 /*
59 65 * |cos(x) - (1+qq1*x^2+qq2*x^4)| <= 2^-55.99 for |x| <= 0.008 (0x3f80624d)
60 66 */
61 -/* QQ1 = */ -0.4999999999975492381842911981948418542742729,
62 -/* QQ2 = */ 0.041666542904352059294545209158357640398771740,
63 -/* PI_H = */ 3.1415926535897931159979634685,
64 -/* PI_L = */ 1.22464679914735317722606593227425e-16,
65 -/* PI_L0 = */ 1.22464679914558443311283879205095e-16,
66 -/* PI_L1 = */ 1.768744113227140223300005233735517376e-28,
67 -/* PI2_H = */ 6.2831853071795862319959269370,
68 -/* PI2_L = */ 2.44929359829470635445213186454850e-16,
69 -/* PI2_L0 = */ 2.44929359829116886622567758410190e-16,
70 -/* PI2_L1 = */ 3.537488226454280446600010467471034752e-28,
67 +/* QQ1 = */-0.4999999999975492381842911981948418542742729,
68 +/* QQ2 = */0.041666542904352059294545209158357640398771740,
69 +/* PI_H = */ 3.1415926535897931159979634685,
70 +/* PI_L = */ 1.22464679914735317722606593227425e-16,
71 +/* PI_L0 = */ 1.22464679914558443311283879205095e-16,
72 +/* PI_L1 = */ 1.768744113227140223300005233735517376e-28,
73 +/* PI2_H = */ 6.2831853071795862319959269370,
74 +/* PI2_L = */ 2.44929359829470635445213186454850e-16,
75 +/* PI2_L0 = */ 2.44929359829116886622567758410190e-16,
76 +/* PI2_L1 = */ 3.537488226454280446600010467471034752e-28,
71 77 };
72 -/* INDENT ON */
73 78
74 -#define ONEA sc
75 -#define ONE sc[0]
76 -#define NONE sc[1]
77 -#define PP1 sc[2]
78 -#define PP2 sc[3]
79 -#define P1 sc[4]
80 -#define P2 sc[5]
81 -#define P3 sc[6]
82 -#define P4 sc[7]
83 -#define QQ1 sc[8]
84 -#define QQ2 sc[9]
85 -#define PI_H sc[10]
86 -#define PI_L sc[11]
87 -#define PI_L0 sc[12]
88 -#define PI_L1 sc[13]
89 -#define PI2_H sc[14]
90 -#define PI2_L sc[15]
91 -#define PI2_L0 sc[16]
92 -#define PI2_L1 sc[17]
93 79
94 -extern const double _TBL_sincos[], _TBL_sincosx[];
80 +#define ONEA sc
81 +#define ONE sc[0]
82 +#define NONE sc[1]
83 +#define PP1 sc[2]
84 +#define PP2 sc[3]
85 +#define P1 sc[4]
86 +#define P2 sc[5]
87 +#define P3 sc[6]
88 +#define P4 sc[7]
89 +#define QQ1 sc[8]
90 +#define QQ2 sc[9]
91 +#define PI_H sc[10]
92 +#define PI_L sc[11]
93 +#define PI_L0 sc[12]
94 +#define PI_L1 sc[13]
95 +#define PI2_H sc[14]
96 +#define PI2_L sc[15]
97 +#define PI2_L0 sc[16]
98 +#define PI2_L1 sc[17]
99 +
100 +extern const double _TBL_sincos[], _TBL_sincosx[];
95 101
96 102 double
97 -sin(double x) {
98 - double z, y[2], w, s, v, p, q;
99 - int i, j, n, hx, ix, lx;
103 +sin(double x)
104 +{
105 + double z, y[2], w, s, v, p, q;
106 + int i, j, n, hx, ix, lx;
100 107
101 108 hx = ((int *)&x)[HIWORD];
102 109 lx = ((int *)&x)[LOWORD];
103 110 ix = hx & ~0x80000000;
104 111
105 - if (ix <= 0x3fc50000) { /* |x| < .1640625 */
112 + if (ix <= 0x3fc50000) { /* |x| < .1640625 */
106 113 if (ix < 0x3e400000) /* |x| < 2**-27 */
107 114 if ((int)x == 0)
108 115 return (x);
116 +
109 117 z = x * x;
118 +
110 119 if (ix < 0x3f800000) /* |x| < 2**-8 */
111 120 w = (z * x) * (PP1 + z * PP2);
112 121 else
113 122 w = (x * z) * ((P1 + z * P2) + (z * z) * (P3 + z * P4));
123 +
114 124 return (x + w);
115 125 }
116 126
117 127 /* for .1640625 < x < M, */
118 128 n = ix >> 20;
119 - if (n < 0x402) { /* x < 8 */
129 +
130 + if (n < 0x402) { /* x < 8 */
120 131 i = (((ix >> 12) & 0xff) | 0x100) >> (0x401 - n);
121 132 j = i - 10;
122 133 x = fabs(x);
123 134 v = x - _TBL_sincosx[j];
135 +
124 136 if (((j - 181) ^ (j - 201)) < 0) {
125 137 /* near pi, sin(x) = sin(pi-x) */
126 138 p = PI_H - x;
127 139 i = ix - 0x400921fb;
128 140 x = p + PI_L;
141 +
129 142 if ((i | ((lx - 0x54442D00) & 0xffffff00)) == 0) {
130 143 /* very close to pi */
131 144 x = p + PI_L0;
132 - return ((hx >= 0)? x + PI_L1 : -(x + PI_L1));
145 + return ((hx >= 0) ? x + PI_L1 : -(x + PI_L1));
133 146 }
147 +
134 148 z = x * x;
149 +
135 150 if (((ix - 0x40092000) >> 11) == 0) {
136 151 /* |pi-x|<2**-8 */
137 152 w = PI_L + (z * x) * (PP1 + z * PP2);
138 153 } else {
139 - w = PI_L + (z * x) * ((P1 + z * P2) +
140 - (z * z) * (P3 + z * P4));
154 + w = PI_L + (z * x) * ((P1 + z * P2) + (z * z) *
155 + (P3 + z * P4));
141 156 }
142 - return ((hx >= 0)? p + w : -p - w);
157 +
158 + return ((hx >= 0) ? p + w : -p - w);
143 159 }
160 +
144 161 s = v * v;
162 +
145 163 if (((j - 382) ^ (j - 402)) < 0) {
146 164 /* near 2pi, sin(x) = sin(x-2pi) */
147 165 p = x - PI2_H;
148 166 i = ix - 0x401921fb;
149 167 x = p - PI2_L;
168 +
150 169 if ((i | ((lx - 0x54442D00) & 0xffffff00)) == 0) {
151 170 /* very close to 2pi */
152 171 x = p - PI2_L0;
153 - return ((hx >= 0)? x - PI2_L1 : -(x - PI2_L1));
172 + return ((hx >= 0) ? x - PI2_L1 : -(x - PI2_L1));
154 173 }
174 +
155 175 z = x * x;
176 +
156 177 if (((ix - 0x40192000) >> 10) == 0) {
157 178 /* |x-2pi|<2**-8 */
158 179 w = (z * x) * (PP1 + z * PP2) - PI2_L;
159 180 } else {
160 - w = (z * x) * ((P1 + z * P2) +
161 - (z * z) * (P3 + z * P4)) - PI2_L;
181 + w = (z * x) * ((P1 + z * P2) + (z * z) * (P3 +
182 + z * P4)) - PI2_L;
162 183 }
163 - return ((hx >= 0)? p + w : -p - w);
184 +
185 + return ((hx >= 0) ? p + w : -p - w);
164 186 }
187 +
165 188 j <<= 1;
166 - w = _TBL_sincos[j+1];
189 + w = _TBL_sincos[j + 1];
167 190 z = _TBL_sincos[j];
168 191 p = v + (v * s) * (PP1 + s * PP2);
169 192 q = s * (QQ1 + s * QQ2);
170 193 v = w * p + z * q;
171 - return ((hx >= 0)? z + v : -z - v);
194 + return ((hx >= 0) ? z + v : -z - v);
172 195 }
173 196
174 - if (ix >= 0x7ff00000) /* sin(Inf or NaN) is NaN */
197 + if (ix >= 0x7ff00000) /* sin(Inf or NaN) is NaN */
175 198 return (x / x);
176 199
177 200 /* argument reduction needed */
178 201 n = __rem_pio2(x, y);
202 +
179 203 switch (n & 3) {
180 204 case 0:
181 205 return (__k_sin(y[0], y[1]));
182 206 case 1:
183 207 return (__k_cos(y[0], y[1]));
184 208 case 2:
185 209 return (-__k_sin(y[0], y[1]));
186 210 default:
187 211 return (-__k_cos(y[0], y[1]));
188 212 }
189 213 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX