src/math/all_test.go

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