github.com/Konstantin8105/c4go@v0.0.0-20240505174241-768bb1c65a51/tests/math.c (about) 1 // Test for math.h. 2 3 #include "tests.h" 4 #include <float.h> 5 #include <math.h> 6 #include <stdio.h> 7 8 #define PI 3.14159265 9 #define IS_NAN -2147483648 10 11 unsigned long long ullmax = 18446744073709551615ull; 12 13 int main() 14 { 15 plan(465);//496); 16 17 18 { 19 diag("modf"); 20 double param, fractpart, intpart; 21 param = 3.14159265; 22 fractpart = modf(param, &intpart); 23 printf("%f = %f + %f \n", param, intpart, fractpart); 24 } 25 26 double w1 = 100; 27 double w2 = 2; 28 double x1 = 3; 29 double x2 = 4; 30 double Ln = 2; 31 double R1o; 32 R1o = ((2.0 * w1 + w2) * x1 * x1 - (w1 + 2.0 * w2) * x2 * x2 + 3.0 * (w1 + w2) * Ln * (x2 - x1) - (w1 - w2) * x1 * x2) / (6.0 * Ln); 33 is_eq(R1o, -34.16666666666666429819088); 34 35 double f01; 36 f01 = (3.0 * (w2 + 4.0 * w1) * x1 * x1 * x1 * x1 - 3.0 * (w1 + 4.0 * w2) * x2 * x2 * x2 * x2 37 - 15.0 * (w2 + 3.0 * w1) * Ln * x1 * x1 * x1 + 15.0 * (w1 + 3.0 * w2) * Ln * x2 * x2 * x2 38 - 3.0 * (w1 - w2) * x1 * x2 * (x1 * x1 + x2 * x2) 39 + 20.0 * (w2 + 2.0 * w1) * Ln * Ln * x1 * x1 - 20.0 * (w1 + 2.0 * w2) * Ln * Ln * x2 * x2 40 + 15.0 * (w1 - w2) * Ln * x1 * x2 * (x1 + x2) 41 - 3.0 * (w1 - w2) * x1 * x1 * x2 * x2 - 20.0 * (w1 - w2) * Ln * Ln * x1 * x2) 42 / 360.0; 43 is_eq(f01, 23.07222222222222285381577); 44 45 diag("Sqrt function"); 46 double (*f)(double) = sqrt; 47 f = sqrt; 48 is_eq(f(4), sqrt(4)); 49 double (*f2)(double) = sqrt; 50 is_eq(f2(4), sqrt(4)); 51 52 // Note: There are some tests that must be disabled because they return 53 // different values under different compilers. See the comment surrounding the 54 // disabled() tests for more information. 55 56 // Test constants 57 diag("constants"); 58 is_eq(M_E, 2.71828182845904509080); 59 is_eq(M_LOG2E, 1.44269504088896338700); 60 is_eq(M_LOG10E, 0.43429448190325181667); 61 is_eq(M_LN2, 0.69314718055994528623); 62 is_eq(M_LN10, 2.30258509299404590109); 63 is_eq(M_PI, 3.14159265358979311600); 64 is_eq(M_PI_2, 1.57079632679489655800); 65 is_eq(M_PI_4, 0.78539816339744827900); 66 is_eq(M_1_PI, 0.31830988618379069122); 67 is_eq(M_2_PI, 0.63661977236758138243); 68 is_eq(M_2_SQRTPI, 1.12837916709551255856); 69 is_eq(M_SQRT2, 1.41421356237309514547); 70 is_eq(M_SQRT1_2, 0.70710678118654757274); 71 72 // Each of the tests are against these values: 73 // 74 // * Simple: 0, 1, -1, 0.5 75 // * Large and small: 1.23e300, -1.23e-300 76 // * Constants: M_PI, M_E 77 // * Special: INFINITY, -INFINITY, NAN 78 79 diag("acos"); 80 is_eq(acos(0), 1.57079632679489655800); 81 is_eq(acos(1), 0); 82 is_eq(acos(-1), M_PI); 83 is_eq(acos(0.5), 1.04719755119659763132); 84 // is_nan(acos(1.23e300)); 85 is_eq(acos(-1.23e-300), 1.57079632679489655800); 86 is_nan(acos(M_PI)); 87 is_nan(acos(M_E)); 88 is_nan(acos(INFINITY)); 89 is_nan(acos(-INFINITY)); 90 is_nan(acos(NAN)); 91 92 diag("asin"); 93 is_eq(asin(0), 0); 94 is_eq(asin(1), 1.57079632679489655800); 95 is_eq(asin(-1), -1.57079632679489655800); 96 is_eq(asin(0.5), 0.52359877559829881566); 97 // is_nan(asin(1.23e300)); 98 is_negzero(asin(-1.23e-300)); 99 is_nan(asin(M_PI)); 100 is_nan(asin(M_E)); 101 is_nan(asin(INFINITY)); 102 is_nan(asin(-INFINITY)); 103 is_nan(asin(NAN)); 104 105 diag("atan"); 106 is_eq(atan(0), 0); 107 is_eq(atan(1), 0.78539816339744827900); 108 is_eq(atan(-1), -0.78539816339744827900); 109 is_eq(atan(0.5), 0.46364760900080614903); 110 // is_eq(atan(1.23e300), 1.57079632679489655800); 111 is_negzero(atan(-1.23e-300)); 112 is_eq(atan(M_PI), 1.26262725567891154199); 113 is_eq(atan(M_E), 1.21828290501727765083); 114 is_eq(atan(INFINITY), 1.57079632679489655800); 115 is_eq(atan(-INFINITY), -1.57079632679489655800); 116 is_nan(atan(NAN)); 117 118 diag("atan2"); 119 120 // atan2(x, 0) 121 is_eq(atan2(0, 0), 0); 122 is_eq(atan2(1, 0), 1.57079632679489655800); 123 is_eq(atan2(-1, 0), -1.57079632679489655800); 124 is_eq(atan2(0.5, 0), 1.57079632679489655800); 125 // is_eq(atan2(1.23e300, 0), 1.57079632679489655800); 126 is_negzero(atan2(-1.23e-300, 0)); 127 is_eq(atan2(M_PI, 0), 1.57079632679489655800); 128 is_eq(atan2(M_E, 0), 1.57079632679489655800); 129 is_eq(atan2(INFINITY, 0), 1.57079632679489655800); 130 is_eq(atan2(-INFINITY, 0), -1.57079632679489655800); 131 is_nan(atan2(NAN, 0)); 132 133 // atan2(x, 1) 134 is_eq(atan2(0, 1), 0); 135 is_eq(atan2(1, 1), 0.78539816339744827900); 136 is_eq(atan2(-1, 1), -0.78539816339744827900); 137 is_eq(atan2(0.5, 1), 0.46364760900080609352); 138 // is_eq(atan2(1.23e300, 1), 1.57079632679489655800); 139 is_negzero(atan2(-1.23e-300, 1)); 140 is_eq(atan2(M_PI, 1), 1.262627255678911764); 141 is_eq(atan2(M_E, 1), 1.2182829050172776508); 142 is_eq(atan2(INFINITY, 1), 1.57079632679489655800); 143 is_eq(atan2(-INFINITY, 1), -1.57079632679489655800); 144 is_nan(atan2(NAN, 1)); 145 146 // atan2(x, INFINITY) 147 is_eq(atan2(0, INFINITY), 0); 148 is_eq(atan2(1, INFINITY), 0); 149 is_negzero(atan2(-1, INFINITY)); 150 is_eq(atan2(0.5, INFINITY), 0); 151 // is_eq(atan2(1.23e300, INFINITY), 0); 152 is_negzero(atan2(-1.23e-300, INFINITY)); 153 is_eq(atan2(M_PI, INFINITY), 0); 154 is_eq(atan2(M_E, INFINITY), 0); 155 is_eq(atan2(INFINITY, INFINITY), 0.78539816339744827900); 156 is_eq(atan2(-INFINITY, INFINITY), -0.78539816339744827900); 157 is_nan(atan2(NAN, INFINITY)); 158 159 // atan2(x, -INFINITY) 160 is_eq(atan2(0, -INFINITY), M_PI); 161 is_eq(atan2(1, -INFINITY), M_PI); 162 is_negzero(atan2(-1, -INFINITY)); 163 is_eq(atan2(0.5, -INFINITY), M_PI); 164 // is_eq(atan2(1.23e300, -INFINITY), M_PI); 165 is_negzero(atan2(-1.23e-300, -INFINITY)); 166 is_eq(atan2(M_PI, -INFINITY), M_PI); 167 is_eq(atan2(M_E, -INFINITY), M_PI); 168 is_eq(atan2(INFINITY, -INFINITY), 2.356194490192344837); 169 is_eq(atan2(-INFINITY, -INFINITY), -2.356194490192344837); 170 is_nan(atan2(NAN, -INFINITY)); 171 172 // atan2(x, NAN) 173 is_nan(atan2(0, NAN)); 174 is_nan(atan2(1, NAN)); 175 is_nan(atan2(-1, NAN)); 176 is_nan(atan2(0.5, NAN)); 177 // is_nan(atan2(1.23e300, NAN)); 178 is_nan(atan2(-1.23e-300, NAN)); 179 is_nan(atan2(M_PI, NAN)); 180 is_nan(atan2(M_E, NAN)); 181 is_nan(atan2(INFINITY, NAN)); 182 is_nan(atan2(-INFINITY, NAN)); 183 is_nan(atan2(NAN, NAN)); 184 185 diag("ceil"); 186 is_eq(ceil(0), 0); 187 is_eq(ceil(1), 1); 188 is_eq(ceil(-1), -1); 189 is_eq(ceil(0.5), 1); 190 // is_eq(ceil(1.23e300), 1.23e300); 191 is_eq(ceil(-1.23e-300), 0); 192 is_eq(ceil(M_PI), 4); 193 is_eq(ceil(M_E), 3); 194 is_inf(ceil(INFINITY), 1); 195 is_inf(ceil(-INFINITY), -1); 196 is_nan(ceil(NAN)); 197 198 diag("cos"); 199 is_eq(cos(0), 1); 200 is_eq(cos(1), 0.54030230586813976501); 201 is_eq(cos(-1), 0.54030230586813976501); 202 is_eq(cos(0.5), 0.87758256189037275874); 203 // https://github.com/golang/go/issues/20539 204 // disabled(is_eq(cos(1.23e300), 0.251533)); 205 is_eq(cos(-1.23e-300), 1); 206 is_eq(cos(M_PI), -1); 207 is_eq(cos(M_E), -0.91173391478696508283); 208 is_nan(cos(INFINITY)); 209 is_nan(cos(-INFINITY)); 210 is_nan(cos(NAN)); 211 212 diag("cosh"); 213 is_eq(cosh(0), 1); 214 is_eq(cosh(1), 1.5430806348152437124); 215 is_eq(cosh(-1), 1.5430806348152437124); 216 is_eq(cosh(0.5), 1.1276259652063806982); 217 // https://github.com/golang/go/issues/20539 218 // disabled(is_eq(cosh(1.23e300), 1)); 219 is_eq(cosh(-1.23e-300), 1); 220 is_eq(cosh(M_PI), 11.591953275521518663); 221 is_eq(cosh(M_E), 7.6101251386622870143); 222 is_inf(cosh(INFINITY), 1); 223 is_inf(cosh(-INFINITY), 1); 224 is_nan(cosh(NAN)); 225 226 diag("exp"); 227 is_eq(exp(0), 1); 228 is_eq(exp(1), 2.7182818284590450908); 229 is_eq(exp(-1), 0.36787944117144233402); 230 is_eq(exp(0.5), 1.6487212707001281942); 231 // https://github.com/golang/go/issues/20539 232 // disabled(is_inf(exp(1.23e300), 1)); 233 is_eq(exp(-1.23e-300), 1); 234 is_eq(exp(M_PI), 23.140692632779266802); 235 is_eq(exp(M_E), 15.154262241479262485); 236 is_inf(exp(INFINITY), 1); 237 is_eq(exp(-INFINITY), 0); 238 is_nan(exp(NAN)); 239 is_eq(expf(0.0f), 1.0f); 240 printf("expf : %10f\n", expf(+1.0f)); // TODO - check 241 printf("expf : %10f\n", expf(-1.0f)); // TODO - check 242 is_eq(expl(0), 1); 243 is_eq(expl(1), 2.7182818284590450908); 244 is_eq(expl(-1), 0.36787944117144233402); 245 246 247 248 diag("fabs"); 249 is_eq(fabs(0), 0); 250 is_eq(fabs(1), 1); 251 is_eq(fabs(-1), 1); 252 is_eq(fabs(0.5), 0.5); 253 // is_eq(fabs(1.23e300), 1.23e300); 254 is_eq(fabs(-1.23e-300), 1.23e-300); 255 is_eq(fabs(M_PI), M_PI); 256 is_eq(fabs(M_E), M_E); 257 is_inf(fabs(INFINITY), 1); 258 is_inf(fabs(-INFINITY), 1); 259 is_nan(fabs(NAN)); 260 261 diag("floor"); 262 is_eq(floor(0), 0); 263 is_eq(floor(1), 1); 264 is_eq(floor(-1), -1); 265 is_eq(floor(0.5), 0); 266 // is_eq(floor(1.23e300), 1.23e300); 267 is_eq(floor(-1.23e-300), -1); 268 is_eq(floor(M_PI), 3); 269 is_eq(floor(M_E), 2); 270 is_inf(floor(INFINITY), 1); 271 is_inf(floor(-INFINITY), -1); 272 is_nan(floor(NAN)); 273 274 diag("fmod"); 275 276 // fmod(x, 0) 277 is_nan(fmod(0, 0)); 278 is_nan(fmod(1, 0)); 279 is_nan(fmod(-1, 0)); 280 is_nan(fmod(0.5, 0)); 281 // is_nan(fmod(1.23e300, 0)); 282 is_nan(fmod(-1.23e-300, 0)); 283 is_nan(fmod(M_PI, 0)); 284 is_nan(fmod(M_E, 0)); 285 is_nan(fmod(INFINITY, 0)); 286 is_nan(fmod(-INFINITY, 0)); 287 is_nan(fmod(NAN, 0)); 288 289 // fmod(x, 0.5) 290 is_eq(fmod(0, 0.5), 0); 291 is_eq(fmod(1, 0.5), 0); 292 is_negzero(fmod(-1, 0.5)); 293 is_eq(fmod(0.5, 0.5), 0); 294 // is_eq(fmod(1.23e300, 0.5), 0); 295 is_negzero(fmod(-1.23e-300, 0.5)); 296 is_eq(fmod(M_PI, 0.5), M_PI - 3); 297 is_eq(fmod(M_E, 0.5), M_E - 2.5); 298 is_nan(fmod(INFINITY, 0.5)); 299 is_nan(fmod(-INFINITY, 0.5)); 300 is_nan(fmod(NAN, 0.5)); 301 302 // fmod(x, INFINITY) 303 is_eq(fmod(0, INFINITY), 0); 304 is_eq(fmod(1, INFINITY), 1); 305 is_negzero(fmod(-1, INFINITY)); 306 is_eq(fmod(0.5, INFINITY), 0.5); 307 // is_eq(fmod(1.23e300, INFINITY), 1.23e300); 308 is_negzero(fmod(-1.23e-300, INFINITY)); 309 is_eq(fmod(M_PI, INFINITY), M_PI); 310 is_eq(fmod(M_E, INFINITY), M_E); 311 is_nan(fmod(INFINITY, INFINITY)); 312 is_nan(fmod(-INFINITY, INFINITY)); 313 is_nan(fmod(NAN, INFINITY)); 314 315 // fmod(x, -INFINITY) 316 is_eq(fmod(0, -INFINITY), 0); 317 is_eq(fmod(1, -INFINITY), 1); 318 is_negzero(fmod(-1, -INFINITY)); 319 is_eq(fmod(0.5, -INFINITY), 0.5); 320 // is_eq(fmod(1.23e300, -INFINITY), 1.23e300); 321 is_negzero(fmod(-1.23e-300, -INFINITY)); 322 is_eq(fmod(M_PI, -INFINITY), M_PI); 323 is_eq(fmod(M_E, -INFINITY), M_E); 324 is_nan(fmod(INFINITY, -INFINITY)); 325 is_nan(fmod(-INFINITY, -INFINITY)); 326 is_nan(fmod(NAN, -INFINITY)); 327 328 // fmod(x, NAN) 329 is_nan(fmod(0, NAN)); 330 is_nan(fmod(1, NAN)); 331 is_nan(fmod(-1, NAN)); 332 is_nan(fmod(0.5, NAN)); 333 // is_nan(fmod(1.23e300, NAN)); 334 is_nan(fmod(-1.23e-300, NAN)); 335 is_nan(fmod(M_PI, NAN)); 336 is_nan(fmod(M_E, NAN)); 337 is_nan(fmod(INFINITY, NAN)); 338 is_nan(fmod(-INFINITY, NAN)); 339 is_nan(fmod(NAN, NAN)); 340 341 diag("remainder") 342 343 // remainder(x, 0) 344 is_nan(remainder(0, 0)); 345 is_nan(remainder(1, 0)); 346 is_nan(remainder(-1, 0)); 347 is_nan(remainder(0.5, 0)); 348 // is_nan(remainder(1.23e300, 0)); 349 is_nan(remainder(-1.23e-300, 0)); 350 is_nan(remainder(M_PI, 0)); 351 is_nan(remainder(M_E, 0)); 352 is_nan(remainder(INFINITY, 0)); 353 is_nan(remainder(-INFINITY, 0)); 354 is_nan(remainder(NAN, 0)); 355 356 // remainder(x, 0.5) 357 is_eq(remainder(0, 0.5), 0); 358 is_eq(remainder(1, 0.5), 0); 359 is_negzero(remainder(-1, 0.5)); 360 is_eq(remainder(0.5, 0.5), 0); 361 // is_eq(remainder(1.23e300, 0.5), 0); 362 is_negzero(remainder(-1.23e-300, 0.5)); 363 is_eq(remainder(M_PI, 0.5), M_PI - 3); 364 is_eq(remainder(M_E, 0.5), M_E - 2.5); 365 is_nan(remainder(INFINITY, 0.5)); 366 is_nan(remainder(-INFINITY, 0.5)); 367 is_nan(remainder(NAN, 0.5)); 368 369 // remainder(x, INFINITY) 370 is_eq(remainder(0, INFINITY), 0); 371 is_eq(remainder(1, INFINITY), 1); 372 is_negzero(remainder(-1, INFINITY)); 373 is_eq(remainder(0.5, INFINITY), 0.5); 374 // is_eq(remainder(1.23e300, INFINITY), 1.23e300); 375 is_negzero(remainder(-1.23e-300, INFINITY)); 376 is_eq(remainder(M_PI, INFINITY), M_PI); 377 is_eq(remainder(M_E, INFINITY), M_E); 378 is_nan(remainder(INFINITY, INFINITY)); 379 is_nan(remainder(-INFINITY, INFINITY)); 380 is_nan(remainder(NAN, INFINITY)); 381 382 // remainder(x, -INFINITY) 383 is_eq(remainder(0, -INFINITY), 0); 384 is_eq(remainder(1, -INFINITY), 1); 385 is_negzero(remainder(-1, -INFINITY)); 386 is_eq(remainder(0.5, -INFINITY), 0.5); 387 // is_eq(remainder(1.23e300, -INFINITY), 1.23e300); 388 is_negzero(remainder(-1.23e-300, -INFINITY)); 389 is_eq(remainder(M_PI, -INFINITY), M_PI); 390 is_eq(remainder(M_E, -INFINITY), M_E); 391 is_nan(remainder(INFINITY, -INFINITY)); 392 is_nan(remainder(-INFINITY, -INFINITY)); 393 is_nan(remainder(NAN, -INFINITY)); 394 395 // remainder(x, NAN) 396 is_nan(remainder(0, NAN)); 397 is_nan(remainder(1, NAN)); 398 is_nan(remainder(-1, NAN)); 399 is_nan(remainder(0.5, NAN)); 400 // is_nan(remainder(1.23e300, NAN)); 401 is_nan(remainder(-1.23e-300, NAN)); 402 is_nan(remainder(M_PI, NAN)); 403 is_nan(remainder(M_E, NAN)); 404 is_nan(remainder(INFINITY, NAN)); 405 is_nan(remainder(-INFINITY, NAN)); 406 is_nan(remainder(NAN, NAN)); 407 408 diag("ldexp"); 409 is_eq(ldexp(0, 2), 0); 410 is_eq(ldexp(1, 2), 4); 411 is_eq(ldexp(-1, 2), -4); 412 is_eq(ldexp(0.5, 2), 2); 413 // is_eq(ldexp(1.23e300, 2), 4.91999999999999978247801e300); 414 is_negzero(ldexp(-1.23e-300, 2)); 415 is_eq(ldexp(M_PI, 2), 12.56637061435917246399); 416 is_eq(ldexp(M_E, 2), 10.87312731383618036318); 417 is_inf(ldexp(INFINITY, 2), 1); 418 is_inf(ldexp(-INFINITY, 2), -1); 419 is_nan(ldexp(NAN, 2)); 420 421 diag("log"); 422 is_inf(log(0), -1); 423 is_eq(log(1), 0); 424 is_nan(log(-1)); 425 is_eq(log(0.5), -0.69314718055994528623); 426 // is_eq(log(1.23e300), 690.98254206759804674221); 427 is_nan(log(-1.23e-300)); 428 is_eq(log(M_PI), 1.14472988584940016388); 429 is_eq(log(M_E), 1); 430 is_inf(log(INFINITY), 1); 431 is_nan(log(-INFINITY)); 432 is_nan(log(NAN)); 433 434 diag("log10"); 435 is_inf(log10(0), -1); 436 is_eq(log10(1), 0); 437 is_nan(log10(-1)); 438 is_eq(log10(0.5), -0.30102999566398119802); 439 // is_eq(log10(1.23e300), 300.08990511143940693728); 440 is_nan(log10(-1.23e-300)); 441 is_eq(log10(M_PI), 0.49714987269413385418); 442 is_eq(log10(M_E), 0.43429448190325181667); 443 is_inf(log10(INFINITY), 1); 444 is_nan(log10(-INFINITY)); 445 is_nan(log10(NAN)); 446 447 diag("log1p"); 448 is_inf(log1p(-1), -1); 449 is_eq(log1p(0), 0); 450 is_nan(log1p(-2)); 451 is_eq(log1p(-0.5), -0.69314718055994528623); 452 is_eq(log1p(M_PI - 1), 1.14472988584940016388); 453 is_eq(log1p(M_E - 1), 1); 454 is_inf(log1p(INFINITY), 1); 455 is_nan(log1p(-INFINITY)); 456 is_nan(log1p(NAN)); 457 458 diag("pow"); 459 460 // pow(x, 0) 461 is_eq(pow(0, 0), 1); 462 is_eq(pow(1, 0), 1); 463 is_eq(pow(-1, 0), 1); 464 is_eq(pow(0.5, 0), 1); 465 // is_eq(pow(1.23e300, 0), 1); 466 is_eq(pow(-1.23e-300, 0), 1); 467 is_eq(pow(M_PI, 0), 1); 468 is_eq(pow(M_E, 0), 1); 469 is_eq(pow(INFINITY, 0), 1); 470 is_eq(pow(-INFINITY, 0), 1); 471 is_eq(pow(NAN, 0), 1); 472 473 // pow(x, M_PI) 474 is_eq(pow(0, M_PI), 0); 475 is_eq(pow(1, M_PI), 1); 476 is_nan(pow(-1, M_PI)); 477 is_eq(pow(0.5, M_PI), 0.11331473229676088110); 478 // is_inf(pow(1.23e300, M_PI), 1); 479 is_nan(pow(-1.23e-300, M_PI)); 480 is_eq(pow(M_PI, M_PI), 36.46215960720790150162); 481 is_eq(pow(M_E, M_PI), 23.14069263277926324918); 482 is_inf(pow(INFINITY, M_PI), 1); 483 is_inf(pow(-INFINITY, M_PI), 1); 484 is_nan(pow(NAN, M_PI)); 485 486 // pow(x, INFINITY) 487 is_eq(pow(0, INFINITY), 0); 488 is_eq(pow(1, INFINITY), 1); 489 is_eq(pow(-1, INFINITY), 1); 490 is_eq(pow(0.5, INFINITY), 0); 491 // is_inf(pow(1.23e300, INFINITY), 1); 492 is_eq(pow(-1.23e-300, INFINITY), 0); 493 is_inf(pow(M_PI, INFINITY), 1); 494 is_inf(pow(M_E, INFINITY), 1); 495 is_inf(pow(INFINITY, INFINITY), 1); 496 is_inf(pow(-INFINITY, INFINITY), 1); 497 is_nan(pow(NAN, INFINITY)); 498 499 // pow(x, -INFINITY) 500 is_inf(pow(0, -INFINITY), 1); 501 is_eq(pow(1, -INFINITY), 1); 502 is_eq(pow(-1, -INFINITY), 1); 503 is_inf(pow(0.5, -INFINITY), 1); 504 // is_eq(pow(1.23e300, -INFINITY), 0); 505 is_inf(pow(-1.23e-300, -INFINITY), 1); 506 is_eq(pow(M_PI, -INFINITY), 0); 507 is_eq(pow(M_E, -INFINITY), 0); 508 is_eq(pow(INFINITY, -INFINITY), 0); 509 is_eq(pow(-INFINITY, -INFINITY), 0); 510 is_nan(pow(NAN, -INFINITY)); 511 512 // pow(x, NAN) 513 is_nan(pow(0, NAN)); 514 is_eq(pow(1, NAN), 1); 515 is_nan(pow(-1, NAN)); 516 is_nan(pow(0.5, NAN)); 517 // is_nan(pow(1.23e300, NAN)); 518 is_nan(pow(-1.23e-300, NAN)); 519 is_nan(pow(M_PI, NAN)); 520 is_nan(pow(M_E, NAN)); 521 is_nan(pow(INFINITY, NAN)); 522 is_nan(pow(-INFINITY, NAN)); 523 is_nan(pow(NAN, NAN)); 524 525 diag("sin"); 526 is_eq(sin(0), 0); 527 is_eq(sin(1), 0.84147098480789650488); 528 is_eq(sin(-1), -0.84147098480789650488); 529 is_eq(sin(0.5), 0.47942553860420300538); 530 // https://github.com/golang/go/issues/20539 531 // disabled(is_eq(sin(1.23e300), 0.967849)); 532 is_negzero(sin(-1.23e-300)); 533 is_eq(sin(M_PI), 0); 534 is_eq(sin(M_E), 0.41078129050290879132); 535 is_nan(sin(INFINITY)); 536 is_nan(sin(-INFINITY)); 537 is_nan(sin(NAN)); 538 539 diag("sinh"); 540 is_eq(sinh(0), 0); 541 is_eq(sinh(1), 1.1752011936438013784); 542 is_eq(sinh(-1), -1.1752011936438013784); 543 is_eq(sinh(0.5), 0.52109530549374738495); 544 // https://github.com/golang/go/issues/20539 545 // disabled(is_eq(sinh(1.23e300), 1)); 546 is_negzero(sinh(-1.23e-300)); 547 is_eq(sinh(M_PI), 11.548739357257746363); 548 is_eq(sinh(M_E), 7.5441371028169745827); 549 is_inf(sinh(INFINITY), 1); 550 is_inf(sinh(-INFINITY), -1); 551 is_nan(sinh(NAN)); 552 553 diag("sqrt"); 554 is_eq(sqrt(0), 0); 555 is_eq(sqrt(1), 1); 556 is_nan(sqrt(-1)); 557 is_eq(sqrt(0.5), 0.70710678118654757274); 558 // is_eq(sqrt(1.23e300), 1.109053650640941776055117e150); 559 is_nan(sqrt(-1.23e-300)); 560 is_eq(sqrt(M_PI), 1.77245385090551588192); 561 is_eq(sqrt(M_E), 1.64872127070012819416); 562 is_inf(sqrt(INFINITY), 1); 563 is_nan(sqrt(-INFINITY)); 564 is_nan(sqrt(NAN)); 565 566 diag("tan"); 567 is_eq(tan(0), 0); 568 is_eq(tan(1), 1.55740772465490207033); 569 is_eq(tan(-1), -1.55740772465490207033); 570 is_eq(tan(0.5), 0.54630248984379048416); 571 // https://github.com/golang/go/issues/20539 572 // disabled(is_eq(tan(1.23e300), 3.847798)); 573 is_negzero(tan(-1.23e-300)); 574 is_eq(tan(M_PI), 0); 575 is_eq(tan(M_E), -0.45054953406980763342); 576 is_nan(tan(INFINITY)); 577 is_nan(tan(-INFINITY)); 578 is_nan(tan(NAN)); 579 580 diag("tanh"); 581 is_eq(tanh(0), 0); 582 is_eq(tanh(1), 0.76159415595576485103); 583 is_eq(tanh(-1), -0.76159415595576485103); 584 is_eq(tanh(0.5), 0.46211715726000973659); 585 // is_eq(tanh(1.23e300), 1); 586 is_negzero(tanh(-1.23e-300)); 587 is_eq(tanh(M_PI), 0.99627207622074998028); 588 is_eq(tanh(M_E), 0.99132891580059978587); 589 is_eq(tanh(INFINITY), 1); 590 is_eq(tanh(-INFINITY), -1); 591 is_nan(tanh(NAN)); 592 593 diag("copysign"); 594 is_eq(copysign(1.0, +2.0), +1.0); 595 is_eq(copysign(1.0, -2.0), -1.0); 596 is_inf(copysign(INFINITY, -2.0), -1); 597 is_nan(copysign(NAN, -2.0)); 598 599 diag("fma"); 600 { 601 double x, y, z; 602 x = 10, y = 20, z = 30; 603 is_eq(fma(x, y, z), x * y + z); 604 } 605 { 606 float x, y, z; 607 x = 10, y = 20, z = 30; 608 is_eq(fmaf(x, y, z), x * y + z); 609 } 610 { 611 long double x, y, z; 612 x = 10, y = 20, z = 30; 613 is_eq(fmal(x, y, z), x * y + z); 614 } 615 616 diag("fmin"); 617 { 618 double x = 100; 619 double y = 1; 620 is_eq(fmin(x, y), y); 621 is_eq(fmin(-x, -y), -x); 622 } 623 { 624 float x = 100; 625 float y = 1; 626 is_eq(fminf(x, y), y); 627 is_eq(fminf(-x, -y), -x); 628 } 629 { 630 long double x = 100; 631 long double y = 1; 632 is_eq(fminl(x, y), y); 633 is_eq(fminl(-x, -y), -x); 634 } 635 636 diag("fmax"); 637 { 638 double x = 100; 639 double y = 1; 640 is_eq(fmax(x, y), x); 641 is_eq(fmax(-x, -y), -y); 642 } 643 { 644 float x = 100; 645 float y = 1; 646 is_eq(fmaxf(x, y), x); 647 is_eq(fmaxf(-x, -y), -y); 648 } 649 { 650 long double x = 100; 651 long double y = 1; 652 is_eq(fmaxl(x, y), x); 653 is_eq(fmaxl(-x, -y), -y); 654 } 655 656 diag("expm1"); 657 { 658 double x = 2.7; 659 double res = exp(x) - 1.0; 660 is_eq(expm1(x), res); 661 } 662 { 663 float x = 2.7; 664 float res = exp(x) - 1.0; 665 is_eq(expm1f(x), res); 666 } 667 { 668 long double x = 2.7; 669 long double res = exp(x) - 1.0; 670 is_eq(expm1l(x), res); 671 } 672 673 diag("exp2"); 674 { 675 double x = 2.7; 676 double res = pow(2.0, x); 677 is_eq(exp2(x), res); 678 } 679 { 680 float x = 2.7; 681 float res = pow(2.0, x); 682 is_eq(exp2f(x), res); 683 } 684 { 685 long double x = 2.7; 686 long double res = pow(2.0, x); 687 is_eq(exp2l(x), res); 688 } 689 690 diag("fdim"); 691 { 692 double x = 2.7, y = 0.2; 693 is_eq(fdim(x, y), x - y); 694 is_eq(fdim(-x, y), 0); 695 } 696 { 697 float x = 2.7, y = 0.2; 698 is_eq(fdimf(x, y), x - y); 699 is_eq(fdimf(-x, y), 0); 700 } 701 { 702 long double x = 2.7, y = 0.2; 703 is_eq(fdiml(x, y), x - y); 704 is_eq(fdiml(-x, y), 0); 705 } 706 707 diag("log2"); 708 { 709 double x = 1024; 710 double res = log2(x); 711 is_eq(exp2(res), x); 712 } 713 { 714 float x = 1024; 715 float res = log2f(x); 716 is_eq(exp2f(res), x); 717 } 718 { 719 long double x = 1024; 720 long double res = log2l(x); 721 is_eq(exp2l(res), x); 722 } 723 724 diag("sinh, cosh, tanh"); 725 { 726 double angle = 2.0; 727 is_eq(sinh(angle) / cosh(angle), tanh(angle)); 728 } 729 { 730 float angle = 2.0; 731 is_eq(sinhf(angle) / coshf(angle), tanh(angle)); 732 } 733 { 734 long double angle = 2.0; 735 is_eq(sinhl(angle) / coshl(angle), tanhl(angle)); 736 } 737 { 738 double angle = 2.0; 739 is_eq(asinh(sinh(angle)), angle); 740 } 741 { 742 double angle = 2.0; 743 is_eq(acosh(cosh(angle)), angle); 744 } 745 { 746 double angle = 2.0; 747 is_eq(atanh(tanh(angle)), angle); 748 } 749 750 diag("cbrt, cbrtf, cbrtl"); 751 { 752 double res = 2.12345; 753 is_eq(cbrt(res * res * res), res); 754 } 755 { 756 float res = 2.12345; 757 is_eq(cbrtf(res * res * res), res); 758 } 759 { 760 long double res = 2.12345; 761 is_eq(cbrtl(res * res * res), res); 762 } 763 764 diag("hypot, hypotf, hypotl"); 765 is_eq(hypot(0, 0), 0); 766 is_eq(hypot(3, 4), 5); 767 is_eq(hypotf(0, 0), 0); 768 is_eq(hypotf(3, 4), 5); 769 is_eq(hypotl(0, 0), 0); 770 is_eq(hypotl(3, 4), 5); 771 772 diag("erf, erfc"); 773 is_eq(erf(1.0), 0.84270079294971489414); 774 printf("%.13f\n", erff(1.0f)); 775 is_eq(erfl(1.0), 0.84270079294971489414); 776 is_eq(erfc(1.0), 0.15729920705028513361); 777 printf("%.13f\n", erfcf(1.0f)); 778 is_eq(erfcl(1.0), 0.15729920705028513361); 779 is_eq(erf(1.0), 1 - erfc(1.0)); 780 printf("%.13f\n", erff(1.0f)); 781 printf("%.5f\n", 1.0f - erfcf(1.0f)); // TODO - not same 782 is_eq(erfl(1.0), 1 - erfcl(1.0)); 783 784 diag("frexp"); 785 { 786 int n; 787 double param = 8.0, result; 788 result = frexp(param, &n); 789 is_eq(result, 0.5000); 790 is_eq(n, 4); 791 } 792 793 diag("round"); 794 { 795 is_eq(lround(2.3), 2); 796 is_eq(lround(3.8), 4); 797 is_eq(lround(-2.3), -2); 798 is_eq(lround(-3.8), -4); 799 800 is_eq(llround(2.3), 2); 801 is_eq(llround(3.8), 4); 802 is_eq(llround(-2.3), -2); 803 is_eq(llround(-3.8), -4); 804 } 805 806 done_testing(); 807 }