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  	// verify that sign is correct when r == 0.
  2799  	test := func(x, y float64) {
  2800  		if r := Remainder(x, y); r == 0 && Signbit(r) != Signbit(x) {
  2801  			t.Errorf("Remainder(x=%f, y=%f) = %f, sign of (zero) result should agree with sign of x", x, y, r)
  2802  		}
  2803  	}
  2804  	for x := 0.0; x <= 3.0; x += 1 {
  2805  		for y := 1.0; y <= 3.0; y += 1 {
  2806  			test(x, y)
  2807  			test(x, -y)
  2808  			test(-x, y)
  2809  			test(-x, -y)
  2810  		}
  2811  	}
  2812  }
  2813  
  2814  func TestRound(t *testing.T) {
  2815  	for i := 0; i < len(vf); i++ {
  2816  		if f := Round(vf[i]); !alike(round[i], f) {
  2817  			t.Errorf("Round(%g) = %g, want %g", vf[i], f, round[i])
  2818  		}
  2819  	}
  2820  	for i := 0; i < len(vfroundSC); i++ {
  2821  		if f := Round(vfroundSC[i][0]); !alike(vfroundSC[i][1], f) {
  2822  			t.Errorf("Round(%g) = %g, want %g", vfroundSC[i][0], f, vfroundSC[i][1])
  2823  		}
  2824  	}
  2825  }
  2826  
  2827  func TestRoundToEven(t *testing.T) {
  2828  	for i := 0; i < len(vf); i++ {
  2829  		if f := RoundToEven(vf[i]); !alike(round[i], f) {
  2830  			t.Errorf("RoundToEven(%g) = %g, want %g", vf[i], f, round[i])
  2831  		}
  2832  	}
  2833  	for i := 0; i < len(vfroundEvenSC); i++ {
  2834  		if f := RoundToEven(vfroundEvenSC[i][0]); !alike(vfroundEvenSC[i][1], f) {
  2835  			t.Errorf("RoundToEven(%g) = %g, want %g", vfroundEvenSC[i][0], f, vfroundEvenSC[i][1])
  2836  		}
  2837  	}
  2838  }
  2839  
  2840  func TestSignbit(t *testing.T) {
  2841  	for i := 0; i < len(vf); i++ {
  2842  		if f := Signbit(vf[i]); signbit[i] != f {
  2843  			t.Errorf("Signbit(%g) = %t, want %t", vf[i], f, signbit[i])
  2844  		}
  2845  	}
  2846  	for i := 0; i < len(vfsignbitSC); i++ {
  2847  		if f := Signbit(vfsignbitSC[i]); signbitSC[i] != f {
  2848  			t.Errorf("Signbit(%g) = %t, want %t", vfsignbitSC[i], f, signbitSC[i])
  2849  		}
  2850  	}
  2851  }
  2852  func TestSin(t *testing.T) {
  2853  	for i := 0; i < len(vf); i++ {
  2854  		if f := Sin(vf[i]); !veryclose(sin[i], f) {
  2855  			t.Errorf("Sin(%g) = %g, want %g", vf[i], f, sin[i])
  2856  		}
  2857  	}
  2858  	for i := 0; i < len(vfsinSC); i++ {
  2859  		if f := Sin(vfsinSC[i]); !alike(sinSC[i], f) {
  2860  			t.Errorf("Sin(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
  2861  		}
  2862  	}
  2863  }
  2864  
  2865  func TestSincos(t *testing.T) {
  2866  	for i := 0; i < len(vf); i++ {
  2867  		if s, c := Sincos(vf[i]); !veryclose(sin[i], s) || !veryclose(cos[i], c) {
  2868  			t.Errorf("Sincos(%g) = %g, %g want %g, %g", vf[i], s, c, sin[i], cos[i])
  2869  		}
  2870  	}
  2871  }
  2872  
  2873  func TestSinh(t *testing.T) {
  2874  	for i := 0; i < len(vf); i++ {
  2875  		if f := Sinh(vf[i]); !close(sinh[i], f) {
  2876  			t.Errorf("Sinh(%g) = %g, want %g", vf[i], f, sinh[i])
  2877  		}
  2878  	}
  2879  	for i := 0; i < len(vfsinhSC); i++ {
  2880  		if f := Sinh(vfsinhSC[i]); !alike(sinhSC[i], f) {
  2881  			t.Errorf("Sinh(%g) = %g, want %g", vfsinhSC[i], f, sinhSC[i])
  2882  		}
  2883  	}
  2884  }
  2885  
  2886  func TestSqrt(t *testing.T) {
  2887  	for i := 0; i < len(vf); i++ {
  2888  		a := Abs(vf[i])
  2889  		if f := SqrtGo(a); sqrt[i] != f {
  2890  			t.Errorf("SqrtGo(%g) = %g, want %g", a, f, sqrt[i])
  2891  		}
  2892  		a = Abs(vf[i])
  2893  		if f := Sqrt(a); sqrt[i] != f {
  2894  			t.Errorf("Sqrt(%g) = %g, want %g", a, f, sqrt[i])
  2895  		}
  2896  	}
  2897  	for i := 0; i < len(vfsqrtSC); i++ {
  2898  		if f := SqrtGo(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
  2899  			t.Errorf("SqrtGo(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
  2900  		}
  2901  		if f := Sqrt(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
  2902  			t.Errorf("Sqrt(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
  2903  		}
  2904  	}
  2905  }
  2906  
  2907  func TestTan(t *testing.T) {
  2908  	for i := 0; i < len(vf); i++ {
  2909  		if f := Tan(vf[i]); !veryclose(tan[i], f) {
  2910  			t.Errorf("Tan(%g) = %g, want %g", vf[i], f, tan[i])
  2911  		}
  2912  	}
  2913  	// same special cases as Sin
  2914  	for i := 0; i < len(vfsinSC); i++ {
  2915  		if f := Tan(vfsinSC[i]); !alike(sinSC[i], f) {
  2916  			t.Errorf("Tan(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
  2917  		}
  2918  	}
  2919  }
  2920  
  2921  func TestTanh(t *testing.T) {
  2922  	for i := 0; i < len(vf); i++ {
  2923  		if f := Tanh(vf[i]); !veryclose(tanh[i], f) {
  2924  			t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i])
  2925  		}
  2926  	}
  2927  	for i := 0; i < len(vftanhSC); i++ {
  2928  		if f := Tanh(vftanhSC[i]); !alike(tanhSC[i], f) {
  2929  			t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i])
  2930  		}
  2931  	}
  2932  }
  2933  
  2934  func TestTrunc(t *testing.T) {
  2935  	for i := 0; i < len(vf); i++ {
  2936  		if f := Trunc(vf[i]); !alike(trunc[i], f) {
  2937  			t.Errorf("Trunc(%g) = %g, want %g", vf[i], f, trunc[i])
  2938  		}
  2939  	}
  2940  	for i := 0; i < len(vfceilSC); i++ {
  2941  		if f := Trunc(vfceilSC[i]); !alike(ceilSC[i], f) {
  2942  			t.Errorf("Trunc(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
  2943  		}
  2944  	}
  2945  }
  2946  
  2947  func TestY0(t *testing.T) {
  2948  	for i := 0; i < len(vf); i++ {
  2949  		a := Abs(vf[i])
  2950  		if f := Y0(a); !close(y0[i], f) {
  2951  			t.Errorf("Y0(%g) = %g, want %g", a, f, y0[i])
  2952  		}
  2953  	}
  2954  	for i := 0; i < len(vfy0SC); i++ {
  2955  		if f := Y0(vfy0SC[i]); !alike(y0SC[i], f) {
  2956  			t.Errorf("Y0(%g) = %g, want %g", vfy0SC[i], f, y0SC[i])
  2957  		}
  2958  	}
  2959  }
  2960  
  2961  func TestY1(t *testing.T) {
  2962  	for i := 0; i < len(vf); i++ {
  2963  		a := Abs(vf[i])
  2964  		if f := Y1(a); !soclose(y1[i], f, 2e-14) {
  2965  			t.Errorf("Y1(%g) = %g, want %g", a, f, y1[i])
  2966  		}
  2967  	}
  2968  	for i := 0; i < len(vfy0SC); i++ {
  2969  		if f := Y1(vfy0SC[i]); !alike(y1SC[i], f) {
  2970  			t.Errorf("Y1(%g) = %g, want %g", vfy0SC[i], f, y1SC[i])
  2971  		}
  2972  	}
  2973  }
  2974  
  2975  func TestYn(t *testing.T) {
  2976  	for i := 0; i < len(vf); i++ {
  2977  		a := Abs(vf[i])
  2978  		if f := Yn(2, a); !close(y2[i], f) {
  2979  			t.Errorf("Yn(2, %g) = %g, want %g", a, f, y2[i])
  2980  		}
  2981  		if f := Yn(-3, a); !close(yM3[i], f) {
  2982  			t.Errorf("Yn(-3, %g) = %g, want %g", a, f, yM3[i])
  2983  		}
  2984  	}
  2985  	for i := 0; i < len(vfy0SC); i++ {
  2986  		if f := Yn(2, vfy0SC[i]); !alike(y2SC[i], f) {
  2987  			t.Errorf("Yn(2, %g) = %g, want %g", vfy0SC[i], f, y2SC[i])
  2988  		}
  2989  		if f := Yn(-3, vfy0SC[i]); !alike(yM3SC[i], f) {
  2990  			t.Errorf("Yn(-3, %g) = %g, want %g", vfy0SC[i], f, yM3SC[i])
  2991  		}
  2992  	}
  2993  	if f := Yn(0, 0); !alike(Inf(-1), f) {
  2994  		t.Errorf("Yn(0, 0) = %g, want %g", f, Inf(-1))
  2995  	}
  2996  }
  2997  
  2998  // Check that math functions of high angle values
  2999  // return accurate results. [Since (vf[i] + large) - large != vf[i],
  3000  // testing for Trig(vf[i] + large) == Trig(vf[i]), where large is
  3001  // a multiple of 2*Pi, is misleading.]
  3002  func TestLargeCos(t *testing.T) {
  3003  	large := float64(100000 * Pi)
  3004  	for i := 0; i < len(vf); i++ {
  3005  		f1 := cosLarge[i]
  3006  		f2 := Cos(vf[i] + large)
  3007  		if !close(f1, f2) {
  3008  			t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1)
  3009  		}
  3010  	}
  3011  }
  3012  
  3013  func TestLargeSin(t *testing.T) {
  3014  	large := float64(100000 * Pi)
  3015  	for i := 0; i < len(vf); i++ {
  3016  		f1 := sinLarge[i]
  3017  		f2 := Sin(vf[i] + large)
  3018  		if !close(f1, f2) {
  3019  			t.Errorf("Sin(%g) = %g, want %g", vf[i]+large, f2, f1)
  3020  		}
  3021  	}
  3022  }
  3023  
  3024  func TestLargeSincos(t *testing.T) {
  3025  	large := float64(100000 * Pi)
  3026  	for i := 0; i < len(vf); i++ {
  3027  		f1, g1 := sinLarge[i], cosLarge[i]
  3028  		f2, g2 := Sincos(vf[i] + large)
  3029  		if !close(f1, f2) || !close(g1, g2) {
  3030  			t.Errorf("Sincos(%g) = %g, %g, want %g, %g", vf[i]+large, f2, g2, f1, g1)
  3031  		}
  3032  	}
  3033  }
  3034  
  3035  func TestLargeTan(t *testing.T) {
  3036  	large := float64(100000 * Pi)
  3037  	for i := 0; i < len(vf); i++ {
  3038  		f1 := tanLarge[i]
  3039  		f2 := Tan(vf[i] + large)
  3040  		if !close(f1, f2) {
  3041  			t.Errorf("Tan(%g) = %g, want %g", vf[i]+large, f2, f1)
  3042  		}
  3043  	}
  3044  }
  3045  
  3046  // Check that trigReduce matches the standard reduction results for input values
  3047  // below reduceThreshold.
  3048  func TestTrigReduce(t *testing.T) {
  3049  	inputs := make([]float64, len(vf))
  3050  	// all of the standard inputs
  3051  	copy(inputs, vf)
  3052  	// all of the large inputs
  3053  	large := float64(100000 * Pi)
  3054  	for _, v := range vf {
  3055  		inputs = append(inputs, v+large)
  3056  	}
  3057  	// Also test some special inputs, Pi and right below the reduceThreshold
  3058  	inputs = append(inputs, Pi, Nextafter(ReduceThreshold, 0))
  3059  	for _, x := range inputs {
  3060  		// reduce the value to compare
  3061  		j, z := TrigReduce(x)
  3062  		xred := float64(j)*(Pi/4) + z
  3063  
  3064  		if f, fred := Sin(x), Sin(xred); !close(f, fred) {
  3065  			t.Errorf("Sin(trigReduce(%g)) != Sin(%g), got %g, want %g", x, x, fred, f)
  3066  		}
  3067  		if f, fred := Cos(x), Cos(xred); !close(f, fred) {
  3068  			t.Errorf("Cos(trigReduce(%g)) != Cos(%g), got %g, want %g", x, x, fred, f)
  3069  		}
  3070  		if f, fred := Tan(x), Tan(xred); !close(f, fred) {
  3071  			t.Errorf(" Tan(trigReduce(%g)) != Tan(%g), got %g, want %g", x, x, fred, f)
  3072  		}
  3073  		f, g := Sincos(x)
  3074  		fred, gred := Sincos(xred)
  3075  		if !close(f, fred) || !close(g, gred) {
  3076  			t.Errorf(" Sincos(trigReduce(%g)) != Sincos(%g), got %g, %g, want %g, %g", x, x, fred, gred, f, g)
  3077  		}
  3078  	}
  3079  }
  3080  
  3081  // Check that math constants are accepted by compiler
  3082  // and have right value (assumes strconv.ParseFloat works).
  3083  // https://golang.org/issue/201
  3084  
  3085  type floatTest struct {
  3086  	val  interface{}
  3087  	name string
  3088  	str  string
  3089  }
  3090  
  3091  var floatTests = []floatTest{
  3092  	{float64(MaxFloat64), "MaxFloat64", "1.7976931348623157e+308"},
  3093  	{float64(SmallestNonzeroFloat64), "SmallestNonzeroFloat64", "5e-324"},
  3094  	{float32(MaxFloat32), "MaxFloat32", "3.4028235e+38"},
  3095  	{float32(SmallestNonzeroFloat32), "SmallestNonzeroFloat32", "1e-45"},
  3096  }
  3097  
  3098  func TestFloatMinMax(t *testing.T) {
  3099  	for _, tt := range floatTests {
  3100  		s := fmt.Sprint(tt.val)
  3101  		if s != tt.str {
  3102  			t.Errorf("Sprint(%v) = %s, want %s", tt.name, s, tt.str)
  3103  		}
  3104  	}
  3105  }
  3106  
  3107  // Benchmarks
  3108  
  3109  // Global exported variables are used to store the
  3110  // return values of functions measured in the benchmarks.
  3111  // Storing the results in these variables prevents the compiler
  3112  // from completely optimizing the benchmarked functions away.
  3113  var (
  3114  	GlobalI int
  3115  	GlobalB bool
  3116  	GlobalF float64
  3117  )
  3118  
  3119  func BenchmarkAcos(b *testing.B) {
  3120  	x := 0.0
  3121  	for i := 0; i < b.N; i++ {
  3122  		x = Acos(.5)
  3123  	}
  3124  	GlobalF = x
  3125  }
  3126  
  3127  func BenchmarkAcosh(b *testing.B) {
  3128  	x := 0.0
  3129  	for i := 0; i < b.N; i++ {
  3130  		x = Acosh(1.5)
  3131  	}
  3132  	GlobalF = x
  3133  }
  3134  
  3135  func BenchmarkAsin(b *testing.B) {
  3136  	x := 0.0
  3137  	for i := 0; i < b.N; i++ {
  3138  		x = Asin(.5)
  3139  	}
  3140  	GlobalF = x
  3141  }
  3142  
  3143  func BenchmarkAsinh(b *testing.B) {
  3144  	x := 0.0
  3145  	for i := 0; i < b.N; i++ {
  3146  		x = Asinh(.5)
  3147  	}
  3148  	GlobalF = x
  3149  }
  3150  
  3151  func BenchmarkAtan(b *testing.B) {
  3152  	x := 0.0
  3153  	for i := 0; i < b.N; i++ {
  3154  		x = Atan(.5)
  3155  	}
  3156  	GlobalF = x
  3157  }
  3158  
  3159  func BenchmarkAtanh(b *testing.B) {
  3160  	x := 0.0
  3161  	for i := 0; i < b.N; i++ {
  3162  		x = Atanh(.5)
  3163  	}
  3164  	GlobalF = x
  3165  }
  3166  
  3167  func BenchmarkAtan2(b *testing.B) {
  3168  	x := 0.0
  3169  	for i := 0; i < b.N; i++ {
  3170  		x = Atan2(.5, 1)
  3171  	}
  3172  	GlobalF = x
  3173  }
  3174  
  3175  func BenchmarkCbrt(b *testing.B) {
  3176  	x := 0.0
  3177  	for i := 0; i < b.N; i++ {
  3178  		x = Cbrt(10)
  3179  	}
  3180  	GlobalF = x
  3181  }
  3182  
  3183  func BenchmarkCeil(b *testing.B) {
  3184  	x := 0.0
  3185  	for i := 0; i < b.N; i++ {
  3186  		x = Ceil(.5)
  3187  	}
  3188  	GlobalF = x
  3189  }
  3190  
  3191  var copysignNeg = -1.0
  3192  
  3193  func BenchmarkCopysign(b *testing.B) {
  3194  	x := 0.0
  3195  	for i := 0; i < b.N; i++ {
  3196  		x = Copysign(.5, copysignNeg)
  3197  	}
  3198  	GlobalF = x
  3199  }
  3200  
  3201  func BenchmarkCos(b *testing.B) {
  3202  	x := 0.0
  3203  	for i := 0; i < b.N; i++ {
  3204  		x = Cos(.5)
  3205  	}
  3206  	GlobalF = x
  3207  }
  3208  
  3209  func BenchmarkCosh(b *testing.B) {
  3210  	x := 0.0
  3211  	for i := 0; i < b.N; i++ {
  3212  		x = Cosh(2.5)
  3213  	}
  3214  	GlobalF = x
  3215  }
  3216  
  3217  func BenchmarkErf(b *testing.B) {
  3218  	x := 0.0
  3219  	for i := 0; i < b.N; i++ {
  3220  		x = Erf(.5)
  3221  	}
  3222  	GlobalF = x
  3223  }
  3224  
  3225  func BenchmarkErfc(b *testing.B) {
  3226  	x := 0.0
  3227  	for i := 0; i < b.N; i++ {
  3228  		x = Erfc(.5)
  3229  	}
  3230  	GlobalF = x
  3231  }
  3232  
  3233  func BenchmarkErfinv(b *testing.B) {
  3234  	x := 0.0
  3235  	for i := 0; i < b.N; i++ {
  3236  		x = Erfinv(.5)
  3237  	}
  3238  	GlobalF = x
  3239  }
  3240  
  3241  func BenchmarkErfcinv(b *testing.B) {
  3242  	x := 0.0
  3243  	for i := 0; i < b.N; i++ {
  3244  		x = Erfcinv(.5)
  3245  	}
  3246  	GlobalF = x
  3247  }
  3248  
  3249  func BenchmarkExp(b *testing.B) {
  3250  	x := 0.0
  3251  	for i := 0; i < b.N; i++ {
  3252  		x = Exp(.5)
  3253  	}
  3254  	GlobalF = x
  3255  }
  3256  
  3257  func BenchmarkExpGo(b *testing.B) {
  3258  	x := 0.0
  3259  	for i := 0; i < b.N; i++ {
  3260  		x = ExpGo(.5)
  3261  	}
  3262  	GlobalF = x
  3263  }
  3264  
  3265  func BenchmarkExpm1(b *testing.B) {
  3266  	x := 0.0
  3267  	for i := 0; i < b.N; i++ {
  3268  		x = Expm1(.5)
  3269  	}
  3270  	GlobalF = x
  3271  }
  3272  
  3273  func BenchmarkExp2(b *testing.B) {
  3274  	x := 0.0
  3275  	for i := 0; i < b.N; i++ {
  3276  		x = Exp2(.5)
  3277  	}
  3278  	GlobalF = x
  3279  }
  3280  
  3281  func BenchmarkExp2Go(b *testing.B) {
  3282  	x := 0.0
  3283  	for i := 0; i < b.N; i++ {
  3284  		x = Exp2Go(.5)
  3285  	}
  3286  	GlobalF = x
  3287  }
  3288  
  3289  var absPos = .5
  3290  
  3291  func BenchmarkAbs(b *testing.B) {
  3292  	x := 0.0
  3293  	for i := 0; i < b.N; i++ {
  3294  		x = Abs(absPos)
  3295  	}
  3296  	GlobalF = x
  3297  
  3298  }
  3299  
  3300  func BenchmarkDim(b *testing.B) {
  3301  	x := 0.0
  3302  	for i := 0; i < b.N; i++ {
  3303  		x = Dim(GlobalF, x)
  3304  	}
  3305  	GlobalF = x
  3306  }
  3307  
  3308  func BenchmarkFloor(b *testing.B) {
  3309  	x := 0.0
  3310  	for i := 0; i < b.N; i++ {
  3311  		x = Floor(.5)
  3312  	}
  3313  	GlobalF = x
  3314  }
  3315  
  3316  func BenchmarkMax(b *testing.B) {
  3317  	x := 0.0
  3318  	for i := 0; i < b.N; i++ {
  3319  		x = Max(10, 3)
  3320  	}
  3321  	GlobalF = x
  3322  }
  3323  
  3324  func BenchmarkMin(b *testing.B) {
  3325  	x := 0.0
  3326  	for i := 0; i < b.N; i++ {
  3327  		x = Min(10, 3)
  3328  	}
  3329  	GlobalF = x
  3330  }
  3331  
  3332  func BenchmarkMod(b *testing.B) {
  3333  	x := 0.0
  3334  	for i := 0; i < b.N; i++ {
  3335  		x = Mod(10, 3)
  3336  	}
  3337  	GlobalF = x
  3338  }
  3339  
  3340  func BenchmarkFrexp(b *testing.B) {
  3341  	x := 0.0
  3342  	y := 0
  3343  	for i := 0; i < b.N; i++ {
  3344  		x, y = Frexp(8)
  3345  	}
  3346  	GlobalF = x
  3347  	GlobalI = y
  3348  }
  3349  
  3350  func BenchmarkGamma(b *testing.B) {
  3351  	x := 0.0
  3352  	for i := 0; i < b.N; i++ {
  3353  		x = Gamma(2.5)
  3354  	}
  3355  	GlobalF = x
  3356  }
  3357  
  3358  func BenchmarkHypot(b *testing.B) {
  3359  	x := 0.0
  3360  	for i := 0; i < b.N; i++ {
  3361  		x = Hypot(3, 4)
  3362  	}
  3363  	GlobalF = x
  3364  }
  3365  
  3366  func BenchmarkHypotGo(b *testing.B) {
  3367  	x := 0.0
  3368  	for i := 0; i < b.N; i++ {
  3369  		x = HypotGo(3, 4)
  3370  	}
  3371  	GlobalF = x
  3372  }
  3373  
  3374  func BenchmarkIlogb(b *testing.B) {
  3375  	x := 0
  3376  	for i := 0; i < b.N; i++ {
  3377  		x = Ilogb(.5)
  3378  	}
  3379  	GlobalI = x
  3380  }
  3381  
  3382  func BenchmarkJ0(b *testing.B) {
  3383  	x := 0.0
  3384  	for i := 0; i < b.N; i++ {
  3385  		x = J0(2.5)
  3386  	}
  3387  	GlobalF = x
  3388  }
  3389  
  3390  func BenchmarkJ1(b *testing.B) {
  3391  	x := 0.0
  3392  	for i := 0; i < b.N; i++ {
  3393  		x = J1(2.5)
  3394  	}
  3395  	GlobalF = x
  3396  }
  3397  
  3398  func BenchmarkJn(b *testing.B) {
  3399  	x := 0.0
  3400  	for i := 0; i < b.N; i++ {
  3401  		x = Jn(2, 2.5)
  3402  	}
  3403  	GlobalF = x
  3404  }
  3405  
  3406  func BenchmarkLdexp(b *testing.B) {
  3407  	x := 0.0
  3408  	for i := 0; i < b.N; i++ {
  3409  		x = Ldexp(.5, 2)
  3410  	}
  3411  	GlobalF = x
  3412  }
  3413  
  3414  func BenchmarkLgamma(b *testing.B) {
  3415  	x := 0.0
  3416  	y := 0
  3417  	for i := 0; i < b.N; i++ {
  3418  		x, y = Lgamma(2.5)
  3419  	}
  3420  	GlobalF = x
  3421  	GlobalI = y
  3422  }
  3423  
  3424  func BenchmarkLog(b *testing.B) {
  3425  	x := 0.0
  3426  	for i := 0; i < b.N; i++ {
  3427  		x = Log(.5)
  3428  	}
  3429  	GlobalF = x
  3430  }
  3431  
  3432  func BenchmarkLogb(b *testing.B) {
  3433  	x := 0.0
  3434  	for i := 0; i < b.N; i++ {
  3435  		x = Logb(.5)
  3436  	}
  3437  	GlobalF = x
  3438  }
  3439  
  3440  func BenchmarkLog1p(b *testing.B) {
  3441  	x := 0.0
  3442  	for i := 0; i < b.N; i++ {
  3443  		x = Log1p(.5)
  3444  	}
  3445  	GlobalF = x
  3446  }
  3447  
  3448  func BenchmarkLog10(b *testing.B) {
  3449  	x := 0.0
  3450  	for i := 0; i < b.N; i++ {
  3451  		x = Log10(.5)
  3452  	}
  3453  	GlobalF = x
  3454  }
  3455  
  3456  func BenchmarkLog2(b *testing.B) {
  3457  	x := 0.0
  3458  	for i := 0; i < b.N; i++ {
  3459  		x = Log2(.5)
  3460  	}
  3461  	GlobalF += x
  3462  }
  3463  
  3464  func BenchmarkModf(b *testing.B) {
  3465  	x := 0.0
  3466  	y := 0.0
  3467  	for i := 0; i < b.N; i++ {
  3468  		x, y = Modf(1.5)
  3469  	}
  3470  	GlobalF += x
  3471  	GlobalF += y
  3472  }
  3473  
  3474  func BenchmarkNextafter32(b *testing.B) {
  3475  	x := float32(0.0)
  3476  	for i := 0; i < b.N; i++ {
  3477  		x = Nextafter32(.5, 1)
  3478  	}
  3479  	GlobalF = float64(x)
  3480  }
  3481  
  3482  func BenchmarkNextafter64(b *testing.B) {
  3483  	x := 0.0
  3484  	for i := 0; i < b.N; i++ {
  3485  		x = Nextafter(.5, 1)
  3486  	}
  3487  	GlobalF = x
  3488  }
  3489  
  3490  func BenchmarkPowInt(b *testing.B) {
  3491  	x := 0.0
  3492  	for i := 0; i < b.N; i++ {
  3493  		x = Pow(2, 2)
  3494  	}
  3495  	GlobalF = x
  3496  }
  3497  
  3498  func BenchmarkPowFrac(b *testing.B) {
  3499  	x := 0.0
  3500  	for i := 0; i < b.N; i++ {
  3501  		x = Pow(2.5, 1.5)
  3502  	}
  3503  	GlobalF = x
  3504  }
  3505  
  3506  var pow10pos = int(300)
  3507  
  3508  func BenchmarkPow10Pos(b *testing.B) {
  3509  	x := 0.0
  3510  	for i := 0; i < b.N; i++ {
  3511  		x = Pow10(pow10pos)
  3512  	}
  3513  	GlobalF = x
  3514  }
  3515  
  3516  var pow10neg = int(-300)
  3517  
  3518  func BenchmarkPow10Neg(b *testing.B) {
  3519  	x := 0.0
  3520  	for i := 0; i < b.N; i++ {
  3521  		x = Pow10(pow10neg)
  3522  	}
  3523  	GlobalF = x
  3524  }
  3525  
  3526  var roundNeg = float64(-2.5)
  3527  
  3528  func BenchmarkRound(b *testing.B) {
  3529  	x := 0.0
  3530  	for i := 0; i < b.N; i++ {
  3531  		x = Round(roundNeg)
  3532  	}
  3533  	GlobalF = x
  3534  }
  3535  
  3536  func BenchmarkRoundToEven(b *testing.B) {
  3537  	x := 0.0
  3538  	for i := 0; i < b.N; i++ {
  3539  		x = RoundToEven(roundNeg)
  3540  	}
  3541  	GlobalF = x
  3542  }
  3543  
  3544  func BenchmarkRemainder(b *testing.B) {
  3545  	x := 0.0
  3546  	for i := 0; i < b.N; i++ {
  3547  		x = Remainder(10, 3)
  3548  	}
  3549  	GlobalF = x
  3550  }
  3551  
  3552  var signbitPos = 2.5
  3553  
  3554  func BenchmarkSignbit(b *testing.B) {
  3555  	x := false
  3556  	for i := 0; i < b.N; i++ {
  3557  		x = Signbit(signbitPos)
  3558  	}
  3559  	GlobalB = x
  3560  }
  3561  
  3562  func BenchmarkSin(b *testing.B) {
  3563  	x := 0.0
  3564  	for i := 0; i < b.N; i++ {
  3565  		x = Sin(.5)
  3566  	}
  3567  	GlobalF = x
  3568  }
  3569  
  3570  func BenchmarkSincos(b *testing.B) {
  3571  	x := 0.0
  3572  	y := 0.0
  3573  	for i := 0; i < b.N; i++ {
  3574  		x, y = Sincos(.5)
  3575  	}
  3576  	GlobalF += x
  3577  	GlobalF += y
  3578  }
  3579  
  3580  func BenchmarkSinh(b *testing.B) {
  3581  	x := 0.0
  3582  	for i := 0; i < b.N; i++ {
  3583  		x = Sinh(2.5)
  3584  	}
  3585  	GlobalF = x
  3586  }
  3587  
  3588  func BenchmarkSqrtIndirect(b *testing.B) {
  3589  	x, y := 0.0, 10.0
  3590  	f := Sqrt
  3591  	for i := 0; i < b.N; i++ {
  3592  		x += f(y)
  3593  	}
  3594  	GlobalF = x
  3595  }
  3596  
  3597  func BenchmarkSqrtLatency(b *testing.B) {
  3598  	x := 10.0
  3599  	for i := 0; i < b.N; i++ {
  3600  		x = Sqrt(x)
  3601  	}
  3602  	GlobalF = x
  3603  }
  3604  
  3605  func BenchmarkSqrtIndirectLatency(b *testing.B) {
  3606  	x := 10.0
  3607  	f := Sqrt
  3608  	for i := 0; i < b.N; i++ {
  3609  		x = f(x)
  3610  	}
  3611  	GlobalF = x
  3612  }
  3613  
  3614  func BenchmarkSqrtGoLatency(b *testing.B) {
  3615  	x := 10.0
  3616  	for i := 0; i < b.N; i++ {
  3617  		x = SqrtGo(x)
  3618  	}
  3619  	GlobalF = x
  3620  }
  3621  
  3622  func isPrime(i int) bool {
  3623  	// Yes, this is a dumb way to write this code,
  3624  	// but calling Sqrt repeatedly in this way demonstrates
  3625  	// the benefit of using a direct SQRT instruction on systems
  3626  	// that have one, whereas the obvious loop seems not to
  3627  	// demonstrate such a benefit.
  3628  	for j := 2; float64(j) <= Sqrt(float64(i)); j++ {
  3629  		if i%j == 0 {
  3630  			return false
  3631  		}
  3632  	}
  3633  	return true
  3634  }
  3635  
  3636  func BenchmarkSqrtPrime(b *testing.B) {
  3637  	x := false
  3638  	for i := 0; i < b.N; i++ {
  3639  		x = isPrime(100003)
  3640  	}
  3641  	GlobalB = x
  3642  }
  3643  
  3644  func BenchmarkTan(b *testing.B) {
  3645  	x := 0.0
  3646  	for i := 0; i < b.N; i++ {
  3647  		x = Tan(.5)
  3648  	}
  3649  	GlobalF = x
  3650  }
  3651  
  3652  func BenchmarkTanh(b *testing.B) {
  3653  	x := 0.0
  3654  	for i := 0; i < b.N; i++ {
  3655  		x = Tanh(2.5)
  3656  	}
  3657  	GlobalF = x
  3658  }
  3659  func BenchmarkTrunc(b *testing.B) {
  3660  	x := 0.0
  3661  	for i := 0; i < b.N; i++ {
  3662  		x = Trunc(.5)
  3663  	}
  3664  	GlobalF = x
  3665  }
  3666  
  3667  func BenchmarkY0(b *testing.B) {
  3668  	x := 0.0
  3669  	for i := 0; i < b.N; i++ {
  3670  		x = Y0(2.5)
  3671  	}
  3672  	GlobalF = x
  3673  }
  3674  
  3675  func BenchmarkY1(b *testing.B) {
  3676  	x := 0.0
  3677  	for i := 0; i < b.N; i++ {
  3678  		x = Y1(2.5)
  3679  	}
  3680  	GlobalF = x
  3681  }
  3682  
  3683  func BenchmarkYn(b *testing.B) {
  3684  	x := 0.0
  3685  	for i := 0; i < b.N; i++ {
  3686  		x = Yn(2, 2.5)
  3687  	}
  3688  	GlobalF = x
  3689  }
  3690  
  3691  func BenchmarkFloat64bits(b *testing.B) {
  3692  	y := uint64(0)
  3693  	for i := 0; i < b.N; i++ {
  3694  		y = Float64bits(roundNeg)
  3695  	}
  3696  	GlobalI = int(y)
  3697  }
  3698  
  3699  var roundUint64 = uint64(5)
  3700  
  3701  func BenchmarkFloat64frombits(b *testing.B) {
  3702  	x := 0.0
  3703  	for i := 0; i < b.N; i++ {
  3704  		x = Float64frombits(roundUint64)
  3705  	}
  3706  	GlobalF = x
  3707  }
  3708  
  3709  var roundFloat32 = float32(-2.5)
  3710  
  3711  func BenchmarkFloat32bits(b *testing.B) {
  3712  	y := uint32(0)
  3713  	for i := 0; i < b.N; i++ {
  3714  		y = Float32bits(roundFloat32)
  3715  	}
  3716  	GlobalI = int(y)
  3717  }
  3718  
  3719  var roundUint32 = uint32(5)
  3720  
  3721  func BenchmarkFloat32frombits(b *testing.B) {
  3722  	x := float32(0.0)
  3723  	for i := 0; i < b.N; i++ {
  3724  		x = Float32frombits(roundUint32)
  3725  	}
  3726  	GlobalF = float64(x)
  3727  }
  3728  

View as plain text