github.com/dorkamotorka/go/src@v0.0.0-20230614113921-187095f0e316/math/all_test.go (about) 1 // Copyright 2009 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package math_test 6 7 import ( 8 "fmt" 9 . "math" 10 "testing" 11 "unsafe" 12 ) 13 14 var vf = []float64{ 15 4.9790119248836735e+00, 16 7.7388724745781045e+00, 17 -2.7688005719200159e-01, 18 -5.0106036182710749e+00, 19 9.6362937071984173e+00, 20 2.9263772392439646e+00, 21 5.2290834314593066e+00, 22 2.7279399104360102e+00, 23 1.8253080916808550e+00, 24 -8.6859247685756013e+00, 25 } 26 27 // The expected results below were computed by the high precision calculators 28 // at https://keisan.casio.com/. More exact input values (array vf[], above) 29 // were obtained by printing them with "%.26f". The answers were calculated 30 // to 26 digits (by using the "Digit number" drop-down control of each 31 // calculator). 32 var acos = []float64{ 33 1.0496193546107222142571536e+00, 34 6.8584012813664425171660692e-01, 35 1.5984878714577160325521819e+00, 36 2.0956199361475859327461799e+00, 37 2.7053008467824138592616927e-01, 38 1.2738121680361776018155625e+00, 39 1.0205369421140629186287407e+00, 40 1.2945003481781246062157835e+00, 41 1.3872364345374451433846657e+00, 42 2.6231510803970463967294145e+00, 43 } 44 var acosh = []float64{ 45 2.4743347004159012494457618e+00, 46 2.8576385344292769649802701e+00, 47 7.2796961502981066190593175e-01, 48 2.4796794418831451156471977e+00, 49 3.0552020742306061857212962e+00, 50 2.044238592688586588942468e+00, 51 2.5158701513104513595766636e+00, 52 1.99050839282411638174299e+00, 53 1.6988625798424034227205445e+00, 54 2.9611454842470387925531875e+00, 55 } 56 var asin = []float64{ 57 5.2117697218417440497416805e-01, 58 8.8495619865825236751471477e-01, 59 -02.769154466281941332086016e-02, 60 -5.2482360935268931351485822e-01, 61 1.3002662421166552333051524e+00, 62 2.9698415875871901741575922e-01, 63 5.5025938468083370060258102e-01, 64 2.7629597861677201301553823e-01, 65 1.83559892257451475846656e-01, 66 -1.0523547536021497774980928e+00, 67 } 68 var asinh = []float64{ 69 2.3083139124923523427628243e+00, 70 2.743551594301593620039021e+00, 71 -2.7345908534880091229413487e-01, 72 -2.3145157644718338650499085e+00, 73 2.9613652154015058521951083e+00, 74 1.7949041616585821933067568e+00, 75 2.3564032905983506405561554e+00, 76 1.7287118790768438878045346e+00, 77 1.3626658083714826013073193e+00, 78 -2.8581483626513914445234004e+00, 79 } 80 var atan = []float64{ 81 1.372590262129621651920085e+00, 82 1.442290609645298083020664e+00, 83 -2.7011324359471758245192595e-01, 84 -1.3738077684543379452781531e+00, 85 1.4673921193587666049154681e+00, 86 1.2415173565870168649117764e+00, 87 1.3818396865615168979966498e+00, 88 1.2194305844639670701091426e+00, 89 1.0696031952318783760193244e+00, 90 -1.4561721938838084990898679e+00, 91 } 92 var atanh = []float64{ 93 5.4651163712251938116878204e-01, 94 1.0299474112843111224914709e+00, 95 -2.7695084420740135145234906e-02, 96 -5.5072096119207195480202529e-01, 97 1.9943940993171843235906642e+00, 98 3.01448604578089708203017e-01, 99 5.8033427206942188834370595e-01, 100 2.7987997499441511013958297e-01, 101 1.8459947964298794318714228e-01, 102 -1.3273186910532645867272502e+00, 103 } 104 var atan2 = []float64{ 105 1.1088291730037004444527075e+00, 106 9.1218183188715804018797795e-01, 107 1.5984772603216203736068915e+00, 108 2.0352918654092086637227327e+00, 109 8.0391819139044720267356014e-01, 110 1.2861075249894661588866752e+00, 111 1.0889904479131695712182587e+00, 112 1.3044821793397925293797357e+00, 113 1.3902530903455392306872261e+00, 114 2.2859857424479142655411058e+00, 115 } 116 var cbrt = []float64{ 117 1.7075799841925094446722675e+00, 118 1.9779982212970353936691498e+00, 119 -6.5177429017779910853339447e-01, 120 -1.7111838886544019873338113e+00, 121 2.1279920909827937423960472e+00, 122 1.4303536770460741452312367e+00, 123 1.7357021059106154902341052e+00, 124 1.3972633462554328350552916e+00, 125 1.2221149580905388454977636e+00, 126 -2.0556003730500069110343596e+00, 127 } 128 var ceil = []float64{ 129 5.0000000000000000e+00, 130 8.0000000000000000e+00, 131 Copysign(0, -1), 132 -5.0000000000000000e+00, 133 1.0000000000000000e+01, 134 3.0000000000000000e+00, 135 6.0000000000000000e+00, 136 3.0000000000000000e+00, 137 2.0000000000000000e+00, 138 -8.0000000000000000e+00, 139 } 140 var copysign = []float64{ 141 -4.9790119248836735e+00, 142 -7.7388724745781045e+00, 143 -2.7688005719200159e-01, 144 -5.0106036182710749e+00, 145 -9.6362937071984173e+00, 146 -2.9263772392439646e+00, 147 -5.2290834314593066e+00, 148 -2.7279399104360102e+00, 149 -1.8253080916808550e+00, 150 -8.6859247685756013e+00, 151 } 152 var cos = []float64{ 153 2.634752140995199110787593e-01, 154 1.148551260848219865642039e-01, 155 9.6191297325640768154550453e-01, 156 2.938141150061714816890637e-01, 157 -9.777138189897924126294461e-01, 158 -9.7693041344303219127199518e-01, 159 4.940088096948647263961162e-01, 160 -9.1565869021018925545016502e-01, 161 -2.517729313893103197176091e-01, 162 -7.39241351595676573201918e-01, 163 } 164 165 // Results for 100000 * Pi + vf[i] 166 var cosLarge = []float64{ 167 2.634752141185559426744e-01, 168 1.14855126055543100712e-01, 169 9.61912973266488928113e-01, 170 2.9381411499556122552e-01, 171 -9.777138189880161924641e-01, 172 -9.76930413445147608049e-01, 173 4.940088097314976789841e-01, 174 -9.15658690217517835002e-01, 175 -2.51772931436786954751e-01, 176 -7.3924135157173099849e-01, 177 } 178 179 var cosh = []float64{ 180 7.2668796942212842775517446e+01, 181 1.1479413465659254502011135e+03, 182 1.0385767908766418550935495e+00, 183 7.5000957789658051428857788e+01, 184 7.655246669605357888468613e+03, 185 9.3567491758321272072888257e+00, 186 9.331351599270605471131735e+01, 187 7.6833430994624643209296404e+00, 188 3.1829371625150718153881164e+00, 189 2.9595059261916188501640911e+03, 190 } 191 var erf = []float64{ 192 5.1865354817738701906913566e-01, 193 7.2623875834137295116929844e-01, 194 -3.123458688281309990629839e-02, 195 -5.2143121110253302920437013e-01, 196 8.2704742671312902508629582e-01, 197 3.2101767558376376743993945e-01, 198 5.403990312223245516066252e-01, 199 3.0034702916738588551174831e-01, 200 2.0369924417882241241559589e-01, 201 -7.8069386968009226729944677e-01, 202 } 203 var erfc = []float64{ 204 4.8134645182261298093086434e-01, 205 2.7376124165862704883070156e-01, 206 1.0312345868828130999062984e+00, 207 1.5214312111025330292043701e+00, 208 1.7295257328687097491370418e-01, 209 6.7898232441623623256006055e-01, 210 4.596009687776754483933748e-01, 211 6.9965297083261411448825169e-01, 212 7.9630075582117758758440411e-01, 213 1.7806938696800922672994468e+00, 214 } 215 var erfinv = []float64{ 216 4.746037673358033586786350696e-01, 217 8.559054432692110956388764172e-01, 218 -2.45427830571707336251331946e-02, 219 -4.78116683518973366268905506e-01, 220 1.479804430319470983648120853e+00, 221 2.654485787128896161882650211e-01, 222 5.027444534221520197823192493e-01, 223 2.466703532707627818954585670e-01, 224 1.632011465103005426240343116e-01, 225 -1.06672334642196900710000389e+00, 226 } 227 var exp = []float64{ 228 1.4533071302642137507696589e+02, 229 2.2958822575694449002537581e+03, 230 7.5814542574851666582042306e-01, 231 6.6668778421791005061482264e-03, 232 1.5310493273896033740861206e+04, 233 1.8659907517999328638667732e+01, 234 1.8662167355098714543942057e+02, 235 1.5301332413189378961665788e+01, 236 6.2047063430646876349125085e+00, 237 1.6894712385826521111610438e-04, 238 } 239 var expm1 = []float64{ 240 5.105047796122957327384770212e-02, 241 8.046199708567344080562675439e-02, 242 -2.764970978891639815187418703e-03, 243 -4.8871434888875355394330300273e-02, 244 1.0115864277221467777117227494e-01, 245 2.969616407795910726014621657e-02, 246 5.368214487944892300914037972e-02, 247 2.765488851131274068067445335e-02, 248 1.842068661871398836913874273e-02, 249 -8.3193870863553801814961137573e-02, 250 } 251 var expm1Large = []float64{ 252 4.2031418113550844e+21, 253 4.0690789717473863e+33, 254 -0.9372627915981363e+00, 255 -1.0, 256 7.077694784145933e+41, 257 5.117936223839153e+12, 258 5.124137759001189e+22, 259 7.03546003972584e+11, 260 8.456921800389698e+07, 261 -1.0, 262 } 263 var exp2 = []float64{ 264 3.1537839463286288034313104e+01, 265 2.1361549283756232296144849e+02, 266 8.2537402562185562902577219e-01, 267 3.1021158628740294833424229e-02, 268 7.9581744110252191462569661e+02, 269 7.6019905892596359262696423e+00, 270 3.7506882048388096973183084e+01, 271 6.6250893439173561733216375e+00, 272 3.5438267900243941544605339e+00, 273 2.4281533133513300984289196e-03, 274 } 275 var fabs = []float64{ 276 4.9790119248836735e+00, 277 7.7388724745781045e+00, 278 2.7688005719200159e-01, 279 5.0106036182710749e+00, 280 9.6362937071984173e+00, 281 2.9263772392439646e+00, 282 5.2290834314593066e+00, 283 2.7279399104360102e+00, 284 1.8253080916808550e+00, 285 8.6859247685756013e+00, 286 } 287 var fdim = []float64{ 288 4.9790119248836735e+00, 289 7.7388724745781045e+00, 290 0.0000000000000000e+00, 291 0.0000000000000000e+00, 292 9.6362937071984173e+00, 293 2.9263772392439646e+00, 294 5.2290834314593066e+00, 295 2.7279399104360102e+00, 296 1.8253080916808550e+00, 297 0.0000000000000000e+00, 298 } 299 var floor = []float64{ 300 4.0000000000000000e+00, 301 7.0000000000000000e+00, 302 -1.0000000000000000e+00, 303 -6.0000000000000000e+00, 304 9.0000000000000000e+00, 305 2.0000000000000000e+00, 306 5.0000000000000000e+00, 307 2.0000000000000000e+00, 308 1.0000000000000000e+00, 309 -9.0000000000000000e+00, 310 } 311 var fmod = []float64{ 312 4.197615023265299782906368e-02, 313 2.261127525421895434476482e+00, 314 3.231794108794261433104108e-02, 315 4.989396381728925078391512e+00, 316 3.637062928015826201999516e-01, 317 1.220868282268106064236690e+00, 318 4.770916568540693347699744e+00, 319 1.816180268691969246219742e+00, 320 8.734595415957246977711748e-01, 321 1.314075231424398637614104e+00, 322 } 323 324 type fi struct { 325 f float64 326 i int 327 } 328 329 var frexp = []fi{ 330 {6.2237649061045918750e-01, 3}, 331 {9.6735905932226306250e-01, 3}, 332 {-5.5376011438400318000e-01, -1}, 333 {-6.2632545228388436250e-01, 3}, 334 {6.02268356699901081250e-01, 4}, 335 {7.3159430981099115000e-01, 2}, 336 {6.5363542893241332500e-01, 3}, 337 {6.8198497760900255000e-01, 2}, 338 {9.1265404584042750000e-01, 1}, 339 {-5.4287029803597508250e-01, 4}, 340 } 341 var gamma = []float64{ 342 2.3254348370739963835386613898e+01, 343 2.991153837155317076427529816e+03, 344 -4.561154336726758060575129109e+00, 345 7.719403468842639065959210984e-01, 346 1.6111876618855418534325755566e+05, 347 1.8706575145216421164173224946e+00, 348 3.4082787447257502836734201635e+01, 349 1.579733951448952054898583387e+00, 350 9.3834586598354592860187267089e-01, 351 -2.093995902923148389186189429e-05, 352 } 353 var j0 = []float64{ 354 -1.8444682230601672018219338e-01, 355 2.27353668906331975435892e-01, 356 9.809259936157051116270273e-01, 357 -1.741170131426226587841181e-01, 358 -2.1389448451144143352039069e-01, 359 -2.340905848928038763337414e-01, 360 -1.0029099691890912094586326e-01, 361 -1.5466726714884328135358907e-01, 362 3.252650187653420388714693e-01, 363 -8.72218484409407250005360235e-03, 364 } 365 var j1 = []float64{ 366 -3.251526395295203422162967e-01, 367 1.893581711430515718062564e-01, 368 -1.3711761352467242914491514e-01, 369 3.287486536269617297529617e-01, 370 1.3133899188830978473849215e-01, 371 3.660243417832986825301766e-01, 372 -3.4436769271848174665420672e-01, 373 4.329481396640773768835036e-01, 374 5.8181350531954794639333955e-01, 375 -2.7030574577733036112996607e-01, 376 } 377 var j2 = []float64{ 378 5.3837518920137802565192769e-02, 379 -1.7841678003393207281244667e-01, 380 9.521746934916464142495821e-03, 381 4.28958355470987397983072e-02, 382 2.4115371837854494725492872e-01, 383 4.842458532394520316844449e-01, 384 -3.142145220618633390125946e-02, 385 4.720849184745124761189957e-01, 386 3.122312022520957042957497e-01, 387 7.096213118930231185707277e-02, 388 } 389 var jM3 = []float64{ 390 -3.684042080996403091021151e-01, 391 2.8157665936340887268092661e-01, 392 4.401005480841948348343589e-04, 393 3.629926999056814081597135e-01, 394 3.123672198825455192489266e-02, 395 -2.958805510589623607540455e-01, 396 -3.2033177696533233403289416e-01, 397 -2.592737332129663376736604e-01, 398 -1.0241334641061485092351251e-01, 399 -2.3762660886100206491674503e-01, 400 } 401 var lgamma = []fi{ 402 {3.146492141244545774319734e+00, 1}, 403 {8.003414490659126375852113e+00, 1}, 404 {1.517575735509779707488106e+00, -1}, 405 {-2.588480028182145853558748e-01, 1}, 406 {1.1989897050205555002007985e+01, 1}, 407 {6.262899811091257519386906e-01, 1}, 408 {3.5287924899091566764846037e+00, 1}, 409 {4.5725644770161182299423372e-01, 1}, 410 {-6.363667087767961257654854e-02, 1}, 411 {-1.077385130910300066425564e+01, -1}, 412 } 413 var log = []float64{ 414 1.605231462693062999102599e+00, 415 2.0462560018708770653153909e+00, 416 -1.2841708730962657801275038e+00, 417 1.6115563905281545116286206e+00, 418 2.2655365644872016636317461e+00, 419 1.0737652208918379856272735e+00, 420 1.6542360106073546632707956e+00, 421 1.0035467127723465801264487e+00, 422 6.0174879014578057187016475e-01, 423 2.161703872847352815363655e+00, 424 } 425 var logb = []float64{ 426 2.0000000000000000e+00, 427 2.0000000000000000e+00, 428 -2.0000000000000000e+00, 429 2.0000000000000000e+00, 430 3.0000000000000000e+00, 431 1.0000000000000000e+00, 432 2.0000000000000000e+00, 433 1.0000000000000000e+00, 434 0.0000000000000000e+00, 435 3.0000000000000000e+00, 436 } 437 var log10 = []float64{ 438 6.9714316642508290997617083e-01, 439 8.886776901739320576279124e-01, 440 -5.5770832400658929815908236e-01, 441 6.998900476822994346229723e-01, 442 9.8391002850684232013281033e-01, 443 4.6633031029295153334285302e-01, 444 7.1842557117242328821552533e-01, 445 4.3583479968917773161304553e-01, 446 2.6133617905227038228626834e-01, 447 9.3881606348649405716214241e-01, 448 } 449 var log1p = []float64{ 450 4.8590257759797794104158205e-02, 451 7.4540265965225865330849141e-02, 452 -2.7726407903942672823234024e-03, 453 -5.1404917651627649094953380e-02, 454 9.1998280672258624681335010e-02, 455 2.8843762576593352865894824e-02, 456 5.0969534581863707268992645e-02, 457 2.6913947602193238458458594e-02, 458 1.8088493239630770262045333e-02, 459 -9.0865245631588989681559268e-02, 460 } 461 var log2 = []float64{ 462 2.3158594707062190618898251e+00, 463 2.9521233862883917703341018e+00, 464 -1.8526669502700329984917062e+00, 465 2.3249844127278861543568029e+00, 466 3.268478366538305087466309e+00, 467 1.5491157592596970278166492e+00, 468 2.3865580889631732407886495e+00, 469 1.447811865817085365540347e+00, 470 8.6813999540425116282815557e-01, 471 3.118679457227342224364709e+00, 472 } 473 var modf = [][2]float64{ 474 {4.0000000000000000e+00, 9.7901192488367350108546816e-01}, 475 {7.0000000000000000e+00, 7.3887247457810456552351752e-01}, 476 {Copysign(0, -1), -2.7688005719200159404635997e-01}, 477 {-5.0000000000000000e+00, -1.060361827107492160848778e-02}, 478 {9.0000000000000000e+00, 6.3629370719841737980004837e-01}, 479 {2.0000000000000000e+00, 9.2637723924396464525443662e-01}, 480 {5.0000000000000000e+00, 2.2908343145930665230025625e-01}, 481 {2.0000000000000000e+00, 7.2793991043601025126008608e-01}, 482 {1.0000000000000000e+00, 8.2530809168085506044576505e-01}, 483 {-8.0000000000000000e+00, -6.8592476857560136238589621e-01}, 484 } 485 var nextafter32 = []float32{ 486 4.979012489318848e+00, 487 7.738873004913330e+00, 488 -2.768800258636475e-01, 489 -5.010602951049805e+00, 490 9.636294364929199e+00, 491 2.926377534866333e+00, 492 5.229084014892578e+00, 493 2.727940082550049e+00, 494 1.825308203697205e+00, 495 -8.685923576354980e+00, 496 } 497 var nextafter64 = []float64{ 498 4.97901192488367438926388786e+00, 499 7.73887247457810545370193722e+00, 500 -2.7688005719200153853520874e-01, 501 -5.01060361827107403343006808e+00, 502 9.63629370719841915615688777e+00, 503 2.92637723924396508934364647e+00, 504 5.22908343145930754047867595e+00, 505 2.72793991043601069534929593e+00, 506 1.82530809168085528249036997e+00, 507 -8.68592476857559958602905681e+00, 508 } 509 var pow = []float64{ 510 9.5282232631648411840742957e+04, 511 5.4811599352999901232411871e+07, 512 5.2859121715894396531132279e-01, 513 9.7587991957286474464259698e-06, 514 4.328064329346044846740467e+09, 515 8.4406761805034547437659092e+02, 516 1.6946633276191194947742146e+05, 517 5.3449040147551939075312879e+02, 518 6.688182138451414936380374e+01, 519 2.0609869004248742886827439e-09, 520 } 521 var remainder = []float64{ 522 4.197615023265299782906368e-02, 523 2.261127525421895434476482e+00, 524 3.231794108794261433104108e-02, 525 -2.120723654214984321697556e-02, 526 3.637062928015826201999516e-01, 527 1.220868282268106064236690e+00, 528 -4.581668629186133046005125e-01, 529 -9.117596417440410050403443e-01, 530 8.734595415957246977711748e-01, 531 1.314075231424398637614104e+00, 532 } 533 var round = []float64{ 534 5, 535 8, 536 Copysign(0, -1), 537 -5, 538 10, 539 3, 540 5, 541 3, 542 2, 543 -9, 544 } 545 var signbit = []bool{ 546 false, 547 false, 548 true, 549 true, 550 false, 551 false, 552 false, 553 false, 554 false, 555 true, 556 } 557 var sin = []float64{ 558 -9.6466616586009283766724726e-01, 559 9.9338225271646545763467022e-01, 560 -2.7335587039794393342449301e-01, 561 9.5586257685042792878173752e-01, 562 -2.099421066779969164496634e-01, 563 2.135578780799860532750616e-01, 564 -8.694568971167362743327708e-01, 565 4.019566681155577786649878e-01, 566 9.6778633541687993721617774e-01, 567 -6.734405869050344734943028e-01, 568 } 569 570 // Results for 100000 * Pi + vf[i] 571 var sinLarge = []float64{ 572 -9.646661658548936063912e-01, 573 9.933822527198506903752e-01, 574 -2.7335587036246899796e-01, 575 9.55862576853689321268e-01, 576 -2.099421066862688873691e-01, 577 2.13557878070308981163e-01, 578 -8.694568970959221300497e-01, 579 4.01956668098863248917e-01, 580 9.67786335404528727927e-01, 581 -6.7344058693131973066e-01, 582 } 583 var sinh = []float64{ 584 7.2661916084208532301448439e+01, 585 1.1479409110035194500526446e+03, 586 -2.8043136512812518927312641e-01, 587 -7.499429091181587232835164e+01, 588 7.6552466042906758523925934e+03, 589 9.3031583421672014313789064e+00, 590 9.330815755828109072810322e+01, 591 7.6179893137269146407361477e+00, 592 3.021769180549615819524392e+00, 593 -2.95950575724449499189888e+03, 594 } 595 var sqrt = []float64{ 596 2.2313699659365484748756904e+00, 597 2.7818829009464263511285458e+00, 598 5.2619393496314796848143251e-01, 599 2.2384377628763938724244104e+00, 600 3.1042380236055381099288487e+00, 601 1.7106657298385224403917771e+00, 602 2.286718922705479046148059e+00, 603 1.6516476350711159636222979e+00, 604 1.3510396336454586262419247e+00, 605 2.9471892997524949215723329e+00, 606 } 607 var tan = []float64{ 608 -3.661316565040227801781974e+00, 609 8.64900232648597589369854e+00, 610 -2.8417941955033612725238097e-01, 611 3.253290185974728640827156e+00, 612 2.147275640380293804770778e-01, 613 -2.18600910711067004921551e-01, 614 -1.760002817872367935518928e+00, 615 -4.389808914752818126249079e-01, 616 -3.843885560201130679995041e+00, 617 9.10988793377685105753416e-01, 618 } 619 620 // Results for 100000 * Pi + vf[i] 621 var tanLarge = []float64{ 622 -3.66131656475596512705e+00, 623 8.6490023287202547927e+00, 624 -2.841794195104782406e-01, 625 3.2532901861033120983e+00, 626 2.14727564046880001365e-01, 627 -2.18600910700688062874e-01, 628 -1.760002817699722747043e+00, 629 -4.38980891453536115952e-01, 630 -3.84388555942723509071e+00, 631 9.1098879344275101051e-01, 632 } 633 var tanh = []float64{ 634 9.9990531206936338549262119e-01, 635 9.9999962057085294197613294e-01, 636 -2.7001505097318677233756845e-01, 637 -9.9991110943061718603541401e-01, 638 9.9999999146798465745022007e-01, 639 9.9427249436125236705001048e-01, 640 9.9994257600983138572705076e-01, 641 9.9149409509772875982054701e-01, 642 9.4936501296239685514466577e-01, 643 -9.9999994291374030946055701e-01, 644 } 645 var trunc = []float64{ 646 4.0000000000000000e+00, 647 7.0000000000000000e+00, 648 Copysign(0, -1), 649 -5.0000000000000000e+00, 650 9.0000000000000000e+00, 651 2.0000000000000000e+00, 652 5.0000000000000000e+00, 653 2.0000000000000000e+00, 654 1.0000000000000000e+00, 655 -8.0000000000000000e+00, 656 } 657 var y0 = []float64{ 658 -3.053399153780788357534855e-01, 659 1.7437227649515231515503649e-01, 660 -8.6221781263678836910392572e-01, 661 -3.100664880987498407872839e-01, 662 1.422200649300982280645377e-01, 663 4.000004067997901144239363e-01, 664 -3.3340749753099352392332536e-01, 665 4.5399790746668954555205502e-01, 666 4.8290004112497761007536522e-01, 667 2.7036697826604756229601611e-01, 668 } 669 var y1 = []float64{ 670 0.15494213737457922210218611, 671 -0.2165955142081145245075746, 672 -2.4644949631241895201032829, 673 0.1442740489541836405154505, 674 0.2215379960518984777080163, 675 0.3038800915160754150565448, 676 0.0691107642452362383808547, 677 0.2380116417809914424860165, 678 -0.20849492979459761009678934, 679 0.0242503179793232308250804, 680 } 681 var y2 = []float64{ 682 0.3675780219390303613394936, 683 -0.23034826393250119879267257, 684 -16.939677983817727205631397, 685 0.367653980523052152867791, 686 -0.0962401471767804440353136, 687 -0.1923169356184851105200523, 688 0.35984072054267882391843766, 689 -0.2794987252299739821654982, 690 -0.7113490692587462579757954, 691 -0.2647831587821263302087457, 692 } 693 var yM3 = []float64{ 694 -0.14035984421094849100895341, 695 -0.097535139617792072703973, 696 242.25775994555580176377379, 697 -0.1492267014802818619511046, 698 0.26148702629155918694500469, 699 0.56675383593895176530394248, 700 -0.206150264009006981070575, 701 0.64784284687568332737963658, 702 1.3503631555901938037008443, 703 0.1461869756579956803341844, 704 } 705 706 // arguments and expected results for special cases 707 var vfacosSC = []float64{ 708 -Pi, 709 1, 710 Pi, 711 NaN(), 712 } 713 var acosSC = []float64{ 714 NaN(), 715 0, 716 NaN(), 717 NaN(), 718 } 719 720 var vfacoshSC = []float64{ 721 Inf(-1), 722 0.5, 723 1, 724 Inf(1), 725 NaN(), 726 } 727 var acoshSC = []float64{ 728 NaN(), 729 NaN(), 730 0, 731 Inf(1), 732 NaN(), 733 } 734 735 var vfasinSC = []float64{ 736 -Pi, 737 Copysign(0, -1), 738 0, 739 Pi, 740 NaN(), 741 } 742 var asinSC = []float64{ 743 NaN(), 744 Copysign(0, -1), 745 0, 746 NaN(), 747 NaN(), 748 } 749 750 var vfasinhSC = []float64{ 751 Inf(-1), 752 Copysign(0, -1), 753 0, 754 Inf(1), 755 NaN(), 756 } 757 var asinhSC = []float64{ 758 Inf(-1), 759 Copysign(0, -1), 760 0, 761 Inf(1), 762 NaN(), 763 } 764 765 var vfatanSC = []float64{ 766 Inf(-1), 767 Copysign(0, -1), 768 0, 769 Inf(1), 770 NaN(), 771 } 772 var atanSC = []float64{ 773 -Pi / 2, 774 Copysign(0, -1), 775 0, 776 Pi / 2, 777 NaN(), 778 } 779 780 var vfatanhSC = []float64{ 781 Inf(-1), 782 -Pi, 783 -1, 784 Copysign(0, -1), 785 0, 786 1, 787 Pi, 788 Inf(1), 789 NaN(), 790 } 791 var atanhSC = []float64{ 792 NaN(), 793 NaN(), 794 Inf(-1), 795 Copysign(0, -1), 796 0, 797 Inf(1), 798 NaN(), 799 NaN(), 800 NaN(), 801 } 802 var vfatan2SC = [][2]float64{ 803 {Inf(-1), Inf(-1)}, 804 {Inf(-1), -Pi}, 805 {Inf(-1), 0}, 806 {Inf(-1), +Pi}, 807 {Inf(-1), Inf(1)}, 808 {Inf(-1), NaN()}, 809 {-Pi, Inf(-1)}, 810 {-Pi, 0}, 811 {-Pi, Inf(1)}, 812 {-Pi, NaN()}, 813 {Copysign(0, -1), Inf(-1)}, 814 {Copysign(0, -1), -Pi}, 815 {Copysign(0, -1), Copysign(0, -1)}, 816 {Copysign(0, -1), 0}, 817 {Copysign(0, -1), +Pi}, 818 {Copysign(0, -1), Inf(1)}, 819 {Copysign(0, -1), NaN()}, 820 {0, Inf(-1)}, 821 {0, -Pi}, 822 {0, Copysign(0, -1)}, 823 {0, 0}, 824 {0, +Pi}, 825 {0, Inf(1)}, 826 {0, NaN()}, 827 {+Pi, Inf(-1)}, 828 {+Pi, 0}, 829 {+Pi, Inf(1)}, 830 {1.0, Inf(1)}, 831 {-1.0, Inf(1)}, 832 {+Pi, NaN()}, 833 {Inf(1), Inf(-1)}, 834 {Inf(1), -Pi}, 835 {Inf(1), 0}, 836 {Inf(1), +Pi}, 837 {Inf(1), Inf(1)}, 838 {Inf(1), NaN()}, 839 {NaN(), NaN()}, 840 } 841 var atan2SC = []float64{ 842 -3 * Pi / 4, // atan2(-Inf, -Inf) 843 -Pi / 2, // atan2(-Inf, -Pi) 844 -Pi / 2, // atan2(-Inf, +0) 845 -Pi / 2, // atan2(-Inf, +Pi) 846 -Pi / 4, // atan2(-Inf, +Inf) 847 NaN(), // atan2(-Inf, NaN) 848 -Pi, // atan2(-Pi, -Inf) 849 -Pi / 2, // atan2(-Pi, +0) 850 Copysign(0, -1), // atan2(-Pi, Inf) 851 NaN(), // atan2(-Pi, NaN) 852 -Pi, // atan2(-0, -Inf) 853 -Pi, // atan2(-0, -Pi) 854 -Pi, // atan2(-0, -0) 855 Copysign(0, -1), // atan2(-0, +0) 856 Copysign(0, -1), // atan2(-0, +Pi) 857 Copysign(0, -1), // atan2(-0, +Inf) 858 NaN(), // atan2(-0, NaN) 859 Pi, // atan2(+0, -Inf) 860 Pi, // atan2(+0, -Pi) 861 Pi, // atan2(+0, -0) 862 0, // atan2(+0, +0) 863 0, // atan2(+0, +Pi) 864 0, // atan2(+0, +Inf) 865 NaN(), // atan2(+0, NaN) 866 Pi, // atan2(+Pi, -Inf) 867 Pi / 2, // atan2(+Pi, +0) 868 0, // atan2(+Pi, +Inf) 869 0, // atan2(+1, +Inf) 870 Copysign(0, -1), // atan2(-1, +Inf) 871 NaN(), // atan2(+Pi, NaN) 872 3 * Pi / 4, // atan2(+Inf, -Inf) 873 Pi / 2, // atan2(+Inf, -Pi) 874 Pi / 2, // atan2(+Inf, +0) 875 Pi / 2, // atan2(+Inf, +Pi) 876 Pi / 4, // atan2(+Inf, +Inf) 877 NaN(), // atan2(+Inf, NaN) 878 NaN(), // atan2(NaN, NaN) 879 } 880 881 var vfcbrtSC = []float64{ 882 Inf(-1), 883 Copysign(0, -1), 884 0, 885 Inf(1), 886 NaN(), 887 } 888 var cbrtSC = []float64{ 889 Inf(-1), 890 Copysign(0, -1), 891 0, 892 Inf(1), 893 NaN(), 894 } 895 896 var vfceilSC = []float64{ 897 Inf(-1), 898 Copysign(0, -1), 899 0, 900 Inf(1), 901 NaN(), 902 } 903 var ceilSC = []float64{ 904 Inf(-1), 905 Copysign(0, -1), 906 0, 907 Inf(1), 908 NaN(), 909 } 910 911 var vfcopysignSC = []float64{ 912 Inf(-1), 913 Inf(1), 914 NaN(), 915 } 916 var copysignSC = []float64{ 917 Inf(-1), 918 Inf(-1), 919 NaN(), 920 } 921 922 var vfcosSC = []float64{ 923 Inf(-1), 924 Inf(1), 925 NaN(), 926 } 927 var cosSC = []float64{ 928 NaN(), 929 NaN(), 930 NaN(), 931 } 932 933 var vfcoshSC = []float64{ 934 Inf(-1), 935 Copysign(0, -1), 936 0, 937 Inf(1), 938 NaN(), 939 } 940 var coshSC = []float64{ 941 Inf(1), 942 1, 943 1, 944 Inf(1), 945 NaN(), 946 } 947 948 var vferfSC = []float64{ 949 Inf(-1), 950 Copysign(0, -1), 951 0, 952 Inf(1), 953 NaN(), 954 -1000, 955 1000, 956 } 957 var erfSC = []float64{ 958 -1, 959 Copysign(0, -1), 960 0, 961 1, 962 NaN(), 963 -1, 964 1, 965 } 966 967 var vferfcSC = []float64{ 968 Inf(-1), 969 Inf(1), 970 NaN(), 971 -1000, 972 1000, 973 } 974 var erfcSC = []float64{ 975 2, 976 0, 977 NaN(), 978 2, 979 0, 980 } 981 982 var vferfinvSC = []float64{ 983 1, 984 -1, 985 0, 986 Inf(-1), 987 Inf(1), 988 NaN(), 989 } 990 var erfinvSC = []float64{ 991 Inf(+1), 992 Inf(-1), 993 0, 994 NaN(), 995 NaN(), 996 NaN(), 997 } 998 999 var vferfcinvSC = []float64{ 1000 0, 1001 2, 1002 1, 1003 Inf(1), 1004 Inf(-1), 1005 NaN(), 1006 } 1007 var erfcinvSC = []float64{ 1008 Inf(+1), 1009 Inf(-1), 1010 0, 1011 NaN(), 1012 NaN(), 1013 NaN(), 1014 } 1015 1016 var vfexpSC = []float64{ 1017 Inf(-1), 1018 -2000, 1019 2000, 1020 Inf(1), 1021 NaN(), 1022 // smallest float64 that overflows Exp(x) 1023 7.097827128933841e+02, 1024 // Issue 18912 1025 1.48852223e+09, 1026 1.4885222e+09, 1027 1, 1028 // near zero 1029 3.725290298461915e-09, 1030 // denormal 1031 -740, 1032 } 1033 var expSC = []float64{ 1034 0, 1035 0, 1036 Inf(1), 1037 Inf(1), 1038 NaN(), 1039 Inf(1), 1040 Inf(1), 1041 Inf(1), 1042 2.718281828459045, 1043 1.0000000037252903, 1044 4.2e-322, 1045 } 1046 1047 var vfexp2SC = []float64{ 1048 Inf(-1), 1049 -2000, 1050 2000, 1051 Inf(1), 1052 NaN(), 1053 // smallest float64 that overflows Exp2(x) 1054 1024, 1055 // near underflow 1056 -1.07399999999999e+03, 1057 // near zero 1058 3.725290298461915e-09, 1059 } 1060 var exp2SC = []float64{ 1061 0, 1062 0, 1063 Inf(1), 1064 Inf(1), 1065 NaN(), 1066 Inf(1), 1067 5e-324, 1068 1.0000000025821745, 1069 } 1070 1071 var vfexpm1SC = []float64{ 1072 Inf(-1), 1073 -710, 1074 Copysign(0, -1), 1075 0, 1076 710, 1077 Inf(1), 1078 NaN(), 1079 } 1080 var expm1SC = []float64{ 1081 -1, 1082 -1, 1083 Copysign(0, -1), 1084 0, 1085 Inf(1), 1086 Inf(1), 1087 NaN(), 1088 } 1089 1090 var vffabsSC = []float64{ 1091 Inf(-1), 1092 Copysign(0, -1), 1093 0, 1094 Inf(1), 1095 NaN(), 1096 } 1097 var fabsSC = []float64{ 1098 Inf(1), 1099 0, 1100 0, 1101 Inf(1), 1102 NaN(), 1103 } 1104 1105 var vffdimSC = [][2]float64{ 1106 {Inf(-1), Inf(-1)}, 1107 {Inf(-1), Inf(1)}, 1108 {Inf(-1), NaN()}, 1109 {Copysign(0, -1), Copysign(0, -1)}, 1110 {Copysign(0, -1), 0}, 1111 {0, Copysign(0, -1)}, 1112 {0, 0}, 1113 {Inf(1), Inf(-1)}, 1114 {Inf(1), Inf(1)}, 1115 {Inf(1), NaN()}, 1116 {NaN(), Inf(-1)}, 1117 {NaN(), Copysign(0, -1)}, 1118 {NaN(), 0}, 1119 {NaN(), Inf(1)}, 1120 {NaN(), NaN()}, 1121 } 1122 var nan = Float64frombits(0xFFF8000000000000) // SSE2 DIVSD 0/0 1123 var vffdim2SC = [][2]float64{ 1124 {Inf(-1), Inf(-1)}, 1125 {Inf(-1), Inf(1)}, 1126 {Inf(-1), nan}, 1127 {Copysign(0, -1), Copysign(0, -1)}, 1128 {Copysign(0, -1), 0}, 1129 {0, Copysign(0, -1)}, 1130 {0, 0}, 1131 {Inf(1), Inf(-1)}, 1132 {Inf(1), Inf(1)}, 1133 {Inf(1), nan}, 1134 {nan, Inf(-1)}, 1135 {nan, Copysign(0, -1)}, 1136 {nan, 0}, 1137 {nan, Inf(1)}, 1138 {nan, nan}, 1139 } 1140 var fdimSC = []float64{ 1141 NaN(), 1142 0, 1143 NaN(), 1144 0, 1145 0, 1146 0, 1147 0, 1148 Inf(1), 1149 NaN(), 1150 NaN(), 1151 NaN(), 1152 NaN(), 1153 NaN(), 1154 NaN(), 1155 NaN(), 1156 } 1157 var fmaxSC = []float64{ 1158 Inf(-1), 1159 Inf(1), 1160 NaN(), 1161 Copysign(0, -1), 1162 0, 1163 0, 1164 0, 1165 Inf(1), 1166 Inf(1), 1167 Inf(1), 1168 NaN(), 1169 NaN(), 1170 NaN(), 1171 Inf(1), 1172 NaN(), 1173 } 1174 var fminSC = []float64{ 1175 Inf(-1), 1176 Inf(-1), 1177 Inf(-1), 1178 Copysign(0, -1), 1179 Copysign(0, -1), 1180 Copysign(0, -1), 1181 0, 1182 Inf(-1), 1183 Inf(1), 1184 NaN(), 1185 Inf(-1), 1186 NaN(), 1187 NaN(), 1188 NaN(), 1189 NaN(), 1190 } 1191 1192 var vffmodSC = [][2]float64{ 1193 {Inf(-1), Inf(-1)}, 1194 {Inf(-1), -Pi}, 1195 {Inf(-1), 0}, 1196 {Inf(-1), Pi}, 1197 {Inf(-1), Inf(1)}, 1198 {Inf(-1), NaN()}, 1199 {-Pi, Inf(-1)}, 1200 {-Pi, 0}, 1201 {-Pi, Inf(1)}, 1202 {-Pi, NaN()}, 1203 {Copysign(0, -1), Inf(-1)}, 1204 {Copysign(0, -1), 0}, 1205 {Copysign(0, -1), Inf(1)}, 1206 {Copysign(0, -1), NaN()}, 1207 {0, Inf(-1)}, 1208 {0, 0}, 1209 {0, Inf(1)}, 1210 {0, NaN()}, 1211 {Pi, Inf(-1)}, 1212 {Pi, 0}, 1213 {Pi, Inf(1)}, 1214 {Pi, NaN()}, 1215 {Inf(1), Inf(-1)}, 1216 {Inf(1), -Pi}, 1217 {Inf(1), 0}, 1218 {Inf(1), Pi}, 1219 {Inf(1), Inf(1)}, 1220 {Inf(1), NaN()}, 1221 {NaN(), Inf(-1)}, 1222 {NaN(), -Pi}, 1223 {NaN(), 0}, 1224 {NaN(), Pi}, 1225 {NaN(), Inf(1)}, 1226 {NaN(), NaN()}, 1227 } 1228 var fmodSC = []float64{ 1229 NaN(), // fmod(-Inf, -Inf) 1230 NaN(), // fmod(-Inf, -Pi) 1231 NaN(), // fmod(-Inf, 0) 1232 NaN(), // fmod(-Inf, Pi) 1233 NaN(), // fmod(-Inf, +Inf) 1234 NaN(), // fmod(-Inf, NaN) 1235 -Pi, // fmod(-Pi, -Inf) 1236 NaN(), // fmod(-Pi, 0) 1237 -Pi, // fmod(-Pi, +Inf) 1238 NaN(), // fmod(-Pi, NaN) 1239 Copysign(0, -1), // fmod(-0, -Inf) 1240 NaN(), // fmod(-0, 0) 1241 Copysign(0, -1), // fmod(-0, Inf) 1242 NaN(), // fmod(-0, NaN) 1243 0, // fmod(0, -Inf) 1244 NaN(), // fmod(0, 0) 1245 0, // fmod(0, +Inf) 1246 NaN(), // fmod(0, NaN) 1247 Pi, // fmod(Pi, -Inf) 1248 NaN(), // fmod(Pi, 0) 1249 Pi, // fmod(Pi, +Inf) 1250 NaN(), // fmod(Pi, NaN) 1251 NaN(), // fmod(+Inf, -Inf) 1252 NaN(), // fmod(+Inf, -Pi) 1253 NaN(), // fmod(+Inf, 0) 1254 NaN(), // fmod(+Inf, Pi) 1255 NaN(), // fmod(+Inf, +Inf) 1256 NaN(), // fmod(+Inf, NaN) 1257 NaN(), // fmod(NaN, -Inf) 1258 NaN(), // fmod(NaN, -Pi) 1259 NaN(), // fmod(NaN, 0) 1260 NaN(), // fmod(NaN, Pi) 1261 NaN(), // fmod(NaN, +Inf) 1262 NaN(), // fmod(NaN, NaN) 1263 } 1264 1265 var vffrexpSC = []float64{ 1266 Inf(-1), 1267 Copysign(0, -1), 1268 0, 1269 Inf(1), 1270 NaN(), 1271 } 1272 var frexpSC = []fi{ 1273 {Inf(-1), 0}, 1274 {Copysign(0, -1), 0}, 1275 {0, 0}, 1276 {Inf(1), 0}, 1277 {NaN(), 0}, 1278 } 1279 1280 var vfgamma = [][2]float64{ 1281 {Inf(1), Inf(1)}, 1282 {Inf(-1), NaN()}, 1283 {0, Inf(1)}, 1284 {Copysign(0, -1), Inf(-1)}, 1285 {NaN(), NaN()}, 1286 {-1, NaN()}, 1287 {-2, NaN()}, 1288 {-3, NaN()}, 1289 {-1e16, NaN()}, 1290 {-1e300, NaN()}, 1291 {1.7e308, Inf(1)}, 1292 1293 // Test inputs inspired by Python test suite. 1294 // Outputs computed at high precision by PARI/GP. 1295 // If recomputing table entries, be careful to use 1296 // high-precision (%.1000g) formatting of the float64 inputs. 1297 // For example, -2.0000000000000004 is the float64 with exact value 1298 // -2.00000000000000044408920985626161695, and 1299 // gamma(-2.0000000000000004) = -1249999999999999.5386078562728167651513, while 1300 // gamma(-2.00000000000000044408920985626161695) = -1125899906826907.2044875028130093136826. 1301 // Thus the table lists -1.1258999068426235e+15 as the answer. 1302 {0.5, 1.772453850905516}, 1303 {1.5, 0.886226925452758}, 1304 {2.5, 1.329340388179137}, 1305 {3.5, 3.3233509704478426}, 1306 {-0.5, -3.544907701811032}, 1307 {-1.5, 2.363271801207355}, 1308 {-2.5, -0.9453087204829419}, 1309 {-3.5, 0.2700882058522691}, 1310 {0.1, 9.51350769866873}, 1311 {0.01, 99.4325851191506}, 1312 {1e-08, 9.999999942278434e+07}, 1313 {1e-16, 1e+16}, 1314 {0.001, 999.4237724845955}, 1315 {1e-16, 1e+16}, 1316 {1e-308, 1e+308}, 1317 {5.6e-309, 1.7857142857142864e+308}, 1318 {5.5e-309, Inf(1)}, 1319 {1e-309, Inf(1)}, 1320 {1e-323, Inf(1)}, 1321 {5e-324, Inf(1)}, 1322 {-0.1, -10.686287021193193}, 1323 {-0.01, -100.58719796441078}, 1324 {-1e-08, -1.0000000057721567e+08}, 1325 {-1e-16, -1e+16}, 1326 {-0.001, -1000.5782056293586}, 1327 {-1e-16, -1e+16}, 1328 {-1e-308, -1e+308}, 1329 {-5.6e-309, -1.7857142857142864e+308}, 1330 {-5.5e-309, Inf(-1)}, 1331 {-1e-309, Inf(-1)}, 1332 {-1e-323, Inf(-1)}, 1333 {-5e-324, Inf(-1)}, 1334 {-0.9999999999999999, -9.007199254740992e+15}, 1335 {-1.0000000000000002, 4.5035996273704955e+15}, 1336 {-1.9999999999999998, 2.2517998136852485e+15}, 1337 {-2.0000000000000004, -1.1258999068426235e+15}, 1338 {-100.00000000000001, -7.540083334883109e-145}, 1339 {-99.99999999999999, 7.540083334884096e-145}, 1340 {17, 2.0922789888e+13}, 1341 {171, 7.257415615307999e+306}, 1342 {171.6, 1.5858969096672565e+308}, 1343 {171.624, 1.7942117599248104e+308}, 1344 {171.625, Inf(1)}, 1345 {172, Inf(1)}, 1346 {2000, Inf(1)}, 1347 {-100.5, -3.3536908198076787e-159}, 1348 {-160.5, -5.255546447007829e-286}, 1349 {-170.5, -3.3127395215386074e-308}, 1350 {-171.5, 1.9316265431712e-310}, 1351 {-176.5, -1.196e-321}, 1352 {-177.5, 5e-324}, 1353 {-178.5, Copysign(0, -1)}, 1354 {-179.5, 0}, 1355 {-201.0001, 0}, 1356 {-202.9999, Copysign(0, -1)}, 1357 {-1000.5, Copysign(0, -1)}, 1358 {-1.0000000003e+09, Copysign(0, -1)}, 1359 {-4.5035996273704955e+15, 0}, 1360 {-63.349078729022985, 4.177797167776188e-88}, 1361 {-127.45117632943295, 1.183111089623681e-214}, 1362 } 1363 1364 var vfhypotSC = [][2]float64{ 1365 {Inf(-1), Inf(-1)}, 1366 {Inf(-1), 0}, 1367 {Inf(-1), Inf(1)}, 1368 {Inf(-1), NaN()}, 1369 {Copysign(0, -1), Copysign(0, -1)}, 1370 {Copysign(0, -1), 0}, 1371 {0, Copysign(0, -1)}, 1372 {0, 0}, // +0, +0 1373 {0, Inf(-1)}, 1374 {0, Inf(1)}, 1375 {0, NaN()}, 1376 {Inf(1), Inf(-1)}, 1377 {Inf(1), 0}, 1378 {Inf(1), Inf(1)}, 1379 {Inf(1), NaN()}, 1380 {NaN(), Inf(-1)}, 1381 {NaN(), 0}, 1382 {NaN(), Inf(1)}, 1383 {NaN(), NaN()}, 1384 } 1385 var hypotSC = []float64{ 1386 Inf(1), 1387 Inf(1), 1388 Inf(1), 1389 Inf(1), 1390 0, 1391 0, 1392 0, 1393 0, 1394 Inf(1), 1395 Inf(1), 1396 NaN(), 1397 Inf(1), 1398 Inf(1), 1399 Inf(1), 1400 Inf(1), 1401 Inf(1), 1402 NaN(), 1403 Inf(1), 1404 NaN(), 1405 } 1406 1407 var ilogbSC = []int{ 1408 MaxInt32, 1409 MinInt32, 1410 MaxInt32, 1411 MaxInt32, 1412 } 1413 1414 var vfj0SC = []float64{ 1415 Inf(-1), 1416 0, 1417 Inf(1), 1418 NaN(), 1419 } 1420 var j0SC = []float64{ 1421 0, 1422 1, 1423 0, 1424 NaN(), 1425 } 1426 var j1SC = []float64{ 1427 0, 1428 0, 1429 0, 1430 NaN(), 1431 } 1432 var j2SC = []float64{ 1433 0, 1434 0, 1435 0, 1436 NaN(), 1437 } 1438 var jM3SC = []float64{ 1439 0, 1440 0, 1441 0, 1442 NaN(), 1443 } 1444 1445 var vfldexpSC = []fi{ 1446 {0, 0}, 1447 {0, -1075}, 1448 {0, 1024}, 1449 {Copysign(0, -1), 0}, 1450 {Copysign(0, -1), -1075}, 1451 {Copysign(0, -1), 1024}, 1452 {Inf(1), 0}, 1453 {Inf(1), -1024}, 1454 {Inf(-1), 0}, 1455 {Inf(-1), -1024}, 1456 {NaN(), -1024}, 1457 {10, int(1) << (uint64(unsafe.Sizeof(0)-1) * 8)}, 1458 {10, -(int(1) << (uint64(unsafe.Sizeof(0)-1) * 8))}, 1459 } 1460 var ldexpSC = []float64{ 1461 0, 1462 0, 1463 0, 1464 Copysign(0, -1), 1465 Copysign(0, -1), 1466 Copysign(0, -1), 1467 Inf(1), 1468 Inf(1), 1469 Inf(-1), 1470 Inf(-1), 1471 NaN(), 1472 Inf(1), 1473 0, 1474 } 1475 1476 var vflgammaSC = []float64{ 1477 Inf(-1), 1478 -3, 1479 0, 1480 1, 1481 2, 1482 Inf(1), 1483 NaN(), 1484 } 1485 var lgammaSC = []fi{ 1486 {Inf(-1), 1}, 1487 {Inf(1), 1}, 1488 {Inf(1), 1}, 1489 {0, 1}, 1490 {0, 1}, 1491 {Inf(1), 1}, 1492 {NaN(), 1}, 1493 } 1494 1495 var vflogSC = []float64{ 1496 Inf(-1), 1497 -Pi, 1498 Copysign(0, -1), 1499 0, 1500 1, 1501 Inf(1), 1502 NaN(), 1503 } 1504 var logSC = []float64{ 1505 NaN(), 1506 NaN(), 1507 Inf(-1), 1508 Inf(-1), 1509 0, 1510 Inf(1), 1511 NaN(), 1512 } 1513 1514 var vflogbSC = []float64{ 1515 Inf(-1), 1516 0, 1517 Inf(1), 1518 NaN(), 1519 } 1520 var logbSC = []float64{ 1521 Inf(1), 1522 Inf(-1), 1523 Inf(1), 1524 NaN(), 1525 } 1526 1527 var vflog1pSC = []float64{ 1528 Inf(-1), 1529 -Pi, 1530 -1, 1531 Copysign(0, -1), 1532 0, 1533 Inf(1), 1534 NaN(), 1535 4503599627370496.5, // Issue #29488 1536 } 1537 var log1pSC = []float64{ 1538 NaN(), 1539 NaN(), 1540 Inf(-1), 1541 Copysign(0, -1), 1542 0, 1543 Inf(1), 1544 NaN(), 1545 36.04365338911715, // Issue #29488 1546 } 1547 1548 var vfmodfSC = []float64{ 1549 Inf(-1), 1550 Copysign(0, -1), 1551 Inf(1), 1552 NaN(), 1553 } 1554 var modfSC = [][2]float64{ 1555 {Inf(-1), NaN()}, // [2]float64{Copysign(0, -1), Inf(-1)}, 1556 {Copysign(0, -1), Copysign(0, -1)}, 1557 {Inf(1), NaN()}, // [2]float64{0, Inf(1)}, 1558 {NaN(), NaN()}, 1559 } 1560 1561 var vfnextafter32SC = [][2]float32{ 1562 {0, 0}, 1563 {0, float32(Copysign(0, -1))}, 1564 {0, -1}, 1565 {0, float32(NaN())}, 1566 {float32(Copysign(0, -1)), 1}, 1567 {float32(Copysign(0, -1)), 0}, 1568 {float32(Copysign(0, -1)), float32(Copysign(0, -1))}, 1569 {float32(Copysign(0, -1)), -1}, 1570 {float32(NaN()), 0}, 1571 {float32(NaN()), float32(NaN())}, 1572 } 1573 var nextafter32SC = []float32{ 1574 0, 1575 0, 1576 -1.401298464e-45, // Float32frombits(0x80000001) 1577 float32(NaN()), 1578 1.401298464e-45, // Float32frombits(0x00000001) 1579 float32(Copysign(0, -1)), 1580 float32(Copysign(0, -1)), 1581 -1.401298464e-45, // Float32frombits(0x80000001) 1582 float32(NaN()), 1583 float32(NaN()), 1584 } 1585 1586 var vfnextafter64SC = [][2]float64{ 1587 {0, 0}, 1588 {0, Copysign(0, -1)}, 1589 {0, -1}, 1590 {0, NaN()}, 1591 {Copysign(0, -1), 1}, 1592 {Copysign(0, -1), 0}, 1593 {Copysign(0, -1), Copysign(0, -1)}, 1594 {Copysign(0, -1), -1}, 1595 {NaN(), 0}, 1596 {NaN(), NaN()}, 1597 } 1598 var nextafter64SC = []float64{ 1599 0, 1600 0, 1601 -4.9406564584124654418e-324, // Float64frombits(0x8000000000000001) 1602 NaN(), 1603 4.9406564584124654418e-324, // Float64frombits(0x0000000000000001) 1604 Copysign(0, -1), 1605 Copysign(0, -1), 1606 -4.9406564584124654418e-324, // Float64frombits(0x8000000000000001) 1607 NaN(), 1608 NaN(), 1609 } 1610 1611 var vfpowSC = [][2]float64{ 1612 {Inf(-1), -Pi}, 1613 {Inf(-1), -3}, 1614 {Inf(-1), Copysign(0, -1)}, 1615 {Inf(-1), 0}, 1616 {Inf(-1), 1}, 1617 {Inf(-1), 3}, 1618 {Inf(-1), Pi}, 1619 {Inf(-1), 0.5}, 1620 {Inf(-1), NaN()}, 1621 1622 {-Pi, Inf(-1)}, 1623 {-Pi, -Pi}, 1624 {-Pi, Copysign(0, -1)}, 1625 {-Pi, 0}, 1626 {-Pi, 1}, 1627 {-Pi, Pi}, 1628 {-Pi, Inf(1)}, 1629 {-Pi, NaN()}, 1630 1631 {-1, Inf(-1)}, 1632 {-1, Inf(1)}, 1633 {-1, NaN()}, 1634 {-0.5, Inf(-1)}, 1635 {-0.5, Inf(1)}, 1636 {Copysign(0, -1), Inf(-1)}, 1637 {Copysign(0, -1), -Pi}, 1638 {Copysign(0, -1), -0.5}, 1639 {Copysign(0, -1), -3}, 1640 {Copysign(0, -1), 3}, 1641 {Copysign(0, -1), Pi}, 1642 {Copysign(0, -1), 0.5}, 1643 {Copysign(0, -1), Inf(1)}, 1644 1645 {0, Inf(-1)}, 1646 {0, -Pi}, 1647 {0, -3}, 1648 {0, Copysign(0, -1)}, 1649 {0, 0}, 1650 {0, 3}, 1651 {0, Pi}, 1652 {0, Inf(1)}, 1653 {0, NaN()}, 1654 1655 {0.5, Inf(-1)}, 1656 {0.5, Inf(1)}, 1657 {1, Inf(-1)}, 1658 {1, Inf(1)}, 1659 {1, NaN()}, 1660 1661 {Pi, Inf(-1)}, 1662 {Pi, Copysign(0, -1)}, 1663 {Pi, 0}, 1664 {Pi, 1}, 1665 {Pi, Inf(1)}, 1666 {Pi, NaN()}, 1667 {Inf(1), -Pi}, 1668 {Inf(1), Copysign(0, -1)}, 1669 {Inf(1), 0}, 1670 {Inf(1), 1}, 1671 {Inf(1), Pi}, 1672 {Inf(1), NaN()}, 1673 {NaN(), -Pi}, 1674 {NaN(), Copysign(0, -1)}, 1675 {NaN(), 0}, 1676 {NaN(), 1}, 1677 {NaN(), Pi}, 1678 {NaN(), NaN()}, 1679 1680 // Issue #7394 overflow checks 1681 {2, float64(1 << 32)}, 1682 {2, -float64(1 << 32)}, 1683 {-2, float64(1<<32 + 1)}, 1684 {0.5, float64(1 << 45)}, 1685 {0.5, -float64(1 << 45)}, 1686 {Nextafter(1, 2), float64(1 << 63)}, 1687 {Nextafter(1, -2), float64(1 << 63)}, 1688 {Nextafter(-1, 2), float64(1 << 63)}, 1689 {Nextafter(-1, -2), float64(1 << 63)}, 1690 1691 // Issue #57465 1692 {Copysign(0, -1), 1e19}, 1693 {Copysign(0, -1), -1e19}, 1694 {Copysign(0, -1), 1<<53 - 1}, 1695 {Copysign(0, -1), -(1<<53 - 1)}, 1696 } 1697 var powSC = []float64{ 1698 0, // pow(-Inf, -Pi) 1699 Copysign(0, -1), // pow(-Inf, -3) 1700 1, // pow(-Inf, -0) 1701 1, // pow(-Inf, +0) 1702 Inf(-1), // pow(-Inf, 1) 1703 Inf(-1), // pow(-Inf, 3) 1704 Inf(1), // pow(-Inf, Pi) 1705 Inf(1), // pow(-Inf, 0.5) 1706 NaN(), // pow(-Inf, NaN) 1707 0, // pow(-Pi, -Inf) 1708 NaN(), // pow(-Pi, -Pi) 1709 1, // pow(-Pi, -0) 1710 1, // pow(-Pi, +0) 1711 -Pi, // pow(-Pi, 1) 1712 NaN(), // pow(-Pi, Pi) 1713 Inf(1), // pow(-Pi, +Inf) 1714 NaN(), // pow(-Pi, NaN) 1715 1, // pow(-1, -Inf) IEEE 754-2008 1716 1, // pow(-1, +Inf) IEEE 754-2008 1717 NaN(), // pow(-1, NaN) 1718 Inf(1), // pow(-1/2, -Inf) 1719 0, // pow(-1/2, +Inf) 1720 Inf(1), // pow(-0, -Inf) 1721 Inf(1), // pow(-0, -Pi) 1722 Inf(1), // pow(-0, -0.5) 1723 Inf(-1), // pow(-0, -3) IEEE 754-2008 1724 Copysign(0, -1), // pow(-0, 3) IEEE 754-2008 1725 0, // pow(-0, +Pi) 1726 0, // pow(-0, 0.5) 1727 0, // pow(-0, +Inf) 1728 Inf(1), // pow(+0, -Inf) 1729 Inf(1), // pow(+0, -Pi) 1730 Inf(1), // pow(+0, -3) 1731 1, // pow(+0, -0) 1732 1, // pow(+0, +0) 1733 0, // pow(+0, 3) 1734 0, // pow(+0, +Pi) 1735 0, // pow(+0, +Inf) 1736 NaN(), // pow(+0, NaN) 1737 Inf(1), // pow(1/2, -Inf) 1738 0, // pow(1/2, +Inf) 1739 1, // pow(1, -Inf) IEEE 754-2008 1740 1, // pow(1, +Inf) IEEE 754-2008 1741 1, // pow(1, NaN) IEEE 754-2008 1742 0, // pow(+Pi, -Inf) 1743 1, // pow(+Pi, -0) 1744 1, // pow(+Pi, +0) 1745 Pi, // pow(+Pi, 1) 1746 Inf(1), // pow(+Pi, +Inf) 1747 NaN(), // pow(+Pi, NaN) 1748 0, // pow(+Inf, -Pi) 1749 1, // pow(+Inf, -0) 1750 1, // pow(+Inf, +0) 1751 Inf(1), // pow(+Inf, 1) 1752 Inf(1), // pow(+Inf, Pi) 1753 NaN(), // pow(+Inf, NaN) 1754 NaN(), // pow(NaN, -Pi) 1755 1, // pow(NaN, -0) 1756 1, // pow(NaN, +0) 1757 NaN(), // pow(NaN, 1) 1758 NaN(), // pow(NaN, +Pi) 1759 NaN(), // pow(NaN, NaN) 1760 1761 // Issue #7394 overflow checks 1762 Inf(1), // pow(2, float64(1 << 32)) 1763 0, // pow(2, -float64(1 << 32)) 1764 Inf(-1), // pow(-2, float64(1<<32 + 1)) 1765 0, // pow(1/2, float64(1 << 45)) 1766 Inf(1), // pow(1/2, -float64(1 << 45)) 1767 Inf(1), // pow(Nextafter(1, 2), float64(1 << 63)) 1768 0, // pow(Nextafter(1, -2), float64(1 << 63)) 1769 0, // pow(Nextafter(-1, 2), float64(1 << 63)) 1770 Inf(1), // pow(Nextafter(-1, -2), float64(1 << 63)) 1771 1772 // Issue #57465 1773 0, // pow(-0, 1e19) 1774 Inf(1), // pow(-0, -1e19) 1775 Copysign(0, -1), // pow(-0, 1<<53 -1) 1776 Inf(-1), // pow(-0, -(1<<53 -1)) 1777 } 1778 1779 var vfpow10SC = []int{ 1780 MinInt32, 1781 -324, 1782 -323, 1783 -50, 1784 -22, 1785 -1, 1786 0, 1787 1, 1788 22, 1789 50, 1790 100, 1791 200, 1792 308, 1793 309, 1794 MaxInt32, 1795 } 1796 1797 var pow10SC = []float64{ 1798 0, // pow10(MinInt32) 1799 0, // pow10(-324) 1800 1.0e-323, // pow10(-323) 1801 1.0e-50, // pow10(-50) 1802 1.0e-22, // pow10(-22) 1803 1.0e-1, // pow10(-1) 1804 1.0e0, // pow10(0) 1805 1.0e1, // pow10(1) 1806 1.0e22, // pow10(22) 1807 1.0e50, // pow10(50) 1808 1.0e100, // pow10(100) 1809 1.0e200, // pow10(200) 1810 1.0e308, // pow10(308) 1811 Inf(1), // pow10(309) 1812 Inf(1), // pow10(MaxInt32) 1813 } 1814 1815 var vfroundSC = [][2]float64{ 1816 {0, 0}, 1817 {1.390671161567e-309, 0}, // denormal 1818 {0.49999999999999994, 0}, // 0.5-epsilon 1819 {0.5, 1}, 1820 {0.5000000000000001, 1}, // 0.5+epsilon 1821 {-1.5, -2}, 1822 {-2.5, -3}, 1823 {NaN(), NaN()}, 1824 {Inf(1), Inf(1)}, 1825 {2251799813685249.5, 2251799813685250}, // 1 bit fraction 1826 {2251799813685250.5, 2251799813685251}, 1827 {4503599627370495.5, 4503599627370496}, // 1 bit fraction, rounding to 0 bit fraction 1828 {4503599627370497, 4503599627370497}, // large integer 1829 } 1830 var vfroundEvenSC = [][2]float64{ 1831 {0, 0}, 1832 {1.390671161567e-309, 0}, // denormal 1833 {0.49999999999999994, 0}, // 0.5-epsilon 1834 {0.5, 0}, 1835 {0.5000000000000001, 1}, // 0.5+epsilon 1836 {-1.5, -2}, 1837 {-2.5, -2}, 1838 {NaN(), NaN()}, 1839 {Inf(1), Inf(1)}, 1840 {2251799813685249.5, 2251799813685250}, // 1 bit fraction 1841 {2251799813685250.5, 2251799813685250}, 1842 {4503599627370495.5, 4503599627370496}, // 1 bit fraction, rounding to 0 bit fraction 1843 {4503599627370497, 4503599627370497}, // large integer 1844 } 1845 1846 var vfsignbitSC = []float64{ 1847 Inf(-1), 1848 Copysign(0, -1), 1849 0, 1850 Inf(1), 1851 NaN(), 1852 } 1853 var signbitSC = []bool{ 1854 true, 1855 true, 1856 false, 1857 false, 1858 false, 1859 } 1860 1861 var vfsinSC = []float64{ 1862 Inf(-1), 1863 Copysign(0, -1), 1864 0, 1865 Inf(1), 1866 NaN(), 1867 } 1868 var sinSC = []float64{ 1869 NaN(), 1870 Copysign(0, -1), 1871 0, 1872 NaN(), 1873 NaN(), 1874 } 1875 1876 var vfsinhSC = []float64{ 1877 Inf(-1), 1878 Copysign(0, -1), 1879 0, 1880 Inf(1), 1881 NaN(), 1882 } 1883 var sinhSC = []float64{ 1884 Inf(-1), 1885 Copysign(0, -1), 1886 0, 1887 Inf(1), 1888 NaN(), 1889 } 1890 1891 var vfsqrtSC = []float64{ 1892 Inf(-1), 1893 -Pi, 1894 Copysign(0, -1), 1895 0, 1896 Inf(1), 1897 NaN(), 1898 Float64frombits(2), // subnormal; see https://golang.org/issue/13013 1899 } 1900 var sqrtSC = []float64{ 1901 NaN(), 1902 NaN(), 1903 Copysign(0, -1), 1904 0, 1905 Inf(1), 1906 NaN(), 1907 3.1434555694052576e-162, 1908 } 1909 1910 var vftanhSC = []float64{ 1911 Inf(-1), 1912 Copysign(0, -1), 1913 0, 1914 Inf(1), 1915 NaN(), 1916 } 1917 var tanhSC = []float64{ 1918 -1, 1919 Copysign(0, -1), 1920 0, 1921 1, 1922 NaN(), 1923 } 1924 1925 var vfy0SC = []float64{ 1926 Inf(-1), 1927 0, 1928 Inf(1), 1929 NaN(), 1930 -1, 1931 } 1932 var y0SC = []float64{ 1933 NaN(), 1934 Inf(-1), 1935 0, 1936 NaN(), 1937 NaN(), 1938 } 1939 var y1SC = []float64{ 1940 NaN(), 1941 Inf(-1), 1942 0, 1943 NaN(), 1944 NaN(), 1945 } 1946 var y2SC = []float64{ 1947 NaN(), 1948 Inf(-1), 1949 0, 1950 NaN(), 1951 NaN(), 1952 } 1953 var yM3SC = []float64{ 1954 NaN(), 1955 Inf(1), 1956 0, 1957 NaN(), 1958 NaN(), 1959 } 1960 1961 // arguments and expected results for boundary cases 1962 const ( 1963 SmallestNormalFloat64 = 2.2250738585072014e-308 // 2**-1022 1964 LargestSubnormalFloat64 = SmallestNormalFloat64 - SmallestNonzeroFloat64 1965 ) 1966 1967 var vffrexpBC = []float64{ 1968 SmallestNormalFloat64, 1969 LargestSubnormalFloat64, 1970 SmallestNonzeroFloat64, 1971 MaxFloat64, 1972 -SmallestNormalFloat64, 1973 -LargestSubnormalFloat64, 1974 -SmallestNonzeroFloat64, 1975 -MaxFloat64, 1976 } 1977 var frexpBC = []fi{ 1978 {0.5, -1021}, 1979 {0.99999999999999978, -1022}, 1980 {0.5, -1073}, 1981 {0.99999999999999989, 1024}, 1982 {-0.5, -1021}, 1983 {-0.99999999999999978, -1022}, 1984 {-0.5, -1073}, 1985 {-0.99999999999999989, 1024}, 1986 } 1987 1988 var vfldexpBC = []fi{ 1989 {SmallestNormalFloat64, -52}, 1990 {LargestSubnormalFloat64, -51}, 1991 {SmallestNonzeroFloat64, 1074}, 1992 {MaxFloat64, -(1023 + 1074)}, 1993 {1, -1075}, 1994 {-1, -1075}, 1995 {1, 1024}, 1996 {-1, 1024}, 1997 {1.0000000000000002, -1075}, 1998 {1, -1075}, 1999 } 2000 var ldexpBC = []float64{ 2001 SmallestNonzeroFloat64, 2002 1e-323, // 2**-1073 2003 1, 2004 1e-323, // 2**-1073 2005 0, 2006 Copysign(0, -1), 2007 Inf(1), 2008 Inf(-1), 2009 SmallestNonzeroFloat64, 2010 0, 2011 } 2012 2013 var logbBC = []float64{ 2014 -1022, 2015 -1023, 2016 -1074, 2017 1023, 2018 -1022, 2019 -1023, 2020 -1074, 2021 1023, 2022 } 2023 2024 // Test cases were generated with Berkeley TestFloat-3e/testfloat_gen. 2025 // http://www.jhauser.us/arithmetic/TestFloat.html. 2026 // The default rounding mode is selected (nearest/even), and exception flags are ignored. 2027 var fmaC = []struct{ x, y, z, want float64 }{ 2028 // Large exponent spread 2029 {-3.999999999999087, -1.1123914289620494e-16, -7.999877929687506, -7.999877929687505}, 2030 {-262112.0000004768, -0.06251525855623184, 1.1102230248837136e-16, 16385.99945072085}, 2031 {-6.462348523533467e-27, -2.3763644720331857e-211, 4.000000000931324, 4.000000000931324}, 2032 2033 // Effective addition 2034 {-2.0000000037252907, 6.7904383376e-313, -3.3951933161e-313, -1.697607001654e-312}, 2035 {-0.12499999999999999, 512.007568359375, -1.4193627164960366e-16, -64.00094604492188}, 2036 {-2.7550648847397148e-39, -3.4028301595800694e+38, 0.9960937495343386, 1.9335955376735676}, 2037 {5.723369164769208e+24, 3.8149300927159385e-06, 1.84489958778182e+19, 4.028324913621874e+19}, 2038 {-0.4843749999990904, -3.6893487872543293e+19, 9.223653786709391e+18, 2.7093936974938993e+19}, 2039 {-3.8146972665201165e-06, 4.2949672959999385e+09, -2.2204460489938386e-16, -16384.000003844263}, 2040 {6.98156394130982e-309, -1.1072962560000002e+09, -4.4414561548793455e-308, -7.73065965765153e-300}, 2041 2042 // Effective subtraction 2043 {5e-324, 4.5, -2e-323, 0}, 2044 {5e-324, 7, -3.5e-323, 0}, 2045 {5e-324, 0.5000000000000001, -5e-324, Copysign(0, -1)}, 2046 {-2.1240680525e-314, -1.233647078189316e+308, -0.25781249999954525, -0.25780987964919844}, 2047 {8.579992955364441e-308, 0.6037391876780558, -4.4501307410480706e-308, 7.29947236107098e-309}, 2048 {-4.450143471986689e-308, -0.9960937499927239, -4.450419332475649e-308, -1.7659233458788e-310}, 2049 {1.4932076393918112, -2.2248022430460833e-308, 4.449875571054211e-308, 1.127783865601762e-308}, 2050 2051 // Overflow 2052 {-2.288020632214759e+38, -8.98846570988901e+307, 1.7696041796300924e+308, Inf(0)}, 2053 {1.4888652783208255e+308, -9.007199254742012e+15, -6.807282911929205e+38, Inf(-1)}, 2054 {9.142703268902826e+192, -1.3504889569802838e+296, -1.9082200803806996e-89, Inf(-1)}, 2055 2056 // Finite x and y, but non-finite z. 2057 {31.99218749627471, -1.7976930544991702e+308, Inf(0), Inf(0)}, 2058 {-1.7976931281784667e+308, -2.0009765625002265, Inf(-1), Inf(-1)}, 2059 2060 // Special 2061 {0, 0, 0, 0}, 2062 {-1.1754226043408471e-38, NaN(), Inf(0), NaN()}, 2063 {0, 0, 2.22507385643494e-308, 2.22507385643494e-308}, 2064 {-8.65697792e+09, NaN(), -7.516192799999999e+09, NaN()}, 2065 {-0.00012207403779029757, 3.221225471996093e+09, NaN(), NaN()}, 2066 {Inf(-1), 0.1252441407414153, -1.387184532981584e-76, Inf(-1)}, 2067 {Inf(0), 1.525878907671432e-05, -9.214364835452549e+18, Inf(0)}, 2068 2069 // Random 2070 {0.1777916152213626, -32.000015266239636, -2.2204459148334633e-16, -5.689334401293007}, 2071 {-2.0816681711722314e-16, -0.4997558592585846, -0.9465627129124969, -0.9465627129124968}, 2072 {-1.9999997615814211, 1.8518819259933516e+19, 16.874999999999996, -3.703763410463646e+19}, 2073 {-0.12499994039717421, 32767.99999976135, -2.0752587082923246e+19, -2.075258708292325e+19}, 2074 {7.705600568510257e-34, -1.801432979000528e+16, -0.17224197722973714, -0.17224197722973716}, 2075 {3.8988133103758913e-308, -0.9848632812499999, 3.893879244098556e-308, 5.40811742605814e-310}, 2076 {-0.012651981190687427, 6.911985574912436e+38, 6.669240527007144e+18, -8.745031148409496e+36}, 2077 {4.612811918325842e+18, 1.4901161193847641e-08, 2.6077032311277997e-08, 6.873625395187494e+10}, 2078 {-9.094947033611148e-13, 4.450691014249257e-308, 2.086006742350485e-308, 2.086006742346437e-308}, 2079 {-7.751454006381804e-05, 5.588653777189071e-308, -2.2207280111272877e-308, -2.2211612130544025e-308}, 2080 } 2081 2082 var sqrt32 = []float32{ 2083 0, 2084 float32(Copysign(0, -1)), 2085 float32(NaN()), 2086 float32(Inf(1)), 2087 float32(Inf(-1)), 2088 1, 2089 2, 2090 -2, 2091 4.9790119248836735e+00, 2092 7.7388724745781045e+00, 2093 -2.7688005719200159e-01, 2094 -5.0106036182710749e+00, 2095 } 2096 2097 func tolerance(a, b, e float64) bool { 2098 // Multiplying by e here can underflow denormal values to zero. 2099 // Check a==b so that at least if a and b are small and identical 2100 // we say they match. 2101 if a == b { 2102 return true 2103 } 2104 d := a - b 2105 if d < 0 { 2106 d = -d 2107 } 2108 2109 // note: b is correct (expected) value, a is actual value. 2110 // make error tolerance a fraction of b, not a. 2111 if b != 0 { 2112 e = e * b 2113 if e < 0 { 2114 e = -e 2115 } 2116 } 2117 return d < e 2118 } 2119 func close(a, b float64) bool { return tolerance(a, b, 1e-14) } 2120 func veryclose(a, b float64) bool { return tolerance(a, b, 4e-16) } 2121 func soclose(a, b, e float64) bool { return tolerance(a, b, e) } 2122 func alike(a, b float64) bool { 2123 switch { 2124 case IsNaN(a) && IsNaN(b): 2125 return true 2126 case a == b: 2127 return Signbit(a) == Signbit(b) 2128 } 2129 return false 2130 } 2131 2132 func TestNaN(t *testing.T) { 2133 f64 := NaN() 2134 if f64 == f64 { 2135 t.Fatalf("NaN() returns %g, expected NaN", f64) 2136 } 2137 f32 := float32(f64) 2138 if f32 == f32 { 2139 t.Fatalf("float32(NaN()) is %g, expected NaN", f32) 2140 } 2141 } 2142 2143 func TestAcos(t *testing.T) { 2144 for i := 0; i < len(vf); i++ { 2145 a := vf[i] / 10 2146 if f := Acos(a); !close(acos[i], f) { 2147 t.Errorf("Acos(%g) = %g, want %g", a, f, acos[i]) 2148 } 2149 } 2150 for i := 0; i < len(vfacosSC); i++ { 2151 if f := Acos(vfacosSC[i]); !alike(acosSC[i], f) { 2152 t.Errorf("Acos(%g) = %g, want %g", vfacosSC[i], f, acosSC[i]) 2153 } 2154 } 2155 } 2156 2157 func TestAcosh(t *testing.T) { 2158 for i := 0; i < len(vf); i++ { 2159 a := 1 + Abs(vf[i]) 2160 if f := Acosh(a); !veryclose(acosh[i], f) { 2161 t.Errorf("Acosh(%g) = %g, want %g", a, f, acosh[i]) 2162 } 2163 } 2164 for i := 0; i < len(vfacoshSC); i++ { 2165 if f := Acosh(vfacoshSC[i]); !alike(acoshSC[i], f) { 2166 t.Errorf("Acosh(%g) = %g, want %g", vfacoshSC[i], f, acoshSC[i]) 2167 } 2168 } 2169 } 2170 2171 func TestAsin(t *testing.T) { 2172 for i := 0; i < len(vf); i++ { 2173 a := vf[i] / 10 2174 if f := Asin(a); !veryclose(asin[i], f) { 2175 t.Errorf("Asin(%g) = %g, want %g", a, f, asin[i]) 2176 } 2177 } 2178 for i := 0; i < len(vfasinSC); i++ { 2179 if f := Asin(vfasinSC[i]); !alike(asinSC[i], f) { 2180 t.Errorf("Asin(%g) = %g, want %g", vfasinSC[i], f, asinSC[i]) 2181 } 2182 } 2183 } 2184 2185 func TestAsinh(t *testing.T) { 2186 for i := 0; i < len(vf); i++ { 2187 if f := Asinh(vf[i]); !veryclose(asinh[i], f) { 2188 t.Errorf("Asinh(%g) = %g, want %g", vf[i], f, asinh[i]) 2189 } 2190 } 2191 for i := 0; i < len(vfasinhSC); i++ { 2192 if f := Asinh(vfasinhSC[i]); !alike(asinhSC[i], f) { 2193 t.Errorf("Asinh(%g) = %g, want %g", vfasinhSC[i], f, asinhSC[i]) 2194 } 2195 } 2196 } 2197 2198 func TestAtan(t *testing.T) { 2199 for i := 0; i < len(vf); i++ { 2200 if f := Atan(vf[i]); !veryclose(atan[i], f) { 2201 t.Errorf("Atan(%g) = %g, want %g", vf[i], f, atan[i]) 2202 } 2203 } 2204 for i := 0; i < len(vfatanSC); i++ { 2205 if f := Atan(vfatanSC[i]); !alike(atanSC[i], f) { 2206 t.Errorf("Atan(%g) = %g, want %g", vfatanSC[i], f, atanSC[i]) 2207 } 2208 } 2209 } 2210 2211 func TestAtanh(t *testing.T) { 2212 for i := 0; i < len(vf); i++ { 2213 a := vf[i] / 10 2214 if f := Atanh(a); !veryclose(atanh[i], f) { 2215 t.Errorf("Atanh(%g) = %g, want %g", a, f, atanh[i]) 2216 } 2217 } 2218 for i := 0; i < len(vfatanhSC); i++ { 2219 if f := Atanh(vfatanhSC[i]); !alike(atanhSC[i], f) { 2220 t.Errorf("Atanh(%g) = %g, want %g", vfatanhSC[i], f, atanhSC[i]) 2221 } 2222 } 2223 } 2224 2225 func TestAtan2(t *testing.T) { 2226 for i := 0; i < len(vf); i++ { 2227 if f := Atan2(10, vf[i]); !veryclose(atan2[i], f) { 2228 t.Errorf("Atan2(10, %g) = %g, want %g", vf[i], f, atan2[i]) 2229 } 2230 } 2231 for i := 0; i < len(vfatan2SC); i++ { 2232 if f := Atan2(vfatan2SC[i][0], vfatan2SC[i][1]); !alike(atan2SC[i], f) { 2233 t.Errorf("Atan2(%g, %g) = %g, want %g", vfatan2SC[i][0], vfatan2SC[i][1], f, atan2SC[i]) 2234 } 2235 } 2236 } 2237 2238 func TestCbrt(t *testing.T) { 2239 for i := 0; i < len(vf); i++ { 2240 if f := Cbrt(vf[i]); !veryclose(cbrt[i], f) { 2241 t.Errorf("Cbrt(%g) = %g, want %g", vf[i], f, cbrt[i]) 2242 } 2243 } 2244 for i := 0; i < len(vfcbrtSC); i++ { 2245 if f := Cbrt(vfcbrtSC[i]); !alike(cbrtSC[i], f) { 2246 t.Errorf("Cbrt(%g) = %g, want %g", vfcbrtSC[i], f, cbrtSC[i]) 2247 } 2248 } 2249 } 2250 2251 func TestCeil(t *testing.T) { 2252 for i := 0; i < len(vf); i++ { 2253 if f := Ceil(vf[i]); !alike(ceil[i], f) { 2254 t.Errorf("Ceil(%g) = %g, want %g", vf[i], f, ceil[i]) 2255 } 2256 } 2257 for i := 0; i < len(vfceilSC); i++ { 2258 if f := Ceil(vfceilSC[i]); !alike(ceilSC[i], f) { 2259 t.Errorf("Ceil(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i]) 2260 } 2261 } 2262 } 2263 2264 func TestCopysign(t *testing.T) { 2265 for i := 0; i < len(vf); i++ { 2266 if f := Copysign(vf[i], -1); copysign[i] != f { 2267 t.Errorf("Copysign(%g, -1) = %g, want %g", vf[i], f, copysign[i]) 2268 } 2269 } 2270 for i := 0; i < len(vf); i++ { 2271 if f := Copysign(vf[i], 1); -copysign[i] != f { 2272 t.Errorf("Copysign(%g, 1) = %g, want %g", vf[i], f, -copysign[i]) 2273 } 2274 } 2275 for i := 0; i < len(vfcopysignSC); i++ { 2276 if f := Copysign(vfcopysignSC[i], -1); !alike(copysignSC[i], f) { 2277 t.Errorf("Copysign(%g, -1) = %g, want %g", vfcopysignSC[i], f, copysignSC[i]) 2278 } 2279 } 2280 } 2281 2282 func TestCos(t *testing.T) { 2283 for i := 0; i < len(vf); i++ { 2284 if f := Cos(vf[i]); !veryclose(cos[i], f) { 2285 t.Errorf("Cos(%g) = %g, want %g", vf[i], f, cos[i]) 2286 } 2287 } 2288 for i := 0; i < len(vfcosSC); i++ { 2289 if f := Cos(vfcosSC[i]); !alike(cosSC[i], f) { 2290 t.Errorf("Cos(%g) = %g, want %g", vfcosSC[i], f, cosSC[i]) 2291 } 2292 } 2293 } 2294 2295 func TestCosh(t *testing.T) { 2296 for i := 0; i < len(vf); i++ { 2297 if f := Cosh(vf[i]); !close(cosh[i], f) { 2298 t.Errorf("Cosh(%g) = %g, want %g", vf[i], f, cosh[i]) 2299 } 2300 } 2301 for i := 0; i < len(vfcoshSC); i++ { 2302 if f := Cosh(vfcoshSC[i]); !alike(coshSC[i], f) { 2303 t.Errorf("Cosh(%g) = %g, want %g", vfcoshSC[i], f, coshSC[i]) 2304 } 2305 } 2306 } 2307 2308 func TestErf(t *testing.T) { 2309 for i := 0; i < len(vf); i++ { 2310 a := vf[i] / 10 2311 if f := Erf(a); !veryclose(erf[i], f) { 2312 t.Errorf("Erf(%g) = %g, want %g", a, f, erf[i]) 2313 } 2314 } 2315 for i := 0; i < len(vferfSC); i++ { 2316 if f := Erf(vferfSC[i]); !alike(erfSC[i], f) { 2317 t.Errorf("Erf(%g) = %g, want %g", vferfSC[i], f, erfSC[i]) 2318 } 2319 } 2320 } 2321 2322 func TestErfc(t *testing.T) { 2323 for i := 0; i < len(vf); i++ { 2324 a := vf[i] / 10 2325 if f := Erfc(a); !veryclose(erfc[i], f) { 2326 t.Errorf("Erfc(%g) = %g, want %g", a, f, erfc[i]) 2327 } 2328 } 2329 for i := 0; i < len(vferfcSC); i++ { 2330 if f := Erfc(vferfcSC[i]); !alike(erfcSC[i], f) { 2331 t.Errorf("Erfc(%g) = %g, want %g", vferfcSC[i], f, erfcSC[i]) 2332 } 2333 } 2334 } 2335 2336 func TestErfinv(t *testing.T) { 2337 for i := 0; i < len(vf); i++ { 2338 a := vf[i] / 10 2339 if f := Erfinv(a); !veryclose(erfinv[i], f) { 2340 t.Errorf("Erfinv(%g) = %g, want %g", a, f, erfinv[i]) 2341 } 2342 } 2343 for i := 0; i < len(vferfinvSC); i++ { 2344 if f := Erfinv(vferfinvSC[i]); !alike(erfinvSC[i], f) { 2345 t.Errorf("Erfinv(%g) = %g, want %g", vferfinvSC[i], f, erfinvSC[i]) 2346 } 2347 } 2348 for x := -0.9; x <= 0.90; x += 1e-2 { 2349 if f := Erf(Erfinv(x)); !close(x, f) { 2350 t.Errorf("Erf(Erfinv(%g)) = %g, want %g", x, f, x) 2351 } 2352 } 2353 for x := -0.9; x <= 0.90; x += 1e-2 { 2354 if f := Erfinv(Erf(x)); !close(x, f) { 2355 t.Errorf("Erfinv(Erf(%g)) = %g, want %g", x, f, x) 2356 } 2357 } 2358 } 2359 2360 func TestErfcinv(t *testing.T) { 2361 for i := 0; i < len(vf); i++ { 2362 a := 1.0 - (vf[i] / 10) 2363 if f := Erfcinv(a); !veryclose(erfinv[i], f) { 2364 t.Errorf("Erfcinv(%g) = %g, want %g", a, f, erfinv[i]) 2365 } 2366 } 2367 for i := 0; i < len(vferfcinvSC); i++ { 2368 if f := Erfcinv(vferfcinvSC[i]); !alike(erfcinvSC[i], f) { 2369 t.Errorf("Erfcinv(%g) = %g, want %g", vferfcinvSC[i], f, erfcinvSC[i]) 2370 } 2371 } 2372 for x := 0.1; x <= 1.9; x += 1e-2 { 2373 if f := Erfc(Erfcinv(x)); !close(x, f) { 2374 t.Errorf("Erfc(Erfcinv(%g)) = %g, want %g", x, f, x) 2375 } 2376 } 2377 for x := 0.1; x <= 1.9; x += 1e-2 { 2378 if f := Erfcinv(Erfc(x)); !close(x, f) { 2379 t.Errorf("Erfcinv(Erfc(%g)) = %g, want %g", x, f, x) 2380 } 2381 } 2382 } 2383 2384 func TestExp(t *testing.T) { 2385 testExp(t, Exp, "Exp") 2386 testExp(t, ExpGo, "ExpGo") 2387 } 2388 2389 func testExp(t *testing.T, Exp func(float64) float64, name string) { 2390 for i := 0; i < len(vf); i++ { 2391 if f := Exp(vf[i]); !veryclose(exp[i], f) { 2392 t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp[i]) 2393 } 2394 } 2395 for i := 0; i < len(vfexpSC); i++ { 2396 if f := Exp(vfexpSC[i]); !alike(expSC[i], f) { 2397 t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i]) 2398 } 2399 } 2400 } 2401 2402 func TestExpm1(t *testing.T) { 2403 for i := 0; i < len(vf); i++ { 2404 a := vf[i] / 100 2405 if f := Expm1(a); !veryclose(expm1[i], f) { 2406 t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1[i]) 2407 } 2408 } 2409 for i := 0; i < len(vf); i++ { 2410 a := vf[i] * 10 2411 if f := Expm1(a); !close(expm1Large[i], f) { 2412 t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1Large[i]) 2413 } 2414 } 2415 for i := 0; i < len(vfexpm1SC); i++ { 2416 if f := Expm1(vfexpm1SC[i]); !alike(expm1SC[i], f) { 2417 t.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC[i], f, expm1SC[i]) 2418 } 2419 } 2420 } 2421 2422 func TestExp2(t *testing.T) { 2423 testExp2(t, Exp2, "Exp2") 2424 testExp2(t, Exp2Go, "Exp2Go") 2425 } 2426 2427 func testExp2(t *testing.T, Exp2 func(float64) float64, name string) { 2428 for i := 0; i < len(vf); i++ { 2429 if f := Exp2(vf[i]); !close(exp2[i], f) { 2430 t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp2[i]) 2431 } 2432 } 2433 for i := 0; i < len(vfexp2SC); i++ { 2434 if f := Exp2(vfexp2SC[i]); !alike(exp2SC[i], f) { 2435 t.Errorf("%s(%g) = %g, want %g", name, vfexp2SC[i], f, exp2SC[i]) 2436 } 2437 } 2438 for n := -1074; n < 1024; n++ { 2439 f := Exp2(float64(n)) 2440 vf := Ldexp(1, n) 2441 if f != vf { 2442 t.Errorf("%s(%d) = %g, want %g", name, n, f, vf) 2443 } 2444 } 2445 } 2446 2447 func TestAbs(t *testing.T) { 2448 for i := 0; i < len(vf); i++ { 2449 if f := Abs(vf[i]); fabs[i] != f { 2450 t.Errorf("Abs(%g) = %g, want %g", vf[i], f, fabs[i]) 2451 } 2452 } 2453 for i := 0; i < len(vffabsSC); i++ { 2454 if f := Abs(vffabsSC[i]); !alike(fabsSC[i], f) { 2455 t.Errorf("Abs(%g) = %g, want %g", vffabsSC[i], f, fabsSC[i]) 2456 } 2457 } 2458 } 2459 2460 func TestDim(t *testing.T) { 2461 for i := 0; i < len(vf); i++ { 2462 if f := Dim(vf[i], 0); fdim[i] != f { 2463 t.Errorf("Dim(%g, %g) = %g, want %g", vf[i], 0.0, f, fdim[i]) 2464 } 2465 } 2466 for i := 0; i < len(vffdimSC); i++ { 2467 if f := Dim(vffdimSC[i][0], vffdimSC[i][1]); !alike(fdimSC[i], f) { 2468 t.Errorf("Dim(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fdimSC[i]) 2469 } 2470 } 2471 for i := 0; i < len(vffdim2SC); i++ { 2472 if f := Dim(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fdimSC[i], f) { 2473 t.Errorf("Dim(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fdimSC[i]) 2474 } 2475 } 2476 } 2477 2478 func TestFloor(t *testing.T) { 2479 for i := 0; i < len(vf); i++ { 2480 if f := Floor(vf[i]); !alike(floor[i], f) { 2481 t.Errorf("Floor(%g) = %g, want %g", vf[i], f, floor[i]) 2482 } 2483 } 2484 for i := 0; i < len(vfceilSC); i++ { 2485 if f := Floor(vfceilSC[i]); !alike(ceilSC[i], f) { 2486 t.Errorf("Floor(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i]) 2487 } 2488 } 2489 } 2490 2491 func TestMax(t *testing.T) { 2492 for i := 0; i < len(vf); i++ { 2493 if f := Max(vf[i], ceil[i]); ceil[i] != f { 2494 t.Errorf("Max(%g, %g) = %g, want %g", vf[i], ceil[i], f, ceil[i]) 2495 } 2496 } 2497 for i := 0; i < len(vffdimSC); i++ { 2498 if f := Max(vffdimSC[i][0], vffdimSC[i][1]); !alike(fmaxSC[i], f) { 2499 t.Errorf("Max(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fmaxSC[i]) 2500 } 2501 } 2502 for i := 0; i < len(vffdim2SC); i++ { 2503 if f := Max(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fmaxSC[i], f) { 2504 t.Errorf("Max(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fmaxSC[i]) 2505 } 2506 } 2507 } 2508 2509 func TestMin(t *testing.T) { 2510 for i := 0; i < len(vf); i++ { 2511 if f := Min(vf[i], floor[i]); floor[i] != f { 2512 t.Errorf("Min(%g, %g) = %g, want %g", vf[i], floor[i], f, floor[i]) 2513 } 2514 } 2515 for i := 0; i < len(vffdimSC); i++ { 2516 if f := Min(vffdimSC[i][0], vffdimSC[i][1]); !alike(fminSC[i], f) { 2517 t.Errorf("Min(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fminSC[i]) 2518 } 2519 } 2520 for i := 0; i < len(vffdim2SC); i++ { 2521 if f := Min(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fminSC[i], f) { 2522 t.Errorf("Min(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fminSC[i]) 2523 } 2524 } 2525 } 2526 2527 func TestMod(t *testing.T) { 2528 for i := 0; i < len(vf); i++ { 2529 if f := Mod(10, vf[i]); fmod[i] != f { 2530 t.Errorf("Mod(10, %g) = %g, want %g", vf[i], f, fmod[i]) 2531 } 2532 } 2533 for i := 0; i < len(vffmodSC); i++ { 2534 if f := Mod(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) { 2535 t.Errorf("Mod(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i]) 2536 } 2537 } 2538 // verify precision of result for extreme inputs 2539 if f := Mod(5.9790119248836734e+200, 1.1258465975523544); 0.6447968302508578 != f { 2540 t.Errorf("Remainder(5.9790119248836734e+200, 1.1258465975523544) = %g, want 0.6447968302508578", f) 2541 } 2542 } 2543 2544 func TestFrexp(t *testing.T) { 2545 for i := 0; i < len(vf); i++ { 2546 if f, j := Frexp(vf[i]); !veryclose(frexp[i].f, f) || frexp[i].i != j { 2547 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vf[i], f, j, frexp[i].f, frexp[i].i) 2548 } 2549 } 2550 for i := 0; i < len(vffrexpSC); i++ { 2551 if f, j := Frexp(vffrexpSC[i]); !alike(frexpSC[i].f, f) || frexpSC[i].i != j { 2552 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpSC[i], f, j, frexpSC[i].f, frexpSC[i].i) 2553 } 2554 } 2555 for i := 0; i < len(vffrexpBC); i++ { 2556 if f, j := Frexp(vffrexpBC[i]); !alike(frexpBC[i].f, f) || frexpBC[i].i != j { 2557 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpBC[i], f, j, frexpBC[i].f, frexpBC[i].i) 2558 } 2559 } 2560 } 2561 2562 func TestGamma(t *testing.T) { 2563 for i := 0; i < len(vf); i++ { 2564 if f := Gamma(vf[i]); !close(gamma[i], f) { 2565 t.Errorf("Gamma(%g) = %g, want %g", vf[i], f, gamma[i]) 2566 } 2567 } 2568 for _, g := range vfgamma { 2569 f := Gamma(g[0]) 2570 var ok bool 2571 if IsNaN(g[1]) || IsInf(g[1], 0) || g[1] == 0 || f == 0 { 2572 ok = alike(g[1], f) 2573 } else if g[0] > -50 && g[0] <= 171 { 2574 ok = veryclose(g[1], f) 2575 } else { 2576 ok = close(g[1], f) 2577 } 2578 if !ok { 2579 t.Errorf("Gamma(%g) = %g, want %g", g[0], f, g[1]) 2580 } 2581 } 2582 } 2583 2584 func TestHypot(t *testing.T) { 2585 for i := 0; i < len(vf); i++ { 2586 a := Abs(1e200 * tanh[i] * Sqrt(2)) 2587 if f := Hypot(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) { 2588 t.Errorf("Hypot(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a) 2589 } 2590 } 2591 for i := 0; i < len(vfhypotSC); i++ { 2592 if f := Hypot(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) { 2593 t.Errorf("Hypot(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i]) 2594 } 2595 } 2596 } 2597 2598 func TestHypotGo(t *testing.T) { 2599 for i := 0; i < len(vf); i++ { 2600 a := Abs(1e200 * tanh[i] * Sqrt(2)) 2601 if f := HypotGo(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) { 2602 t.Errorf("HypotGo(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a) 2603 } 2604 } 2605 for i := 0; i < len(vfhypotSC); i++ { 2606 if f := HypotGo(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) { 2607 t.Errorf("HypotGo(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i]) 2608 } 2609 } 2610 } 2611 2612 func TestIlogb(t *testing.T) { 2613 for i := 0; i < len(vf); i++ { 2614 a := frexp[i].i - 1 // adjust because fr in the interval [½, 1) 2615 if e := Ilogb(vf[i]); a != e { 2616 t.Errorf("Ilogb(%g) = %d, want %d", vf[i], e, a) 2617 } 2618 } 2619 for i := 0; i < len(vflogbSC); i++ { 2620 if e := Ilogb(vflogbSC[i]); ilogbSC[i] != e { 2621 t.Errorf("Ilogb(%g) = %d, want %d", vflogbSC[i], e, ilogbSC[i]) 2622 } 2623 } 2624 for i := 0; i < len(vffrexpBC); i++ { 2625 if e := Ilogb(vffrexpBC[i]); int(logbBC[i]) != e { 2626 t.Errorf("Ilogb(%g) = %d, want %d", vffrexpBC[i], e, int(logbBC[i])) 2627 } 2628 } 2629 } 2630 2631 func TestJ0(t *testing.T) { 2632 for i := 0; i < len(vf); i++ { 2633 if f := J0(vf[i]); !soclose(j0[i], f, 4e-14) { 2634 t.Errorf("J0(%g) = %g, want %g", vf[i], f, j0[i]) 2635 } 2636 } 2637 for i := 0; i < len(vfj0SC); i++ { 2638 if f := J0(vfj0SC[i]); !alike(j0SC[i], f) { 2639 t.Errorf("J0(%g) = %g, want %g", vfj0SC[i], f, j0SC[i]) 2640 } 2641 } 2642 } 2643 2644 func TestJ1(t *testing.T) { 2645 for i := 0; i < len(vf); i++ { 2646 if f := J1(vf[i]); !close(j1[i], f) { 2647 t.Errorf("J1(%g) = %g, want %g", vf[i], f, j1[i]) 2648 } 2649 } 2650 for i := 0; i < len(vfj0SC); i++ { 2651 if f := J1(vfj0SC[i]); !alike(j1SC[i], f) { 2652 t.Errorf("J1(%g) = %g, want %g", vfj0SC[i], f, j1SC[i]) 2653 } 2654 } 2655 } 2656 2657 func TestJn(t *testing.T) { 2658 for i := 0; i < len(vf); i++ { 2659 if f := Jn(2, vf[i]); !close(j2[i], f) { 2660 t.Errorf("Jn(2, %g) = %g, want %g", vf[i], f, j2[i]) 2661 } 2662 if f := Jn(-3, vf[i]); !close(jM3[i], f) { 2663 t.Errorf("Jn(-3, %g) = %g, want %g", vf[i], f, jM3[i]) 2664 } 2665 } 2666 for i := 0; i < len(vfj0SC); i++ { 2667 if f := Jn(2, vfj0SC[i]); !alike(j2SC[i], f) { 2668 t.Errorf("Jn(2, %g) = %g, want %g", vfj0SC[i], f, j2SC[i]) 2669 } 2670 if f := Jn(-3, vfj0SC[i]); !alike(jM3SC[i], f) { 2671 t.Errorf("Jn(-3, %g) = %g, want %g", vfj0SC[i], f, jM3SC[i]) 2672 } 2673 } 2674 } 2675 2676 func TestLdexp(t *testing.T) { 2677 for i := 0; i < len(vf); i++ { 2678 if f := Ldexp(frexp[i].f, frexp[i].i); !veryclose(vf[i], f) { 2679 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexp[i].f, frexp[i].i, f, vf[i]) 2680 } 2681 } 2682 for i := 0; i < len(vffrexpSC); i++ { 2683 if f := Ldexp(frexpSC[i].f, frexpSC[i].i); !alike(vffrexpSC[i], f) { 2684 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpSC[i].f, frexpSC[i].i, f, vffrexpSC[i]) 2685 } 2686 } 2687 for i := 0; i < len(vfldexpSC); i++ { 2688 if f := Ldexp(vfldexpSC[i].f, vfldexpSC[i].i); !alike(ldexpSC[i], f) { 2689 t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpSC[i].f, vfldexpSC[i].i, f, ldexpSC[i]) 2690 } 2691 } 2692 for i := 0; i < len(vffrexpBC); i++ { 2693 if f := Ldexp(frexpBC[i].f, frexpBC[i].i); !alike(vffrexpBC[i], f) { 2694 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpBC[i].f, frexpBC[i].i, f, vffrexpBC[i]) 2695 } 2696 } 2697 for i := 0; i < len(vfldexpBC); i++ { 2698 if f := Ldexp(vfldexpBC[i].f, vfldexpBC[i].i); !alike(ldexpBC[i], f) { 2699 t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpBC[i].f, vfldexpBC[i].i, f, ldexpBC[i]) 2700 } 2701 } 2702 } 2703 2704 func TestLgamma(t *testing.T) { 2705 for i := 0; i < len(vf); i++ { 2706 if f, s := Lgamma(vf[i]); !close(lgamma[i].f, f) || lgamma[i].i != s { 2707 t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vf[i], f, s, lgamma[i].f, lgamma[i].i) 2708 } 2709 } 2710 for i := 0; i < len(vflgammaSC); i++ { 2711 if f, s := Lgamma(vflgammaSC[i]); !alike(lgammaSC[i].f, f) || lgammaSC[i].i != s { 2712 t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vflgammaSC[i], f, s, lgammaSC[i].f, lgammaSC[i].i) 2713 } 2714 } 2715 } 2716 2717 func TestLog(t *testing.T) { 2718 for i := 0; i < len(vf); i++ { 2719 a := Abs(vf[i]) 2720 if f := Log(a); log[i] != f { 2721 t.Errorf("Log(%g) = %g, want %g", a, f, log[i]) 2722 } 2723 } 2724 if f := Log(10); f != Ln10 { 2725 t.Errorf("Log(%g) = %g, want %g", 10.0, f, Ln10) 2726 } 2727 for i := 0; i < len(vflogSC); i++ { 2728 if f := Log(vflogSC[i]); !alike(logSC[i], f) { 2729 t.Errorf("Log(%g) = %g, want %g", vflogSC[i], f, logSC[i]) 2730 } 2731 } 2732 } 2733 2734 func TestLogb(t *testing.T) { 2735 for i := 0; i < len(vf); i++ { 2736 if f := Logb(vf[i]); logb[i] != f { 2737 t.Errorf("Logb(%g) = %g, want %g", vf[i], f, logb[i]) 2738 } 2739 } 2740 for i := 0; i < len(vflogbSC); i++ { 2741 if f := Logb(vflogbSC[i]); !alike(logbSC[i], f) { 2742 t.Errorf("Logb(%g) = %g, want %g", vflogbSC[i], f, logbSC[i]) 2743 } 2744 } 2745 for i := 0; i < len(vffrexpBC); i++ { 2746 if f := Logb(vffrexpBC[i]); !alike(logbBC[i], f) { 2747 t.Errorf("Logb(%g) = %g, want %g", vffrexpBC[i], f, logbBC[i]) 2748 } 2749 } 2750 } 2751 2752 func TestLog10(t *testing.T) { 2753 for i := 0; i < len(vf); i++ { 2754 a := Abs(vf[i]) 2755 if f := Log10(a); !veryclose(log10[i], f) { 2756 t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i]) 2757 } 2758 } 2759 if f := Log10(E); f != Log10E { 2760 t.Errorf("Log10(%g) = %g, want %g", E, f, Log10E) 2761 } 2762 for i := 0; i < len(vflogSC); i++ { 2763 if f := Log10(vflogSC[i]); !alike(logSC[i], f) { 2764 t.Errorf("Log10(%g) = %g, want %g", vflogSC[i], f, logSC[i]) 2765 } 2766 } 2767 } 2768 2769 func TestLog1p(t *testing.T) { 2770 for i := 0; i < len(vf); i++ { 2771 a := vf[i] / 100 2772 if f := Log1p(a); !veryclose(log1p[i], f) { 2773 t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i]) 2774 } 2775 } 2776 a := 9.0 2777 if f := Log1p(a); f != Ln10 { 2778 t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10) 2779 } 2780 for i := 0; i < len(vflogSC); i++ { 2781 if f := Log1p(vflog1pSC[i]); !alike(log1pSC[i], f) { 2782 t.Errorf("Log1p(%g) = %g, want %g", vflog1pSC[i], f, log1pSC[i]) 2783 } 2784 } 2785 } 2786 2787 func TestLog2(t *testing.T) { 2788 for i := 0; i < len(vf); i++ { 2789 a := Abs(vf[i]) 2790 if f := Log2(a); !veryclose(log2[i], f) { 2791 t.Errorf("Log2(%g) = %g, want %g", a, f, log2[i]) 2792 } 2793 } 2794 if f := Log2(E); f != Log2E { 2795 t.Errorf("Log2(%g) = %g, want %g", E, f, Log2E) 2796 } 2797 for i := 0; i < len(vflogSC); i++ { 2798 if f := Log2(vflogSC[i]); !alike(logSC[i], f) { 2799 t.Errorf("Log2(%g) = %g, want %g", vflogSC[i], f, logSC[i]) 2800 } 2801 } 2802 for i := -1074; i <= 1023; i++ { 2803 f := Ldexp(1, i) 2804 l := Log2(f) 2805 if l != float64(i) { 2806 t.Errorf("Log2(2**%d) = %g, want %d", i, l, i) 2807 } 2808 } 2809 } 2810 2811 func TestModf(t *testing.T) { 2812 for i := 0; i < len(vf); i++ { 2813 if f, g := Modf(vf[i]); !veryclose(modf[i][0], f) || !veryclose(modf[i][1], g) { 2814 t.Errorf("Modf(%g) = %g, %g, want %g, %g", vf[i], f, g, modf[i][0], modf[i][1]) 2815 } 2816 } 2817 for i := 0; i < len(vfmodfSC); i++ { 2818 if f, g := Modf(vfmodfSC[i]); !alike(modfSC[i][0], f) || !alike(modfSC[i][1], g) { 2819 t.Errorf("Modf(%g) = %g, %g, want %g, %g", vfmodfSC[i], f, g, modfSC[i][0], modfSC[i][1]) 2820 } 2821 } 2822 } 2823 2824 func TestNextafter32(t *testing.T) { 2825 for i := 0; i < len(vf); i++ { 2826 vfi := float32(vf[i]) 2827 if f := Nextafter32(vfi, 10); nextafter32[i] != f { 2828 t.Errorf("Nextafter32(%g, %g) = %g want %g", vfi, 10.0, f, nextafter32[i]) 2829 } 2830 } 2831 for i := 0; i < len(vfnextafter32SC); i++ { 2832 if f := Nextafter32(vfnextafter32SC[i][0], vfnextafter32SC[i][1]); !alike(float64(nextafter32SC[i]), float64(f)) { 2833 t.Errorf("Nextafter32(%g, %g) = %g want %g", vfnextafter32SC[i][0], vfnextafter32SC[i][1], f, nextafter32SC[i]) 2834 } 2835 } 2836 } 2837 2838 func TestNextafter64(t *testing.T) { 2839 for i := 0; i < len(vf); i++ { 2840 if f := Nextafter(vf[i], 10); nextafter64[i] != f { 2841 t.Errorf("Nextafter64(%g, %g) = %g want %g", vf[i], 10.0, f, nextafter64[i]) 2842 } 2843 } 2844 for i := 0; i < len(vfnextafter64SC); i++ { 2845 if f := Nextafter(vfnextafter64SC[i][0], vfnextafter64SC[i][1]); !alike(nextafter64SC[i], f) { 2846 t.Errorf("Nextafter64(%g, %g) = %g want %g", vfnextafter64SC[i][0], vfnextafter64SC[i][1], f, nextafter64SC[i]) 2847 } 2848 } 2849 } 2850 2851 func TestPow(t *testing.T) { 2852 for i := 0; i < len(vf); i++ { 2853 if f := Pow(10, vf[i]); !close(pow[i], f) { 2854 t.Errorf("Pow(10, %g) = %g, want %g", vf[i], f, pow[i]) 2855 } 2856 } 2857 for i := 0; i < len(vfpowSC); i++ { 2858 if f := Pow(vfpowSC[i][0], vfpowSC[i][1]); !alike(powSC[i], f) { 2859 t.Errorf("Pow(%g, %g) = %g, want %g", vfpowSC[i][0], vfpowSC[i][1], f, powSC[i]) 2860 } 2861 } 2862 } 2863 2864 func TestPow10(t *testing.T) { 2865 for i := 0; i < len(vfpow10SC); i++ { 2866 if f := Pow10(vfpow10SC[i]); !alike(pow10SC[i], f) { 2867 t.Errorf("Pow10(%d) = %g, want %g", vfpow10SC[i], f, pow10SC[i]) 2868 } 2869 } 2870 } 2871 2872 func TestRemainder(t *testing.T) { 2873 for i := 0; i < len(vf); i++ { 2874 if f := Remainder(10, vf[i]); remainder[i] != f { 2875 t.Errorf("Remainder(10, %g) = %g, want %g", vf[i], f, remainder[i]) 2876 } 2877 } 2878 for i := 0; i < len(vffmodSC); i++ { 2879 if f := Remainder(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) { 2880 t.Errorf("Remainder(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i]) 2881 } 2882 } 2883 // verify precision of result for extreme inputs 2884 if f := Remainder(5.9790119248836734e+200, 1.1258465975523544); -0.4810497673014966 != f { 2885 t.Errorf("Remainder(5.9790119248836734e+200, 1.1258465975523544) = %g, want -0.4810497673014966", f) 2886 } 2887 // verify that sign is correct when r == 0. 2888 test := func(x, y float64) { 2889 if r := Remainder(x, y); r == 0 && Signbit(r) != Signbit(x) { 2890 t.Errorf("Remainder(x=%f, y=%f) = %f, sign of (zero) result should agree with sign of x", x, y, r) 2891 } 2892 } 2893 for x := 0.0; x <= 3.0; x += 1 { 2894 for y := 1.0; y <= 3.0; y += 1 { 2895 test(x, y) 2896 test(x, -y) 2897 test(-x, y) 2898 test(-x, -y) 2899 } 2900 } 2901 } 2902 2903 func TestRound(t *testing.T) { 2904 for i := 0; i < len(vf); i++ { 2905 if f := Round(vf[i]); !alike(round[i], f) { 2906 t.Errorf("Round(%g) = %g, want %g", vf[i], f, round[i]) 2907 } 2908 } 2909 for i := 0; i < len(vfroundSC); i++ { 2910 if f := Round(vfroundSC[i][0]); !alike(vfroundSC[i][1], f) { 2911 t.Errorf("Round(%g) = %g, want %g", vfroundSC[i][0], f, vfroundSC[i][1]) 2912 } 2913 } 2914 } 2915 2916 func TestRoundToEven(t *testing.T) { 2917 for i := 0; i < len(vf); i++ { 2918 if f := RoundToEven(vf[i]); !alike(round[i], f) { 2919 t.Errorf("RoundToEven(%g) = %g, want %g", vf[i], f, round[i]) 2920 } 2921 } 2922 for i := 0; i < len(vfroundEvenSC); i++ { 2923 if f := RoundToEven(vfroundEvenSC[i][0]); !alike(vfroundEvenSC[i][1], f) { 2924 t.Errorf("RoundToEven(%g) = %g, want %g", vfroundEvenSC[i][0], f, vfroundEvenSC[i][1]) 2925 } 2926 } 2927 } 2928 2929 func TestSignbit(t *testing.T) { 2930 for i := 0; i < len(vf); i++ { 2931 if f := Signbit(vf[i]); signbit[i] != f { 2932 t.Errorf("Signbit(%g) = %t, want %t", vf[i], f, signbit[i]) 2933 } 2934 } 2935 for i := 0; i < len(vfsignbitSC); i++ { 2936 if f := Signbit(vfsignbitSC[i]); signbitSC[i] != f { 2937 t.Errorf("Signbit(%g) = %t, want %t", vfsignbitSC[i], f, signbitSC[i]) 2938 } 2939 } 2940 } 2941 func TestSin(t *testing.T) { 2942 for i := 0; i < len(vf); i++ { 2943 if f := Sin(vf[i]); !veryclose(sin[i], f) { 2944 t.Errorf("Sin(%g) = %g, want %g", vf[i], f, sin[i]) 2945 } 2946 } 2947 for i := 0; i < len(vfsinSC); i++ { 2948 if f := Sin(vfsinSC[i]); !alike(sinSC[i], f) { 2949 t.Errorf("Sin(%g) = %g, want %g", vfsinSC[i], f, sinSC[i]) 2950 } 2951 } 2952 } 2953 2954 func TestSincos(t *testing.T) { 2955 for i := 0; i < len(vf); i++ { 2956 if s, c := Sincos(vf[i]); !veryclose(sin[i], s) || !veryclose(cos[i], c) { 2957 t.Errorf("Sincos(%g) = %g, %g want %g, %g", vf[i], s, c, sin[i], cos[i]) 2958 } 2959 } 2960 } 2961 2962 func TestSinh(t *testing.T) { 2963 for i := 0; i < len(vf); i++ { 2964 if f := Sinh(vf[i]); !close(sinh[i], f) { 2965 t.Errorf("Sinh(%g) = %g, want %g", vf[i], f, sinh[i]) 2966 } 2967 } 2968 for i := 0; i < len(vfsinhSC); i++ { 2969 if f := Sinh(vfsinhSC[i]); !alike(sinhSC[i], f) { 2970 t.Errorf("Sinh(%g) = %g, want %g", vfsinhSC[i], f, sinhSC[i]) 2971 } 2972 } 2973 } 2974 2975 func TestSqrt(t *testing.T) { 2976 for i := 0; i < len(vf); i++ { 2977 a := Abs(vf[i]) 2978 if f := SqrtGo(a); sqrt[i] != f { 2979 t.Errorf("SqrtGo(%g) = %g, want %g", a, f, sqrt[i]) 2980 } 2981 a = Abs(vf[i]) 2982 if f := Sqrt(a); sqrt[i] != f { 2983 t.Errorf("Sqrt(%g) = %g, want %g", a, f, sqrt[i]) 2984 } 2985 } 2986 for i := 0; i < len(vfsqrtSC); i++ { 2987 if f := SqrtGo(vfsqrtSC[i]); !alike(sqrtSC[i], f) { 2988 t.Errorf("SqrtGo(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i]) 2989 } 2990 if f := Sqrt(vfsqrtSC[i]); !alike(sqrtSC[i], f) { 2991 t.Errorf("Sqrt(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i]) 2992 } 2993 } 2994 } 2995 2996 func TestTan(t *testing.T) { 2997 for i := 0; i < len(vf); i++ { 2998 if f := Tan(vf[i]); !veryclose(tan[i], f) { 2999 t.Errorf("Tan(%g) = %g, want %g", vf[i], f, tan[i]) 3000 } 3001 } 3002 // same special cases as Sin 3003 for i := 0; i < len(vfsinSC); i++ { 3004 if f := Tan(vfsinSC[i]); !alike(sinSC[i], f) { 3005 t.Errorf("Tan(%g) = %g, want %g", vfsinSC[i], f, sinSC[i]) 3006 } 3007 } 3008 } 3009 3010 func TestTanh(t *testing.T) { 3011 for i := 0; i < len(vf); i++ { 3012 if f := Tanh(vf[i]); !veryclose(tanh[i], f) { 3013 t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i]) 3014 } 3015 } 3016 for i := 0; i < len(vftanhSC); i++ { 3017 if f := Tanh(vftanhSC[i]); !alike(tanhSC[i], f) { 3018 t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i]) 3019 } 3020 } 3021 } 3022 3023 func TestTrunc(t *testing.T) { 3024 for i := 0; i < len(vf); i++ { 3025 if f := Trunc(vf[i]); !alike(trunc[i], f) { 3026 t.Errorf("Trunc(%g) = %g, want %g", vf[i], f, trunc[i]) 3027 } 3028 } 3029 for i := 0; i < len(vfceilSC); i++ { 3030 if f := Trunc(vfceilSC[i]); !alike(ceilSC[i], f) { 3031 t.Errorf("Trunc(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i]) 3032 } 3033 } 3034 } 3035 3036 func TestY0(t *testing.T) { 3037 for i := 0; i < len(vf); i++ { 3038 a := Abs(vf[i]) 3039 if f := Y0(a); !close(y0[i], f) { 3040 t.Errorf("Y0(%g) = %g, want %g", a, f, y0[i]) 3041 } 3042 } 3043 for i := 0; i < len(vfy0SC); i++ { 3044 if f := Y0(vfy0SC[i]); !alike(y0SC[i], f) { 3045 t.Errorf("Y0(%g) = %g, want %g", vfy0SC[i], f, y0SC[i]) 3046 } 3047 } 3048 } 3049 3050 func TestY1(t *testing.T) { 3051 for i := 0; i < len(vf); i++ { 3052 a := Abs(vf[i]) 3053 if f := Y1(a); !soclose(y1[i], f, 2e-14) { 3054 t.Errorf("Y1(%g) = %g, want %g", a, f, y1[i]) 3055 } 3056 } 3057 for i := 0; i < len(vfy0SC); i++ { 3058 if f := Y1(vfy0SC[i]); !alike(y1SC[i], f) { 3059 t.Errorf("Y1(%g) = %g, want %g", vfy0SC[i], f, y1SC[i]) 3060 } 3061 } 3062 } 3063 3064 func TestYn(t *testing.T) { 3065 for i := 0; i < len(vf); i++ { 3066 a := Abs(vf[i]) 3067 if f := Yn(2, a); !close(y2[i], f) { 3068 t.Errorf("Yn(2, %g) = %g, want %g", a, f, y2[i]) 3069 } 3070 if f := Yn(-3, a); !close(yM3[i], f) { 3071 t.Errorf("Yn(-3, %g) = %g, want %g", a, f, yM3[i]) 3072 } 3073 } 3074 for i := 0; i < len(vfy0SC); i++ { 3075 if f := Yn(2, vfy0SC[i]); !alike(y2SC[i], f) { 3076 t.Errorf("Yn(2, %g) = %g, want %g", vfy0SC[i], f, y2SC[i]) 3077 } 3078 if f := Yn(-3, vfy0SC[i]); !alike(yM3SC[i], f) { 3079 t.Errorf("Yn(-3, %g) = %g, want %g", vfy0SC[i], f, yM3SC[i]) 3080 } 3081 } 3082 if f := Yn(0, 0); !alike(Inf(-1), f) { 3083 t.Errorf("Yn(0, 0) = %g, want %g", f, Inf(-1)) 3084 } 3085 } 3086 3087 var PortableFMA = FMA // hide call from compiler intrinsic; falls back to portable code 3088 3089 func TestFMA(t *testing.T) { 3090 for _, c := range fmaC { 3091 got := FMA(c.x, c.y, c.z) 3092 if !alike(got, c.want) { 3093 t.Errorf("FMA(%g,%g,%g) == %g; want %g", c.x, c.y, c.z, got, c.want) 3094 } 3095 got = PortableFMA(c.x, c.y, c.z) 3096 if !alike(got, c.want) { 3097 t.Errorf("PortableFMA(%g,%g,%g) == %g; want %g", c.x, c.y, c.z, got, c.want) 3098 } 3099 } 3100 } 3101 3102 // Check that math functions of high angle values 3103 // return accurate results. [Since (vf[i] + large) - large != vf[i], 3104 // testing for Trig(vf[i] + large) == Trig(vf[i]), where large is 3105 // a multiple of 2*Pi, is misleading.] 3106 func TestLargeCos(t *testing.T) { 3107 large := float64(100000 * Pi) 3108 for i := 0; i < len(vf); i++ { 3109 f1 := cosLarge[i] 3110 f2 := Cos(vf[i] + large) 3111 if !close(f1, f2) { 3112 t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1) 3113 } 3114 } 3115 } 3116 3117 func TestLargeSin(t *testing.T) { 3118 large := float64(100000 * Pi) 3119 for i := 0; i < len(vf); i++ { 3120 f1 := sinLarge[i] 3121 f2 := Sin(vf[i] + large) 3122 if !close(f1, f2) { 3123 t.Errorf("Sin(%g) = %g, want %g", vf[i]+large, f2, f1) 3124 } 3125 } 3126 } 3127 3128 func TestLargeSincos(t *testing.T) { 3129 large := float64(100000 * Pi) 3130 for i := 0; i < len(vf); i++ { 3131 f1, g1 := sinLarge[i], cosLarge[i] 3132 f2, g2 := Sincos(vf[i] + large) 3133 if !close(f1, f2) || !close(g1, g2) { 3134 t.Errorf("Sincos(%g) = %g, %g, want %g, %g", vf[i]+large, f2, g2, f1, g1) 3135 } 3136 } 3137 } 3138 3139 func TestLargeTan(t *testing.T) { 3140 large := float64(100000 * Pi) 3141 for i := 0; i < len(vf); i++ { 3142 f1 := tanLarge[i] 3143 f2 := Tan(vf[i] + large) 3144 if !close(f1, f2) { 3145 t.Errorf("Tan(%g) = %g, want %g", vf[i]+large, f2, f1) 3146 } 3147 } 3148 } 3149 3150 // Check that trigReduce matches the standard reduction results for input values 3151 // below reduceThreshold. 3152 func TestTrigReduce(t *testing.T) { 3153 inputs := make([]float64, len(vf)) 3154 // all of the standard inputs 3155 copy(inputs, vf) 3156 // all of the large inputs 3157 large := float64(100000 * Pi) 3158 for _, v := range vf { 3159 inputs = append(inputs, v+large) 3160 } 3161 // Also test some special inputs, Pi and right below the reduceThreshold 3162 inputs = append(inputs, Pi, Nextafter(ReduceThreshold, 0)) 3163 for _, x := range inputs { 3164 // reduce the value to compare 3165 j, z := TrigReduce(x) 3166 xred := float64(j)*(Pi/4) + z 3167 3168 if f, fred := Sin(x), Sin(xred); !close(f, fred) { 3169 t.Errorf("Sin(trigReduce(%g)) != Sin(%g), got %g, want %g", x, x, fred, f) 3170 } 3171 if f, fred := Cos(x), Cos(xred); !close(f, fred) { 3172 t.Errorf("Cos(trigReduce(%g)) != Cos(%g), got %g, want %g", x, x, fred, f) 3173 } 3174 if f, fred := Tan(x), Tan(xred); !close(f, fred) { 3175 t.Errorf(" Tan(trigReduce(%g)) != Tan(%g), got %g, want %g", x, x, fred, f) 3176 } 3177 f, g := Sincos(x) 3178 fred, gred := Sincos(xred) 3179 if !close(f, fred) || !close(g, gred) { 3180 t.Errorf(" Sincos(trigReduce(%g)) != Sincos(%g), got %g, %g, want %g, %g", x, x, fred, gred, f, g) 3181 } 3182 } 3183 } 3184 3185 // Check that math constants are accepted by compiler 3186 // and have right value (assumes strconv.ParseFloat works). 3187 // https://golang.org/issue/201 3188 3189 type floatTest struct { 3190 val any 3191 name string 3192 str string 3193 } 3194 3195 var floatTests = []floatTest{ 3196 {float64(MaxFloat64), "MaxFloat64", "1.7976931348623157e+308"}, 3197 {float64(SmallestNonzeroFloat64), "SmallestNonzeroFloat64", "5e-324"}, 3198 {float32(MaxFloat32), "MaxFloat32", "3.4028235e+38"}, 3199 {float32(SmallestNonzeroFloat32), "SmallestNonzeroFloat32", "1e-45"}, 3200 } 3201 3202 func TestFloatMinMax(t *testing.T) { 3203 for _, tt := range floatTests { 3204 s := fmt.Sprint(tt.val) 3205 if s != tt.str { 3206 t.Errorf("Sprint(%v) = %s, want %s", tt.name, s, tt.str) 3207 } 3208 } 3209 } 3210 3211 func TestFloatMinima(t *testing.T) { 3212 if q := float32(SmallestNonzeroFloat32 / 2); q != 0 { 3213 t.Errorf("float32(SmallestNonzeroFloat32 / 2) = %g, want 0", q) 3214 } 3215 if q := float64(SmallestNonzeroFloat64 / 2); q != 0 { 3216 t.Errorf("float64(SmallestNonzeroFloat64 / 2) = %g, want 0", q) 3217 } 3218 } 3219 3220 var indirectSqrt = Sqrt 3221 3222 // TestFloat32Sqrt checks the correctness of the float32 square root optimization result. 3223 func TestFloat32Sqrt(t *testing.T) { 3224 for _, v := range sqrt32 { 3225 want := float32(indirectSqrt(float64(v))) 3226 got := float32(Sqrt(float64(v))) 3227 if IsNaN(float64(want)) { 3228 if !IsNaN(float64(got)) { 3229 t.Errorf("got=%#v want=NaN, v=%#v", got, v) 3230 } 3231 continue 3232 } 3233 if got != want { 3234 t.Errorf("got=%#v want=%#v, v=%#v", got, want, v) 3235 } 3236 } 3237 } 3238 3239 // Benchmarks 3240 3241 // Global exported variables are used to store the 3242 // return values of functions measured in the benchmarks. 3243 // Storing the results in these variables prevents the compiler 3244 // from completely optimizing the benchmarked functions away. 3245 var ( 3246 GlobalI int 3247 GlobalB bool 3248 GlobalF float64 3249 ) 3250 3251 func BenchmarkAcos(b *testing.B) { 3252 x := 0.0 3253 for i := 0; i < b.N; i++ { 3254 x = Acos(.5) 3255 } 3256 GlobalF = x 3257 } 3258 3259 func BenchmarkAcosh(b *testing.B) { 3260 x := 0.0 3261 for i := 0; i < b.N; i++ { 3262 x = Acosh(1.5) 3263 } 3264 GlobalF = x 3265 } 3266 3267 func BenchmarkAsin(b *testing.B) { 3268 x := 0.0 3269 for i := 0; i < b.N; i++ { 3270 x = Asin(.5) 3271 } 3272 GlobalF = x 3273 } 3274 3275 func BenchmarkAsinh(b *testing.B) { 3276 x := 0.0 3277 for i := 0; i < b.N; i++ { 3278 x = Asinh(.5) 3279 } 3280 GlobalF = x 3281 } 3282 3283 func BenchmarkAtan(b *testing.B) { 3284 x := 0.0 3285 for i := 0; i < b.N; i++ { 3286 x = Atan(.5) 3287 } 3288 GlobalF = x 3289 } 3290 3291 func BenchmarkAtanh(b *testing.B) { 3292 x := 0.0 3293 for i := 0; i < b.N; i++ { 3294 x = Atanh(.5) 3295 } 3296 GlobalF = x 3297 } 3298 3299 func BenchmarkAtan2(b *testing.B) { 3300 x := 0.0 3301 for i := 0; i < b.N; i++ { 3302 x = Atan2(.5, 1) 3303 } 3304 GlobalF = x 3305 } 3306 3307 func BenchmarkCbrt(b *testing.B) { 3308 x := 0.0 3309 for i := 0; i < b.N; i++ { 3310 x = Cbrt(10) 3311 } 3312 GlobalF = x 3313 } 3314 3315 func BenchmarkCeil(b *testing.B) { 3316 x := 0.0 3317 for i := 0; i < b.N; i++ { 3318 x = Ceil(.5) 3319 } 3320 GlobalF = x 3321 } 3322 3323 var copysignNeg = -1.0 3324 3325 func BenchmarkCopysign(b *testing.B) { 3326 x := 0.0 3327 for i := 0; i < b.N; i++ { 3328 x = Copysign(.5, copysignNeg) 3329 } 3330 GlobalF = x 3331 } 3332 3333 func BenchmarkCos(b *testing.B) { 3334 x := 0.0 3335 for i := 0; i < b.N; i++ { 3336 x = Cos(.5) 3337 } 3338 GlobalF = x 3339 } 3340 3341 func BenchmarkCosh(b *testing.B) { 3342 x := 0.0 3343 for i := 0; i < b.N; i++ { 3344 x = Cosh(2.5) 3345 } 3346 GlobalF = x 3347 } 3348 3349 func BenchmarkErf(b *testing.B) { 3350 x := 0.0 3351 for i := 0; i < b.N; i++ { 3352 x = Erf(.5) 3353 } 3354 GlobalF = x 3355 } 3356 3357 func BenchmarkErfc(b *testing.B) { 3358 x := 0.0 3359 for i := 0; i < b.N; i++ { 3360 x = Erfc(.5) 3361 } 3362 GlobalF = x 3363 } 3364 3365 func BenchmarkErfinv(b *testing.B) { 3366 x := 0.0 3367 for i := 0; i < b.N; i++ { 3368 x = Erfinv(.5) 3369 } 3370 GlobalF = x 3371 } 3372 3373 func BenchmarkErfcinv(b *testing.B) { 3374 x := 0.0 3375 for i := 0; i < b.N; i++ { 3376 x = Erfcinv(.5) 3377 } 3378 GlobalF = x 3379 } 3380 3381 func BenchmarkExp(b *testing.B) { 3382 x := 0.0 3383 for i := 0; i < b.N; i++ { 3384 x = Exp(.5) 3385 } 3386 GlobalF = x 3387 } 3388 3389 func BenchmarkExpGo(b *testing.B) { 3390 x := 0.0 3391 for i := 0; i < b.N; i++ { 3392 x = ExpGo(.5) 3393 } 3394 GlobalF = x 3395 } 3396 3397 func BenchmarkExpm1(b *testing.B) { 3398 x := 0.0 3399 for i := 0; i < b.N; i++ { 3400 x = Expm1(.5) 3401 } 3402 GlobalF = x 3403 } 3404 3405 func BenchmarkExp2(b *testing.B) { 3406 x := 0.0 3407 for i := 0; i < b.N; i++ { 3408 x = Exp2(.5) 3409 } 3410 GlobalF = x 3411 } 3412 3413 func BenchmarkExp2Go(b *testing.B) { 3414 x := 0.0 3415 for i := 0; i < b.N; i++ { 3416 x = Exp2Go(.5) 3417 } 3418 GlobalF = x 3419 } 3420 3421 var absPos = .5 3422 3423 func BenchmarkAbs(b *testing.B) { 3424 x := 0.0 3425 for i := 0; i < b.N; i++ { 3426 x = Abs(absPos) 3427 } 3428 GlobalF = x 3429 3430 } 3431 3432 func BenchmarkDim(b *testing.B) { 3433 x := 0.0 3434 for i := 0; i < b.N; i++ { 3435 x = Dim(GlobalF, x) 3436 } 3437 GlobalF = x 3438 } 3439 3440 func BenchmarkFloor(b *testing.B) { 3441 x := 0.0 3442 for i := 0; i < b.N; i++ { 3443 x = Floor(.5) 3444 } 3445 GlobalF = x 3446 } 3447 3448 func BenchmarkMax(b *testing.B) { 3449 x := 0.0 3450 for i := 0; i < b.N; i++ { 3451 x = Max(10, 3) 3452 } 3453 GlobalF = x 3454 } 3455 3456 func BenchmarkMin(b *testing.B) { 3457 x := 0.0 3458 for i := 0; i < b.N; i++ { 3459 x = Min(10, 3) 3460 } 3461 GlobalF = x 3462 } 3463 3464 func BenchmarkMod(b *testing.B) { 3465 x := 0.0 3466 for i := 0; i < b.N; i++ { 3467 x = Mod(10, 3) 3468 } 3469 GlobalF = x 3470 } 3471 3472 func BenchmarkFrexp(b *testing.B) { 3473 x := 0.0 3474 y := 0 3475 for i := 0; i < b.N; i++ { 3476 x, y = Frexp(8) 3477 } 3478 GlobalF = x 3479 GlobalI = y 3480 } 3481 3482 func BenchmarkGamma(b *testing.B) { 3483 x := 0.0 3484 for i := 0; i < b.N; i++ { 3485 x = Gamma(2.5) 3486 } 3487 GlobalF = x 3488 } 3489 3490 func BenchmarkHypot(b *testing.B) { 3491 x := 0.0 3492 for i := 0; i < b.N; i++ { 3493 x = Hypot(3, 4) 3494 } 3495 GlobalF = x 3496 } 3497 3498 func BenchmarkHypotGo(b *testing.B) { 3499 x := 0.0 3500 for i := 0; i < b.N; i++ { 3501 x = HypotGo(3, 4) 3502 } 3503 GlobalF = x 3504 } 3505 3506 func BenchmarkIlogb(b *testing.B) { 3507 x := 0 3508 for i := 0; i < b.N; i++ { 3509 x = Ilogb(.5) 3510 } 3511 GlobalI = x 3512 } 3513 3514 func BenchmarkJ0(b *testing.B) { 3515 x := 0.0 3516 for i := 0; i < b.N; i++ { 3517 x = J0(2.5) 3518 } 3519 GlobalF = x 3520 } 3521 3522 func BenchmarkJ1(b *testing.B) { 3523 x := 0.0 3524 for i := 0; i < b.N; i++ { 3525 x = J1(2.5) 3526 } 3527 GlobalF = x 3528 } 3529 3530 func BenchmarkJn(b *testing.B) { 3531 x := 0.0 3532 for i := 0; i < b.N; i++ { 3533 x = Jn(2, 2.5) 3534 } 3535 GlobalF = x 3536 } 3537 3538 func BenchmarkLdexp(b *testing.B) { 3539 x := 0.0 3540 for i := 0; i < b.N; i++ { 3541 x = Ldexp(.5, 2) 3542 } 3543 GlobalF = x 3544 } 3545 3546 func BenchmarkLgamma(b *testing.B) { 3547 x := 0.0 3548 y := 0 3549 for i := 0; i < b.N; i++ { 3550 x, y = Lgamma(2.5) 3551 } 3552 GlobalF = x 3553 GlobalI = y 3554 } 3555 3556 func BenchmarkLog(b *testing.B) { 3557 x := 0.0 3558 for i := 0; i < b.N; i++ { 3559 x = Log(.5) 3560 } 3561 GlobalF = x 3562 } 3563 3564 func BenchmarkLogb(b *testing.B) { 3565 x := 0.0 3566 for i := 0; i < b.N; i++ { 3567 x = Logb(.5) 3568 } 3569 GlobalF = x 3570 } 3571 3572 func BenchmarkLog1p(b *testing.B) { 3573 x := 0.0 3574 for i := 0; i < b.N; i++ { 3575 x = Log1p(.5) 3576 } 3577 GlobalF = x 3578 } 3579 3580 func BenchmarkLog10(b *testing.B) { 3581 x := 0.0 3582 for i := 0; i < b.N; i++ { 3583 x = Log10(.5) 3584 } 3585 GlobalF = x 3586 } 3587 3588 func BenchmarkLog2(b *testing.B) { 3589 x := 0.0 3590 for i := 0; i < b.N; i++ { 3591 x = Log2(.5) 3592 } 3593 GlobalF += x 3594 } 3595 3596 func BenchmarkModf(b *testing.B) { 3597 x := 0.0 3598 y := 0.0 3599 for i := 0; i < b.N; i++ { 3600 x, y = Modf(1.5) 3601 } 3602 GlobalF += x 3603 GlobalF += y 3604 } 3605 3606 func BenchmarkNextafter32(b *testing.B) { 3607 x := float32(0.0) 3608 for i := 0; i < b.N; i++ { 3609 x = Nextafter32(.5, 1) 3610 } 3611 GlobalF = float64(x) 3612 } 3613 3614 func BenchmarkNextafter64(b *testing.B) { 3615 x := 0.0 3616 for i := 0; i < b.N; i++ { 3617 x = Nextafter(.5, 1) 3618 } 3619 GlobalF = x 3620 } 3621 3622 func BenchmarkPowInt(b *testing.B) { 3623 x := 0.0 3624 for i := 0; i < b.N; i++ { 3625 x = Pow(2, 2) 3626 } 3627 GlobalF = x 3628 } 3629 3630 func BenchmarkPowFrac(b *testing.B) { 3631 x := 0.0 3632 for i := 0; i < b.N; i++ { 3633 x = Pow(2.5, 1.5) 3634 } 3635 GlobalF = x 3636 } 3637 3638 var pow10pos = int(300) 3639 3640 func BenchmarkPow10Pos(b *testing.B) { 3641 x := 0.0 3642 for i := 0; i < b.N; i++ { 3643 x = Pow10(pow10pos) 3644 } 3645 GlobalF = x 3646 } 3647 3648 var pow10neg = int(-300) 3649 3650 func BenchmarkPow10Neg(b *testing.B) { 3651 x := 0.0 3652 for i := 0; i < b.N; i++ { 3653 x = Pow10(pow10neg) 3654 } 3655 GlobalF = x 3656 } 3657 3658 var roundNeg = float64(-2.5) 3659 3660 func BenchmarkRound(b *testing.B) { 3661 x := 0.0 3662 for i := 0; i < b.N; i++ { 3663 x = Round(roundNeg) 3664 } 3665 GlobalF = x 3666 } 3667 3668 func BenchmarkRoundToEven(b *testing.B) { 3669 x := 0.0 3670 for i := 0; i < b.N; i++ { 3671 x = RoundToEven(roundNeg) 3672 } 3673 GlobalF = x 3674 } 3675 3676 func BenchmarkRemainder(b *testing.B) { 3677 x := 0.0 3678 for i := 0; i < b.N; i++ { 3679 x = Remainder(10, 3) 3680 } 3681 GlobalF = x 3682 } 3683 3684 var signbitPos = 2.5 3685 3686 func BenchmarkSignbit(b *testing.B) { 3687 x := false 3688 for i := 0; i < b.N; i++ { 3689 x = Signbit(signbitPos) 3690 } 3691 GlobalB = x 3692 } 3693 3694 func BenchmarkSin(b *testing.B) { 3695 x := 0.0 3696 for i := 0; i < b.N; i++ { 3697 x = Sin(.5) 3698 } 3699 GlobalF = x 3700 } 3701 3702 func BenchmarkSincos(b *testing.B) { 3703 x := 0.0 3704 y := 0.0 3705 for i := 0; i < b.N; i++ { 3706 x, y = Sincos(.5) 3707 } 3708 GlobalF += x 3709 GlobalF += y 3710 } 3711 3712 func BenchmarkSinh(b *testing.B) { 3713 x := 0.0 3714 for i := 0; i < b.N; i++ { 3715 x = Sinh(2.5) 3716 } 3717 GlobalF = x 3718 } 3719 3720 func BenchmarkSqrtIndirect(b *testing.B) { 3721 x, y := 0.0, 10.0 3722 f := Sqrt 3723 for i := 0; i < b.N; i++ { 3724 x += f(y) 3725 } 3726 GlobalF = x 3727 } 3728 3729 func BenchmarkSqrtLatency(b *testing.B) { 3730 x := 10.0 3731 for i := 0; i < b.N; i++ { 3732 x = Sqrt(x) 3733 } 3734 GlobalF = x 3735 } 3736 3737 func BenchmarkSqrtIndirectLatency(b *testing.B) { 3738 x := 10.0 3739 f := Sqrt 3740 for i := 0; i < b.N; i++ { 3741 x = f(x) 3742 } 3743 GlobalF = x 3744 } 3745 3746 func BenchmarkSqrtGoLatency(b *testing.B) { 3747 x := 10.0 3748 for i := 0; i < b.N; i++ { 3749 x = SqrtGo(x) 3750 } 3751 GlobalF = x 3752 } 3753 3754 func isPrime(i int) bool { 3755 // Yes, this is a dumb way to write this code, 3756 // but calling Sqrt repeatedly in this way demonstrates 3757 // the benefit of using a direct SQRT instruction on systems 3758 // that have one, whereas the obvious loop seems not to 3759 // demonstrate such a benefit. 3760 for j := 2; float64(j) <= Sqrt(float64(i)); j++ { 3761 if i%j == 0 { 3762 return false 3763 } 3764 } 3765 return true 3766 } 3767 3768 func BenchmarkSqrtPrime(b *testing.B) { 3769 x := false 3770 for i := 0; i < b.N; i++ { 3771 x = isPrime(100003) 3772 } 3773 GlobalB = x 3774 } 3775 3776 func BenchmarkTan(b *testing.B) { 3777 x := 0.0 3778 for i := 0; i < b.N; i++ { 3779 x = Tan(.5) 3780 } 3781 GlobalF = x 3782 } 3783 3784 func BenchmarkTanh(b *testing.B) { 3785 x := 0.0 3786 for i := 0; i < b.N; i++ { 3787 x = Tanh(2.5) 3788 } 3789 GlobalF = x 3790 } 3791 func BenchmarkTrunc(b *testing.B) { 3792 x := 0.0 3793 for i := 0; i < b.N; i++ { 3794 x = Trunc(.5) 3795 } 3796 GlobalF = x 3797 } 3798 3799 func BenchmarkY0(b *testing.B) { 3800 x := 0.0 3801 for i := 0; i < b.N; i++ { 3802 x = Y0(2.5) 3803 } 3804 GlobalF = x 3805 } 3806 3807 func BenchmarkY1(b *testing.B) { 3808 x := 0.0 3809 for i := 0; i < b.N; i++ { 3810 x = Y1(2.5) 3811 } 3812 GlobalF = x 3813 } 3814 3815 func BenchmarkYn(b *testing.B) { 3816 x := 0.0 3817 for i := 0; i < b.N; i++ { 3818 x = Yn(2, 2.5) 3819 } 3820 GlobalF = x 3821 } 3822 3823 func BenchmarkFloat64bits(b *testing.B) { 3824 y := uint64(0) 3825 for i := 0; i < b.N; i++ { 3826 y = Float64bits(roundNeg) 3827 } 3828 GlobalI = int(y) 3829 } 3830 3831 var roundUint64 = uint64(5) 3832 3833 func BenchmarkFloat64frombits(b *testing.B) { 3834 x := 0.0 3835 for i := 0; i < b.N; i++ { 3836 x = Float64frombits(roundUint64) 3837 } 3838 GlobalF = x 3839 } 3840 3841 var roundFloat32 = float32(-2.5) 3842 3843 func BenchmarkFloat32bits(b *testing.B) { 3844 y := uint32(0) 3845 for i := 0; i < b.N; i++ { 3846 y = Float32bits(roundFloat32) 3847 } 3848 GlobalI = int(y) 3849 } 3850 3851 var roundUint32 = uint32(5) 3852 3853 func BenchmarkFloat32frombits(b *testing.B) { 3854 x := float32(0.0) 3855 for i := 0; i < b.N; i++ { 3856 x = Float32frombits(roundUint32) 3857 } 3858 GlobalF = float64(x) 3859 } 3860 3861 func BenchmarkFMA(b *testing.B) { 3862 x := 0.0 3863 for i := 0; i < b.N; i++ { 3864 x = FMA(E, Pi, x) 3865 } 3866 GlobalF = x 3867 }