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