libgo/go/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         {0.0000000000000000e+00, -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 nextafter = []float64{
 460         4.97901192488367438926388786e+00,
 461         7.73887247457810545370193722e+00,
 462         -2.7688005719200153853520874e-01,
 463         -5.01060361827107403343006808e+00,
 464         9.63629370719841915615688777e+00,
 465         2.92637723924396508934364647e+00,
 466         5.22908343145930754047867595e+00,
 467         2.72793991043601069534929593e+00,
 468         1.82530809168085528249036997e+00,
 469         -8.68592476857559958602905681e+00,
 470 }
 471 var pow = []float64{
 472         9.5282232631648411840742957e+04,
 473         5.4811599352999901232411871e+07,
 474         5.2859121715894396531132279e-01,
 475         9.7587991957286474464259698e-06,
 476         4.328064329346044846740467e+09,
 477         8.4406761805034547437659092e+02,
 478         1.6946633276191194947742146e+05,
 479         5.3449040147551939075312879e+02,
 480         6.688182138451414936380374e+01,
 481         2.0609869004248742886827439e-09,
 482 }
 483 var remainder = []float64{
 484         4.197615023265299782906368e-02,
 485         2.261127525421895434476482e+00,
 486         3.231794108794261433104108e-02,
 487         -2.120723654214984321697556e-02,
 488         3.637062928015826201999516e-01,
 489         1.220868282268106064236690e+00,
 490         -4.581668629186133046005125e-01,
 491         -9.117596417440410050403443e-01,
 492         8.734595415957246977711748e-01,
 493         1.314075231424398637614104e+00,
 494 }
 495 var signbit = []bool{
 496         false,
 497         false,
 498         true,
 499         true,
 500         false,
 501         false,
 502         false,
 503         false,
 504         false,
 505         true,
 506 }
 507 var sin = []float64{
 508         -9.6466616586009283766724726e-01,
 509         9.9338225271646545763467022e-01,
 510         -2.7335587039794393342449301e-01,
 511         9.5586257685042792878173752e-01,
 512         -2.099421066779969164496634e-01,
 513         2.135578780799860532750616e-01,
 514         -8.694568971167362743327708e-01,
 515         4.019566681155577786649878e-01,
 516         9.6778633541687993721617774e-01,
 517         -6.734405869050344734943028e-01,
 518 }
 519
 520 // Results for 100000 * Pi + vf[i]
 521 var sinLarge = []float64{
 522         -9.646661658548936063912e-01,
 523         9.933822527198506903752e-01,
 524         -2.7335587036246899796e-01,
 525         9.55862576853689321268e-01,
 526         -2.099421066862688873691e-01,
 527         2.13557878070308981163e-01,
 528         -8.694568970959221300497e-01,
 529         4.01956668098863248917e-01,
 530         9.67786335404528727927e-01,
 531         -6.7344058693131973066e-01,
 532 }
 533 var sinh = []float64{
 534         7.2661916084208532301448439e+01,
 535         1.1479409110035194500526446e+03,
 536         -2.8043136512812518927312641e-01,
 537         -7.499429091181587232835164e+01,
 538         7.6552466042906758523925934e+03,
 539         9.3031583421672014313789064e+00,
 540         9.330815755828109072810322e+01,
 541         7.6179893137269146407361477e+00,
 542         3.021769180549615819524392e+00,
 543         -2.95950575724449499189888e+03,
 544 }
 545 var sqrt = []float64{
 546         2.2313699659365484748756904e+00,
 547         2.7818829009464263511285458e+00,
 548         5.2619393496314796848143251e-01,
 549         2.2384377628763938724244104e+00,
 550         3.1042380236055381099288487e+00,
 551         1.7106657298385224403917771e+00,
 552         2.286718922705479046148059e+00,
 553         1.6516476350711159636222979e+00,
 554         1.3510396336454586262419247e+00,
 555         2.9471892997524949215723329e+00,
 556 }
 557 var tan = []float64{
 558         -3.661316565040227801781974e+00,
 559         8.64900232648597589369854e+00,
 560         -2.8417941955033612725238097e-01,
 561         3.253290185974728640827156e+00,
 562         2.147275640380293804770778e-01,
 563         -2.18600910711067004921551e-01,
 564         -1.760002817872367935518928e+00,
 565         -4.389808914752818126249079e-01,
 566         -3.843885560201130679995041e+00,
 567         9.10988793377685105753416e-01,
 568 }
 569
 570 // Results for 100000 * Pi + vf[i]
 571 var tanLarge = []float64{
 572         -3.66131656475596512705e+00,
 573         8.6490023287202547927e+00,
 574         -2.841794195104782406e-01,
 575         3.2532901861033120983e+00,
 576         2.14727564046880001365e-01,
 577         -2.18600910700688062874e-01,
 578         -1.760002817699722747043e+00,
 579         -4.38980891453536115952e-01,
 580         -3.84388555942723509071e+00,
 581         9.1098879344275101051e-01,
 582 }
 583 var tanh = []float64{
 584         9.9990531206936338549262119e-01,
 585         9.9999962057085294197613294e-01,
 586         -2.7001505097318677233756845e-01,
 587         -9.9991110943061718603541401e-01,
 588         9.9999999146798465745022007e-01,
 589         9.9427249436125236705001048e-01,
 590         9.9994257600983138572705076e-01,
 591         9.9149409509772875982054701e-01,
 592         9.4936501296239685514466577e-01,
 593         -9.9999994291374030946055701e-01,
 594 }
 595 var trunc = []float64{
 596         4.0000000000000000e+00,
 597         7.0000000000000000e+00,
 598         -0.0000000000000000e+00,
 599         -5.0000000000000000e+00,
 600         9.0000000000000000e+00,
 601         2.0000000000000000e+00,
 602         5.0000000000000000e+00,
 603         2.0000000000000000e+00,
 604         1.0000000000000000e+00,
 605         -8.0000000000000000e+00,
 606 }
 607 var y0 = []float64{
 608         -3.053399153780788357534855e-01,
 609         1.7437227649515231515503649e-01,
 610         -8.6221781263678836910392572e-01,
 611         -3.100664880987498407872839e-01,
 612         1.422200649300982280645377e-01,
 613         4.000004067997901144239363e-01,
 614         -3.3340749753099352392332536e-01,
 615         4.5399790746668954555205502e-01,
 616         4.8290004112497761007536522e-01,
 617         2.7036697826604756229601611e-01,
 618 }
 619 var y1 = []float64{
 620         0.15494213737457922210218611,
 621         -0.2165955142081145245075746,
 622         -2.4644949631241895201032829,
 623         0.1442740489541836405154505,
 624         0.2215379960518984777080163,
 625         0.3038800915160754150565448,
 626         0.0691107642452362383808547,
 627         0.2380116417809914424860165,
 628         -0.20849492979459761009678934,
 629         0.0242503179793232308250804,
 630 }
 631 var y2 = []float64{
 632         0.3675780219390303613394936,
 633         -0.23034826393250119879267257,
 634         -16.939677983817727205631397,
 635         0.367653980523052152867791,
 636         -0.0962401471767804440353136,
 637         -0.1923169356184851105200523,
 638         0.35984072054267882391843766,
 639         -0.2794987252299739821654982,
 640         -0.7113490692587462579757954,
 641         -0.2647831587821263302087457,
 642 }
 643 var yM3 = []float64{
 644         -0.14035984421094849100895341,
 645         -0.097535139617792072703973,
 646         242.25775994555580176377379,
 647         -0.1492267014802818619511046,
 648         0.26148702629155918694500469,
 649         0.56675383593895176530394248,
 650         -0.206150264009006981070575,
 651         0.64784284687568332737963658,
 652         1.3503631555901938037008443,
 653         0.1461869756579956803341844,
 654 }
 655
 656 // arguments and expected results for special cases
 657 var vfacosSC = []float64{
 658         -Pi,
 659         1,
 660         Pi,
 661         NaN(),
 662 }
 663 var acosSC = []float64{
 664         NaN(),
 665         0,
 666         NaN(),
 667         NaN(),
 668 }
 669
 670 var vfacoshSC = []float64{
 671         Inf(-1),
 672         0.5,
 673         1,
 674         Inf(1),
 675         NaN(),
 676 }
 677 var acoshSC = []float64{
 678         NaN(),
 679         NaN(),
 680         0,
 681         Inf(1),
 682         NaN(),
 683 }
 684
 685 var vfasinSC = []float64{
 686         -Pi,
 687         Copysign(0, -1),
 688         0,
 689         Pi,
 690         NaN(),
 691 }
 692 var asinSC = []float64{
 693         NaN(),
 694         Copysign(0, -1),
 695         0,
 696         NaN(),
 697         NaN(),
 698 }
 699
 700 var vfasinhSC = []float64{
 701         Inf(-1),
 702         Copysign(0, -1),
 703         0,
 704         Inf(1),
 705         NaN(),
 706 }
 707 var asinhSC = []float64{
 708         Inf(-1),
 709         Copysign(0, -1),
 710         0,
 711         Inf(1),
 712         NaN(),
 713 }
 714
 715 var vfatanSC = []float64{
 716         Inf(-1),
 717         Copysign(0, -1),
 718         0,
 719         Inf(1),
 720         NaN(),
 721 }
 722 var atanSC = []float64{
 723         -Pi / 2,
 724         Copysign(0, -1),
 725         0,
 726         Pi / 2,
 727         NaN(),
 728 }
 729
 730 var vfatanhSC = []float64{
 731         Inf(-1),
 732         -Pi,
 733         -1,
 734         Copysign(0, -1),
 735         0,
 736         1,
 737         Pi,
 738         Inf(1),
 739         NaN(),
 740 }
 741 var atanhSC = []float64{
 742         NaN(),
 743         NaN(),
 744         Inf(-1),
 745         Copysign(0, -1),
 746         0,
 747         Inf(1),
 748         NaN(),
 749         NaN(),
 750         NaN(),
 751 }
 752 var vfatan2SC = [][2]float64{
 753         {Inf(-1), Inf(-1)},
 754         {Inf(-1), -Pi},
 755         {Inf(-1), 0},
 756         {Inf(-1), +Pi},
 757         {Inf(-1), Inf(1)},
 758         {Inf(-1), NaN()},
 759         {-Pi, Inf(-1)},
 760         {-Pi, 0},
 761         {-Pi, Inf(1)},
 762         {-Pi, NaN()},
 763         {Copysign(0, -1), Inf(-1)},
 764         {Copysign(0, -1), -Pi},
 765         {Copysign(0, -1), Copysign(0, -1)},
 766         {Copysign(0, -1), 0},
 767         {Copysign(0, -1), +Pi},
 768         {Copysign(0, -1), Inf(1)},
 769         {Copysign(0, -1), NaN()},
 770         {0, Inf(-1)},
 771         {0, -Pi},
 772         {0, Copysign(0, -1)},
 773         {0, 0},
 774         {0, +Pi},
 775         {0, Inf(1)},
 776         {0, NaN()},
 777         {+Pi, Inf(-1)},
 778         {+Pi, 0},
 779         {+Pi, Inf(1)},
 780         {+Pi, NaN()},
 781         {Inf(1), Inf(-1)},
 782         {Inf(1), -Pi},
 783         {Inf(1), 0},
 784         {Inf(1), +Pi},
 785         {Inf(1), Inf(1)},
 786         {Inf(1), NaN()},
 787         {NaN(), NaN()},
 788 }
 789 var atan2SC = []float64{
 790         -3 * Pi / 4,     // atan2(-Inf, -Inf)
 791         -Pi / 2,         // atan2(-Inf, -Pi)
 792         -Pi / 2,         // atan2(-Inf, +0)
 793         -Pi / 2,         // atan2(-Inf, +Pi)
 794         -Pi / 4,         // atan2(-Inf, +Inf)
 795         NaN(),           // atan2(-Inf, NaN)
 796         -Pi,             // atan2(-Pi, -Inf)
 797         -Pi / 2,         // atan2(-Pi, +0)
 798         Copysign(0, -1), // atan2(-Pi, Inf)
 799         NaN(),           // atan2(-Pi, NaN)
 800         -Pi,             // atan2(-0, -Inf)
 801         -Pi,             // atan2(-0, -Pi)
 802         -Pi,             // atan2(-0, -0)
 803         Copysign(0, -1), // atan2(-0, +0)
 804         Copysign(0, -1), // atan2(-0, +Pi)
 805         Copysign(0, -1), // atan2(-0, +Inf)
 806         NaN(),           // atan2(-0, NaN)
 807         Pi,              // atan2(+0, -Inf)
 808         Pi,              // atan2(+0, -Pi)
 809         Pi,              // atan2(+0, -0)
 810         0,               // atan2(+0, +0)
 811         0,               // atan2(+0, +Pi)
 812         0,               // atan2(+0, +Inf)
 813         NaN(),           // atan2(+0, NaN)
 814         Pi,              // atan2(+Pi, -Inf)
 815         Pi / 2,          // atan2(+Pi, +0)
 816         0,               // atan2(+Pi, +Inf)
 817         NaN(),           // atan2(+Pi, NaN)
 818         3 * Pi / 4,      // atan2(+Inf, -Inf)
 819         Pi / 2,          // atan2(+Inf, -Pi)
 820         Pi / 2,          // atan2(+Inf, +0)
 821         Pi / 2,          // atan2(+Inf, +Pi)
 822         Pi / 4,          // atan2(+Inf, +Inf)
 823         NaN(),           // atan2(+Inf, NaN)
 824         NaN(),           // atan2(NaN, NaN)
 825 }
 826
 827 var vfcbrtSC = []float64{
 828         Inf(-1),
 829         Copysign(0, -1),
 830         0,
 831         Inf(1),
 832         NaN(),
 833 }
 834 var cbrtSC = []float64{
 835         Inf(-1),
 836         Copysign(0, -1),
 837         0,
 838         Inf(1),
 839         NaN(),
 840 }
 841
 842 var vfceilSC = []float64{
 843         Inf(-1),
 844         Copysign(0, -1),
 845         0,
 846         Inf(1),
 847         NaN(),
 848 }
 849 var ceilSC = []float64{
 850         Inf(-1),
 851         Copysign(0, -1),
 852         0,
 853         Inf(1),
 854         NaN(),
 855 }
 856
 857 var vfcopysignSC = []float64{
 858         Inf(-1),
 859         Inf(1),
 860         NaN(),
 861 }
 862 var copysignSC = []float64{
 863         Inf(-1),
 864         Inf(-1),
 865         NaN(),
 866 }
 867
 868 var vfcosSC = []float64{
 869         Inf(-1),
 870         Inf(1),
 871         NaN(),
 872 }
 873 var cosSC = []float64{
 874         NaN(),
 875         NaN(),
 876         NaN(),
 877 }
 878
 879 var vfcoshSC = []float64{
 880         Inf(-1),
 881         Copysign(0, -1),
 882         0,
 883         Inf(1),
 884         NaN(),
 885 }
 886 var coshSC = []float64{
 887         Inf(1),
 888         1,
 889         1,
 890         Inf(1),
 891         NaN(),
 892 }
 893
 894 var vferfSC = []float64{
 895         Inf(-1),
 896         Copysign(0, -1),
 897         0,
 898         Inf(1),
 899         NaN(),
 900 }
 901 var erfSC = []float64{
 902         -1,
 903         Copysign(0, -1),
 904         0,
 905         1,
 906         NaN(),
 907 }
 908
 909 var vferfcSC = []float64{
 910         Inf(-1),
 911         Inf(1),
 912         NaN(),
 913 }
 914 var erfcSC = []float64{
 915         2,
 916         0,
 917         NaN(),
 918 }
 919
 920 var vfexpSC = []float64{
 921         Inf(-1),
 922         -2000,
 923         2000,
 924         Inf(1),
 925         NaN(),
 926 }
 927 var expSC = []float64{
 928         0,
 929         0,
 930         Inf(1),
 931         Inf(1),
 932         NaN(),
 933 }
 934
 935 var vfexpm1SC = []float64{
 936         Inf(-1),
 937         Copysign(0, -1),
 938         0,
 939         Inf(1),
 940         NaN(),
 941 }
 942 var expm1SC = []float64{
 943         -1,
 944         Copysign(0, -1),
 945         0,
 946         Inf(1),
 947         NaN(),
 948 }
 949
 950 var vffabsSC = []float64{
 951         Inf(-1),
 952         Copysign(0, -1),
 953         0,
 954         Inf(1),
 955         NaN(),
 956 }
 957 var fabsSC = []float64{
 958         Inf(1),
 959         0,
 960         0,
 961         Inf(1),
 962         NaN(),
 963 }
 964
 965 var vffdimSC = [][2]float64{
 966         {Inf(-1), Inf(-1)},
 967         {Inf(-1), Inf(1)},
 968         {Inf(-1), NaN()},
 969         {Copysign(0, -1), Copysign(0, -1)},
 970         {Copysign(0, -1), 0},
 971         {0, Copysign(0, -1)},
 972         {0, 0},
 973         {Inf(1), Inf(-1)},
 974         {Inf(1), Inf(1)},
 975         {Inf(1), NaN()},
 976         {NaN(), Inf(-1)},
 977         {NaN(), Copysign(0, -1)},
 978         {NaN(), 0},
 979         {NaN(), Inf(1)},
 980         {NaN(), NaN()},
 981 }
 982 var fdimSC = []float64{
 983         NaN(),
 984         0,
 985         NaN(),
 986         0,
 987         0,
 988         0,
 989         0,
 990         Inf(1),
 991         NaN(),
 992         NaN(),
 993         NaN(),
 994         NaN(),
 995         NaN(),
 996         NaN(),
 997         NaN(),
 998 }
 999 var fmaxSC = []float64{
1000         Inf(-1),
1001         Inf(1),
1002         NaN(),
1003         Copysign(0, -1),
1004         0,
1005         0,
1006         0,
1007         Inf(1),
1008         Inf(1),
1009         Inf(1),
1010         NaN(),
1011         NaN(),
1012         NaN(),
1013         Inf(1),
1014         NaN(),
1015 }
1016 var fminSC = []float64{
1017         Inf(-1),
1018         Inf(-1),
1019         Inf(-1),
1020         Copysign(0, -1),
1021         Copysign(0, -1),
1022         Copysign(0, -1),
1023         0,
1024         Inf(-1),
1025         Inf(1),
1026         NaN(),
1027         Inf(-1),
1028         NaN(),
1029         NaN(),
1030         NaN(),
1031         NaN(),
1032 }
1033
1034 var vffmodSC = [][2]float64{
1035         {Inf(-1), Inf(-1)},
1036         {Inf(-1), -Pi},
1037         {Inf(-1), 0},
1038         {Inf(-1), Pi},
1039         {Inf(-1), Inf(1)},
1040         {Inf(-1), NaN()},
1041         {-Pi, Inf(-1)},
1042         {-Pi, 0},
1043         {-Pi, Inf(1)},
1044         {-Pi, NaN()},
1045         {Copysign(0, -1), Inf(-1)},
1046         {Copysign(0, -1), 0},
1047         {Copysign(0, -1), Inf(1)},
1048         {Copysign(0, -1), NaN()},
1049         {0, Inf(-1)},
1050         {0, 0},
1051         {0, Inf(1)},
1052         {0, NaN()},
1053         {Pi, Inf(-1)},
1054         {Pi, 0},
1055         {Pi, Inf(1)},
1056         {Pi, NaN()},
1057         {Inf(1), Inf(-1)},
1058         {Inf(1), -Pi},
1059         {Inf(1), 0},
1060         {Inf(1), Pi},
1061         {Inf(1), Inf(1)},
1062         {Inf(1), NaN()},
1063         {NaN(), Inf(-1)},
1064         {NaN(), -Pi},
1065         {NaN(), 0},
1066         {NaN(), Pi},
1067         {NaN(), Inf(1)},
1068         {NaN(), NaN()},
1069 }
1070 var fmodSC = []float64{
1071         NaN(),           // fmod(-Inf, -Inf)
1072         NaN(),           // fmod(-Inf, -Pi)
1073         NaN(),           // fmod(-Inf, 0)
1074         NaN(),           // fmod(-Inf, Pi)
1075         NaN(),           // fmod(-Inf, +Inf)
1076         NaN(),           // fmod(-Inf, NaN)
1077         -Pi,             // fmod(-Pi, -Inf)
1078         NaN(),           // fmod(-Pi, 0)
1079         -Pi,             // fmod(-Pi, +Inf)
1080         NaN(),           // fmod(-Pi, NaN)
1081         Copysign(0, -1), // fmod(-0, -Inf)
1082         NaN(),           // fmod(-0, 0)
1083         Copysign(0, -1), // fmod(-0, Inf)
1084         NaN(),           // fmod(-0, NaN)
1085         0,               // fmod(0, -Inf)
1086         NaN(),           // fmod(0, 0)
1087         0,               // fmod(0, +Inf)
1088         NaN(),           // fmod(0, NaN)
1089         Pi,              // fmod(Pi, -Inf)
1090         NaN(),           // fmod(Pi, 0)
1091         Pi,              // fmod(Pi, +Inf)
1092         NaN(),           // fmod(Pi, NaN)
1093         NaN(),           // fmod(+Inf, -Inf)
1094         NaN(),           // fmod(+Inf, -Pi)
1095         NaN(),           // fmod(+Inf, 0)
1096         NaN(),           // fmod(+Inf, Pi)
1097         NaN(),           // fmod(+Inf, +Inf)
1098         NaN(),           // fmod(+Inf, NaN)
1099         NaN(),           // fmod(NaN, -Inf)
1100         NaN(),           // fmod(NaN, -Pi)
1101         NaN(),           // fmod(NaN, 0)
1102         NaN(),           // fmod(NaN, Pi)
1103         NaN(),           // fmod(NaN, +Inf)
1104         NaN(),           // fmod(NaN, NaN)
1105 }
1106
1107 var vffrexpSC = []float64{
1108         Inf(-1),
1109         Copysign(0, -1),
1110         0,
1111         Inf(1),
1112         NaN(),
1113 }
1114 var frexpSC = []fi{
1115         {Inf(-1), 0},
1116         {Copysign(0, -1), 0},
1117         {0, 0},
1118         {Inf(1), 0},
1119         {NaN(), 0},
1120 }
1121
1122 var vfgammaSC = []float64{
1123         Inf(-1),
1124         -3,
1125         Copysign(0, -1),
1126         0,
1127         Inf(1),
1128         NaN(),
1129 }
1130 var gammaSC = []float64{
1131         Inf(-1),
1132         Inf(1),
1133         Inf(1),
1134         Inf(1),
1135         Inf(1),
1136         NaN(),
1137 }
1138
1139 var vfhypotSC = [][2]float64{
1140         {Inf(-1), Inf(-1)},
1141         {Inf(-1), 0},
1142         {Inf(-1), Inf(1)},
1143         {Inf(-1), NaN()},
1144         {Copysign(0, -1), Copysign(0, -1)},
1145         {Copysign(0, -1), 0},
1146         {0, Copysign(0, -1)},
1147         {0, 0}, // +0, +0
1148         {0, Inf(-1)},
1149         {0, Inf(1)},
1150         {0, NaN()},
1151         {Inf(1), Inf(-1)},
1152         {Inf(1), 0},
1153         {Inf(1), Inf(1)},
1154         {Inf(1), NaN()},
1155         {NaN(), Inf(-1)},
1156         {NaN(), 0},
1157         {NaN(), Inf(1)},
1158         {NaN(), NaN()},
1159 }
1160 var hypotSC = []float64{
1161         Inf(1),
1162         Inf(1),
1163         Inf(1),
1164         Inf(1),
1165         0,
1166         0,
1167         0,
1168         0,
1169         Inf(1),
1170         Inf(1),
1171         NaN(),
1172         Inf(1),
1173         Inf(1),
1174         Inf(1),
1175         Inf(1),
1176         Inf(1),
1177         NaN(),
1178         Inf(1),
1179         NaN(),
1180 }
1181
1182 var vfilogbSC = []float64{
1183         Inf(-1),
1184         0,
1185         Inf(1),
1186         NaN(),
1187 }
1188 var ilogbSC = []int{
1189         MaxInt32,
1190         MinInt32,
1191         MaxInt32,
1192         MaxInt32,
1193 }
1194
1195 var vfj0SC = []float64{
1196         Inf(-1),
1197         0,
1198         Inf(1),
1199         NaN(),
1200 }
1201 var j0SC = []float64{
1202         0,
1203         1,
1204         0,
1205         NaN(),
1206 }
1207 var j1SC = []float64{
1208         0,
1209         0,
1210         0,
1211         NaN(),
1212 }
1213 var j2SC = []float64{
1214         0,
1215         0,
1216         0,
1217         NaN(),
1218 }
1219 var jM3SC = []float64{
1220         0,
1221         0,
1222         0,
1223         NaN(),
1224 }
1225
1226 var vfldexpSC = []fi{
1227         {0, 0},
1228         {0, -1075},
1229         {0, 1024},
1230         {Copysign(0, -1), 0},
1231         {Copysign(0, -1), -1075},
1232         {Copysign(0, -1), 1024},
1233         {Inf(1), 0},
1234         {Inf(1), -1024},
1235         {Inf(-1), 0},
1236         {Inf(-1), -1024},
1237         {NaN(), -1024},
1238 }
1239 var ldexpSC = []float64{
1240         0,
1241         0,
1242         0,
1243         Copysign(0, -1),
1244         Copysign(0, -1),
1245         Copysign(0, -1),
1246         Inf(1),
1247         Inf(1),
1248         Inf(-1),
1249         Inf(-1),
1250         NaN(),
1251 }
1252
1253 var vflgammaSC = []float64{
1254         Inf(-1),
1255         -3,
1256         0,
1257         1,
1258         2,
1259         Inf(1),
1260         NaN(),
1261 }
1262 var lgammaSC = []fi{
1263         {Inf(-1), 1},
1264         {Inf(1), 1},
1265         {Inf(1), 1},
1266         {0, 1},
1267         {0, 1},
1268         {Inf(1), 1},
1269         {NaN(), 1},
1270 }
1271
1272 var vflogSC = []float64{
1273         Inf(-1),
1274         -Pi,
1275         Copysign(0, -1),
1276         0,
1277         1,
1278         Inf(1),
1279         NaN(),
1280 }
1281 var logSC = []float64{
1282         NaN(),
1283         NaN(),
1284         Inf(-1),
1285         Inf(-1),
1286         0,
1287         Inf(1),
1288         NaN(),
1289 }
1290
1291 var vflogbSC = []float64{
1292         Inf(-1),
1293         0,
1294         Inf(1),
1295         NaN(),
1296 }
1297 var logbSC = []float64{
1298         Inf(1),
1299         Inf(-1),
1300         Inf(1),
1301         NaN(),
1302 }
1303
1304 var vflog1pSC = []float64{
1305         Inf(-1),
1306         -Pi,
1307         -1,
1308         Copysign(0, -1),
1309         0,
1310         Inf(1),
1311         NaN(),
1312 }
1313 var log1pSC = []float64{
1314         NaN(),
1315         NaN(),
1316         Inf(-1),
1317         Copysign(0, -1),
1318         0,
1319         Inf(1),
1320         NaN(),
1321 }
1322
1323 var vfmodfSC = []float64{
1324         Inf(-1),
1325         Inf(1),
1326         NaN(),
1327 }
1328 var modfSC = [][2]float64{
1329         {Inf(-1), NaN()}, // [2]float64{Copysign(0, -1), Inf(-1)},
1330         {Inf(1), NaN()},  // [2]float64{0, Inf(1)},
1331         {NaN(), NaN()},
1332 }
1333
1334 var vfnextafterSC = [][2]float64{
1335         {0, 0},
1336         {0, Copysign(0, -1)},
1337         {0, -1},
1338         {0, NaN()},
1339         {Copysign(0, -1), 1},
1340         {Copysign(0, -1), 0},
1341         {Copysign(0, -1), Copysign(0, -1)},
1342         {Copysign(0, -1), -1},
1343         {NaN(), 0},
1344         {NaN(), NaN()},
1345 }
1346 var nextafterSC = []float64{
1347         0,
1348         0,
1349         -4.9406564584124654418e-324, // Float64frombits(0x8000000000000001)
1350         NaN(),
1351         4.9406564584124654418e-324, // Float64frombits(0x0000000000000001)
1352         Copysign(0, -1),
1353         Copysign(0, -1),
1354         -4.9406564584124654418e-324, // Float64frombits(0x8000000000000001)
1355         NaN(),
1356         NaN(),
1357 }
1358
1359 var vfpowSC = [][2]float64{
1360         {Inf(-1), -Pi},
1361         {Inf(-1), -3},
1362         {Inf(-1), Copysign(0, -1)},
1363         {Inf(-1), 0},
1364         {Inf(-1), 1},
1365         {Inf(-1), 3},
1366         {Inf(-1), Pi},
1367         {Inf(-1), NaN()},
1368
1369         {-Pi, Inf(-1)},
1370         {-Pi, -Pi},
1371         {-Pi, Copysign(0, -1)},
1372         {-Pi, 0},
1373         {-Pi, 1},
1374         {-Pi, Pi},
1375         {-Pi, Inf(1)},
1376         {-Pi, NaN()},
1377
1378         {-1, Inf(-1)},
1379         {-1, Inf(1)},
1380         {-1, NaN()},
1381         {-1 / 2, Inf(-1)},
1382         {-1 / 2, Inf(1)},
1383         {Copysign(0, -1), Inf(-1)},
1384         {Copysign(0, -1), -Pi},
1385         {Copysign(0, -1), -3},
1386         {Copysign(0, -1), 3},
1387         {Copysign(0, -1), Pi},
1388         {Copysign(0, -1), Inf(1)},
1389
1390         {0, Inf(-1)},
1391         {0, -Pi},
1392         {0, -3},
1393         {0, Copysign(0, -1)},
1394         {0, 0},
1395         {0, 3},
1396         {0, Pi},
1397         {0, Inf(1)},
1398         {0, NaN()},
1399
1400         {1 / 2, Inf(-1)},
1401         {1 / 2, Inf(1)},
1402         {1, Inf(-1)},
1403         {1, Inf(1)},
1404         {1, NaN()},
1405
1406         {Pi, Inf(-1)},
1407         {Pi, Copysign(0, -1)},
1408         {Pi, 0},
1409         {Pi, 1},
1410         {Pi, Inf(1)},
1411         {Pi, NaN()},
1412         {Inf(1), -Pi},
1413         {Inf(1), Copysign(0, -1)},
1414         {Inf(1), 0},
1415         {Inf(1), 1},
1416         {Inf(1), Pi},
1417         {Inf(1), NaN()},
1418         {NaN(), -Pi},
1419         {NaN(), Copysign(0, -1)},
1420         {NaN(), 0},
1421         {NaN(), 1},
1422         {NaN(), Pi},
1423         {NaN(), NaN()},
1424 }
1425 var powSC = []float64{
1426         0,               // pow(-Inf, -Pi)
1427         Copysign(0, -1), // pow(-Inf, -3)
1428         1,               // pow(-Inf, -0)
1429         1,               // pow(-Inf, +0)
1430         Inf(-1),         // pow(-Inf, 1)
1431         Inf(-1),         // pow(-Inf, 3)
1432         Inf(1),          // pow(-Inf, Pi)
1433         NaN(),           // pow(-Inf, NaN)
1434         0,               // pow(-Pi, -Inf)
1435         NaN(),           // pow(-Pi, -Pi)
1436         1,               // pow(-Pi, -0)
1437         1,               // pow(-Pi, +0)
1438         -Pi,             // pow(-Pi, 1)
1439         NaN(),           // pow(-Pi, Pi)
1440         Inf(1),          // pow(-Pi, +Inf)
1441         NaN(),           // pow(-Pi, NaN)
1442         1,               // pow(-1, -Inf) IEEE 754-2008
1443         1,               // pow(-1, +Inf) IEEE 754-2008
1444         NaN(),           // pow(-1, NaN)
1445         Inf(1),          // pow(-1/2, -Inf)
1446         0,               // pow(-1/2, +Inf)
1447         Inf(1),          // pow(-0, -Inf)
1448         Inf(1),          // pow(-0, -Pi)
1449         Inf(-1),         // pow(-0, -3) IEEE 754-2008
1450         Copysign(0, -1), // pow(-0, 3) IEEE 754-2008
1451         0,               // pow(-0, +Pi)
1452         0,               // pow(-0, +Inf)
1453         Inf(1),          // pow(+0, -Inf)
1454         Inf(1),          // pow(+0, -Pi)
1455         Inf(1),          // pow(+0, -3)
1456         1,               // pow(+0, -0)
1457         1,               // pow(+0, +0)
1458         0,               // pow(+0, 3)
1459         0,               // pow(+0, +Pi)
1460         0,               // pow(+0, +Inf)
1461         NaN(),           // pow(+0, NaN)
1462         Inf(1),          // pow(1/2, -Inf)
1463         0,               // pow(1/2, +Inf)
1464         1,               // pow(1, -Inf) IEEE 754-2008
1465         1,               // pow(1, +Inf) IEEE 754-2008
1466         1,               // pow(1, NaN) IEEE 754-2008
1467         0,               // pow(+Pi, -Inf)
1468         1,               // pow(+Pi, -0)
1469         1,               // pow(+Pi, +0)
1470         Pi,              // pow(+Pi, 1)
1471         Inf(1),          // pow(+Pi, +Inf)
1472         NaN(),           // pow(+Pi, NaN)
1473         0,               // pow(+Inf, -Pi)
1474         1,               // pow(+Inf, -0)
1475         1,               // pow(+Inf, +0)
1476         Inf(1),          // pow(+Inf, 1)
1477         Inf(1),          // pow(+Inf, Pi)
1478         NaN(),           // pow(+Inf, NaN)
1479         NaN(),           // pow(NaN, -Pi)
1480         1,               // pow(NaN, -0)
1481         1,               // pow(NaN, +0)
1482         NaN(),           // pow(NaN, 1)
1483         NaN(),           // pow(NaN, +Pi)
1484         NaN(),           // pow(NaN, NaN)
1485 }
1486
1487 var vfpow10SC = []int{
1488         MinInt32,
1489         MaxInt32,
1490         -325,
1491         309,
1492 }
1493
1494 var pow10SC = []float64{
1495         0,      // pow10(MinInt32)
1496         Inf(1), // pow10(MaxInt32)
1497         0,      // pow10(-325)
1498         Inf(1), // pow10(309)
1499 }
1500
1501 var vfsignbitSC = []float64{
1502         Inf(-1),
1503         Copysign(0, -1),
1504         0,
1505         Inf(1),
1506         NaN(),
1507 }
1508 var signbitSC = []bool{
1509         true,
1510         true,
1511         false,
1512         false,
1513         false,
1514 }
1515
1516 var vfsinSC = []float64{
1517         Inf(-1),
1518         Copysign(0, -1),
1519         0,
1520         Inf(1),
1521         NaN(),
1522 }
1523 var sinSC = []float64{
1524         NaN(),
1525         Copysign(0, -1),
1526         0,
1527         NaN(),
1528         NaN(),
1529 }
1530
1531 var vfsinhSC = []float64{
1532         Inf(-1),
1533         Copysign(0, -1),
1534         0,
1535         Inf(1),
1536         NaN(),
1537 }
1538 var sinhSC = []float64{
1539         Inf(-1),
1540         Copysign(0, -1),
1541         0,
1542         Inf(1),
1543         NaN(),
1544 }
1545
1546 var vfsqrtSC = []float64{
1547         Inf(-1),
1548         -Pi,
1549         Copysign(0, -1),
1550         0,
1551         Inf(1),
1552         NaN(),
1553 }
1554 var sqrtSC = []float64{
1555         NaN(),
1556         NaN(),
1557         Copysign(0, -1),
1558         0,
1559         Inf(1),
1560         NaN(),
1561 }
1562
1563 var vftanhSC = []float64{
1564         Inf(-1),
1565         Copysign(0, -1),
1566         0,
1567         Inf(1),
1568         NaN(),
1569 }
1570 var tanhSC = []float64{
1571         -1,
1572         Copysign(0, -1),
1573         0,
1574         1,
1575         NaN(),
1576 }
1577
1578 var vfy0SC = []float64{
1579         Inf(-1),
1580         0,
1581         Inf(1),
1582         NaN(),
1583 }
1584 var y0SC = []float64{
1585         NaN(),
1586         Inf(-1),
1587         0,
1588         NaN(),
1589 }
1590 var y1SC = []float64{
1591         NaN(),
1592         Inf(-1),
1593         0,
1594         NaN(),
1595 }
1596 var y2SC = []float64{
1597         NaN(),
1598         Inf(-1),
1599         0,
1600         NaN(),
1601 }
1602 var yM3SC = []float64{
1603         NaN(),
1604         Inf(1),
1605         0,
1606         NaN(),
1607 }
1608
1609 // arguments and expected results for boundary cases
1610 const (
1611         SmallestNormalFloat64   = 2.2250738585072014e-308 // 2**-1022
1612         LargestSubnormalFloat64 = SmallestNormalFloat64 - SmallestNonzeroFloat64
1613 )
1614
1615 var vffrexpBC = []float64{
1616         SmallestNormalFloat64,
1617         LargestSubnormalFloat64,
1618         SmallestNonzeroFloat64,
1619         MaxFloat64,
1620         -SmallestNormalFloat64,
1621         -LargestSubnormalFloat64,
1622         -SmallestNonzeroFloat64,
1623         -MaxFloat64,
1624 }
1625 var frexpBC = []fi{
1626         {0.5, -1021},
1627         {0.99999999999999978, -1022},
1628         {0.5, -1073},
1629         {0.99999999999999989, 1024},
1630         {-0.5, -1021},
1631         {-0.99999999999999978, -1022},
1632         {-0.5, -1073},
1633         {-0.99999999999999989, 1024},
1634 }
1635
1636 var vfldexpBC = []fi{
1637         {SmallestNormalFloat64, -52},
1638         {LargestSubnormalFloat64, -51},
1639         {SmallestNonzeroFloat64, 1074},
1640         {MaxFloat64, -(1023 + 1074)},
1641         {1, -1075},
1642         {-1, -1075},
1643         {1, 1024},
1644         {-1, 1024},
1645 }
1646 var ldexpBC = []float64{
1647         SmallestNonzeroFloat64,
1648         1e-323, // 2**-1073
1649         1,
1650         1e-323, // 2**-1073
1651         0,
1652         Copysign(0, -1),
1653         Inf(1),
1654         Inf(-1),
1655 }
1656
1657 var logbBC = []float64{
1658         -1022,
1659         -1023,
1660         -1074,
1661         1023,
1662         -1022,
1663         -1023,
1664         -1074,
1665         1023,
1666 }
1667
1668 func tolerance(a, b, e float64) bool {
1669         d := a - b
1670         if d < 0 {
1671                 d = -d
1672         }
1673
1674         if a != 0 {
1675                 e = e * a
1676                 if e < 0 {
1677                         e = -e
1678                 }
1679         }
1680         return d < e
1681 }
1682 func kindaclose(a, b float64) bool { return tolerance(a, b, 1e-8) }
1683 func close(a, b float64) bool      { return tolerance(a, b, 1e-14) }
1684 func veryclose(a, b float64) bool  { return tolerance(a, b, 4e-16) }
1685 func soclose(a, b, e float64) bool { return tolerance(a, b, e) }
1686 func alike(a, b float64) bool {
1687         switch {
1688         case IsNaN(a) && IsNaN(b):
1689                 return true
1690         case a == b:
1691                 return Signbit(a) == Signbit(b)
1692         }
1693         return false
1694 }
1695
1696 func TestAcos(t *testing.T) {
1697         for i := 0; i < len(vf); i++ {
1698                 a := vf[i] / 10
1699                 if f := Acos(a); !close(acos[i], f) {
1700                         t.Errorf("Acos(%g) = %g, want %g", a, f, acos[i])
1701                 }
1702         }
1703         for i := 0; i < len(vfacosSC); i++ {
1704                 if f := Acos(vfacosSC[i]); !alike(acosSC[i], f) {
1705                         t.Errorf("Acos(%g) = %g, want %g", vfacosSC[i], f, acosSC[i])
1706                 }
1707         }
1708 }
1709
1710 func TestAcosh(t *testing.T) {
1711         for i := 0; i < len(vf); i++ {
1712                 a := 1 + Abs(vf[i])
1713                 if f := Acosh(a); !veryclose(acosh[i], f) {
1714                         t.Errorf("Acosh(%g) = %g, want %g", a, f, acosh[i])
1715                 }
1716         }
1717         for i := 0; i < len(vfacoshSC); i++ {
1718                 if f := Acosh(vfacoshSC[i]); !alike(acoshSC[i], f) {
1719                         t.Errorf("Acosh(%g) = %g, want %g", vfacoshSC[i], f, acoshSC[i])
1720                 }
1721         }
1722 }
1723
1724 func TestAsin(t *testing.T) {
1725         for i := 0; i < len(vf); i++ {
1726                 a := vf[i] / 10
1727                 if f := Asin(a); !veryclose(asin[i], f) {
1728                         t.Errorf("Asin(%g) = %g, want %g", a, f, asin[i])
1729                 }
1730         }
1731         for i := 0; i < len(vfasinSC); i++ {
1732                 if f := Asin(vfasinSC[i]); !alike(asinSC[i], f) {
1733                         t.Errorf("Asin(%g) = %g, want %g", vfasinSC[i], f, asinSC[i])
1734                 }
1735         }
1736 }
1737
1738 func TestAsinh(t *testing.T) {
1739         for i := 0; i < len(vf); i++ {
1740                 if f := Asinh(vf[i]); !veryclose(asinh[i], f) {
1741                         t.Errorf("Asinh(%g) = %g, want %g", vf[i], f, asinh[i])
1742                 }
1743         }
1744         for i := 0; i < len(vfasinhSC); i++ {
1745                 if f := Asinh(vfasinhSC[i]); !alike(asinhSC[i], f) {
1746                         t.Errorf("Asinh(%g) = %g, want %g", vfasinhSC[i], f, asinhSC[i])
1747                 }
1748         }
1749 }
1750
1751 func TestAtan(t *testing.T) {
1752         for i := 0; i < len(vf); i++ {
1753                 if f := Atan(vf[i]); !veryclose(atan[i], f) {
1754                         t.Errorf("Atan(%g) = %g, want %g", vf[i], f, atan[i])
1755                 }
1756         }
1757         for i := 0; i < len(vfatanSC); i++ {
1758                 if f := Atan(vfatanSC[i]); !alike(atanSC[i], f) {
1759                         t.Errorf("Atan(%g) = %g, want %g", vfatanSC[i], f, atanSC[i])
1760                 }
1761         }
1762 }
1763
1764 func TestAtanh(t *testing.T) {
1765         for i := 0; i < len(vf); i++ {
1766                 a := vf[i] / 10
1767                 if f := Atanh(a); !veryclose(atanh[i], f) {
1768                         t.Errorf("Atanh(%g) = %g, want %g", a, f, atanh[i])
1769                 }
1770         }
1771         for i := 0; i < len(vfatanhSC); i++ {
1772                 if f := Atanh(vfatanhSC[i]); !alike(atanhSC[i], f) {
1773                         t.Errorf("Atanh(%g) = %g, want %g", vfatanhSC[i], f, atanhSC[i])
1774                 }
1775         }
1776 }
1777
1778 func TestAtan2(t *testing.T) {
1779         for i := 0; i < len(vf); i++ {
1780                 if f := Atan2(10, vf[i]); !veryclose(atan2[i], f) {
1781                         t.Errorf("Atan2(10, %g) = %g, want %g", vf[i], f, atan2[i])
1782                 }
1783         }
1784         for i := 0; i < len(vfatan2SC); i++ {
1785                 if f := Atan2(vfatan2SC[i][0], vfatan2SC[i][1]); !alike(atan2SC[i], f) {
1786                         t.Errorf("Atan2(%g, %g) = %g, want %g", vfatan2SC[i][0], vfatan2SC[i][1], f, atan2SC[i])
1787                 }
1788         }
1789 }
1790
1791 func TestCbrt(t *testing.T) {
1792         for i := 0; i < len(vf); i++ {
1793                 if f := Cbrt(vf[i]); !veryclose(cbrt[i], f) {
1794                         t.Errorf("Cbrt(%g) = %g, want %g", vf[i], f, cbrt[i])
1795                 }
1796         }
1797         for i := 0; i < len(vfcbrtSC); i++ {
1798                 if f := Cbrt(vfcbrtSC[i]); !alike(cbrtSC[i], f) {
1799                         t.Errorf("Cbrt(%g) = %g, want %g", vfcbrtSC[i], f, cbrtSC[i])
1800                 }
1801         }
1802 }
1803
1804 func TestCeil(t *testing.T) {
1805         for i := 0; i < len(vf); i++ {
1806                 if f := Ceil(vf[i]); ceil[i] != f {
1807                         t.Errorf("Ceil(%g) = %g, want %g", vf[i], f, ceil[i])
1808                 }
1809         }
1810         for i := 0; i < len(vfceilSC); i++ {
1811                 if f := Ceil(vfceilSC[i]); !alike(ceilSC[i], f) {
1812                         t.Errorf("Ceil(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
1813                 }
1814         }
1815 }
1816
1817 func TestCopysign(t *testing.T) {
1818         for i := 0; i < len(vf); i++ {
1819                 if f := Copysign(vf[i], -1); copysign[i] != f {
1820                         t.Errorf("Copysign(%g, -1) = %g, want %g", vf[i], f, copysign[i])
1821                 }
1822         }
1823         for i := 0; i < len(vf); i++ {
1824                 if f := Copysign(vf[i], 1); -copysign[i] != f {
1825                         t.Errorf("Copysign(%g, 1) = %g, want %g", vf[i], f, -copysign[i])
1826                 }
1827         }
1828         for i := 0; i < len(vfcopysignSC); i++ {
1829                 if f := Copysign(vfcopysignSC[i], -1); !alike(copysignSC[i], f) {
1830                         t.Errorf("Copysign(%g, -1) = %g, want %g", vfcopysignSC[i], f, copysignSC[i])
1831                 }
1832         }
1833 }
1834
1835 func TestCos(t *testing.T) {
1836         for i := 0; i < len(vf); i++ {
1837                 if f := Cos(vf[i]); !veryclose(cos[i], f) {
1838                         t.Errorf("Cos(%g) = %g, want %g", vf[i], f, cos[i])
1839                 }
1840         }
1841         for i := 0; i < len(vfcosSC); i++ {
1842                 if f := Cos(vfcosSC[i]); !alike(cosSC[i], f) {
1843                         t.Errorf("Cos(%g) = %g, want %g", vfcosSC[i], f, cosSC[i])
1844                 }
1845         }
1846 }
1847
1848 func TestCosh(t *testing.T) {
1849         for i := 0; i < len(vf); i++ {
1850                 if f := Cosh(vf[i]); !close(cosh[i], f) {
1851                         t.Errorf("Cosh(%g) = %g, want %g", vf[i], f, cosh[i])
1852                 }
1853         }
1854         for i := 0; i < len(vfcoshSC); i++ {
1855                 if f := Cosh(vfcoshSC[i]); !alike(coshSC[i], f) {
1856                         t.Errorf("Cosh(%g) = %g, want %g", vfcoshSC[i], f, coshSC[i])
1857                 }
1858         }
1859 }
1860
1861 func TestErf(t *testing.T) {
1862         for i := 0; i < len(vf); i++ {
1863                 a := vf[i] / 10
1864                 if f := Erf(a); !veryclose(erf[i], f) {
1865                         t.Errorf("Erf(%g) = %g, want %g", a, f, erf[i])
1866                 }
1867         }
1868         for i := 0; i < len(vferfSC); i++ {
1869                 if f := Erf(vferfSC[i]); !alike(erfSC[i], f) {
1870                         t.Errorf("Erf(%g) = %g, want %g", vferfSC[i], f, erfSC[i])
1871                 }
1872         }
1873 }
1874
1875 func TestErfc(t *testing.T) {
1876         for i := 0; i < len(vf); i++ {
1877                 a := vf[i] / 10
1878                 if f := Erfc(a); !veryclose(erfc[i], f) {
1879                         t.Errorf("Erfc(%g) = %g, want %g", a, f, erfc[i])
1880                 }
1881         }
1882         for i := 0; i < len(vferfcSC); i++ {
1883                 if f := Erfc(vferfcSC[i]); !alike(erfcSC[i], f) {
1884                         t.Errorf("Erfc(%g) = %g, want %g", vferfcSC[i], f, erfcSC[i])
1885                 }
1886         }
1887 }
1888
1889 func TestExp(t *testing.T) {
1890         testExp(t, Exp, "Exp")
1891         testExp(t, ExpGo, "ExpGo")
1892 }
1893
1894 func testExp(t *testing.T, Exp func(float64) float64, name string) {
1895         for i := 0; i < len(vf); i++ {
1896                 if f := Exp(vf[i]); !close(exp[i], f) {
1897                         t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp[i])
1898                 }
1899         }
1900         for i := 0; i < len(vfexpSC); i++ {
1901                 if f := Exp(vfexpSC[i]); !alike(expSC[i], f) {
1902                         t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i])
1903                 }
1904         }
1905 }
1906
1907 func TestExpm1(t *testing.T) {
1908         for i := 0; i < len(vf); i++ {
1909                 a := vf[i] / 100
1910                 if f := Expm1(a); !veryclose(expm1[i], f) {
1911                         t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1[i])
1912                 }
1913         }
1914         for i := 0; i < len(vfexpm1SC); i++ {
1915                 if f := Expm1(vfexpm1SC[i]); !alike(expm1SC[i], f) {
1916                         t.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC[i], f, expm1SC[i])
1917                 }
1918         }
1919 }
1920
1921 func TestExp2(t *testing.T) {
1922         testExp2(t, Exp2, "Exp2")
1923         testExp2(t, Exp2Go, "Exp2Go")
1924 }
1925
1926 func testExp2(t *testing.T, Exp2 func(float64) float64, name string) {
1927         for i := 0; i < len(vf); i++ {
1928                 if f := Exp2(vf[i]); !close(exp2[i], f) {
1929                         t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp2[i])
1930                 }
1931         }
1932         for i := 0; i < len(vfexpSC); i++ {
1933                 if f := Exp2(vfexpSC[i]); !alike(expSC[i], f) {
1934                         t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i])
1935                 }
1936         }
1937         for n := -1074; n < 1024; n++ {
1938                 f := Exp2(float64(n))
1939                 vf := Ldexp(1, n)
1940                 if f != vf {
1941                         t.Errorf("%s(%d) = %g, want %g", name, n, f, vf)
1942                 }
1943         }
1944 }
1945
1946 func TestAbs(t *testing.T) {
1947         for i := 0; i < len(vf); i++ {
1948                 if f := Abs(vf[i]); fabs[i] != f {
1949                         t.Errorf("Abs(%g) = %g, want %g", vf[i], f, fabs[i])
1950                 }
1951         }
1952         for i := 0; i < len(vffabsSC); i++ {
1953                 if f := Abs(vffabsSC[i]); !alike(fabsSC[i], f) {
1954                         t.Errorf("Abs(%g) = %g, want %g", vffabsSC[i], f, fabsSC[i])
1955                 }
1956         }
1957 }
1958
1959 func TestDim(t *testing.T) {
1960         for i := 0; i < len(vf); i++ {
1961                 if f := Dim(vf[i], 0); fdim[i] != f {
1962                         t.Errorf("Dim(%g, %g) = %g, want %g", vf[i], 0.0, f, fdim[i])
1963                 }
1964         }
1965         for i := 0; i < len(vffdimSC); i++ {
1966                 if f := Dim(vffdimSC[i][0], vffdimSC[i][1]); !alike(fdimSC[i], f) {
1967                         t.Errorf("Dim(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fdimSC[i])
1968                 }
1969         }
1970 }
1971
1972 func TestFloor(t *testing.T) {
1973         for i := 0; i < len(vf); i++ {
1974                 if f := Floor(vf[i]); floor[i] != f {
1975                         t.Errorf("Floor(%g) = %g, want %g", vf[i], f, floor[i])
1976                 }
1977         }
1978         for i := 0; i < len(vfceilSC); i++ {
1979                 if f := Floor(vfceilSC[i]); !alike(ceilSC[i], f) {
1980                         t.Errorf("Floor(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
1981                 }
1982         }
1983 }
1984
1985 func TestMax(t *testing.T) {
1986         for i := 0; i < len(vf); i++ {
1987                 if f := Max(vf[i], ceil[i]); ceil[i] != f {
1988                         t.Errorf("Max(%g, %g) = %g, want %g", vf[i], ceil[i], f, ceil[i])
1989                 }
1990         }
1991         for i := 0; i < len(vffdimSC); i++ {
1992                 if f := Max(vffdimSC[i][0], vffdimSC[i][1]); !alike(fmaxSC[i], f) {
1993                         t.Errorf("Max(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fmaxSC[i])
1994                 }
1995         }
1996 }
1997
1998 func TestMin(t *testing.T) {
1999         for i := 0; i < len(vf); i++ {
2000                 if f := Min(vf[i], floor[i]); floor[i] != f {
2001                         t.Errorf("Min(%g, %g) = %g, want %g", vf[i], floor[i], f, floor[i])
2002                 }
2003         }
2004         for i := 0; i < len(vffdimSC); i++ {
2005                 if f := Min(vffdimSC[i][0], vffdimSC[i][1]); !alike(fminSC[i], f) {
2006                         t.Errorf("Min(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fminSC[i])
2007                 }
2008         }
2009 }
2010
2011 func TestMod(t *testing.T) {
2012         for i := 0; i < len(vf); i++ {
2013                 if f := Mod(10, vf[i]); fmod[i] != f {
2014                         t.Errorf("Mod(10, %g) = %g, want %g", vf[i], f, fmod[i])
2015                 }
2016         }
2017         for i := 0; i < len(vffmodSC); i++ {
2018                 if f := Mod(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
2019                         t.Errorf("Mod(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
2020                 }
2021         }
2022 }
2023
2024 func TestFrexp(t *testing.T) {
2025         for i := 0; i < len(vf); i++ {
2026                 if f, j := Frexp(vf[i]); !veryclose(frexp[i].f, f) || frexp[i].i != j {
2027                         t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vf[i], f, j, frexp[i].f, frexp[i].i)
2028                 }
2029         }
2030         for i := 0; i < len(vffrexpSC); i++ {
2031                 if f, j := Frexp(vffrexpSC[i]); !alike(frexpSC[i].f, f) || frexpSC[i].i != j {
2032                         t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpSC[i], f, j, frexpSC[i].f, frexpSC[i].i)
2033                 }
2034         }
2035         for i := 0; i < len(vffrexpBC); i++ {
2036                 if f, j := Frexp(vffrexpBC[i]); !alike(frexpBC[i].f, f) || frexpBC[i].i != j {
2037                         t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpBC[i], f, j, frexpBC[i].f, frexpBC[i].i)
2038                 }
2039         }
2040 }
2041
2042 func TestGamma(t *testing.T) {
2043         for i := 0; i < len(vf); i++ {
2044                 if f := Gamma(vf[i]); !close(gamma[i], f) {
2045                         t.Errorf("Gamma(%g) = %g, want %g", vf[i], f, gamma[i])
2046                 }
2047         }
2048         for i := 0; i < len(vfgammaSC); i++ {
2049                 if f := Gamma(vfgammaSC[i]); !alike(gammaSC[i], f) {
2050                         t.Errorf("Gamma(%g) = %g, want %g", vfgammaSC[i], f, gammaSC[i])
2051                 }
2052         }
2053 }
2054
2055 func TestHypot(t *testing.T) {
2056         for i := 0; i < len(vf); i++ {
2057                 a := Abs(1e200 * tanh[i] * Sqrt(2))
2058                 if f := Hypot(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
2059                         t.Errorf("Hypot(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
2060                 }
2061         }
2062         for i := 0; i < len(vfhypotSC); i++ {
2063                 if f := Hypot(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) {
2064                         t.Errorf("Hypot(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i])
2065                 }
2066         }
2067 }
2068
2069 func TestHypotGo(t *testing.T) {
2070         for i := 0; i < len(vf); i++ {
2071                 a := Abs(1e200 * tanh[i] * Sqrt(2))
2072                 if f := HypotGo(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
2073                         t.Errorf("HypotGo(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
2074                 }
2075         }
2076         for i := 0; i < len(vfhypotSC); i++ {
2077                 if f := HypotGo(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) {
2078                         t.Errorf("HypotGo(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i])
2079                 }
2080         }
2081 }
2082
2083 func TestIlogb(t *testing.T) {
2084         for i := 0; i < len(vf); i++ {
2085                 a := frexp[i].i - 1 // adjust because fr in the interval [½, 1)
2086                 if e := Ilogb(vf[i]); a != e {
2087                         t.Errorf("Ilogb(%g) = %d, want %d", vf[i], e, a)
2088                 }
2089         }
2090         for i := 0; i < len(vflogbSC); i++ {
2091                 if e := Ilogb(vflogbSC[i]); ilogbSC[i] != e {
2092                         t.Errorf("Ilogb(%g) = %d, want %d", vflogbSC[i], e, ilogbSC[i])
2093                 }
2094         }
2095         for i := 0; i < len(vffrexpBC); i++ {
2096                 if e := Ilogb(vffrexpBC[i]); int(logbBC[i]) != e {
2097                         t.Errorf("Ilogb(%g) = %d, want %d", vffrexpBC[i], e, int(logbBC[i]))
2098                 }
2099         }
2100 }
2101
2102 func TestJ0(t *testing.T) {
2103         for i := 0; i < len(vf); i++ {
2104                 if f := J0(vf[i]); !soclose(j0[i], f, 4e-14) {
2105                         t.Errorf("J0(%g) = %g, want %g", vf[i], f, j0[i])
2106                 }
2107         }
2108         for i := 0; i < len(vfj0SC); i++ {
2109                 if f := J0(vfj0SC[i]); !alike(j0SC[i], f) {
2110                         t.Errorf("J0(%g) = %g, want %g", vfj0SC[i], f, j0SC[i])
2111                 }
2112         }
2113 }
2114
2115 func TestJ1(t *testing.T) {
2116         for i := 0; i < len(vf); i++ {
2117                 if f := J1(vf[i]); !close(j1[i], f) {
2118                         t.Errorf("J1(%g) = %g, want %g", vf[i], f, j1[i])
2119                 }
2120         }
2121         for i := 0; i < len(vfj0SC); i++ {
2122                 if f := J1(vfj0SC[i]); !alike(j1SC[i], f) {
2123                         t.Errorf("J1(%g) = %g, want %g", vfj0SC[i], f, j1SC[i])
2124                 }
2125         }
2126 }
2127
2128 func TestJn(t *testing.T) {
2129         for i := 0; i < len(vf); i++ {
2130                 if f := Jn(2, vf[i]); !close(j2[i], f) {
2131                         t.Errorf("Jn(2, %g) = %g, want %g", vf[i], f, j2[i])
2132                 }
2133                 if f := Jn(-3, vf[i]); !close(jM3[i], f) {
2134                         t.Errorf("Jn(-3, %g) = %g, want %g", vf[i], f, jM3[i])
2135                 }
2136         }
2137         for i := 0; i < len(vfj0SC); i++ {
2138                 if f := Jn(2, vfj0SC[i]); !alike(j2SC[i], f) {
2139                         t.Errorf("Jn(2, %g) = %g, want %g", vfj0SC[i], f, j2SC[i])
2140                 }
2141                 if f := Jn(-3, vfj0SC[i]); !alike(jM3SC[i], f) {
2142                         t.Errorf("Jn(-3, %g) = %g, want %g", vfj0SC[i], f, jM3SC[i])
2143                 }
2144         }
2145 }
2146
2147 func TestLdexp(t *testing.T) {
2148         for i := 0; i < len(vf); i++ {
2149                 if f := Ldexp(frexp[i].f, frexp[i].i); !veryclose(vf[i], f) {
2150                         t.Errorf("Ldexp(%g, %d) = %g, want %g", frexp[i].f, frexp[i].i, f, vf[i])
2151                 }
2152         }
2153         for i := 0; i < len(vffrexpSC); i++ {
2154                 if f := Ldexp(frexpSC[i].f, frexpSC[i].i); !alike(vffrexpSC[i], f) {
2155                         t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpSC[i].f, frexpSC[i].i, f, vffrexpSC[i])
2156                 }
2157         }
2158         for i := 0; i < len(vfldexpSC); i++ {
2159                 if f := Ldexp(vfldexpSC[i].f, vfldexpSC[i].i); !alike(ldexpSC[i], f) {
2160                         t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpSC[i].f, vfldexpSC[i].i, f, ldexpSC[i])
2161                 }
2162         }
2163         for i := 0; i < len(vffrexpBC); i++ {
2164                 if f := Ldexp(frexpBC[i].f, frexpBC[i].i); !alike(vffrexpBC[i], f) {
2165                         t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpBC[i].f, frexpBC[i].i, f, vffrexpBC[i])
2166                 }
2167         }
2168         for i := 0; i < len(vfldexpBC); i++ {
2169                 if f := Ldexp(vfldexpBC[i].f, vfldexpBC[i].i); !alike(ldexpBC[i], f) {
2170                         t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpBC[i].f, vfldexpBC[i].i, f, ldexpBC[i])
2171                 }
2172         }
2173 }
2174
2175 func TestLgamma(t *testing.T) {
2176         for i := 0; i < len(vf); i++ {
2177                 if f, s := Lgamma(vf[i]); !close(lgamma[i].f, f) || lgamma[i].i != s {
2178                         t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vf[i], f, s, lgamma[i].f, lgamma[i].i)
2179                 }
2180         }
2181         for i := 0; i < len(vflgammaSC); i++ {
2182                 if f, s := Lgamma(vflgammaSC[i]); !alike(lgammaSC[i].f, f) || lgammaSC[i].i != s {
2183                         t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vflgammaSC[i], f, s, lgammaSC[i].f, lgammaSC[i].i)
2184                 }
2185         }
2186 }
2187
2188 func TestLog(t *testing.T) {
2189         for i := 0; i < len(vf); i++ {
2190                 a := Abs(vf[i])
2191                 if f := Log(a); log[i] != f {
2192                         t.Errorf("Log(%g) = %g, want %g", a, f, log[i])
2193                 }
2194         }
2195         if f := Log(10); f != Ln10 {
2196                 t.Errorf("Log(%g) = %g, want %g", 10.0, f, Ln10)
2197         }
2198         for i := 0; i < len(vflogSC); i++ {
2199                 if f := Log(vflogSC[i]); !alike(logSC[i], f) {
2200                         t.Errorf("Log(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2201                 }
2202         }
2203 }
2204
2205 func TestLogb(t *testing.T) {
2206         for i := 0; i < len(vf); i++ {
2207                 if f := Logb(vf[i]); logb[i] != f {
2208                         t.Errorf("Logb(%g) = %g, want %g", vf[i], f, logb[i])
2209                 }
2210         }
2211         for i := 0; i < len(vflogbSC); i++ {
2212                 if f := Logb(vflogbSC[i]); !alike(logbSC[i], f) {
2213                         t.Errorf("Logb(%g) = %g, want %g", vflogbSC[i], f, logbSC[i])
2214                 }
2215         }
2216         for i := 0; i < len(vffrexpBC); i++ {
2217                 if f := Logb(vffrexpBC[i]); !alike(logbBC[i], f) {
2218                         t.Errorf("Logb(%g) = %g, want %g", vffrexpBC[i], f, logbBC[i])
2219                 }
2220         }
2221 }
2222
2223 func TestLog10(t *testing.T) {
2224         for i := 0; i < len(vf); i++ {
2225                 a := Abs(vf[i])
2226                 if f := Log10(a); !veryclose(log10[i], f) {
2227                         t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i])
2228                 }
2229         }
2230         if f := Log10(E); f != Log10E {
2231                 t.Errorf("Log10(%g) = %g, want %g", E, f, Log10E)
2232         }
2233         for i := 0; i < len(vflogSC); i++ {
2234                 if f := Log10(vflogSC[i]); !alike(logSC[i], f) {
2235                         t.Errorf("Log10(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2236                 }
2237         }
2238 }
2239
2240 func TestLog1p(t *testing.T) {
2241         for i := 0; i < len(vf); i++ {
2242                 a := vf[i] / 100
2243                 if f := Log1p(a); !veryclose(log1p[i], f) {
2244                         t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i])
2245                 }
2246         }
2247         a := 9.0
2248         if f := Log1p(a); f != Ln10 {
2249                 t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10)
2250         }
2251         for i := 0; i < len(vflogSC); i++ {
2252                 if f := Log1p(vflog1pSC[i]); !alike(log1pSC[i], f) {
2253                         t.Errorf("Log1p(%g) = %g, want %g", vflog1pSC[i], f, log1pSC[i])
2254                 }
2255         }
2256 }
2257
2258 func TestLog2(t *testing.T) {
2259         for i := 0; i < len(vf); i++ {
2260                 a := Abs(vf[i])
2261                 if f := Log2(a); !veryclose(log2[i], f) {
2262                         t.Errorf("Log2(%g) = %g, want %g", a, f, log2[i])
2263                 }
2264         }
2265         if f := Log2(E); f != Log2E {
2266                 t.Errorf("Log2(%g) = %g, want %g", E, f, Log2E)
2267         }
2268         for i := 0; i < len(vflogSC); i++ {
2269                 if f := Log2(vflogSC[i]); !alike(logSC[i], f) {
2270                         t.Errorf("Log2(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2271                 }
2272         }
2273 }
2274
2275 func TestModf(t *testing.T) {
2276         for i := 0; i < len(vf); i++ {
2277                 if f, g := Modf(vf[i]); !veryclose(modf[i][0], f) || !veryclose(modf[i][1], g) {
2278                         t.Errorf("Modf(%g) = %g, %g, want %g, %g", vf[i], f, g, modf[i][0], modf[i][1])
2279                 }
2280         }
2281         for i := 0; i < len(vfmodfSC); i++ {
2282                 if f, g := Modf(vfmodfSC[i]); !alike(modfSC[i][0], f) || !alike(modfSC[i][1], g) {
2283                         t.Errorf("Modf(%g) = %g, %g, want %g, %g", vfmodfSC[i], f, g, modfSC[i][0], modfSC[i][1])
2284                 }
2285         }
2286 }
2287
2288 func TestNextafter(t *testing.T) {
2289         for i := 0; i < len(vf); i++ {
2290                 if f := Nextafter(vf[i], 10); nextafter[i] != f {
2291                         t.Errorf("Nextafter(%g, %g) = %g want %g", vf[i], 10.0, f, nextafter[i])
2292                 }
2293         }
2294         for i := 0; i < len(vfnextafterSC); i++ {
2295                 if f := Nextafter(vfnextafterSC[i][0], vfnextafterSC[i][1]); !alike(nextafterSC[i], f) {
2296                         t.Errorf("Nextafter(%g, %g) = %g want %g", vfnextafterSC[i][0], vfnextafterSC[i][1], f, nextafterSC[i])
2297                 }
2298         }
2299 }
2300
2301 func TestPow(t *testing.T) {
2302         for i := 0; i < len(vf); i++ {
2303                 if f := Pow(10, vf[i]); !close(pow[i], f) {
2304                         t.Errorf("Pow(10, %g) = %g, want %g", vf[i], f, pow[i])
2305                 }
2306         }
2307         for i := 0; i < len(vfpowSC); i++ {
2308                 if f := Pow(vfpowSC[i][0], vfpowSC[i][1]); !alike(powSC[i], f) {
2309                         t.Errorf("Pow(%g, %g) = %g, want %g", vfpowSC[i][0], vfpowSC[i][1], f, powSC[i])
2310                 }
2311         }
2312 }
2313
2314 func TestPow10(t *testing.T) {
2315         for i := 0; i < len(vfpow10SC); i++ {
2316                 if f := Pow10(vfpow10SC[i]); !alike(pow10SC[i], f) {
2317                         t.Errorf("Pow10(%d) = %g, want %g", vfpow10SC[i], f, pow10SC[i])
2318                 }
2319         }
2320 }
2321
2322 func TestRemainder(t *testing.T) {
2323         for i := 0; i < len(vf); i++ {
2324                 if f := Remainder(10, vf[i]); remainder[i] != f {
2325                         t.Errorf("Remainder(10, %g) = %g, want %g", vf[i], f, remainder[i])
2326                 }
2327         }
2328         for i := 0; i < len(vffmodSC); i++ {
2329                 if f := Remainder(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
2330                         t.Errorf("Remainder(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
2331                 }
2332         }
2333 }
2334
2335 func TestSignbit(t *testing.T) {
2336         for i := 0; i < len(vf); i++ {
2337                 if f := Signbit(vf[i]); signbit[i] != f {
2338                         t.Errorf("Signbit(%g) = %t, want %t", vf[i], f, signbit[i])
2339                 }
2340         }
2341         for i := 0; i < len(vfsignbitSC); i++ {
2342                 if f := Signbit(vfsignbitSC[i]); signbitSC[i] != f {
2343                         t.Errorf("Signbit(%g) = %t, want %t", vfsignbitSC[i], f, signbitSC[i])
2344                 }
2345         }
2346 }
2347 func TestSin(t *testing.T) {
2348         for i := 0; i < len(vf); i++ {
2349                 if f := Sin(vf[i]); !veryclose(sin[i], f) {
2350                         t.Errorf("Sin(%g) = %g, want %g", vf[i], f, sin[i])
2351                 }
2352         }
2353         for i := 0; i < len(vfsinSC); i++ {
2354                 if f := Sin(vfsinSC[i]); !alike(sinSC[i], f) {
2355                         t.Errorf("Sin(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
2356                 }
2357         }
2358 }
2359
2360 func TestSincos(t *testing.T) {
2361         for i := 0; i < len(vf); i++ {
2362                 if s, c := Sincos(vf[i]); !veryclose(sin[i], s) || !veryclose(cos[i], c) {
2363                         t.Errorf("Sincos(%g) = %g, %g want %g, %g", vf[i], s, c, sin[i], cos[i])
2364                 }
2365         }
2366 }
2367
2368 func TestSinh(t *testing.T) {
2369         for i := 0; i < len(vf); i++ {
2370                 if f := Sinh(vf[i]); !close(sinh[i], f) {
2371                         t.Errorf("Sinh(%g) = %g, want %g", vf[i], f, sinh[i])
2372                 }
2373         }
2374         for i := 0; i < len(vfsinhSC); i++ {
2375                 if f := Sinh(vfsinhSC[i]); !alike(sinhSC[i], f) {
2376                         t.Errorf("Sinh(%g) = %g, want %g", vfsinhSC[i], f, sinhSC[i])
2377                 }
2378         }
2379 }
2380
2381 func TestSqrt(t *testing.T) {
2382         for i := 0; i < len(vf); i++ {
2383                 a := Abs(vf[i])
2384                 if f := SqrtGo(a); sqrt[i] != f {
2385                         t.Errorf("SqrtGo(%g) = %g, want %g", a, f, sqrt[i])
2386                 }
2387                 a = Abs(vf[i])
2388                 if f := Sqrt(a); sqrt[i] != f {
2389                         t.Errorf("Sqrt(%g) = %g, want %g", a, f, sqrt[i])
2390                 }
2391         }
2392         for i := 0; i < len(vfsqrtSC); i++ {
2393                 if f := SqrtGo(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
2394                         t.Errorf("SqrtGo(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
2395                 }
2396                 if f := Sqrt(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
2397                         t.Errorf("Sqrt(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
2398                 }
2399         }
2400 }
2401
2402 func TestTan(t *testing.T) {
2403         for i := 0; i < len(vf); i++ {
2404                 if f := Tan(vf[i]); !veryclose(tan[i], f) {
2405                         t.Errorf("Tan(%g) = %g, want %g", vf[i], f, tan[i])
2406                 }
2407         }
2408         // same special cases as Sin
2409         for i := 0; i < len(vfsinSC); i++ {
2410                 if f := Tan(vfsinSC[i]); !alike(sinSC[i], f) {
2411                         t.Errorf("Tan(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
2412                 }
2413         }
2414 }
2415
2416 func TestTanh(t *testing.T) {
2417         for i := 0; i < len(vf); i++ {
2418                 if f := Tanh(vf[i]); !veryclose(tanh[i], f) {
2419                         t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i])
2420                 }
2421         }
2422         for i := 0; i < len(vftanhSC); i++ {
2423                 if f := Tanh(vftanhSC[i]); !alike(tanhSC[i], f) {
2424                         t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i])
2425                 }
2426         }
2427 }
2428
2429 func TestTrunc(t *testing.T) {
2430         for i := 0; i < len(vf); i++ {
2431                 if f := Trunc(vf[i]); trunc[i] != f {
2432                         t.Errorf("Trunc(%g) = %g, want %g", vf[i], f, trunc[i])
2433                 }
2434         }
2435         for i := 0; i < len(vfceilSC); i++ {
2436                 if f := Trunc(vfceilSC[i]); !alike(ceilSC[i], f) {
2437                         t.Errorf("Trunc(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
2438                 }
2439         }
2440 }
2441
2442 func TestY0(t *testing.T) {
2443         for i := 0; i < len(vf); i++ {
2444                 a := Abs(vf[i])
2445                 if f := Y0(a); !close(y0[i], f) {
2446                         t.Errorf("Y0(%g) = %g, want %g", a, f, y0[i])
2447                 }
2448         }
2449         for i := 0; i < len(vfy0SC); i++ {
2450                 if f := Y0(vfy0SC[i]); !alike(y0SC[i], f) {
2451                         t.Errorf("Y0(%g) = %g, want %g", vfy0SC[i], f, y0SC[i])
2452                 }
2453         }
2454 }
2455
2456 func TestY1(t *testing.T) {
2457         for i := 0; i < len(vf); i++ {
2458                 a := Abs(vf[i])
2459                 if f := Y1(a); !soclose(y1[i], f, 2e-14) {
2460                         t.Errorf("Y1(%g) = %g, want %g", a, f, y1[i])
2461                 }
2462         }
2463         for i := 0; i < len(vfy0SC); i++ {
2464                 if f := Y1(vfy0SC[i]); !alike(y1SC[i], f) {
2465                         t.Errorf("Y1(%g) = %g, want %g", vfy0SC[i], f, y1SC[i])
2466                 }
2467         }
2468 }
2469
2470 func TestYn(t *testing.T) {
2471         for i := 0; i < len(vf); i++ {
2472                 a := Abs(vf[i])
2473                 if f := Yn(2, a); !close(y2[i], f) {
2474                         t.Errorf("Yn(2, %g) = %g, want %g", a, f, y2[i])
2475                 }
2476                 if f := Yn(-3, a); !close(yM3[i], f) {
2477                         t.Errorf("Yn(-3, %g) = %g, want %g", a, f, yM3[i])
2478                 }
2479         }
2480         for i := 0; i < len(vfy0SC); i++ {
2481                 if f := Yn(2, vfy0SC[i]); !alike(y2SC[i], f) {
2482                         t.Errorf("Yn(2, %g) = %g, want %g", vfy0SC[i], f, y2SC[i])
2483                 }
2484                 if f := Yn(-3, vfy0SC[i]); !alike(yM3SC[i], f) {
2485                         t.Errorf("Yn(-3, %g) = %g, want %g", vfy0SC[i], f, yM3SC[i])
2486                 }
2487         }
2488 }
2489
2490 // Check that math functions of high angle values
2491 // return accurate results. [Since (vf[i] + large) - large != vf[i],
2492 // testing for Trig(vf[i] + large) == Trig(vf[i]), where large is
2493 // a multiple of 2*Pi, is misleading.]
2494 func TestLargeCos(t *testing.T) {
2495         large := float64(100000 * Pi)
2496         for i := 0; i < len(vf); i++ {
2497                 f1 := cosLarge[i]
2498                 f2 := Cos(vf[i] + large)
2499                 if !close(f1, f2) {
2500                         t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1)
2501                 }
2502         }
2503 }
2504
2505 func TestLargeSin(t *testing.T) {
2506         large := float64(100000 * Pi)
2507         for i := 0; i < len(vf); i++ {
2508                 f1 := sinLarge[i]
2509                 f2 := Sin(vf[i] + large)
2510                 if !close(f1, f2) {
2511                         t.Errorf("Sin(%g) = %g, want %g", vf[i]+large, f2, f1)
2512                 }
2513         }
2514 }
2515
2516 func TestLargeSincos(t *testing.T) {
2517         large := float64(100000 * Pi)
2518         for i := 0; i < len(vf); i++ {
2519                 f1, g1 := sinLarge[i], cosLarge[i]
2520                 f2, g2 := Sincos(vf[i] + large)
2521                 if !close(f1, f2) || !close(g1, g2) {
2522                         t.Errorf("Sincos(%g) = %g, %g, want %g, %g", vf[i]+large, f2, g2, f1, g1)
2523                 }
2524         }
2525 }
2526
2527 func TestLargeTan(t *testing.T) {
2528         large := float64(100000 * Pi)
2529         for i := 0; i < len(vf); i++ {
2530                 f1 := tanLarge[i]
2531                 f2 := Tan(vf[i] + large)
2532                 if !close(f1, f2) {
2533                         t.Errorf("Tan(%g) = %g, want %g", vf[i]+large, f2, f1)
2534                 }
2535         }
2536 }
2537
2538 // Check that math constants are accepted by compiler
2539 // and have right value (assumes strconv.ParseFloat works).
2540 // http://code.google.com/p/go/issues/detail?id=201
2541
2542 type floatTest struct {
2543         val  interface{}
2544         name string
2545         str  string
2546 }
2547
2548 var floatTests = []floatTest{
2549         {float64(MaxFloat64), "MaxFloat64", "1.7976931348623157e+308"},
2550         {float64(SmallestNonzeroFloat64), "SmallestNonzeroFloat64", "5e-324"},
2551         {float32(MaxFloat32), "MaxFloat32", "3.4028235e+38"},
2552         {float32(SmallestNonzeroFloat32), "SmallestNonzeroFloat32", "1e-45"},
2553 }
2554
2555 func TestFloatMinMax(t *testing.T) {
2556         for _, tt := range floatTests {
2557                 s := fmt.Sprint(tt.val)
2558                 if s != tt.str {
2559                         t.Errorf("Sprint(%v) = %s, want %s", tt.name, s, tt.str)
2560                 }
2561         }
2562 }
2563
2564 // Benchmarks
2565
2566 func BenchmarkAcos(b *testing.B) {
2567         for i := 0; i < b.N; i++ {
2568                 Acos(.5)
2569         }
2570 }
2571
2572 func BenchmarkAcosh(b *testing.B) {
2573         for i := 0; i < b.N; i++ {
2574                 Acosh(1.5)
2575         }
2576 }
2577
2578 func BenchmarkAsin(b *testing.B) {
2579         for i := 0; i < b.N; i++ {
2580                 Asin(.5)
2581         }
2582 }
2583
2584 func BenchmarkAsinh(b *testing.B) {
2585         for i := 0; i < b.N; i++ {
2586                 Asinh(.5)
2587         }
2588 }
2589
2590 func BenchmarkAtan(b *testing.B) {
2591         for i := 0; i < b.N; i++ {
2592                 Atan(.5)
2593         }
2594 }
2595
2596 func BenchmarkAtanh(b *testing.B) {
2597         for i := 0; i < b.N; i++ {
2598                 Atanh(.5)
2599         }
2600 }
2601
2602 func BenchmarkAtan2(b *testing.B) {
2603         for i := 0; i < b.N; i++ {
2604                 Atan2(.5, 1)
2605         }
2606 }
2607
2608 func BenchmarkCbrt(b *testing.B) {
2609         for i := 0; i < b.N; i++ {
2610                 Cbrt(10)
2611         }
2612 }
2613
2614 func BenchmarkCeil(b *testing.B) {
2615         for i := 0; i < b.N; i++ {
2616                 Ceil(.5)
2617         }
2618 }
2619
2620 func BenchmarkCopysign(b *testing.B) {
2621         for i := 0; i < b.N; i++ {
2622                 Copysign(.5, -1)
2623         }
2624 }
2625
2626 func BenchmarkCos(b *testing.B) {
2627         for i := 0; i < b.N; i++ {
2628                 Cos(.5)
2629         }
2630 }
2631
2632 func BenchmarkCosh(b *testing.B) {
2633         for i := 0; i < b.N; i++ {
2634                 Cosh(2.5)
2635         }
2636 }
2637
2638 func BenchmarkErf(b *testing.B) {
2639         for i := 0; i < b.N; i++ {
2640                 Erf(.5)
2641         }
2642 }
2643
2644 func BenchmarkErfc(b *testing.B) {
2645         for i := 0; i < b.N; i++ {
2646                 Erfc(.5)
2647         }
2648 }
2649
2650 func BenchmarkExp(b *testing.B) {
2651         for i := 0; i < b.N; i++ {
2652                 Exp(.5)
2653         }
2654 }
2655
2656 func BenchmarkExpGo(b *testing.B) {
2657         for i := 0; i < b.N; i++ {
2658                 ExpGo(.5)
2659         }
2660 }
2661
2662 func BenchmarkExpm1(b *testing.B) {
2663         for i := 0; i < b.N; i++ {
2664                 Expm1(.5)
2665         }
2666 }
2667
2668 func BenchmarkExp2(b *testing.B) {
2669         for i := 0; i < b.N; i++ {
2670                 Exp2(.5)
2671         }
2672 }
2673
2674 func BenchmarkExp2Go(b *testing.B) {
2675         for i := 0; i < b.N; i++ {
2676                 Exp2Go(.5)
2677         }
2678 }
2679
2680 func BenchmarkAbs(b *testing.B) {
2681         for i := 0; i < b.N; i++ {
2682                 Abs(.5)
2683         }
2684 }
2685
2686 func BenchmarkDim(b *testing.B) {
2687         for i := 0; i < b.N; i++ {
2688                 Dim(10, 3)
2689         }
2690 }
2691
2692 func BenchmarkFloor(b *testing.B) {
2693         for i := 0; i < b.N; i++ {
2694                 Floor(.5)
2695         }
2696 }
2697
2698 func BenchmarkMax(b *testing.B) {
2699         for i := 0; i < b.N; i++ {
2700                 Max(10, 3)
2701         }
2702 }
2703
2704 func BenchmarkMin(b *testing.B) {
2705         for i := 0; i < b.N; i++ {
2706                 Min(10, 3)
2707         }
2708 }
2709
2710 func BenchmarkMod(b *testing.B) {
2711         for i := 0; i < b.N; i++ {
2712                 Mod(10, 3)
2713         }
2714 }
2715
2716 func BenchmarkFrexp(b *testing.B) {
2717         for i := 0; i < b.N; i++ {
2718                 Frexp(8)
2719         }
2720 }
2721
2722 func BenchmarkGamma(b *testing.B) {
2723         for i := 0; i < b.N; i++ {
2724                 Gamma(2.5)
2725         }
2726 }
2727
2728 func BenchmarkHypot(b *testing.B) {
2729         for i := 0; i < b.N; i++ {
2730                 Hypot(3, 4)
2731         }
2732 }
2733
2734 func BenchmarkHypotGo(b *testing.B) {
2735         for i := 0; i < b.N; i++ {
2736                 HypotGo(3, 4)
2737         }
2738 }
2739
2740 func BenchmarkIlogb(b *testing.B) {
2741         for i := 0; i < b.N; i++ {
2742                 Ilogb(.5)
2743         }
2744 }
2745
2746 func BenchmarkJ0(b *testing.B) {
2747         for i := 0; i < b.N; i++ {
2748                 J0(2.5)
2749         }
2750 }
2751
2752 func BenchmarkJ1(b *testing.B) {
2753         for i := 0; i < b.N; i++ {
2754                 J1(2.5)
2755         }
2756 }
2757
2758 func BenchmarkJn(b *testing.B) {
2759         for i := 0; i < b.N; i++ {
2760                 Jn(2, 2.5)
2761         }
2762 }
2763
2764 func BenchmarkLdexp(b *testing.B) {
2765         for i := 0; i < b.N; i++ {
2766                 Ldexp(.5, 2)
2767         }
2768 }
2769
2770 func BenchmarkLgamma(b *testing.B) {
2771         for i := 0; i < b.N; i++ {
2772                 Lgamma(2.5)
2773         }
2774 }
2775
2776 func BenchmarkLog(b *testing.B) {
2777         for i := 0; i < b.N; i++ {
2778                 Log(.5)
2779         }
2780 }
2781
2782 func BenchmarkLogb(b *testing.B) {
2783         for i := 0; i < b.N; i++ {
2784                 Logb(.5)
2785         }
2786 }
2787
2788 func BenchmarkLog1p(b *testing.B) {
2789         for i := 0; i < b.N; i++ {
2790                 Log1p(.5)
2791         }
2792 }
2793
2794 func BenchmarkLog10(b *testing.B) {
2795         for i := 0; i < b.N; i++ {
2796                 Log10(.5)
2797         }
2798 }
2799
2800 func BenchmarkLog2(b *testing.B) {
2801         for i := 0; i < b.N; i++ {
2802                 Log2(.5)
2803         }
2804 }
2805
2806 func BenchmarkModf(b *testing.B) {
2807         for i := 0; i < b.N; i++ {
2808                 Modf(1.5)
2809         }
2810 }
2811
2812 func BenchmarkNextafter(b *testing.B) {
2813         for i := 0; i < b.N; i++ {
2814                 Nextafter(.5, 1)
2815         }
2816 }
2817
2818 func BenchmarkPowInt(b *testing.B) {
2819         for i := 0; i < b.N; i++ {
2820                 Pow(2, 2)
2821         }
2822 }
2823
2824 func BenchmarkPowFrac(b *testing.B) {
2825         for i := 0; i < b.N; i++ {
2826                 Pow(2.5, 1.5)
2827         }
2828 }
2829
2830 func BenchmarkPow10Pos(b *testing.B) {
2831         for i := 0; i < b.N; i++ {
2832                 Pow10(300)
2833         }
2834 }
2835
2836 func BenchmarkPow10Neg(b *testing.B) {
2837         for i := 0; i < b.N; i++ {
2838                 Pow10(-300)
2839         }
2840 }
2841
2842 func BenchmarkRemainder(b *testing.B) {
2843         for i := 0; i < b.N; i++ {
2844                 Remainder(10, 3)
2845         }
2846 }
2847
2848 func BenchmarkSignbit(b *testing.B) {
2849         for i := 0; i < b.N; i++ {
2850                 Signbit(2.5)
2851         }
2852 }
2853
2854 func BenchmarkSin(b *testing.B) {
2855         for i := 0; i < b.N; i++ {
2856                 Sin(.5)
2857         }
2858 }
2859
2860 func BenchmarkSincos(b *testing.B) {
2861         for i := 0; i < b.N; i++ {
2862                 Sincos(.5)
2863         }
2864 }
2865
2866 func BenchmarkSinh(b *testing.B) {
2867         for i := 0; i < b.N; i++ {
2868                 Sinh(2.5)
2869         }
2870 }
2871
2872 func BenchmarkSqrt(b *testing.B) {
2873         for i := 0; i < b.N; i++ {
2874                 Sqrt(10)
2875         }
2876 }
2877
2878 func BenchmarkSqrtGo(b *testing.B) {
2879         for i := 0; i < b.N; i++ {
2880                 SqrtGo(10)
2881         }
2882 }
2883
2884 func BenchmarkTan(b *testing.B) {
2885         for i := 0; i < b.N; i++ {
2886                 Tan(.5)
2887         }
2888 }
2889
2890 func BenchmarkTanh(b *testing.B) {
2891         for i := 0; i < b.N; i++ {
2892                 Tanh(2.5)
2893         }
2894 }
2895 func BenchmarkTrunc(b *testing.B) {
2896         for i := 0; i < b.N; i++ {
2897                 Trunc(.5)
2898         }
2899 }
2900
2901 func BenchmarkY0(b *testing.B) {
2902         for i := 0; i < b.N; i++ {
2903                 Y0(2.5)
2904         }
2905 }
2906
2907 func BenchmarkY1(b *testing.B) {
2908         for i := 0; i < b.N; i++ {
2909                 Y1(2.5)
2910         }
2911 }
2912
2913 func BenchmarkYn(b *testing.B) {
2914         for i := 0; i < b.N; i++ {
2915                 Yn(2, 2.5)
2916         }
2917 }