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 5package math_test 6 7import ( 8 "fmt" 9 . "math" 10 "testing" 11 "unsafe" 12) 13 14var 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). 32var 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} 44var 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} 56var 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} 68var 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} 80var 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} 92var 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} 104var 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} 116var 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} 128var 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} 140var 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} 152var 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] 166var 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 179var 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} 191var 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} 203var 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} 215var 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} 227var 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} 239var 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} 251var 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} 263var 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} 275var 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} 287var 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} 299var 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} 311var 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 324type fi struct { 325 f float64 326 i int 327} 328 329var 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} 341var 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} 353var 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} 365var 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} 377var 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} 389var 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} 401var 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} 413var 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} 425var 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} 437var 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} 449var 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} 461var 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} 473var 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} 485var 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} 497var 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} 509var 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} 521var 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} 533var 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} 545var signbit = []bool{ 546 false, 547 false, 548 true, 549 true, 550 false, 551 false, 552 false, 553 false, 554 false, 555 true, 556} 557var 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] 571var 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} 583var 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} 595var 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} 607var 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] 621var 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} 633var 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} 645var 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} 657var 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} 669var 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} 681var 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} 693var 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 707var vfacosSC = []float64{ 708 -Pi, 709 1, 710 Pi, 711 NaN(), 712} 713var acosSC = []float64{ 714 NaN(), 715 0, 716 NaN(), 717 NaN(), 718} 719 720var vfacoshSC = []float64{ 721 Inf(-1), 722 0.5, 723 1, 724 Inf(1), 725 NaN(), 726} 727var acoshSC = []float64{ 728 NaN(), 729 NaN(), 730 0, 731 Inf(1), 732 NaN(), 733} 734 735var vfasinSC = []float64{ 736 -Pi, 737 Copysign(0, -1), 738 0, 739 Pi, 740 NaN(), 741} 742var asinSC = []float64{ 743 NaN(), 744 Copysign(0, -1), 745 0, 746 NaN(), 747 NaN(), 748} 749 750var vfasinhSC = []float64{ 751 Inf(-1), 752 Copysign(0, -1), 753 0, 754 Inf(1), 755 NaN(), 756} 757var asinhSC = []float64{ 758 Inf(-1), 759 Copysign(0, -1), 760 0, 761 Inf(1), 762 NaN(), 763} 764 765var vfatanSC = []float64{ 766 Inf(-1), 767 Copysign(0, -1), 768 0, 769 Inf(1), 770 NaN(), 771} 772var atanSC = []float64{ 773 -Pi / 2, 774 Copysign(0, -1), 775 0, 776 Pi / 2, 777 NaN(), 778} 779 780var 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} 791var 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} 802var 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 {+Pi, NaN()}, 831 {Inf(1), Inf(-1)}, 832 {Inf(1), -Pi}, 833 {Inf(1), 0}, 834 {Inf(1), +Pi}, 835 {Inf(1), Inf(1)}, 836 {Inf(1), NaN()}, 837 {NaN(), NaN()}, 838} 839var atan2SC = []float64{ 840 -3 * Pi / 4, // atan2(-Inf, -Inf) 841 -Pi / 2, // atan2(-Inf, -Pi) 842 -Pi / 2, // atan2(-Inf, +0) 843 -Pi / 2, // atan2(-Inf, +Pi) 844 -Pi / 4, // atan2(-Inf, +Inf) 845 NaN(), // atan2(-Inf, NaN) 846 -Pi, // atan2(-Pi, -Inf) 847 -Pi / 2, // atan2(-Pi, +0) 848 Copysign(0, -1), // atan2(-Pi, Inf) 849 NaN(), // atan2(-Pi, NaN) 850 -Pi, // atan2(-0, -Inf) 851 -Pi, // atan2(-0, -Pi) 852 -Pi, // atan2(-0, -0) 853 Copysign(0, -1), // atan2(-0, +0) 854 Copysign(0, -1), // atan2(-0, +Pi) 855 Copysign(0, -1), // atan2(-0, +Inf) 856 NaN(), // atan2(-0, NaN) 857 Pi, // atan2(+0, -Inf) 858 Pi, // atan2(+0, -Pi) 859 Pi, // atan2(+0, -0) 860 0, // atan2(+0, +0) 861 0, // atan2(+0, +Pi) 862 0, // atan2(+0, +Inf) 863 NaN(), // atan2(+0, NaN) 864 Pi, // atan2(+Pi, -Inf) 865 Pi / 2, // atan2(+Pi, +0) 866 0, // atan2(+Pi, +Inf) 867 NaN(), // atan2(+Pi, NaN) 868 3 * Pi / 4, // atan2(+Inf, -Inf) 869 Pi / 2, // atan2(+Inf, -Pi) 870 Pi / 2, // atan2(+Inf, +0) 871 Pi / 2, // atan2(+Inf, +Pi) 872 Pi / 4, // atan2(+Inf, +Inf) 873 NaN(), // atan2(+Inf, NaN) 874 NaN(), // atan2(NaN, NaN) 875} 876 877var vfcbrtSC = []float64{ 878 Inf(-1), 879 Copysign(0, -1), 880 0, 881 Inf(1), 882 NaN(), 883} 884var cbrtSC = []float64{ 885 Inf(-1), 886 Copysign(0, -1), 887 0, 888 Inf(1), 889 NaN(), 890} 891 892var vfceilSC = []float64{ 893 Inf(-1), 894 Copysign(0, -1), 895 0, 896 Inf(1), 897 NaN(), 898} 899var ceilSC = []float64{ 900 Inf(-1), 901 Copysign(0, -1), 902 0, 903 Inf(1), 904 NaN(), 905} 906 907var vfcopysignSC = []float64{ 908 Inf(-1), 909 Inf(1), 910 NaN(), 911} 912var copysignSC = []float64{ 913 Inf(-1), 914 Inf(-1), 915 NaN(), 916} 917 918var vfcosSC = []float64{ 919 Inf(-1), 920 Inf(1), 921 NaN(), 922} 923var cosSC = []float64{ 924 NaN(), 925 NaN(), 926 NaN(), 927} 928 929var vfcoshSC = []float64{ 930 Inf(-1), 931 Copysign(0, -1), 932 0, 933 Inf(1), 934 NaN(), 935} 936var coshSC = []float64{ 937 Inf(1), 938 1, 939 1, 940 Inf(1), 941 NaN(), 942} 943 944var vferfSC = []float64{ 945 Inf(-1), 946 Copysign(0, -1), 947 0, 948 Inf(1), 949 NaN(), 950 -1000, 951 1000, 952} 953var erfSC = []float64{ 954 -1, 955 Copysign(0, -1), 956 0, 957 1, 958 NaN(), 959 -1, 960 1, 961} 962 963var vferfcSC = []float64{ 964 Inf(-1), 965 Inf(1), 966 NaN(), 967 -1000, 968 1000, 969} 970var erfcSC = []float64{ 971 2, 972 0, 973 NaN(), 974 2, 975 0, 976} 977 978var vferfinvSC = []float64{ 979 1, 980 -1, 981 0, 982 Inf(-1), 983 Inf(1), 984 NaN(), 985} 986var erfinvSC = []float64{ 987 Inf(+1), 988 Inf(-1), 989 0, 990 NaN(), 991 NaN(), 992 NaN(), 993} 994 995var vferfcinvSC = []float64{ 996 0, 997 2, 998 1, 999 Inf(1), 1000 Inf(-1), 1001 NaN(), 1002} 1003var erfcinvSC = []float64{ 1004 Inf(+1), 1005 Inf(-1), 1006 0, 1007 NaN(), 1008 NaN(), 1009 NaN(), 1010} 1011 1012var vfexpSC = []float64{ 1013 Inf(-1), 1014 -2000, 1015 2000, 1016 Inf(1), 1017 NaN(), 1018 // smallest float64 that overflows Exp(x) 1019 7.097827128933841e+02, 1020 // Issue 18912 1021 1.48852223e+09, 1022 1.4885222e+09, 1023 1, 1024 // near zero 1025 3.725290298461915e-09, 1026 // denormal 1027 -740, 1028} 1029var expSC = []float64{ 1030 0, 1031 0, 1032 Inf(1), 1033 Inf(1), 1034 NaN(), 1035 Inf(1), 1036 Inf(1), 1037 Inf(1), 1038 2.718281828459045, 1039 1.0000000037252903, 1040 4.2e-322, 1041} 1042 1043var vfexp2SC = []float64{ 1044 Inf(-1), 1045 -2000, 1046 2000, 1047 Inf(1), 1048 NaN(), 1049 // smallest float64 that overflows Exp2(x) 1050 1024, 1051 // near underflow 1052 -1.07399999999999e+03, 1053 // near zero 1054 3.725290298461915e-09, 1055} 1056var exp2SC = []float64{ 1057 0, 1058 0, 1059 Inf(1), 1060 Inf(1), 1061 NaN(), 1062 Inf(1), 1063 5e-324, 1064 1.0000000025821745, 1065} 1066 1067var vfexpm1SC = []float64{ 1068 Inf(-1), 1069 -710, 1070 Copysign(0, -1), 1071 0, 1072 710, 1073 Inf(1), 1074 NaN(), 1075} 1076var expm1SC = []float64{ 1077 -1, 1078 -1, 1079 Copysign(0, -1), 1080 0, 1081 Inf(1), 1082 Inf(1), 1083 NaN(), 1084} 1085 1086var vffabsSC = []float64{ 1087 Inf(-1), 1088 Copysign(0, -1), 1089 0, 1090 Inf(1), 1091 NaN(), 1092} 1093var fabsSC = []float64{ 1094 Inf(1), 1095 0, 1096 0, 1097 Inf(1), 1098 NaN(), 1099} 1100 1101var vffdimSC = [][2]float64{ 1102 {Inf(-1), Inf(-1)}, 1103 {Inf(-1), Inf(1)}, 1104 {Inf(-1), NaN()}, 1105 {Copysign(0, -1), Copysign(0, -1)}, 1106 {Copysign(0, -1), 0}, 1107 {0, Copysign(0, -1)}, 1108 {0, 0}, 1109 {Inf(1), Inf(-1)}, 1110 {Inf(1), Inf(1)}, 1111 {Inf(1), NaN()}, 1112 {NaN(), Inf(-1)}, 1113 {NaN(), Copysign(0, -1)}, 1114 {NaN(), 0}, 1115 {NaN(), Inf(1)}, 1116 {NaN(), NaN()}, 1117} 1118var nan = Float64frombits(0xFFF8000000000000) // SSE2 DIVSD 0/0 1119var vffdim2SC = [][2]float64{ 1120 {Inf(-1), Inf(-1)}, 1121 {Inf(-1), Inf(1)}, 1122 {Inf(-1), nan}, 1123 {Copysign(0, -1), Copysign(0, -1)}, 1124 {Copysign(0, -1), 0}, 1125 {0, Copysign(0, -1)}, 1126 {0, 0}, 1127 {Inf(1), Inf(-1)}, 1128 {Inf(1), Inf(1)}, 1129 {Inf(1), nan}, 1130 {nan, Inf(-1)}, 1131 {nan, Copysign(0, -1)}, 1132 {nan, 0}, 1133 {nan, Inf(1)}, 1134 {nan, nan}, 1135} 1136var fdimSC = []float64{ 1137 NaN(), 1138 0, 1139 NaN(), 1140 0, 1141 0, 1142 0, 1143 0, 1144 Inf(1), 1145 NaN(), 1146 NaN(), 1147 NaN(), 1148 NaN(), 1149 NaN(), 1150 NaN(), 1151 NaN(), 1152} 1153var fmaxSC = []float64{ 1154 Inf(-1), 1155 Inf(1), 1156 NaN(), 1157 Copysign(0, -1), 1158 0, 1159 0, 1160 0, 1161 Inf(1), 1162 Inf(1), 1163 Inf(1), 1164 NaN(), 1165 NaN(), 1166 NaN(), 1167 Inf(1), 1168 NaN(), 1169} 1170var fminSC = []float64{ 1171 Inf(-1), 1172 Inf(-1), 1173 Inf(-1), 1174 Copysign(0, -1), 1175 Copysign(0, -1), 1176 Copysign(0, -1), 1177 0, 1178 Inf(-1), 1179 Inf(1), 1180 NaN(), 1181 Inf(-1), 1182 NaN(), 1183 NaN(), 1184 NaN(), 1185 NaN(), 1186} 1187 1188var vffmodSC = [][2]float64{ 1189 {Inf(-1), Inf(-1)}, 1190 {Inf(-1), -Pi}, 1191 {Inf(-1), 0}, 1192 {Inf(-1), Pi}, 1193 {Inf(-1), Inf(1)}, 1194 {Inf(-1), NaN()}, 1195 {-Pi, Inf(-1)}, 1196 {-Pi, 0}, 1197 {-Pi, Inf(1)}, 1198 {-Pi, NaN()}, 1199 {Copysign(0, -1), Inf(-1)}, 1200 {Copysign(0, -1), 0}, 1201 {Copysign(0, -1), Inf(1)}, 1202 {Copysign(0, -1), NaN()}, 1203 {0, Inf(-1)}, 1204 {0, 0}, 1205 {0, Inf(1)}, 1206 {0, NaN()}, 1207 {Pi, Inf(-1)}, 1208 {Pi, 0}, 1209 {Pi, Inf(1)}, 1210 {Pi, NaN()}, 1211 {Inf(1), Inf(-1)}, 1212 {Inf(1), -Pi}, 1213 {Inf(1), 0}, 1214 {Inf(1), Pi}, 1215 {Inf(1), Inf(1)}, 1216 {Inf(1), NaN()}, 1217 {NaN(), Inf(-1)}, 1218 {NaN(), -Pi}, 1219 {NaN(), 0}, 1220 {NaN(), Pi}, 1221 {NaN(), Inf(1)}, 1222 {NaN(), NaN()}, 1223} 1224var fmodSC = []float64{ 1225 NaN(), // fmod(-Inf, -Inf) 1226 NaN(), // fmod(-Inf, -Pi) 1227 NaN(), // fmod(-Inf, 0) 1228 NaN(), // fmod(-Inf, Pi) 1229 NaN(), // fmod(-Inf, +Inf) 1230 NaN(), // fmod(-Inf, NaN) 1231 -Pi, // fmod(-Pi, -Inf) 1232 NaN(), // fmod(-Pi, 0) 1233 -Pi, // fmod(-Pi, +Inf) 1234 NaN(), // fmod(-Pi, NaN) 1235 Copysign(0, -1), // fmod(-0, -Inf) 1236 NaN(), // fmod(-0, 0) 1237 Copysign(0, -1), // fmod(-0, Inf) 1238 NaN(), // fmod(-0, NaN) 1239 0, // fmod(0, -Inf) 1240 NaN(), // fmod(0, 0) 1241 0, // fmod(0, +Inf) 1242 NaN(), // fmod(0, NaN) 1243 Pi, // fmod(Pi, -Inf) 1244 NaN(), // fmod(Pi, 0) 1245 Pi, // fmod(Pi, +Inf) 1246 NaN(), // fmod(Pi, NaN) 1247 NaN(), // fmod(+Inf, -Inf) 1248 NaN(), // fmod(+Inf, -Pi) 1249 NaN(), // fmod(+Inf, 0) 1250 NaN(), // fmod(+Inf, Pi) 1251 NaN(), // fmod(+Inf, +Inf) 1252 NaN(), // fmod(+Inf, NaN) 1253 NaN(), // fmod(NaN, -Inf) 1254 NaN(), // fmod(NaN, -Pi) 1255 NaN(), // fmod(NaN, 0) 1256 NaN(), // fmod(NaN, Pi) 1257 NaN(), // fmod(NaN, +Inf) 1258 NaN(), // fmod(NaN, NaN) 1259} 1260 1261var vffrexpSC = []float64{ 1262 Inf(-1), 1263 Copysign(0, -1), 1264 0, 1265 Inf(1), 1266 NaN(), 1267} 1268var frexpSC = []fi{ 1269 {Inf(-1), 0}, 1270 {Copysign(0, -1), 0}, 1271 {0, 0}, 1272 {Inf(1), 0}, 1273 {NaN(), 0}, 1274} 1275 1276var vfgamma = [][2]float64{ 1277 {Inf(1), Inf(1)}, 1278 {Inf(-1), NaN()}, 1279 {0, Inf(1)}, 1280 {Copysign(0, -1), Inf(-1)}, 1281 {NaN(), NaN()}, 1282 {-1, NaN()}, 1283 {-2, NaN()}, 1284 {-3, NaN()}, 1285 {-1e16, NaN()}, 1286 {-1e300, NaN()}, 1287 {1.7e308, Inf(1)}, 1288 1289 // Test inputs inspired by Python test suite. 1290 // Outputs computed at high precision by PARI/GP. 1291 // If recomputing table entries, be careful to use 1292 // high-precision (%.1000g) formatting of the float64 inputs. 1293 // For example, -2.0000000000000004 is the float64 with exact value 1294 // -2.00000000000000044408920985626161695, and 1295 // gamma(-2.0000000000000004) = -1249999999999999.5386078562728167651513, while 1296 // gamma(-2.00000000000000044408920985626161695) = -1125899906826907.2044875028130093136826. 1297 // Thus the table lists -1.1258999068426235e+15 as the answer. 1298 {0.5, 1.772453850905516}, 1299 {1.5, 0.886226925452758}, 1300 {2.5, 1.329340388179137}, 1301 {3.5, 3.3233509704478426}, 1302 {-0.5, -3.544907701811032}, 1303 {-1.5, 2.363271801207355}, 1304 {-2.5, -0.9453087204829419}, 1305 {-3.5, 0.2700882058522691}, 1306 {0.1, 9.51350769866873}, 1307 {0.01, 99.4325851191506}, 1308 {1e-08, 9.999999942278434e+07}, 1309 {1e-16, 1e+16}, 1310 {0.001, 999.4237724845955}, 1311 {1e-16, 1e+16}, 1312 {1e-308, 1e+308}, 1313 {5.6e-309, 1.7857142857142864e+308}, 1314 {5.5e-309, Inf(1)}, 1315 {1e-309, Inf(1)}, 1316 {1e-323, Inf(1)}, 1317 {5e-324, Inf(1)}, 1318 {-0.1, -10.686287021193193}, 1319 {-0.01, -100.58719796441078}, 1320 {-1e-08, -1.0000000057721567e+08}, 1321 {-1e-16, -1e+16}, 1322 {-0.001, -1000.5782056293586}, 1323 {-1e-16, -1e+16}, 1324 {-1e-308, -1e+308}, 1325 {-5.6e-309, -1.7857142857142864e+308}, 1326 {-5.5e-309, Inf(-1)}, 1327 {-1e-309, Inf(-1)}, 1328 {-1e-323, Inf(-1)}, 1329 {-5e-324, Inf(-1)}, 1330 {-0.9999999999999999, -9.007199254740992e+15}, 1331 {-1.0000000000000002, 4.5035996273704955e+15}, 1332 {-1.9999999999999998, 2.2517998136852485e+15}, 1333 {-2.0000000000000004, -1.1258999068426235e+15}, 1334 {-100.00000000000001, -7.540083334883109e-145}, 1335 {-99.99999999999999, 7.540083334884096e-145}, 1336 {17, 2.0922789888e+13}, 1337 {171, 7.257415615307999e+306}, 1338 {171.6, 1.5858969096672565e+308}, 1339 {171.624, 1.7942117599248104e+308}, 1340 {171.625, Inf(1)}, 1341 {172, Inf(1)}, 1342 {2000, Inf(1)}, 1343 {-100.5, -3.3536908198076787e-159}, 1344 {-160.5, -5.255546447007829e-286}, 1345 {-170.5, -3.3127395215386074e-308}, 1346 {-171.5, 1.9316265431712e-310}, 1347 {-176.5, -1.196e-321}, 1348 {-177.5, 5e-324}, 1349 {-178.5, Copysign(0, -1)}, 1350 {-179.5, 0}, 1351 {-201.0001, 0}, 1352 {-202.9999, Copysign(0, -1)}, 1353 {-1000.5, Copysign(0, -1)}, 1354 {-1.0000000003e+09, Copysign(0, -1)}, 1355 {-4.5035996273704955e+15, 0}, 1356 {-63.349078729022985, 4.177797167776188e-88}, 1357 {-127.45117632943295, 1.183111089623681e-214}, 1358} 1359 1360var vfhypotSC = [][2]float64{ 1361 {Inf(-1), Inf(-1)}, 1362 {Inf(-1), 0}, 1363 {Inf(-1), Inf(1)}, 1364 {Inf(-1), NaN()}, 1365 {Copysign(0, -1), Copysign(0, -1)}, 1366 {Copysign(0, -1), 0}, 1367 {0, Copysign(0, -1)}, 1368 {0, 0}, // +0, +0 1369 {0, Inf(-1)}, 1370 {0, Inf(1)}, 1371 {0, NaN()}, 1372 {Inf(1), Inf(-1)}, 1373 {Inf(1), 0}, 1374 {Inf(1), Inf(1)}, 1375 {Inf(1), NaN()}, 1376 {NaN(), Inf(-1)}, 1377 {NaN(), 0}, 1378 {NaN(), Inf(1)}, 1379 {NaN(), NaN()}, 1380} 1381var hypotSC = []float64{ 1382 Inf(1), 1383 Inf(1), 1384 Inf(1), 1385 Inf(1), 1386 0, 1387 0, 1388 0, 1389 0, 1390 Inf(1), 1391 Inf(1), 1392 NaN(), 1393 Inf(1), 1394 Inf(1), 1395 Inf(1), 1396 Inf(1), 1397 Inf(1), 1398 NaN(), 1399 Inf(1), 1400 NaN(), 1401} 1402 1403var ilogbSC = []int{ 1404 MaxInt32, 1405 MinInt32, 1406 MaxInt32, 1407 MaxInt32, 1408} 1409 1410var vfj0SC = []float64{ 1411 Inf(-1), 1412 0, 1413 Inf(1), 1414 NaN(), 1415} 1416var j0SC = []float64{ 1417 0, 1418 1, 1419 0, 1420 NaN(), 1421} 1422var j1SC = []float64{ 1423 0, 1424 0, 1425 0, 1426 NaN(), 1427} 1428var j2SC = []float64{ 1429 0, 1430 0, 1431 0, 1432 NaN(), 1433} 1434var jM3SC = []float64{ 1435 0, 1436 0, 1437 0, 1438 NaN(), 1439} 1440 1441var vfldexpSC = []fi{ 1442 {0, 0}, 1443 {0, -1075}, 1444 {0, 1024}, 1445 {Copysign(0, -1), 0}, 1446 {Copysign(0, -1), -1075}, 1447 {Copysign(0, -1), 1024}, 1448 {Inf(1), 0}, 1449 {Inf(1), -1024}, 1450 {Inf(-1), 0}, 1451 {Inf(-1), -1024}, 1452 {NaN(), -1024}, 1453 {10, int(1) << (uint64(unsafe.Sizeof(0)-1) * 8)}, 1454 {10, -(int(1) << (uint64(unsafe.Sizeof(0)-1) * 8))}, 1455} 1456var ldexpSC = []float64{ 1457 0, 1458 0, 1459 0, 1460 Copysign(0, -1), 1461 Copysign(0, -1), 1462 Copysign(0, -1), 1463 Inf(1), 1464 Inf(1), 1465 Inf(-1), 1466 Inf(-1), 1467 NaN(), 1468 Inf(1), 1469 0, 1470} 1471 1472var vflgammaSC = []float64{ 1473 Inf(-1), 1474 -3, 1475 0, 1476 1, 1477 2, 1478 Inf(1), 1479 NaN(), 1480} 1481var lgammaSC = []fi{ 1482 {Inf(-1), 1}, 1483 {Inf(1), 1}, 1484 {Inf(1), 1}, 1485 {0, 1}, 1486 {0, 1}, 1487 {Inf(1), 1}, 1488 {NaN(), 1}, 1489} 1490 1491var vflogSC = []float64{ 1492 Inf(-1), 1493 -Pi, 1494 Copysign(0, -1), 1495 0, 1496 1, 1497 Inf(1), 1498 NaN(), 1499} 1500var logSC = []float64{ 1501 NaN(), 1502 NaN(), 1503 Inf(-1), 1504 Inf(-1), 1505 0, 1506 Inf(1), 1507 NaN(), 1508} 1509 1510var vflogbSC = []float64{ 1511 Inf(-1), 1512 0, 1513 Inf(1), 1514 NaN(), 1515} 1516var logbSC = []float64{ 1517 Inf(1), 1518 Inf(-1), 1519 Inf(1), 1520 NaN(), 1521} 1522 1523var vflog1pSC = []float64{ 1524 Inf(-1), 1525 -Pi, 1526 -1, 1527 Copysign(0, -1), 1528 0, 1529 Inf(1), 1530 NaN(), 1531 4503599627370496.5, // Issue #29488 1532} 1533var log1pSC = []float64{ 1534 NaN(), 1535 NaN(), 1536 Inf(-1), 1537 Copysign(0, -1), 1538 0, 1539 Inf(1), 1540 NaN(), 1541 36.04365338911715, // Issue #29488 1542} 1543 1544var vfmodfSC = []float64{ 1545 Inf(-1), 1546 Copysign(0, -1), 1547 Inf(1), 1548 NaN(), 1549} 1550var modfSC = [][2]float64{ 1551 {Inf(-1), NaN()}, // [2]float64{Copysign(0, -1), Inf(-1)}, 1552 {Copysign(0, -1), Copysign(0, -1)}, 1553 {Inf(1), NaN()}, // [2]float64{0, Inf(1)}, 1554 {NaN(), NaN()}, 1555} 1556 1557var vfnextafter32SC = [][2]float32{ 1558 {0, 0}, 1559 {0, float32(Copysign(0, -1))}, 1560 {0, -1}, 1561 {0, float32(NaN())}, 1562 {float32(Copysign(0, -1)), 1}, 1563 {float32(Copysign(0, -1)), 0}, 1564 {float32(Copysign(0, -1)), float32(Copysign(0, -1))}, 1565 {float32(Copysign(0, -1)), -1}, 1566 {float32(NaN()), 0}, 1567 {float32(NaN()), float32(NaN())}, 1568} 1569var nextafter32SC = []float32{ 1570 0, 1571 0, 1572 -1.401298464e-45, // Float32frombits(0x80000001) 1573 float32(NaN()), 1574 1.401298464e-45, // Float32frombits(0x00000001) 1575 float32(Copysign(0, -1)), 1576 float32(Copysign(0, -1)), 1577 -1.401298464e-45, // Float32frombits(0x80000001) 1578 float32(NaN()), 1579 float32(NaN()), 1580} 1581 1582var vfnextafter64SC = [][2]float64{ 1583 {0, 0}, 1584 {0, Copysign(0, -1)}, 1585 {0, -1}, 1586 {0, NaN()}, 1587 {Copysign(0, -1), 1}, 1588 {Copysign(0, -1), 0}, 1589 {Copysign(0, -1), Copysign(0, -1)}, 1590 {Copysign(0, -1), -1}, 1591 {NaN(), 0}, 1592 {NaN(), NaN()}, 1593} 1594var nextafter64SC = []float64{ 1595 0, 1596 0, 1597 -4.9406564584124654418e-324, // Float64frombits(0x8000000000000001) 1598 NaN(), 1599 4.9406564584124654418e-324, // Float64frombits(0x0000000000000001) 1600 Copysign(0, -1), 1601 Copysign(0, -1), 1602 -4.9406564584124654418e-324, // Float64frombits(0x8000000000000001) 1603 NaN(), 1604 NaN(), 1605} 1606 1607var vfpowSC = [][2]float64{ 1608 {Inf(-1), -Pi}, 1609 {Inf(-1), -3}, 1610 {Inf(-1), Copysign(0, -1)}, 1611 {Inf(-1), 0}, 1612 {Inf(-1), 1}, 1613 {Inf(-1), 3}, 1614 {Inf(-1), Pi}, 1615 {Inf(-1), 0.5}, 1616 {Inf(-1), NaN()}, 1617 1618 {-Pi, Inf(-1)}, 1619 {-Pi, -Pi}, 1620 {-Pi, Copysign(0, -1)}, 1621 {-Pi, 0}, 1622 {-Pi, 1}, 1623 {-Pi, Pi}, 1624 {-Pi, Inf(1)}, 1625 {-Pi, NaN()}, 1626 1627 {-1, Inf(-1)}, 1628 {-1, Inf(1)}, 1629 {-1, NaN()}, 1630 {-1 / 2, Inf(-1)}, 1631 {-1 / 2, Inf(1)}, 1632 {Copysign(0, -1), Inf(-1)}, 1633 {Copysign(0, -1), -Pi}, 1634 {Copysign(0, -1), -0.5}, 1635 {Copysign(0, -1), -3}, 1636 {Copysign(0, -1), 3}, 1637 {Copysign(0, -1), Pi}, 1638 {Copysign(0, -1), 0.5}, 1639 {Copysign(0, -1), Inf(1)}, 1640 1641 {0, Inf(-1)}, 1642 {0, -Pi}, 1643 {0, -3}, 1644 {0, Copysign(0, -1)}, 1645 {0, 0}, 1646 {0, 3}, 1647 {0, Pi}, 1648 {0, Inf(1)}, 1649 {0, NaN()}, 1650 1651 {1 / 2, Inf(-1)}, 1652 {1 / 2, Inf(1)}, 1653 {1, Inf(-1)}, 1654 {1, Inf(1)}, 1655 {1, NaN()}, 1656 1657 {Pi, Inf(-1)}, 1658 {Pi, Copysign(0, -1)}, 1659 {Pi, 0}, 1660 {Pi, 1}, 1661 {Pi, Inf(1)}, 1662 {Pi, NaN()}, 1663 {Inf(1), -Pi}, 1664 {Inf(1), Copysign(0, -1)}, 1665 {Inf(1), 0}, 1666 {Inf(1), 1}, 1667 {Inf(1), Pi}, 1668 {Inf(1), NaN()}, 1669 {NaN(), -Pi}, 1670 {NaN(), Copysign(0, -1)}, 1671 {NaN(), 0}, 1672 {NaN(), 1}, 1673 {NaN(), Pi}, 1674 {NaN(), NaN()}, 1675 1676 // Issue #7394 overflow checks 1677 {2, float64(1 << 32)}, 1678 {2, -float64(1 << 32)}, 1679 {-2, float64(1<<32 + 1)}, 1680 {1 / 2, float64(1 << 45)}, 1681 {1 / 2, -float64(1 << 45)}, 1682 {Nextafter(1, 2), float64(1 << 63)}, 1683 {Nextafter(1, -2), float64(1 << 63)}, 1684 {Nextafter(-1, 2), float64(1 << 63)}, 1685 {Nextafter(-1, -2), float64(1 << 63)}, 1686} 1687var powSC = []float64{ 1688 0, // pow(-Inf, -Pi) 1689 Copysign(0, -1), // pow(-Inf, -3) 1690 1, // pow(-Inf, -0) 1691 1, // pow(-Inf, +0) 1692 Inf(-1), // pow(-Inf, 1) 1693 Inf(-1), // pow(-Inf, 3) 1694 Inf(1), // pow(-Inf, Pi) 1695 Inf(1), // pow(-Inf, 0.5) 1696 NaN(), // pow(-Inf, NaN) 1697 0, // pow(-Pi, -Inf) 1698 NaN(), // pow(-Pi, -Pi) 1699 1, // pow(-Pi, -0) 1700 1, // pow(-Pi, +0) 1701 -Pi, // pow(-Pi, 1) 1702 NaN(), // pow(-Pi, Pi) 1703 Inf(1), // pow(-Pi, +Inf) 1704 NaN(), // pow(-Pi, NaN) 1705 1, // pow(-1, -Inf) IEEE 754-2008 1706 1, // pow(-1, +Inf) IEEE 754-2008 1707 NaN(), // pow(-1, NaN) 1708 Inf(1), // pow(-1/2, -Inf) 1709 0, // pow(-1/2, +Inf) 1710 Inf(1), // pow(-0, -Inf) 1711 Inf(1), // pow(-0, -Pi) 1712 Inf(1), // pow(-0, -0.5) 1713 Inf(-1), // pow(-0, -3) IEEE 754-2008 1714 Copysign(0, -1), // pow(-0, 3) IEEE 754-2008 1715 0, // pow(-0, +Pi) 1716 0, // pow(-0, 0.5) 1717 0, // pow(-0, +Inf) 1718 Inf(1), // pow(+0, -Inf) 1719 Inf(1), // pow(+0, -Pi) 1720 Inf(1), // pow(+0, -3) 1721 1, // pow(+0, -0) 1722 1, // pow(+0, +0) 1723 0, // pow(+0, 3) 1724 0, // pow(+0, +Pi) 1725 0, // pow(+0, +Inf) 1726 NaN(), // pow(+0, NaN) 1727 Inf(1), // pow(1/2, -Inf) 1728 0, // pow(1/2, +Inf) 1729 1, // pow(1, -Inf) IEEE 754-2008 1730 1, // pow(1, +Inf) IEEE 754-2008 1731 1, // pow(1, NaN) IEEE 754-2008 1732 0, // pow(+Pi, -Inf) 1733 1, // pow(+Pi, -0) 1734 1, // pow(+Pi, +0) 1735 Pi, // pow(+Pi, 1) 1736 Inf(1), // pow(+Pi, +Inf) 1737 NaN(), // pow(+Pi, NaN) 1738 0, // pow(+Inf, -Pi) 1739 1, // pow(+Inf, -0) 1740 1, // pow(+Inf, +0) 1741 Inf(1), // pow(+Inf, 1) 1742 Inf(1), // pow(+Inf, Pi) 1743 NaN(), // pow(+Inf, NaN) 1744 NaN(), // pow(NaN, -Pi) 1745 1, // pow(NaN, -0) 1746 1, // pow(NaN, +0) 1747 NaN(), // pow(NaN, 1) 1748 NaN(), // pow(NaN, +Pi) 1749 NaN(), // pow(NaN, NaN) 1750 1751 // Issue #7394 overflow checks 1752 Inf(1), // pow(2, float64(1 << 32)) 1753 0, // pow(2, -float64(1 << 32)) 1754 Inf(-1), // pow(-2, float64(1<<32 + 1)) 1755 0, // pow(1/2, float64(1 << 45)) 1756 Inf(1), // pow(1/2, -float64(1 << 45)) 1757 Inf(1), // pow(Nextafter(1, 2), float64(1 << 63)) 1758 0, // pow(Nextafter(1, -2), float64(1 << 63)) 1759 0, // pow(Nextafter(-1, 2), float64(1 << 63)) 1760 Inf(1), // pow(Nextafter(-1, -2), float64(1 << 63)) 1761} 1762 1763var vfpow10SC = []int{ 1764 MinInt32, 1765 -324, 1766 -323, 1767 -50, 1768 -22, 1769 -1, 1770 0, 1771 1, 1772 22, 1773 50, 1774 100, 1775 200, 1776 308, 1777 309, 1778 MaxInt32, 1779} 1780 1781var pow10SC = []float64{ 1782 0, // pow10(MinInt32) 1783 0, // pow10(-324) 1784 1.0e-323, // pow10(-323) 1785 1.0e-50, // pow10(-50) 1786 1.0e-22, // pow10(-22) 1787 1.0e-1, // pow10(-1) 1788 1.0e0, // pow10(0) 1789 1.0e1, // pow10(1) 1790 1.0e22, // pow10(22) 1791 1.0e50, // pow10(50) 1792 1.0e100, // pow10(100) 1793 1.0e200, // pow10(200) 1794 1.0e308, // pow10(308) 1795 Inf(1), // pow10(309) 1796 Inf(1), // pow10(MaxInt32) 1797} 1798 1799var vfroundSC = [][2]float64{ 1800 {0, 0}, 1801 {1.390671161567e-309, 0}, // denormal 1802 {0.49999999999999994, 0}, // 0.5-epsilon 1803 {0.5, 1}, 1804 {0.5000000000000001, 1}, // 0.5+epsilon 1805 {-1.5, -2}, 1806 {-2.5, -3}, 1807 {NaN(), NaN()}, 1808 {Inf(1), Inf(1)}, 1809 {2251799813685249.5, 2251799813685250}, // 1 bit fraction 1810 {2251799813685250.5, 2251799813685251}, 1811 {4503599627370495.5, 4503599627370496}, // 1 bit fraction, rounding to 0 bit fraction 1812 {4503599627370497, 4503599627370497}, // large integer 1813} 1814var vfroundEvenSC = [][2]float64{ 1815 {0, 0}, 1816 {1.390671161567e-309, 0}, // denormal 1817 {0.49999999999999994, 0}, // 0.5-epsilon 1818 {0.5, 0}, 1819 {0.5000000000000001, 1}, // 0.5+epsilon 1820 {-1.5, -2}, 1821 {-2.5, -2}, 1822 {NaN(), NaN()}, 1823 {Inf(1), Inf(1)}, 1824 {2251799813685249.5, 2251799813685250}, // 1 bit fraction 1825 {2251799813685250.5, 2251799813685250}, 1826 {4503599627370495.5, 4503599627370496}, // 1 bit fraction, rounding to 0 bit fraction 1827 {4503599627370497, 4503599627370497}, // large integer 1828} 1829 1830var vfsignbitSC = []float64{ 1831 Inf(-1), 1832 Copysign(0, -1), 1833 0, 1834 Inf(1), 1835 NaN(), 1836} 1837var signbitSC = []bool{ 1838 true, 1839 true, 1840 false, 1841 false, 1842 false, 1843} 1844 1845var vfsinSC = []float64{ 1846 Inf(-1), 1847 Copysign(0, -1), 1848 0, 1849 Inf(1), 1850 NaN(), 1851} 1852var sinSC = []float64{ 1853 NaN(), 1854 Copysign(0, -1), 1855 0, 1856 NaN(), 1857 NaN(), 1858} 1859 1860var vfsinhSC = []float64{ 1861 Inf(-1), 1862 Copysign(0, -1), 1863 0, 1864 Inf(1), 1865 NaN(), 1866} 1867var sinhSC = []float64{ 1868 Inf(-1), 1869 Copysign(0, -1), 1870 0, 1871 Inf(1), 1872 NaN(), 1873} 1874 1875var vfsqrtSC = []float64{ 1876 Inf(-1), 1877 -Pi, 1878 Copysign(0, -1), 1879 0, 1880 Inf(1), 1881 NaN(), 1882 Float64frombits(2), // subnormal; see https://golang.org/issue/13013 1883} 1884var sqrtSC = []float64{ 1885 NaN(), 1886 NaN(), 1887 Copysign(0, -1), 1888 0, 1889 Inf(1), 1890 NaN(), 1891 3.1434555694052576e-162, 1892} 1893 1894var vftanhSC = []float64{ 1895 Inf(-1), 1896 Copysign(0, -1), 1897 0, 1898 Inf(1), 1899 NaN(), 1900} 1901var tanhSC = []float64{ 1902 -1, 1903 Copysign(0, -1), 1904 0, 1905 1, 1906 NaN(), 1907} 1908 1909var vfy0SC = []float64{ 1910 Inf(-1), 1911 0, 1912 Inf(1), 1913 NaN(), 1914 -1, 1915} 1916var y0SC = []float64{ 1917 NaN(), 1918 Inf(-1), 1919 0, 1920 NaN(), 1921 NaN(), 1922} 1923var y1SC = []float64{ 1924 NaN(), 1925 Inf(-1), 1926 0, 1927 NaN(), 1928 NaN(), 1929} 1930var y2SC = []float64{ 1931 NaN(), 1932 Inf(-1), 1933 0, 1934 NaN(), 1935 NaN(), 1936} 1937var yM3SC = []float64{ 1938 NaN(), 1939 Inf(1), 1940 0, 1941 NaN(), 1942 NaN(), 1943} 1944 1945// arguments and expected results for boundary cases 1946const ( 1947 SmallestNormalFloat64 = 2.2250738585072014e-308 // 2**-1022 1948 LargestSubnormalFloat64 = SmallestNormalFloat64 - SmallestNonzeroFloat64 1949) 1950 1951var vffrexpBC = []float64{ 1952 SmallestNormalFloat64, 1953 LargestSubnormalFloat64, 1954 SmallestNonzeroFloat64, 1955 MaxFloat64, 1956 -SmallestNormalFloat64, 1957 -LargestSubnormalFloat64, 1958 -SmallestNonzeroFloat64, 1959 -MaxFloat64, 1960} 1961var frexpBC = []fi{ 1962 {0.5, -1021}, 1963 {0.99999999999999978, -1022}, 1964 {0.5, -1073}, 1965 {0.99999999999999989, 1024}, 1966 {-0.5, -1021}, 1967 {-0.99999999999999978, -1022}, 1968 {-0.5, -1073}, 1969 {-0.99999999999999989, 1024}, 1970} 1971 1972var vfldexpBC = []fi{ 1973 {SmallestNormalFloat64, -52}, 1974 {LargestSubnormalFloat64, -51}, 1975 {SmallestNonzeroFloat64, 1074}, 1976 {MaxFloat64, -(1023 + 1074)}, 1977 {1, -1075}, 1978 {-1, -1075}, 1979 {1, 1024}, 1980 {-1, 1024}, 1981 {1.0000000000000002, -1075}, 1982 {1, -1075}, 1983} 1984var ldexpBC = []float64{ 1985 SmallestNonzeroFloat64, 1986 1e-323, // 2**-1073 1987 1, 1988 1e-323, // 2**-1073 1989 0, 1990 Copysign(0, -1), 1991 Inf(1), 1992 Inf(-1), 1993 SmallestNonzeroFloat64, 1994 0, 1995} 1996 1997var logbBC = []float64{ 1998 -1022, 1999 -1023, 2000 -1074, 2001 1023, 2002 -1022, 2003 -1023, 2004 -1074, 2005 1023, 2006} 2007 2008// Test cases were generated with Berkeley TestFloat-3e/testfloat_gen. 2009// http://www.jhauser.us/arithmetic/TestFloat.html. 2010// The default rounding mode is selected (nearest/even), and exception flags are ignored. 2011var fmaC = []struct{ x, y, z, want float64 }{ 2012 // Large exponent spread 2013 {-3.999999999999087, -1.1123914289620494e-16, -7.999877929687506, -7.999877929687505}, 2014 {-262112.0000004768, -0.06251525855623184, 1.1102230248837136e-16, 16385.99945072085}, 2015 {-6.462348523533467e-27, -2.3763644720331857e-211, 4.000000000931324, 4.000000000931324}, 2016 2017 // Effective addition 2018 {-2.0000000037252907, 6.7904383376e-313, -3.3951933161e-313, -1.697607001654e-312}, 2019 {-0.12499999999999999, 512.007568359375, -1.4193627164960366e-16, -64.00094604492188}, 2020 {-2.7550648847397148e-39, -3.4028301595800694e+38, 0.9960937495343386, 1.9335955376735676}, 2021 {5.723369164769208e+24, 3.8149300927159385e-06, 1.84489958778182e+19, 4.028324913621874e+19}, 2022 {-0.4843749999990904, -3.6893487872543293e+19, 9.223653786709391e+18, 2.7093936974938993e+19}, 2023 {-3.8146972665201165e-06, 4.2949672959999385e+09, -2.2204460489938386e-16, -16384.000003844263}, 2024 {6.98156394130982e-309, -1.1072962560000002e+09, -4.4414561548793455e-308, -7.73065965765153e-300}, 2025 2026 // Effective subtraction 2027 {5e-324, 4.5, -2e-323, 0}, 2028 {5e-324, 7, -3.5e-323, 0}, 2029 {5e-324, 0.5000000000000001, -5e-324, Copysign(0, -1)}, 2030 {-2.1240680525e-314, -1.233647078189316e+308, -0.25781249999954525, -0.25780987964919844}, 2031 {8.579992955364441e-308, 0.6037391876780558, -4.4501307410480706e-308, 7.29947236107098e-309}, 2032 {-4.450143471986689e-308, -0.9960937499927239, -4.450419332475649e-308, -1.7659233458788e-310}, 2033 {1.4932076393918112, -2.2248022430460833e-308, 4.449875571054211e-308, 1.127783865601762e-308}, 2034 2035 // Overflow 2036 {-2.288020632214759e+38, -8.98846570988901e+307, 1.7696041796300924e+308, Inf(0)}, 2037 {1.4888652783208255e+308, -9.007199254742012e+15, -6.807282911929205e+38, Inf(-1)}, 2038 {9.142703268902826e+192, -1.3504889569802838e+296, -1.9082200803806996e-89, Inf(-1)}, 2039 2040 // Finite x and y, but non-finite z. 2041 {31.99218749627471, -1.7976930544991702e+308, Inf(0), Inf(0)}, 2042 {-1.7976931281784667e+308, -2.0009765625002265, Inf(-1), Inf(-1)}, 2043 2044 // Special 2045 {0, 0, 0, 0}, 2046 {-1.1754226043408471e-38, NaN(), Inf(0), NaN()}, 2047 {0, 0, 2.22507385643494e-308, 2.22507385643494e-308}, 2048 {-8.65697792e+09, NaN(), -7.516192799999999e+09, NaN()}, 2049 {-0.00012207403779029757, 3.221225471996093e+09, NaN(), NaN()}, 2050 {Inf(-1), 0.1252441407414153, -1.387184532981584e-76, Inf(-1)}, 2051 {Inf(0), 1.525878907671432e-05, -9.214364835452549e+18, Inf(0)}, 2052 2053 // Random 2054 {0.1777916152213626, -32.000015266239636, -2.2204459148334633e-16, -5.689334401293007}, 2055 {-2.0816681711722314e-16, -0.4997558592585846, -0.9465627129124969, -0.9465627129124968}, 2056 {-1.9999997615814211, 1.8518819259933516e+19, 16.874999999999996, -3.703763410463646e+19}, 2057 {-0.12499994039717421, 32767.99999976135, -2.0752587082923246e+19, -2.075258708292325e+19}, 2058 {7.705600568510257e-34, -1.801432979000528e+16, -0.17224197722973714, -0.17224197722973716}, 2059 {3.8988133103758913e-308, -0.9848632812499999, 3.893879244098556e-308, 5.40811742605814e-310}, 2060 {-0.012651981190687427, 6.911985574912436e+38, 6.669240527007144e+18, -8.745031148409496e+36}, 2061 {4.612811918325842e+18, 1.4901161193847641e-08, 2.6077032311277997e-08, 6.873625395187494e+10}, 2062 {-9.094947033611148e-13, 4.450691014249257e-308, 2.086006742350485e-308, 2.086006742346437e-308}, 2063 {-7.751454006381804e-05, 5.588653777189071e-308, -2.2207280111272877e-308, -2.2211612130544025e-308}, 2064} 2065 2066func tolerance(a, b, e float64) bool { 2067 // Multiplying by e here can underflow denormal values to zero. 2068 // Check a==b so that at least if a and b are small and identical 2069 // we say they match. 2070 if a == b { 2071 return true 2072 } 2073 d := a - b 2074 if d < 0 { 2075 d = -d 2076 } 2077 2078 // note: b is correct (expected) value, a is actual value. 2079 // make error tolerance a fraction of b, not a. 2080 if b != 0 { 2081 e = e * b 2082 if e < 0 { 2083 e = -e 2084 } 2085 } 2086 return d < e 2087} 2088func close(a, b float64) bool { return tolerance(a, b, 1e-14) } 2089func veryclose(a, b float64) bool { return tolerance(a, b, 4e-16) } 2090func soclose(a, b, e float64) bool { return tolerance(a, b, e) } 2091func alike(a, b float64) bool { 2092 switch { 2093 case IsNaN(a) && IsNaN(b): 2094 return true 2095 case a == b: 2096 return Signbit(a) == Signbit(b) 2097 } 2098 return false 2099} 2100 2101func TestNaN(t *testing.T) { 2102 f64 := NaN() 2103 if f64 == f64 { 2104 t.Fatalf("NaN() returns %g, expected NaN", f64) 2105 } 2106 f32 := float32(f64) 2107 if f32 == f32 { 2108 t.Fatalf("float32(NaN()) is %g, expected NaN", f32) 2109 } 2110} 2111 2112func TestAcos(t *testing.T) { 2113 for i := 0; i < len(vf); i++ { 2114 a := vf[i] / 10 2115 if f := Acos(a); !close(acos[i], f) { 2116 t.Errorf("Acos(%g) = %g, want %g", a, f, acos[i]) 2117 } 2118 } 2119 for i := 0; i < len(vfacosSC); i++ { 2120 if f := Acos(vfacosSC[i]); !alike(acosSC[i], f) { 2121 t.Errorf("Acos(%g) = %g, want %g", vfacosSC[i], f, acosSC[i]) 2122 } 2123 } 2124} 2125 2126func TestAcosh(t *testing.T) { 2127 for i := 0; i < len(vf); i++ { 2128 a := 1 + Abs(vf[i]) 2129 if f := Acosh(a); !veryclose(acosh[i], f) { 2130 t.Errorf("Acosh(%g) = %g, want %g", a, f, acosh[i]) 2131 } 2132 } 2133 for i := 0; i < len(vfacoshSC); i++ { 2134 if f := Acosh(vfacoshSC[i]); !alike(acoshSC[i], f) { 2135 t.Errorf("Acosh(%g) = %g, want %g", vfacoshSC[i], f, acoshSC[i]) 2136 } 2137 } 2138} 2139 2140func TestAsin(t *testing.T) { 2141 for i := 0; i < len(vf); i++ { 2142 a := vf[i] / 10 2143 if f := Asin(a); !veryclose(asin[i], f) { 2144 t.Errorf("Asin(%g) = %g, want %g", a, f, asin[i]) 2145 } 2146 } 2147 for i := 0; i < len(vfasinSC); i++ { 2148 if f := Asin(vfasinSC[i]); !alike(asinSC[i], f) { 2149 t.Errorf("Asin(%g) = %g, want %g", vfasinSC[i], f, asinSC[i]) 2150 } 2151 } 2152} 2153 2154func TestAsinh(t *testing.T) { 2155 for i := 0; i < len(vf); i++ { 2156 if f := Asinh(vf[i]); !veryclose(asinh[i], f) { 2157 t.Errorf("Asinh(%g) = %g, want %g", vf[i], f, asinh[i]) 2158 } 2159 } 2160 for i := 0; i < len(vfasinhSC); i++ { 2161 if f := Asinh(vfasinhSC[i]); !alike(asinhSC[i], f) { 2162 t.Errorf("Asinh(%g) = %g, want %g", vfasinhSC[i], f, asinhSC[i]) 2163 } 2164 } 2165} 2166 2167func TestAtan(t *testing.T) { 2168 for i := 0; i < len(vf); i++ { 2169 if f := Atan(vf[i]); !veryclose(atan[i], f) { 2170 t.Errorf("Atan(%g) = %g, want %g", vf[i], f, atan[i]) 2171 } 2172 } 2173 for i := 0; i < len(vfatanSC); i++ { 2174 if f := Atan(vfatanSC[i]); !alike(atanSC[i], f) { 2175 t.Errorf("Atan(%g) = %g, want %g", vfatanSC[i], f, atanSC[i]) 2176 } 2177 } 2178} 2179 2180func TestAtanh(t *testing.T) { 2181 for i := 0; i < len(vf); i++ { 2182 a := vf[i] / 10 2183 if f := Atanh(a); !veryclose(atanh[i], f) { 2184 t.Errorf("Atanh(%g) = %g, want %g", a, f, atanh[i]) 2185 } 2186 } 2187 for i := 0; i < len(vfatanhSC); i++ { 2188 if f := Atanh(vfatanhSC[i]); !alike(atanhSC[i], f) { 2189 t.Errorf("Atanh(%g) = %g, want %g", vfatanhSC[i], f, atanhSC[i]) 2190 } 2191 } 2192} 2193 2194func TestAtan2(t *testing.T) { 2195 for i := 0; i < len(vf); i++ { 2196 if f := Atan2(10, vf[i]); !veryclose(atan2[i], f) { 2197 t.Errorf("Atan2(10, %g) = %g, want %g", vf[i], f, atan2[i]) 2198 } 2199 } 2200 for i := 0; i < len(vfatan2SC); i++ { 2201 if f := Atan2(vfatan2SC[i][0], vfatan2SC[i][1]); !alike(atan2SC[i], f) { 2202 t.Errorf("Atan2(%g, %g) = %g, want %g", vfatan2SC[i][0], vfatan2SC[i][1], f, atan2SC[i]) 2203 } 2204 } 2205} 2206 2207func TestCbrt(t *testing.T) { 2208 for i := 0; i < len(vf); i++ { 2209 if f := Cbrt(vf[i]); !veryclose(cbrt[i], f) { 2210 t.Errorf("Cbrt(%g) = %g, want %g", vf[i], f, cbrt[i]) 2211 } 2212 } 2213 for i := 0; i < len(vfcbrtSC); i++ { 2214 if f := Cbrt(vfcbrtSC[i]); !alike(cbrtSC[i], f) { 2215 t.Errorf("Cbrt(%g) = %g, want %g", vfcbrtSC[i], f, cbrtSC[i]) 2216 } 2217 } 2218} 2219 2220func TestCeil(t *testing.T) { 2221 for i := 0; i < len(vf); i++ { 2222 if f := Ceil(vf[i]); !alike(ceil[i], f) { 2223 t.Errorf("Ceil(%g) = %g, want %g", vf[i], f, ceil[i]) 2224 } 2225 } 2226 for i := 0; i < len(vfceilSC); i++ { 2227 if f := Ceil(vfceilSC[i]); !alike(ceilSC[i], f) { 2228 t.Errorf("Ceil(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i]) 2229 } 2230 } 2231} 2232 2233func TestCopysign(t *testing.T) { 2234 for i := 0; i < len(vf); i++ { 2235 if f := Copysign(vf[i], -1); copysign[i] != f { 2236 t.Errorf("Copysign(%g, -1) = %g, want %g", vf[i], f, copysign[i]) 2237 } 2238 } 2239 for i := 0; i < len(vf); i++ { 2240 if f := Copysign(vf[i], 1); -copysign[i] != f { 2241 t.Errorf("Copysign(%g, 1) = %g, want %g", vf[i], f, -copysign[i]) 2242 } 2243 } 2244 for i := 0; i < len(vfcopysignSC); i++ { 2245 if f := Copysign(vfcopysignSC[i], -1); !alike(copysignSC[i], f) { 2246 t.Errorf("Copysign(%g, -1) = %g, want %g", vfcopysignSC[i], f, copysignSC[i]) 2247 } 2248 } 2249} 2250 2251func TestCos(t *testing.T) { 2252 for i := 0; i < len(vf); i++ { 2253 if f := Cos(vf[i]); !veryclose(cos[i], f) { 2254 t.Errorf("Cos(%g) = %g, want %g", vf[i], f, cos[i]) 2255 } 2256 } 2257 for i := 0; i < len(vfcosSC); i++ { 2258 if f := Cos(vfcosSC[i]); !alike(cosSC[i], f) { 2259 t.Errorf("Cos(%g) = %g, want %g", vfcosSC[i], f, cosSC[i]) 2260 } 2261 } 2262} 2263 2264func TestCosh(t *testing.T) { 2265 for i := 0; i < len(vf); i++ { 2266 if f := Cosh(vf[i]); !close(cosh[i], f) { 2267 t.Errorf("Cosh(%g) = %g, want %g", vf[i], f, cosh[i]) 2268 } 2269 } 2270 for i := 0; i < len(vfcoshSC); i++ { 2271 if f := Cosh(vfcoshSC[i]); !alike(coshSC[i], f) { 2272 t.Errorf("Cosh(%g) = %g, want %g", vfcoshSC[i], f, coshSC[i]) 2273 } 2274 } 2275} 2276 2277func TestErf(t *testing.T) { 2278 for i := 0; i < len(vf); i++ { 2279 a := vf[i] / 10 2280 if f := Erf(a); !veryclose(erf[i], f) { 2281 t.Errorf("Erf(%g) = %g, want %g", a, f, erf[i]) 2282 } 2283 } 2284 for i := 0; i < len(vferfSC); i++ { 2285 if f := Erf(vferfSC[i]); !alike(erfSC[i], f) { 2286 t.Errorf("Erf(%g) = %g, want %g", vferfSC[i], f, erfSC[i]) 2287 } 2288 } 2289} 2290 2291func TestErfc(t *testing.T) { 2292 for i := 0; i < len(vf); i++ { 2293 a := vf[i] / 10 2294 if f := Erfc(a); !veryclose(erfc[i], f) { 2295 t.Errorf("Erfc(%g) = %g, want %g", a, f, erfc[i]) 2296 } 2297 } 2298 for i := 0; i < len(vferfcSC); i++ { 2299 if f := Erfc(vferfcSC[i]); !alike(erfcSC[i], f) { 2300 t.Errorf("Erfc(%g) = %g, want %g", vferfcSC[i], f, erfcSC[i]) 2301 } 2302 } 2303} 2304 2305func TestErfinv(t *testing.T) { 2306 for i := 0; i < len(vf); i++ { 2307 a := vf[i] / 10 2308 if f := Erfinv(a); !veryclose(erfinv[i], f) { 2309 t.Errorf("Erfinv(%g) = %g, want %g", a, f, erfinv[i]) 2310 } 2311 } 2312 for i := 0; i < len(vferfinvSC); i++ { 2313 if f := Erfinv(vferfinvSC[i]); !alike(erfinvSC[i], f) { 2314 t.Errorf("Erfinv(%g) = %g, want %g", vferfinvSC[i], f, erfinvSC[i]) 2315 } 2316 } 2317 for x := -0.9; x <= 0.90; x += 1e-2 { 2318 if f := Erf(Erfinv(x)); !close(x, f) { 2319 t.Errorf("Erf(Erfinv(%g)) = %g, want %g", x, f, x) 2320 } 2321 } 2322 for x := -0.9; x <= 0.90; x += 1e-2 { 2323 if f := Erfinv(Erf(x)); !close(x, f) { 2324 t.Errorf("Erfinv(Erf(%g)) = %g, want %g", x, f, x) 2325 } 2326 } 2327} 2328 2329func TestErfcinv(t *testing.T) { 2330 for i := 0; i < len(vf); i++ { 2331 a := 1.0 - (vf[i] / 10) 2332 if f := Erfcinv(a); !veryclose(erfinv[i], f) { 2333 t.Errorf("Erfcinv(%g) = %g, want %g", a, f, erfinv[i]) 2334 } 2335 } 2336 for i := 0; i < len(vferfcinvSC); i++ { 2337 if f := Erfcinv(vferfcinvSC[i]); !alike(erfcinvSC[i], f) { 2338 t.Errorf("Erfcinv(%g) = %g, want %g", vferfcinvSC[i], f, erfcinvSC[i]) 2339 } 2340 } 2341 for x := 0.1; x <= 1.9; x += 1e-2 { 2342 if f := Erfc(Erfcinv(x)); !close(x, f) { 2343 t.Errorf("Erfc(Erfcinv(%g)) = %g, want %g", x, f, x) 2344 } 2345 } 2346 for x := 0.1; x <= 1.9; x += 1e-2 { 2347 if f := Erfcinv(Erfc(x)); !close(x, f) { 2348 t.Errorf("Erfcinv(Erfc(%g)) = %g, want %g", x, f, x) 2349 } 2350 } 2351} 2352 2353func TestExp(t *testing.T) { 2354 testExp(t, Exp, "Exp") 2355 testExp(t, ExpGo, "ExpGo") 2356} 2357 2358func testExp(t *testing.T, Exp func(float64) float64, name string) { 2359 for i := 0; i < len(vf); i++ { 2360 if f := Exp(vf[i]); !veryclose(exp[i], f) { 2361 t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp[i]) 2362 } 2363 } 2364 for i := 0; i < len(vfexpSC); i++ { 2365 if f := Exp(vfexpSC[i]); !alike(expSC[i], f) { 2366 t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i]) 2367 } 2368 } 2369} 2370 2371func TestExpm1(t *testing.T) { 2372 for i := 0; i < len(vf); i++ { 2373 a := vf[i] / 100 2374 if f := Expm1(a); !veryclose(expm1[i], f) { 2375 t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1[i]) 2376 } 2377 } 2378 for i := 0; i < len(vf); i++ { 2379 a := vf[i] * 10 2380 if f := Expm1(a); !close(expm1Large[i], f) { 2381 t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1Large[i]) 2382 } 2383 } 2384 for i := 0; i < len(vfexpm1SC); i++ { 2385 if f := Expm1(vfexpm1SC[i]); !alike(expm1SC[i], f) { 2386 t.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC[i], f, expm1SC[i]) 2387 } 2388 } 2389} 2390 2391func TestExp2(t *testing.T) { 2392 testExp2(t, Exp2, "Exp2") 2393 testExp2(t, Exp2Go, "Exp2Go") 2394} 2395 2396func testExp2(t *testing.T, Exp2 func(float64) float64, name string) { 2397 for i := 0; i < len(vf); i++ { 2398 if f := Exp2(vf[i]); !close(exp2[i], f) { 2399 t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp2[i]) 2400 } 2401 } 2402 for i := 0; i < len(vfexp2SC); i++ { 2403 if f := Exp2(vfexp2SC[i]); !alike(exp2SC[i], f) { 2404 t.Errorf("%s(%g) = %g, want %g", name, vfexp2SC[i], f, exp2SC[i]) 2405 } 2406 } 2407 for n := -1074; n < 1024; n++ { 2408 f := Exp2(float64(n)) 2409 vf := Ldexp(1, n) 2410 if f != vf { 2411 t.Errorf("%s(%d) = %g, want %g", name, n, f, vf) 2412 } 2413 } 2414} 2415 2416func TestAbs(t *testing.T) { 2417 for i := 0; i < len(vf); i++ { 2418 if f := Abs(vf[i]); fabs[i] != f { 2419 t.Errorf("Abs(%g) = %g, want %g", vf[i], f, fabs[i]) 2420 } 2421 } 2422 for i := 0; i < len(vffabsSC); i++ { 2423 if f := Abs(vffabsSC[i]); !alike(fabsSC[i], f) { 2424 t.Errorf("Abs(%g) = %g, want %g", vffabsSC[i], f, fabsSC[i]) 2425 } 2426 } 2427} 2428 2429func TestDim(t *testing.T) { 2430 for i := 0; i < len(vf); i++ { 2431 if f := Dim(vf[i], 0); fdim[i] != f { 2432 t.Errorf("Dim(%g, %g) = %g, want %g", vf[i], 0.0, f, fdim[i]) 2433 } 2434 } 2435 for i := 0; i < len(vffdimSC); i++ { 2436 if f := Dim(vffdimSC[i][0], vffdimSC[i][1]); !alike(fdimSC[i], f) { 2437 t.Errorf("Dim(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fdimSC[i]) 2438 } 2439 } 2440 for i := 0; i < len(vffdim2SC); i++ { 2441 if f := Dim(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fdimSC[i], f) { 2442 t.Errorf("Dim(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fdimSC[i]) 2443 } 2444 } 2445} 2446 2447func TestFloor(t *testing.T) { 2448 for i := 0; i < len(vf); i++ { 2449 if f := Floor(vf[i]); !alike(floor[i], f) { 2450 t.Errorf("Floor(%g) = %g, want %g", vf[i], f, floor[i]) 2451 } 2452 } 2453 for i := 0; i < len(vfceilSC); i++ { 2454 if f := Floor(vfceilSC[i]); !alike(ceilSC[i], f) { 2455 t.Errorf("Floor(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i]) 2456 } 2457 } 2458} 2459 2460func TestMax(t *testing.T) { 2461 for i := 0; i < len(vf); i++ { 2462 if f := Max(vf[i], ceil[i]); ceil[i] != f { 2463 t.Errorf("Max(%g, %g) = %g, want %g", vf[i], ceil[i], f, ceil[i]) 2464 } 2465 } 2466 for i := 0; i < len(vffdimSC); i++ { 2467 if f := Max(vffdimSC[i][0], vffdimSC[i][1]); !alike(fmaxSC[i], f) { 2468 t.Errorf("Max(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fmaxSC[i]) 2469 } 2470 } 2471 for i := 0; i < len(vffdim2SC); i++ { 2472 if f := Max(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fmaxSC[i], f) { 2473 t.Errorf("Max(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fmaxSC[i]) 2474 } 2475 } 2476} 2477 2478func TestMin(t *testing.T) { 2479 for i := 0; i < len(vf); i++ { 2480 if f := Min(vf[i], floor[i]); floor[i] != f { 2481 t.Errorf("Min(%g, %g) = %g, want %g", vf[i], floor[i], f, floor[i]) 2482 } 2483 } 2484 for i := 0; i < len(vffdimSC); i++ { 2485 if f := Min(vffdimSC[i][0], vffdimSC[i][1]); !alike(fminSC[i], f) { 2486 t.Errorf("Min(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fminSC[i]) 2487 } 2488 } 2489 for i := 0; i < len(vffdim2SC); i++ { 2490 if f := Min(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fminSC[i], f) { 2491 t.Errorf("Min(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fminSC[i]) 2492 } 2493 } 2494} 2495 2496func TestMod(t *testing.T) { 2497 for i := 0; i < len(vf); i++ { 2498 if f := Mod(10, vf[i]); fmod[i] != f { 2499 t.Errorf("Mod(10, %g) = %g, want %g", vf[i], f, fmod[i]) 2500 } 2501 } 2502 for i := 0; i < len(vffmodSC); i++ { 2503 if f := Mod(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) { 2504 t.Errorf("Mod(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i]) 2505 } 2506 } 2507 // verify precision of result for extreme inputs 2508 if f := Mod(5.9790119248836734e+200, 1.1258465975523544); 0.6447968302508578 != f { 2509 t.Errorf("Remainder(5.9790119248836734e+200, 1.1258465975523544) = %g, want 0.6447968302508578", f) 2510 } 2511} 2512 2513func TestFrexp(t *testing.T) { 2514 for i := 0; i < len(vf); i++ { 2515 if f, j := Frexp(vf[i]); !veryclose(frexp[i].f, f) || frexp[i].i != j { 2516 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vf[i], f, j, frexp[i].f, frexp[i].i) 2517 } 2518 } 2519 for i := 0; i < len(vffrexpSC); i++ { 2520 if f, j := Frexp(vffrexpSC[i]); !alike(frexpSC[i].f, f) || frexpSC[i].i != j { 2521 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpSC[i], f, j, frexpSC[i].f, frexpSC[i].i) 2522 } 2523 } 2524 for i := 0; i < len(vffrexpBC); i++ { 2525 if f, j := Frexp(vffrexpBC[i]); !alike(frexpBC[i].f, f) || frexpBC[i].i != j { 2526 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpBC[i], f, j, frexpBC[i].f, frexpBC[i].i) 2527 } 2528 } 2529} 2530 2531func TestGamma(t *testing.T) { 2532 for i := 0; i < len(vf); i++ { 2533 if f := Gamma(vf[i]); !close(gamma[i], f) { 2534 t.Errorf("Gamma(%g) = %g, want %g", vf[i], f, gamma[i]) 2535 } 2536 } 2537 for _, g := range vfgamma { 2538 f := Gamma(g[0]) 2539 var ok bool 2540 if IsNaN(g[1]) || IsInf(g[1], 0) || g[1] == 0 || f == 0 { 2541 ok = alike(g[1], f) 2542 } else if g[0] > -50 && g[0] <= 171 { 2543 ok = veryclose(g[1], f) 2544 } else { 2545 ok = close(g[1], f) 2546 } 2547 if !ok { 2548 t.Errorf("Gamma(%g) = %g, want %g", g[0], f, g[1]) 2549 } 2550 } 2551} 2552 2553func TestHypot(t *testing.T) { 2554 for i := 0; i < len(vf); i++ { 2555 a := Abs(1e200 * tanh[i] * Sqrt(2)) 2556 if f := Hypot(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) { 2557 t.Errorf("Hypot(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a) 2558 } 2559 } 2560 for i := 0; i < len(vfhypotSC); i++ { 2561 if f := Hypot(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) { 2562 t.Errorf("Hypot(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i]) 2563 } 2564 } 2565} 2566 2567func TestHypotGo(t *testing.T) { 2568 for i := 0; i < len(vf); i++ { 2569 a := Abs(1e200 * tanh[i] * Sqrt(2)) 2570 if f := HypotGo(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) { 2571 t.Errorf("HypotGo(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a) 2572 } 2573 } 2574 for i := 0; i < len(vfhypotSC); i++ { 2575 if f := HypotGo(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) { 2576 t.Errorf("HypotGo(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i]) 2577 } 2578 } 2579} 2580 2581func TestIlogb(t *testing.T) { 2582 for i := 0; i < len(vf); i++ { 2583 a := frexp[i].i - 1 // adjust because fr in the interval [½, 1) 2584 if e := Ilogb(vf[i]); a != e { 2585 t.Errorf("Ilogb(%g) = %d, want %d", vf[i], e, a) 2586 } 2587 } 2588 for i := 0; i < len(vflogbSC); i++ { 2589 if e := Ilogb(vflogbSC[i]); ilogbSC[i] != e { 2590 t.Errorf("Ilogb(%g) = %d, want %d", vflogbSC[i], e, ilogbSC[i]) 2591 } 2592 } 2593 for i := 0; i < len(vffrexpBC); i++ { 2594 if e := Ilogb(vffrexpBC[i]); int(logbBC[i]) != e { 2595 t.Errorf("Ilogb(%g) = %d, want %d", vffrexpBC[i], e, int(logbBC[i])) 2596 } 2597 } 2598} 2599 2600func TestJ0(t *testing.T) { 2601 for i := 0; i < len(vf); i++ { 2602 if f := J0(vf[i]); !soclose(j0[i], f, 4e-14) { 2603 t.Errorf("J0(%g) = %g, want %g", vf[i], f, j0[i]) 2604 } 2605 } 2606 for i := 0; i < len(vfj0SC); i++ { 2607 if f := J0(vfj0SC[i]); !alike(j0SC[i], f) { 2608 t.Errorf("J0(%g) = %g, want %g", vfj0SC[i], f, j0SC[i]) 2609 } 2610 } 2611} 2612 2613func TestJ1(t *testing.T) { 2614 for i := 0; i < len(vf); i++ { 2615 if f := J1(vf[i]); !close(j1[i], f) { 2616 t.Errorf("J1(%g) = %g, want %g", vf[i], f, j1[i]) 2617 } 2618 } 2619 for i := 0; i < len(vfj0SC); i++ { 2620 if f := J1(vfj0SC[i]); !alike(j1SC[i], f) { 2621 t.Errorf("J1(%g) = %g, want %g", vfj0SC[i], f, j1SC[i]) 2622 } 2623 } 2624} 2625 2626func TestJn(t *testing.T) { 2627 for i := 0; i < len(vf); i++ { 2628 if f := Jn(2, vf[i]); !close(j2[i], f) { 2629 t.Errorf("Jn(2, %g) = %g, want %g", vf[i], f, j2[i]) 2630 } 2631 if f := Jn(-3, vf[i]); !close(jM3[i], f) { 2632 t.Errorf("Jn(-3, %g) = %g, want %g", vf[i], f, jM3[i]) 2633 } 2634 } 2635 for i := 0; i < len(vfj0SC); i++ { 2636 if f := Jn(2, vfj0SC[i]); !alike(j2SC[i], f) { 2637 t.Errorf("Jn(2, %g) = %g, want %g", vfj0SC[i], f, j2SC[i]) 2638 } 2639 if f := Jn(-3, vfj0SC[i]); !alike(jM3SC[i], f) { 2640 t.Errorf("Jn(-3, %g) = %g, want %g", vfj0SC[i], f, jM3SC[i]) 2641 } 2642 } 2643} 2644 2645func TestLdexp(t *testing.T) { 2646 for i := 0; i < len(vf); i++ { 2647 if f := Ldexp(frexp[i].f, frexp[i].i); !veryclose(vf[i], f) { 2648 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexp[i].f, frexp[i].i, f, vf[i]) 2649 } 2650 } 2651 for i := 0; i < len(vffrexpSC); i++ { 2652 if f := Ldexp(frexpSC[i].f, frexpSC[i].i); !alike(vffrexpSC[i], f) { 2653 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpSC[i].f, frexpSC[i].i, f, vffrexpSC[i]) 2654 } 2655 } 2656 for i := 0; i < len(vfldexpSC); i++ { 2657 if f := Ldexp(vfldexpSC[i].f, vfldexpSC[i].i); !alike(ldexpSC[i], f) { 2658 t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpSC[i].f, vfldexpSC[i].i, f, ldexpSC[i]) 2659 } 2660 } 2661 for i := 0; i < len(vffrexpBC); i++ { 2662 if f := Ldexp(frexpBC[i].f, frexpBC[i].i); !alike(vffrexpBC[i], f) { 2663 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpBC[i].f, frexpBC[i].i, f, vffrexpBC[i]) 2664 } 2665 } 2666 for i := 0; i < len(vfldexpBC); i++ { 2667 if f := Ldexp(vfldexpBC[i].f, vfldexpBC[i].i); !alike(ldexpBC[i], f) { 2668 t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpBC[i].f, vfldexpBC[i].i, f, ldexpBC[i]) 2669 } 2670 } 2671} 2672 2673func TestLgamma(t *testing.T) { 2674 for i := 0; i < len(vf); i++ { 2675 if f, s := Lgamma(vf[i]); !close(lgamma[i].f, f) || lgamma[i].i != s { 2676 t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vf[i], f, s, lgamma[i].f, lgamma[i].i) 2677 } 2678 } 2679 for i := 0; i < len(vflgammaSC); i++ { 2680 if f, s := Lgamma(vflgammaSC[i]); !alike(lgammaSC[i].f, f) || lgammaSC[i].i != s { 2681 t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vflgammaSC[i], f, s, lgammaSC[i].f, lgammaSC[i].i) 2682 } 2683 } 2684} 2685 2686func TestLog(t *testing.T) { 2687 for i := 0; i < len(vf); i++ { 2688 a := Abs(vf[i]) 2689 if f := Log(a); log[i] != f { 2690 t.Errorf("Log(%g) = %g, want %g", a, f, log[i]) 2691 } 2692 } 2693 if f := Log(10); f != Ln10 { 2694 t.Errorf("Log(%g) = %g, want %g", 10.0, f, Ln10) 2695 } 2696 for i := 0; i < len(vflogSC); i++ { 2697 if f := Log(vflogSC[i]); !alike(logSC[i], f) { 2698 t.Errorf("Log(%g) = %g, want %g", vflogSC[i], f, logSC[i]) 2699 } 2700 } 2701} 2702 2703func TestLogb(t *testing.T) { 2704 for i := 0; i < len(vf); i++ { 2705 if f := Logb(vf[i]); logb[i] != f { 2706 t.Errorf("Logb(%g) = %g, want %g", vf[i], f, logb[i]) 2707 } 2708 } 2709 for i := 0; i < len(vflogbSC); i++ { 2710 if f := Logb(vflogbSC[i]); !alike(logbSC[i], f) { 2711 t.Errorf("Logb(%g) = %g, want %g", vflogbSC[i], f, logbSC[i]) 2712 } 2713 } 2714 for i := 0; i < len(vffrexpBC); i++ { 2715 if f := Logb(vffrexpBC[i]); !alike(logbBC[i], f) { 2716 t.Errorf("Logb(%g) = %g, want %g", vffrexpBC[i], f, logbBC[i]) 2717 } 2718 } 2719} 2720 2721func TestLog10(t *testing.T) { 2722 for i := 0; i < len(vf); i++ { 2723 a := Abs(vf[i]) 2724 if f := Log10(a); !veryclose(log10[i], f) { 2725 t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i]) 2726 } 2727 } 2728 if f := Log10(E); f != Log10E { 2729 t.Errorf("Log10(%g) = %g, want %g", E, f, Log10E) 2730 } 2731 for i := 0; i < len(vflogSC); i++ { 2732 if f := Log10(vflogSC[i]); !alike(logSC[i], f) { 2733 t.Errorf("Log10(%g) = %g, want %g", vflogSC[i], f, logSC[i]) 2734 } 2735 } 2736} 2737 2738func TestLog1p(t *testing.T) { 2739 for i := 0; i < len(vf); i++ { 2740 a := vf[i] / 100 2741 if f := Log1p(a); !veryclose(log1p[i], f) { 2742 t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i]) 2743 } 2744 } 2745 a := 9.0 2746 if f := Log1p(a); f != Ln10 { 2747 t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10) 2748 } 2749 for i := 0; i < len(vflogSC); i++ { 2750 if f := Log1p(vflog1pSC[i]); !alike(log1pSC[i], f) { 2751 t.Errorf("Log1p(%g) = %g, want %g", vflog1pSC[i], f, log1pSC[i]) 2752 } 2753 } 2754} 2755 2756func TestLog2(t *testing.T) { 2757 for i := 0; i < len(vf); i++ { 2758 a := Abs(vf[i]) 2759 if f := Log2(a); !veryclose(log2[i], f) { 2760 t.Errorf("Log2(%g) = %g, want %g", a, f, log2[i]) 2761 } 2762 } 2763 if f := Log2(E); f != Log2E { 2764 t.Errorf("Log2(%g) = %g, want %g", E, f, Log2E) 2765 } 2766 for i := 0; i < len(vflogSC); i++ { 2767 if f := Log2(vflogSC[i]); !alike(logSC[i], f) { 2768 t.Errorf("Log2(%g) = %g, want %g", vflogSC[i], f, logSC[i]) 2769 } 2770 } 2771 for i := -1074; i <= 1023; i++ { 2772 f := Ldexp(1, i) 2773 l := Log2(f) 2774 if l != float64(i) { 2775 t.Errorf("Log2(2**%d) = %g, want %d", i, l, i) 2776 } 2777 } 2778} 2779 2780func TestModf(t *testing.T) { 2781 for i := 0; i < len(vf); i++ { 2782 if f, g := Modf(vf[i]); !veryclose(modf[i][0], f) || !veryclose(modf[i][1], g) { 2783 t.Errorf("Modf(%g) = %g, %g, want %g, %g", vf[i], f, g, modf[i][0], modf[i][1]) 2784 } 2785 } 2786 for i := 0; i < len(vfmodfSC); i++ { 2787 if f, g := Modf(vfmodfSC[i]); !alike(modfSC[i][0], f) || !alike(modfSC[i][1], g) { 2788 t.Errorf("Modf(%g) = %g, %g, want %g, %g", vfmodfSC[i], f, g, modfSC[i][0], modfSC[i][1]) 2789 } 2790 } 2791} 2792 2793func TestNextafter32(t *testing.T) { 2794 for i := 0; i < len(vf); i++ { 2795 vfi := float32(vf[i]) 2796 if f := Nextafter32(vfi, 10); nextafter32[i] != f { 2797 t.Errorf("Nextafter32(%g, %g) = %g want %g", vfi, 10.0, f, nextafter32[i]) 2798 } 2799 } 2800 for i := 0; i < len(vfnextafter32SC); i++ { 2801 if f := Nextafter32(vfnextafter32SC[i][0], vfnextafter32SC[i][1]); !alike(float64(nextafter32SC[i]), float64(f)) { 2802 t.Errorf("Nextafter32(%g, %g) = %g want %g", vfnextafter32SC[i][0], vfnextafter32SC[i][1], f, nextafter32SC[i]) 2803 } 2804 } 2805} 2806 2807func TestNextafter64(t *testing.T) { 2808 for i := 0; i < len(vf); i++ { 2809 if f := Nextafter(vf[i], 10); nextafter64[i] != f { 2810 t.Errorf("Nextafter64(%g, %g) = %g want %g", vf[i], 10.0, f, nextafter64[i]) 2811 } 2812 } 2813 for i := 0; i < len(vfnextafter64SC); i++ { 2814 if f := Nextafter(vfnextafter64SC[i][0], vfnextafter64SC[i][1]); !alike(nextafter64SC[i], f) { 2815 t.Errorf("Nextafter64(%g, %g) = %g want %g", vfnextafter64SC[i][0], vfnextafter64SC[i][1], f, nextafter64SC[i]) 2816 } 2817 } 2818} 2819 2820func TestPow(t *testing.T) { 2821 for i := 0; i < len(vf); i++ { 2822 if f := Pow(10, vf[i]); !close(pow[i], f) { 2823 t.Errorf("Pow(10, %g) = %g, want %g", vf[i], f, pow[i]) 2824 } 2825 } 2826 for i := 0; i < len(vfpowSC); i++ { 2827 if f := Pow(vfpowSC[i][0], vfpowSC[i][1]); !alike(powSC[i], f) { 2828 t.Errorf("Pow(%g, %g) = %g, want %g", vfpowSC[i][0], vfpowSC[i][1], f, powSC[i]) 2829 } 2830 } 2831} 2832 2833func TestPow10(t *testing.T) { 2834 for i := 0; i < len(vfpow10SC); i++ { 2835 if f := Pow10(vfpow10SC[i]); !alike(pow10SC[i], f) { 2836 t.Errorf("Pow10(%d) = %g, want %g", vfpow10SC[i], f, pow10SC[i]) 2837 } 2838 } 2839} 2840 2841func TestRemainder(t *testing.T) { 2842 for i := 0; i < len(vf); i++ { 2843 if f := Remainder(10, vf[i]); remainder[i] != f { 2844 t.Errorf("Remainder(10, %g) = %g, want %g", vf[i], f, remainder[i]) 2845 } 2846 } 2847 for i := 0; i < len(vffmodSC); i++ { 2848 if f := Remainder(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) { 2849 t.Errorf("Remainder(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i]) 2850 } 2851 } 2852 // verify precision of result for extreme inputs 2853 if f := Remainder(5.9790119248836734e+200, 1.1258465975523544); -0.4810497673014966 != f { 2854 t.Errorf("Remainder(5.9790119248836734e+200, 1.1258465975523544) = %g, want -0.4810497673014966", f) 2855 } 2856 // verify that sign is correct when r == 0. 2857 test := func(x, y float64) { 2858 if r := Remainder(x, y); r == 0 && Signbit(r) != Signbit(x) { 2859 t.Errorf("Remainder(x=%f, y=%f) = %f, sign of (zero) result should agree with sign of x", x, y, r) 2860 } 2861 } 2862 for x := 0.0; x <= 3.0; x += 1 { 2863 for y := 1.0; y <= 3.0; y += 1 { 2864 test(x, y) 2865 test(x, -y) 2866 test(-x, y) 2867 test(-x, -y) 2868 } 2869 } 2870} 2871 2872func TestRound(t *testing.T) { 2873 for i := 0; i < len(vf); i++ { 2874 if f := Round(vf[i]); !alike(round[i], f) { 2875 t.Errorf("Round(%g) = %g, want %g", vf[i], f, round[i]) 2876 } 2877 } 2878 for i := 0; i < len(vfroundSC); i++ { 2879 if f := Round(vfroundSC[i][0]); !alike(vfroundSC[i][1], f) { 2880 t.Errorf("Round(%g) = %g, want %g", vfroundSC[i][0], f, vfroundSC[i][1]) 2881 } 2882 } 2883} 2884 2885func TestRoundToEven(t *testing.T) { 2886 for i := 0; i < len(vf); i++ { 2887 if f := RoundToEven(vf[i]); !alike(round[i], f) { 2888 t.Errorf("RoundToEven(%g) = %g, want %g", vf[i], f, round[i]) 2889 } 2890 } 2891 for i := 0; i < len(vfroundEvenSC); i++ { 2892 if f := RoundToEven(vfroundEvenSC[i][0]); !alike(vfroundEvenSC[i][1], f) { 2893 t.Errorf("RoundToEven(%g) = %g, want %g", vfroundEvenSC[i][0], f, vfroundEvenSC[i][1]) 2894 } 2895 } 2896} 2897 2898func TestSignbit(t *testing.T) { 2899 for i := 0; i < len(vf); i++ { 2900 if f := Signbit(vf[i]); signbit[i] != f { 2901 t.Errorf("Signbit(%g) = %t, want %t", vf[i], f, signbit[i]) 2902 } 2903 } 2904 for i := 0; i < len(vfsignbitSC); i++ { 2905 if f := Signbit(vfsignbitSC[i]); signbitSC[i] != f { 2906 t.Errorf("Signbit(%g) = %t, want %t", vfsignbitSC[i], f, signbitSC[i]) 2907 } 2908 } 2909} 2910func TestSin(t *testing.T) { 2911 for i := 0; i < len(vf); i++ { 2912 if f := Sin(vf[i]); !veryclose(sin[i], f) { 2913 t.Errorf("Sin(%g) = %g, want %g", vf[i], f, sin[i]) 2914 } 2915 } 2916 for i := 0; i < len(vfsinSC); i++ { 2917 if f := Sin(vfsinSC[i]); !alike(sinSC[i], f) { 2918 t.Errorf("Sin(%g) = %g, want %g", vfsinSC[i], f, sinSC[i]) 2919 } 2920 } 2921} 2922 2923func TestSincos(t *testing.T) { 2924 for i := 0; i < len(vf); i++ { 2925 if s, c := Sincos(vf[i]); !veryclose(sin[i], s) || !veryclose(cos[i], c) { 2926 t.Errorf("Sincos(%g) = %g, %g want %g, %g", vf[i], s, c, sin[i], cos[i]) 2927 } 2928 } 2929} 2930 2931func TestSinh(t *testing.T) { 2932 for i := 0; i < len(vf); i++ { 2933 if f := Sinh(vf[i]); !close(sinh[i], f) { 2934 t.Errorf("Sinh(%g) = %g, want %g", vf[i], f, sinh[i]) 2935 } 2936 } 2937 for i := 0; i < len(vfsinhSC); i++ { 2938 if f := Sinh(vfsinhSC[i]); !alike(sinhSC[i], f) { 2939 t.Errorf("Sinh(%g) = %g, want %g", vfsinhSC[i], f, sinhSC[i]) 2940 } 2941 } 2942} 2943 2944func TestSqrt(t *testing.T) { 2945 for i := 0; i < len(vf); i++ { 2946 a := Abs(vf[i]) 2947 if f := SqrtGo(a); sqrt[i] != f { 2948 t.Errorf("SqrtGo(%g) = %g, want %g", a, f, sqrt[i]) 2949 } 2950 a = Abs(vf[i]) 2951 if f := Sqrt(a); sqrt[i] != f { 2952 t.Errorf("Sqrt(%g) = %g, want %g", a, f, sqrt[i]) 2953 } 2954 } 2955 for i := 0; i < len(vfsqrtSC); i++ { 2956 if f := SqrtGo(vfsqrtSC[i]); !alike(sqrtSC[i], f) { 2957 t.Errorf("SqrtGo(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i]) 2958 } 2959 if f := Sqrt(vfsqrtSC[i]); !alike(sqrtSC[i], f) { 2960 t.Errorf("Sqrt(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i]) 2961 } 2962 } 2963} 2964 2965func TestTan(t *testing.T) { 2966 for i := 0; i < len(vf); i++ { 2967 if f := Tan(vf[i]); !veryclose(tan[i], f) { 2968 t.Errorf("Tan(%g) = %g, want %g", vf[i], f, tan[i]) 2969 } 2970 } 2971 // same special cases as Sin 2972 for i := 0; i < len(vfsinSC); i++ { 2973 if f := Tan(vfsinSC[i]); !alike(sinSC[i], f) { 2974 t.Errorf("Tan(%g) = %g, want %g", vfsinSC[i], f, sinSC[i]) 2975 } 2976 } 2977} 2978 2979func TestTanh(t *testing.T) { 2980 for i := 0; i < len(vf); i++ { 2981 if f := Tanh(vf[i]); !veryclose(tanh[i], f) { 2982 t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i]) 2983 } 2984 } 2985 for i := 0; i < len(vftanhSC); i++ { 2986 if f := Tanh(vftanhSC[i]); !alike(tanhSC[i], f) { 2987 t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i]) 2988 } 2989 } 2990} 2991 2992func TestTrunc(t *testing.T) { 2993 for i := 0; i < len(vf); i++ { 2994 if f := Trunc(vf[i]); !alike(trunc[i], f) { 2995 t.Errorf("Trunc(%g) = %g, want %g", vf[i], f, trunc[i]) 2996 } 2997 } 2998 for i := 0; i < len(vfceilSC); i++ { 2999 if f := Trunc(vfceilSC[i]); !alike(ceilSC[i], f) { 3000 t.Errorf("Trunc(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i]) 3001 } 3002 } 3003} 3004 3005func TestY0(t *testing.T) { 3006 for i := 0; i < len(vf); i++ { 3007 a := Abs(vf[i]) 3008 if f := Y0(a); !close(y0[i], f) { 3009 t.Errorf("Y0(%g) = %g, want %g", a, f, y0[i]) 3010 } 3011 } 3012 for i := 0; i < len(vfy0SC); i++ { 3013 if f := Y0(vfy0SC[i]); !alike(y0SC[i], f) { 3014 t.Errorf("Y0(%g) = %g, want %g", vfy0SC[i], f, y0SC[i]) 3015 } 3016 } 3017} 3018 3019func TestY1(t *testing.T) { 3020 for i := 0; i < len(vf); i++ { 3021 a := Abs(vf[i]) 3022 if f := Y1(a); !soclose(y1[i], f, 2e-14) { 3023 t.Errorf("Y1(%g) = %g, want %g", a, f, y1[i]) 3024 } 3025 } 3026 for i := 0; i < len(vfy0SC); i++ { 3027 if f := Y1(vfy0SC[i]); !alike(y1SC[i], f) { 3028 t.Errorf("Y1(%g) = %g, want %g", vfy0SC[i], f, y1SC[i]) 3029 } 3030 } 3031} 3032 3033func TestYn(t *testing.T) { 3034 for i := 0; i < len(vf); i++ { 3035 a := Abs(vf[i]) 3036 if f := Yn(2, a); !close(y2[i], f) { 3037 t.Errorf("Yn(2, %g) = %g, want %g", a, f, y2[i]) 3038 } 3039 if f := Yn(-3, a); !close(yM3[i], f) { 3040 t.Errorf("Yn(-3, %g) = %g, want %g", a, f, yM3[i]) 3041 } 3042 } 3043 for i := 0; i < len(vfy0SC); i++ { 3044 if f := Yn(2, vfy0SC[i]); !alike(y2SC[i], f) { 3045 t.Errorf("Yn(2, %g) = %g, want %g", vfy0SC[i], f, y2SC[i]) 3046 } 3047 if f := Yn(-3, vfy0SC[i]); !alike(yM3SC[i], f) { 3048 t.Errorf("Yn(-3, %g) = %g, want %g", vfy0SC[i], f, yM3SC[i]) 3049 } 3050 } 3051 if f := Yn(0, 0); !alike(Inf(-1), f) { 3052 t.Errorf("Yn(0, 0) = %g, want %g", f, Inf(-1)) 3053 } 3054} 3055 3056var PortableFMA = FMA // hide call from compiler intrinsic; falls back to portable code 3057 3058func TestFMA(t *testing.T) { 3059 for _, c := range fmaC { 3060 got := FMA(c.x, c.y, c.z) 3061 if !alike(got, c.want) { 3062 t.Errorf("FMA(%g,%g,%g) == %g; want %g", c.x, c.y, c.z, got, c.want) 3063 } 3064 got = PortableFMA(c.x, c.y, c.z) 3065 if !alike(got, c.want) { 3066 t.Errorf("PortableFMA(%g,%g,%g) == %g; want %g", c.x, c.y, c.z, got, c.want) 3067 } 3068 } 3069} 3070 3071// Check that math functions of high angle values 3072// return accurate results. [Since (vf[i] + large) - large != vf[i], 3073// testing for Trig(vf[i] + large) == Trig(vf[i]), where large is 3074// a multiple of 2*Pi, is misleading.] 3075func TestLargeCos(t *testing.T) { 3076 large := float64(100000 * Pi) 3077 for i := 0; i < len(vf); i++ { 3078 f1 := cosLarge[i] 3079 f2 := Cos(vf[i] + large) 3080 if !close(f1, f2) { 3081 t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1) 3082 } 3083 } 3084} 3085 3086func TestLargeSin(t *testing.T) { 3087 large := float64(100000 * Pi) 3088 for i := 0; i < len(vf); i++ { 3089 f1 := sinLarge[i] 3090 f2 := Sin(vf[i] + large) 3091 if !close(f1, f2) { 3092 t.Errorf("Sin(%g) = %g, want %g", vf[i]+large, f2, f1) 3093 } 3094 } 3095} 3096 3097func TestLargeSincos(t *testing.T) { 3098 large := float64(100000 * Pi) 3099 for i := 0; i < len(vf); i++ { 3100 f1, g1 := sinLarge[i], cosLarge[i] 3101 f2, g2 := Sincos(vf[i] + large) 3102 if !close(f1, f2) || !close(g1, g2) { 3103 t.Errorf("Sincos(%g) = %g, %g, want %g, %g", vf[i]+large, f2, g2, f1, g1) 3104 } 3105 } 3106} 3107 3108func TestLargeTan(t *testing.T) { 3109 large := float64(100000 * Pi) 3110 for i := 0; i < len(vf); i++ { 3111 f1 := tanLarge[i] 3112 f2 := Tan(vf[i] + large) 3113 if !close(f1, f2) { 3114 t.Errorf("Tan(%g) = %g, want %g", vf[i]+large, f2, f1) 3115 } 3116 } 3117} 3118 3119// Check that trigReduce matches the standard reduction results for input values 3120// below reduceThreshold. 3121func TestTrigReduce(t *testing.T) { 3122 inputs := make([]float64, len(vf)) 3123 // all of the standard inputs 3124 copy(inputs, vf) 3125 // all of the large inputs 3126 large := float64(100000 * Pi) 3127 for _, v := range vf { 3128 inputs = append(inputs, v+large) 3129 } 3130 // Also test some special inputs, Pi and right below the reduceThreshold 3131 inputs = append(inputs, Pi, Nextafter(ReduceThreshold, 0)) 3132 for _, x := range inputs { 3133 // reduce the value to compare 3134 j, z := TrigReduce(x) 3135 xred := float64(j)*(Pi/4) + z 3136 3137 if f, fred := Sin(x), Sin(xred); !close(f, fred) { 3138 t.Errorf("Sin(trigReduce(%g)) != Sin(%g), got %g, want %g", x, x, fred, f) 3139 } 3140 if f, fred := Cos(x), Cos(xred); !close(f, fred) { 3141 t.Errorf("Cos(trigReduce(%g)) != Cos(%g), got %g, want %g", x, x, fred, f) 3142 } 3143 if f, fred := Tan(x), Tan(xred); !close(f, fred) { 3144 t.Errorf(" Tan(trigReduce(%g)) != Tan(%g), got %g, want %g", x, x, fred, f) 3145 } 3146 f, g := Sincos(x) 3147 fred, gred := Sincos(xred) 3148 if !close(f, fred) || !close(g, gred) { 3149 t.Errorf(" Sincos(trigReduce(%g)) != Sincos(%g), got %g, %g, want %g, %g", x, x, fred, gred, f, g) 3150 } 3151 } 3152} 3153 3154// Check that math constants are accepted by compiler 3155// and have right value (assumes strconv.ParseFloat works). 3156// https://golang.org/issue/201 3157 3158type floatTest struct { 3159 val interface{} 3160 name string 3161 str string 3162} 3163 3164var floatTests = []floatTest{ 3165 {float64(MaxFloat64), "MaxFloat64", "1.7976931348623157e+308"}, 3166 {float64(SmallestNonzeroFloat64), "SmallestNonzeroFloat64", "5e-324"}, 3167 {float32(MaxFloat32), "MaxFloat32", "3.4028235e+38"}, 3168 {float32(SmallestNonzeroFloat32), "SmallestNonzeroFloat32", "1e-45"}, 3169} 3170 3171func TestFloatMinMax(t *testing.T) { 3172 for _, tt := range floatTests { 3173 s := fmt.Sprint(tt.val) 3174 if s != tt.str { 3175 t.Errorf("Sprint(%v) = %s, want %s", tt.name, s, tt.str) 3176 } 3177 } 3178} 3179 3180// Benchmarks 3181 3182// Global exported variables are used to store the 3183// return values of functions measured in the benchmarks. 3184// Storing the results in these variables prevents the compiler 3185// from completely optimizing the benchmarked functions away. 3186var ( 3187 GlobalI int 3188 GlobalB bool 3189 GlobalF float64 3190) 3191 3192func BenchmarkAcos(b *testing.B) { 3193 x := 0.0 3194 for i := 0; i < b.N; i++ { 3195 x = Acos(.5) 3196 } 3197 GlobalF = x 3198} 3199 3200func BenchmarkAcosh(b *testing.B) { 3201 x := 0.0 3202 for i := 0; i < b.N; i++ { 3203 x = Acosh(1.5) 3204 } 3205 GlobalF = x 3206} 3207 3208func BenchmarkAsin(b *testing.B) { 3209 x := 0.0 3210 for i := 0; i < b.N; i++ { 3211 x = Asin(.5) 3212 } 3213 GlobalF = x 3214} 3215 3216func BenchmarkAsinh(b *testing.B) { 3217 x := 0.0 3218 for i := 0; i < b.N; i++ { 3219 x = Asinh(.5) 3220 } 3221 GlobalF = x 3222} 3223 3224func BenchmarkAtan(b *testing.B) { 3225 x := 0.0 3226 for i := 0; i < b.N; i++ { 3227 x = Atan(.5) 3228 } 3229 GlobalF = x 3230} 3231 3232func BenchmarkAtanh(b *testing.B) { 3233 x := 0.0 3234 for i := 0; i < b.N; i++ { 3235 x = Atanh(.5) 3236 } 3237 GlobalF = x 3238} 3239 3240func BenchmarkAtan2(b *testing.B) { 3241 x := 0.0 3242 for i := 0; i < b.N; i++ { 3243 x = Atan2(.5, 1) 3244 } 3245 GlobalF = x 3246} 3247 3248func BenchmarkCbrt(b *testing.B) { 3249 x := 0.0 3250 for i := 0; i < b.N; i++ { 3251 x = Cbrt(10) 3252 } 3253 GlobalF = x 3254} 3255 3256func BenchmarkCeil(b *testing.B) { 3257 x := 0.0 3258 for i := 0; i < b.N; i++ { 3259 x = Ceil(.5) 3260 } 3261 GlobalF = x 3262} 3263 3264var copysignNeg = -1.0 3265 3266func BenchmarkCopysign(b *testing.B) { 3267 x := 0.0 3268 for i := 0; i < b.N; i++ { 3269 x = Copysign(.5, copysignNeg) 3270 } 3271 GlobalF = x 3272} 3273 3274func BenchmarkCos(b *testing.B) { 3275 x := 0.0 3276 for i := 0; i < b.N; i++ { 3277 x = Cos(.5) 3278 } 3279 GlobalF = x 3280} 3281 3282func BenchmarkCosh(b *testing.B) { 3283 x := 0.0 3284 for i := 0; i < b.N; i++ { 3285 x = Cosh(2.5) 3286 } 3287 GlobalF = x 3288} 3289 3290func BenchmarkErf(b *testing.B) { 3291 x := 0.0 3292 for i := 0; i < b.N; i++ { 3293 x = Erf(.5) 3294 } 3295 GlobalF = x 3296} 3297 3298func BenchmarkErfc(b *testing.B) { 3299 x := 0.0 3300 for i := 0; i < b.N; i++ { 3301 x = Erfc(.5) 3302 } 3303 GlobalF = x 3304} 3305 3306func BenchmarkErfinv(b *testing.B) { 3307 x := 0.0 3308 for i := 0; i < b.N; i++ { 3309 x = Erfinv(.5) 3310 } 3311 GlobalF = x 3312} 3313 3314func BenchmarkErfcinv(b *testing.B) { 3315 x := 0.0 3316 for i := 0; i < b.N; i++ { 3317 x = Erfcinv(.5) 3318 } 3319 GlobalF = x 3320} 3321 3322func BenchmarkExp(b *testing.B) { 3323 x := 0.0 3324 for i := 0; i < b.N; i++ { 3325 x = Exp(.5) 3326 } 3327 GlobalF = x 3328} 3329 3330func BenchmarkExpGo(b *testing.B) { 3331 x := 0.0 3332 for i := 0; i < b.N; i++ { 3333 x = ExpGo(.5) 3334 } 3335 GlobalF = x 3336} 3337 3338func BenchmarkExpm1(b *testing.B) { 3339 x := 0.0 3340 for i := 0; i < b.N; i++ { 3341 x = Expm1(.5) 3342 } 3343 GlobalF = x 3344} 3345 3346func BenchmarkExp2(b *testing.B) { 3347 x := 0.0 3348 for i := 0; i < b.N; i++ { 3349 x = Exp2(.5) 3350 } 3351 GlobalF = x 3352} 3353 3354func BenchmarkExp2Go(b *testing.B) { 3355 x := 0.0 3356 for i := 0; i < b.N; i++ { 3357 x = Exp2Go(.5) 3358 } 3359 GlobalF = x 3360} 3361 3362var absPos = .5 3363 3364func BenchmarkAbs(b *testing.B) { 3365 x := 0.0 3366 for i := 0; i < b.N; i++ { 3367 x = Abs(absPos) 3368 } 3369 GlobalF = x 3370 3371} 3372 3373func BenchmarkDim(b *testing.B) { 3374 x := 0.0 3375 for i := 0; i < b.N; i++ { 3376 x = Dim(GlobalF, x) 3377 } 3378 GlobalF = x 3379} 3380 3381func BenchmarkFloor(b *testing.B) { 3382 x := 0.0 3383 for i := 0; i < b.N; i++ { 3384 x = Floor(.5) 3385 } 3386 GlobalF = x 3387} 3388 3389func BenchmarkMax(b *testing.B) { 3390 x := 0.0 3391 for i := 0; i < b.N; i++ { 3392 x = Max(10, 3) 3393 } 3394 GlobalF = x 3395} 3396 3397func BenchmarkMin(b *testing.B) { 3398 x := 0.0 3399 for i := 0; i < b.N; i++ { 3400 x = Min(10, 3) 3401 } 3402 GlobalF = x 3403} 3404 3405func BenchmarkMod(b *testing.B) { 3406 x := 0.0 3407 for i := 0; i < b.N; i++ { 3408 x = Mod(10, 3) 3409 } 3410 GlobalF = x 3411} 3412 3413func BenchmarkFrexp(b *testing.B) { 3414 x := 0.0 3415 y := 0 3416 for i := 0; i < b.N; i++ { 3417 x, y = Frexp(8) 3418 } 3419 GlobalF = x 3420 GlobalI = y 3421} 3422 3423func BenchmarkGamma(b *testing.B) { 3424 x := 0.0 3425 for i := 0; i < b.N; i++ { 3426 x = Gamma(2.5) 3427 } 3428 GlobalF = x 3429} 3430 3431func BenchmarkHypot(b *testing.B) { 3432 x := 0.0 3433 for i := 0; i < b.N; i++ { 3434 x = Hypot(3, 4) 3435 } 3436 GlobalF = x 3437} 3438 3439func BenchmarkHypotGo(b *testing.B) { 3440 x := 0.0 3441 for i := 0; i < b.N; i++ { 3442 x = HypotGo(3, 4) 3443 } 3444 GlobalF = x 3445} 3446 3447func BenchmarkIlogb(b *testing.B) { 3448 x := 0 3449 for i := 0; i < b.N; i++ { 3450 x = Ilogb(.5) 3451 } 3452 GlobalI = x 3453} 3454 3455func BenchmarkJ0(b *testing.B) { 3456 x := 0.0 3457 for i := 0; i < b.N; i++ { 3458 x = J0(2.5) 3459 } 3460 GlobalF = x 3461} 3462 3463func BenchmarkJ1(b *testing.B) { 3464 x := 0.0 3465 for i := 0; i < b.N; i++ { 3466 x = J1(2.5) 3467 } 3468 GlobalF = x 3469} 3470 3471func BenchmarkJn(b *testing.B) { 3472 x := 0.0 3473 for i := 0; i < b.N; i++ { 3474 x = Jn(2, 2.5) 3475 } 3476 GlobalF = x 3477} 3478 3479func BenchmarkLdexp(b *testing.B) { 3480 x := 0.0 3481 for i := 0; i < b.N; i++ { 3482 x = Ldexp(.5, 2) 3483 } 3484 GlobalF = x 3485} 3486 3487func BenchmarkLgamma(b *testing.B) { 3488 x := 0.0 3489 y := 0 3490 for i := 0; i < b.N; i++ { 3491 x, y = Lgamma(2.5) 3492 } 3493 GlobalF = x 3494 GlobalI = y 3495} 3496 3497func BenchmarkLog(b *testing.B) { 3498 x := 0.0 3499 for i := 0; i < b.N; i++ { 3500 x = Log(.5) 3501 } 3502 GlobalF = x 3503} 3504 3505func BenchmarkLogb(b *testing.B) { 3506 x := 0.0 3507 for i := 0; i < b.N; i++ { 3508 x = Logb(.5) 3509 } 3510 GlobalF = x 3511} 3512 3513func BenchmarkLog1p(b *testing.B) { 3514 x := 0.0 3515 for i := 0; i < b.N; i++ { 3516 x = Log1p(.5) 3517 } 3518 GlobalF = x 3519} 3520 3521func BenchmarkLog10(b *testing.B) { 3522 x := 0.0 3523 for i := 0; i < b.N; i++ { 3524 x = Log10(.5) 3525 } 3526 GlobalF = x 3527} 3528 3529func BenchmarkLog2(b *testing.B) { 3530 x := 0.0 3531 for i := 0; i < b.N; i++ { 3532 x = Log2(.5) 3533 } 3534 GlobalF += x 3535} 3536 3537func BenchmarkModf(b *testing.B) { 3538 x := 0.0 3539 y := 0.0 3540 for i := 0; i < b.N; i++ { 3541 x, y = Modf(1.5) 3542 } 3543 GlobalF += x 3544 GlobalF += y 3545} 3546 3547func BenchmarkNextafter32(b *testing.B) { 3548 x := float32(0.0) 3549 for i := 0; i < b.N; i++ { 3550 x = Nextafter32(.5, 1) 3551 } 3552 GlobalF = float64(x) 3553} 3554 3555func BenchmarkNextafter64(b *testing.B) { 3556 x := 0.0 3557 for i := 0; i < b.N; i++ { 3558 x = Nextafter(.5, 1) 3559 } 3560 GlobalF = x 3561} 3562 3563func BenchmarkPowInt(b *testing.B) { 3564 x := 0.0 3565 for i := 0; i < b.N; i++ { 3566 x = Pow(2, 2) 3567 } 3568 GlobalF = x 3569} 3570 3571func BenchmarkPowFrac(b *testing.B) { 3572 x := 0.0 3573 for i := 0; i < b.N; i++ { 3574 x = Pow(2.5, 1.5) 3575 } 3576 GlobalF = x 3577} 3578 3579var pow10pos = int(300) 3580 3581func BenchmarkPow10Pos(b *testing.B) { 3582 x := 0.0 3583 for i := 0; i < b.N; i++ { 3584 x = Pow10(pow10pos) 3585 } 3586 GlobalF = x 3587} 3588 3589var pow10neg = int(-300) 3590 3591func BenchmarkPow10Neg(b *testing.B) { 3592 x := 0.0 3593 for i := 0; i < b.N; i++ { 3594 x = Pow10(pow10neg) 3595 } 3596 GlobalF = x 3597} 3598 3599var roundNeg = float64(-2.5) 3600 3601func BenchmarkRound(b *testing.B) { 3602 x := 0.0 3603 for i := 0; i < b.N; i++ { 3604 x = Round(roundNeg) 3605 } 3606 GlobalF = x 3607} 3608 3609func BenchmarkRoundToEven(b *testing.B) { 3610 x := 0.0 3611 for i := 0; i < b.N; i++ { 3612 x = RoundToEven(roundNeg) 3613 } 3614 GlobalF = x 3615} 3616 3617func BenchmarkRemainder(b *testing.B) { 3618 x := 0.0 3619 for i := 0; i < b.N; i++ { 3620 x = Remainder(10, 3) 3621 } 3622 GlobalF = x 3623} 3624 3625var signbitPos = 2.5 3626 3627func BenchmarkSignbit(b *testing.B) { 3628 x := false 3629 for i := 0; i < b.N; i++ { 3630 x = Signbit(signbitPos) 3631 } 3632 GlobalB = x 3633} 3634 3635func BenchmarkSin(b *testing.B) { 3636 x := 0.0 3637 for i := 0; i < b.N; i++ { 3638 x = Sin(.5) 3639 } 3640 GlobalF = x 3641} 3642 3643func BenchmarkSincos(b *testing.B) { 3644 x := 0.0 3645 y := 0.0 3646 for i := 0; i < b.N; i++ { 3647 x, y = Sincos(.5) 3648 } 3649 GlobalF += x 3650 GlobalF += y 3651} 3652 3653func BenchmarkSinh(b *testing.B) { 3654 x := 0.0 3655 for i := 0; i < b.N; i++ { 3656 x = Sinh(2.5) 3657 } 3658 GlobalF = x 3659} 3660 3661func BenchmarkSqrtIndirect(b *testing.B) { 3662 x, y := 0.0, 10.0 3663 f := Sqrt 3664 for i := 0; i < b.N; i++ { 3665 x += f(y) 3666 } 3667 GlobalF = x 3668} 3669 3670func BenchmarkSqrtLatency(b *testing.B) { 3671 x := 10.0 3672 for i := 0; i < b.N; i++ { 3673 x = Sqrt(x) 3674 } 3675 GlobalF = x 3676} 3677 3678func BenchmarkSqrtIndirectLatency(b *testing.B) { 3679 x := 10.0 3680 f := Sqrt 3681 for i := 0; i < b.N; i++ { 3682 x = f(x) 3683 } 3684 GlobalF = x 3685} 3686 3687func BenchmarkSqrtGoLatency(b *testing.B) { 3688 x := 10.0 3689 for i := 0; i < b.N; i++ { 3690 x = SqrtGo(x) 3691 } 3692 GlobalF = x 3693} 3694 3695func isPrime(i int) bool { 3696 // Yes, this is a dumb way to write this code, 3697 // but calling Sqrt repeatedly in this way demonstrates 3698 // the benefit of using a direct SQRT instruction on systems 3699 // that have one, whereas the obvious loop seems not to 3700 // demonstrate such a benefit. 3701 for j := 2; float64(j) <= Sqrt(float64(i)); j++ { 3702 if i%j == 0 { 3703 return false 3704 } 3705 } 3706 return true 3707} 3708 3709func BenchmarkSqrtPrime(b *testing.B) { 3710 x := false 3711 for i := 0; i < b.N; i++ { 3712 x = isPrime(100003) 3713 } 3714 GlobalB = x 3715} 3716 3717func BenchmarkTan(b *testing.B) { 3718 x := 0.0 3719 for i := 0; i < b.N; i++ { 3720 x = Tan(.5) 3721 } 3722 GlobalF = x 3723} 3724 3725func BenchmarkTanh(b *testing.B) { 3726 x := 0.0 3727 for i := 0; i < b.N; i++ { 3728 x = Tanh(2.5) 3729 } 3730 GlobalF = x 3731} 3732func BenchmarkTrunc(b *testing.B) { 3733 x := 0.0 3734 for i := 0; i < b.N; i++ { 3735 x = Trunc(.5) 3736 } 3737 GlobalF = x 3738} 3739 3740func BenchmarkY0(b *testing.B) { 3741 x := 0.0 3742 for i := 0; i < b.N; i++ { 3743 x = Y0(2.5) 3744 } 3745 GlobalF = x 3746} 3747 3748func BenchmarkY1(b *testing.B) { 3749 x := 0.0 3750 for i := 0; i < b.N; i++ { 3751 x = Y1(2.5) 3752 } 3753 GlobalF = x 3754} 3755 3756func BenchmarkYn(b *testing.B) { 3757 x := 0.0 3758 for i := 0; i < b.N; i++ { 3759 x = Yn(2, 2.5) 3760 } 3761 GlobalF = x 3762} 3763 3764func BenchmarkFloat64bits(b *testing.B) { 3765 y := uint64(0) 3766 for i := 0; i < b.N; i++ { 3767 y = Float64bits(roundNeg) 3768 } 3769 GlobalI = int(y) 3770} 3771 3772var roundUint64 = uint64(5) 3773 3774func BenchmarkFloat64frombits(b *testing.B) { 3775 x := 0.0 3776 for i := 0; i < b.N; i++ { 3777 x = Float64frombits(roundUint64) 3778 } 3779 GlobalF = x 3780} 3781 3782var roundFloat32 = float32(-2.5) 3783 3784func BenchmarkFloat32bits(b *testing.B) { 3785 y := uint32(0) 3786 for i := 0; i < b.N; i++ { 3787 y = Float32bits(roundFloat32) 3788 } 3789 GlobalI = int(y) 3790} 3791 3792var roundUint32 = uint32(5) 3793 3794func BenchmarkFloat32frombits(b *testing.B) { 3795 x := float32(0.0) 3796 for i := 0; i < b.N; i++ { 3797 x = Float32frombits(roundUint32) 3798 } 3799 GlobalF = float64(x) 3800} 3801 3802func BenchmarkFMA(b *testing.B) { 3803 x := 0.0 3804 for i := 0; i < b.N; i++ { 3805 x = FMA(E, Pi, x) 3806 } 3807 GlobalF = x 3808} 3809