github.com/ice-blockchain/go/src@v0.0.0-20240403114104-1564d284e521/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 {Copysign(0, -1), 0, 0, 0}, 2063 {0, 0, Copysign(0, -1), 0}, 2064 {Copysign(0, -1), 0, Copysign(0, -1), Copysign(0, -1)}, 2065 {-1.1754226043408471e-38, NaN(), Inf(0), NaN()}, 2066 {0, 0, 2.22507385643494e-308, 2.22507385643494e-308}, 2067 {-8.65697792e+09, NaN(), -7.516192799999999e+09, NaN()}, 2068 {-0.00012207403779029757, 3.221225471996093e+09, NaN(), NaN()}, 2069 {Inf(-1), 0.1252441407414153, -1.387184532981584e-76, Inf(-1)}, 2070 {Inf(0), 1.525878907671432e-05, -9.214364835452549e+18, Inf(0)}, 2071 2072 // Random 2073 {0.1777916152213626, -32.000015266239636, -2.2204459148334633e-16, -5.689334401293007}, 2074 {-2.0816681711722314e-16, -0.4997558592585846, -0.9465627129124969, -0.9465627129124968}, 2075 {-1.9999997615814211, 1.8518819259933516e+19, 16.874999999999996, -3.703763410463646e+19}, 2076 {-0.12499994039717421, 32767.99999976135, -2.0752587082923246e+19, -2.075258708292325e+19}, 2077 {7.705600568510257e-34, -1.801432979000528e+16, -0.17224197722973714, -0.17224197722973716}, 2078 {3.8988133103758913e-308, -0.9848632812499999, 3.893879244098556e-308, 5.40811742605814e-310}, 2079 {-0.012651981190687427, 6.911985574912436e+38, 6.669240527007144e+18, -8.745031148409496e+36}, 2080 {4.612811918325842e+18, 1.4901161193847641e-08, 2.6077032311277997e-08, 6.873625395187494e+10}, 2081 {-9.094947033611148e-13, 4.450691014249257e-308, 2.086006742350485e-308, 2.086006742346437e-308}, 2082 {-7.751454006381804e-05, 5.588653777189071e-308, -2.2207280111272877e-308, -2.2211612130544025e-308}, 2083 2084 // Issue #61130 2085 {-1, 1, 1, 0}, 2086 {1, 1, -1, 0}, 2087 } 2088 2089 var sqrt32 = []float32{ 2090 0, 2091 float32(Copysign(0, -1)), 2092 float32(NaN()), 2093 float32(Inf(1)), 2094 float32(Inf(-1)), 2095 1, 2096 2, 2097 -2, 2098 4.9790119248836735e+00, 2099 7.7388724745781045e+00, 2100 -2.7688005719200159e-01, 2101 -5.0106036182710749e+00, 2102 } 2103 2104 func tolerance(a, b, e float64) bool { 2105 // Multiplying by e here can underflow denormal values to zero. 2106 // Check a==b so that at least if a and b are small and identical 2107 // we say they match. 2108 if a == b { 2109 return true 2110 } 2111 d := a - b 2112 if d < 0 { 2113 d = -d 2114 } 2115 2116 // note: b is correct (expected) value, a is actual value. 2117 // make error tolerance a fraction of b, not a. 2118 if b != 0 { 2119 e = e * b 2120 if e < 0 { 2121 e = -e 2122 } 2123 } 2124 return d < e 2125 } 2126 func close(a, b float64) bool { return tolerance(a, b, 1e-14) } 2127 func veryclose(a, b float64) bool { return tolerance(a, b, 4e-16) } 2128 func soclose(a, b, e float64) bool { return tolerance(a, b, e) } 2129 func alike(a, b float64) bool { 2130 switch { 2131 case IsNaN(a) && IsNaN(b): 2132 return true 2133 case a == b: 2134 return Signbit(a) == Signbit(b) 2135 } 2136 return false 2137 } 2138 2139 func TestNaN(t *testing.T) { 2140 f64 := NaN() 2141 if f64 == f64 { 2142 t.Fatalf("NaN() returns %g, expected NaN", f64) 2143 } 2144 f32 := float32(f64) 2145 if f32 == f32 { 2146 t.Fatalf("float32(NaN()) is %g, expected NaN", f32) 2147 } 2148 } 2149 2150 func TestAcos(t *testing.T) { 2151 for i := 0; i < len(vf); i++ { 2152 a := vf[i] / 10 2153 if f := Acos(a); !close(acos[i], f) { 2154 t.Errorf("Acos(%g) = %g, want %g", a, f, acos[i]) 2155 } 2156 } 2157 for i := 0; i < len(vfacosSC); i++ { 2158 if f := Acos(vfacosSC[i]); !alike(acosSC[i], f) { 2159 t.Errorf("Acos(%g) = %g, want %g", vfacosSC[i], f, acosSC[i]) 2160 } 2161 } 2162 } 2163 2164 func TestAcosh(t *testing.T) { 2165 for i := 0; i < len(vf); i++ { 2166 a := 1 + Abs(vf[i]) 2167 if f := Acosh(a); !veryclose(acosh[i], f) { 2168 t.Errorf("Acosh(%g) = %g, want %g", a, f, acosh[i]) 2169 } 2170 } 2171 for i := 0; i < len(vfacoshSC); i++ { 2172 if f := Acosh(vfacoshSC[i]); !alike(acoshSC[i], f) { 2173 t.Errorf("Acosh(%g) = %g, want %g", vfacoshSC[i], f, acoshSC[i]) 2174 } 2175 } 2176 } 2177 2178 func TestAsin(t *testing.T) { 2179 for i := 0; i < len(vf); i++ { 2180 a := vf[i] / 10 2181 if f := Asin(a); !veryclose(asin[i], f) { 2182 t.Errorf("Asin(%g) = %g, want %g", a, f, asin[i]) 2183 } 2184 } 2185 for i := 0; i < len(vfasinSC); i++ { 2186 if f := Asin(vfasinSC[i]); !alike(asinSC[i], f) { 2187 t.Errorf("Asin(%g) = %g, want %g", vfasinSC[i], f, asinSC[i]) 2188 } 2189 } 2190 } 2191 2192 func TestAsinh(t *testing.T) { 2193 for i := 0; i < len(vf); i++ { 2194 if f := Asinh(vf[i]); !veryclose(asinh[i], f) { 2195 t.Errorf("Asinh(%g) = %g, want %g", vf[i], f, asinh[i]) 2196 } 2197 } 2198 for i := 0; i < len(vfasinhSC); i++ { 2199 if f := Asinh(vfasinhSC[i]); !alike(asinhSC[i], f) { 2200 t.Errorf("Asinh(%g) = %g, want %g", vfasinhSC[i], f, asinhSC[i]) 2201 } 2202 } 2203 } 2204 2205 func TestAtan(t *testing.T) { 2206 for i := 0; i < len(vf); i++ { 2207 if f := Atan(vf[i]); !veryclose(atan[i], f) { 2208 t.Errorf("Atan(%g) = %g, want %g", vf[i], f, atan[i]) 2209 } 2210 } 2211 for i := 0; i < len(vfatanSC); i++ { 2212 if f := Atan(vfatanSC[i]); !alike(atanSC[i], f) { 2213 t.Errorf("Atan(%g) = %g, want %g", vfatanSC[i], f, atanSC[i]) 2214 } 2215 } 2216 } 2217 2218 func TestAtanh(t *testing.T) { 2219 for i := 0; i < len(vf); i++ { 2220 a := vf[i] / 10 2221 if f := Atanh(a); !veryclose(atanh[i], f) { 2222 t.Errorf("Atanh(%g) = %g, want %g", a, f, atanh[i]) 2223 } 2224 } 2225 for i := 0; i < len(vfatanhSC); i++ { 2226 if f := Atanh(vfatanhSC[i]); !alike(atanhSC[i], f) { 2227 t.Errorf("Atanh(%g) = %g, want %g", vfatanhSC[i], f, atanhSC[i]) 2228 } 2229 } 2230 } 2231 2232 func TestAtan2(t *testing.T) { 2233 for i := 0; i < len(vf); i++ { 2234 if f := Atan2(10, vf[i]); !veryclose(atan2[i], f) { 2235 t.Errorf("Atan2(10, %g) = %g, want %g", vf[i], f, atan2[i]) 2236 } 2237 } 2238 for i := 0; i < len(vfatan2SC); i++ { 2239 if f := Atan2(vfatan2SC[i][0], vfatan2SC[i][1]); !alike(atan2SC[i], f) { 2240 t.Errorf("Atan2(%g, %g) = %g, want %g", vfatan2SC[i][0], vfatan2SC[i][1], f, atan2SC[i]) 2241 } 2242 } 2243 } 2244 2245 func TestCbrt(t *testing.T) { 2246 for i := 0; i < len(vf); i++ { 2247 if f := Cbrt(vf[i]); !veryclose(cbrt[i], f) { 2248 t.Errorf("Cbrt(%g) = %g, want %g", vf[i], f, cbrt[i]) 2249 } 2250 } 2251 for i := 0; i < len(vfcbrtSC); i++ { 2252 if f := Cbrt(vfcbrtSC[i]); !alike(cbrtSC[i], f) { 2253 t.Errorf("Cbrt(%g) = %g, want %g", vfcbrtSC[i], f, cbrtSC[i]) 2254 } 2255 } 2256 } 2257 2258 func TestCeil(t *testing.T) { 2259 for i := 0; i < len(vf); i++ { 2260 if f := Ceil(vf[i]); !alike(ceil[i], f) { 2261 t.Errorf("Ceil(%g) = %g, want %g", vf[i], f, ceil[i]) 2262 } 2263 } 2264 for i := 0; i < len(vfceilSC); i++ { 2265 if f := Ceil(vfceilSC[i]); !alike(ceilSC[i], f) { 2266 t.Errorf("Ceil(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i]) 2267 } 2268 } 2269 } 2270 2271 func TestCopysign(t *testing.T) { 2272 for i := 0; i < len(vf); i++ { 2273 if f := Copysign(vf[i], -1); copysign[i] != f { 2274 t.Errorf("Copysign(%g, -1) = %g, want %g", vf[i], f, copysign[i]) 2275 } 2276 } 2277 for i := 0; i < len(vf); i++ { 2278 if f := Copysign(vf[i], 1); -copysign[i] != f { 2279 t.Errorf("Copysign(%g, 1) = %g, want %g", vf[i], f, -copysign[i]) 2280 } 2281 } 2282 for i := 0; i < len(vfcopysignSC); i++ { 2283 if f := Copysign(vfcopysignSC[i], -1); !alike(copysignSC[i], f) { 2284 t.Errorf("Copysign(%g, -1) = %g, want %g", vfcopysignSC[i], f, copysignSC[i]) 2285 } 2286 } 2287 } 2288 2289 func TestCos(t *testing.T) { 2290 for i := 0; i < len(vf); i++ { 2291 if f := Cos(vf[i]); !veryclose(cos[i], f) { 2292 t.Errorf("Cos(%g) = %g, want %g", vf[i], f, cos[i]) 2293 } 2294 } 2295 for i := 0; i < len(vfcosSC); i++ { 2296 if f := Cos(vfcosSC[i]); !alike(cosSC[i], f) { 2297 t.Errorf("Cos(%g) = %g, want %g", vfcosSC[i], f, cosSC[i]) 2298 } 2299 } 2300 } 2301 2302 func TestCosh(t *testing.T) { 2303 for i := 0; i < len(vf); i++ { 2304 if f := Cosh(vf[i]); !close(cosh[i], f) { 2305 t.Errorf("Cosh(%g) = %g, want %g", vf[i], f, cosh[i]) 2306 } 2307 } 2308 for i := 0; i < len(vfcoshSC); i++ { 2309 if f := Cosh(vfcoshSC[i]); !alike(coshSC[i], f) { 2310 t.Errorf("Cosh(%g) = %g, want %g", vfcoshSC[i], f, coshSC[i]) 2311 } 2312 } 2313 } 2314 2315 func TestErf(t *testing.T) { 2316 for i := 0; i < len(vf); i++ { 2317 a := vf[i] / 10 2318 if f := Erf(a); !veryclose(erf[i], f) { 2319 t.Errorf("Erf(%g) = %g, want %g", a, f, erf[i]) 2320 } 2321 } 2322 for i := 0; i < len(vferfSC); i++ { 2323 if f := Erf(vferfSC[i]); !alike(erfSC[i], f) { 2324 t.Errorf("Erf(%g) = %g, want %g", vferfSC[i], f, erfSC[i]) 2325 } 2326 } 2327 } 2328 2329 func TestErfc(t *testing.T) { 2330 for i := 0; i < len(vf); i++ { 2331 a := vf[i] / 10 2332 if f := Erfc(a); !veryclose(erfc[i], f) { 2333 t.Errorf("Erfc(%g) = %g, want %g", a, f, erfc[i]) 2334 } 2335 } 2336 for i := 0; i < len(vferfcSC); i++ { 2337 if f := Erfc(vferfcSC[i]); !alike(erfcSC[i], f) { 2338 t.Errorf("Erfc(%g) = %g, want %g", vferfcSC[i], f, erfcSC[i]) 2339 } 2340 } 2341 } 2342 2343 func TestErfinv(t *testing.T) { 2344 for i := 0; i < len(vf); i++ { 2345 a := vf[i] / 10 2346 if f := Erfinv(a); !veryclose(erfinv[i], f) { 2347 t.Errorf("Erfinv(%g) = %g, want %g", a, f, erfinv[i]) 2348 } 2349 } 2350 for i := 0; i < len(vferfinvSC); i++ { 2351 if f := Erfinv(vferfinvSC[i]); !alike(erfinvSC[i], f) { 2352 t.Errorf("Erfinv(%g) = %g, want %g", vferfinvSC[i], f, erfinvSC[i]) 2353 } 2354 } 2355 for x := -0.9; x <= 0.90; x += 1e-2 { 2356 if f := Erf(Erfinv(x)); !close(x, f) { 2357 t.Errorf("Erf(Erfinv(%g)) = %g, want %g", x, f, x) 2358 } 2359 } 2360 for x := -0.9; x <= 0.90; x += 1e-2 { 2361 if f := Erfinv(Erf(x)); !close(x, f) { 2362 t.Errorf("Erfinv(Erf(%g)) = %g, want %g", x, f, x) 2363 } 2364 } 2365 } 2366 2367 func TestErfcinv(t *testing.T) { 2368 for i := 0; i < len(vf); i++ { 2369 a := 1.0 - (vf[i] / 10) 2370 if f := Erfcinv(a); !veryclose(erfinv[i], f) { 2371 t.Errorf("Erfcinv(%g) = %g, want %g", a, f, erfinv[i]) 2372 } 2373 } 2374 for i := 0; i < len(vferfcinvSC); i++ { 2375 if f := Erfcinv(vferfcinvSC[i]); !alike(erfcinvSC[i], f) { 2376 t.Errorf("Erfcinv(%g) = %g, want %g", vferfcinvSC[i], f, erfcinvSC[i]) 2377 } 2378 } 2379 for x := 0.1; x <= 1.9; x += 1e-2 { 2380 if f := Erfc(Erfcinv(x)); !close(x, f) { 2381 t.Errorf("Erfc(Erfcinv(%g)) = %g, want %g", x, f, x) 2382 } 2383 } 2384 for x := 0.1; x <= 1.9; x += 1e-2 { 2385 if f := Erfcinv(Erfc(x)); !close(x, f) { 2386 t.Errorf("Erfcinv(Erfc(%g)) = %g, want %g", x, f, x) 2387 } 2388 } 2389 } 2390 2391 func TestExp(t *testing.T) { 2392 testExp(t, Exp, "Exp") 2393 testExp(t, ExpGo, "ExpGo") 2394 } 2395 2396 func testExp(t *testing.T, Exp func(float64) float64, name string) { 2397 for i := 0; i < len(vf); i++ { 2398 if f := Exp(vf[i]); !veryclose(exp[i], f) { 2399 t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp[i]) 2400 } 2401 } 2402 for i := 0; i < len(vfexpSC); i++ { 2403 if f := Exp(vfexpSC[i]); !alike(expSC[i], f) { 2404 t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i]) 2405 } 2406 } 2407 } 2408 2409 func TestExpm1(t *testing.T) { 2410 for i := 0; i < len(vf); i++ { 2411 a := vf[i] / 100 2412 if f := Expm1(a); !veryclose(expm1[i], f) { 2413 t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1[i]) 2414 } 2415 } 2416 for i := 0; i < len(vf); i++ { 2417 a := vf[i] * 10 2418 if f := Expm1(a); !close(expm1Large[i], f) { 2419 t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1Large[i]) 2420 } 2421 } 2422 for i := 0; i < len(vfexpm1SC); i++ { 2423 if f := Expm1(vfexpm1SC[i]); !alike(expm1SC[i], f) { 2424 t.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC[i], f, expm1SC[i]) 2425 } 2426 } 2427 } 2428 2429 func TestExp2(t *testing.T) { 2430 testExp2(t, Exp2, "Exp2") 2431 testExp2(t, Exp2Go, "Exp2Go") 2432 } 2433 2434 func testExp2(t *testing.T, Exp2 func(float64) float64, name string) { 2435 for i := 0; i < len(vf); i++ { 2436 if f := Exp2(vf[i]); !close(exp2[i], f) { 2437 t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp2[i]) 2438 } 2439 } 2440 for i := 0; i < len(vfexp2SC); i++ { 2441 if f := Exp2(vfexp2SC[i]); !alike(exp2SC[i], f) { 2442 t.Errorf("%s(%g) = %g, want %g", name, vfexp2SC[i], f, exp2SC[i]) 2443 } 2444 } 2445 for n := -1074; n < 1024; n++ { 2446 f := Exp2(float64(n)) 2447 vf := Ldexp(1, n) 2448 if f != vf { 2449 t.Errorf("%s(%d) = %g, want %g", name, n, f, vf) 2450 } 2451 } 2452 } 2453 2454 func TestAbs(t *testing.T) { 2455 for i := 0; i < len(vf); i++ { 2456 if f := Abs(vf[i]); fabs[i] != f { 2457 t.Errorf("Abs(%g) = %g, want %g", vf[i], f, fabs[i]) 2458 } 2459 } 2460 for i := 0; i < len(vffabsSC); i++ { 2461 if f := Abs(vffabsSC[i]); !alike(fabsSC[i], f) { 2462 t.Errorf("Abs(%g) = %g, want %g", vffabsSC[i], f, fabsSC[i]) 2463 } 2464 } 2465 } 2466 2467 func TestDim(t *testing.T) { 2468 for i := 0; i < len(vf); i++ { 2469 if f := Dim(vf[i], 0); fdim[i] != f { 2470 t.Errorf("Dim(%g, %g) = %g, want %g", vf[i], 0.0, f, fdim[i]) 2471 } 2472 } 2473 for i := 0; i < len(vffdimSC); i++ { 2474 if f := Dim(vffdimSC[i][0], vffdimSC[i][1]); !alike(fdimSC[i], f) { 2475 t.Errorf("Dim(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fdimSC[i]) 2476 } 2477 } 2478 for i := 0; i < len(vffdim2SC); i++ { 2479 if f := Dim(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fdimSC[i], f) { 2480 t.Errorf("Dim(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fdimSC[i]) 2481 } 2482 } 2483 } 2484 2485 func TestFloor(t *testing.T) { 2486 for i := 0; i < len(vf); i++ { 2487 if f := Floor(vf[i]); !alike(floor[i], f) { 2488 t.Errorf("Floor(%g) = %g, want %g", vf[i], f, floor[i]) 2489 } 2490 } 2491 for i := 0; i < len(vfceilSC); i++ { 2492 if f := Floor(vfceilSC[i]); !alike(ceilSC[i], f) { 2493 t.Errorf("Floor(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i]) 2494 } 2495 } 2496 } 2497 2498 func TestMax(t *testing.T) { 2499 for i := 0; i < len(vf); i++ { 2500 if f := Max(vf[i], ceil[i]); ceil[i] != f { 2501 t.Errorf("Max(%g, %g) = %g, want %g", vf[i], ceil[i], f, ceil[i]) 2502 } 2503 } 2504 for i := 0; i < len(vffdimSC); i++ { 2505 if f := Max(vffdimSC[i][0], vffdimSC[i][1]); !alike(fmaxSC[i], f) { 2506 t.Errorf("Max(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fmaxSC[i]) 2507 } 2508 } 2509 for i := 0; i < len(vffdim2SC); i++ { 2510 if f := Max(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fmaxSC[i], f) { 2511 t.Errorf("Max(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fmaxSC[i]) 2512 } 2513 } 2514 } 2515 2516 func TestMin(t *testing.T) { 2517 for i := 0; i < len(vf); i++ { 2518 if f := Min(vf[i], floor[i]); floor[i] != f { 2519 t.Errorf("Min(%g, %g) = %g, want %g", vf[i], floor[i], f, floor[i]) 2520 } 2521 } 2522 for i := 0; i < len(vffdimSC); i++ { 2523 if f := Min(vffdimSC[i][0], vffdimSC[i][1]); !alike(fminSC[i], f) { 2524 t.Errorf("Min(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fminSC[i]) 2525 } 2526 } 2527 for i := 0; i < len(vffdim2SC); i++ { 2528 if f := Min(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fminSC[i], f) { 2529 t.Errorf("Min(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fminSC[i]) 2530 } 2531 } 2532 } 2533 2534 func TestMod(t *testing.T) { 2535 for i := 0; i < len(vf); i++ { 2536 if f := Mod(10, vf[i]); fmod[i] != f { 2537 t.Errorf("Mod(10, %g) = %g, want %g", vf[i], f, fmod[i]) 2538 } 2539 } 2540 for i := 0; i < len(vffmodSC); i++ { 2541 if f := Mod(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) { 2542 t.Errorf("Mod(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i]) 2543 } 2544 } 2545 // verify precision of result for extreme inputs 2546 if f := Mod(5.9790119248836734e+200, 1.1258465975523544); 0.6447968302508578 != f { 2547 t.Errorf("Remainder(5.9790119248836734e+200, 1.1258465975523544) = %g, want 0.6447968302508578", f) 2548 } 2549 } 2550 2551 func TestFrexp(t *testing.T) { 2552 for i := 0; i < len(vf); i++ { 2553 if f, j := Frexp(vf[i]); !veryclose(frexp[i].f, f) || frexp[i].i != j { 2554 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vf[i], f, j, frexp[i].f, frexp[i].i) 2555 } 2556 } 2557 for i := 0; i < len(vffrexpSC); i++ { 2558 if f, j := Frexp(vffrexpSC[i]); !alike(frexpSC[i].f, f) || frexpSC[i].i != j { 2559 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpSC[i], f, j, frexpSC[i].f, frexpSC[i].i) 2560 } 2561 } 2562 for i := 0; i < len(vffrexpBC); i++ { 2563 if f, j := Frexp(vffrexpBC[i]); !alike(frexpBC[i].f, f) || frexpBC[i].i != j { 2564 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpBC[i], f, j, frexpBC[i].f, frexpBC[i].i) 2565 } 2566 } 2567 } 2568 2569 func TestGamma(t *testing.T) { 2570 for i := 0; i < len(vf); i++ { 2571 if f := Gamma(vf[i]); !close(gamma[i], f) { 2572 t.Errorf("Gamma(%g) = %g, want %g", vf[i], f, gamma[i]) 2573 } 2574 } 2575 for _, g := range vfgamma { 2576 f := Gamma(g[0]) 2577 var ok bool 2578 if IsNaN(g[1]) || IsInf(g[1], 0) || g[1] == 0 || f == 0 { 2579 ok = alike(g[1], f) 2580 } else if g[0] > -50 && g[0] <= 171 { 2581 ok = veryclose(g[1], f) 2582 } else { 2583 ok = close(g[1], f) 2584 } 2585 if !ok { 2586 t.Errorf("Gamma(%g) = %g, want %g", g[0], f, g[1]) 2587 } 2588 } 2589 } 2590 2591 func TestHypot(t *testing.T) { 2592 for i := 0; i < len(vf); i++ { 2593 a := Abs(1e200 * tanh[i] * Sqrt(2)) 2594 if f := Hypot(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) { 2595 t.Errorf("Hypot(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a) 2596 } 2597 } 2598 for i := 0; i < len(vfhypotSC); i++ { 2599 if f := Hypot(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) { 2600 t.Errorf("Hypot(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i]) 2601 } 2602 } 2603 } 2604 2605 func TestHypotGo(t *testing.T) { 2606 for i := 0; i < len(vf); i++ { 2607 a := Abs(1e200 * tanh[i] * Sqrt(2)) 2608 if f := HypotGo(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) { 2609 t.Errorf("HypotGo(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a) 2610 } 2611 } 2612 for i := 0; i < len(vfhypotSC); i++ { 2613 if f := HypotGo(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) { 2614 t.Errorf("HypotGo(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i]) 2615 } 2616 } 2617 } 2618 2619 func TestIlogb(t *testing.T) { 2620 for i := 0; i < len(vf); i++ { 2621 a := frexp[i].i - 1 // adjust because fr in the interval [½, 1) 2622 if e := Ilogb(vf[i]); a != e { 2623 t.Errorf("Ilogb(%g) = %d, want %d", vf[i], e, a) 2624 } 2625 } 2626 for i := 0; i < len(vflogbSC); i++ { 2627 if e := Ilogb(vflogbSC[i]); ilogbSC[i] != e { 2628 t.Errorf("Ilogb(%g) = %d, want %d", vflogbSC[i], e, ilogbSC[i]) 2629 } 2630 } 2631 for i := 0; i < len(vffrexpBC); i++ { 2632 if e := Ilogb(vffrexpBC[i]); int(logbBC[i]) != e { 2633 t.Errorf("Ilogb(%g) = %d, want %d", vffrexpBC[i], e, int(logbBC[i])) 2634 } 2635 } 2636 } 2637 2638 func TestJ0(t *testing.T) { 2639 for i := 0; i < len(vf); i++ { 2640 if f := J0(vf[i]); !soclose(j0[i], f, 4e-14) { 2641 t.Errorf("J0(%g) = %g, want %g", vf[i], f, j0[i]) 2642 } 2643 } 2644 for i := 0; i < len(vfj0SC); i++ { 2645 if f := J0(vfj0SC[i]); !alike(j0SC[i], f) { 2646 t.Errorf("J0(%g) = %g, want %g", vfj0SC[i], f, j0SC[i]) 2647 } 2648 } 2649 } 2650 2651 func TestJ1(t *testing.T) { 2652 for i := 0; i < len(vf); i++ { 2653 if f := J1(vf[i]); !close(j1[i], f) { 2654 t.Errorf("J1(%g) = %g, want %g", vf[i], f, j1[i]) 2655 } 2656 } 2657 for i := 0; i < len(vfj0SC); i++ { 2658 if f := J1(vfj0SC[i]); !alike(j1SC[i], f) { 2659 t.Errorf("J1(%g) = %g, want %g", vfj0SC[i], f, j1SC[i]) 2660 } 2661 } 2662 } 2663 2664 func TestJn(t *testing.T) { 2665 for i := 0; i < len(vf); i++ { 2666 if f := Jn(2, vf[i]); !close(j2[i], f) { 2667 t.Errorf("Jn(2, %g) = %g, want %g", vf[i], f, j2[i]) 2668 } 2669 if f := Jn(-3, vf[i]); !close(jM3[i], f) { 2670 t.Errorf("Jn(-3, %g) = %g, want %g", vf[i], f, jM3[i]) 2671 } 2672 } 2673 for i := 0; i < len(vfj0SC); i++ { 2674 if f := Jn(2, vfj0SC[i]); !alike(j2SC[i], f) { 2675 t.Errorf("Jn(2, %g) = %g, want %g", vfj0SC[i], f, j2SC[i]) 2676 } 2677 if f := Jn(-3, vfj0SC[i]); !alike(jM3SC[i], f) { 2678 t.Errorf("Jn(-3, %g) = %g, want %g", vfj0SC[i], f, jM3SC[i]) 2679 } 2680 } 2681 } 2682 2683 func TestLdexp(t *testing.T) { 2684 for i := 0; i < len(vf); i++ { 2685 if f := Ldexp(frexp[i].f, frexp[i].i); !veryclose(vf[i], f) { 2686 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexp[i].f, frexp[i].i, f, vf[i]) 2687 } 2688 } 2689 for i := 0; i < len(vffrexpSC); i++ { 2690 if f := Ldexp(frexpSC[i].f, frexpSC[i].i); !alike(vffrexpSC[i], f) { 2691 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpSC[i].f, frexpSC[i].i, f, vffrexpSC[i]) 2692 } 2693 } 2694 for i := 0; i < len(vfldexpSC); i++ { 2695 if f := Ldexp(vfldexpSC[i].f, vfldexpSC[i].i); !alike(ldexpSC[i], f) { 2696 t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpSC[i].f, vfldexpSC[i].i, f, ldexpSC[i]) 2697 } 2698 } 2699 for i := 0; i < len(vffrexpBC); i++ { 2700 if f := Ldexp(frexpBC[i].f, frexpBC[i].i); !alike(vffrexpBC[i], f) { 2701 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpBC[i].f, frexpBC[i].i, f, vffrexpBC[i]) 2702 } 2703 } 2704 for i := 0; i < len(vfldexpBC); i++ { 2705 if f := Ldexp(vfldexpBC[i].f, vfldexpBC[i].i); !alike(ldexpBC[i], f) { 2706 t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpBC[i].f, vfldexpBC[i].i, f, ldexpBC[i]) 2707 } 2708 } 2709 } 2710 2711 func TestLgamma(t *testing.T) { 2712 for i := 0; i < len(vf); i++ { 2713 if f, s := Lgamma(vf[i]); !close(lgamma[i].f, f) || lgamma[i].i != s { 2714 t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vf[i], f, s, lgamma[i].f, lgamma[i].i) 2715 } 2716 } 2717 for i := 0; i < len(vflgammaSC); i++ { 2718 if f, s := Lgamma(vflgammaSC[i]); !alike(lgammaSC[i].f, f) || lgammaSC[i].i != s { 2719 t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vflgammaSC[i], f, s, lgammaSC[i].f, lgammaSC[i].i) 2720 } 2721 } 2722 } 2723 2724 func TestLog(t *testing.T) { 2725 for i := 0; i < len(vf); i++ { 2726 a := Abs(vf[i]) 2727 if f := Log(a); log[i] != f { 2728 t.Errorf("Log(%g) = %g, want %g", a, f, log[i]) 2729 } 2730 } 2731 if f := Log(10); f != Ln10 { 2732 t.Errorf("Log(%g) = %g, want %g", 10.0, f, Ln10) 2733 } 2734 for i := 0; i < len(vflogSC); i++ { 2735 if f := Log(vflogSC[i]); !alike(logSC[i], f) { 2736 t.Errorf("Log(%g) = %g, want %g", vflogSC[i], f, logSC[i]) 2737 } 2738 } 2739 } 2740 2741 func TestLogb(t *testing.T) { 2742 for i := 0; i < len(vf); i++ { 2743 if f := Logb(vf[i]); logb[i] != f { 2744 t.Errorf("Logb(%g) = %g, want %g", vf[i], f, logb[i]) 2745 } 2746 } 2747 for i := 0; i < len(vflogbSC); i++ { 2748 if f := Logb(vflogbSC[i]); !alike(logbSC[i], f) { 2749 t.Errorf("Logb(%g) = %g, want %g", vflogbSC[i], f, logbSC[i]) 2750 } 2751 } 2752 for i := 0; i < len(vffrexpBC); i++ { 2753 if f := Logb(vffrexpBC[i]); !alike(logbBC[i], f) { 2754 t.Errorf("Logb(%g) = %g, want %g", vffrexpBC[i], f, logbBC[i]) 2755 } 2756 } 2757 } 2758 2759 func TestLog10(t *testing.T) { 2760 for i := 0; i < len(vf); i++ { 2761 a := Abs(vf[i]) 2762 if f := Log10(a); !veryclose(log10[i], f) { 2763 t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i]) 2764 } 2765 } 2766 if f := Log10(E); f != Log10E { 2767 t.Errorf("Log10(%g) = %g, want %g", E, f, Log10E) 2768 } 2769 for i := 0; i < len(vflogSC); i++ { 2770 if f := Log10(vflogSC[i]); !alike(logSC[i], f) { 2771 t.Errorf("Log10(%g) = %g, want %g", vflogSC[i], f, logSC[i]) 2772 } 2773 } 2774 } 2775 2776 func TestLog1p(t *testing.T) { 2777 for i := 0; i < len(vf); i++ { 2778 a := vf[i] / 100 2779 if f := Log1p(a); !veryclose(log1p[i], f) { 2780 t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i]) 2781 } 2782 } 2783 a := 9.0 2784 if f := Log1p(a); f != Ln10 { 2785 t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10) 2786 } 2787 for i := 0; i < len(vflogSC); i++ { 2788 if f := Log1p(vflog1pSC[i]); !alike(log1pSC[i], f) { 2789 t.Errorf("Log1p(%g) = %g, want %g", vflog1pSC[i], f, log1pSC[i]) 2790 } 2791 } 2792 } 2793 2794 func TestLog2(t *testing.T) { 2795 for i := 0; i < len(vf); i++ { 2796 a := Abs(vf[i]) 2797 if f := Log2(a); !veryclose(log2[i], f) { 2798 t.Errorf("Log2(%g) = %g, want %g", a, f, log2[i]) 2799 } 2800 } 2801 if f := Log2(E); f != Log2E { 2802 t.Errorf("Log2(%g) = %g, want %g", E, f, Log2E) 2803 } 2804 for i := 0; i < len(vflogSC); i++ { 2805 if f := Log2(vflogSC[i]); !alike(logSC[i], f) { 2806 t.Errorf("Log2(%g) = %g, want %g", vflogSC[i], f, logSC[i]) 2807 } 2808 } 2809 for i := -1074; i <= 1023; i++ { 2810 f := Ldexp(1, i) 2811 l := Log2(f) 2812 if l != float64(i) { 2813 t.Errorf("Log2(2**%d) = %g, want %d", i, l, i) 2814 } 2815 } 2816 } 2817 2818 func TestModf(t *testing.T) { 2819 for i := 0; i < len(vf); i++ { 2820 if f, g := Modf(vf[i]); !veryclose(modf[i][0], f) || !veryclose(modf[i][1], g) { 2821 t.Errorf("Modf(%g) = %g, %g, want %g, %g", vf[i], f, g, modf[i][0], modf[i][1]) 2822 } 2823 } 2824 for i := 0; i < len(vfmodfSC); i++ { 2825 if f, g := Modf(vfmodfSC[i]); !alike(modfSC[i][0], f) || !alike(modfSC[i][1], g) { 2826 t.Errorf("Modf(%g) = %g, %g, want %g, %g", vfmodfSC[i], f, g, modfSC[i][0], modfSC[i][1]) 2827 } 2828 } 2829 } 2830 2831 func TestNextafter32(t *testing.T) { 2832 for i := 0; i < len(vf); i++ { 2833 vfi := float32(vf[i]) 2834 if f := Nextafter32(vfi, 10); nextafter32[i] != f { 2835 t.Errorf("Nextafter32(%g, %g) = %g want %g", vfi, 10.0, f, nextafter32[i]) 2836 } 2837 } 2838 for i := 0; i < len(vfnextafter32SC); i++ { 2839 if f := Nextafter32(vfnextafter32SC[i][0], vfnextafter32SC[i][1]); !alike(float64(nextafter32SC[i]), float64(f)) { 2840 t.Errorf("Nextafter32(%g, %g) = %g want %g", vfnextafter32SC[i][0], vfnextafter32SC[i][1], f, nextafter32SC[i]) 2841 } 2842 } 2843 } 2844 2845 func TestNextafter64(t *testing.T) { 2846 for i := 0; i < len(vf); i++ { 2847 if f := Nextafter(vf[i], 10); nextafter64[i] != f { 2848 t.Errorf("Nextafter64(%g, %g) = %g want %g", vf[i], 10.0, f, nextafter64[i]) 2849 } 2850 } 2851 for i := 0; i < len(vfnextafter64SC); i++ { 2852 if f := Nextafter(vfnextafter64SC[i][0], vfnextafter64SC[i][1]); !alike(nextafter64SC[i], f) { 2853 t.Errorf("Nextafter64(%g, %g) = %g want %g", vfnextafter64SC[i][0], vfnextafter64SC[i][1], f, nextafter64SC[i]) 2854 } 2855 } 2856 } 2857 2858 func TestPow(t *testing.T) { 2859 for i := 0; i < len(vf); i++ { 2860 if f := Pow(10, vf[i]); !close(pow[i], f) { 2861 t.Errorf("Pow(10, %g) = %g, want %g", vf[i], f, pow[i]) 2862 } 2863 } 2864 for i := 0; i < len(vfpowSC); i++ { 2865 if f := Pow(vfpowSC[i][0], vfpowSC[i][1]); !alike(powSC[i], f) { 2866 t.Errorf("Pow(%g, %g) = %g, want %g", vfpowSC[i][0], vfpowSC[i][1], f, powSC[i]) 2867 } 2868 } 2869 } 2870 2871 func TestPow10(t *testing.T) { 2872 for i := 0; i < len(vfpow10SC); i++ { 2873 if f := Pow10(vfpow10SC[i]); !alike(pow10SC[i], f) { 2874 t.Errorf("Pow10(%d) = %g, want %g", vfpow10SC[i], f, pow10SC[i]) 2875 } 2876 } 2877 } 2878 2879 func TestRemainder(t *testing.T) { 2880 for i := 0; i < len(vf); i++ { 2881 if f := Remainder(10, vf[i]); remainder[i] != f { 2882 t.Errorf("Remainder(10, %g) = %g, want %g", vf[i], f, remainder[i]) 2883 } 2884 } 2885 for i := 0; i < len(vffmodSC); i++ { 2886 if f := Remainder(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) { 2887 t.Errorf("Remainder(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i]) 2888 } 2889 } 2890 // verify precision of result for extreme inputs 2891 if f := Remainder(5.9790119248836734e+200, 1.1258465975523544); -0.4810497673014966 != f { 2892 t.Errorf("Remainder(5.9790119248836734e+200, 1.1258465975523544) = %g, want -0.4810497673014966", f) 2893 } 2894 // verify that sign is correct when r == 0. 2895 test := func(x, y float64) { 2896 if r := Remainder(x, y); r == 0 && Signbit(r) != Signbit(x) { 2897 t.Errorf("Remainder(x=%f, y=%f) = %f, sign of (zero) result should agree with sign of x", x, y, r) 2898 } 2899 } 2900 for x := 0.0; x <= 3.0; x += 1 { 2901 for y := 1.0; y <= 3.0; y += 1 { 2902 test(x, y) 2903 test(x, -y) 2904 test(-x, y) 2905 test(-x, -y) 2906 } 2907 } 2908 } 2909 2910 func TestRound(t *testing.T) { 2911 for i := 0; i < len(vf); i++ { 2912 if f := Round(vf[i]); !alike(round[i], f) { 2913 t.Errorf("Round(%g) = %g, want %g", vf[i], f, round[i]) 2914 } 2915 } 2916 for i := 0; i < len(vfroundSC); i++ { 2917 if f := Round(vfroundSC[i][0]); !alike(vfroundSC[i][1], f) { 2918 t.Errorf("Round(%g) = %g, want %g", vfroundSC[i][0], f, vfroundSC[i][1]) 2919 } 2920 } 2921 } 2922 2923 func TestRoundToEven(t *testing.T) { 2924 for i := 0; i < len(vf); i++ { 2925 if f := RoundToEven(vf[i]); !alike(round[i], f) { 2926 t.Errorf("RoundToEven(%g) = %g, want %g", vf[i], f, round[i]) 2927 } 2928 } 2929 for i := 0; i < len(vfroundEvenSC); i++ { 2930 if f := RoundToEven(vfroundEvenSC[i][0]); !alike(vfroundEvenSC[i][1], f) { 2931 t.Errorf("RoundToEven(%g) = %g, want %g", vfroundEvenSC[i][0], f, vfroundEvenSC[i][1]) 2932 } 2933 } 2934 } 2935 2936 func TestSignbit(t *testing.T) { 2937 for i := 0; i < len(vf); i++ { 2938 if f := Signbit(vf[i]); signbit[i] != f { 2939 t.Errorf("Signbit(%g) = %t, want %t", vf[i], f, signbit[i]) 2940 } 2941 } 2942 for i := 0; i < len(vfsignbitSC); i++ { 2943 if f := Signbit(vfsignbitSC[i]); signbitSC[i] != f { 2944 t.Errorf("Signbit(%g) = %t, want %t", vfsignbitSC[i], f, signbitSC[i]) 2945 } 2946 } 2947 } 2948 func TestSin(t *testing.T) { 2949 for i := 0; i < len(vf); i++ { 2950 if f := Sin(vf[i]); !veryclose(sin[i], f) { 2951 t.Errorf("Sin(%g) = %g, want %g", vf[i], f, sin[i]) 2952 } 2953 } 2954 for i := 0; i < len(vfsinSC); i++ { 2955 if f := Sin(vfsinSC[i]); !alike(sinSC[i], f) { 2956 t.Errorf("Sin(%g) = %g, want %g", vfsinSC[i], f, sinSC[i]) 2957 } 2958 } 2959 } 2960 2961 func TestSincos(t *testing.T) { 2962 for i := 0; i < len(vf); i++ { 2963 if s, c := Sincos(vf[i]); !veryclose(sin[i], s) || !veryclose(cos[i], c) { 2964 t.Errorf("Sincos(%g) = %g, %g want %g, %g", vf[i], s, c, sin[i], cos[i]) 2965 } 2966 } 2967 } 2968 2969 func TestSinh(t *testing.T) { 2970 for i := 0; i < len(vf); i++ { 2971 if f := Sinh(vf[i]); !close(sinh[i], f) { 2972 t.Errorf("Sinh(%g) = %g, want %g", vf[i], f, sinh[i]) 2973 } 2974 } 2975 for i := 0; i < len(vfsinhSC); i++ { 2976 if f := Sinh(vfsinhSC[i]); !alike(sinhSC[i], f) { 2977 t.Errorf("Sinh(%g) = %g, want %g", vfsinhSC[i], f, sinhSC[i]) 2978 } 2979 } 2980 } 2981 2982 func TestSqrt(t *testing.T) { 2983 for i := 0; i < len(vf); i++ { 2984 a := Abs(vf[i]) 2985 if f := SqrtGo(a); sqrt[i] != f { 2986 t.Errorf("SqrtGo(%g) = %g, want %g", a, f, sqrt[i]) 2987 } 2988 a = Abs(vf[i]) 2989 if f := Sqrt(a); sqrt[i] != f { 2990 t.Errorf("Sqrt(%g) = %g, want %g", a, f, sqrt[i]) 2991 } 2992 } 2993 for i := 0; i < len(vfsqrtSC); i++ { 2994 if f := SqrtGo(vfsqrtSC[i]); !alike(sqrtSC[i], f) { 2995 t.Errorf("SqrtGo(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i]) 2996 } 2997 if f := Sqrt(vfsqrtSC[i]); !alike(sqrtSC[i], f) { 2998 t.Errorf("Sqrt(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i]) 2999 } 3000 } 3001 } 3002 3003 func TestTan(t *testing.T) { 3004 for i := 0; i < len(vf); i++ { 3005 if f := Tan(vf[i]); !veryclose(tan[i], f) { 3006 t.Errorf("Tan(%g) = %g, want %g", vf[i], f, tan[i]) 3007 } 3008 } 3009 // same special cases as Sin 3010 for i := 0; i < len(vfsinSC); i++ { 3011 if f := Tan(vfsinSC[i]); !alike(sinSC[i], f) { 3012 t.Errorf("Tan(%g) = %g, want %g", vfsinSC[i], f, sinSC[i]) 3013 } 3014 } 3015 } 3016 3017 func TestTanh(t *testing.T) { 3018 for i := 0; i < len(vf); i++ { 3019 if f := Tanh(vf[i]); !veryclose(tanh[i], f) { 3020 t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i]) 3021 } 3022 } 3023 for i := 0; i < len(vftanhSC); i++ { 3024 if f := Tanh(vftanhSC[i]); !alike(tanhSC[i], f) { 3025 t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i]) 3026 } 3027 } 3028 } 3029 3030 func TestTrunc(t *testing.T) { 3031 for i := 0; i < len(vf); i++ { 3032 if f := Trunc(vf[i]); !alike(trunc[i], f) { 3033 t.Errorf("Trunc(%g) = %g, want %g", vf[i], f, trunc[i]) 3034 } 3035 } 3036 for i := 0; i < len(vfceilSC); i++ { 3037 if f := Trunc(vfceilSC[i]); !alike(ceilSC[i], f) { 3038 t.Errorf("Trunc(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i]) 3039 } 3040 } 3041 } 3042 3043 func TestY0(t *testing.T) { 3044 for i := 0; i < len(vf); i++ { 3045 a := Abs(vf[i]) 3046 if f := Y0(a); !close(y0[i], f) { 3047 t.Errorf("Y0(%g) = %g, want %g", a, f, y0[i]) 3048 } 3049 } 3050 for i := 0; i < len(vfy0SC); i++ { 3051 if f := Y0(vfy0SC[i]); !alike(y0SC[i], f) { 3052 t.Errorf("Y0(%g) = %g, want %g", vfy0SC[i], f, y0SC[i]) 3053 } 3054 } 3055 } 3056 3057 func TestY1(t *testing.T) { 3058 for i := 0; i < len(vf); i++ { 3059 a := Abs(vf[i]) 3060 if f := Y1(a); !soclose(y1[i], f, 2e-14) { 3061 t.Errorf("Y1(%g) = %g, want %g", a, f, y1[i]) 3062 } 3063 } 3064 for i := 0; i < len(vfy0SC); i++ { 3065 if f := Y1(vfy0SC[i]); !alike(y1SC[i], f) { 3066 t.Errorf("Y1(%g) = %g, want %g", vfy0SC[i], f, y1SC[i]) 3067 } 3068 } 3069 } 3070 3071 func TestYn(t *testing.T) { 3072 for i := 0; i < len(vf); i++ { 3073 a := Abs(vf[i]) 3074 if f := Yn(2, a); !close(y2[i], f) { 3075 t.Errorf("Yn(2, %g) = %g, want %g", a, f, y2[i]) 3076 } 3077 if f := Yn(-3, a); !close(yM3[i], f) { 3078 t.Errorf("Yn(-3, %g) = %g, want %g", a, f, yM3[i]) 3079 } 3080 } 3081 for i := 0; i < len(vfy0SC); i++ { 3082 if f := Yn(2, vfy0SC[i]); !alike(y2SC[i], f) { 3083 t.Errorf("Yn(2, %g) = %g, want %g", vfy0SC[i], f, y2SC[i]) 3084 } 3085 if f := Yn(-3, vfy0SC[i]); !alike(yM3SC[i], f) { 3086 t.Errorf("Yn(-3, %g) = %g, want %g", vfy0SC[i], f, yM3SC[i]) 3087 } 3088 } 3089 if f := Yn(0, 0); !alike(Inf(-1), f) { 3090 t.Errorf("Yn(0, 0) = %g, want %g", f, Inf(-1)) 3091 } 3092 } 3093 3094 var PortableFMA = FMA // hide call from compiler intrinsic; falls back to portable code 3095 3096 func TestFMA(t *testing.T) { 3097 for _, c := range fmaC { 3098 got := FMA(c.x, c.y, c.z) 3099 if !alike(got, c.want) { 3100 t.Errorf("FMA(%g,%g,%g) == %g; want %g", c.x, c.y, c.z, got, c.want) 3101 } 3102 got = PortableFMA(c.x, c.y, c.z) 3103 if !alike(got, c.want) { 3104 t.Errorf("PortableFMA(%g,%g,%g) == %g; want %g", c.x, c.y, c.z, got, c.want) 3105 } 3106 } 3107 } 3108 3109 //go:noinline 3110 func fmsub(x, y, z float64) float64 { 3111 return FMA(x, y, -z) 3112 } 3113 3114 //go:noinline 3115 func fnmsub(x, y, z float64) float64 { 3116 return FMA(-x, y, z) 3117 } 3118 3119 //go:noinline 3120 func fnmadd(x, y, z float64) float64 { 3121 return FMA(-x, y, -z) 3122 } 3123 3124 func TestFMANegativeArgs(t *testing.T) { 3125 // Some architectures have instructions for fused multiply-subtract and 3126 // also negated variants of fused multiply-add and subtract. This test 3127 // aims to check that the optimizations that generate those instructions 3128 // are applied correctly, if they exist. 3129 for _, c := range fmaC { 3130 want := PortableFMA(c.x, c.y, -c.z) 3131 got := fmsub(c.x, c.y, c.z) 3132 if !alike(got, want) { 3133 t.Errorf("FMA(%g, %g, -(%g)) == %g, want %g", c.x, c.y, c.z, got, want) 3134 } 3135 want = PortableFMA(-c.x, c.y, c.z) 3136 got = fnmsub(c.x, c.y, c.z) 3137 if !alike(got, want) { 3138 t.Errorf("FMA(-(%g), %g, %g) == %g, want %g", c.x, c.y, c.z, got, want) 3139 } 3140 want = PortableFMA(-c.x, c.y, -c.z) 3141 got = fnmadd(c.x, c.y, c.z) 3142 if !alike(got, want) { 3143 t.Errorf("FMA(-(%g), %g, -(%g)) == %g, want %g", c.x, c.y, c.z, got, want) 3144 } 3145 } 3146 } 3147 3148 // Check that math functions of high angle values 3149 // return accurate results. [Since (vf[i] + large) - large != vf[i], 3150 // testing for Trig(vf[i] + large) == Trig(vf[i]), where large is 3151 // a multiple of 2*Pi, is misleading.] 3152 func TestLargeCos(t *testing.T) { 3153 large := float64(100000 * Pi) 3154 for i := 0; i < len(vf); i++ { 3155 f1 := cosLarge[i] 3156 f2 := Cos(vf[i] + large) 3157 if !close(f1, f2) { 3158 t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1) 3159 } 3160 } 3161 } 3162 3163 func TestLargeSin(t *testing.T) { 3164 large := float64(100000 * Pi) 3165 for i := 0; i < len(vf); i++ { 3166 f1 := sinLarge[i] 3167 f2 := Sin(vf[i] + large) 3168 if !close(f1, f2) { 3169 t.Errorf("Sin(%g) = %g, want %g", vf[i]+large, f2, f1) 3170 } 3171 } 3172 } 3173 3174 func TestLargeSincos(t *testing.T) { 3175 large := float64(100000 * Pi) 3176 for i := 0; i < len(vf); i++ { 3177 f1, g1 := sinLarge[i], cosLarge[i] 3178 f2, g2 := Sincos(vf[i] + large) 3179 if !close(f1, f2) || !close(g1, g2) { 3180 t.Errorf("Sincos(%g) = %g, %g, want %g, %g", vf[i]+large, f2, g2, f1, g1) 3181 } 3182 } 3183 } 3184 3185 func TestLargeTan(t *testing.T) { 3186 large := float64(100000 * Pi) 3187 for i := 0; i < len(vf); i++ { 3188 f1 := tanLarge[i] 3189 f2 := Tan(vf[i] + large) 3190 if !close(f1, f2) { 3191 t.Errorf("Tan(%g) = %g, want %g", vf[i]+large, f2, f1) 3192 } 3193 } 3194 } 3195 3196 // Check that trigReduce matches the standard reduction results for input values 3197 // below reduceThreshold. 3198 func TestTrigReduce(t *testing.T) { 3199 inputs := make([]float64, len(vf)) 3200 // all of the standard inputs 3201 copy(inputs, vf) 3202 // all of the large inputs 3203 large := float64(100000 * Pi) 3204 for _, v := range vf { 3205 inputs = append(inputs, v+large) 3206 } 3207 // Also test some special inputs, Pi and right below the reduceThreshold 3208 inputs = append(inputs, Pi, Nextafter(ReduceThreshold, 0)) 3209 for _, x := range inputs { 3210 // reduce the value to compare 3211 j, z := TrigReduce(x) 3212 xred := float64(j)*(Pi/4) + z 3213 3214 if f, fred := Sin(x), Sin(xred); !close(f, fred) { 3215 t.Errorf("Sin(trigReduce(%g)) != Sin(%g), got %g, want %g", x, x, fred, f) 3216 } 3217 if f, fred := Cos(x), Cos(xred); !close(f, fred) { 3218 t.Errorf("Cos(trigReduce(%g)) != Cos(%g), got %g, want %g", x, x, fred, f) 3219 } 3220 if f, fred := Tan(x), Tan(xred); !close(f, fred) { 3221 t.Errorf(" Tan(trigReduce(%g)) != Tan(%g), got %g, want %g", x, x, fred, f) 3222 } 3223 f, g := Sincos(x) 3224 fred, gred := Sincos(xred) 3225 if !close(f, fred) || !close(g, gred) { 3226 t.Errorf(" Sincos(trigReduce(%g)) != Sincos(%g), got %g, %g, want %g, %g", x, x, fred, gred, f, g) 3227 } 3228 } 3229 } 3230 3231 // Check that math constants are accepted by compiler 3232 // and have right value (assumes strconv.ParseFloat works). 3233 // https://golang.org/issue/201 3234 3235 type floatTest struct { 3236 val any 3237 name string 3238 str string 3239 } 3240 3241 var floatTests = []floatTest{ 3242 {float64(MaxFloat64), "MaxFloat64", "1.7976931348623157e+308"}, 3243 {float64(SmallestNonzeroFloat64), "SmallestNonzeroFloat64", "5e-324"}, 3244 {float32(MaxFloat32), "MaxFloat32", "3.4028235e+38"}, 3245 {float32(SmallestNonzeroFloat32), "SmallestNonzeroFloat32", "1e-45"}, 3246 } 3247 3248 func TestFloatMinMax(t *testing.T) { 3249 for _, tt := range floatTests { 3250 s := fmt.Sprint(tt.val) 3251 if s != tt.str { 3252 t.Errorf("Sprint(%v) = %s, want %s", tt.name, s, tt.str) 3253 } 3254 } 3255 } 3256 3257 func TestFloatMinima(t *testing.T) { 3258 if q := float32(SmallestNonzeroFloat32 / 2); q != 0 { 3259 t.Errorf("float32(SmallestNonzeroFloat32 / 2) = %g, want 0", q) 3260 } 3261 if q := float64(SmallestNonzeroFloat64 / 2); q != 0 { 3262 t.Errorf("float64(SmallestNonzeroFloat64 / 2) = %g, want 0", q) 3263 } 3264 } 3265 3266 var indirectSqrt = Sqrt 3267 3268 // TestFloat32Sqrt checks the correctness of the float32 square root optimization result. 3269 func TestFloat32Sqrt(t *testing.T) { 3270 for _, v := range sqrt32 { 3271 want := float32(indirectSqrt(float64(v))) 3272 got := float32(Sqrt(float64(v))) 3273 if IsNaN(float64(want)) { 3274 if !IsNaN(float64(got)) { 3275 t.Errorf("got=%#v want=NaN, v=%#v", got, v) 3276 } 3277 continue 3278 } 3279 if got != want { 3280 t.Errorf("got=%#v want=%#v, v=%#v", got, want, v) 3281 } 3282 } 3283 } 3284 3285 // Benchmarks 3286 3287 // Global exported variables are used to store the 3288 // return values of functions measured in the benchmarks. 3289 // Storing the results in these variables prevents the compiler 3290 // from completely optimizing the benchmarked functions away. 3291 var ( 3292 GlobalI int 3293 GlobalB bool 3294 GlobalF float64 3295 ) 3296 3297 func BenchmarkAcos(b *testing.B) { 3298 x := 0.0 3299 for i := 0; i < b.N; i++ { 3300 x = Acos(.5) 3301 } 3302 GlobalF = x 3303 } 3304 3305 func BenchmarkAcosh(b *testing.B) { 3306 x := 0.0 3307 for i := 0; i < b.N; i++ { 3308 x = Acosh(1.5) 3309 } 3310 GlobalF = x 3311 } 3312 3313 func BenchmarkAsin(b *testing.B) { 3314 x := 0.0 3315 for i := 0; i < b.N; i++ { 3316 x = Asin(.5) 3317 } 3318 GlobalF = x 3319 } 3320 3321 func BenchmarkAsinh(b *testing.B) { 3322 x := 0.0 3323 for i := 0; i < b.N; i++ { 3324 x = Asinh(.5) 3325 } 3326 GlobalF = x 3327 } 3328 3329 func BenchmarkAtan(b *testing.B) { 3330 x := 0.0 3331 for i := 0; i < b.N; i++ { 3332 x = Atan(.5) 3333 } 3334 GlobalF = x 3335 } 3336 3337 func BenchmarkAtanh(b *testing.B) { 3338 x := 0.0 3339 for i := 0; i < b.N; i++ { 3340 x = Atanh(.5) 3341 } 3342 GlobalF = x 3343 } 3344 3345 func BenchmarkAtan2(b *testing.B) { 3346 x := 0.0 3347 for i := 0; i < b.N; i++ { 3348 x = Atan2(.5, 1) 3349 } 3350 GlobalF = x 3351 } 3352 3353 func BenchmarkCbrt(b *testing.B) { 3354 x := 0.0 3355 for i := 0; i < b.N; i++ { 3356 x = Cbrt(10) 3357 } 3358 GlobalF = x 3359 } 3360 3361 func BenchmarkCeil(b *testing.B) { 3362 x := 0.0 3363 for i := 0; i < b.N; i++ { 3364 x = Ceil(.5) 3365 } 3366 GlobalF = x 3367 } 3368 3369 var copysignNeg = -1.0 3370 3371 func BenchmarkCopysign(b *testing.B) { 3372 x := 0.0 3373 for i := 0; i < b.N; i++ { 3374 x = Copysign(.5, copysignNeg) 3375 } 3376 GlobalF = x 3377 } 3378 3379 func BenchmarkCos(b *testing.B) { 3380 x := 0.0 3381 for i := 0; i < b.N; i++ { 3382 x = Cos(.5) 3383 } 3384 GlobalF = x 3385 } 3386 3387 func BenchmarkCosh(b *testing.B) { 3388 x := 0.0 3389 for i := 0; i < b.N; i++ { 3390 x = Cosh(2.5) 3391 } 3392 GlobalF = x 3393 } 3394 3395 func BenchmarkErf(b *testing.B) { 3396 x := 0.0 3397 for i := 0; i < b.N; i++ { 3398 x = Erf(.5) 3399 } 3400 GlobalF = x 3401 } 3402 3403 func BenchmarkErfc(b *testing.B) { 3404 x := 0.0 3405 for i := 0; i < b.N; i++ { 3406 x = Erfc(.5) 3407 } 3408 GlobalF = x 3409 } 3410 3411 func BenchmarkErfinv(b *testing.B) { 3412 x := 0.0 3413 for i := 0; i < b.N; i++ { 3414 x = Erfinv(.5) 3415 } 3416 GlobalF = x 3417 } 3418 3419 func BenchmarkErfcinv(b *testing.B) { 3420 x := 0.0 3421 for i := 0; i < b.N; i++ { 3422 x = Erfcinv(.5) 3423 } 3424 GlobalF = x 3425 } 3426 3427 func BenchmarkExp(b *testing.B) { 3428 x := 0.0 3429 for i := 0; i < b.N; i++ { 3430 x = Exp(.5) 3431 } 3432 GlobalF = x 3433 } 3434 3435 func BenchmarkExpGo(b *testing.B) { 3436 x := 0.0 3437 for i := 0; i < b.N; i++ { 3438 x = ExpGo(.5) 3439 } 3440 GlobalF = x 3441 } 3442 3443 func BenchmarkExpm1(b *testing.B) { 3444 x := 0.0 3445 for i := 0; i < b.N; i++ { 3446 x = Expm1(.5) 3447 } 3448 GlobalF = x 3449 } 3450 3451 func BenchmarkExp2(b *testing.B) { 3452 x := 0.0 3453 for i := 0; i < b.N; i++ { 3454 x = Exp2(.5) 3455 } 3456 GlobalF = x 3457 } 3458 3459 func BenchmarkExp2Go(b *testing.B) { 3460 x := 0.0 3461 for i := 0; i < b.N; i++ { 3462 x = Exp2Go(.5) 3463 } 3464 GlobalF = x 3465 } 3466 3467 var absPos = .5 3468 3469 func BenchmarkAbs(b *testing.B) { 3470 x := 0.0 3471 for i := 0; i < b.N; i++ { 3472 x = Abs(absPos) 3473 } 3474 GlobalF = x 3475 3476 } 3477 3478 func BenchmarkDim(b *testing.B) { 3479 x := 0.0 3480 for i := 0; i < b.N; i++ { 3481 x = Dim(GlobalF, x) 3482 } 3483 GlobalF = x 3484 } 3485 3486 func BenchmarkFloor(b *testing.B) { 3487 x := 0.0 3488 for i := 0; i < b.N; i++ { 3489 x = Floor(.5) 3490 } 3491 GlobalF = x 3492 } 3493 3494 func BenchmarkMax(b *testing.B) { 3495 x := 0.0 3496 for i := 0; i < b.N; i++ { 3497 x = Max(10, 3) 3498 } 3499 GlobalF = x 3500 } 3501 3502 func BenchmarkMin(b *testing.B) { 3503 x := 0.0 3504 for i := 0; i < b.N; i++ { 3505 x = Min(10, 3) 3506 } 3507 GlobalF = x 3508 } 3509 3510 func BenchmarkMod(b *testing.B) { 3511 x := 0.0 3512 for i := 0; i < b.N; i++ { 3513 x = Mod(10, 3) 3514 } 3515 GlobalF = x 3516 } 3517 3518 func BenchmarkFrexp(b *testing.B) { 3519 x := 0.0 3520 y := 0 3521 for i := 0; i < b.N; i++ { 3522 x, y = Frexp(8) 3523 } 3524 GlobalF = x 3525 GlobalI = y 3526 } 3527 3528 func BenchmarkGamma(b *testing.B) { 3529 x := 0.0 3530 for i := 0; i < b.N; i++ { 3531 x = Gamma(2.5) 3532 } 3533 GlobalF = x 3534 } 3535 3536 func BenchmarkHypot(b *testing.B) { 3537 x := 0.0 3538 for i := 0; i < b.N; i++ { 3539 x = Hypot(3, 4) 3540 } 3541 GlobalF = x 3542 } 3543 3544 func BenchmarkHypotGo(b *testing.B) { 3545 x := 0.0 3546 for i := 0; i < b.N; i++ { 3547 x = HypotGo(3, 4) 3548 } 3549 GlobalF = x 3550 } 3551 3552 func BenchmarkIlogb(b *testing.B) { 3553 x := 0 3554 for i := 0; i < b.N; i++ { 3555 x = Ilogb(.5) 3556 } 3557 GlobalI = x 3558 } 3559 3560 func BenchmarkJ0(b *testing.B) { 3561 x := 0.0 3562 for i := 0; i < b.N; i++ { 3563 x = J0(2.5) 3564 } 3565 GlobalF = x 3566 } 3567 3568 func BenchmarkJ1(b *testing.B) { 3569 x := 0.0 3570 for i := 0; i < b.N; i++ { 3571 x = J1(2.5) 3572 } 3573 GlobalF = x 3574 } 3575 3576 func BenchmarkJn(b *testing.B) { 3577 x := 0.0 3578 for i := 0; i < b.N; i++ { 3579 x = Jn(2, 2.5) 3580 } 3581 GlobalF = x 3582 } 3583 3584 func BenchmarkLdexp(b *testing.B) { 3585 x := 0.0 3586 for i := 0; i < b.N; i++ { 3587 x = Ldexp(.5, 2) 3588 } 3589 GlobalF = x 3590 } 3591 3592 func BenchmarkLgamma(b *testing.B) { 3593 x := 0.0 3594 y := 0 3595 for i := 0; i < b.N; i++ { 3596 x, y = Lgamma(2.5) 3597 } 3598 GlobalF = x 3599 GlobalI = y 3600 } 3601 3602 func BenchmarkLog(b *testing.B) { 3603 x := 0.0 3604 for i := 0; i < b.N; i++ { 3605 x = Log(.5) 3606 } 3607 GlobalF = x 3608 } 3609 3610 func BenchmarkLogb(b *testing.B) { 3611 x := 0.0 3612 for i := 0; i < b.N; i++ { 3613 x = Logb(.5) 3614 } 3615 GlobalF = x 3616 } 3617 3618 func BenchmarkLog1p(b *testing.B) { 3619 x := 0.0 3620 for i := 0; i < b.N; i++ { 3621 x = Log1p(.5) 3622 } 3623 GlobalF = x 3624 } 3625 3626 func BenchmarkLog10(b *testing.B) { 3627 x := 0.0 3628 for i := 0; i < b.N; i++ { 3629 x = Log10(.5) 3630 } 3631 GlobalF = x 3632 } 3633 3634 func BenchmarkLog2(b *testing.B) { 3635 x := 0.0 3636 for i := 0; i < b.N; i++ { 3637 x = Log2(.5) 3638 } 3639 GlobalF += x 3640 } 3641 3642 func BenchmarkModf(b *testing.B) { 3643 x := 0.0 3644 y := 0.0 3645 for i := 0; i < b.N; i++ { 3646 x, y = Modf(1.5) 3647 } 3648 GlobalF += x 3649 GlobalF += y 3650 } 3651 3652 func BenchmarkNextafter32(b *testing.B) { 3653 x := float32(0.0) 3654 for i := 0; i < b.N; i++ { 3655 x = Nextafter32(.5, 1) 3656 } 3657 GlobalF = float64(x) 3658 } 3659 3660 func BenchmarkNextafter64(b *testing.B) { 3661 x := 0.0 3662 for i := 0; i < b.N; i++ { 3663 x = Nextafter(.5, 1) 3664 } 3665 GlobalF = x 3666 } 3667 3668 func BenchmarkPowInt(b *testing.B) { 3669 x := 0.0 3670 for i := 0; i < b.N; i++ { 3671 x = Pow(2, 2) 3672 } 3673 GlobalF = x 3674 } 3675 3676 func BenchmarkPowFrac(b *testing.B) { 3677 x := 0.0 3678 for i := 0; i < b.N; i++ { 3679 x = Pow(2.5, 1.5) 3680 } 3681 GlobalF = x 3682 } 3683 3684 var pow10pos = int(300) 3685 3686 func BenchmarkPow10Pos(b *testing.B) { 3687 x := 0.0 3688 for i := 0; i < b.N; i++ { 3689 x = Pow10(pow10pos) 3690 } 3691 GlobalF = x 3692 } 3693 3694 var pow10neg = int(-300) 3695 3696 func BenchmarkPow10Neg(b *testing.B) { 3697 x := 0.0 3698 for i := 0; i < b.N; i++ { 3699 x = Pow10(pow10neg) 3700 } 3701 GlobalF = x 3702 } 3703 3704 var roundNeg = float64(-2.5) 3705 3706 func BenchmarkRound(b *testing.B) { 3707 x := 0.0 3708 for i := 0; i < b.N; i++ { 3709 x = Round(roundNeg) 3710 } 3711 GlobalF = x 3712 } 3713 3714 func BenchmarkRoundToEven(b *testing.B) { 3715 x := 0.0 3716 for i := 0; i < b.N; i++ { 3717 x = RoundToEven(roundNeg) 3718 } 3719 GlobalF = x 3720 } 3721 3722 func BenchmarkRemainder(b *testing.B) { 3723 x := 0.0 3724 for i := 0; i < b.N; i++ { 3725 x = Remainder(10, 3) 3726 } 3727 GlobalF = x 3728 } 3729 3730 var signbitPos = 2.5 3731 3732 func BenchmarkSignbit(b *testing.B) { 3733 x := false 3734 for i := 0; i < b.N; i++ { 3735 x = Signbit(signbitPos) 3736 } 3737 GlobalB = x 3738 } 3739 3740 func BenchmarkSin(b *testing.B) { 3741 x := 0.0 3742 for i := 0; i < b.N; i++ { 3743 x = Sin(.5) 3744 } 3745 GlobalF = x 3746 } 3747 3748 func BenchmarkSincos(b *testing.B) { 3749 x := 0.0 3750 y := 0.0 3751 for i := 0; i < b.N; i++ { 3752 x, y = Sincos(.5) 3753 } 3754 GlobalF += x 3755 GlobalF += y 3756 } 3757 3758 func BenchmarkSinh(b *testing.B) { 3759 x := 0.0 3760 for i := 0; i < b.N; i++ { 3761 x = Sinh(2.5) 3762 } 3763 GlobalF = x 3764 } 3765 3766 func BenchmarkSqrtIndirect(b *testing.B) { 3767 x, y := 0.0, 10.0 3768 f := Sqrt 3769 for i := 0; i < b.N; i++ { 3770 x += f(y) 3771 } 3772 GlobalF = x 3773 } 3774 3775 func BenchmarkSqrtLatency(b *testing.B) { 3776 x := 10.0 3777 for i := 0; i < b.N; i++ { 3778 x = Sqrt(x) 3779 } 3780 GlobalF = x 3781 } 3782 3783 func BenchmarkSqrtIndirectLatency(b *testing.B) { 3784 x := 10.0 3785 f := Sqrt 3786 for i := 0; i < b.N; i++ { 3787 x = f(x) 3788 } 3789 GlobalF = x 3790 } 3791 3792 func BenchmarkSqrtGoLatency(b *testing.B) { 3793 x := 10.0 3794 for i := 0; i < b.N; i++ { 3795 x = SqrtGo(x) 3796 } 3797 GlobalF = x 3798 } 3799 3800 func isPrime(i int) bool { 3801 // Yes, this is a dumb way to write this code, 3802 // but calling Sqrt repeatedly in this way demonstrates 3803 // the benefit of using a direct SQRT instruction on systems 3804 // that have one, whereas the obvious loop seems not to 3805 // demonstrate such a benefit. 3806 for j := 2; float64(j) <= Sqrt(float64(i)); j++ { 3807 if i%j == 0 { 3808 return false 3809 } 3810 } 3811 return true 3812 } 3813 3814 func BenchmarkSqrtPrime(b *testing.B) { 3815 x := false 3816 for i := 0; i < b.N; i++ { 3817 x = isPrime(100003) 3818 } 3819 GlobalB = x 3820 } 3821 3822 func BenchmarkTan(b *testing.B) { 3823 x := 0.0 3824 for i := 0; i < b.N; i++ { 3825 x = Tan(.5) 3826 } 3827 GlobalF = x 3828 } 3829 3830 func BenchmarkTanh(b *testing.B) { 3831 x := 0.0 3832 for i := 0; i < b.N; i++ { 3833 x = Tanh(2.5) 3834 } 3835 GlobalF = x 3836 } 3837 func BenchmarkTrunc(b *testing.B) { 3838 x := 0.0 3839 for i := 0; i < b.N; i++ { 3840 x = Trunc(.5) 3841 } 3842 GlobalF = x 3843 } 3844 3845 func BenchmarkY0(b *testing.B) { 3846 x := 0.0 3847 for i := 0; i < b.N; i++ { 3848 x = Y0(2.5) 3849 } 3850 GlobalF = x 3851 } 3852 3853 func BenchmarkY1(b *testing.B) { 3854 x := 0.0 3855 for i := 0; i < b.N; i++ { 3856 x = Y1(2.5) 3857 } 3858 GlobalF = x 3859 } 3860 3861 func BenchmarkYn(b *testing.B) { 3862 x := 0.0 3863 for i := 0; i < b.N; i++ { 3864 x = Yn(2, 2.5) 3865 } 3866 GlobalF = x 3867 } 3868 3869 func BenchmarkFloat64bits(b *testing.B) { 3870 y := uint64(0) 3871 for i := 0; i < b.N; i++ { 3872 y = Float64bits(roundNeg) 3873 } 3874 GlobalI = int(y) 3875 } 3876 3877 var roundUint64 = uint64(5) 3878 3879 func BenchmarkFloat64frombits(b *testing.B) { 3880 x := 0.0 3881 for i := 0; i < b.N; i++ { 3882 x = Float64frombits(roundUint64) 3883 } 3884 GlobalF = x 3885 } 3886 3887 var roundFloat32 = float32(-2.5) 3888 3889 func BenchmarkFloat32bits(b *testing.B) { 3890 y := uint32(0) 3891 for i := 0; i < b.N; i++ { 3892 y = Float32bits(roundFloat32) 3893 } 3894 GlobalI = int(y) 3895 } 3896 3897 var roundUint32 = uint32(5) 3898 3899 func BenchmarkFloat32frombits(b *testing.B) { 3900 x := float32(0.0) 3901 for i := 0; i < b.N; i++ { 3902 x = Float32frombits(roundUint32) 3903 } 3904 GlobalF = float64(x) 3905 } 3906 3907 func BenchmarkFMA(b *testing.B) { 3908 x := 0.0 3909 for i := 0; i < b.N; i++ { 3910 x = FMA(E, Pi, x) 3911 } 3912 GlobalF = x 3913 }