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 )
  12
  13 var vf = []float64{
  14         4.9790119248836735e+00,
  15         7.7388724745781045e+00,
  16         -2.7688005719200159e-01,
  17         -5.0106036182710749e+00,
  18         9.6362937071984173e+00,
  19         2.9263772392439646e+00,
  20         5.2290834314593066e+00,
  21         2.7279399104360102e+00,
  22         1.8253080916808550e+00,
  23         -8.6859247685756013e+00,
  24 }
  25
  26 // The expected results below were computed by the high precision calculators
  27 // at http://keisan.casio.com/.  More exact input values (array vf[], above)
  28 // were obtained by printing them with "%.26f".  The answers were calculated
  29 // to 26 digits (by using the "Digit number" drop-down control of each
  30 // calculator).
  31 var acos = []float64{
  32         1.0496193546107222142571536e+00,
  33         6.8584012813664425171660692e-01,
  34         1.5984878714577160325521819e+00,
  35         2.0956199361475859327461799e+00,
  36         2.7053008467824138592616927e-01,
  37         1.2738121680361776018155625e+00,
  38         1.0205369421140629186287407e+00,
  39         1.2945003481781246062157835e+00,
  40         1.3872364345374451433846657e+00,
  41         2.6231510803970463967294145e+00,
  42 }
  43 var acosh = []float64{
  44         2.4743347004159012494457618e+00,
  45         2.8576385344292769649802701e+00,
  46         7.2796961502981066190593175e-01,
  47         2.4796794418831451156471977e+00,
  48         3.0552020742306061857212962e+00,
  49         2.044238592688586588942468e+00,
  50         2.5158701513104513595766636e+00,
  51         1.99050839282411638174299e+00,
  52         1.6988625798424034227205445e+00,
  53         2.9611454842470387925531875e+00,
  54 }
  55 var asin = []float64{
  56         5.2117697218417440497416805e-01,
  57         8.8495619865825236751471477e-01,
  58         -02.769154466281941332086016e-02,
  59         -5.2482360935268931351485822e-01,
  60         1.3002662421166552333051524e+00,
  61         2.9698415875871901741575922e-01,
  62         5.5025938468083370060258102e-01,
  63         2.7629597861677201301553823e-01,
  64         1.83559892257451475846656e-01,
  65         -1.0523547536021497774980928e+00,
  66 }
  67 var asinh = []float64{
  68         2.3083139124923523427628243e+00,
  69         2.743551594301593620039021e+00,
  70         -2.7345908534880091229413487e-01,
  71         -2.3145157644718338650499085e+00,
  72         2.9613652154015058521951083e+00,
  73         1.7949041616585821933067568e+00,
  74         2.3564032905983506405561554e+00,
  75         1.7287118790768438878045346e+00,
  76         1.3626658083714826013073193e+00,
  77         -2.8581483626513914445234004e+00,
  78 }
  79 var atan = []float64{
  80         1.372590262129621651920085e+00,
  81         1.442290609645298083020664e+00,
  82         -2.7011324359471758245192595e-01,
  83         -1.3738077684543379452781531e+00,
  84         1.4673921193587666049154681e+00,
  85         1.2415173565870168649117764e+00,
  86         1.3818396865615168979966498e+00,
  87         1.2194305844639670701091426e+00,
  88         1.0696031952318783760193244e+00,
  89         -1.4561721938838084990898679e+00,
  90 }
  91 var atanh = []float64{
  92         5.4651163712251938116878204e-01,
  93         1.0299474112843111224914709e+00,
  94         -2.7695084420740135145234906e-02,
  95         -5.5072096119207195480202529e-01,
  96         1.9943940993171843235906642e+00,
  97         3.01448604578089708203017e-01,
  98         5.8033427206942188834370595e-01,
  99         2.7987997499441511013958297e-01,
 100         1.8459947964298794318714228e-01,
 101         -1.3273186910532645867272502e+00,
 102 }
 103 var atan2 = []float64{
 104         1.1088291730037004444527075e+00,
 105         9.1218183188715804018797795e-01,
 106         1.5984772603216203736068915e+00,
 107         2.0352918654092086637227327e+00,
 108         8.0391819139044720267356014e-01,
 109         1.2861075249894661588866752e+00,
 110         1.0889904479131695712182587e+00,
 111         1.3044821793397925293797357e+00,
 112         1.3902530903455392306872261e+00,
 113         2.2859857424479142655411058e+00,
 114 }
 115 var cbrt = []float64{
 116         1.7075799841925094446722675e+00,
 117         1.9779982212970353936691498e+00,
 118         -6.5177429017779910853339447e-01,
 119         -1.7111838886544019873338113e+00,
 120         2.1279920909827937423960472e+00,
 121         1.4303536770460741452312367e+00,
 122         1.7357021059106154902341052e+00,
 123         1.3972633462554328350552916e+00,
 124         1.2221149580905388454977636e+00,
 125         -2.0556003730500069110343596e+00,
 126 }
 127 var ceil = []float64{
 128         5.0000000000000000e+00,
 129         8.0000000000000000e+00,
 130         0.0000000000000000e+00,
 131         -5.0000000000000000e+00,
 132         1.0000000000000000e+01,
 133         3.0000000000000000e+00,
 134         6.0000000000000000e+00,
 135         3.0000000000000000e+00,
 136         2.0000000000000000e+00,
 137         -8.0000000000000000e+00,
 138 }
 139 var copysign = []float64{
 140         -4.9790119248836735e+00,
 141         -7.7388724745781045e+00,
 142         -2.7688005719200159e-01,
 143         -5.0106036182710749e+00,
 144         -9.6362937071984173e+00,
 145         -2.9263772392439646e+00,
 146         -5.2290834314593066e+00,
 147         -2.7279399104360102e+00,
 148         -1.8253080916808550e+00,
 149         -8.6859247685756013e+00,
 150 }
 151 var cos = []float64{
 152         2.634752140995199110787593e-01,
 153         1.148551260848219865642039e-01,
 154         9.6191297325640768154550453e-01,
 155         2.938141150061714816890637e-01,
 156         -9.777138189897924126294461e-01,
 157         -9.7693041344303219127199518e-01,
 158         4.940088096948647263961162e-01,
 159         -9.1565869021018925545016502e-01,
 160         -2.517729313893103197176091e-01,
 161         -7.39241351595676573201918e-01,
 162 }
 163
 164 // Results for 100000 * Pi + vf[i]
 165 var cosLarge = []float64{
 166         2.634752141185559426744e-01,
 167         1.14855126055543100712e-01,
 168         9.61912973266488928113e-01,
 169         2.9381411499556122552e-01,
 170         -9.777138189880161924641e-01,
 171         -9.76930413445147608049e-01,
 172         4.940088097314976789841e-01,
 173         -9.15658690217517835002e-01,
 174         -2.51772931436786954751e-01,
 175         -7.3924135157173099849e-01,
 176 }
 177 var cosh = []float64{
 178         7.2668796942212842775517446e+01,
 179         1.1479413465659254502011135e+03,
 180         1.0385767908766418550935495e+00,
 181         7.5000957789658051428857788e+01,
 182         7.655246669605357888468613e+03,
 183         9.3567491758321272072888257e+00,
 184         9.331351599270605471131735e+01,
 185         7.6833430994624643209296404e+00,
 186         3.1829371625150718153881164e+00,
 187         2.9595059261916188501640911e+03,
 188 }
 189 var erf = []float64{
 190         5.1865354817738701906913566e-01,
 191         7.2623875834137295116929844e-01,
 192         -3.123458688281309990629839e-02,
 193         -5.2143121110253302920437013e-01,
 194         8.2704742671312902508629582e-01,
 195         3.2101767558376376743993945e-01,
 196         5.403990312223245516066252e-01,
 197         3.0034702916738588551174831e-01,
 198         2.0369924417882241241559589e-01,
 199         -7.8069386968009226729944677e-01,
 200 }
 201 var erfc = []float64{
 202         4.8134645182261298093086434e-01,
 203         2.7376124165862704883070156e-01,
 204         1.0312345868828130999062984e+00,
 205         1.5214312111025330292043701e+00,
 206         1.7295257328687097491370418e-01,
 207         6.7898232441623623256006055e-01,
 208         4.596009687776754483933748e-01,
 209         6.9965297083261411448825169e-01,
 210         7.9630075582117758758440411e-01,
 211         1.7806938696800922672994468e+00,
 212 }
 213 var exp = []float64{
 214         1.4533071302642137507696589e+02,
 215         2.2958822575694449002537581e+03,
 216         7.5814542574851666582042306e-01,
 217         6.6668778421791005061482264e-03,
 218         1.5310493273896033740861206e+04,
 219         1.8659907517999328638667732e+01,
 220         1.8662167355098714543942057e+02,
 221         1.5301332413189378961665788e+01,
 222         6.2047063430646876349125085e+00,
 223         1.6894712385826521111610438e-04,
 224 }
 225 var expm1 = []float64{
 226         5.105047796122957327384770212e-02,
 227         8.046199708567344080562675439e-02,
 228         -2.764970978891639815187418703e-03,
 229         -4.8871434888875355394330300273e-02,
 230         1.0115864277221467777117227494e-01,
 231         2.969616407795910726014621657e-02,
 232         5.368214487944892300914037972e-02,
 233         2.765488851131274068067445335e-02,
 234         1.842068661871398836913874273e-02,
 235         -8.3193870863553801814961137573e-02,
 236 }
 237 var exp2 = []float64{
 238         3.1537839463286288034313104e+01,
 239         2.1361549283756232296144849e+02,
 240         8.2537402562185562902577219e-01,
 241         3.1021158628740294833424229e-02,
 242         7.9581744110252191462569661e+02,
 243         7.6019905892596359262696423e+00,
 244         3.7506882048388096973183084e+01,
 245         6.6250893439173561733216375e+00,
 246         3.5438267900243941544605339e+00,
 247         2.4281533133513300984289196e-03,
 248 }
 249 var fabs = []float64{
 250         4.9790119248836735e+00,
 251         7.7388724745781045e+00,
 252         2.7688005719200159e-01,
 253         5.0106036182710749e+00,
 254         9.6362937071984173e+00,
 255         2.9263772392439646e+00,
 256         5.2290834314593066e+00,
 257         2.7279399104360102e+00,
 258         1.8253080916808550e+00,
 259         8.6859247685756013e+00,
 260 }
 261 var fdim = []float64{
 262         4.9790119248836735e+00,
 263         7.7388724745781045e+00,
 264         0.0000000000000000e+00,
 265         0.0000000000000000e+00,
 266         9.6362937071984173e+00,
 267         2.9263772392439646e+00,
 268         5.2290834314593066e+00,
 269         2.7279399104360102e+00,
 270         1.8253080916808550e+00,
 271         0.0000000000000000e+00,
 272 }
 273 var floor = []float64{
 274         4.0000000000000000e+00,
 275         7.0000000000000000e+00,
 276         -1.0000000000000000e+00,
 277         -6.0000000000000000e+00,
 278         9.0000000000000000e+00,
 279         2.0000000000000000e+00,
 280         5.0000000000000000e+00,
 281         2.0000000000000000e+00,
 282         1.0000000000000000e+00,
 283         -9.0000000000000000e+00,
 284 }
 285 var fmod = []float64{
 286         4.197615023265299782906368e-02,
 287         2.261127525421895434476482e+00,
 288         3.231794108794261433104108e-02,
 289         4.989396381728925078391512e+00,
 290         3.637062928015826201999516e-01,
 291         1.220868282268106064236690e+00,
 292         4.770916568540693347699744e+00,
 293         1.816180268691969246219742e+00,
 294         8.734595415957246977711748e-01,
 295         1.314075231424398637614104e+00,
 296 }
 297
 298 type fi struct {
 299         f float64
 300         i int
 301 }
 302
 303 var frexp = []fi{
 304         {6.2237649061045918750e-01, 3},
 305         {9.6735905932226306250e-01, 3},
 306         {-5.5376011438400318000e-01, -1},
 307         {-6.2632545228388436250e-01, 3},
 308         {6.02268356699901081250e-01, 4},
 309         {7.3159430981099115000e-01, 2},
 310         {6.5363542893241332500e-01, 3},
 311         {6.8198497760900255000e-01, 2},
 312         {9.1265404584042750000e-01, 1},
 313         {-5.4287029803597508250e-01, 4},
 314 }
 315 var gamma = []float64{
 316         2.3254348370739963835386613898e+01,
 317         2.991153837155317076427529816e+03,
 318         -4.561154336726758060575129109e+00,
 319         7.719403468842639065959210984e-01,
 320         1.6111876618855418534325755566e+05,
 321         1.8706575145216421164173224946e+00,
 322         3.4082787447257502836734201635e+01,
 323         1.579733951448952054898583387e+00,
 324         9.3834586598354592860187267089e-01,
 325         -2.093995902923148389186189429e-05,
 326 }
 327 var j0 = []float64{
 328         -1.8444682230601672018219338e-01,
 329         2.27353668906331975435892e-01,
 330         9.809259936157051116270273e-01,
 331         -1.741170131426226587841181e-01,
 332         -2.1389448451144143352039069e-01,
 333         -2.340905848928038763337414e-01,
 334         -1.0029099691890912094586326e-01,
 335         -1.5466726714884328135358907e-01,
 336         3.252650187653420388714693e-01,
 337         -8.72218484409407250005360235e-03,
 338 }
 339 var j1 = []float64{
 340         -3.251526395295203422162967e-01,
 341         1.893581711430515718062564e-01,
 342         -1.3711761352467242914491514e-01,
 343         3.287486536269617297529617e-01,
 344         1.3133899188830978473849215e-01,
 345         3.660243417832986825301766e-01,
 346         -3.4436769271848174665420672e-01,
 347         4.329481396640773768835036e-01,
 348         5.8181350531954794639333955e-01,
 349         -2.7030574577733036112996607e-01,
 350 }
 351 var j2 = []float64{
 352         5.3837518920137802565192769e-02,
 353         -1.7841678003393207281244667e-01,
 354         9.521746934916464142495821e-03,
 355         4.28958355470987397983072e-02,
 356         2.4115371837854494725492872e-01,
 357         4.842458532394520316844449e-01,
 358         -3.142145220618633390125946e-02,
 359         4.720849184745124761189957e-01,
 360         3.122312022520957042957497e-01,
 361         7.096213118930231185707277e-02,
 362 }
 363 var jM3 = []float64{
 364         -3.684042080996403091021151e-01,
 365         2.8157665936340887268092661e-01,
 366         4.401005480841948348343589e-04,
 367         3.629926999056814081597135e-01,
 368         3.123672198825455192489266e-02,
 369         -2.958805510589623607540455e-01,
 370         -3.2033177696533233403289416e-01,
 371         -2.592737332129663376736604e-01,
 372         -1.0241334641061485092351251e-01,
 373         -2.3762660886100206491674503e-01,
 374 }
 375 var lgamma = []fi{
 376         {3.146492141244545774319734e+00, 1},
 377         {8.003414490659126375852113e+00, 1},
 378         {1.517575735509779707488106e+00, -1},
 379         {-2.588480028182145853558748e-01, 1},
 380         {1.1989897050205555002007985e+01, 1},
 381         {6.262899811091257519386906e-01, 1},
 382         {3.5287924899091566764846037e+00, 1},
 383         {4.5725644770161182299423372e-01, 1},
 384         {-6.363667087767961257654854e-02, 1},
 385         {-1.077385130910300066425564e+01, -1},
 386 }
 387 var log = []float64{
 388         1.605231462693062999102599e+00,
 389         2.0462560018708770653153909e+00,
 390         -1.2841708730962657801275038e+00,
 391         1.6115563905281545116286206e+00,
 392         2.2655365644872016636317461e+00,
 393         1.0737652208918379856272735e+00,
 394         1.6542360106073546632707956e+00,
 395         1.0035467127723465801264487e+00,
 396         6.0174879014578057187016475e-01,
 397         2.161703872847352815363655e+00,
 398 }
 399 var logb = []float64{
 400         2.0000000000000000e+00,
 401         2.0000000000000000e+00,
 402         -2.0000000000000000e+00,
 403         2.0000000000000000e+00,
 404         3.0000000000000000e+00,
 405         1.0000000000000000e+00,
 406         2.0000000000000000e+00,
 407         1.0000000000000000e+00,
 408         0.0000000000000000e+00,
 409         3.0000000000000000e+00,
 410 }
 411 var log10 = []float64{
 412         6.9714316642508290997617083e-01,
 413         8.886776901739320576279124e-01,
 414         -5.5770832400658929815908236e-01,
 415         6.998900476822994346229723e-01,
 416         9.8391002850684232013281033e-01,
 417         4.6633031029295153334285302e-01,
 418         7.1842557117242328821552533e-01,
 419         4.3583479968917773161304553e-01,
 420         2.6133617905227038228626834e-01,
 421         9.3881606348649405716214241e-01,
 422 }
 423 var log1p = []float64{
 424         4.8590257759797794104158205e-02,
 425         7.4540265965225865330849141e-02,
 426         -2.7726407903942672823234024e-03,
 427         -5.1404917651627649094953380e-02,
 428         9.1998280672258624681335010e-02,
 429         2.8843762576593352865894824e-02,
 430         5.0969534581863707268992645e-02,
 431         2.6913947602193238458458594e-02,
 432         1.8088493239630770262045333e-02,
 433         -9.0865245631588989681559268e-02,
 434 }
 435 var log2 = []float64{
 436         2.3158594707062190618898251e+00,
 437         2.9521233862883917703341018e+00,
 438         -1.8526669502700329984917062e+00,
 439         2.3249844127278861543568029e+00,
 440         3.268478366538305087466309e+00,
 441         1.5491157592596970278166492e+00,
 442         2.3865580889631732407886495e+00,
 443         1.447811865817085365540347e+00,
 444         8.6813999540425116282815557e-01,
 445         3.118679457227342224364709e+00,
 446 }
 447 var modf = [][2]float64{
 448         {4.0000000000000000e+00, 9.7901192488367350108546816e-01},
 449         {7.0000000000000000e+00, 7.3887247457810456552351752e-01},
 450         {Copysign(0, -1), -2.7688005719200159404635997e-01},
 451         {-5.0000000000000000e+00, -1.060361827107492160848778e-02},
 452         {9.0000000000000000e+00, 6.3629370719841737980004837e-01},
 453         {2.0000000000000000e+00, 9.2637723924396464525443662e-01},
 454         {5.0000000000000000e+00, 2.2908343145930665230025625e-01},
 455         {2.0000000000000000e+00, 7.2793991043601025126008608e-01},
 456         {1.0000000000000000e+00, 8.2530809168085506044576505e-01},
 457         {-8.0000000000000000e+00, -6.8592476857560136238589621e-01},
 458 }
 459 var nextafter32 = []float32{
 460         4.979012489318848e+00,
 461         7.738873004913330e+00,
 462         -2.768800258636475e-01,
 463         -5.010602951049805e+00,
 464         9.636294364929199e+00,
 465         2.926377534866333e+00,
 466         5.229084014892578e+00,
 467         2.727940082550049e+00,
 468         1.825308203697205e+00,
 469         -8.685923576354980e+00,
 470 }
 471 var nextafter64 = []float64{
 472         4.97901192488367438926388786e+00,
 473         7.73887247457810545370193722e+00,
 474         -2.7688005719200153853520874e-01,
 475         -5.01060361827107403343006808e+00,
 476         9.63629370719841915615688777e+00,
 477         2.92637723924396508934364647e+00,
 478         5.22908343145930754047867595e+00,
 479         2.72793991043601069534929593e+00,
 480         1.82530809168085528249036997e+00,
 481         -8.68592476857559958602905681e+00,
 482 }
 483 var pow = []float64{
 484         9.5282232631648411840742957e+04,
 485         5.4811599352999901232411871e+07,
 486         5.2859121715894396531132279e-01,
 487         9.7587991957286474464259698e-06,
 488         4.328064329346044846740467e+09,
 489         8.4406761805034547437659092e+02,
 490         1.6946633276191194947742146e+05,
 491         5.3449040147551939075312879e+02,
 492         6.688182138451414936380374e+01,
 493         2.0609869004248742886827439e-09,
 494 }
 495 var remainder = []float64{
 496         4.197615023265299782906368e-02,
 497         2.261127525421895434476482e+00,
 498         3.231794108794261433104108e-02,
 499         -2.120723654214984321697556e-02,
 500         3.637062928015826201999516e-01,
 501         1.220868282268106064236690e+00,
 502         -4.581668629186133046005125e-01,
 503         -9.117596417440410050403443e-01,
 504         8.734595415957246977711748e-01,
 505         1.314075231424398637614104e+00,
 506 }
 507 var signbit = []bool{
 508         false,
 509         false,
 510         true,
 511         true,
 512         false,
 513         false,
 514         false,
 515         false,
 516         false,
 517         true,
 518 }
 519 var sin = []float64{
 520         -9.6466616586009283766724726e-01,
 521         9.9338225271646545763467022e-01,
 522         -2.7335587039794393342449301e-01,
 523         9.5586257685042792878173752e-01,
 524         -2.099421066779969164496634e-01,
 525         2.135578780799860532750616e-01,
 526         -8.694568971167362743327708e-01,
 527         4.019566681155577786649878e-01,
 528         9.6778633541687993721617774e-01,
 529         -6.734405869050344734943028e-01,
 530 }
 531
 532 // Results for 100000 * Pi + vf[i]
 533 var sinLarge = []float64{
 534         -9.646661658548936063912e-01,
 535         9.933822527198506903752e-01,
 536         -2.7335587036246899796e-01,
 537         9.55862576853689321268e-01,
 538         -2.099421066862688873691e-01,
 539         2.13557878070308981163e-01,
 540         -8.694568970959221300497e-01,
 541         4.01956668098863248917e-01,
 542         9.67786335404528727927e-01,
 543         -6.7344058693131973066e-01,
 544 }
 545 var sinh = []float64{
 546         7.2661916084208532301448439e+01,
 547         1.1479409110035194500526446e+03,
 548         -2.8043136512812518927312641e-01,
 549         -7.499429091181587232835164e+01,
 550         7.6552466042906758523925934e+03,
 551         9.3031583421672014313789064e+00,
 552         9.330815755828109072810322e+01,
 553         7.6179893137269146407361477e+00,
 554         3.021769180549615819524392e+00,
 555         -2.95950575724449499189888e+03,
 556 }
 557 var sqrt = []float64{
 558         2.2313699659365484748756904e+00,
 559         2.7818829009464263511285458e+00,
 560         5.2619393496314796848143251e-01,
 561         2.2384377628763938724244104e+00,
 562         3.1042380236055381099288487e+00,
 563         1.7106657298385224403917771e+00,
 564         2.286718922705479046148059e+00,
 565         1.6516476350711159636222979e+00,
 566         1.3510396336454586262419247e+00,
 567         2.9471892997524949215723329e+00,
 568 }
 569 var tan = []float64{
 570         -3.661316565040227801781974e+00,
 571         8.64900232648597589369854e+00,
 572         -2.8417941955033612725238097e-01,
 573         3.253290185974728640827156e+00,
 574         2.147275640380293804770778e-01,
 575         -2.18600910711067004921551e-01,
 576         -1.760002817872367935518928e+00,
 577         -4.389808914752818126249079e-01,
 578         -3.843885560201130679995041e+00,
 579         9.10988793377685105753416e-01,
 580 }
 581
 582 // Results for 100000 * Pi + vf[i]
 583 var tanLarge = []float64{
 584         -3.66131656475596512705e+00,
 585         8.6490023287202547927e+00,
 586         -2.841794195104782406e-01,
 587         3.2532901861033120983e+00,
 588         2.14727564046880001365e-01,
 589         -2.18600910700688062874e-01,
 590         -1.760002817699722747043e+00,
 591         -4.38980891453536115952e-01,
 592         -3.84388555942723509071e+00,
 593         9.1098879344275101051e-01,
 594 }
 595 var tanh = []float64{
 596         9.9990531206936338549262119e-01,
 597         9.9999962057085294197613294e-01,
 598         -2.7001505097318677233756845e-01,
 599         -9.9991110943061718603541401e-01,
 600         9.9999999146798465745022007e-01,
 601         9.9427249436125236705001048e-01,
 602         9.9994257600983138572705076e-01,
 603         9.9149409509772875982054701e-01,
 604         9.4936501296239685514466577e-01,
 605         -9.9999994291374030946055701e-01,
 606 }
 607 var trunc = []float64{
 608         4.0000000000000000e+00,
 609         7.0000000000000000e+00,
 610         -0.0000000000000000e+00,
 611         -5.0000000000000000e+00,
 612         9.0000000000000000e+00,
 613         2.0000000000000000e+00,
 614         5.0000000000000000e+00,
 615         2.0000000000000000e+00,
 616         1.0000000000000000e+00,
 617         -8.0000000000000000e+00,
 618 }
 619 var y0 = []float64{
 620         -3.053399153780788357534855e-01,
 621         1.7437227649515231515503649e-01,
 622         -8.6221781263678836910392572e-01,
 623         -3.100664880987498407872839e-01,
 624         1.422200649300982280645377e-01,
 625         4.000004067997901144239363e-01,
 626         -3.3340749753099352392332536e-01,
 627         4.5399790746668954555205502e-01,
 628         4.8290004112497761007536522e-01,
 629         2.7036697826604756229601611e-01,
 630 }
 631 var y1 = []float64{
 632         0.15494213737457922210218611,
 633         -0.2165955142081145245075746,
 634         -2.4644949631241895201032829,
 635         0.1442740489541836405154505,
 636         0.2215379960518984777080163,
 637         0.3038800915160754150565448,
 638         0.0691107642452362383808547,
 639         0.2380116417809914424860165,
 640         -0.20849492979459761009678934,
 641         0.0242503179793232308250804,
 642 }
 643 var y2 = []float64{
 644         0.3675780219390303613394936,
 645         -0.23034826393250119879267257,
 646         -16.939677983817727205631397,
 647         0.367653980523052152867791,
 648         -0.0962401471767804440353136,
 649         -0.1923169356184851105200523,
 650         0.35984072054267882391843766,
 651         -0.2794987252299739821654982,
 652         -0.7113490692587462579757954,
 653         -0.2647831587821263302087457,
 654 }
 655 var yM3 = []float64{
 656         -0.14035984421094849100895341,
 657         -0.097535139617792072703973,
 658         242.25775994555580176377379,
 659         -0.1492267014802818619511046,
 660         0.26148702629155918694500469,
 661         0.56675383593895176530394248,
 662         -0.206150264009006981070575,
 663         0.64784284687568332737963658,
 664         1.3503631555901938037008443,
 665         0.1461869756579956803341844,
 666 }
 667
 668 // arguments and expected results for special cases
 669 var vfacosSC = []float64{
 670         -Pi,
 671         1,
 672         Pi,
 673         NaN(),
 674 }
 675 var acosSC = []float64{
 676         NaN(),
 677         0,
 678         NaN(),
 679         NaN(),
 680 }
 681
 682 var vfacoshSC = []float64{
 683         Inf(-1),
 684         0.5,
 685         1,
 686         Inf(1),
 687         NaN(),
 688 }
 689 var acoshSC = []float64{
 690         NaN(),
 691         NaN(),
 692         0,
 693         Inf(1),
 694         NaN(),
 695 }
 696
 697 var vfasinSC = []float64{
 698         -Pi,
 699         Copysign(0, -1),
 700         0,
 701         Pi,
 702         NaN(),
 703 }
 704 var asinSC = []float64{
 705         NaN(),
 706         Copysign(0, -1),
 707         0,
 708         NaN(),
 709         NaN(),
 710 }
 711
 712 var vfasinhSC = []float64{
 713         Inf(-1),
 714         Copysign(0, -1),
 715         0,
 716         Inf(1),
 717         NaN(),
 718 }
 719 var asinhSC = []float64{
 720         Inf(-1),
 721         Copysign(0, -1),
 722         0,
 723         Inf(1),
 724         NaN(),
 725 }
 726
 727 var vfatanSC = []float64{
 728         Inf(-1),
 729         Copysign(0, -1),
 730         0,
 731         Inf(1),
 732         NaN(),
 733 }
 734 var atanSC = []float64{
 735         -Pi / 2,
 736         Copysign(0, -1),
 737         0,
 738         Pi / 2,
 739         NaN(),
 740 }
 741
 742 var vfatanhSC = []float64{
 743         Inf(-1),
 744         -Pi,
 745         -1,
 746         Copysign(0, -1),
 747         0,
 748         1,
 749         Pi,
 750         Inf(1),
 751         NaN(),
 752 }
 753 var atanhSC = []float64{
 754         NaN(),
 755         NaN(),
 756         Inf(-1),
 757         Copysign(0, -1),
 758         0,
 759         Inf(1),
 760         NaN(),
 761         NaN(),
 762         NaN(),
 763 }
 764 var vfatan2SC = [][2]float64{
 765         {Inf(-1), Inf(-1)},
 766         {Inf(-1), -Pi},
 767         {Inf(-1), 0},
 768         {Inf(-1), +Pi},
 769         {Inf(-1), Inf(1)},
 770         {Inf(-1), NaN()},
 771         {-Pi, Inf(-1)},
 772         {-Pi, 0},
 773         {-Pi, Inf(1)},
 774         {-Pi, NaN()},
 775         {Copysign(0, -1), Inf(-1)},
 776         {Copysign(0, -1), -Pi},
 777         {Copysign(0, -1), Copysign(0, -1)},
 778         {Copysign(0, -1), 0},
 779         {Copysign(0, -1), +Pi},
 780         {Copysign(0, -1), Inf(1)},
 781         {Copysign(0, -1), NaN()},
 782         {0, Inf(-1)},
 783         {0, -Pi},
 784         {0, Copysign(0, -1)},
 785         {0, 0},
 786         {0, +Pi},
 787         {0, Inf(1)},
 788         {0, NaN()},
 789         {+Pi, Inf(-1)},
 790         {+Pi, 0},
 791         {+Pi, Inf(1)},
 792         {+Pi, NaN()},
 793         {Inf(1), Inf(-1)},
 794         {Inf(1), -Pi},
 795         {Inf(1), 0},
 796         {Inf(1), +Pi},
 797         {Inf(1), Inf(1)},
 798         {Inf(1), NaN()},
 799         {NaN(), NaN()},
 800 }
 801 var atan2SC = []float64{
 802         -3 * Pi / 4,     // atan2(-Inf, -Inf)
 803         -Pi / 2,         // atan2(-Inf, -Pi)
 804         -Pi / 2,         // atan2(-Inf, +0)
 805         -Pi / 2,         // atan2(-Inf, +Pi)
 806         -Pi / 4,         // atan2(-Inf, +Inf)
 807         NaN(),           // atan2(-Inf, NaN)
 808         -Pi,             // atan2(-Pi, -Inf)
 809         -Pi / 2,         // atan2(-Pi, +0)
 810         Copysign(0, -1), // atan2(-Pi, Inf)
 811         NaN(),           // atan2(-Pi, NaN)
 812         -Pi,             // atan2(-0, -Inf)
 813         -Pi,             // atan2(-0, -Pi)
 814         -Pi,             // atan2(-0, -0)
 815         Copysign(0, -1), // atan2(-0, +0)
 816         Copysign(0, -1), // atan2(-0, +Pi)
 817         Copysign(0, -1), // atan2(-0, +Inf)
 818         NaN(),           // atan2(-0, NaN)
 819         Pi,              // atan2(+0, -Inf)
 820         Pi,              // atan2(+0, -Pi)
 821         Pi,              // atan2(+0, -0)
 822         0,               // atan2(+0, +0)
 823         0,               // atan2(+0, +Pi)
 824         0,               // atan2(+0, +Inf)
 825         NaN(),           // atan2(+0, NaN)
 826         Pi,              // atan2(+Pi, -Inf)
 827         Pi / 2,          // atan2(+Pi, +0)
 828         0,               // atan2(+Pi, +Inf)
 829         NaN(),           // atan2(+Pi, NaN)
 830         3 * Pi / 4,      // atan2(+Inf, -Inf)
 831         Pi / 2,          // atan2(+Inf, -Pi)
 832         Pi / 2,          // atan2(+Inf, +0)
 833         Pi / 2,          // atan2(+Inf, +Pi)
 834         Pi / 4,          // atan2(+Inf, +Inf)
 835         NaN(),           // atan2(+Inf, NaN)
 836         NaN(),           // atan2(NaN, NaN)
 837 }
 838
 839 var vfcbrtSC = []float64{
 840         Inf(-1),
 841         Copysign(0, -1),
 842         0,
 843         Inf(1),
 844         NaN(),
 845 }
 846 var cbrtSC = []float64{
 847         Inf(-1),
 848         Copysign(0, -1),
 849         0,
 850         Inf(1),
 851         NaN(),
 852 }
 853
 854 var vfceilSC = []float64{
 855         Inf(-1),
 856         Copysign(0, -1),
 857         0,
 858         Inf(1),
 859         NaN(),
 860 }
 861 var ceilSC = []float64{
 862         Inf(-1),
 863         Copysign(0, -1),
 864         0,
 865         Inf(1),
 866         NaN(),
 867 }
 868
 869 var vfcopysignSC = []float64{
 870         Inf(-1),
 871         Inf(1),
 872         NaN(),
 873 }
 874 var copysignSC = []float64{
 875         Inf(-1),
 876         Inf(-1),
 877         NaN(),
 878 }
 879
 880 var vfcosSC = []float64{
 881         Inf(-1),
 882         Inf(1),
 883         NaN(),
 884 }
 885 var cosSC = []float64{
 886         NaN(),
 887         NaN(),
 888         NaN(),
 889 }
 890
 891 var vfcoshSC = []float64{
 892         Inf(-1),
 893         Copysign(0, -1),
 894         0,
 895         Inf(1),
 896         NaN(),
 897 }
 898 var coshSC = []float64{
 899         Inf(1),
 900         1,
 901         1,
 902         Inf(1),
 903         NaN(),
 904 }
 905
 906 var vferfSC = []float64{
 907         Inf(-1),
 908         Copysign(0, -1),
 909         0,
 910         Inf(1),
 911         NaN(),
 912 }
 913 var erfSC = []float64{
 914         -1,
 915         Copysign(0, -1),
 916         0,
 917         1,
 918         NaN(),
 919 }
 920
 921 var vferfcSC = []float64{
 922         Inf(-1),
 923         Inf(1),
 924         NaN(),
 925 }
 926 var erfcSC = []float64{
 927         2,
 928         0,
 929         NaN(),
 930 }
 931
 932 var vfexpSC = []float64{
 933         Inf(-1),
 934         -2000,
 935         2000,
 936         Inf(1),
 937         NaN(),
 938 }
 939 var expSC = []float64{
 940         0,
 941         0,
 942         Inf(1),
 943         Inf(1),
 944         NaN(),
 945 }
 946
 947 var vfexpm1SC = []float64{
 948         Inf(-1),
 949         -710,
 950         Copysign(0, -1),
 951         0,
 952         710,
 953         Inf(1),
 954         NaN(),
 955 }
 956 var expm1SC = []float64{
 957         -1,
 958         -1,
 959         Copysign(0, -1),
 960         0,
 961         Inf(1),
 962         Inf(1),
 963         NaN(),
 964 }
 965
 966 var vffabsSC = []float64{
 967         Inf(-1),
 968         Copysign(0, -1),
 969         0,
 970         Inf(1),
 971         NaN(),
 972 }
 973 var fabsSC = []float64{
 974         Inf(1),
 975         0,
 976         0,
 977         Inf(1),
 978         NaN(),
 979 }
 980
 981 var vffdimSC = [][2]float64{
 982         {Inf(-1), Inf(-1)},
 983         {Inf(-1), Inf(1)},
 984         {Inf(-1), NaN()},
 985         {Copysign(0, -1), Copysign(0, -1)},
 986         {Copysign(0, -1), 0},
 987         {0, Copysign(0, -1)},
 988         {0, 0},
 989         {Inf(1), Inf(-1)},
 990         {Inf(1), Inf(1)},
 991         {Inf(1), NaN()},
 992         {NaN(), Inf(-1)},
 993         {NaN(), Copysign(0, -1)},
 994         {NaN(), 0},
 995         {NaN(), Inf(1)},
 996         {NaN(), NaN()},
 997 }
 998 var nan = Float64frombits(0xFFF8000000000000) // SSE2 DIVSD 0/0
 999 var vffdim2SC = [][2]float64{
1000         {Inf(-1), Inf(-1)},
1001         {Inf(-1), Inf(1)},
1002         {Inf(-1), nan},
1003         {Copysign(0, -1), Copysign(0, -1)},
1004         {Copysign(0, -1), 0},
1005         {0, Copysign(0, -1)},
1006         {0, 0},
1007         {Inf(1), Inf(-1)},
1008         {Inf(1), Inf(1)},
1009         {Inf(1), nan},
1010         {nan, Inf(-1)},
1011         {nan, Copysign(0, -1)},
1012         {nan, 0},
1013         {nan, Inf(1)},
1014         {nan, nan},
1015 }
1016 var fdimSC = []float64{
1017         NaN(),
1018         0,
1019         NaN(),
1020         0,
1021         0,
1022         0,
1023         0,
1024         Inf(1),
1025         NaN(),
1026         NaN(),
1027         NaN(),
1028         NaN(),
1029         NaN(),
1030         NaN(),
1031         NaN(),
1032 }
1033 var fmaxSC = []float64{
1034         Inf(-1),
1035         Inf(1),
1036         NaN(),
1037         Copysign(0, -1),
1038         0,
1039         0,
1040         0,
1041         Inf(1),
1042         Inf(1),
1043         Inf(1),
1044         NaN(),
1045         NaN(),
1046         NaN(),
1047         Inf(1),
1048         NaN(),
1049 }
1050 var fminSC = []float64{
1051         Inf(-1),
1052         Inf(-1),
1053         Inf(-1),
1054         Copysign(0, -1),
1055         Copysign(0, -1),
1056         Copysign(0, -1),
1057         0,
1058         Inf(-1),
1059         Inf(1),
1060         NaN(),
1061         Inf(-1),
1062         NaN(),
1063         NaN(),
1064         NaN(),
1065         NaN(),
1066 }
1067
1068 var vffmodSC = [][2]float64{
1069         {Inf(-1), Inf(-1)},
1070         {Inf(-1), -Pi},
1071         {Inf(-1), 0},
1072         {Inf(-1), Pi},
1073         {Inf(-1), Inf(1)},
1074         {Inf(-1), NaN()},
1075         {-Pi, Inf(-1)},
1076         {-Pi, 0},
1077         {-Pi, Inf(1)},
1078         {-Pi, NaN()},
1079         {Copysign(0, -1), Inf(-1)},
1080         {Copysign(0, -1), 0},
1081         {Copysign(0, -1), Inf(1)},
1082         {Copysign(0, -1), NaN()},
1083         {0, Inf(-1)},
1084         {0, 0},
1085         {0, Inf(1)},
1086         {0, NaN()},
1087         {Pi, Inf(-1)},
1088         {Pi, 0},
1089         {Pi, Inf(1)},
1090         {Pi, NaN()},
1091         {Inf(1), Inf(-1)},
1092         {Inf(1), -Pi},
1093         {Inf(1), 0},
1094         {Inf(1), Pi},
1095         {Inf(1), Inf(1)},
1096         {Inf(1), NaN()},
1097         {NaN(), Inf(-1)},
1098         {NaN(), -Pi},
1099         {NaN(), 0},
1100         {NaN(), Pi},
1101         {NaN(), Inf(1)},
1102         {NaN(), NaN()},
1103 }
1104 var fmodSC = []float64{
1105         NaN(),           // fmod(-Inf, -Inf)
1106         NaN(),           // fmod(-Inf, -Pi)
1107         NaN(),           // fmod(-Inf, 0)
1108         NaN(),           // fmod(-Inf, Pi)
1109         NaN(),           // fmod(-Inf, +Inf)
1110         NaN(),           // fmod(-Inf, NaN)
1111         -Pi,             // fmod(-Pi, -Inf)
1112         NaN(),           // fmod(-Pi, 0)
1113         -Pi,             // fmod(-Pi, +Inf)
1114         NaN(),           // fmod(-Pi, NaN)
1115         Copysign(0, -1), // fmod(-0, -Inf)
1116         NaN(),           // fmod(-0, 0)
1117         Copysign(0, -1), // fmod(-0, Inf)
1118         NaN(),           // fmod(-0, NaN)
1119         0,               // fmod(0, -Inf)
1120         NaN(),           // fmod(0, 0)
1121         0,               // fmod(0, +Inf)
1122         NaN(),           // fmod(0, NaN)
1123         Pi,              // fmod(Pi, -Inf)
1124         NaN(),           // fmod(Pi, 0)
1125         Pi,              // fmod(Pi, +Inf)
1126         NaN(),           // fmod(Pi, NaN)
1127         NaN(),           // fmod(+Inf, -Inf)
1128         NaN(),           // fmod(+Inf, -Pi)
1129         NaN(),           // fmod(+Inf, 0)
1130         NaN(),           // fmod(+Inf, Pi)
1131         NaN(),           // fmod(+Inf, +Inf)
1132         NaN(),           // fmod(+Inf, NaN)
1133         NaN(),           // fmod(NaN, -Inf)
1134         NaN(),           // fmod(NaN, -Pi)
1135         NaN(),           // fmod(NaN, 0)
1136         NaN(),           // fmod(NaN, Pi)
1137         NaN(),           // fmod(NaN, +Inf)
1138         NaN(),           // fmod(NaN, NaN)
1139 }
1140
1141 var vffrexpSC = []float64{
1142         Inf(-1),
1143         Copysign(0, -1),
1144         0,
1145         Inf(1),
1146         NaN(),
1147 }
1148 var frexpSC = []fi{
1149         {Inf(-1), 0},
1150         {Copysign(0, -1), 0},
1151         {0, 0},
1152         {Inf(1), 0},
1153         {NaN(), 0},
1154 }
1155
1156 var vfgammaSC = []float64{
1157         Inf(-1),
1158         -3,
1159         Copysign(0, -1),
1160         0,
1161         Inf(1),
1162         NaN(),
1163 }
1164 var gammaSC = []float64{
1165         NaN(),
1166         NaN(),
1167         Inf(-1),
1168         Inf(1),
1169         Inf(1),
1170         NaN(),
1171 }
1172
1173 var vfhypotSC = [][2]float64{
1174         {Inf(-1), Inf(-1)},
1175         {Inf(-1), 0},
1176         {Inf(-1), Inf(1)},
1177         {Inf(-1), NaN()},
1178         {Copysign(0, -1), Copysign(0, -1)},
1179         {Copysign(0, -1), 0},
1180         {0, Copysign(0, -1)},
1181         {0, 0}, // +0, +0
1182         {0, Inf(-1)},
1183         {0, Inf(1)},
1184         {0, NaN()},
1185         {Inf(1), Inf(-1)},
1186         {Inf(1), 0},
1187         {Inf(1), Inf(1)},
1188         {Inf(1), NaN()},
1189         {NaN(), Inf(-1)},
1190         {NaN(), 0},
1191         {NaN(), Inf(1)},
1192         {NaN(), NaN()},
1193 }
1194 var hypotSC = []float64{
1195         Inf(1),
1196         Inf(1),
1197         Inf(1),
1198         Inf(1),
1199         0,
1200         0,
1201         0,
1202         0,
1203         Inf(1),
1204         Inf(1),
1205         NaN(),
1206         Inf(1),
1207         Inf(1),
1208         Inf(1),
1209         Inf(1),
1210         Inf(1),
1211         NaN(),
1212         Inf(1),
1213         NaN(),
1214 }
1215
1216 var vfilogbSC = []float64{
1217         Inf(-1),
1218         0,
1219         Inf(1),
1220         NaN(),
1221 }
1222 var ilogbSC = []int{
1223         MaxInt32,
1224         MinInt32,
1225         MaxInt32,
1226         MaxInt32,
1227 }
1228
1229 var vfj0SC = []float64{
1230         Inf(-1),
1231         0,
1232         Inf(1),
1233         NaN(),
1234 }
1235 var j0SC = []float64{
1236         0,
1237         1,
1238         0,
1239         NaN(),
1240 }
1241 var j1SC = []float64{
1242         0,
1243         0,
1244         0,
1245         NaN(),
1246 }
1247 var j2SC = []float64{
1248         0,
1249         0,
1250         0,
1251         NaN(),
1252 }
1253 var jM3SC = []float64{
1254         0,
1255         0,
1256         0,
1257         NaN(),
1258 }
1259
1260 var vfldexpSC = []fi{
1261         {0, 0},
1262         {0, -1075},
1263         {0, 1024},
1264         {Copysign(0, -1), 0},
1265         {Copysign(0, -1), -1075},
1266         {Copysign(0, -1), 1024},
1267         {Inf(1), 0},
1268         {Inf(1), -1024},
1269         {Inf(-1), 0},
1270         {Inf(-1), -1024},
1271         {NaN(), -1024},
1272 }
1273 var ldexpSC = []float64{
1274         0,
1275         0,
1276         0,
1277         Copysign(0, -1),
1278         Copysign(0, -1),
1279         Copysign(0, -1),
1280         Inf(1),
1281         Inf(1),
1282         Inf(-1),
1283         Inf(-1),
1284         NaN(),
1285 }
1286
1287 var vflgammaSC = []float64{
1288         Inf(-1),
1289         -3,
1290         0,
1291         1,
1292         2,
1293         Inf(1),
1294         NaN(),
1295 }
1296 var lgammaSC = []fi{
1297         {Inf(-1), 1},
1298         {Inf(1), 1},
1299         {Inf(1), 1},
1300         {0, 1},
1301         {0, 1},
1302         {Inf(1), 1},
1303         {NaN(), 1},
1304 }
1305
1306 var vflogSC = []float64{
1307         Inf(-1),
1308         -Pi,
1309         Copysign(0, -1),
1310         0,
1311         1,
1312         Inf(1),
1313         NaN(),
1314 }
1315 var logSC = []float64{
1316         NaN(),
1317         NaN(),
1318         Inf(-1),
1319         Inf(-1),
1320         0,
1321         Inf(1),
1322         NaN(),
1323 }
1324
1325 var vflogbSC = []float64{
1326         Inf(-1),
1327         0,
1328         Inf(1),
1329         NaN(),
1330 }
1331 var logbSC = []float64{
1332         Inf(1),
1333         Inf(-1),
1334         Inf(1),
1335         NaN(),
1336 }
1337
1338 var vflog1pSC = []float64{
1339         Inf(-1),
1340         -Pi,
1341         -1,
1342         Copysign(0, -1),
1343         0,
1344         Inf(1),
1345         NaN(),
1346 }
1347 var log1pSC = []float64{
1348         NaN(),
1349         NaN(),
1350         Inf(-1),
1351         Copysign(0, -1),
1352         0,
1353         Inf(1),
1354         NaN(),
1355 }
1356
1357 var vfmodfSC = []float64{
1358         Inf(-1),
1359         Copysign(0, -1),
1360         Inf(1),
1361         NaN(),
1362 }
1363 var modfSC = [][2]float64{
1364         {Inf(-1), NaN()}, // [2]float64{Copysign(0, -1), Inf(-1)},
1365         {Copysign(0, -1), Copysign(0, -1)},
1366         {Inf(1), NaN()}, // [2]float64{0, Inf(1)},
1367         {NaN(), NaN()},
1368 }
1369
1370 var vfnextafter32SC = [][2]float32{
1371         {0, 0},
1372         {0, float32(Copysign(0, -1))},
1373         {0, -1},
1374         {0, float32(NaN())},
1375         {float32(Copysign(0, -1)), 1},
1376         {float32(Copysign(0, -1)), 0},
1377         {float32(Copysign(0, -1)), float32(Copysign(0, -1))},
1378         {float32(Copysign(0, -1)), -1},
1379         {float32(NaN()), 0},
1380         {float32(NaN()), float32(NaN())},
1381 }
1382 var nextafter32SC = []float32{
1383         0,
1384         0,
1385         -1.401298464e-45, // Float32frombits(0x80000001)
1386         float32(NaN()),
1387         1.401298464e-45, // Float32frombits(0x00000001)
1388         float32(Copysign(0, -1)),
1389         float32(Copysign(0, -1)),
1390         -1.401298464e-45, // Float32frombits(0x80000001)
1391         float32(NaN()),
1392         float32(NaN()),
1393 }
1394
1395 var vfnextafter64SC = [][2]float64{
1396         {0, 0},
1397         {0, Copysign(0, -1)},
1398         {0, -1},
1399         {0, NaN()},
1400         {Copysign(0, -1), 1},
1401         {Copysign(0, -1), 0},
1402         {Copysign(0, -1), Copysign(0, -1)},
1403         {Copysign(0, -1), -1},
1404         {NaN(), 0},
1405         {NaN(), NaN()},
1406 }
1407 var nextafter64SC = []float64{
1408         0,
1409         0,
1410         -4.9406564584124654418e-324, // Float64frombits(0x8000000000000001)
1411         NaN(),
1412         4.9406564584124654418e-324, // Float64frombits(0x0000000000000001)
1413         Copysign(0, -1),
1414         Copysign(0, -1),
1415         -4.9406564584124654418e-324, // Float64frombits(0x8000000000000001)
1416         NaN(),
1417         NaN(),
1418 }
1419
1420 var vfpowSC = [][2]float64{
1421         {Inf(-1), -Pi},
1422         {Inf(-1), -3},
1423         {Inf(-1), Copysign(0, -1)},
1424         {Inf(-1), 0},
1425         {Inf(-1), 1},
1426         {Inf(-1), 3},
1427         {Inf(-1), Pi},
1428         {Inf(-1), NaN()},
1429
1430         {-Pi, Inf(-1)},
1431         {-Pi, -Pi},
1432         {-Pi, Copysign(0, -1)},
1433         {-Pi, 0},
1434         {-Pi, 1},
1435         {-Pi, Pi},
1436         {-Pi, Inf(1)},
1437         {-Pi, NaN()},
1438
1439         {-1, Inf(-1)},
1440         {-1, Inf(1)},
1441         {-1, NaN()},
1442         {-1 / 2, Inf(-1)},
1443         {-1 / 2, Inf(1)},
1444         {Copysign(0, -1), Inf(-1)},
1445         {Copysign(0, -1), -Pi},
1446         {Copysign(0, -1), -3},
1447         {Copysign(0, -1), 3},
1448         {Copysign(0, -1), Pi},
1449         {Copysign(0, -1), Inf(1)},
1450
1451         {0, Inf(-1)},
1452         {0, -Pi},
1453         {0, -3},
1454         {0, Copysign(0, -1)},
1455         {0, 0},
1456         {0, 3},
1457         {0, Pi},
1458         {0, Inf(1)},
1459         {0, NaN()},
1460
1461         {1 / 2, Inf(-1)},
1462         {1 / 2, Inf(1)},
1463         {1, Inf(-1)},
1464         {1, Inf(1)},
1465         {1, NaN()},
1466
1467         {Pi, Inf(-1)},
1468         {Pi, Copysign(0, -1)},
1469         {Pi, 0},
1470         {Pi, 1},
1471         {Pi, Inf(1)},
1472         {Pi, NaN()},
1473         {Inf(1), -Pi},
1474         {Inf(1), Copysign(0, -1)},
1475         {Inf(1), 0},
1476         {Inf(1), 1},
1477         {Inf(1), Pi},
1478         {Inf(1), NaN()},
1479         {NaN(), -Pi},
1480         {NaN(), Copysign(0, -1)},
1481         {NaN(), 0},
1482         {NaN(), 1},
1483         {NaN(), Pi},
1484         {NaN(), NaN()},
1485 }
1486 var powSC = []float64{
1487         0,               // pow(-Inf, -Pi)
1488         Copysign(0, -1), // pow(-Inf, -3)
1489         1,               // pow(-Inf, -0)
1490         1,               // pow(-Inf, +0)
1491         Inf(-1),         // pow(-Inf, 1)
1492         Inf(-1),         // pow(-Inf, 3)
1493         Inf(1),          // pow(-Inf, Pi)
1494         NaN(),           // pow(-Inf, NaN)
1495         0,               // pow(-Pi, -Inf)
1496         NaN(),           // pow(-Pi, -Pi)
1497         1,               // pow(-Pi, -0)
1498         1,               // pow(-Pi, +0)
1499         -Pi,             // pow(-Pi, 1)
1500         NaN(),           // pow(-Pi, Pi)
1501         Inf(1),          // pow(-Pi, +Inf)
1502         NaN(),           // pow(-Pi, NaN)
1503         1,               // pow(-1, -Inf) IEEE 754-2008
1504         1,               // pow(-1, +Inf) IEEE 754-2008
1505         NaN(),           // pow(-1, NaN)
1506         Inf(1),          // pow(-1/2, -Inf)
1507         0,               // pow(-1/2, +Inf)
1508         Inf(1),          // pow(-0, -Inf)
1509         Inf(1),          // pow(-0, -Pi)
1510         Inf(-1),         // pow(-0, -3) IEEE 754-2008
1511         Copysign(0, -1), // pow(-0, 3) IEEE 754-2008
1512         0,               // pow(-0, +Pi)
1513         0,               // pow(-0, +Inf)
1514         Inf(1),          // pow(+0, -Inf)
1515         Inf(1),          // pow(+0, -Pi)
1516         Inf(1),          // pow(+0, -3)
1517         1,               // pow(+0, -0)
1518         1,               // pow(+0, +0)
1519         0,               // pow(+0, 3)
1520         0,               // pow(+0, +Pi)
1521         0,               // pow(+0, +Inf)
1522         NaN(),           // pow(+0, NaN)
1523         Inf(1),          // pow(1/2, -Inf)
1524         0,               // pow(1/2, +Inf)
1525         1,               // pow(1, -Inf) IEEE 754-2008
1526         1,               // pow(1, +Inf) IEEE 754-2008
1527         1,               // pow(1, NaN) IEEE 754-2008
1528         0,               // pow(+Pi, -Inf)
1529         1,               // pow(+Pi, -0)
1530         1,               // pow(+Pi, +0)
1531         Pi,              // pow(+Pi, 1)
1532         Inf(1),          // pow(+Pi, +Inf)
1533         NaN(),           // pow(+Pi, NaN)
1534         0,               // pow(+Inf, -Pi)
1535         1,               // pow(+Inf, -0)
1536         1,               // pow(+Inf, +0)
1537         Inf(1),          // pow(+Inf, 1)
1538         Inf(1),          // pow(+Inf, Pi)
1539         NaN(),           // pow(+Inf, NaN)
1540         NaN(),           // pow(NaN, -Pi)
1541         1,               // pow(NaN, -0)
1542         1,               // pow(NaN, +0)
1543         NaN(),           // pow(NaN, 1)
1544         NaN(),           // pow(NaN, +Pi)
1545         NaN(),           // pow(NaN, NaN)
1546 }
1547
1548 var vfpow10SC = []int{
1549         MinInt32,
1550         MaxInt32,
1551         -325,
1552         309,
1553 }
1554
1555 var pow10SC = []float64{
1556         0,      // pow10(MinInt32)
1557         Inf(1), // pow10(MaxInt32)
1558         0,      // pow10(-325)
1559         Inf(1), // pow10(309)
1560 }
1561
1562 var vfsignbitSC = []float64{
1563         Inf(-1),
1564         Copysign(0, -1),
1565         0,
1566         Inf(1),
1567         NaN(),
1568 }
1569 var signbitSC = []bool{
1570         true,
1571         true,
1572         false,
1573         false,
1574         false,
1575 }
1576
1577 var vfsinSC = []float64{
1578         Inf(-1),
1579         Copysign(0, -1),
1580         0,
1581         Inf(1),
1582         NaN(),
1583 }
1584 var sinSC = []float64{
1585         NaN(),
1586         Copysign(0, -1),
1587         0,
1588         NaN(),
1589         NaN(),
1590 }
1591
1592 var vfsinhSC = []float64{
1593         Inf(-1),
1594         Copysign(0, -1),
1595         0,
1596         Inf(1),
1597         NaN(),
1598 }
1599 var sinhSC = []float64{
1600         Inf(-1),
1601         Copysign(0, -1),
1602         0,
1603         Inf(1),
1604         NaN(),
1605 }
1606
1607 var vfsqrtSC = []float64{
1608         Inf(-1),
1609         -Pi,
1610         Copysign(0, -1),
1611         0,
1612         Inf(1),
1613         NaN(),
1614 }
1615 var sqrtSC = []float64{
1616         NaN(),
1617         NaN(),
1618         Copysign(0, -1),
1619         0,
1620         Inf(1),
1621         NaN(),
1622 }
1623
1624 var vftanhSC = []float64{
1625         Inf(-1),
1626         Copysign(0, -1),
1627         0,
1628         Inf(1),
1629         NaN(),
1630 }
1631 var tanhSC = []float64{
1632         -1,
1633         Copysign(0, -1),
1634         0,
1635         1,
1636         NaN(),
1637 }
1638
1639 var vfy0SC = []float64{
1640         Inf(-1),
1641         0,
1642         Inf(1),
1643         NaN(),
1644 }
1645 var y0SC = []float64{
1646         NaN(),
1647         Inf(-1),
1648         0,
1649         NaN(),
1650 }
1651 var y1SC = []float64{
1652         NaN(),
1653         Inf(-1),
1654         0,
1655         NaN(),
1656 }
1657 var y2SC = []float64{
1658         NaN(),
1659         Inf(-1),
1660         0,
1661         NaN(),
1662 }
1663 var yM3SC = []float64{
1664         NaN(),
1665         Inf(1),
1666         0,
1667         NaN(),
1668 }
1669
1670 // arguments and expected results for boundary cases
1671 const (
1672         SmallestNormalFloat64   = 2.2250738585072014e-308 // 2**-1022
1673         LargestSubnormalFloat64 = SmallestNormalFloat64 - SmallestNonzeroFloat64
1674 )
1675
1676 var vffrexpBC = []float64{
1677         SmallestNormalFloat64,
1678         LargestSubnormalFloat64,
1679         SmallestNonzeroFloat64,
1680         MaxFloat64,
1681         -SmallestNormalFloat64,
1682         -LargestSubnormalFloat64,
1683         -SmallestNonzeroFloat64,
1684         -MaxFloat64,
1685 }
1686 var frexpBC = []fi{
1687         {0.5, -1021},
1688         {0.99999999999999978, -1022},
1689         {0.5, -1073},
1690         {0.99999999999999989, 1024},
1691         {-0.5, -1021},
1692         {-0.99999999999999978, -1022},
1693         {-0.5, -1073},
1694         {-0.99999999999999989, 1024},
1695 }
1696
1697 var vfldexpBC = []fi{
1698         {SmallestNormalFloat64, -52},
1699         {LargestSubnormalFloat64, -51},
1700         {SmallestNonzeroFloat64, 1074},
1701         {MaxFloat64, -(1023 + 1074)},
1702         {1, -1075},
1703         {-1, -1075},
1704         {1, 1024},
1705         {-1, 1024},
1706 }
1707 var ldexpBC = []float64{
1708         SmallestNonzeroFloat64,
1709         1e-323, // 2**-1073
1710         1,
1711         1e-323, // 2**-1073
1712         0,
1713         Copysign(0, -1),
1714         Inf(1),
1715         Inf(-1),
1716 }
1717
1718 var logbBC = []float64{
1719         -1022,
1720         -1023,
1721         -1074,
1722         1023,
1723         -1022,
1724         -1023,
1725         -1074,
1726         1023,
1727 }
1728
1729 func tolerance(a, b, e float64) bool {
1730         d := a - b
1731         if d < 0 {
1732                 d = -d
1733         }
1734
1735         // note: b is correct (expected) value, a is actual value.
1736         // make error tolerance a fraction of b, not a.
1737         if b != 0 {
1738                 e = e * b
1739                 if e < 0 {
1740                         e = -e
1741                 }
1742         }
1743         return d < e
1744 }
1745 func kindaclose(a, b float64) bool { return tolerance(a, b, 1e-8) }
1746 func close(a, b float64) bool      { return tolerance(a, b, 1e-14) }
1747 func veryclose(a, b float64) bool  { return tolerance(a, b, 4e-16) }
1748 func soclose(a, b, e float64) bool { return tolerance(a, b, e) }
1749 func alike(a, b float64) bool {
1750         switch {
1751         case IsNaN(a) && IsNaN(b):
1752                 return true
1753         case a == b:
1754                 return Signbit(a) == Signbit(b)
1755         }
1756         return false
1757 }
1758
1759 func TestNaN(t *testing.T) {
1760         f64 := NaN()
1761         if f64 == f64 {
1762                 t.Fatalf("NaN() returns %g, expected NaN", f64)
1763         }
1764         f32 := float32(f64)
1765         if f32 == f32 {
1766                 t.Fatalf("float32(NaN()) is %g, expected NaN", f32)
1767         }
1768 }
1769
1770 func TestAcos(t *testing.T) {
1771         for i := 0; i < len(vf); i++ {
1772                 a := vf[i] / 10
1773                 if f := Acos(a); !close(acos[i], f) {
1774                         t.Errorf("Acos(%g) = %g, want %g", a, f, acos[i])
1775                 }
1776         }
1777         for i := 0; i < len(vfacosSC); i++ {
1778                 if f := Acos(vfacosSC[i]); !alike(acosSC[i], f) {
1779                         t.Errorf("Acos(%g) = %g, want %g", vfacosSC[i], f, acosSC[i])
1780                 }
1781         }
1782 }
1783
1784 func TestAcosh(t *testing.T) {
1785         for i := 0; i < len(vf); i++ {
1786                 a := 1 + Abs(vf[i])
1787                 if f := Acosh(a); !veryclose(acosh[i], f) {
1788                         t.Errorf("Acosh(%g) = %g, want %g", a, f, acosh[i])
1789                 }
1790         }
1791         for i := 0; i < len(vfacoshSC); i++ {
1792                 if f := Acosh(vfacoshSC[i]); !alike(acoshSC[i], f) {
1793                         t.Errorf("Acosh(%g) = %g, want %g", vfacoshSC[i], f, acoshSC[i])
1794                 }
1795         }
1796 }
1797
1798 func TestAsin(t *testing.T) {
1799         for i := 0; i < len(vf); i++ {
1800                 a := vf[i] / 10
1801                 if f := Asin(a); !veryclose(asin[i], f) {
1802                         t.Errorf("Asin(%g) = %g, want %g", a, f, asin[i])
1803                 }
1804         }
1805         for i := 0; i < len(vfasinSC); i++ {
1806                 if f := Asin(vfasinSC[i]); !alike(asinSC[i], f) {
1807                         t.Errorf("Asin(%g) = %g, want %g", vfasinSC[i], f, asinSC[i])
1808                 }
1809         }
1810 }
1811
1812 func TestAsinh(t *testing.T) {
1813         for i := 0; i < len(vf); i++ {
1814                 if f := Asinh(vf[i]); !veryclose(asinh[i], f) {
1815                         t.Errorf("Asinh(%g) = %g, want %g", vf[i], f, asinh[i])
1816                 }
1817         }
1818         for i := 0; i < len(vfasinhSC); i++ {
1819                 if f := Asinh(vfasinhSC[i]); !alike(asinhSC[i], f) {
1820                         t.Errorf("Asinh(%g) = %g, want %g", vfasinhSC[i], f, asinhSC[i])
1821                 }
1822         }
1823 }
1824
1825 func TestAtan(t *testing.T) {
1826         for i := 0; i < len(vf); i++ {
1827                 if f := Atan(vf[i]); !veryclose(atan[i], f) {
1828                         t.Errorf("Atan(%g) = %g, want %g", vf[i], f, atan[i])
1829                 }
1830         }
1831         for i := 0; i < len(vfatanSC); i++ {
1832                 if f := Atan(vfatanSC[i]); !alike(atanSC[i], f) {
1833                         t.Errorf("Atan(%g) = %g, want %g", vfatanSC[i], f, atanSC[i])
1834                 }
1835         }
1836 }
1837
1838 func TestAtanh(t *testing.T) {
1839         for i := 0; i < len(vf); i++ {
1840                 a := vf[i] / 10
1841                 if f := Atanh(a); !veryclose(atanh[i], f) {
1842                         t.Errorf("Atanh(%g) = %g, want %g", a, f, atanh[i])
1843                 }
1844         }
1845         for i := 0; i < len(vfatanhSC); i++ {
1846                 if f := Atanh(vfatanhSC[i]); !alike(atanhSC[i], f) {
1847                         t.Errorf("Atanh(%g) = %g, want %g", vfatanhSC[i], f, atanhSC[i])
1848                 }
1849         }
1850 }
1851
1852 func TestAtan2(t *testing.T) {
1853         for i := 0; i < len(vf); i++ {
1854                 if f := Atan2(10, vf[i]); !veryclose(atan2[i], f) {
1855                         t.Errorf("Atan2(10, %g) = %g, want %g", vf[i], f, atan2[i])
1856                 }
1857         }
1858         for i := 0; i < len(vfatan2SC); i++ {
1859                 if f := Atan2(vfatan2SC[i][0], vfatan2SC[i][1]); !alike(atan2SC[i], f) {
1860                         t.Errorf("Atan2(%g, %g) = %g, want %g", vfatan2SC[i][0], vfatan2SC[i][1], f, atan2SC[i])
1861                 }
1862         }
1863 }
1864
1865 func TestCbrt(t *testing.T) {
1866         for i := 0; i < len(vf); i++ {
1867                 if f := Cbrt(vf[i]); !veryclose(cbrt[i], f) {
1868                         t.Errorf("Cbrt(%g) = %g, want %g", vf[i], f, cbrt[i])
1869                 }
1870         }
1871         for i := 0; i < len(vfcbrtSC); i++ {
1872                 if f := Cbrt(vfcbrtSC[i]); !alike(cbrtSC[i], f) {
1873                         t.Errorf("Cbrt(%g) = %g, want %g", vfcbrtSC[i], f, cbrtSC[i])
1874                 }
1875         }
1876 }
1877
1878 func TestCeil(t *testing.T) {
1879         for i := 0; i < len(vf); i++ {
1880                 if f := Ceil(vf[i]); ceil[i] != f {
1881                         t.Errorf("Ceil(%g) = %g, want %g", vf[i], f, ceil[i])
1882                 }
1883         }
1884         for i := 0; i < len(vfceilSC); i++ {
1885                 if f := Ceil(vfceilSC[i]); !alike(ceilSC[i], f) {
1886                         t.Errorf("Ceil(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
1887                 }
1888         }
1889 }
1890
1891 func TestCopysign(t *testing.T) {
1892         for i := 0; i < len(vf); i++ {
1893                 if f := Copysign(vf[i], -1); copysign[i] != f {
1894                         t.Errorf("Copysign(%g, -1) = %g, want %g", vf[i], f, copysign[i])
1895                 }
1896         }
1897         for i := 0; i < len(vf); i++ {
1898                 if f := Copysign(vf[i], 1); -copysign[i] != f {
1899                         t.Errorf("Copysign(%g, 1) = %g, want %g", vf[i], f, -copysign[i])
1900                 }
1901         }
1902         for i := 0; i < len(vfcopysignSC); i++ {
1903                 if f := Copysign(vfcopysignSC[i], -1); !alike(copysignSC[i], f) {
1904                         t.Errorf("Copysign(%g, -1) = %g, want %g", vfcopysignSC[i], f, copysignSC[i])
1905                 }
1906         }
1907 }
1908
1909 func TestCos(t *testing.T) {
1910         for i := 0; i < len(vf); i++ {
1911                 if f := Cos(vf[i]); !veryclose(cos[i], f) {
1912                         t.Errorf("Cos(%g) = %g, want %g", vf[i], f, cos[i])
1913                 }
1914         }
1915         for i := 0; i < len(vfcosSC); i++ {
1916                 if f := Cos(vfcosSC[i]); !alike(cosSC[i], f) {
1917                         t.Errorf("Cos(%g) = %g, want %g", vfcosSC[i], f, cosSC[i])
1918                 }
1919         }
1920 }
1921
1922 func TestCosh(t *testing.T) {
1923         for i := 0; i < len(vf); i++ {
1924                 if f := Cosh(vf[i]); !close(cosh[i], f) {
1925                         t.Errorf("Cosh(%g) = %g, want %g", vf[i], f, cosh[i])
1926                 }
1927         }
1928         for i := 0; i < len(vfcoshSC); i++ {
1929                 if f := Cosh(vfcoshSC[i]); !alike(coshSC[i], f) {
1930                         t.Errorf("Cosh(%g) = %g, want %g", vfcoshSC[i], f, coshSC[i])
1931                 }
1932         }
1933 }
1934
1935 func TestErf(t *testing.T) {
1936         for i := 0; i < len(vf); i++ {
1937                 a := vf[i] / 10
1938                 if f := Erf(a); !veryclose(erf[i], f) {
1939                         t.Errorf("Erf(%g) = %g, want %g", a, f, erf[i])
1940                 }
1941         }
1942         for i := 0; i < len(vferfSC); i++ {
1943                 if f := Erf(vferfSC[i]); !alike(erfSC[i], f) {
1944                         t.Errorf("Erf(%g) = %g, want %g", vferfSC[i], f, erfSC[i])
1945                 }
1946         }
1947 }
1948
1949 func TestErfc(t *testing.T) {
1950         for i := 0; i < len(vf); i++ {
1951                 a := vf[i] / 10
1952                 if f := Erfc(a); !veryclose(erfc[i], f) {
1953                         t.Errorf("Erfc(%g) = %g, want %g", a, f, erfc[i])
1954                 }
1955         }
1956         for i := 0; i < len(vferfcSC); i++ {
1957                 if f := Erfc(vferfcSC[i]); !alike(erfcSC[i], f) {
1958                         t.Errorf("Erfc(%g) = %g, want %g", vferfcSC[i], f, erfcSC[i])
1959                 }
1960         }
1961 }
1962
1963 func TestExp(t *testing.T) {
1964         testExp(t, Exp, "Exp")
1965         testExp(t, ExpGo, "ExpGo")
1966 }
1967
1968 func testExp(t *testing.T, Exp func(float64) float64, name string) {
1969         for i := 0; i < len(vf); i++ {
1970                 if f := Exp(vf[i]); !close(exp[i], f) {
1971                         t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp[i])
1972                 }
1973         }
1974         for i := 0; i < len(vfexpSC); i++ {
1975                 if f := Exp(vfexpSC[i]); !alike(expSC[i], f) {
1976                         t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i])
1977                 }
1978         }
1979 }
1980
1981 func TestExpm1(t *testing.T) {
1982         for i := 0; i < len(vf); i++ {
1983                 a := vf[i] / 100
1984                 if f := Expm1(a); !veryclose(expm1[i], f) {
1985                         t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1[i])
1986                 }
1987         }
1988         for i := 0; i < len(vfexpm1SC); i++ {
1989                 if f := Expm1(vfexpm1SC[i]); !alike(expm1SC[i], f) {
1990                         t.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC[i], f, expm1SC[i])
1991                 }
1992         }
1993 }
1994
1995 func TestExp2(t *testing.T) {
1996         testExp2(t, Exp2, "Exp2")
1997         testExp2(t, Exp2Go, "Exp2Go")
1998 }
1999
2000 func testExp2(t *testing.T, Exp2 func(float64) float64, name string) {
2001         for i := 0; i < len(vf); i++ {
2002                 if f := Exp2(vf[i]); !close(exp2[i], f) {
2003                         t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp2[i])
2004                 }
2005         }
2006         for i := 0; i < len(vfexpSC); i++ {
2007                 if f := Exp2(vfexpSC[i]); !alike(expSC[i], f) {
2008                         t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i])
2009                 }
2010         }
2011         for n := -1074; n < 1024; n++ {
2012                 f := Exp2(float64(n))
2013                 vf := Ldexp(1, n)
2014                 if f != vf {
2015                         t.Errorf("%s(%d) = %g, want %g", name, n, f, vf)
2016                 }
2017         }
2018 }
2019
2020 func TestAbs(t *testing.T) {
2021         for i := 0; i < len(vf); i++ {
2022                 if f := Abs(vf[i]); fabs[i] != f {
2023                         t.Errorf("Abs(%g) = %g, want %g", vf[i], f, fabs[i])
2024                 }
2025         }
2026         for i := 0; i < len(vffabsSC); i++ {
2027                 if f := Abs(vffabsSC[i]); !alike(fabsSC[i], f) {
2028                         t.Errorf("Abs(%g) = %g, want %g", vffabsSC[i], f, fabsSC[i])
2029                 }
2030         }
2031 }
2032
2033 func TestDim(t *testing.T) {
2034         for i := 0; i < len(vf); i++ {
2035                 if f := Dim(vf[i], 0); fdim[i] != f {
2036                         t.Errorf("Dim(%g, %g) = %g, want %g", vf[i], 0.0, f, fdim[i])
2037                 }
2038         }
2039         for i := 0; i < len(vffdimSC); i++ {
2040                 if f := Dim(vffdimSC[i][0], vffdimSC[i][1]); !alike(fdimSC[i], f) {
2041                         t.Errorf("Dim(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fdimSC[i])
2042                 }
2043         }
2044         for i := 0; i < len(vffdim2SC); i++ {
2045                 if f := Dim(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fdimSC[i], f) {
2046                         t.Errorf("Dim(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fdimSC[i])
2047                 }
2048         }
2049 }
2050
2051 func TestFloor(t *testing.T) {
2052         for i := 0; i < len(vf); i++ {
2053                 if f := Floor(vf[i]); floor[i] != f {
2054                         t.Errorf("Floor(%g) = %g, want %g", vf[i], f, floor[i])
2055                 }
2056         }
2057         for i := 0; i < len(vfceilSC); i++ {
2058                 if f := Floor(vfceilSC[i]); !alike(ceilSC[i], f) {
2059                         t.Errorf("Floor(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
2060                 }
2061         }
2062 }
2063
2064 func TestMax(t *testing.T) {
2065         for i := 0; i < len(vf); i++ {
2066                 if f := Max(vf[i], ceil[i]); ceil[i] != f {
2067                         t.Errorf("Max(%g, %g) = %g, want %g", vf[i], ceil[i], f, ceil[i])
2068                 }
2069         }
2070         for i := 0; i < len(vffdimSC); i++ {
2071                 if f := Max(vffdimSC[i][0], vffdimSC[i][1]); !alike(fmaxSC[i], f) {
2072                         t.Errorf("Max(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fmaxSC[i])
2073                 }
2074         }
2075         for i := 0; i < len(vffdim2SC); i++ {
2076                 if f := Max(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fmaxSC[i], f) {
2077                         t.Errorf("Max(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fmaxSC[i])
2078                 }
2079         }
2080 }
2081
2082 func TestMin(t *testing.T) {
2083         for i := 0; i < len(vf); i++ {
2084                 if f := Min(vf[i], floor[i]); floor[i] != f {
2085                         t.Errorf("Min(%g, %g) = %g, want %g", vf[i], floor[i], f, floor[i])
2086                 }
2087         }
2088         for i := 0; i < len(vffdimSC); i++ {
2089                 if f := Min(vffdimSC[i][0], vffdimSC[i][1]); !alike(fminSC[i], f) {
2090                         t.Errorf("Min(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fminSC[i])
2091                 }
2092         }
2093         for i := 0; i < len(vffdim2SC); i++ {
2094                 if f := Min(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fminSC[i], f) {
2095                         t.Errorf("Min(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fminSC[i])
2096                 }
2097         }
2098 }
2099
2100 func TestMod(t *testing.T) {
2101         for i := 0; i < len(vf); i++ {
2102                 if f := Mod(10, vf[i]); fmod[i] != f {
2103                         t.Errorf("Mod(10, %g) = %g, want %g", vf[i], f, fmod[i])
2104                 }
2105         }
2106         for i := 0; i < len(vffmodSC); i++ {
2107                 if f := Mod(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
2108                         t.Errorf("Mod(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
2109                 }
2110         }
2111 }
2112
2113 func TestFrexp(t *testing.T) {
2114         for i := 0; i < len(vf); i++ {
2115                 if f, j := Frexp(vf[i]); !veryclose(frexp[i].f, f) || frexp[i].i != j {
2116                         t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vf[i], f, j, frexp[i].f, frexp[i].i)
2117                 }
2118         }
2119         for i := 0; i < len(vffrexpSC); i++ {
2120                 if f, j := Frexp(vffrexpSC[i]); !alike(frexpSC[i].f, f) || frexpSC[i].i != j {
2121                         t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpSC[i], f, j, frexpSC[i].f, frexpSC[i].i)
2122                 }
2123         }
2124         for i := 0; i < len(vffrexpBC); i++ {
2125                 if f, j := Frexp(vffrexpBC[i]); !alike(frexpBC[i].f, f) || frexpBC[i].i != j {
2126                         t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpBC[i], f, j, frexpBC[i].f, frexpBC[i].i)
2127                 }
2128         }
2129 }
2130
2131 func TestGamma(t *testing.T) {
2132         for i := 0; i < len(vf); i++ {
2133                 if f := Gamma(vf[i]); !close(gamma[i], f) {
2134                         t.Errorf("Gamma(%g) = %g, want %g", vf[i], f, gamma[i])
2135                 }
2136         }
2137         for i := 0; i < len(vfgammaSC); i++ {
2138                 if f := Gamma(vfgammaSC[i]); !alike(gammaSC[i], f) {
2139                         t.Errorf("Gamma(%g) = %g, want %g", vfgammaSC[i], f, gammaSC[i])
2140                 }
2141         }
2142 }
2143
2144 func TestHypot(t *testing.T) {
2145         for i := 0; i < len(vf); i++ {
2146                 a := Abs(1e200 * tanh[i] * Sqrt(2))
2147                 if f := Hypot(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
2148                         t.Errorf("Hypot(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
2149                 }
2150         }
2151         for i := 0; i < len(vfhypotSC); i++ {
2152                 if f := Hypot(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) {
2153                         t.Errorf("Hypot(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i])
2154                 }
2155         }
2156 }
2157
2158 func TestHypotGo(t *testing.T) {
2159         for i := 0; i < len(vf); i++ {
2160                 a := Abs(1e200 * tanh[i] * Sqrt(2))
2161                 if f := HypotGo(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
2162                         t.Errorf("HypotGo(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
2163                 }
2164         }
2165         for i := 0; i < len(vfhypotSC); i++ {
2166                 if f := HypotGo(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) {
2167                         t.Errorf("HypotGo(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i])
2168                 }
2169         }
2170 }
2171
2172 func TestIlogb(t *testing.T) {
2173         for i := 0; i < len(vf); i++ {
2174                 a := frexp[i].i - 1 // adjust because fr in the interval [½, 1)
2175                 if e := Ilogb(vf[i]); a != e {
2176                         t.Errorf("Ilogb(%g) = %d, want %d", vf[i], e, a)
2177                 }
2178         }
2179         for i := 0; i < len(vflogbSC); i++ {
2180                 if e := Ilogb(vflogbSC[i]); ilogbSC[i] != e {
2181                         t.Errorf("Ilogb(%g) = %d, want %d", vflogbSC[i], e, ilogbSC[i])
2182                 }
2183         }
2184         for i := 0; i < len(vffrexpBC); i++ {
2185                 if e := Ilogb(vffrexpBC[i]); int(logbBC[i]) != e {
2186                         t.Errorf("Ilogb(%g) = %d, want %d", vffrexpBC[i], e, int(logbBC[i]))
2187                 }
2188         }
2189 }
2190
2191 func TestJ0(t *testing.T) {
2192         for i := 0; i < len(vf); i++ {
2193                 if f := J0(vf[i]); !soclose(j0[i], f, 4e-14) {
2194                         t.Errorf("J0(%g) = %g, want %g", vf[i], f, j0[i])
2195                 }
2196         }
2197         for i := 0; i < len(vfj0SC); i++ {
2198                 if f := J0(vfj0SC[i]); !alike(j0SC[i], f) {
2199                         t.Errorf("J0(%g) = %g, want %g", vfj0SC[i], f, j0SC[i])
2200                 }
2201         }
2202 }
2203
2204 func TestJ1(t *testing.T) {
2205         for i := 0; i < len(vf); i++ {
2206                 if f := J1(vf[i]); !close(j1[i], f) {
2207                         t.Errorf("J1(%g) = %g, want %g", vf[i], f, j1[i])
2208                 }
2209         }
2210         for i := 0; i < len(vfj0SC); i++ {
2211                 if f := J1(vfj0SC[i]); !alike(j1SC[i], f) {
2212                         t.Errorf("J1(%g) = %g, want %g", vfj0SC[i], f, j1SC[i])
2213                 }
2214         }
2215 }
2216
2217 func TestJn(t *testing.T) {
2218         for i := 0; i < len(vf); i++ {
2219                 if f := Jn(2, vf[i]); !close(j2[i], f) {
2220                         t.Errorf("Jn(2, %g) = %g, want %g", vf[i], f, j2[i])
2221                 }
2222                 if f := Jn(-3, vf[i]); !close(jM3[i], f) {
2223                         t.Errorf("Jn(-3, %g) = %g, want %g", vf[i], f, jM3[i])
2224                 }
2225         }
2226         for i := 0; i < len(vfj0SC); i++ {
2227                 if f := Jn(2, vfj0SC[i]); !alike(j2SC[i], f) {
2228                         t.Errorf("Jn(2, %g) = %g, want %g", vfj0SC[i], f, j2SC[i])
2229                 }
2230                 if f := Jn(-3, vfj0SC[i]); !alike(jM3SC[i], f) {
2231                         t.Errorf("Jn(-3, %g) = %g, want %g", vfj0SC[i], f, jM3SC[i])
2232                 }
2233         }
2234 }
2235
2236 func TestLdexp(t *testing.T) {
2237         for i := 0; i < len(vf); i++ {
2238                 if f := Ldexp(frexp[i].f, frexp[i].i); !veryclose(vf[i], f) {
2239                         t.Errorf("Ldexp(%g, %d) = %g, want %g", frexp[i].f, frexp[i].i, f, vf[i])
2240                 }
2241         }
2242         for i := 0; i < len(vffrexpSC); i++ {
2243                 if f := Ldexp(frexpSC[i].f, frexpSC[i].i); !alike(vffrexpSC[i], f) {
2244                         t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpSC[i].f, frexpSC[i].i, f, vffrexpSC[i])
2245                 }
2246         }
2247         for i := 0; i < len(vfldexpSC); i++ {
2248                 if f := Ldexp(vfldexpSC[i].f, vfldexpSC[i].i); !alike(ldexpSC[i], f) {
2249                         t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpSC[i].f, vfldexpSC[i].i, f, ldexpSC[i])
2250                 }
2251         }
2252         for i := 0; i < len(vffrexpBC); i++ {
2253                 if f := Ldexp(frexpBC[i].f, frexpBC[i].i); !alike(vffrexpBC[i], f) {
2254                         t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpBC[i].f, frexpBC[i].i, f, vffrexpBC[i])
2255                 }
2256         }
2257         for i := 0; i < len(vfldexpBC); i++ {
2258                 if f := Ldexp(vfldexpBC[i].f, vfldexpBC[i].i); !alike(ldexpBC[i], f) {
2259                         t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpBC[i].f, vfldexpBC[i].i, f, ldexpBC[i])
2260                 }
2261         }
2262 }
2263
2264 func TestLgamma(t *testing.T) {
2265         for i := 0; i < len(vf); i++ {
2266                 if f, s := Lgamma(vf[i]); !close(lgamma[i].f, f) || lgamma[i].i != s {
2267                         t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vf[i], f, s, lgamma[i].f, lgamma[i].i)
2268                 }
2269         }
2270         for i := 0; i < len(vflgammaSC); i++ {
2271                 if f, s := Lgamma(vflgammaSC[i]); !alike(lgammaSC[i].f, f) || lgammaSC[i].i != s {
2272                         t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vflgammaSC[i], f, s, lgammaSC[i].f, lgammaSC[i].i)
2273                 }
2274         }
2275 }
2276
2277 func TestLog(t *testing.T) {
2278         for i := 0; i < len(vf); i++ {
2279                 a := Abs(vf[i])
2280                 if f := Log(a); log[i] != f {
2281                         t.Errorf("Log(%g) = %g, want %g", a, f, log[i])
2282                 }
2283         }
2284         if f := Log(10); f != Ln10 {
2285                 t.Errorf("Log(%g) = %g, want %g", 10.0, f, Ln10)
2286         }
2287         for i := 0; i < len(vflogSC); i++ {
2288                 if f := Log(vflogSC[i]); !alike(logSC[i], f) {
2289                         t.Errorf("Log(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2290                 }
2291         }
2292 }
2293
2294 func TestLogb(t *testing.T) {
2295         for i := 0; i < len(vf); i++ {
2296                 if f := Logb(vf[i]); logb[i] != f {
2297                         t.Errorf("Logb(%g) = %g, want %g", vf[i], f, logb[i])
2298                 }
2299         }
2300         for i := 0; i < len(vflogbSC); i++ {
2301                 if f := Logb(vflogbSC[i]); !alike(logbSC[i], f) {
2302                         t.Errorf("Logb(%g) = %g, want %g", vflogbSC[i], f, logbSC[i])
2303                 }
2304         }
2305         for i := 0; i < len(vffrexpBC); i++ {
2306                 if f := Logb(vffrexpBC[i]); !alike(logbBC[i], f) {
2307                         t.Errorf("Logb(%g) = %g, want %g", vffrexpBC[i], f, logbBC[i])
2308                 }
2309         }
2310 }
2311
2312 func TestLog10(t *testing.T) {
2313         for i := 0; i < len(vf); i++ {
2314                 a := Abs(vf[i])
2315                 if f := Log10(a); !veryclose(log10[i], f) {
2316                         t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i])
2317                 }
2318         }
2319         if f := Log10(E); f != Log10E {
2320                 t.Errorf("Log10(%g) = %g, want %g", E, f, Log10E)
2321         }
2322         for i := 0; i < len(vflogSC); i++ {
2323                 if f := Log10(vflogSC[i]); !alike(logSC[i], f) {
2324                         t.Errorf("Log10(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2325                 }
2326         }
2327 }
2328
2329 func TestLog1p(t *testing.T) {
2330         for i := 0; i < len(vf); i++ {
2331                 a := vf[i] / 100
2332                 if f := Log1p(a); !veryclose(log1p[i], f) {
2333                         t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i])
2334                 }
2335         }
2336         a := 9.0
2337         if f := Log1p(a); f != Ln10 {
2338                 t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10)
2339         }
2340         for i := 0; i < len(vflogSC); i++ {
2341                 if f := Log1p(vflog1pSC[i]); !alike(log1pSC[i], f) {
2342                         t.Errorf("Log1p(%g) = %g, want %g", vflog1pSC[i], f, log1pSC[i])
2343                 }
2344         }
2345 }
2346
2347 func TestLog2(t *testing.T) {
2348         for i := 0; i < len(vf); i++ {
2349                 a := Abs(vf[i])
2350                 if f := Log2(a); !veryclose(log2[i], f) {
2351                         t.Errorf("Log2(%g) = %g, want %g", a, f, log2[i])
2352                 }
2353         }
2354         if f := Log2(E); f != Log2E {
2355                 t.Errorf("Log2(%g) = %g, want %g", E, f, Log2E)
2356         }
2357         for i := 0; i < len(vflogSC); i++ {
2358                 if f := Log2(vflogSC[i]); !alike(logSC[i], f) {
2359                         t.Errorf("Log2(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2360                 }
2361         }
2362         for i := -1074; i <= 1023; i++ {
2363                 f := Ldexp(1, i)
2364                 l := Log2(f)
2365                 if l != float64(i) {
2366                         t.Errorf("Log2(2**%d) = %g, want %d", i, l, i)
2367                 }
2368         }
2369 }
2370
2371 func TestModf(t *testing.T) {
2372         for i := 0; i < len(vf); i++ {
2373                 if f, g := Modf(vf[i]); !veryclose(modf[i][0], f) || !veryclose(modf[i][1], g) {
2374                         t.Errorf("Modf(%g) = %g, %g, want %g, %g", vf[i], f, g, modf[i][0], modf[i][1])
2375                 }
2376         }
2377         for i := 0; i < len(vfmodfSC); i++ {
2378                 if f, g := Modf(vfmodfSC[i]); !alike(modfSC[i][0], f) || !alike(modfSC[i][1], g) {
2379                         t.Errorf("Modf(%g) = %g, %g, want %g, %g", vfmodfSC[i], f, g, modfSC[i][0], modfSC[i][1])
2380                 }
2381         }
2382 }
2383
2384 func TestNextafter32(t *testing.T) {
2385         for i := 0; i < len(vf); i++ {
2386                 vfi := float32(vf[i])
2387                 if f := Nextafter32(vfi, 10); nextafter32[i] != f {
2388                         t.Errorf("Nextafter32(%g, %g) = %g want %g", vfi, 10.0, f, nextafter32[i])
2389                 }
2390         }
2391         for i := 0; i < len(vfnextafter32SC); i++ {
2392                 if f := Nextafter32(vfnextafter32SC[i][0], vfnextafter32SC[i][1]); !alike(float64(nextafter32SC[i]), float64(f)) {
2393                         t.Errorf("Nextafter32(%g, %g) = %g want %g", vfnextafter32SC[i][0], vfnextafter32SC[i][1], f, nextafter32SC[i])
2394                 }
2395         }
2396 }
2397
2398 func TestNextafter64(t *testing.T) {
2399         for i := 0; i < len(vf); i++ {
2400                 if f := Nextafter(vf[i], 10); nextafter64[i] != f {
2401                         t.Errorf("Nextafter64(%g, %g) = %g want %g", vf[i], 10.0, f, nextafter64[i])
2402                 }
2403         }
2404         for i := 0; i < len(vfnextafter64SC); i++ {
2405                 if f := Nextafter(vfnextafter64SC[i][0], vfnextafter64SC[i][1]); !alike(nextafter64SC[i], f) {
2406                         t.Errorf("Nextafter64(%g, %g) = %g want %g", vfnextafter64SC[i][0], vfnextafter64SC[i][1], f, nextafter64SC[i])
2407                 }
2408         }
2409 }
2410
2411 func TestPow(t *testing.T) {
2412         for i := 0; i < len(vf); i++ {
2413                 if f := Pow(10, vf[i]); !close(pow[i], f) {
2414                         t.Errorf("Pow(10, %g) = %g, want %g", vf[i], f, pow[i])
2415                 }
2416         }
2417         for i := 0; i < len(vfpowSC); i++ {
2418                 if f := Pow(vfpowSC[i][0], vfpowSC[i][1]); !alike(powSC[i], f) {
2419                         t.Errorf("Pow(%g, %g) = %g, want %g", vfpowSC[i][0], vfpowSC[i][1], f, powSC[i])
2420                 }
2421         }
2422 }
2423
2424 func TestPow10(t *testing.T) {
2425         for i := 0; i < len(vfpow10SC); i++ {
2426                 if f := Pow10(vfpow10SC[i]); !alike(pow10SC[i], f) {
2427                         t.Errorf("Pow10(%d) = %g, want %g", vfpow10SC[i], f, pow10SC[i])
2428                 }
2429         }
2430 }
2431
2432 func TestRemainder(t *testing.T) {
2433         for i := 0; i < len(vf); i++ {
2434                 if f := Remainder(10, vf[i]); remainder[i] != f {
2435                         t.Errorf("Remainder(10, %g) = %g, want %g", vf[i], f, remainder[i])
2436                 }
2437         }
2438         for i := 0; i < len(vffmodSC); i++ {
2439                 if f := Remainder(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
2440                         t.Errorf("Remainder(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
2441                 }
2442         }
2443 }
2444
2445 func TestSignbit(t *testing.T) {
2446         for i := 0; i < len(vf); i++ {
2447                 if f := Signbit(vf[i]); signbit[i] != f {
2448                         t.Errorf("Signbit(%g) = %t, want %t", vf[i], f, signbit[i])
2449                 }
2450         }
2451         for i := 0; i < len(vfsignbitSC); i++ {
2452                 if f := Signbit(vfsignbitSC[i]); signbitSC[i] != f {
2453                         t.Errorf("Signbit(%g) = %t, want %t", vfsignbitSC[i], f, signbitSC[i])
2454                 }
2455         }
2456 }
2457 func TestSin(t *testing.T) {
2458         for i := 0; i < len(vf); i++ {
2459                 if f := Sin(vf[i]); !veryclose(sin[i], f) {
2460                         t.Errorf("Sin(%g) = %g, want %g", vf[i], f, sin[i])
2461                 }
2462         }
2463         for i := 0; i < len(vfsinSC); i++ {
2464                 if f := Sin(vfsinSC[i]); !alike(sinSC[i], f) {
2465                         t.Errorf("Sin(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
2466                 }
2467         }
2468 }
2469
2470 func TestSincos(t *testing.T) {
2471         for i := 0; i < len(vf); i++ {
2472                 if s, c := Sincos(vf[i]); !veryclose(sin[i], s) || !veryclose(cos[i], c) {
2473                         t.Errorf("Sincos(%g) = %g, %g want %g, %g", vf[i], s, c, sin[i], cos[i])
2474                 }
2475         }
2476 }
2477
2478 func TestSinh(t *testing.T) {
2479         for i := 0; i < len(vf); i++ {
2480                 if f := Sinh(vf[i]); !close(sinh[i], f) {
2481                         t.Errorf("Sinh(%g) = %g, want %g", vf[i], f, sinh[i])
2482                 }
2483         }
2484         for i := 0; i < len(vfsinhSC); i++ {
2485                 if f := Sinh(vfsinhSC[i]); !alike(sinhSC[i], f) {
2486                         t.Errorf("Sinh(%g) = %g, want %g", vfsinhSC[i], f, sinhSC[i])
2487                 }
2488         }
2489 }
2490
2491 func TestSqrt(t *testing.T) {
2492         for i := 0; i < len(vf); i++ {
2493                 a := Abs(vf[i])
2494                 if f := SqrtGo(a); sqrt[i] != f {
2495                         t.Errorf("SqrtGo(%g) = %g, want %g", a, f, sqrt[i])
2496                 }
2497                 a = Abs(vf[i])
2498                 if f := Sqrt(a); sqrt[i] != f {
2499                         t.Errorf("Sqrt(%g) = %g, want %g", a, f, sqrt[i])
2500                 }
2501         }
2502         for i := 0; i < len(vfsqrtSC); i++ {
2503                 if f := SqrtGo(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
2504                         t.Errorf("SqrtGo(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
2505                 }
2506                 if f := Sqrt(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
2507                         t.Errorf("Sqrt(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
2508                 }
2509         }
2510 }
2511
2512 func TestTan(t *testing.T) {
2513         for i := 0; i < len(vf); i++ {
2514                 if f := Tan(vf[i]); !veryclose(tan[i], f) {
2515                         t.Errorf("Tan(%g) = %g, want %g", vf[i], f, tan[i])
2516                 }
2517         }
2518         // same special cases as Sin
2519         for i := 0; i < len(vfsinSC); i++ {
2520                 if f := Tan(vfsinSC[i]); !alike(sinSC[i], f) {
2521                         t.Errorf("Tan(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
2522                 }
2523         }
2524 }
2525
2526 func TestTanh(t *testing.T) {
2527         for i := 0; i < len(vf); i++ {
2528                 if f := Tanh(vf[i]); !veryclose(tanh[i], f) {
2529                         t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i])
2530                 }
2531         }
2532         for i := 0; i < len(vftanhSC); i++ {
2533                 if f := Tanh(vftanhSC[i]); !alike(tanhSC[i], f) {
2534                         t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i])
2535                 }
2536         }
2537 }
2538
2539 func TestTrunc(t *testing.T) {
2540         for i := 0; i < len(vf); i++ {
2541                 if f := Trunc(vf[i]); trunc[i] != f {
2542                         t.Errorf("Trunc(%g) = %g, want %g", vf[i], f, trunc[i])
2543                 }
2544         }
2545         for i := 0; i < len(vfceilSC); i++ {
2546                 if f := Trunc(vfceilSC[i]); !alike(ceilSC[i], f) {
2547                         t.Errorf("Trunc(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
2548                 }
2549         }
2550 }
2551
2552 func TestY0(t *testing.T) {
2553         for i := 0; i < len(vf); i++ {
2554                 a := Abs(vf[i])
2555                 if f := Y0(a); !close(y0[i], f) {
2556                         t.Errorf("Y0(%g) = %g, want %g", a, f, y0[i])
2557                 }
2558         }
2559         for i := 0; i < len(vfy0SC); i++ {
2560                 if f := Y0(vfy0SC[i]); !alike(y0SC[i], f) {
2561                         t.Errorf("Y0(%g) = %g, want %g", vfy0SC[i], f, y0SC[i])
2562                 }
2563         }
2564 }
2565
2566 func TestY1(t *testing.T) {
2567         for i := 0; i < len(vf); i++ {
2568                 a := Abs(vf[i])
2569                 if f := Y1(a); !soclose(y1[i], f, 2e-14) {
2570                         t.Errorf("Y1(%g) = %g, want %g", a, f, y1[i])
2571                 }
2572         }
2573         for i := 0; i < len(vfy0SC); i++ {
2574                 if f := Y1(vfy0SC[i]); !alike(y1SC[i], f) {
2575                         t.Errorf("Y1(%g) = %g, want %g", vfy0SC[i], f, y1SC[i])
2576                 }
2577         }
2578 }
2579
2580 func TestYn(t *testing.T) {
2581         for i := 0; i < len(vf); i++ {
2582                 a := Abs(vf[i])
2583                 if f := Yn(2, a); !close(y2[i], f) {
2584                         t.Errorf("Yn(2, %g) = %g, want %g", a, f, y2[i])
2585                 }
2586                 if f := Yn(-3, a); !close(yM3[i], f) {
2587                         t.Errorf("Yn(-3, %g) = %g, want %g", a, f, yM3[i])
2588                 }
2589         }
2590         for i := 0; i < len(vfy0SC); i++ {
2591                 if f := Yn(2, vfy0SC[i]); !alike(y2SC[i], f) {
2592                         t.Errorf("Yn(2, %g) = %g, want %g", vfy0SC[i], f, y2SC[i])
2593                 }
2594                 if f := Yn(-3, vfy0SC[i]); !alike(yM3SC[i], f) {
2595                         t.Errorf("Yn(-3, %g) = %g, want %g", vfy0SC[i], f, yM3SC[i])
2596                 }
2597         }
2598 }
2599
2600 // Check that math functions of high angle values
2601 // return accurate results. [Since (vf[i] + large) - large != vf[i],
2602 // testing for Trig(vf[i] + large) == Trig(vf[i]), where large is
2603 // a multiple of 2*Pi, is misleading.]
2604 func TestLargeCos(t *testing.T) {
2605         large := float64(100000 * Pi)
2606         for i := 0; i < len(vf); i++ {
2607                 f1 := cosLarge[i]
2608                 f2 := Cos(vf[i] + large)
2609                 if !close(f1, f2) {
2610                         t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1)
2611                 }
2612         }
2613 }
2614
2615 func TestLargeSin(t *testing.T) {
2616         large := float64(100000 * Pi)
2617         for i := 0; i < len(vf); i++ {
2618                 f1 := sinLarge[i]
2619                 f2 := Sin(vf[i] + large)
2620                 if !close(f1, f2) {
2621                         t.Errorf("Sin(%g) = %g, want %g", vf[i]+large, f2, f1)
2622                 }
2623         }
2624 }
2625
2626 func TestLargeSincos(t *testing.T) {
2627         large := float64(100000 * Pi)
2628         for i := 0; i < len(vf); i++ {
2629                 f1, g1 := sinLarge[i], cosLarge[i]
2630                 f2, g2 := Sincos(vf[i] + large)
2631                 if !close(f1, f2) || !close(g1, g2) {
2632                         t.Errorf("Sincos(%g) = %g, %g, want %g, %g", vf[i]+large, f2, g2, f1, g1)
2633                 }
2634         }
2635 }
2636
2637 func TestLargeTan(t *testing.T) {
2638         large := float64(100000 * Pi)
2639         for i := 0; i < len(vf); i++ {
2640                 f1 := tanLarge[i]
2641                 f2 := Tan(vf[i] + large)
2642                 if !close(f1, f2) {
2643                         t.Errorf("Tan(%g) = %g, want %g", vf[i]+large, f2, f1)
2644                 }
2645         }
2646 }
2647
2648 // Check that math constants are accepted by compiler
2649 // and have right value (assumes strconv.ParseFloat works).
2650 // https://golang.org/issue/201
2651
2652 type floatTest struct {
2653         val  interface{}
2654         name string
2655         str  string
2656 }
2657
2658 var floatTests = []floatTest{
2659         {float64(MaxFloat64), "MaxFloat64", "1.7976931348623157e+308"},
2660         {float64(SmallestNonzeroFloat64), "SmallestNonzeroFloat64", "5e-324"},
2661         {float32(MaxFloat32), "MaxFloat32", "3.4028235e+38"},
2662         {float32(SmallestNonzeroFloat32), "SmallestNonzeroFloat32", "1e-45"},
2663 }
2664
2665 func TestFloatMinMax(t *testing.T) {
2666         for _, tt := range floatTests {
2667                 s := fmt.Sprint(tt.val)
2668                 if s != tt.str {
2669                         t.Errorf("Sprint(%v) = %s, want %s", tt.name, s, tt.str)
2670                 }
2671         }
2672 }
2673
2674 // Benchmarks
2675
2676 func BenchmarkAcos(b *testing.B) {
2677         for i := 0; i < b.N; i++ {
2678                 Acos(.5)
2679         }
2680 }
2681
2682 func BenchmarkAcosh(b *testing.B) {
2683         for i := 0; i < b.N; i++ {
2684                 Acosh(1.5)
2685         }
2686 }
2687
2688 func BenchmarkAsin(b *testing.B) {
2689         for i := 0; i < b.N; i++ {
2690                 Asin(.5)
2691         }
2692 }
2693
2694 func BenchmarkAsinh(b *testing.B) {
2695         for i := 0; i < b.N; i++ {
2696                 Asinh(.5)
2697         }
2698 }
2699
2700 func BenchmarkAtan(b *testing.B) {
2701         for i := 0; i < b.N; i++ {
2702                 Atan(.5)
2703         }
2704 }
2705
2706 func BenchmarkAtanh(b *testing.B) {
2707         for i := 0; i < b.N; i++ {
2708                 Atanh(.5)
2709         }
2710 }
2711
2712 func BenchmarkAtan2(b *testing.B) {
2713         for i := 0; i < b.N; i++ {
2714                 Atan2(.5, 1)
2715         }
2716 }
2717
2718 func BenchmarkCbrt(b *testing.B) {
2719         for i := 0; i < b.N; i++ {
2720                 Cbrt(10)
2721         }
2722 }
2723
2724 func BenchmarkCeil(b *testing.B) {
2725         for i := 0; i < b.N; i++ {
2726                 Ceil(.5)
2727         }
2728 }
2729
2730 func BenchmarkCopysign(b *testing.B) {
2731         for i := 0; i < b.N; i++ {
2732                 Copysign(.5, -1)
2733         }
2734 }
2735
2736 func BenchmarkCos(b *testing.B) {
2737         for i := 0; i < b.N; i++ {
2738                 Cos(.5)
2739         }
2740 }
2741
2742 func BenchmarkCosh(b *testing.B) {
2743         for i := 0; i < b.N; i++ {
2744                 Cosh(2.5)
2745         }
2746 }
2747
2748 func BenchmarkErf(b *testing.B) {
2749         for i := 0; i < b.N; i++ {
2750                 Erf(.5)
2751         }
2752 }
2753
2754 func BenchmarkErfc(b *testing.B) {
2755         for i := 0; i < b.N; i++ {
2756                 Erfc(.5)
2757         }
2758 }
2759
2760 func BenchmarkExp(b *testing.B) {
2761         for i := 0; i < b.N; i++ {
2762                 Exp(.5)
2763         }
2764 }
2765
2766 func BenchmarkExpGo(b *testing.B) {
2767         for i := 0; i < b.N; i++ {
2768                 ExpGo(.5)
2769         }
2770 }
2771
2772 func BenchmarkExpm1(b *testing.B) {
2773         for i := 0; i < b.N; i++ {
2774                 Expm1(.5)
2775         }
2776 }
2777
2778 func BenchmarkExp2(b *testing.B) {
2779         for i := 0; i < b.N; i++ {
2780                 Exp2(.5)
2781         }
2782 }
2783
2784 func BenchmarkExp2Go(b *testing.B) {
2785         for i := 0; i < b.N; i++ {
2786                 Exp2Go(.5)
2787         }
2788 }
2789
2790 func BenchmarkAbs(b *testing.B) {
2791         for i := 0; i < b.N; i++ {
2792                 Abs(.5)
2793         }
2794 }
2795
2796 func BenchmarkDim(b *testing.B) {
2797         for i := 0; i < b.N; i++ {
2798                 Dim(10, 3)
2799         }
2800 }
2801
2802 func BenchmarkFloor(b *testing.B) {
2803         for i := 0; i < b.N; i++ {
2804                 Floor(.5)
2805         }
2806 }
2807
2808 func BenchmarkMax(b *testing.B) {
2809         for i := 0; i < b.N; i++ {
2810                 Max(10, 3)
2811         }
2812 }
2813
2814 func BenchmarkMin(b *testing.B) {
2815         for i := 0; i < b.N; i++ {
2816                 Min(10, 3)
2817         }
2818 }
2819
2820 func BenchmarkMod(b *testing.B) {
2821         for i := 0; i < b.N; i++ {
2822                 Mod(10, 3)
2823         }
2824 }
2825
2826 func BenchmarkFrexp(b *testing.B) {
2827         for i := 0; i < b.N; i++ {
2828                 Frexp(8)
2829         }
2830 }
2831
2832 func BenchmarkGamma(b *testing.B) {
2833         for i := 0; i < b.N; i++ {
2834                 Gamma(2.5)
2835         }
2836 }
2837
2838 func BenchmarkHypot(b *testing.B) {
2839         for i := 0; i < b.N; i++ {
2840                 Hypot(3, 4)
2841         }
2842 }
2843
2844 func BenchmarkHypotGo(b *testing.B) {
2845         for i := 0; i < b.N; i++ {
2846                 HypotGo(3, 4)
2847         }
2848 }
2849
2850 func BenchmarkIlogb(b *testing.B) {
2851         for i := 0; i < b.N; i++ {
2852                 Ilogb(.5)
2853         }
2854 }
2855
2856 func BenchmarkJ0(b *testing.B) {
2857         for i := 0; i < b.N; i++ {
2858                 J0(2.5)
2859         }
2860 }
2861
2862 func BenchmarkJ1(b *testing.B) {
2863         for i := 0; i < b.N; i++ {
2864                 J1(2.5)
2865         }
2866 }
2867
2868 func BenchmarkJn(b *testing.B) {
2869         for i := 0; i < b.N; i++ {
2870                 Jn(2, 2.5)
2871         }
2872 }
2873
2874 func BenchmarkLdexp(b *testing.B) {
2875         for i := 0; i < b.N; i++ {
2876                 Ldexp(.5, 2)
2877         }
2878 }
2879
2880 func BenchmarkLgamma(b *testing.B) {
2881         for i := 0; i < b.N; i++ {
2882                 Lgamma(2.5)
2883         }
2884 }
2885
2886 func BenchmarkLog(b *testing.B) {
2887         for i := 0; i < b.N; i++ {
2888                 Log(.5)
2889         }
2890 }
2891
2892 func BenchmarkLogb(b *testing.B) {
2893         for i := 0; i < b.N; i++ {
2894                 Logb(.5)
2895         }
2896 }
2897
2898 func BenchmarkLog1p(b *testing.B) {
2899         for i := 0; i < b.N; i++ {
2900                 Log1p(.5)
2901         }
2902 }
2903
2904 func BenchmarkLog10(b *testing.B) {
2905         for i := 0; i < b.N; i++ {
2906                 Log10(.5)
2907         }
2908 }
2909
2910 func BenchmarkLog2(b *testing.B) {
2911         for i := 0; i < b.N; i++ {
2912                 Log2(.5)
2913         }
2914 }
2915
2916 func BenchmarkModf(b *testing.B) {
2917         for i := 0; i < b.N; i++ {
2918                 Modf(1.5)
2919         }
2920 }
2921
2922 func BenchmarkNextafter32(b *testing.B) {
2923         for i := 0; i < b.N; i++ {
2924                 Nextafter32(.5, 1)
2925         }
2926 }
2927
2928 func BenchmarkNextafter64(b *testing.B) {
2929         for i := 0; i < b.N; i++ {
2930                 Nextafter(.5, 1)
2931         }
2932 }
2933
2934 func BenchmarkPowInt(b *testing.B) {
2935         for i := 0; i < b.N; i++ {
2936                 Pow(2, 2)
2937         }
2938 }
2939
2940 func BenchmarkPowFrac(b *testing.B) {
2941         for i := 0; i < b.N; i++ {
2942                 Pow(2.5, 1.5)
2943         }
2944 }
2945
2946 func BenchmarkPow10Pos(b *testing.B) {
2947         for i := 0; i < b.N; i++ {
2948                 Pow10(300)
2949         }
2950 }
2951
2952 func BenchmarkPow10Neg(b *testing.B) {
2953         for i := 0; i < b.N; i++ {
2954                 Pow10(-300)
2955         }
2956 }
2957
2958 func BenchmarkRemainder(b *testing.B) {
2959         for i := 0; i < b.N; i++ {
2960                 Remainder(10, 3)
2961         }
2962 }
2963
2964 func BenchmarkSignbit(b *testing.B) {
2965         for i := 0; i < b.N; i++ {
2966                 Signbit(2.5)
2967         }
2968 }
2969
2970 func BenchmarkSin(b *testing.B) {
2971         for i := 0; i < b.N; i++ {
2972                 Sin(.5)
2973         }
2974 }
2975
2976 func BenchmarkSincos(b *testing.B) {
2977         for i := 0; i < b.N; i++ {
2978                 Sincos(.5)
2979         }
2980 }
2981
2982 func BenchmarkSinh(b *testing.B) {
2983         for i := 0; i < b.N; i++ {
2984                 Sinh(2.5)
2985         }
2986 }
2987
2988 var Global float64
2989
2990 func BenchmarkSqrt(b *testing.B) {
2991         x, y := 0.0, 10.0
2992         for i := 0; i < b.N; i++ {
2993                 x += Sqrt(y)
2994         }
2995         Global = x
2996 }
2997
2998 func BenchmarkSqrtIndirect(b *testing.B) {
2999         x, y := 0.0, 10.0
3000         f := Sqrt
3001         for i := 0; i < b.N; i++ {
3002                 x += f(y)
3003         }
3004         Global = x
3005 }
3006
3007 func BenchmarkSqrtGo(b *testing.B) {
3008         x, y := 0.0, 10.0
3009         for i := 0; i < b.N; i++ {
3010                 x += SqrtGo(y)
3011         }
3012         Global = x
3013 }
3014
3015 func isPrime(i int) bool {
3016         // Yes, this is a dumb way to write this code,
3017         // but calling Sqrt repeatedly in this way demonstrates
3018         // the benefit of using a direct SQRT instruction on systems
3019         // that have one, whereas the obvious loop seems not to
3020         // demonstrate such a benefit.
3021         for j := 2; float64(j) <= Sqrt(float64(i)); j++ {
3022                 if i%j == 0 {
3023                         return false
3024                 }
3025         }
3026         return true
3027 }
3028
3029 func BenchmarkSqrtPrime(b *testing.B) {
3030         any := false
3031         for i := 0; i < b.N; i++ {
3032                 if isPrime(100003) {
3033                         any = true
3034                 }
3035         }
3036         if any {
3037                 Global = 1
3038         }
3039 }
3040
3041 func BenchmarkTan(b *testing.B) {
3042         for i := 0; i < b.N; i++ {
3043                 Tan(.5)
3044         }
3045 }
3046
3047 func BenchmarkTanh(b *testing.B) {
3048         for i := 0; i < b.N; i++ {
3049                 Tanh(2.5)
3050         }
3051 }
3052 func BenchmarkTrunc(b *testing.B) {
3053         for i := 0; i < b.N; i++ {
3054                 Trunc(.5)
3055         }
3056 }
3057
3058 func BenchmarkY0(b *testing.B) {
3059         for i := 0; i < b.N; i++ {
3060                 Y0(2.5)
3061         }
3062 }
3063
3064 func BenchmarkY1(b *testing.B) {
3065         for i := 0; i < b.N; i++ {
3066                 Y1(2.5)
3067         }
3068 }
3069
3070 func BenchmarkYn(b *testing.B) {
3071         for i := 0; i < b.N; i++ {
3072                 Yn(2, 2.5)
3073         }
3074 }