Print this page
5261 libm should stop using synonyms.h
5298 fabs is 0-sized, confuses dis(1) and others
Reviewed by: Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
Approved by: Gordon Ross <gwr@nexenta.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libm/common/complex/clog.c
+++ new/usr/src/lib/libm/common/complex/clog.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 *
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 29 #pragma weak clog = __clog
30 30
31 31 /* INDENT OFF */
32 32 /*
33 33 * dcomplex clog(dcomplex z);
34 34 *
35 35 * _________
36 36 * / 2 2 -1 y
37 37 * log(x+iy) = log(\/ x + y ) + i tan (---)
38 38 * x
39 39 *
40 40 * 1 2 2 -1 y
41 41 * = --- log(x + y ) + i tan (---)
42 42 * 2 x
43 43 *
44 44 * Note that the arctangent ranges from -PI to +PI, thus the imaginary
45 45 * part of clog is atan2(y,x).
46 46 *
47 47 * EXCEPTION CASES (conform to ISO/IEC 9899:1999(E)):
48 48 * clog(-0 + i 0 ) = -inf + i pi
49 49 * clog( 0 + i 0 ) = -inf + i 0
50 50 * clog( x + i inf ) = -inf + i pi/2, for finite x
51 51 * clog( x + i NaN ) = NaN + i NaN with invalid for finite x
52 52 * clog(-inf + iy )= +inf + i pi, for finite positive-signed y
|
↓ open down ↓ |
52 lines elided |
↑ open up ↑ |
53 53 * clog(+inf + iy )= +inf + i 0 , for finite positive-signed y
54 54 * clog(-inf + i inf)= inf + i 3pi/4
55 55 * clog(+inf + i inf)= inf + i pi/4
56 56 * clog(+-inf+ i NaN)= inf + i NaN
57 57 * clog(NaN + i y )= NaN + i NaN for finite y
58 58 * clog(NaN + i inf)= inf + i NaN
59 59 * clog(NaN + i NaN)= NaN + i NaN
60 60 */
61 61 /* INDENT ON */
62 62
63 -#include "libm_synonyms.h"
64 63 #include <math.h> /* atan2/fabs/log/log1p */
65 64 #include "complex_wrapper.h"
66 65 #include "libm_protos.h" /* __k_clog_r */
67 66
68 67
69 68 static const double half = 0.5, one = 1.0;
70 69
71 70 dcomplex
72 -clog(dcomplex z) {
71 +__clog(dcomplex z) {
73 72 dcomplex ans;
74 73 double x, y, t, ax, ay, w;
75 74 int n, ix, iy, hx, hy;
76 75 unsigned lx, ly;
77 76
78 77 x = D_RE(z);
79 78 y = D_IM(z);
80 79 hx = HI_WORD(x);
81 80 lx = LO_WORD(x);
82 81 hy = HI_WORD(y);
83 82 ly = LO_WORD(y);
84 83 ix = hx & 0x7fffffff;
85 84 iy = hy & 0x7fffffff;
86 85 ay = fabs(y);
87 86 ax = fabs(x);
88 87 D_IM(ans) = carg(z);
89 88 if (ix < iy || (ix == iy && lx < ly)) {
90 89 /* swap x and y to force ax >= ay */
91 90 t = ax;
92 91 ax = ay;
93 92 ay = t;
94 93 n = ix, ix = iy;
95 94 iy = n;
96 95 n = lx, lx = ly;
97 96 ly = n;
98 97 }
99 98 n = (ix - iy) >> 20;
100 99 if (ix >= 0x7ff00000) { /* x or y is Inf or NaN */
101 100 if (ISINF(ix, lx))
102 101 D_RE(ans) = ax;
103 102 else if (ISINF(iy, ly))
104 103 D_RE(ans) = ay;
105 104 else
106 105 D_RE(ans) = ax * ay;
107 106 } else if ((iy | ly) == 0) {
108 107 D_RE(ans) = ((ix | lx) == 0)? -one / ax : log(ax);
109 108 } else if (((0x3fffffff - ix) ^ (ix - 0x3fe00000)) >= 0) {
110 109 /* 0.5 <= x < 2 */
111 110 if (ix >= 0x3ff00000) {
112 111 if (((ix - 0x3ff00000) | lx) == 0)
113 112 D_RE(ans) = half * log1p(ay * ay);
114 113 else if (n >= 60)
115 114 D_RE(ans) = log(ax);
116 115 else
117 116 D_RE(ans) = half * (log1p(ay * ay + (ax -
118 117 one) * (ax + one)));
119 118 } else if (n >= 60) {
120 119 D_RE(ans) = log(ax);
121 120 } else {
122 121 D_RE(ans) = __k_clog_r(ax, ay, &w);
123 122 }
124 123 } else if (n >= 30) {
125 124 D_RE(ans) = log(ax);
126 125 } else if (ix < 0x5f300000 && iy >= 0x20b00000) {
127 126 /* 2**-500< y < x < 2**500 */
128 127 D_RE(ans) = half * log(ax * ax + ay * ay);
129 128 } else {
130 129 t = ay / ax;
131 130 D_RE(ans) = log(ax) + half * log1p(t * t);
132 131 }
133 132 return (ans);
134 133 }
|
↓ open down ↓ |
52 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX