Print this page
11210 libm should be cstyle(1ONBLD) clean
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libm/common/complex/csqrtl.c
+++ new/usr/src/lib/libm/common/complex/csqrtl.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.
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
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 23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
24 24 */
25 +
25 26 /*
26 27 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
27 28 * Use is subject to license terms.
28 29 */
29 30
30 31 #pragma weak __csqrtl = csqrtl
31 32
32 -#include "libm.h" /* fabsl/isinfl/sqrtl */
33 +#include "libm.h" /* fabsl/isinfl/sqrtl */
33 34 #include "complex_wrapper.h"
34 35 #include "longdouble.h"
35 36
36 -/* INDENT OFF */
37 37 static const long double
38 38 twom9001 = 2.6854002716003034957421765100615693043656e-2710L,
39 39 twom4500 = 2.3174987687592429423263242862381544149252e-1355L,
40 40 two8999 = 9.3095991180122343502582347372163290310934e+2708L,
41 41 two4500 = 4.3149968987270974283777803545571722250806e+1354L,
42 42 zero = 0.0L,
43 43 half = 0.5L,
44 44 two = 2.0L;
45 -/* INDENT ON */
45 +
46 46
47 47 ldcomplex
48 -csqrtl(ldcomplex z) {
48 +csqrtl(ldcomplex z)
49 +{
49 50 ldcomplex ans;
50 51 long double x, y, t, ax, ay;
51 52 int n, ix, iy, hx, hy;
52 53
53 54 x = LD_RE(z);
54 55 y = LD_IM(z);
55 56 hx = HI_XWORD(x);
56 57 hy = HI_XWORD(y);
57 58 ix = hx & 0x7fffffff;
58 59 iy = hy & 0x7fffffff;
59 60 ay = fabsl(y);
60 61 ax = fabsl(x);
62 +
61 63 if (ix >= 0x7fff0000 || iy >= 0x7fff0000) {
62 64 /* x or y is Inf or NaN */
63 - if (isinfl(y))
65 + if (isinfl(y)) {
64 66 LD_IM(ans) = LD_RE(ans) = ay;
65 - else if (isinfl(x)) {
67 + } else if (isinfl(x)) {
66 68 if (hx > 0) {
67 69 LD_RE(ans) = ax;
68 70 LD_IM(ans) = ay * zero;
69 71 } else {
70 72 LD_RE(ans) = ay * zero;
71 73 LD_IM(ans) = ax;
72 74 }
73 - } else
75 + } else {
74 76 LD_IM(ans) = LD_RE(ans) = ax + ay;
77 + }
75 78 } else if (y == zero) {
76 79 if (hx >= 0) {
77 80 LD_RE(ans) = sqrtl(ax);
78 81 LD_IM(ans) = zero;
79 82 } else {
80 83 LD_IM(ans) = sqrtl(ax);
81 84 LD_RE(ans) = zero;
82 85 }
83 86 } else if (ix >= iy) {
84 87 n = (ix - iy) >> 16;
85 -#if defined(__x86) /* 64 significant bits */
88 +#if defined(__x86) /* 64 significant bits */
86 89 if (n >= 35)
87 -#else /* 113 significant bits */
90 +#else /* 113 significant bits */
88 91 if (n >= 60)
89 92 #endif
93 + {
90 94 t = sqrtl(ax);
91 - else if (ix >= 0x5f3f0000) { /* x > 2**8000 */
95 + } else if (ix >= 0x5f3f0000) { /* x > 2**8000 */
92 96 ax *= twom9001;
93 97 y *= twom9001;
94 98 t = two4500 * sqrtl(ax + sqrtl(ax * ax + y * y));
95 99 } else if (iy <= 0x20bf0000) { /* y < 2**-8000 */
96 100 ax *= two8999;
97 101 y *= two8999;
98 102 t = twom4500 * sqrtl(ax + sqrtl(ax * ax + y * y));
99 - } else
103 + } else {
100 104 t = sqrtl(half * (ax + sqrtl(ax * ax + y * y)));
105 + }
101 106
102 107 if (hx >= 0) {
103 108 LD_RE(ans) = t;
104 109 LD_IM(ans) = ay / (t + t);
105 110 } else {
106 111 LD_IM(ans) = t;
107 112 LD_RE(ans) = ay / (t + t);
108 113 }
109 114 } else {
110 115 n = (iy - ix) >> 16;
111 -#if defined(__x86) /* 64 significant bits */
112 - if (n >= 35) { /* } */
113 -#else /* 113 significant bits */
116 +#if defined(__x86) /* 64 significant bits */
117 + if (n >= 35) { /* } */
118 +#else /* 113 significant bits */
114 119 if (n >= 60) {
115 120 #endif
121 +
116 122 if (n >= 120)
117 123 t = sqrtl(half * ay);
118 124 else if (iy >= 0x7ffe0000)
119 125 t = sqrtl(half * ay + half * ax);
120 126 else if (ix <= 0x00010000)
121 127 t = half * (sqrtl(two * (ax + ay)));
122 128 else
123 129 t = sqrtl(half * (ax + ay));
124 130 } else if (iy >= 0x5f3f0000) { /* y > 2**8000 */
125 131 ax *= twom9001;
126 132 y *= twom9001;
127 133 t = two4500 * sqrtl(ax + sqrtl(ax * ax + y * y));
128 134 } else if (ix <= 0x20bf0000) {
129 135 ax *= two8999;
130 136 y *= two8999;
131 137 t = twom4500 * sqrtl(ax + sqrtl(ax * ax + y * y));
132 - } else
138 + } else {
133 139 t = sqrtl(half * (ax + sqrtl(ax * ax + y * y)));
140 + }
134 141
135 142 if (hx >= 0) {
136 143 LD_RE(ans) = t;
137 144 LD_IM(ans) = ay / (t + t);
138 145 } else {
139 146 LD_IM(ans) = t;
140 147 LD_RE(ans) = ay / (t + t);
141 148 }
142 149 }
150 +
143 151 if (hy < 0)
144 152 LD_IM(ans) = -LD_IM(ans);
153 +
145 154 return (ans);
146 155 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX