Print this page
5261 libm should stop using synonyms.h
| 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
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 *
|
↓ open down ↓ |
18 lines elided |
↑ open up ↑ |
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
23 23 */
24 24 /*
25 25 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
26 26 * Use is subject to license terms.
27 27 */
28 28
29 -#pragma weak sin = __sin
29 +#pragma weak __sin = sin
30 30
31 31 /* INDENT OFF */
32 32 /*
33 33 * sin(x)
34 34 * Accurate Table look-up algorithm by K.C. Ng, May, 1995.
35 35 *
36 36 * Algorithm: see sincos.c
37 37 */
38 38
39 39 #include "libm.h"
40 40
41 41 static const double sc[] = {
42 42 /* ONE = */ 1.0,
43 43 /* NONE = */ -1.0,
44 44 /*
45 45 * |sin(x) - (x+pp1*x^3+pp2*x^5)| <= 2^-58.79 for |x| < 0.008
46 46 */
47 47 /* PP1 = */ -0.166666666666316558867252052378889521480627858683055567,
48 48 /* PP2 = */ .008333315652997472323564894248466758248475374977974017927,
49 49 /*
50 50 * |(sin(x) - (x+p1*x^3+...+p4*x^9)|
51 51 * |------------------------------ | <= 2^-57.63 for |x| < 0.1953125
52 52 * | x |
53 53 */
54 54 /* P1 = */ -1.666666666666629669805215138920301589656e-0001,
55 55 /* P2 = */ 8.333333332390951295683993455280336376663e-0003,
56 56 /* P3 = */ -1.984126237997976692791551778230098403960e-0004,
57 57 /* P4 = */ 2.753403624854277237649987622848330351110e-0006,
58 58 /*
59 59 * |cos(x) - (1+qq1*x^2+qq2*x^4)| <= 2^-55.99 for |x| <= 0.008 (0x3f80624d)
60 60 */
61 61 /* QQ1 = */ -0.4999999999975492381842911981948418542742729,
62 62 /* QQ2 = */ 0.041666542904352059294545209158357640398771740,
63 63 /* PI_H = */ 3.1415926535897931159979634685,
64 64 /* PI_L = */ 1.22464679914735317722606593227425e-16,
65 65 /* PI_L0 = */ 1.22464679914558443311283879205095e-16,
66 66 /* PI_L1 = */ 1.768744113227140223300005233735517376e-28,
67 67 /* PI2_H = */ 6.2831853071795862319959269370,
68 68 /* PI2_L = */ 2.44929359829470635445213186454850e-16,
69 69 /* PI2_L0 = */ 2.44929359829116886622567758410190e-16,
70 70 /* PI2_L1 = */ 3.537488226454280446600010467471034752e-28,
71 71 };
72 72 /* INDENT ON */
73 73
74 74 #define ONEA sc
75 75 #define ONE sc[0]
76 76 #define NONE sc[1]
77 77 #define PP1 sc[2]
78 78 #define PP2 sc[3]
79 79 #define P1 sc[4]
80 80 #define P2 sc[5]
81 81 #define P3 sc[6]
82 82 #define P4 sc[7]
83 83 #define QQ1 sc[8]
84 84 #define QQ2 sc[9]
85 85 #define PI_H sc[10]
86 86 #define PI_L sc[11]
87 87 #define PI_L0 sc[12]
88 88 #define PI_L1 sc[13]
89 89 #define PI2_H sc[14]
90 90 #define PI2_L sc[15]
91 91 #define PI2_L0 sc[16]
92 92 #define PI2_L1 sc[17]
93 93
94 94 extern const double _TBL_sincos[], _TBL_sincosx[];
95 95
96 96 double
97 97 sin(double x) {
98 98 double z, y[2], w, s, v, p, q;
99 99 int i, j, n, hx, ix, lx;
100 100
101 101 hx = ((int *)&x)[HIWORD];
102 102 lx = ((int *)&x)[LOWORD];
103 103 ix = hx & ~0x80000000;
104 104
105 105 if (ix <= 0x3fc50000) { /* |x| < .1640625 */
106 106 if (ix < 0x3e400000) /* |x| < 2**-27 */
107 107 if ((int)x == 0)
108 108 return (x);
109 109 z = x * x;
110 110 if (ix < 0x3f800000) /* |x| < 2**-8 */
111 111 w = (z * x) * (PP1 + z * PP2);
112 112 else
113 113 w = (x * z) * ((P1 + z * P2) + (z * z) * (P3 + z * P4));
114 114 return (x + w);
115 115 }
116 116
117 117 /* for .1640625 < x < M, */
118 118 n = ix >> 20;
119 119 if (n < 0x402) { /* x < 8 */
120 120 i = (((ix >> 12) & 0xff) | 0x100) >> (0x401 - n);
121 121 j = i - 10;
122 122 x = fabs(x);
123 123 v = x - _TBL_sincosx[j];
124 124 if (((j - 181) ^ (j - 201)) < 0) {
125 125 /* near pi, sin(x) = sin(pi-x) */
126 126 p = PI_H - x;
127 127 i = ix - 0x400921fb;
128 128 x = p + PI_L;
129 129 if ((i | ((lx - 0x54442D00) & 0xffffff00)) == 0) {
130 130 /* very close to pi */
131 131 x = p + PI_L0;
132 132 return ((hx >= 0)? x + PI_L1 : -(x + PI_L1));
133 133 }
134 134 z = x * x;
135 135 if (((ix - 0x40092000) >> 11) == 0) {
136 136 /* |pi-x|<2**-8 */
137 137 w = PI_L + (z * x) * (PP1 + z * PP2);
138 138 } else {
139 139 w = PI_L + (z * x) * ((P1 + z * P2) +
140 140 (z * z) * (P3 + z * P4));
141 141 }
142 142 return ((hx >= 0)? p + w : -p - w);
143 143 }
144 144 s = v * v;
145 145 if (((j - 382) ^ (j - 402)) < 0) {
146 146 /* near 2pi, sin(x) = sin(x-2pi) */
147 147 p = x - PI2_H;
148 148 i = ix - 0x401921fb;
149 149 x = p - PI2_L;
150 150 if ((i | ((lx - 0x54442D00) & 0xffffff00)) == 0) {
151 151 /* very close to 2pi */
152 152 x = p - PI2_L0;
153 153 return ((hx >= 0)? x - PI2_L1 : -(x - PI2_L1));
154 154 }
155 155 z = x * x;
156 156 if (((ix - 0x40192000) >> 10) == 0) {
157 157 /* |x-2pi|<2**-8 */
158 158 w = (z * x) * (PP1 + z * PP2) - PI2_L;
159 159 } else {
160 160 w = (z * x) * ((P1 + z * P2) +
161 161 (z * z) * (P3 + z * P4)) - PI2_L;
162 162 }
163 163 return ((hx >= 0)? p + w : -p - w);
164 164 }
165 165 j <<= 1;
166 166 w = _TBL_sincos[j+1];
167 167 z = _TBL_sincos[j];
168 168 p = v + (v * s) * (PP1 + s * PP2);
169 169 q = s * (QQ1 + s * QQ2);
170 170 v = w * p + z * q;
171 171 return ((hx >= 0)? z + v : -z - v);
172 172 }
173 173
174 174 if (ix >= 0x7ff00000) /* sin(Inf or NaN) is NaN */
175 175 return (x / x);
176 176
177 177 /* argument reduction needed */
178 178 n = __rem_pio2(x, y);
179 179 switch (n & 3) {
180 180 case 0:
181 181 return (__k_sin(y[0], y[1]));
182 182 case 1:
183 183 return (__k_cos(y[0], y[1]));
184 184 case 2:
185 185 return (-__k_sin(y[0], y[1]));
186 186 default:
187 187 return (-__k_cos(y[0], y[1]));
188 188 }
189 189 }
|
↓ open down ↓ |
150 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX