| test-csqrt.c (177763) | test-csqrt.c (251241) |
|---|---|
| 1/*- 2 * Copyright (c) 2007 David Schultz <das@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright --- 15 unchanged lines hidden (view full) --- 24 * SUCH DAMAGE. 25 */ 26 27/* 28 * Tests for csqrt{,f}() 29 */ 30 31#include <sys/cdefs.h> | 1/*- 2 * Copyright (c) 2007 David Schultz <das@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright --- 15 unchanged lines hidden (view full) --- 24 * SUCH DAMAGE. 25 */ 26 27/* 28 * Tests for csqrt{,f}() 29 */ 30 31#include <sys/cdefs.h> |
| 32__FBSDID("$FreeBSD: head/tools/regression/lib/msun/test-csqrt.c 177763 2008-03-30 20:09:51Z das $"); | 32__FBSDID("$FreeBSD: head/tools/regression/lib/msun/test-csqrt.c 251241 2013-06-02 04:30:03Z das $"); |
| 33 34#include <assert.h> 35#include <complex.h> 36#include <float.h> 37#include <math.h> 38#include <stdio.h> 39 | 33 34#include <assert.h> 35#include <complex.h> 36#include <float.h> 37#include <math.h> 38#include <stdio.h> 39 |
| 40#include "test-utils.h" 41 |
|
| 40#define N(i) (sizeof(i) / sizeof((i)[0])) 41 42/* 43 * This is a test hook that can point to csqrtl(), _csqrt(), or to _csqrtf(). 44 * The latter two convert to float or double, respectively, and test csqrtf() 45 * and csqrt() with the same arguments. 46 */ 47long double complex (*t_csqrt)(long double complex); --- 10 unchanged lines hidden (view full) --- 58{ 59 60 return (csqrt((double complex)d)); 61} 62 63#pragma STDC CX_LIMITED_RANGE off 64 65/* | 42#define N(i) (sizeof(i) / sizeof((i)[0])) 43 44/* 45 * This is a test hook that can point to csqrtl(), _csqrt(), or to _csqrtf(). 46 * The latter two convert to float or double, respectively, and test csqrtf() 47 * and csqrt() with the same arguments. 48 */ 49long double complex (*t_csqrt)(long double complex); --- 10 unchanged lines hidden (view full) --- 60{ 61 62 return (csqrt((double complex)d)); 63} 64 65#pragma STDC CX_LIMITED_RANGE off 66 67/* |
| 66 * XXX gcc implements complex multiplication incorrectly. In 67 * particular, it implements it as if the CX_LIMITED_RANGE pragma 68 * were ON. Consequently, we need this function to form numbers 69 * such as x + INFINITY * I, since gcc evalutes INFINITY * I as 70 * NaN + INFINITY * I. 71 */ 72static inline long double complex 73cpackl(long double x, long double y) 74{ 75 long double complex z; 76 77 __real__ z = x; 78 __imag__ z = y; 79 return (z); 80} 81 82/* | |
| 83 * Compare d1 and d2 using special rules: NaN == NaN and +0 != -0. 84 * Fail an assertion if they differ. 85 */ 86static void 87assert_equal(long double complex d1, long double complex d2) 88{ 89 | 68 * Compare d1 and d2 using special rules: NaN == NaN and +0 != -0. 69 * Fail an assertion if they differ. 70 */ 71static void 72assert_equal(long double complex d1, long double complex d2) 73{ 74 |
| 90 if (isnan(creall(d1))) { 91 assert(isnan(creall(d2))); 92 } else { 93 assert(creall(d1) == creall(d2)); 94 assert(copysignl(1.0, creall(d1)) == 95 copysignl(1.0, creall(d2))); 96 } 97 if (isnan(cimagl(d1))) { 98 assert(isnan(cimagl(d2))); 99 } else { 100 assert(cimagl(d1) == cimagl(d2)); 101 assert(copysignl(1.0, cimagl(d1)) == 102 copysignl(1.0, cimagl(d2))); 103 } | 75 assert(cfpequal(d1, d2)); |
| 104} 105 106/* 107 * Test csqrt for some finite arguments where the answer is exact. 108 * (We do not test if it produces correctly rounded answers when the 109 * result is inexact, nor do we check whether it throws spurious 110 * exceptions.) 111 */ --- 44 unchanged lines hidden (view full) --- 156 int i, j; 157 158 for (i = 0; i < N(tests); i += 4) { 159 for (j = 0; j < N(mults); j++) { 160 a = tests[i] * mults[j] * mults[j]; 161 b = tests[i + 1] * mults[j] * mults[j]; 162 x = tests[i + 2] * mults[j]; 163 y = tests[i + 3] * mults[j]; | 76} 77 78/* 79 * Test csqrt for some finite arguments where the answer is exact. 80 * (We do not test if it produces correctly rounded answers when the 81 * result is inexact, nor do we check whether it throws spurious 82 * exceptions.) 83 */ --- 44 unchanged lines hidden (view full) --- 128 int i, j; 129 130 for (i = 0; i < N(tests); i += 4) { 131 for (j = 0; j < N(mults); j++) { 132 a = tests[i] * mults[j] * mults[j]; 133 b = tests[i + 1] * mults[j] * mults[j]; 134 x = tests[i + 2] * mults[j]; 135 y = tests[i + 3] * mults[j]; |
| 164 assert(t_csqrt(cpackl(a, b)) == cpackl(x, y)); | 136 assert(t_csqrt(CMPLXL(a, b)) == CMPLXL(x, y)); |
| 165 } 166 } 167 168} 169 170/* 171 * Test the handling of +/- 0. 172 */ 173static void 174test_zeros() 175{ 176 | 137 } 138 } 139 140} 141 142/* 143 * Test the handling of +/- 0. 144 */ 145static void 146test_zeros() 147{ 148 |
| 177 assert_equal(t_csqrt(cpackl(0.0, 0.0)), cpackl(0.0, 0.0)); 178 assert_equal(t_csqrt(cpackl(-0.0, 0.0)), cpackl(0.0, 0.0)); 179 assert_equal(t_csqrt(cpackl(0.0, -0.0)), cpackl(0.0, -0.0)); 180 assert_equal(t_csqrt(cpackl(-0.0, -0.0)), cpackl(0.0, -0.0)); | 149 assert_equal(t_csqrt(CMPLXL(0.0, 0.0)), CMPLXL(0.0, 0.0)); 150 assert_equal(t_csqrt(CMPLXL(-0.0, 0.0)), CMPLXL(0.0, 0.0)); 151 assert_equal(t_csqrt(CMPLXL(0.0, -0.0)), CMPLXL(0.0, -0.0)); 152 assert_equal(t_csqrt(CMPLXL(-0.0, -0.0)), CMPLXL(0.0, -0.0)); |
| 181} 182 183/* 184 * Test the handling of infinities when the other argument is not NaN. 185 */ 186static void 187test_infinities() 188{ --- 5 unchanged lines hidden (view full) --- 194 INFINITY, 195 -INFINITY, 196 }; 197 198 int i; 199 200 for (i = 0; i < N(vals); i++) { 201 if (isfinite(vals[i])) { | 153} 154 155/* 156 * Test the handling of infinities when the other argument is not NaN. 157 */ 158static void 159test_infinities() 160{ --- 5 unchanged lines hidden (view full) --- 166 INFINITY, 167 -INFINITY, 168 }; 169 170 int i; 171 172 for (i = 0; i < N(vals); i++) { 173 if (isfinite(vals[i])) { |
| 202 assert_equal(t_csqrt(cpackl(-INFINITY, vals[i])), 203 cpackl(0.0, copysignl(INFINITY, vals[i]))); 204 assert_equal(t_csqrt(cpackl(INFINITY, vals[i])), 205 cpackl(INFINITY, copysignl(0.0, vals[i]))); | 174 assert_equal(t_csqrt(CMPLXL(-INFINITY, vals[i])), 175 CMPLXL(0.0, copysignl(INFINITY, vals[i]))); 176 assert_equal(t_csqrt(CMPLXL(INFINITY, vals[i])), 177 CMPLXL(INFINITY, copysignl(0.0, vals[i]))); |
| 206 } | 178 } |
| 207 assert_equal(t_csqrt(cpackl(vals[i], INFINITY)), 208 cpackl(INFINITY, INFINITY)); 209 assert_equal(t_csqrt(cpackl(vals[i], -INFINITY)), 210 cpackl(INFINITY, -INFINITY)); | 179 assert_equal(t_csqrt(CMPLXL(vals[i], INFINITY)), 180 CMPLXL(INFINITY, INFINITY)); 181 assert_equal(t_csqrt(CMPLXL(vals[i], -INFINITY)), 182 CMPLXL(INFINITY, -INFINITY)); |
| 211 } 212} 213 214/* 215 * Test the handling of NaNs. 216 */ 217static void 218test_nans() 219{ 220 | 183 } 184} 185 186/* 187 * Test the handling of NaNs. 188 */ 189static void 190test_nans() 191{ 192 |
| 221 assert(creall(t_csqrt(cpackl(INFINITY, NAN))) == INFINITY); 222 assert(isnan(cimagl(t_csqrt(cpackl(INFINITY, NAN))))); | 193 assert(creall(t_csqrt(CMPLXL(INFINITY, NAN))) == INFINITY); 194 assert(isnan(cimagl(t_csqrt(CMPLXL(INFINITY, NAN))))); |
| 223 | 195 |
| 224 assert(isnan(creall(t_csqrt(cpackl(-INFINITY, NAN))))); 225 assert(isinf(cimagl(t_csqrt(cpackl(-INFINITY, NAN))))); | 196 assert(isnan(creall(t_csqrt(CMPLXL(-INFINITY, NAN))))); 197 assert(isinf(cimagl(t_csqrt(CMPLXL(-INFINITY, NAN))))); |
| 226 | 198 |
| 227 assert_equal(t_csqrt(cpackl(NAN, INFINITY)), 228 cpackl(INFINITY, INFINITY)); 229 assert_equal(t_csqrt(cpackl(NAN, -INFINITY)), 230 cpackl(INFINITY, -INFINITY)); | 199 assert_equal(t_csqrt(CMPLXL(NAN, INFINITY)), 200 CMPLXL(INFINITY, INFINITY)); 201 assert_equal(t_csqrt(CMPLXL(NAN, -INFINITY)), 202 CMPLXL(INFINITY, -INFINITY)); |
| 231 | 203 |
| 232 assert_equal(t_csqrt(cpackl(0.0, NAN)), cpackl(NAN, NAN)); 233 assert_equal(t_csqrt(cpackl(-0.0, NAN)), cpackl(NAN, NAN)); 234 assert_equal(t_csqrt(cpackl(42.0, NAN)), cpackl(NAN, NAN)); 235 assert_equal(t_csqrt(cpackl(-42.0, NAN)), cpackl(NAN, NAN)); 236 assert_equal(t_csqrt(cpackl(NAN, 0.0)), cpackl(NAN, NAN)); 237 assert_equal(t_csqrt(cpackl(NAN, -0.0)), cpackl(NAN, NAN)); 238 assert_equal(t_csqrt(cpackl(NAN, 42.0)), cpackl(NAN, NAN)); 239 assert_equal(t_csqrt(cpackl(NAN, -42.0)), cpackl(NAN, NAN)); 240 assert_equal(t_csqrt(cpackl(NAN, NAN)), cpackl(NAN, NAN)); | 204 assert_equal(t_csqrt(CMPLXL(0.0, NAN)), CMPLXL(NAN, NAN)); 205 assert_equal(t_csqrt(CMPLXL(-0.0, NAN)), CMPLXL(NAN, NAN)); 206 assert_equal(t_csqrt(CMPLXL(42.0, NAN)), CMPLXL(NAN, NAN)); 207 assert_equal(t_csqrt(CMPLXL(-42.0, NAN)), CMPLXL(NAN, NAN)); 208 assert_equal(t_csqrt(CMPLXL(NAN, 0.0)), CMPLXL(NAN, NAN)); 209 assert_equal(t_csqrt(CMPLXL(NAN, -0.0)), CMPLXL(NAN, NAN)); 210 assert_equal(t_csqrt(CMPLXL(NAN, 42.0)), CMPLXL(NAN, NAN)); 211 assert_equal(t_csqrt(CMPLXL(NAN, -42.0)), CMPLXL(NAN, NAN)); 212 assert_equal(t_csqrt(CMPLXL(NAN, NAN)), CMPLXL(NAN, NAN)); |
| 241} 242 243/* 244 * Test whether csqrt(a + bi) works for inputs that are large enough to 245 * cause overflow in hypot(a, b) + a. In this case we are using 246 * csqrt(115 + 252*I) == 14 + 9*I 247 * scaled up to near MAX_EXP. 248 */ 249static void 250test_overflow(int maxexp) 251{ 252 long double a, b; 253 long double complex result; 254 255 a = ldexpl(115 * 0x1p-8, maxexp); 256 b = ldexpl(252 * 0x1p-8, maxexp); | 213} 214 215/* 216 * Test whether csqrt(a + bi) works for inputs that are large enough to 217 * cause overflow in hypot(a, b) + a. In this case we are using 218 * csqrt(115 + 252*I) == 14 + 9*I 219 * scaled up to near MAX_EXP. 220 */ 221static void 222test_overflow(int maxexp) 223{ 224 long double a, b; 225 long double complex result; 226 227 a = ldexpl(115 * 0x1p-8, maxexp); 228 b = ldexpl(252 * 0x1p-8, maxexp); |
| 257 result = t_csqrt(cpackl(a, b)); | 229 result = t_csqrt(CMPLXL(a, b)); |
| 258 assert(creall(result) == ldexpl(14 * 0x1p-4, maxexp / 2)); 259 assert(cimagl(result) == ldexpl(9 * 0x1p-4, maxexp / 2)); 260} 261 262int 263main(int argc, char *argv[]) 264{ 265 --- 58 unchanged lines hidden --- | 230 assert(creall(result) == ldexpl(14 * 0x1p-4, maxexp / 2)); 231 assert(cimagl(result) == ldexpl(9 * 0x1p-4, maxexp / 2)); 232} 233 234int 235main(int argc, char *argv[]) 236{ 237 --- 58 unchanged lines hidden --- |