...

Source file src/math/all_test.go

Documentation: math

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

View as plain text