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 TestNaN(t *testing.T) {
1697         f64 := NaN()
1698         if f64 == f64 {
1699                 t.Fatalf("NaN() returns %g, expected NaN", f64)
1700         }
1701         f32 := float32(f64)
1702         if f32 == f32 {
1703                 t.Fatalf("float32(NaN()) is %g, expected NaN", f32)
1704         }
1705 }
1706
1707 func TestAcos(t *testing.T) {
1708         for i := 0; i < len(vf); i++ {
1709                 a := vf[i] / 10
1710                 if f := Acos(a); !close(acos[i], f) {
1711                         t.Errorf("Acos(%g) = %g, want %g", a, f, acos[i])
1712                 }
1713         }
1714         for i := 0; i < len(vfacosSC); i++ {
1715                 if f := Acos(vfacosSC[i]); !alike(acosSC[i], f) {
1716                         t.Errorf("Acos(%g) = %g, want %g", vfacosSC[i], f, acosSC[i])
1717                 }
1718         }
1719 }
1720
1721 func TestAcosh(t *testing.T) {
1722         for i := 0; i < len(vf); i++ {
1723                 a := 1 + Abs(vf[i])
1724                 if f := Acosh(a); !veryclose(acosh[i], f) {
1725                         t.Errorf("Acosh(%g) = %g, want %g", a, f, acosh[i])
1726                 }
1727         }
1728         for i := 0; i < len(vfacoshSC); i++ {
1729                 if f := Acosh(vfacoshSC[i]); !alike(acoshSC[i], f) {
1730                         t.Errorf("Acosh(%g) = %g, want %g", vfacoshSC[i], f, acoshSC[i])
1731                 }
1732         }
1733 }
1734
1735 func TestAsin(t *testing.T) {
1736         for i := 0; i < len(vf); i++ {
1737                 a := vf[i] / 10
1738                 if f := Asin(a); !veryclose(asin[i], f) {
1739                         t.Errorf("Asin(%g) = %g, want %g", a, f, asin[i])
1740                 }
1741         }
1742         for i := 0; i < len(vfasinSC); i++ {
1743                 if f := Asin(vfasinSC[i]); !alike(asinSC[i], f) {
1744                         t.Errorf("Asin(%g) = %g, want %g", vfasinSC[i], f, asinSC[i])
1745                 }
1746         }
1747 }
1748
1749 func TestAsinh(t *testing.T) {
1750         for i := 0; i < len(vf); i++ {
1751                 if f := Asinh(vf[i]); !veryclose(asinh[i], f) {
1752                         t.Errorf("Asinh(%g) = %g, want %g", vf[i], f, asinh[i])
1753                 }
1754         }
1755         for i := 0; i < len(vfasinhSC); i++ {
1756                 if f := Asinh(vfasinhSC[i]); !alike(asinhSC[i], f) {
1757                         t.Errorf("Asinh(%g) = %g, want %g", vfasinhSC[i], f, asinhSC[i])
1758                 }
1759         }
1760 }
1761
1762 func TestAtan(t *testing.T) {
1763         for i := 0; i < len(vf); i++ {
1764                 if f := Atan(vf[i]); !veryclose(atan[i], f) {
1765                         t.Errorf("Atan(%g) = %g, want %g", vf[i], f, atan[i])
1766                 }
1767         }
1768         for i := 0; i < len(vfatanSC); i++ {
1769                 if f := Atan(vfatanSC[i]); !alike(atanSC[i], f) {
1770                         t.Errorf("Atan(%g) = %g, want %g", vfatanSC[i], f, atanSC[i])
1771                 }
1772         }
1773 }
1774
1775 func TestAtanh(t *testing.T) {
1776         for i := 0; i < len(vf); i++ {
1777                 a := vf[i] / 10
1778                 if f := Atanh(a); !veryclose(atanh[i], f) {
1779                         t.Errorf("Atanh(%g) = %g, want %g", a, f, atanh[i])
1780                 }
1781         }
1782         for i := 0; i < len(vfatanhSC); i++ {
1783                 if f := Atanh(vfatanhSC[i]); !alike(atanhSC[i], f) {
1784                         t.Errorf("Atanh(%g) = %g, want %g", vfatanhSC[i], f, atanhSC[i])
1785                 }
1786         }
1787 }
1788
1789 func TestAtan2(t *testing.T) {
1790         for i := 0; i < len(vf); i++ {
1791                 if f := Atan2(10, vf[i]); !veryclose(atan2[i], f) {
1792                         t.Errorf("Atan2(10, %g) = %g, want %g", vf[i], f, atan2[i])
1793                 }
1794         }
1795         for i := 0; i < len(vfatan2SC); i++ {
1796                 if f := Atan2(vfatan2SC[i][0], vfatan2SC[i][1]); !alike(atan2SC[i], f) {
1797                         t.Errorf("Atan2(%g, %g) = %g, want %g", vfatan2SC[i][0], vfatan2SC[i][1], f, atan2SC[i])
1798                 }
1799         }
1800 }
1801
1802 func TestCbrt(t *testing.T) {
1803         for i := 0; i < len(vf); i++ {
1804                 if f := Cbrt(vf[i]); !veryclose(cbrt[i], f) {
1805                         t.Errorf("Cbrt(%g) = %g, want %g", vf[i], f, cbrt[i])
1806                 }
1807         }
1808         for i := 0; i < len(vfcbrtSC); i++ {
1809                 if f := Cbrt(vfcbrtSC[i]); !alike(cbrtSC[i], f) {
1810                         t.Errorf("Cbrt(%g) = %g, want %g", vfcbrtSC[i], f, cbrtSC[i])
1811                 }
1812         }
1813 }
1814
1815 func TestCeil(t *testing.T) {
1816         for i := 0; i < len(vf); i++ {
1817                 if f := Ceil(vf[i]); ceil[i] != f {
1818                         t.Errorf("Ceil(%g) = %g, want %g", vf[i], f, ceil[i])
1819                 }
1820         }
1821         for i := 0; i < len(vfceilSC); i++ {
1822                 if f := Ceil(vfceilSC[i]); !alike(ceilSC[i], f) {
1823                         t.Errorf("Ceil(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
1824                 }
1825         }
1826 }
1827
1828 func TestCopysign(t *testing.T) {
1829         for i := 0; i < len(vf); i++ {
1830                 if f := Copysign(vf[i], -1); copysign[i] != f {
1831                         t.Errorf("Copysign(%g, -1) = %g, want %g", vf[i], f, copysign[i])
1832                 }
1833         }
1834         for i := 0; i < len(vf); i++ {
1835                 if f := Copysign(vf[i], 1); -copysign[i] != f {
1836                         t.Errorf("Copysign(%g, 1) = %g, want %g", vf[i], f, -copysign[i])
1837                 }
1838         }
1839         for i := 0; i < len(vfcopysignSC); i++ {
1840                 if f := Copysign(vfcopysignSC[i], -1); !alike(copysignSC[i], f) {
1841                         t.Errorf("Copysign(%g, -1) = %g, want %g", vfcopysignSC[i], f, copysignSC[i])
1842                 }
1843         }
1844 }
1845
1846 func TestCos(t *testing.T) {
1847         for i := 0; i < len(vf); i++ {
1848                 if f := Cos(vf[i]); !veryclose(cos[i], f) {
1849                         t.Errorf("Cos(%g) = %g, want %g", vf[i], f, cos[i])
1850                 }
1851         }
1852         for i := 0; i < len(vfcosSC); i++ {
1853                 if f := Cos(vfcosSC[i]); !alike(cosSC[i], f) {
1854                         t.Errorf("Cos(%g) = %g, want %g", vfcosSC[i], f, cosSC[i])
1855                 }
1856         }
1857 }
1858
1859 func TestCosh(t *testing.T) {
1860         for i := 0; i < len(vf); i++ {
1861                 if f := Cosh(vf[i]); !close(cosh[i], f) {
1862                         t.Errorf("Cosh(%g) = %g, want %g", vf[i], f, cosh[i])
1863                 }
1864         }
1865         for i := 0; i < len(vfcoshSC); i++ {
1866                 if f := Cosh(vfcoshSC[i]); !alike(coshSC[i], f) {
1867                         t.Errorf("Cosh(%g) = %g, want %g", vfcoshSC[i], f, coshSC[i])
1868                 }
1869         }
1870 }
1871
1872 func TestErf(t *testing.T) {
1873         for i := 0; i < len(vf); i++ {
1874                 a := vf[i] / 10
1875                 if f := Erf(a); !veryclose(erf[i], f) {
1876                         t.Errorf("Erf(%g) = %g, want %g", a, f, erf[i])
1877                 }
1878         }
1879         for i := 0; i < len(vferfSC); i++ {
1880                 if f := Erf(vferfSC[i]); !alike(erfSC[i], f) {
1881                         t.Errorf("Erf(%g) = %g, want %g", vferfSC[i], f, erfSC[i])
1882                 }
1883         }
1884 }
1885
1886 func TestErfc(t *testing.T) {
1887         for i := 0; i < len(vf); i++ {
1888                 a := vf[i] / 10
1889                 if f := Erfc(a); !veryclose(erfc[i], f) {
1890                         t.Errorf("Erfc(%g) = %g, want %g", a, f, erfc[i])
1891                 }
1892         }
1893         for i := 0; i < len(vferfcSC); i++ {
1894                 if f := Erfc(vferfcSC[i]); !alike(erfcSC[i], f) {
1895                         t.Errorf("Erfc(%g) = %g, want %g", vferfcSC[i], f, erfcSC[i])
1896                 }
1897         }
1898 }
1899
1900 func TestExp(t *testing.T) {
1901         testExp(t, Exp, "Exp")
1902         testExp(t, ExpGo, "ExpGo")
1903 }
1904
1905 func testExp(t *testing.T, Exp func(float64) float64, name string) {
1906         for i := 0; i < len(vf); i++ {
1907                 if f := Exp(vf[i]); !close(exp[i], f) {
1908                         t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp[i])
1909                 }
1910         }
1911         for i := 0; i < len(vfexpSC); i++ {
1912                 if f := Exp(vfexpSC[i]); !alike(expSC[i], f) {
1913                         t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i])
1914                 }
1915         }
1916 }
1917
1918 func TestExpm1(t *testing.T) {
1919         for i := 0; i < len(vf); i++ {
1920                 a := vf[i] / 100
1921                 if f := Expm1(a); !veryclose(expm1[i], f) {
1922                         t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1[i])
1923                 }
1924         }
1925         for i := 0; i < len(vfexpm1SC); i++ {
1926                 if f := Expm1(vfexpm1SC[i]); !alike(expm1SC[i], f) {
1927                         t.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC[i], f, expm1SC[i])
1928                 }
1929         }
1930 }
1931
1932 func TestExp2(t *testing.T) {
1933         testExp2(t, Exp2, "Exp2")
1934         testExp2(t, Exp2Go, "Exp2Go")
1935 }
1936
1937 func testExp2(t *testing.T, Exp2 func(float64) float64, name string) {
1938         for i := 0; i < len(vf); i++ {
1939                 if f := Exp2(vf[i]); !close(exp2[i], f) {
1940                         t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp2[i])
1941                 }
1942         }
1943         for i := 0; i < len(vfexpSC); i++ {
1944                 if f := Exp2(vfexpSC[i]); !alike(expSC[i], f) {
1945                         t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i])
1946                 }
1947         }
1948         for n := -1074; n < 1024; n++ {
1949                 f := Exp2(float64(n))
1950                 vf := Ldexp(1, n)
1951                 if f != vf {
1952                         t.Errorf("%s(%d) = %g, want %g", name, n, f, vf)
1953                 }
1954         }
1955 }
1956
1957 func TestAbs(t *testing.T) {
1958         for i := 0; i < len(vf); i++ {
1959                 if f := Abs(vf[i]); fabs[i] != f {
1960                         t.Errorf("Abs(%g) = %g, want %g", vf[i], f, fabs[i])
1961                 }
1962         }
1963         for i := 0; i < len(vffabsSC); i++ {
1964                 if f := Abs(vffabsSC[i]); !alike(fabsSC[i], f) {
1965                         t.Errorf("Abs(%g) = %g, want %g", vffabsSC[i], f, fabsSC[i])
1966                 }
1967         }
1968 }
1969
1970 func TestDim(t *testing.T) {
1971         for i := 0; i < len(vf); i++ {
1972                 if f := Dim(vf[i], 0); fdim[i] != f {
1973                         t.Errorf("Dim(%g, %g) = %g, want %g", vf[i], 0.0, f, fdim[i])
1974                 }
1975         }
1976         for i := 0; i < len(vffdimSC); i++ {
1977                 if f := Dim(vffdimSC[i][0], vffdimSC[i][1]); !alike(fdimSC[i], f) {
1978                         t.Errorf("Dim(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fdimSC[i])
1979                 }
1980         }
1981 }
1982
1983 func TestFloor(t *testing.T) {
1984         for i := 0; i < len(vf); i++ {
1985                 if f := Floor(vf[i]); floor[i] != f {
1986                         t.Errorf("Floor(%g) = %g, want %g", vf[i], f, floor[i])
1987                 }
1988         }
1989         for i := 0; i < len(vfceilSC); i++ {
1990                 if f := Floor(vfceilSC[i]); !alike(ceilSC[i], f) {
1991                         t.Errorf("Floor(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
1992                 }
1993         }
1994 }
1995
1996 func TestMax(t *testing.T) {
1997         for i := 0; i < len(vf); i++ {
1998                 if f := Max(vf[i], ceil[i]); ceil[i] != f {
1999                         t.Errorf("Max(%g, %g) = %g, want %g", vf[i], ceil[i], f, ceil[i])
2000                 }
2001         }
2002         for i := 0; i < len(vffdimSC); i++ {
2003                 if f := Max(vffdimSC[i][0], vffdimSC[i][1]); !alike(fmaxSC[i], f) {
2004                         t.Errorf("Max(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fmaxSC[i])
2005                 }
2006         }
2007 }
2008
2009 func TestMin(t *testing.T) {
2010         for i := 0; i < len(vf); i++ {
2011                 if f := Min(vf[i], floor[i]); floor[i] != f {
2012                         t.Errorf("Min(%g, %g) = %g, want %g", vf[i], floor[i], f, floor[i])
2013                 }
2014         }
2015         for i := 0; i < len(vffdimSC); i++ {
2016                 if f := Min(vffdimSC[i][0], vffdimSC[i][1]); !alike(fminSC[i], f) {
2017                         t.Errorf("Min(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fminSC[i])
2018                 }
2019         }
2020 }
2021
2022 func TestMod(t *testing.T) {
2023         for i := 0; i < len(vf); i++ {
2024                 if f := Mod(10, vf[i]); fmod[i] != f {
2025                         t.Errorf("Mod(10, %g) = %g, want %g", vf[i], f, fmod[i])
2026                 }
2027         }
2028         for i := 0; i < len(vffmodSC); i++ {
2029                 if f := Mod(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
2030                         t.Errorf("Mod(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
2031                 }
2032         }
2033 }
2034
2035 func TestFrexp(t *testing.T) {
2036         for i := 0; i < len(vf); i++ {
2037                 if f, j := Frexp(vf[i]); !veryclose(frexp[i].f, f) || frexp[i].i != j {
2038                         t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vf[i], f, j, frexp[i].f, frexp[i].i)
2039                 }
2040         }
2041         for i := 0; i < len(vffrexpSC); i++ {
2042                 if f, j := Frexp(vffrexpSC[i]); !alike(frexpSC[i].f, f) || frexpSC[i].i != j {
2043                         t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpSC[i], f, j, frexpSC[i].f, frexpSC[i].i)
2044                 }
2045         }
2046         for i := 0; i < len(vffrexpBC); i++ {
2047                 if f, j := Frexp(vffrexpBC[i]); !alike(frexpBC[i].f, f) || frexpBC[i].i != j {
2048                         t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpBC[i], f, j, frexpBC[i].f, frexpBC[i].i)
2049                 }
2050         }
2051 }
2052
2053 func TestGamma(t *testing.T) {
2054         for i := 0; i < len(vf); i++ {
2055                 if f := Gamma(vf[i]); !close(gamma[i], f) {
2056                         t.Errorf("Gamma(%g) = %g, want %g", vf[i], f, gamma[i])
2057                 }
2058         }
2059         for i := 0; i < len(vfgammaSC); i++ {
2060                 if f := Gamma(vfgammaSC[i]); !alike(gammaSC[i], f) {
2061                         t.Errorf("Gamma(%g) = %g, want %g", vfgammaSC[i], f, gammaSC[i])
2062                 }
2063         }
2064 }
2065
2066 func TestHypot(t *testing.T) {
2067         for i := 0; i < len(vf); i++ {
2068                 a := Abs(1e200 * tanh[i] * Sqrt(2))
2069                 if f := Hypot(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
2070                         t.Errorf("Hypot(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
2071                 }
2072         }
2073         for i := 0; i < len(vfhypotSC); i++ {
2074                 if f := Hypot(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) {
2075                         t.Errorf("Hypot(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i])
2076                 }
2077         }
2078 }
2079
2080 func TestHypotGo(t *testing.T) {
2081         for i := 0; i < len(vf); i++ {
2082                 a := Abs(1e200 * tanh[i] * Sqrt(2))
2083                 if f := HypotGo(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
2084                         t.Errorf("HypotGo(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
2085                 }
2086         }
2087         for i := 0; i < len(vfhypotSC); i++ {
2088                 if f := HypotGo(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) {
2089                         t.Errorf("HypotGo(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i])
2090                 }
2091         }
2092 }
2093
2094 func TestIlogb(t *testing.T) {
2095         for i := 0; i < len(vf); i++ {
2096                 a := frexp[i].i - 1 // adjust because fr in the interval [½, 1)
2097                 if e := Ilogb(vf[i]); a != e {
2098                         t.Errorf("Ilogb(%g) = %d, want %d", vf[i], e, a)
2099                 }
2100         }
2101         for i := 0; i < len(vflogbSC); i++ {
2102                 if e := Ilogb(vflogbSC[i]); ilogbSC[i] != e {
2103                         t.Errorf("Ilogb(%g) = %d, want %d", vflogbSC[i], e, ilogbSC[i])
2104                 }
2105         }
2106         for i := 0; i < len(vffrexpBC); i++ {
2107                 if e := Ilogb(vffrexpBC[i]); int(logbBC[i]) != e {
2108                         t.Errorf("Ilogb(%g) = %d, want %d", vffrexpBC[i], e, int(logbBC[i]))
2109                 }
2110         }
2111 }
2112
2113 func TestJ0(t *testing.T) {
2114         for i := 0; i < len(vf); i++ {
2115                 if f := J0(vf[i]); !soclose(j0[i], f, 4e-14) {
2116                         t.Errorf("J0(%g) = %g, want %g", vf[i], f, j0[i])
2117                 }
2118         }
2119         for i := 0; i < len(vfj0SC); i++ {
2120                 if f := J0(vfj0SC[i]); !alike(j0SC[i], f) {
2121                         t.Errorf("J0(%g) = %g, want %g", vfj0SC[i], f, j0SC[i])
2122                 }
2123         }
2124 }
2125
2126 func TestJ1(t *testing.T) {
2127         for i := 0; i < len(vf); i++ {
2128                 if f := J1(vf[i]); !close(j1[i], f) {
2129                         t.Errorf("J1(%g) = %g, want %g", vf[i], f, j1[i])
2130                 }
2131         }
2132         for i := 0; i < len(vfj0SC); i++ {
2133                 if f := J1(vfj0SC[i]); !alike(j1SC[i], f) {
2134                         t.Errorf("J1(%g) = %g, want %g", vfj0SC[i], f, j1SC[i])
2135                 }
2136         }
2137 }
2138
2139 func TestJn(t *testing.T) {
2140         for i := 0; i < len(vf); i++ {
2141                 if f := Jn(2, vf[i]); !close(j2[i], f) {
2142                         t.Errorf("Jn(2, %g) = %g, want %g", vf[i], f, j2[i])
2143                 }
2144                 if f := Jn(-3, vf[i]); !close(jM3[i], f) {
2145                         t.Errorf("Jn(-3, %g) = %g, want %g", vf[i], f, jM3[i])
2146                 }
2147         }
2148         for i := 0; i < len(vfj0SC); i++ {
2149                 if f := Jn(2, vfj0SC[i]); !alike(j2SC[i], f) {
2150                         t.Errorf("Jn(2, %g) = %g, want %g", vfj0SC[i], f, j2SC[i])
2151                 }
2152                 if f := Jn(-3, vfj0SC[i]); !alike(jM3SC[i], f) {
2153                         t.Errorf("Jn(-3, %g) = %g, want %g", vfj0SC[i], f, jM3SC[i])
2154                 }
2155         }
2156 }
2157
2158 func TestLdexp(t *testing.T) {
2159         for i := 0; i < len(vf); i++ {
2160                 if f := Ldexp(frexp[i].f, frexp[i].i); !veryclose(vf[i], f) {
2161                         t.Errorf("Ldexp(%g, %d) = %g, want %g", frexp[i].f, frexp[i].i, f, vf[i])
2162                 }
2163         }
2164         for i := 0; i < len(vffrexpSC); i++ {
2165                 if f := Ldexp(frexpSC[i].f, frexpSC[i].i); !alike(vffrexpSC[i], f) {
2166                         t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpSC[i].f, frexpSC[i].i, f, vffrexpSC[i])
2167                 }
2168         }
2169         for i := 0; i < len(vfldexpSC); i++ {
2170                 if f := Ldexp(vfldexpSC[i].f, vfldexpSC[i].i); !alike(ldexpSC[i], f) {
2171                         t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpSC[i].f, vfldexpSC[i].i, f, ldexpSC[i])
2172                 }
2173         }
2174         for i := 0; i < len(vffrexpBC); i++ {
2175                 if f := Ldexp(frexpBC[i].f, frexpBC[i].i); !alike(vffrexpBC[i], f) {
2176                         t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpBC[i].f, frexpBC[i].i, f, vffrexpBC[i])
2177                 }
2178         }
2179         for i := 0; i < len(vfldexpBC); i++ {
2180                 if f := Ldexp(vfldexpBC[i].f, vfldexpBC[i].i); !alike(ldexpBC[i], f) {
2181                         t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpBC[i].f, vfldexpBC[i].i, f, ldexpBC[i])
2182                 }
2183         }
2184 }
2185
2186 func TestLgamma(t *testing.T) {
2187         for i := 0; i < len(vf); i++ {
2188                 if f, s := Lgamma(vf[i]); !close(lgamma[i].f, f) || lgamma[i].i != s {
2189                         t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vf[i], f, s, lgamma[i].f, lgamma[i].i)
2190                 }
2191         }
2192         for i := 0; i < len(vflgammaSC); i++ {
2193                 if f, s := Lgamma(vflgammaSC[i]); !alike(lgammaSC[i].f, f) || lgammaSC[i].i != s {
2194                         t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vflgammaSC[i], f, s, lgammaSC[i].f, lgammaSC[i].i)
2195                 }
2196         }
2197 }
2198
2199 func TestLog(t *testing.T) {
2200         for i := 0; i < len(vf); i++ {
2201                 a := Abs(vf[i])
2202                 if f := Log(a); log[i] != f {
2203                         t.Errorf("Log(%g) = %g, want %g", a, f, log[i])
2204                 }
2205         }
2206         if f := Log(10); f != Ln10 {
2207                 t.Errorf("Log(%g) = %g, want %g", 10.0, f, Ln10)
2208         }
2209         for i := 0; i < len(vflogSC); i++ {
2210                 if f := Log(vflogSC[i]); !alike(logSC[i], f) {
2211                         t.Errorf("Log(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2212                 }
2213         }
2214 }
2215
2216 func TestLogb(t *testing.T) {
2217         for i := 0; i < len(vf); i++ {
2218                 if f := Logb(vf[i]); logb[i] != f {
2219                         t.Errorf("Logb(%g) = %g, want %g", vf[i], f, logb[i])
2220                 }
2221         }
2222         for i := 0; i < len(vflogbSC); i++ {
2223                 if f := Logb(vflogbSC[i]); !alike(logbSC[i], f) {
2224                         t.Errorf("Logb(%g) = %g, want %g", vflogbSC[i], f, logbSC[i])
2225                 }
2226         }
2227         for i := 0; i < len(vffrexpBC); i++ {
2228                 if f := Logb(vffrexpBC[i]); !alike(logbBC[i], f) {
2229                         t.Errorf("Logb(%g) = %g, want %g", vffrexpBC[i], f, logbBC[i])
2230                 }
2231         }
2232 }
2233
2234 func TestLog10(t *testing.T) {
2235         for i := 0; i < len(vf); i++ {
2236                 a := Abs(vf[i])
2237                 if f := Log10(a); !veryclose(log10[i], f) {
2238                         t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i])
2239                 }
2240         }
2241         if f := Log10(E); f != Log10E {
2242                 t.Errorf("Log10(%g) = %g, want %g", E, f, Log10E)
2243         }
2244         for i := 0; i < len(vflogSC); i++ {
2245                 if f := Log10(vflogSC[i]); !alike(logSC[i], f) {
2246                         t.Errorf("Log10(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2247                 }
2248         }
2249 }
2250
2251 func TestLog1p(t *testing.T) {
2252         for i := 0; i < len(vf); i++ {
2253                 a := vf[i] / 100
2254                 if f := Log1p(a); !veryclose(log1p[i], f) {
2255                         t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i])
2256                 }
2257         }
2258         a := 9.0
2259         if f := Log1p(a); f != Ln10 {
2260                 t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10)
2261         }
2262         for i := 0; i < len(vflogSC); i++ {
2263                 if f := Log1p(vflog1pSC[i]); !alike(log1pSC[i], f) {
2264                         t.Errorf("Log1p(%g) = %g, want %g", vflog1pSC[i], f, log1pSC[i])
2265                 }
2266         }
2267 }
2268
2269 func TestLog2(t *testing.T) {
2270         for i := 0; i < len(vf); i++ {
2271                 a := Abs(vf[i])
2272                 if f := Log2(a); !veryclose(log2[i], f) {
2273                         t.Errorf("Log2(%g) = %g, want %g", a, f, log2[i])
2274                 }
2275         }
2276         if f := Log2(E); f != Log2E {
2277                 t.Errorf("Log2(%g) = %g, want %g", E, f, Log2E)
2278         }
2279         for i := 0; i < len(vflogSC); i++ {
2280                 if f := Log2(vflogSC[i]); !alike(logSC[i], f) {
2281                         t.Errorf("Log2(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2282                 }
2283         }
2284 }
2285
2286 func TestModf(t *testing.T) {
2287         for i := 0; i < len(vf); i++ {
2288                 if f, g := Modf(vf[i]); !veryclose(modf[i][0], f) || !veryclose(modf[i][1], g) {
2289                         t.Errorf("Modf(%g) = %g, %g, want %g, %g", vf[i], f, g, modf[i][0], modf[i][1])
2290                 }
2291         }
2292         for i := 0; i < len(vfmodfSC); i++ {
2293                 if f, g := Modf(vfmodfSC[i]); !alike(modfSC[i][0], f) || !alike(modfSC[i][1], g) {
2294                         t.Errorf("Modf(%g) = %g, %g, want %g, %g", vfmodfSC[i], f, g, modfSC[i][0], modfSC[i][1])
2295                 }
2296         }
2297 }
2298
2299 func TestNextafter(t *testing.T) {
2300         for i := 0; i < len(vf); i++ {
2301                 if f := Nextafter(vf[i], 10); nextafter[i] != f {
2302                         t.Errorf("Nextafter(%g, %g) = %g want %g", vf[i], 10.0, f, nextafter[i])
2303                 }
2304         }
2305         for i := 0; i < len(vfnextafterSC); i++ {
2306                 if f := Nextafter(vfnextafterSC[i][0], vfnextafterSC[i][1]); !alike(nextafterSC[i], f) {
2307                         t.Errorf("Nextafter(%g, %g) = %g want %g", vfnextafterSC[i][0], vfnextafterSC[i][1], f, nextafterSC[i])
2308                 }
2309         }
2310 }
2311
2312 func TestPow(t *testing.T) {
2313         for i := 0; i < len(vf); i++ {
2314                 if f := Pow(10, vf[i]); !close(pow[i], f) {
2315                         t.Errorf("Pow(10, %g) = %g, want %g", vf[i], f, pow[i])
2316                 }
2317         }
2318         for i := 0; i < len(vfpowSC); i++ {
2319                 if f := Pow(vfpowSC[i][0], vfpowSC[i][1]); !alike(powSC[i], f) {
2320                         t.Errorf("Pow(%g, %g) = %g, want %g", vfpowSC[i][0], vfpowSC[i][1], f, powSC[i])
2321                 }
2322         }
2323 }
2324
2325 func TestPow10(t *testing.T) {
2326         for i := 0; i < len(vfpow10SC); i++ {
2327                 if f := Pow10(vfpow10SC[i]); !alike(pow10SC[i], f) {
2328                         t.Errorf("Pow10(%d) = %g, want %g", vfpow10SC[i], f, pow10SC[i])
2329                 }
2330         }
2331 }
2332
2333 func TestRemainder(t *testing.T) {
2334         for i := 0; i < len(vf); i++ {
2335                 if f := Remainder(10, vf[i]); remainder[i] != f {
2336                         t.Errorf("Remainder(10, %g) = %g, want %g", vf[i], f, remainder[i])
2337                 }
2338         }
2339         for i := 0; i < len(vffmodSC); i++ {
2340                 if f := Remainder(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
2341                         t.Errorf("Remainder(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
2342                 }
2343         }
2344 }
2345
2346 func TestSignbit(t *testing.T) {
2347         for i := 0; i < len(vf); i++ {
2348                 if f := Signbit(vf[i]); signbit[i] != f {
2349                         t.Errorf("Signbit(%g) = %t, want %t", vf[i], f, signbit[i])
2350                 }
2351         }
2352         for i := 0; i < len(vfsignbitSC); i++ {
2353                 if f := Signbit(vfsignbitSC[i]); signbitSC[i] != f {
2354                         t.Errorf("Signbit(%g) = %t, want %t", vfsignbitSC[i], f, signbitSC[i])
2355                 }
2356         }
2357 }
2358 func TestSin(t *testing.T) {
2359         for i := 0; i < len(vf); i++ {
2360                 if f := Sin(vf[i]); !veryclose(sin[i], f) {
2361                         t.Errorf("Sin(%g) = %g, want %g", vf[i], f, sin[i])
2362                 }
2363         }
2364         for i := 0; i < len(vfsinSC); i++ {
2365                 if f := Sin(vfsinSC[i]); !alike(sinSC[i], f) {
2366                         t.Errorf("Sin(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
2367                 }
2368         }
2369 }
2370
2371 func TestSincos(t *testing.T) {
2372         for i := 0; i < len(vf); i++ {
2373                 if s, c := Sincos(vf[i]); !veryclose(sin[i], s) || !veryclose(cos[i], c) {
2374                         t.Errorf("Sincos(%g) = %g, %g want %g, %g", vf[i], s, c, sin[i], cos[i])
2375                 }
2376         }
2377 }
2378
2379 func TestSinh(t *testing.T) {
2380         for i := 0; i < len(vf); i++ {
2381                 if f := Sinh(vf[i]); !close(sinh[i], f) {
2382                         t.Errorf("Sinh(%g) = %g, want %g", vf[i], f, sinh[i])
2383                 }
2384         }
2385         for i := 0; i < len(vfsinhSC); i++ {
2386                 if f := Sinh(vfsinhSC[i]); !alike(sinhSC[i], f) {
2387                         t.Errorf("Sinh(%g) = %g, want %g", vfsinhSC[i], f, sinhSC[i])
2388                 }
2389         }
2390 }
2391
2392 func TestSqrt(t *testing.T) {
2393         for i := 0; i < len(vf); i++ {
2394                 a := Abs(vf[i])
2395                 if f := SqrtGo(a); sqrt[i] != f {
2396                         t.Errorf("SqrtGo(%g) = %g, want %g", a, f, sqrt[i])
2397                 }
2398                 a = Abs(vf[i])
2399                 if f := Sqrt(a); sqrt[i] != f {
2400                         t.Errorf("Sqrt(%g) = %g, want %g", a, f, sqrt[i])
2401                 }
2402         }
2403         for i := 0; i < len(vfsqrtSC); i++ {
2404                 if f := SqrtGo(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
2405                         t.Errorf("SqrtGo(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
2406                 }
2407                 if f := Sqrt(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
2408                         t.Errorf("Sqrt(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
2409                 }
2410         }
2411 }
2412
2413 func TestTan(t *testing.T) {
2414         for i := 0; i < len(vf); i++ {
2415                 if f := Tan(vf[i]); !veryclose(tan[i], f) {
2416                         t.Errorf("Tan(%g) = %g, want %g", vf[i], f, tan[i])
2417                 }
2418         }
2419         // same special cases as Sin
2420         for i := 0; i < len(vfsinSC); i++ {
2421                 if f := Tan(vfsinSC[i]); !alike(sinSC[i], f) {
2422                         t.Errorf("Tan(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
2423                 }
2424         }
2425 }
2426
2427 func TestTanh(t *testing.T) {
2428         for i := 0; i < len(vf); i++ {
2429                 if f := Tanh(vf[i]); !veryclose(tanh[i], f) {
2430                         t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i])
2431                 }
2432         }
2433         for i := 0; i < len(vftanhSC); i++ {
2434                 if f := Tanh(vftanhSC[i]); !alike(tanhSC[i], f) {
2435                         t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i])
2436                 }
2437         }
2438 }
2439
2440 func TestTrunc(t *testing.T) {
2441         for i := 0; i < len(vf); i++ {
2442                 if f := Trunc(vf[i]); trunc[i] != f {
2443                         t.Errorf("Trunc(%g) = %g, want %g", vf[i], f, trunc[i])
2444                 }
2445         }
2446         for i := 0; i < len(vfceilSC); i++ {
2447                 if f := Trunc(vfceilSC[i]); !alike(ceilSC[i], f) {
2448                         t.Errorf("Trunc(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
2449                 }
2450         }
2451 }
2452
2453 func TestY0(t *testing.T) {
2454         for i := 0; i < len(vf); i++ {
2455                 a := Abs(vf[i])
2456                 if f := Y0(a); !close(y0[i], f) {
2457                         t.Errorf("Y0(%g) = %g, want %g", a, f, y0[i])
2458                 }
2459         }
2460         for i := 0; i < len(vfy0SC); i++ {
2461                 if f := Y0(vfy0SC[i]); !alike(y0SC[i], f) {
2462                         t.Errorf("Y0(%g) = %g, want %g", vfy0SC[i], f, y0SC[i])
2463                 }
2464         }
2465 }
2466
2467 func TestY1(t *testing.T) {
2468         for i := 0; i < len(vf); i++ {
2469                 a := Abs(vf[i])
2470                 if f := Y1(a); !soclose(y1[i], f, 2e-14) {
2471                         t.Errorf("Y1(%g) = %g, want %g", a, f, y1[i])
2472                 }
2473         }
2474         for i := 0; i < len(vfy0SC); i++ {
2475                 if f := Y1(vfy0SC[i]); !alike(y1SC[i], f) {
2476                         t.Errorf("Y1(%g) = %g, want %g", vfy0SC[i], f, y1SC[i])
2477                 }
2478         }
2479 }
2480
2481 func TestYn(t *testing.T) {
2482         for i := 0; i < len(vf); i++ {
2483                 a := Abs(vf[i])
2484                 if f := Yn(2, a); !close(y2[i], f) {
2485                         t.Errorf("Yn(2, %g) = %g, want %g", a, f, y2[i])
2486                 }
2487                 if f := Yn(-3, a); !close(yM3[i], f) {
2488                         t.Errorf("Yn(-3, %g) = %g, want %g", a, f, yM3[i])
2489                 }
2490         }
2491         for i := 0; i < len(vfy0SC); i++ {
2492                 if f := Yn(2, vfy0SC[i]); !alike(y2SC[i], f) {
2493                         t.Errorf("Yn(2, %g) = %g, want %g", vfy0SC[i], f, y2SC[i])
2494                 }
2495                 if f := Yn(-3, vfy0SC[i]); !alike(yM3SC[i], f) {
2496                         t.Errorf("Yn(-3, %g) = %g, want %g", vfy0SC[i], f, yM3SC[i])
2497                 }
2498         }
2499 }
2500
2501 // Check that math functions of high angle values
2502 // return accurate results. [Since (vf[i] + large) - large != vf[i],
2503 // testing for Trig(vf[i] + large) == Trig(vf[i]), where large is
2504 // a multiple of 2*Pi, is misleading.]
2505 func TestLargeCos(t *testing.T) {
2506         large := float64(100000 * Pi)
2507         for i := 0; i < len(vf); i++ {
2508                 f1 := cosLarge[i]
2509                 f2 := Cos(vf[i] + large)
2510                 if !close(f1, f2) {
2511                         t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1)
2512                 }
2513         }
2514 }
2515
2516 func TestLargeSin(t *testing.T) {
2517         large := float64(100000 * Pi)
2518         for i := 0; i < len(vf); i++ {
2519                 f1 := sinLarge[i]
2520                 f2 := Sin(vf[i] + large)
2521                 if !close(f1, f2) {
2522                         t.Errorf("Sin(%g) = %g, want %g", vf[i]+large, f2, f1)
2523                 }
2524         }
2525 }
2526
2527 func TestLargeSincos(t *testing.T) {
2528         large := float64(100000 * Pi)
2529         for i := 0; i < len(vf); i++ {
2530                 f1, g1 := sinLarge[i], cosLarge[i]
2531                 f2, g2 := Sincos(vf[i] + large)
2532                 if !close(f1, f2) || !close(g1, g2) {
2533                         t.Errorf("Sincos(%g) = %g, %g, want %g, %g", vf[i]+large, f2, g2, f1, g1)
2534                 }
2535         }
2536 }
2537
2538 func TestLargeTan(t *testing.T) {
2539         large := float64(100000 * Pi)
2540         for i := 0; i < len(vf); i++ {
2541                 f1 := tanLarge[i]
2542                 f2 := Tan(vf[i] + large)
2543                 if !close(f1, f2) {
2544                         t.Errorf("Tan(%g) = %g, want %g", vf[i]+large, f2, f1)
2545                 }
2546         }
2547 }
2548
2549 // Check that math constants are accepted by compiler
2550 // and have right value (assumes strconv.ParseFloat works).
2551 // http://code.google.com/p/go/issues/detail?id=201
2552
2553 type floatTest struct {
2554         val  interface{}
2555         name string
2556         str  string
2557 }
2558
2559 var floatTests = []floatTest{
2560         {float64(MaxFloat64), "MaxFloat64", "1.7976931348623157e+308"},
2561         {float64(SmallestNonzeroFloat64), "SmallestNonzeroFloat64", "5e-324"},
2562         {float32(MaxFloat32), "MaxFloat32", "3.4028235e+38"},
2563         {float32(SmallestNonzeroFloat32), "SmallestNonzeroFloat32", "1e-45"},
2564 }
2565
2566 func TestFloatMinMax(t *testing.T) {
2567         for _, tt := range floatTests {
2568                 s := fmt.Sprint(tt.val)
2569                 if s != tt.str {
2570                         t.Errorf("Sprint(%v) = %s, want %s", tt.name, s, tt.str)
2571                 }
2572         }
2573 }
2574
2575 // Benchmarks
2576
2577 func BenchmarkAcos(b *testing.B) {
2578         for i := 0; i < b.N; i++ {
2579                 Acos(.5)
2580         }
2581 }
2582
2583 func BenchmarkAcosh(b *testing.B) {
2584         for i := 0; i < b.N; i++ {
2585                 Acosh(1.5)
2586         }
2587 }
2588
2589 func BenchmarkAsin(b *testing.B) {
2590         for i := 0; i < b.N; i++ {
2591                 Asin(.5)
2592         }
2593 }
2594
2595 func BenchmarkAsinh(b *testing.B) {
2596         for i := 0; i < b.N; i++ {
2597                 Asinh(.5)
2598         }
2599 }
2600
2601 func BenchmarkAtan(b *testing.B) {
2602         for i := 0; i < b.N; i++ {
2603                 Atan(.5)
2604         }
2605 }
2606
2607 func BenchmarkAtanh(b *testing.B) {
2608         for i := 0; i < b.N; i++ {
2609                 Atanh(.5)
2610         }
2611 }
2612
2613 func BenchmarkAtan2(b *testing.B) {
2614         for i := 0; i < b.N; i++ {
2615                 Atan2(.5, 1)
2616         }
2617 }
2618
2619 func BenchmarkCbrt(b *testing.B) {
2620         for i := 0; i < b.N; i++ {
2621                 Cbrt(10)
2622         }
2623 }
2624
2625 func BenchmarkCeil(b *testing.B) {
2626         for i := 0; i < b.N; i++ {
2627                 Ceil(.5)
2628         }
2629 }
2630
2631 func BenchmarkCopysign(b *testing.B) {
2632         for i := 0; i < b.N; i++ {
2633                 Copysign(.5, -1)
2634         }
2635 }
2636
2637 func BenchmarkCos(b *testing.B) {
2638         for i := 0; i < b.N; i++ {
2639                 Cos(.5)
2640         }
2641 }
2642
2643 func BenchmarkCosh(b *testing.B) {
2644         for i := 0; i < b.N; i++ {
2645                 Cosh(2.5)
2646         }
2647 }
2648
2649 func BenchmarkErf(b *testing.B) {
2650         for i := 0; i < b.N; i++ {
2651                 Erf(.5)
2652         }
2653 }
2654
2655 func BenchmarkErfc(b *testing.B) {
2656         for i := 0; i < b.N; i++ {
2657                 Erfc(.5)
2658         }
2659 }
2660
2661 func BenchmarkExp(b *testing.B) {
2662         for i := 0; i < b.N; i++ {
2663                 Exp(.5)
2664         }
2665 }
2666
2667 func BenchmarkExpGo(b *testing.B) {
2668         for i := 0; i < b.N; i++ {
2669                 ExpGo(.5)
2670         }
2671 }
2672
2673 func BenchmarkExpm1(b *testing.B) {
2674         for i := 0; i < b.N; i++ {
2675                 Expm1(.5)
2676         }
2677 }
2678
2679 func BenchmarkExp2(b *testing.B) {
2680         for i := 0; i < b.N; i++ {
2681                 Exp2(.5)
2682         }
2683 }
2684
2685 func BenchmarkExp2Go(b *testing.B) {
2686         for i := 0; i < b.N; i++ {
2687                 Exp2Go(.5)
2688         }
2689 }
2690
2691 func BenchmarkAbs(b *testing.B) {
2692         for i := 0; i < b.N; i++ {
2693                 Abs(.5)
2694         }
2695 }
2696
2697 func BenchmarkDim(b *testing.B) {
2698         for i := 0; i < b.N; i++ {
2699                 Dim(10, 3)
2700         }
2701 }
2702
2703 func BenchmarkFloor(b *testing.B) {
2704         for i := 0; i < b.N; i++ {
2705                 Floor(.5)
2706         }
2707 }
2708
2709 func BenchmarkMax(b *testing.B) {
2710         for i := 0; i < b.N; i++ {
2711                 Max(10, 3)
2712         }
2713 }
2714
2715 func BenchmarkMin(b *testing.B) {
2716         for i := 0; i < b.N; i++ {
2717                 Min(10, 3)
2718         }
2719 }
2720
2721 func BenchmarkMod(b *testing.B) {
2722         for i := 0; i < b.N; i++ {
2723                 Mod(10, 3)
2724         }
2725 }
2726
2727 func BenchmarkFrexp(b *testing.B) {
2728         for i := 0; i < b.N; i++ {
2729                 Frexp(8)
2730         }
2731 }
2732
2733 func BenchmarkGamma(b *testing.B) {
2734         for i := 0; i < b.N; i++ {
2735                 Gamma(2.5)
2736         }
2737 }
2738
2739 func BenchmarkHypot(b *testing.B) {
2740         for i := 0; i < b.N; i++ {
2741                 Hypot(3, 4)
2742         }
2743 }
2744
2745 func BenchmarkHypotGo(b *testing.B) {
2746         for i := 0; i < b.N; i++ {
2747                 HypotGo(3, 4)
2748         }
2749 }
2750
2751 func BenchmarkIlogb(b *testing.B) {
2752         for i := 0; i < b.N; i++ {
2753                 Ilogb(.5)
2754         }
2755 }
2756
2757 func BenchmarkJ0(b *testing.B) {
2758         for i := 0; i < b.N; i++ {
2759                 J0(2.5)
2760         }
2761 }
2762
2763 func BenchmarkJ1(b *testing.B) {
2764         for i := 0; i < b.N; i++ {
2765                 J1(2.5)
2766         }
2767 }
2768
2769 func BenchmarkJn(b *testing.B) {
2770         for i := 0; i < b.N; i++ {
2771                 Jn(2, 2.5)
2772         }
2773 }
2774
2775 func BenchmarkLdexp(b *testing.B) {
2776         for i := 0; i < b.N; i++ {
2777                 Ldexp(.5, 2)
2778         }
2779 }
2780
2781 func BenchmarkLgamma(b *testing.B) {
2782         for i := 0; i < b.N; i++ {
2783                 Lgamma(2.5)
2784         }
2785 }
2786
2787 func BenchmarkLog(b *testing.B) {
2788         for i := 0; i < b.N; i++ {
2789                 Log(.5)
2790         }
2791 }
2792
2793 func BenchmarkLogb(b *testing.B) {
2794         for i := 0; i < b.N; i++ {
2795                 Logb(.5)
2796         }
2797 }
2798
2799 func BenchmarkLog1p(b *testing.B) {
2800         for i := 0; i < b.N; i++ {
2801                 Log1p(.5)
2802         }
2803 }
2804
2805 func BenchmarkLog10(b *testing.B) {
2806         for i := 0; i < b.N; i++ {
2807                 Log10(.5)
2808         }
2809 }
2810
2811 func BenchmarkLog2(b *testing.B) {
2812         for i := 0; i < b.N; i++ {
2813                 Log2(.5)
2814         }
2815 }
2816
2817 func BenchmarkModf(b *testing.B) {
2818         for i := 0; i < b.N; i++ {
2819                 Modf(1.5)
2820         }
2821 }
2822
2823 func BenchmarkNextafter(b *testing.B) {
2824         for i := 0; i < b.N; i++ {
2825                 Nextafter(.5, 1)
2826         }
2827 }
2828
2829 func BenchmarkPowInt(b *testing.B) {
2830         for i := 0; i < b.N; i++ {
2831                 Pow(2, 2)
2832         }
2833 }
2834
2835 func BenchmarkPowFrac(b *testing.B) {
2836         for i := 0; i < b.N; i++ {
2837                 Pow(2.5, 1.5)
2838         }
2839 }
2840
2841 func BenchmarkPow10Pos(b *testing.B) {
2842         for i := 0; i < b.N; i++ {
2843                 Pow10(300)
2844         }
2845 }
2846
2847 func BenchmarkPow10Neg(b *testing.B) {
2848         for i := 0; i < b.N; i++ {
2849                 Pow10(-300)
2850         }
2851 }
2852
2853 func BenchmarkRemainder(b *testing.B) {
2854         for i := 0; i < b.N; i++ {
2855                 Remainder(10, 3)
2856         }
2857 }
2858
2859 func BenchmarkSignbit(b *testing.B) {
2860         for i := 0; i < b.N; i++ {
2861                 Signbit(2.5)
2862         }
2863 }
2864
2865 func BenchmarkSin(b *testing.B) {
2866         for i := 0; i < b.N; i++ {
2867                 Sin(.5)
2868         }
2869 }
2870
2871 func BenchmarkSincos(b *testing.B) {
2872         for i := 0; i < b.N; i++ {
2873                 Sincos(.5)
2874         }
2875 }
2876
2877 func BenchmarkSinh(b *testing.B) {
2878         for i := 0; i < b.N; i++ {
2879                 Sinh(2.5)
2880         }
2881 }
2882
2883 func BenchmarkSqrt(b *testing.B) {
2884         for i := 0; i < b.N; i++ {
2885                 Sqrt(10)
2886         }
2887 }
2888
2889 func BenchmarkSqrtGo(b *testing.B) {
2890         for i := 0; i < b.N; i++ {
2891                 SqrtGo(10)
2892         }
2893 }
2894
2895 func BenchmarkTan(b *testing.B) {
2896         for i := 0; i < b.N; i++ {
2897                 Tan(.5)
2898         }
2899 }
2900
2901 func BenchmarkTanh(b *testing.B) {
2902         for i := 0; i < b.N; i++ {
2903                 Tanh(2.5)
2904         }
2905 }
2906 func BenchmarkTrunc(b *testing.B) {
2907         for i := 0; i < b.N; i++ {
2908                 Trunc(.5)
2909         }
2910 }
2911
2912 func BenchmarkY0(b *testing.B) {
2913         for i := 0; i < b.N; i++ {
2914                 Y0(2.5)
2915         }
2916 }
2917
2918 func BenchmarkY1(b *testing.B) {
2919         for i := 0; i < b.N; i++ {
2920                 Y1(2.5)
2921         }
2922 }
2923
2924 func BenchmarkYn(b *testing.B) {
2925         for i := 0; i < b.N; i++ {
2926                 Yn(2, 2.5)
2927         }
2928 }