...

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  	{1.0, Inf(1)},
   831  	{-1.0, Inf(1)},
   832  	{+Pi, NaN()},
   833  	{Inf(1), Inf(-1)},
   834  	{Inf(1), -Pi},
   835  	{Inf(1), 0},
   836  	{Inf(1), +Pi},
   837  	{Inf(1), Inf(1)},
   838  	{Inf(1), NaN()},
   839  	{NaN(), NaN()},
   840  }
   841  var atan2SC = []float64{
   842  	-3 * Pi / 4,     // atan2(-Inf, -Inf)
   843  	-Pi / 2,         // atan2(-Inf, -Pi)
   844  	-Pi / 2,         // atan2(-Inf, +0)
   845  	-Pi / 2,         // atan2(-Inf, +Pi)
   846  	-Pi / 4,         // atan2(-Inf, +Inf)
   847  	NaN(),           // atan2(-Inf, NaN)
   848  	-Pi,             // atan2(-Pi, -Inf)
   849  	-Pi / 2,         // atan2(-Pi, +0)
   850  	Copysign(0, -1), // atan2(-Pi, Inf)
   851  	NaN(),           // atan2(-Pi, NaN)
   852  	-Pi,             // atan2(-0, -Inf)
   853  	-Pi,             // atan2(-0, -Pi)
   854  	-Pi,             // atan2(-0, -0)
   855  	Copysign(0, -1), // atan2(-0, +0)
   856  	Copysign(0, -1), // atan2(-0, +Pi)
   857  	Copysign(0, -1), // atan2(-0, +Inf)
   858  	NaN(),           // atan2(-0, NaN)
   859  	Pi,              // atan2(+0, -Inf)
   860  	Pi,              // atan2(+0, -Pi)
   861  	Pi,              // atan2(+0, -0)
   862  	0,               // atan2(+0, +0)
   863  	0,               // atan2(+0, +Pi)
   864  	0,               // atan2(+0, +Inf)
   865  	NaN(),           // atan2(+0, NaN)
   866  	Pi,              // atan2(+Pi, -Inf)
   867  	Pi / 2,          // atan2(+Pi, +0)
   868  	0,               // atan2(+Pi, +Inf)
   869  	0,               // atan2(+1, +Inf)
   870  	Copysign(0, -1), // atan2(-1, +Inf)
   871  	NaN(),           // atan2(+Pi, NaN)
   872  	3 * Pi / 4,      // atan2(+Inf, -Inf)
   873  	Pi / 2,          // atan2(+Inf, -Pi)
   874  	Pi / 2,          // atan2(+Inf, +0)
   875  	Pi / 2,          // atan2(+Inf, +Pi)
   876  	Pi / 4,          // atan2(+Inf, +Inf)
   877  	NaN(),           // atan2(+Inf, NaN)
   878  	NaN(),           // atan2(NaN, NaN)
   879  }
   880  
   881  var vfcbrtSC = []float64{
   882  	Inf(-1),
   883  	Copysign(0, -1),
   884  	0,
   885  	Inf(1),
   886  	NaN(),
   887  }
   888  var cbrtSC = []float64{
   889  	Inf(-1),
   890  	Copysign(0, -1),
   891  	0,
   892  	Inf(1),
   893  	NaN(),
   894  }
   895  
   896  var vfceilSC = []float64{
   897  	Inf(-1),
   898  	Copysign(0, -1),
   899  	0,
   900  	Inf(1),
   901  	NaN(),
   902  }
   903  var ceilSC = []float64{
   904  	Inf(-1),
   905  	Copysign(0, -1),
   906  	0,
   907  	Inf(1),
   908  	NaN(),
   909  }
   910  
   911  var vfcopysignSC = []float64{
   912  	Inf(-1),
   913  	Inf(1),
   914  	NaN(),
   915  }
   916  var copysignSC = []float64{
   917  	Inf(-1),
   918  	Inf(-1),
   919  	NaN(),
   920  }
   921  
   922  var vfcosSC = []float64{
   923  	Inf(-1),
   924  	Inf(1),
   925  	NaN(),
   926  }
   927  var cosSC = []float64{
   928  	NaN(),
   929  	NaN(),
   930  	NaN(),
   931  }
   932  
   933  var vfcoshSC = []float64{
   934  	Inf(-1),
   935  	Copysign(0, -1),
   936  	0,
   937  	Inf(1),
   938  	NaN(),
   939  }
   940  var coshSC = []float64{
   941  	Inf(1),
   942  	1,
   943  	1,
   944  	Inf(1),
   945  	NaN(),
   946  }
   947  
   948  var vferfSC = []float64{
   949  	Inf(-1),
   950  	Copysign(0, -1),
   951  	0,
   952  	Inf(1),
   953  	NaN(),
   954  	-1000,
   955  	1000,
   956  }
   957  var erfSC = []float64{
   958  	-1,
   959  	Copysign(0, -1),
   960  	0,
   961  	1,
   962  	NaN(),
   963  	-1,
   964  	1,
   965  }
   966  
   967  var vferfcSC = []float64{
   968  	Inf(-1),
   969  	Inf(1),
   970  	NaN(),
   971  	-1000,
   972  	1000,
   973  }
   974  var erfcSC = []float64{
   975  	2,
   976  	0,
   977  	NaN(),
   978  	2,
   979  	0,
   980  }
   981  
   982  var vferfinvSC = []float64{
   983  	1,
   984  	-1,
   985  	0,
   986  	Inf(-1),
   987  	Inf(1),
   988  	NaN(),
   989  }
   990  var erfinvSC = []float64{
   991  	Inf(+1),
   992  	Inf(-1),
   993  	0,
   994  	NaN(),
   995  	NaN(),
   996  	NaN(),
   997  }
   998  
   999  var vferfcinvSC = []float64{
  1000  	0,
  1001  	2,
  1002  	1,
  1003  	Inf(1),
  1004  	Inf(-1),
  1005  	NaN(),
  1006  }
  1007  var erfcinvSC = []float64{
  1008  	Inf(+1),
  1009  	Inf(-1),
  1010  	0,
  1011  	NaN(),
  1012  	NaN(),
  1013  	NaN(),
  1014  }
  1015  
  1016  var vfexpSC = []float64{
  1017  	Inf(-1),
  1018  	-2000,
  1019  	2000,
  1020  	Inf(1),
  1021  	NaN(),
  1022  	// smallest float64 that overflows Exp(x)
  1023  	7.097827128933841e+02,
  1024  	// Issue 18912
  1025  	1.48852223e+09,
  1026  	1.4885222e+09,
  1027  	1,
  1028  	// near zero
  1029  	3.725290298461915e-09,
  1030  	// denormal
  1031  	-740,
  1032  }
  1033  var expSC = []float64{
  1034  	0,
  1035  	0,
  1036  	Inf(1),
  1037  	Inf(1),
  1038  	NaN(),
  1039  	Inf(1),
  1040  	Inf(1),
  1041  	Inf(1),
  1042  	2.718281828459045,
  1043  	1.0000000037252903,
  1044  	4.2e-322,
  1045  }
  1046  
  1047  var vfexp2SC = []float64{
  1048  	Inf(-1),
  1049  	-2000,
  1050  	2000,
  1051  	Inf(1),
  1052  	NaN(),
  1053  	// smallest float64 that overflows Exp2(x)
  1054  	1024,
  1055  	// near underflow
  1056  	-1.07399999999999e+03,
  1057  	// near zero
  1058  	3.725290298461915e-09,
  1059  }
  1060  var exp2SC = []float64{
  1061  	0,
  1062  	0,
  1063  	Inf(1),
  1064  	Inf(1),
  1065  	NaN(),
  1066  	Inf(1),
  1067  	5e-324,
  1068  	1.0000000025821745,
  1069  }
  1070  
  1071  var vfexpm1SC = []float64{
  1072  	Inf(-1),
  1073  	-710,
  1074  	Copysign(0, -1),
  1075  	0,
  1076  	710,
  1077  	Inf(1),
  1078  	NaN(),
  1079  }
  1080  var expm1SC = []float64{
  1081  	-1,
  1082  	-1,
  1083  	Copysign(0, -1),
  1084  	0,
  1085  	Inf(1),
  1086  	Inf(1),
  1087  	NaN(),
  1088  }
  1089  
  1090  var vffabsSC = []float64{
  1091  	Inf(-1),
  1092  	Copysign(0, -1),
  1093  	0,
  1094  	Inf(1),
  1095  	NaN(),
  1096  }
  1097  var fabsSC = []float64{
  1098  	Inf(1),
  1099  	0,
  1100  	0,
  1101  	Inf(1),
  1102  	NaN(),
  1103  }
  1104  
  1105  var vffdimSC = [][2]float64{
  1106  	{Inf(-1), Inf(-1)},
  1107  	{Inf(-1), Inf(1)},
  1108  	{Inf(-1), NaN()},
  1109  	{Copysign(0, -1), Copysign(0, -1)},
  1110  	{Copysign(0, -1), 0},
  1111  	{0, Copysign(0, -1)},
  1112  	{0, 0},
  1113  	{Inf(1), Inf(-1)},
  1114  	{Inf(1), Inf(1)},
  1115  	{Inf(1), NaN()},
  1116  	{NaN(), Inf(-1)},
  1117  	{NaN(), Copysign(0, -1)},
  1118  	{NaN(), 0},
  1119  	{NaN(), Inf(1)},
  1120  	{NaN(), NaN()},
  1121  }
  1122  var nan = Float64frombits(0xFFF8000000000000) // SSE2 DIVSD 0/0
  1123  var vffdim2SC = [][2]float64{
  1124  	{Inf(-1), Inf(-1)},
  1125  	{Inf(-1), Inf(1)},
  1126  	{Inf(-1), nan},
  1127  	{Copysign(0, -1), Copysign(0, -1)},
  1128  	{Copysign(0, -1), 0},
  1129  	{0, Copysign(0, -1)},
  1130  	{0, 0},
  1131  	{Inf(1), Inf(-1)},
  1132  	{Inf(1), Inf(1)},
  1133  	{Inf(1), nan},
  1134  	{nan, Inf(-1)},
  1135  	{nan, Copysign(0, -1)},
  1136  	{nan, 0},
  1137  	{nan, Inf(1)},
  1138  	{nan, nan},
  1139  }
  1140  var fdimSC = []float64{
  1141  	NaN(),
  1142  	0,
  1143  	NaN(),
  1144  	0,
  1145  	0,
  1146  	0,
  1147  	0,
  1148  	Inf(1),
  1149  	NaN(),
  1150  	NaN(),
  1151  	NaN(),
  1152  	NaN(),
  1153  	NaN(),
  1154  	NaN(),
  1155  	NaN(),
  1156  }
  1157  var fmaxSC = []float64{
  1158  	Inf(-1),
  1159  	Inf(1),
  1160  	NaN(),
  1161  	Copysign(0, -1),
  1162  	0,
  1163  	0,
  1164  	0,
  1165  	Inf(1),
  1166  	Inf(1),
  1167  	Inf(1),
  1168  	NaN(),
  1169  	NaN(),
  1170  	NaN(),
  1171  	Inf(1),
  1172  	NaN(),
  1173  }
  1174  var fminSC = []float64{
  1175  	Inf(-1),
  1176  	Inf(-1),
  1177  	Inf(-1),
  1178  	Copysign(0, -1),
  1179  	Copysign(0, -1),
  1180  	Copysign(0, -1),
  1181  	0,
  1182  	Inf(-1),
  1183  	Inf(1),
  1184  	NaN(),
  1185  	Inf(-1),
  1186  	NaN(),
  1187  	NaN(),
  1188  	NaN(),
  1189  	NaN(),
  1190  }
  1191  
  1192  var vffmodSC = [][2]float64{
  1193  	{Inf(-1), Inf(-1)},
  1194  	{Inf(-1), -Pi},
  1195  	{Inf(-1), 0},
  1196  	{Inf(-1), Pi},
  1197  	{Inf(-1), Inf(1)},
  1198  	{Inf(-1), NaN()},
  1199  	{-Pi, Inf(-1)},
  1200  	{-Pi, 0},
  1201  	{-Pi, Inf(1)},
  1202  	{-Pi, NaN()},
  1203  	{Copysign(0, -1), Inf(-1)},
  1204  	{Copysign(0, -1), 0},
  1205  	{Copysign(0, -1), Inf(1)},
  1206  	{Copysign(0, -1), NaN()},
  1207  	{0, Inf(-1)},
  1208  	{0, 0},
  1209  	{0, Inf(1)},
  1210  	{0, NaN()},
  1211  	{Pi, Inf(-1)},
  1212  	{Pi, 0},
  1213  	{Pi, Inf(1)},
  1214  	{Pi, NaN()},
  1215  	{Inf(1), Inf(-1)},
  1216  	{Inf(1), -Pi},
  1217  	{Inf(1), 0},
  1218  	{Inf(1), Pi},
  1219  	{Inf(1), Inf(1)},
  1220  	{Inf(1), NaN()},
  1221  	{NaN(), Inf(-1)},
  1222  	{NaN(), -Pi},
  1223  	{NaN(), 0},
  1224  	{NaN(), Pi},
  1225  	{NaN(), Inf(1)},
  1226  	{NaN(), NaN()},
  1227  }
  1228  var fmodSC = []float64{
  1229  	NaN(),           // fmod(-Inf, -Inf)
  1230  	NaN(),           // fmod(-Inf, -Pi)
  1231  	NaN(),           // fmod(-Inf, 0)
  1232  	NaN(),           // fmod(-Inf, Pi)
  1233  	NaN(),           // fmod(-Inf, +Inf)
  1234  	NaN(),           // fmod(-Inf, NaN)
  1235  	-Pi,             // fmod(-Pi, -Inf)
  1236  	NaN(),           // fmod(-Pi, 0)
  1237  	-Pi,             // fmod(-Pi, +Inf)
  1238  	NaN(),           // fmod(-Pi, NaN)
  1239  	Copysign(0, -1), // fmod(-0, -Inf)
  1240  	NaN(),           // fmod(-0, 0)
  1241  	Copysign(0, -1), // fmod(-0, Inf)
  1242  	NaN(),           // fmod(-0, NaN)
  1243  	0,               // fmod(0, -Inf)
  1244  	NaN(),           // fmod(0, 0)
  1245  	0,               // fmod(0, +Inf)
  1246  	NaN(),           // fmod(0, NaN)
  1247  	Pi,              // fmod(Pi, -Inf)
  1248  	NaN(),           // fmod(Pi, 0)
  1249  	Pi,              // fmod(Pi, +Inf)
  1250  	NaN(),           // fmod(Pi, NaN)
  1251  	NaN(),           // fmod(+Inf, -Inf)
  1252  	NaN(),           // fmod(+Inf, -Pi)
  1253  	NaN(),           // fmod(+Inf, 0)
  1254  	NaN(),           // fmod(+Inf, Pi)
  1255  	NaN(),           // fmod(+Inf, +Inf)
  1256  	NaN(),           // fmod(+Inf, NaN)
  1257  	NaN(),           // fmod(NaN, -Inf)
  1258  	NaN(),           // fmod(NaN, -Pi)
  1259  	NaN(),           // fmod(NaN, 0)
  1260  	NaN(),           // fmod(NaN, Pi)
  1261  	NaN(),           // fmod(NaN, +Inf)
  1262  	NaN(),           // fmod(NaN, NaN)
  1263  }
  1264  
  1265  var vffrexpSC = []float64{
  1266  	Inf(-1),
  1267  	Copysign(0, -1),
  1268  	0,
  1269  	Inf(1),
  1270  	NaN(),
  1271  }
  1272  var frexpSC = []fi{
  1273  	{Inf(-1), 0},
  1274  	{Copysign(0, -1), 0},
  1275  	{0, 0},
  1276  	{Inf(1), 0},
  1277  	{NaN(), 0},
  1278  }
  1279  
  1280  var vfgamma = [][2]float64{
  1281  	{Inf(1), Inf(1)},
  1282  	{Inf(-1), NaN()},
  1283  	{0, Inf(1)},
  1284  	{Copysign(0, -1), Inf(-1)},
  1285  	{NaN(), NaN()},
  1286  	{-1, NaN()},
  1287  	{-2, NaN()},
  1288  	{-3, NaN()},
  1289  	{-1e16, NaN()},
  1290  	{-1e300, NaN()},
  1291  	{1.7e308, Inf(1)},
  1292  
  1293  	// Test inputs inspired by Python test suite.
  1294  	// Outputs computed at high precision by PARI/GP.
  1295  	// If recomputing table entries, be careful to use
  1296  	// high-precision (%.1000g) formatting of the float64 inputs.
  1297  	// For example, -2.0000000000000004 is the float64 with exact value
  1298  	// -2.00000000000000044408920985626161695, and
  1299  	// gamma(-2.0000000000000004) = -1249999999999999.5386078562728167651513, while
  1300  	// gamma(-2.00000000000000044408920985626161695) = -1125899906826907.2044875028130093136826.
  1301  	// Thus the table lists -1.1258999068426235e+15 as the answer.
  1302  	{0.5, 1.772453850905516},
  1303  	{1.5, 0.886226925452758},
  1304  	{2.5, 1.329340388179137},
  1305  	{3.5, 3.3233509704478426},
  1306  	{-0.5, -3.544907701811032},
  1307  	{-1.5, 2.363271801207355},
  1308  	{-2.5, -0.9453087204829419},
  1309  	{-3.5, 0.2700882058522691},
  1310  	{0.1, 9.51350769866873},
  1311  	{0.01, 99.4325851191506},
  1312  	{1e-08, 9.999999942278434e+07},
  1313  	{1e-16, 1e+16},
  1314  	{0.001, 999.4237724845955},
  1315  	{1e-16, 1e+16},
  1316  	{1e-308, 1e+308},
  1317  	{5.6e-309, 1.7857142857142864e+308},
  1318  	{5.5e-309, Inf(1)},
  1319  	{1e-309, Inf(1)},
  1320  	{1e-323, Inf(1)},
  1321  	{5e-324, Inf(1)},
  1322  	{-0.1, -10.686287021193193},
  1323  	{-0.01, -100.58719796441078},
  1324  	{-1e-08, -1.0000000057721567e+08},
  1325  	{-1e-16, -1e+16},
  1326  	{-0.001, -1000.5782056293586},
  1327  	{-1e-16, -1e+16},
  1328  	{-1e-308, -1e+308},
  1329  	{-5.6e-309, -1.7857142857142864e+308},
  1330  	{-5.5e-309, Inf(-1)},
  1331  	{-1e-309, Inf(-1)},
  1332  	{-1e-323, Inf(-1)},
  1333  	{-5e-324, Inf(-1)},
  1334  	{-0.9999999999999999, -9.007199254740992e+15},
  1335  	{-1.0000000000000002, 4.5035996273704955e+15},
  1336  	{-1.9999999999999998, 2.2517998136852485e+15},
  1337  	{-2.0000000000000004, -1.1258999068426235e+15},
  1338  	{-100.00000000000001, -7.540083334883109e-145},
  1339  	{-99.99999999999999, 7.540083334884096e-145},
  1340  	{17, 2.0922789888e+13},
  1341  	{171, 7.257415615307999e+306},
  1342  	{171.6, 1.5858969096672565e+308},
  1343  	{171.624, 1.7942117599248104e+308},
  1344  	{171.625, Inf(1)},
  1345  	{172, Inf(1)},
  1346  	{2000, Inf(1)},
  1347  	{-100.5, -3.3536908198076787e-159},
  1348  	{-160.5, -5.255546447007829e-286},
  1349  	{-170.5, -3.3127395215386074e-308},
  1350  	{-171.5, 1.9316265431712e-310},
  1351  	{-176.5, -1.196e-321},
  1352  	{-177.5, 5e-324},
  1353  	{-178.5, Copysign(0, -1)},
  1354  	{-179.5, 0},
  1355  	{-201.0001, 0},
  1356  	{-202.9999, Copysign(0, -1)},
  1357  	{-1000.5, Copysign(0, -1)},
  1358  	{-1.0000000003e+09, Copysign(0, -1)},
  1359  	{-4.5035996273704955e+15, 0},
  1360  	{-63.349078729022985, 4.177797167776188e-88},
  1361  	{-127.45117632943295, 1.183111089623681e-214},
  1362  }
  1363  
  1364  var vfhypotSC = [][2]float64{
  1365  	{Inf(-1), Inf(-1)},
  1366  	{Inf(-1), 0},
  1367  	{Inf(-1), Inf(1)},
  1368  	{Inf(-1), NaN()},
  1369  	{Copysign(0, -1), Copysign(0, -1)},
  1370  	{Copysign(0, -1), 0},
  1371  	{0, Copysign(0, -1)},
  1372  	{0, 0}, // +0, +0
  1373  	{0, Inf(-1)},
  1374  	{0, Inf(1)},
  1375  	{0, NaN()},
  1376  	{Inf(1), Inf(-1)},
  1377  	{Inf(1), 0},
  1378  	{Inf(1), Inf(1)},
  1379  	{Inf(1), NaN()},
  1380  	{NaN(), Inf(-1)},
  1381  	{NaN(), 0},
  1382  	{NaN(), Inf(1)},
  1383  	{NaN(), NaN()},
  1384  }
  1385  var hypotSC = []float64{
  1386  	Inf(1),
  1387  	Inf(1),
  1388  	Inf(1),
  1389  	Inf(1),
  1390  	0,
  1391  	0,
  1392  	0,
  1393  	0,
  1394  	Inf(1),
  1395  	Inf(1),
  1396  	NaN(),
  1397  	Inf(1),
  1398  	Inf(1),
  1399  	Inf(1),
  1400  	Inf(1),
  1401  	Inf(1),
  1402  	NaN(),
  1403  	Inf(1),
  1404  	NaN(),
  1405  }
  1406  
  1407  var ilogbSC = []int{
  1408  	MaxInt32,
  1409  	MinInt32,
  1410  	MaxInt32,
  1411  	MaxInt32,
  1412  }
  1413  
  1414  var vfj0SC = []float64{
  1415  	Inf(-1),
  1416  	0,
  1417  	Inf(1),
  1418  	NaN(),
  1419  }
  1420  var j0SC = []float64{
  1421  	0,
  1422  	1,
  1423  	0,
  1424  	NaN(),
  1425  }
  1426  var j1SC = []float64{
  1427  	0,
  1428  	0,
  1429  	0,
  1430  	NaN(),
  1431  }
  1432  var j2SC = []float64{
  1433  	0,
  1434  	0,
  1435  	0,
  1436  	NaN(),
  1437  }
  1438  var jM3SC = []float64{
  1439  	0,
  1440  	0,
  1441  	0,
  1442  	NaN(),
  1443  }
  1444  
  1445  var vfldexpSC = []fi{
  1446  	{0, 0},
  1447  	{0, -1075},
  1448  	{0, 1024},
  1449  	{Copysign(0, -1), 0},
  1450  	{Copysign(0, -1), -1075},
  1451  	{Copysign(0, -1), 1024},
  1452  	{Inf(1), 0},
  1453  	{Inf(1), -1024},
  1454  	{Inf(-1), 0},
  1455  	{Inf(-1), -1024},
  1456  	{NaN(), -1024},
  1457  	{10, int(1) << (uint64(unsafe.Sizeof(0)-1) * 8)},
  1458  	{10, -(int(1) << (uint64(unsafe.Sizeof(0)-1) * 8))},
  1459  }
  1460  var ldexpSC = []float64{
  1461  	0,
  1462  	0,
  1463  	0,
  1464  	Copysign(0, -1),
  1465  	Copysign(0, -1),
  1466  	Copysign(0, -1),
  1467  	Inf(1),
  1468  	Inf(1),
  1469  	Inf(-1),
  1470  	Inf(-1),
  1471  	NaN(),
  1472  	Inf(1),
  1473  	0,
  1474  }
  1475  
  1476  var vflgammaSC = []float64{
  1477  	Inf(-1),
  1478  	-3,
  1479  	0,
  1480  	1,
  1481  	2,
  1482  	Inf(1),
  1483  	NaN(),
  1484  }
  1485  var lgammaSC = []fi{
  1486  	{Inf(-1), 1},
  1487  	{Inf(1), 1},
  1488  	{Inf(1), 1},
  1489  	{0, 1},
  1490  	{0, 1},
  1491  	{Inf(1), 1},
  1492  	{NaN(), 1},
  1493  }
  1494  
  1495  var vflogSC = []float64{
  1496  	Inf(-1),
  1497  	-Pi,
  1498  	Copysign(0, -1),
  1499  	0,
  1500  	1,
  1501  	Inf(1),
  1502  	NaN(),
  1503  }
  1504  var logSC = []float64{
  1505  	NaN(),
  1506  	NaN(),
  1507  	Inf(-1),
  1508  	Inf(-1),
  1509  	0,
  1510  	Inf(1),
  1511  	NaN(),
  1512  }
  1513  
  1514  var vflogbSC = []float64{
  1515  	Inf(-1),
  1516  	0,
  1517  	Inf(1),
  1518  	NaN(),
  1519  }
  1520  var logbSC = []float64{
  1521  	Inf(1),
  1522  	Inf(-1),
  1523  	Inf(1),
  1524  	NaN(),
  1525  }
  1526  
  1527  var vflog1pSC = []float64{
  1528  	Inf(-1),
  1529  	-Pi,
  1530  	-1,
  1531  	Copysign(0, -1),
  1532  	0,
  1533  	Inf(1),
  1534  	NaN(),
  1535  	4503599627370496.5, // Issue #29488
  1536  }
  1537  var log1pSC = []float64{
  1538  	NaN(),
  1539  	NaN(),
  1540  	Inf(-1),
  1541  	Copysign(0, -1),
  1542  	0,
  1543  	Inf(1),
  1544  	NaN(),
  1545  	36.04365338911715, // Issue #29488
  1546  }
  1547  
  1548  var vfmodfSC = []float64{
  1549  	Inf(-1),
  1550  	Copysign(0, -1),
  1551  	Inf(1),
  1552  	NaN(),
  1553  }
  1554  var modfSC = [][2]float64{
  1555  	{Inf(-1), NaN()}, // [2]float64{Copysign(0, -1), Inf(-1)},
  1556  	{Copysign(0, -1), Copysign(0, -1)},
  1557  	{Inf(1), NaN()}, // [2]float64{0, Inf(1)},
  1558  	{NaN(), NaN()},
  1559  }
  1560  
  1561  var vfnextafter32SC = [][2]float32{
  1562  	{0, 0},
  1563  	{0, float32(Copysign(0, -1))},
  1564  	{0, -1},
  1565  	{0, float32(NaN())},
  1566  	{float32(Copysign(0, -1)), 1},
  1567  	{float32(Copysign(0, -1)), 0},
  1568  	{float32(Copysign(0, -1)), float32(Copysign(0, -1))},
  1569  	{float32(Copysign(0, -1)), -1},
  1570  	{float32(NaN()), 0},
  1571  	{float32(NaN()), float32(NaN())},
  1572  }
  1573  var nextafter32SC = []float32{
  1574  	0,
  1575  	0,
  1576  	-1.401298464e-45, // Float32frombits(0x80000001)
  1577  	float32(NaN()),
  1578  	1.401298464e-45, // Float32frombits(0x00000001)
  1579  	float32(Copysign(0, -1)),
  1580  	float32(Copysign(0, -1)),
  1581  	-1.401298464e-45, // Float32frombits(0x80000001)
  1582  	float32(NaN()),
  1583  	float32(NaN()),
  1584  }
  1585  
  1586  var vfnextafter64SC = [][2]float64{
  1587  	{0, 0},
  1588  	{0, Copysign(0, -1)},
  1589  	{0, -1},
  1590  	{0, NaN()},
  1591  	{Copysign(0, -1), 1},
  1592  	{Copysign(0, -1), 0},
  1593  	{Copysign(0, -1), Copysign(0, -1)},
  1594  	{Copysign(0, -1), -1},
  1595  	{NaN(), 0},
  1596  	{NaN(), NaN()},
  1597  }
  1598  var nextafter64SC = []float64{
  1599  	0,
  1600  	0,
  1601  	-4.9406564584124654418e-324, // Float64frombits(0x8000000000000001)
  1602  	NaN(),
  1603  	4.9406564584124654418e-324, // Float64frombits(0x0000000000000001)
  1604  	Copysign(0, -1),
  1605  	Copysign(0, -1),
  1606  	-4.9406564584124654418e-324, // Float64frombits(0x8000000000000001)
  1607  	NaN(),
  1608  	NaN(),
  1609  }
  1610  
  1611  var vfpowSC = [][2]float64{
  1612  	{Inf(-1), -Pi},
  1613  	{Inf(-1), -3},
  1614  	{Inf(-1), Copysign(0, -1)},
  1615  	{Inf(-1), 0},
  1616  	{Inf(-1), 1},
  1617  	{Inf(-1), 3},
  1618  	{Inf(-1), Pi},
  1619  	{Inf(-1), 0.5},
  1620  	{Inf(-1), NaN()},
  1621  
  1622  	{-Pi, Inf(-1)},
  1623  	{-Pi, -Pi},
  1624  	{-Pi, Copysign(0, -1)},
  1625  	{-Pi, 0},
  1626  	{-Pi, 1},
  1627  	{-Pi, Pi},
  1628  	{-Pi, Inf(1)},
  1629  	{-Pi, NaN()},
  1630  
  1631  	{-1, Inf(-1)},
  1632  	{-1, Inf(1)},
  1633  	{-1, NaN()},
  1634  	{-0.5, Inf(-1)},
  1635  	{-0.5, Inf(1)},
  1636  	{Copysign(0, -1), Inf(-1)},
  1637  	{Copysign(0, -1), -Pi},
  1638  	{Copysign(0, -1), -0.5},
  1639  	{Copysign(0, -1), -3},
  1640  	{Copysign(0, -1), 3},
  1641  	{Copysign(0, -1), Pi},
  1642  	{Copysign(0, -1), 0.5},
  1643  	{Copysign(0, -1), Inf(1)},
  1644  
  1645  	{0, Inf(-1)},
  1646  	{0, -Pi},
  1647  	{0, -3},
  1648  	{0, Copysign(0, -1)},
  1649  	{0, 0},
  1650  	{0, 3},
  1651  	{0, Pi},
  1652  	{0, Inf(1)},
  1653  	{0, NaN()},
  1654  
  1655  	{0.5, Inf(-1)},
  1656  	{0.5, Inf(1)},
  1657  	{1, Inf(-1)},
  1658  	{1, Inf(1)},
  1659  	{1, NaN()},
  1660  
  1661  	{Pi, Inf(-1)},
  1662  	{Pi, Copysign(0, -1)},
  1663  	{Pi, 0},
  1664  	{Pi, 1},
  1665  	{Pi, Inf(1)},
  1666  	{Pi, NaN()},
  1667  	{Inf(1), -Pi},
  1668  	{Inf(1), Copysign(0, -1)},
  1669  	{Inf(1), 0},
  1670  	{Inf(1), 1},
  1671  	{Inf(1), Pi},
  1672  	{Inf(1), NaN()},
  1673  	{NaN(), -Pi},
  1674  	{NaN(), Copysign(0, -1)},
  1675  	{NaN(), 0},
  1676  	{NaN(), 1},
  1677  	{NaN(), Pi},
  1678  	{NaN(), NaN()},
  1679  
  1680  	// Issue #7394 overflow checks
  1681  	{2, float64(1 << 32)},
  1682  	{2, -float64(1 << 32)},
  1683  	{-2, float64(1<<32 + 1)},
  1684  	{0.5, float64(1 << 45)},
  1685  	{0.5, -float64(1 << 45)},
  1686  	{Nextafter(1, 2), float64(1 << 63)},
  1687  	{Nextafter(1, -2), float64(1 << 63)},
  1688  	{Nextafter(-1, 2), float64(1 << 63)},
  1689  	{Nextafter(-1, -2), float64(1 << 63)},
  1690  
  1691  	// Issue #57465
  1692  	{Copysign(0, -1), 1e19},
  1693  	{Copysign(0, -1), -1e19},
  1694  	{Copysign(0, -1), 1<<53 - 1},
  1695  	{Copysign(0, -1), -(1<<53 - 1)},
  1696  }
  1697  var powSC = []float64{
  1698  	0,               // pow(-Inf, -Pi)
  1699  	Copysign(0, -1), // pow(-Inf, -3)
  1700  	1,               // pow(-Inf, -0)
  1701  	1,               // pow(-Inf, +0)
  1702  	Inf(-1),         // pow(-Inf, 1)
  1703  	Inf(-1),         // pow(-Inf, 3)
  1704  	Inf(1),          // pow(-Inf, Pi)
  1705  	Inf(1),          // pow(-Inf, 0.5)
  1706  	NaN(),           // pow(-Inf, NaN)
  1707  	0,               // pow(-Pi, -Inf)
  1708  	NaN(),           // pow(-Pi, -Pi)
  1709  	1,               // pow(-Pi, -0)
  1710  	1,               // pow(-Pi, +0)
  1711  	-Pi,             // pow(-Pi, 1)
  1712  	NaN(),           // pow(-Pi, Pi)
  1713  	Inf(1),          // pow(-Pi, +Inf)
  1714  	NaN(),           // pow(-Pi, NaN)
  1715  	1,               // pow(-1, -Inf) IEEE 754-2008
  1716  	1,               // pow(-1, +Inf) IEEE 754-2008
  1717  	NaN(),           // pow(-1, NaN)
  1718  	Inf(1),          // pow(-1/2, -Inf)
  1719  	0,               // pow(-1/2, +Inf)
  1720  	Inf(1),          // pow(-0, -Inf)
  1721  	Inf(1),          // pow(-0, -Pi)
  1722  	Inf(1),          // pow(-0, -0.5)
  1723  	Inf(-1),         // pow(-0, -3) IEEE 754-2008
  1724  	Copysign(0, -1), // pow(-0, 3) IEEE 754-2008
  1725  	0,               // pow(-0, +Pi)
  1726  	0,               // pow(-0, 0.5)
  1727  	0,               // pow(-0, +Inf)
  1728  	Inf(1),          // pow(+0, -Inf)
  1729  	Inf(1),          // pow(+0, -Pi)
  1730  	Inf(1),          // pow(+0, -3)
  1731  	1,               // pow(+0, -0)
  1732  	1,               // pow(+0, +0)
  1733  	0,               // pow(+0, 3)
  1734  	0,               // pow(+0, +Pi)
  1735  	0,               // pow(+0, +Inf)
  1736  	NaN(),           // pow(+0, NaN)
  1737  	Inf(1),          // pow(1/2, -Inf)
  1738  	0,               // pow(1/2, +Inf)
  1739  	1,               // pow(1, -Inf) IEEE 754-2008
  1740  	1,               // pow(1, +Inf) IEEE 754-2008
  1741  	1,               // pow(1, NaN) IEEE 754-2008
  1742  	0,               // pow(+Pi, -Inf)
  1743  	1,               // pow(+Pi, -0)
  1744  	1,               // pow(+Pi, +0)
  1745  	Pi,              // pow(+Pi, 1)
  1746  	Inf(1),          // pow(+Pi, +Inf)
  1747  	NaN(),           // pow(+Pi, NaN)
  1748  	0,               // pow(+Inf, -Pi)
  1749  	1,               // pow(+Inf, -0)
  1750  	1,               // pow(+Inf, +0)
  1751  	Inf(1),          // pow(+Inf, 1)
  1752  	Inf(1),          // pow(+Inf, Pi)
  1753  	NaN(),           // pow(+Inf, NaN)
  1754  	NaN(),           // pow(NaN, -Pi)
  1755  	1,               // pow(NaN, -0)
  1756  	1,               // pow(NaN, +0)
  1757  	NaN(),           // pow(NaN, 1)
  1758  	NaN(),           // pow(NaN, +Pi)
  1759  	NaN(),           // pow(NaN, NaN)
  1760  
  1761  	// Issue #7394 overflow checks
  1762  	Inf(1),  // pow(2, float64(1 << 32))
  1763  	0,       // pow(2, -float64(1 << 32))
  1764  	Inf(-1), // pow(-2, float64(1<<32 + 1))
  1765  	0,       // pow(1/2, float64(1 << 45))
  1766  	Inf(1),  // pow(1/2, -float64(1 << 45))
  1767  	Inf(1),  // pow(Nextafter(1, 2), float64(1 << 63))
  1768  	0,       // pow(Nextafter(1, -2), float64(1 << 63))
  1769  	0,       // pow(Nextafter(-1, 2), float64(1 << 63))
  1770  	Inf(1),  // pow(Nextafter(-1, -2), float64(1 << 63))
  1771  
  1772  	// Issue #57465
  1773  	0,               // pow(-0, 1e19)
  1774  	Inf(1),          // pow(-0, -1e19)
  1775  	Copysign(0, -1), // pow(-0, 1<<53 -1)
  1776  	Inf(-1),         // pow(-0, -(1<<53 -1))
  1777  }
  1778  
  1779  var vfpow10SC = []int{
  1780  	MinInt32,
  1781  	-324,
  1782  	-323,
  1783  	-50,
  1784  	-22,
  1785  	-1,
  1786  	0,
  1787  	1,
  1788  	22,
  1789  	50,
  1790  	100,
  1791  	200,
  1792  	308,
  1793  	309,
  1794  	MaxInt32,
  1795  }
  1796  
  1797  var pow10SC = []float64{
  1798  	0,        // pow10(MinInt32)
  1799  	0,        // pow10(-324)
  1800  	1.0e-323, // pow10(-323)
  1801  	1.0e-50,  // pow10(-50)
  1802  	1.0e-22,  // pow10(-22)
  1803  	1.0e-1,   // pow10(-1)
  1804  	1.0e0,    // pow10(0)
  1805  	1.0e1,    // pow10(1)
  1806  	1.0e22,   // pow10(22)
  1807  	1.0e50,   // pow10(50)
  1808  	1.0e100,  // pow10(100)
  1809  	1.0e200,  // pow10(200)
  1810  	1.0e308,  // pow10(308)
  1811  	Inf(1),   // pow10(309)
  1812  	Inf(1),   // pow10(MaxInt32)
  1813  }
  1814  
  1815  var vfroundSC = [][2]float64{
  1816  	{0, 0},
  1817  	{1.390671161567e-309, 0}, // denormal
  1818  	{0.49999999999999994, 0}, // 0.5-epsilon
  1819  	{0.5, 1},
  1820  	{0.5000000000000001, 1}, // 0.5+epsilon
  1821  	{-1.5, -2},
  1822  	{-2.5, -3},
  1823  	{NaN(), NaN()},
  1824  	{Inf(1), Inf(1)},
  1825  	{2251799813685249.5, 2251799813685250}, // 1 bit fraction
  1826  	{2251799813685250.5, 2251799813685251},
  1827  	{4503599627370495.5, 4503599627370496}, // 1 bit fraction, rounding to 0 bit fraction
  1828  	{4503599627370497, 4503599627370497},   // large integer
  1829  }
  1830  var vfroundEvenSC = [][2]float64{
  1831  	{0, 0},
  1832  	{1.390671161567e-309, 0}, // denormal
  1833  	{0.49999999999999994, 0}, // 0.5-epsilon
  1834  	{0.5, 0},
  1835  	{0.5000000000000001, 1}, // 0.5+epsilon
  1836  	{-1.5, -2},
  1837  	{-2.5, -2},
  1838  	{NaN(), NaN()},
  1839  	{Inf(1), Inf(1)},
  1840  	{2251799813685249.5, 2251799813685250}, // 1 bit fraction
  1841  	{2251799813685250.5, 2251799813685250},
  1842  	{4503599627370495.5, 4503599627370496}, // 1 bit fraction, rounding to 0 bit fraction
  1843  	{4503599627370497, 4503599627370497},   // large integer
  1844  }
  1845  
  1846  var vfsignbitSC = []float64{
  1847  	Inf(-1),
  1848  	Copysign(0, -1),
  1849  	0,
  1850  	Inf(1),
  1851  	NaN(),
  1852  }
  1853  var signbitSC = []bool{
  1854  	true,
  1855  	true,
  1856  	false,
  1857  	false,
  1858  	false,
  1859  }
  1860  
  1861  var vfsinSC = []float64{
  1862  	Inf(-1),
  1863  	Copysign(0, -1),
  1864  	0,
  1865  	Inf(1),
  1866  	NaN(),
  1867  }
  1868  var sinSC = []float64{
  1869  	NaN(),
  1870  	Copysign(0, -1),
  1871  	0,
  1872  	NaN(),
  1873  	NaN(),
  1874  }
  1875  
  1876  var vfsinhSC = []float64{
  1877  	Inf(-1),
  1878  	Copysign(0, -1),
  1879  	0,
  1880  	Inf(1),
  1881  	NaN(),
  1882  }
  1883  var sinhSC = []float64{
  1884  	Inf(-1),
  1885  	Copysign(0, -1),
  1886  	0,
  1887  	Inf(1),
  1888  	NaN(),
  1889  }
  1890  
  1891  var vfsqrtSC = []float64{
  1892  	Inf(-1),
  1893  	-Pi,
  1894  	Copysign(0, -1),
  1895  	0,
  1896  	Inf(1),
  1897  	NaN(),
  1898  	Float64frombits(2), // subnormal; see https://golang.org/issue/13013
  1899  }
  1900  var sqrtSC = []float64{
  1901  	NaN(),
  1902  	NaN(),
  1903  	Copysign(0, -1),
  1904  	0,
  1905  	Inf(1),
  1906  	NaN(),
  1907  	3.1434555694052576e-162,
  1908  }
  1909  
  1910  var vftanhSC = []float64{
  1911  	Inf(-1),
  1912  	Copysign(0, -1),
  1913  	0,
  1914  	Inf(1),
  1915  	NaN(),
  1916  }
  1917  var tanhSC = []float64{
  1918  	-1,
  1919  	Copysign(0, -1),
  1920  	0,
  1921  	1,
  1922  	NaN(),
  1923  }
  1924  
  1925  var vfy0SC = []float64{
  1926  	Inf(-1),
  1927  	0,
  1928  	Inf(1),
  1929  	NaN(),
  1930  	-1,
  1931  }
  1932  var y0SC = []float64{
  1933  	NaN(),
  1934  	Inf(-1),
  1935  	0,
  1936  	NaN(),
  1937  	NaN(),
  1938  }
  1939  var y1SC = []float64{
  1940  	NaN(),
  1941  	Inf(-1),
  1942  	0,
  1943  	NaN(),
  1944  	NaN(),
  1945  }
  1946  var y2SC = []float64{
  1947  	NaN(),
  1948  	Inf(-1),
  1949  	0,
  1950  	NaN(),
  1951  	NaN(),
  1952  }
  1953  var yM3SC = []float64{
  1954  	NaN(),
  1955  	Inf(1),
  1956  	0,
  1957  	NaN(),
  1958  	NaN(),
  1959  }
  1960  
  1961  // arguments and expected results for boundary cases
  1962  const (
  1963  	SmallestNormalFloat64   = 2.2250738585072014e-308 // 2**-1022
  1964  	LargestSubnormalFloat64 = SmallestNormalFloat64 - SmallestNonzeroFloat64
  1965  )
  1966  
  1967  var vffrexpBC = []float64{
  1968  	SmallestNormalFloat64,
  1969  	LargestSubnormalFloat64,
  1970  	SmallestNonzeroFloat64,
  1971  	MaxFloat64,
  1972  	-SmallestNormalFloat64,
  1973  	-LargestSubnormalFloat64,
  1974  	-SmallestNonzeroFloat64,
  1975  	-MaxFloat64,
  1976  }
  1977  var frexpBC = []fi{
  1978  	{0.5, -1021},
  1979  	{0.99999999999999978, -1022},
  1980  	{0.5, -1073},
  1981  	{0.99999999999999989, 1024},
  1982  	{-0.5, -1021},
  1983  	{-0.99999999999999978, -1022},
  1984  	{-0.5, -1073},
  1985  	{-0.99999999999999989, 1024},
  1986  }
  1987  
  1988  var vfldexpBC = []fi{
  1989  	{SmallestNormalFloat64, -52},
  1990  	{LargestSubnormalFloat64, -51},
  1991  	{SmallestNonzeroFloat64, 1074},
  1992  	{MaxFloat64, -(1023 + 1074)},
  1993  	{1, -1075},
  1994  	{-1, -1075},
  1995  	{1, 1024},
  1996  	{-1, 1024},
  1997  	{1.0000000000000002, -1075},
  1998  	{1, -1075},
  1999  }
  2000  var ldexpBC = []float64{
  2001  	SmallestNonzeroFloat64,
  2002  	1e-323, // 2**-1073
  2003  	1,
  2004  	1e-323, // 2**-1073
  2005  	0,
  2006  	Copysign(0, -1),
  2007  	Inf(1),
  2008  	Inf(-1),
  2009  	SmallestNonzeroFloat64,
  2010  	0,
  2011  }
  2012  
  2013  var logbBC = []float64{
  2014  	-1022,
  2015  	-1023,
  2016  	-1074,
  2017  	1023,
  2018  	-1022,
  2019  	-1023,
  2020  	-1074,
  2021  	1023,
  2022  }
  2023  
  2024  // Test cases were generated with Berkeley TestFloat-3e/testfloat_gen.
  2025  // http://www.jhauser.us/arithmetic/TestFloat.html.
  2026  // The default rounding mode is selected (nearest/even), and exception flags are ignored.
  2027  var fmaC = []struct{ x, y, z, want float64 }{
  2028  	// Large exponent spread
  2029  	{-3.999999999999087, -1.1123914289620494e-16, -7.999877929687506, -7.999877929687505},
  2030  	{-262112.0000004768, -0.06251525855623184, 1.1102230248837136e-16, 16385.99945072085},
  2031  	{-6.462348523533467e-27, -2.3763644720331857e-211, 4.000000000931324, 4.000000000931324},
  2032  
  2033  	// Effective addition
  2034  	{-2.0000000037252907, 6.7904383376e-313, -3.3951933161e-313, -1.697607001654e-312},
  2035  	{-0.12499999999999999, 512.007568359375, -1.4193627164960366e-16, -64.00094604492188},
  2036  	{-2.7550648847397148e-39, -3.4028301595800694e+38, 0.9960937495343386, 1.9335955376735676},
  2037  	{5.723369164769208e+24, 3.8149300927159385e-06, 1.84489958778182e+19, 4.028324913621874e+19},
  2038  	{-0.4843749999990904, -3.6893487872543293e+19, 9.223653786709391e+18, 2.7093936974938993e+19},
  2039  	{-3.8146972665201165e-06, 4.2949672959999385e+09, -2.2204460489938386e-16, -16384.000003844263},
  2040  	{6.98156394130982e-309, -1.1072962560000002e+09, -4.4414561548793455e-308, -7.73065965765153e-300},
  2041  
  2042  	// Effective subtraction
  2043  	{5e-324, 4.5, -2e-323, 0},
  2044  	{5e-324, 7, -3.5e-323, 0},
  2045  	{5e-324, 0.5000000000000001, -5e-324, Copysign(0, -1)},
  2046  	{-2.1240680525e-314, -1.233647078189316e+308, -0.25781249999954525, -0.25780987964919844},
  2047  	{8.579992955364441e-308, 0.6037391876780558, -4.4501307410480706e-308, 7.29947236107098e-309},
  2048  	{-4.450143471986689e-308, -0.9960937499927239, -4.450419332475649e-308, -1.7659233458788e-310},
  2049  	{1.4932076393918112, -2.2248022430460833e-308, 4.449875571054211e-308, 1.127783865601762e-308},
  2050  
  2051  	// Overflow
  2052  	{-2.288020632214759e+38, -8.98846570988901e+307, 1.7696041796300924e+308, Inf(0)},
  2053  	{1.4888652783208255e+308, -9.007199254742012e+15, -6.807282911929205e+38, Inf(-1)},
  2054  	{9.142703268902826e+192, -1.3504889569802838e+296, -1.9082200803806996e-89, Inf(-1)},
  2055  
  2056  	// Finite x and y, but non-finite z.
  2057  	{31.99218749627471, -1.7976930544991702e+308, Inf(0), Inf(0)},
  2058  	{-1.7976931281784667e+308, -2.0009765625002265, Inf(-1), Inf(-1)},
  2059  
  2060  	// Special
  2061  	{0, 0, 0, 0},
  2062  	{Copysign(0, -1), 0, 0, 0},
  2063  	{0, 0, Copysign(0, -1), 0},
  2064  	{Copysign(0, -1), 0, Copysign(0, -1), Copysign(0, -1)},
  2065  	{-1.1754226043408471e-38, NaN(), Inf(0), NaN()},
  2066  	{0, 0, 2.22507385643494e-308, 2.22507385643494e-308},
  2067  	{-8.65697792e+09, NaN(), -7.516192799999999e+09, NaN()},
  2068  	{-0.00012207403779029757, 3.221225471996093e+09, NaN(), NaN()},
  2069  	{Inf(-1), 0.1252441407414153, -1.387184532981584e-76, Inf(-1)},
  2070  	{Inf(0), 1.525878907671432e-05, -9.214364835452549e+18, Inf(0)},
  2071  
  2072  	// Random
  2073  	{0.1777916152213626, -32.000015266239636, -2.2204459148334633e-16, -5.689334401293007},
  2074  	{-2.0816681711722314e-16, -0.4997558592585846, -0.9465627129124969, -0.9465627129124968},
  2075  	{-1.9999997615814211, 1.8518819259933516e+19, 16.874999999999996, -3.703763410463646e+19},
  2076  	{-0.12499994039717421, 32767.99999976135, -2.0752587082923246e+19, -2.075258708292325e+19},
  2077  	{7.705600568510257e-34, -1.801432979000528e+16, -0.17224197722973714, -0.17224197722973716},
  2078  	{3.8988133103758913e-308, -0.9848632812499999, 3.893879244098556e-308, 5.40811742605814e-310},
  2079  	{-0.012651981190687427, 6.911985574912436e+38, 6.669240527007144e+18, -8.745031148409496e+36},
  2080  	{4.612811918325842e+18, 1.4901161193847641e-08, 2.6077032311277997e-08, 6.873625395187494e+10},
  2081  	{-9.094947033611148e-13, 4.450691014249257e-308, 2.086006742350485e-308, 2.086006742346437e-308},
  2082  	{-7.751454006381804e-05, 5.588653777189071e-308, -2.2207280111272877e-308, -2.2211612130544025e-308},
  2083  
  2084  	// Issue #61130
  2085  	{-1, 1, 1, 0},
  2086  	{1, 1, -1, 0},
  2087  }
  2088  
  2089  var sqrt32 = []float32{
  2090  	0,
  2091  	float32(Copysign(0, -1)),
  2092  	float32(NaN()),
  2093  	float32(Inf(1)),
  2094  	float32(Inf(-1)),
  2095  	1,
  2096  	2,
  2097  	-2,
  2098  	4.9790119248836735e+00,
  2099  	7.7388724745781045e+00,
  2100  	-2.7688005719200159e-01,
  2101  	-5.0106036182710749e+00,
  2102  }
  2103  
  2104  func tolerance(a, b, e float64) bool {
  2105  	// Multiplying by e here can underflow denormal values to zero.
  2106  	// Check a==b so that at least if a and b are small and identical
  2107  	// we say they match.
  2108  	if a == b {
  2109  		return true
  2110  	}
  2111  	d := a - b
  2112  	if d < 0 {
  2113  		d = -d
  2114  	}
  2115  
  2116  	// note: b is correct (expected) value, a is actual value.
  2117  	// make error tolerance a fraction of b, not a.
  2118  	if b != 0 {
  2119  		e = e * b
  2120  		if e < 0 {
  2121  			e = -e
  2122  		}
  2123  	}
  2124  	return d < e
  2125  }
  2126  func close(a, b float64) bool      { return tolerance(a, b, 1e-14) }
  2127  func veryclose(a, b float64) bool  { return tolerance(a, b, 4e-16) }
  2128  func soclose(a, b, e float64) bool { return tolerance(a, b, e) }
  2129  func alike(a, b float64) bool {
  2130  	switch {
  2131  	case IsNaN(a) && IsNaN(b):
  2132  		return true
  2133  	case a == b:
  2134  		return Signbit(a) == Signbit(b)
  2135  	}
  2136  	return false
  2137  }
  2138  
  2139  func TestNaN(t *testing.T) {
  2140  	f64 := NaN()
  2141  	if f64 == f64 {
  2142  		t.Fatalf("NaN() returns %g, expected NaN", f64)
  2143  	}
  2144  	f32 := float32(f64)
  2145  	if f32 == f32 {
  2146  		t.Fatalf("float32(NaN()) is %g, expected NaN", f32)
  2147  	}
  2148  }
  2149  
  2150  func TestAcos(t *testing.T) {
  2151  	for i := 0; i < len(vf); i++ {
  2152  		a := vf[i] / 10
  2153  		if f := Acos(a); !close(acos[i], f) {
  2154  			t.Errorf("Acos(%g) = %g, want %g", a, f, acos[i])
  2155  		}
  2156  	}
  2157  	for i := 0; i < len(vfacosSC); i++ {
  2158  		if f := Acos(vfacosSC[i]); !alike(acosSC[i], f) {
  2159  			t.Errorf("Acos(%g) = %g, want %g", vfacosSC[i], f, acosSC[i])
  2160  		}
  2161  	}
  2162  }
  2163  
  2164  func TestAcosh(t *testing.T) {
  2165  	for i := 0; i < len(vf); i++ {
  2166  		a := 1 + Abs(vf[i])
  2167  		if f := Acosh(a); !veryclose(acosh[i], f) {
  2168  			t.Errorf("Acosh(%g) = %g, want %g", a, f, acosh[i])
  2169  		}
  2170  	}
  2171  	for i := 0; i < len(vfacoshSC); i++ {
  2172  		if f := Acosh(vfacoshSC[i]); !alike(acoshSC[i], f) {
  2173  			t.Errorf("Acosh(%g) = %g, want %g", vfacoshSC[i], f, acoshSC[i])
  2174  		}
  2175  	}
  2176  }
  2177  
  2178  func TestAsin(t *testing.T) {
  2179  	for i := 0; i < len(vf); i++ {
  2180  		a := vf[i] / 10
  2181  		if f := Asin(a); !veryclose(asin[i], f) {
  2182  			t.Errorf("Asin(%g) = %g, want %g", a, f, asin[i])
  2183  		}
  2184  	}
  2185  	for i := 0; i < len(vfasinSC); i++ {
  2186  		if f := Asin(vfasinSC[i]); !alike(asinSC[i], f) {
  2187  			t.Errorf("Asin(%g) = %g, want %g", vfasinSC[i], f, asinSC[i])
  2188  		}
  2189  	}
  2190  }
  2191  
  2192  func TestAsinh(t *testing.T) {
  2193  	for i := 0; i < len(vf); i++ {
  2194  		if f := Asinh(vf[i]); !veryclose(asinh[i], f) {
  2195  			t.Errorf("Asinh(%g) = %g, want %g", vf[i], f, asinh[i])
  2196  		}
  2197  	}
  2198  	for i := 0; i < len(vfasinhSC); i++ {
  2199  		if f := Asinh(vfasinhSC[i]); !alike(asinhSC[i], f) {
  2200  			t.Errorf("Asinh(%g) = %g, want %g", vfasinhSC[i], f, asinhSC[i])
  2201  		}
  2202  	}
  2203  }
  2204  
  2205  func TestAtan(t *testing.T) {
  2206  	for i := 0; i < len(vf); i++ {
  2207  		if f := Atan(vf[i]); !veryclose(atan[i], f) {
  2208  			t.Errorf("Atan(%g) = %g, want %g", vf[i], f, atan[i])
  2209  		}
  2210  	}
  2211  	for i := 0; i < len(vfatanSC); i++ {
  2212  		if f := Atan(vfatanSC[i]); !alike(atanSC[i], f) {
  2213  			t.Errorf("Atan(%g) = %g, want %g", vfatanSC[i], f, atanSC[i])
  2214  		}
  2215  	}
  2216  }
  2217  
  2218  func TestAtanh(t *testing.T) {
  2219  	for i := 0; i < len(vf); i++ {
  2220  		a := vf[i] / 10
  2221  		if f := Atanh(a); !veryclose(atanh[i], f) {
  2222  			t.Errorf("Atanh(%g) = %g, want %g", a, f, atanh[i])
  2223  		}
  2224  	}
  2225  	for i := 0; i < len(vfatanhSC); i++ {
  2226  		if f := Atanh(vfatanhSC[i]); !alike(atanhSC[i], f) {
  2227  			t.Errorf("Atanh(%g) = %g, want %g", vfatanhSC[i], f, atanhSC[i])
  2228  		}
  2229  	}
  2230  }
  2231  
  2232  func TestAtan2(t *testing.T) {
  2233  	for i := 0; i < len(vf); i++ {
  2234  		if f := Atan2(10, vf[i]); !veryclose(atan2[i], f) {
  2235  			t.Errorf("Atan2(10, %g) = %g, want %g", vf[i], f, atan2[i])
  2236  		}
  2237  	}
  2238  	for i := 0; i < len(vfatan2SC); i++ {
  2239  		if f := Atan2(vfatan2SC[i][0], vfatan2SC[i][1]); !alike(atan2SC[i], f) {
  2240  			t.Errorf("Atan2(%g, %g) = %g, want %g", vfatan2SC[i][0], vfatan2SC[i][1], f, atan2SC[i])
  2241  		}
  2242  	}
  2243  }
  2244  
  2245  func TestCbrt(t *testing.T) {
  2246  	for i := 0; i < len(vf); i++ {
  2247  		if f := Cbrt(vf[i]); !veryclose(cbrt[i], f) {
  2248  			t.Errorf("Cbrt(%g) = %g, want %g", vf[i], f, cbrt[i])
  2249  		}
  2250  	}
  2251  	for i := 0; i < len(vfcbrtSC); i++ {
  2252  		if f := Cbrt(vfcbrtSC[i]); !alike(cbrtSC[i], f) {
  2253  			t.Errorf("Cbrt(%g) = %g, want %g", vfcbrtSC[i], f, cbrtSC[i])
  2254  		}
  2255  	}
  2256  }
  2257  
  2258  func TestCeil(t *testing.T) {
  2259  	for i := 0; i < len(vf); i++ {
  2260  		if f := Ceil(vf[i]); !alike(ceil[i], f) {
  2261  			t.Errorf("Ceil(%g) = %g, want %g", vf[i], f, ceil[i])
  2262  		}
  2263  	}
  2264  	for i := 0; i < len(vfceilSC); i++ {
  2265  		if f := Ceil(vfceilSC[i]); !alike(ceilSC[i], f) {
  2266  			t.Errorf("Ceil(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
  2267  		}
  2268  	}
  2269  }
  2270  
  2271  func TestCopysign(t *testing.T) {
  2272  	for i := 0; i < len(vf); i++ {
  2273  		if f := Copysign(vf[i], -1); copysign[i] != f {
  2274  			t.Errorf("Copysign(%g, -1) = %g, want %g", vf[i], f, copysign[i])
  2275  		}
  2276  	}
  2277  	for i := 0; i < len(vf); i++ {
  2278  		if f := Copysign(vf[i], 1); -copysign[i] != f {
  2279  			t.Errorf("Copysign(%g, 1) = %g, want %g", vf[i], f, -copysign[i])
  2280  		}
  2281  	}
  2282  	for i := 0; i < len(vfcopysignSC); i++ {
  2283  		if f := Copysign(vfcopysignSC[i], -1); !alike(copysignSC[i], f) {
  2284  			t.Errorf("Copysign(%g, -1) = %g, want %g", vfcopysignSC[i], f, copysignSC[i])
  2285  		}
  2286  	}
  2287  }
  2288  
  2289  func TestCos(t *testing.T) {
  2290  	for i := 0; i < len(vf); i++ {
  2291  		if f := Cos(vf[i]); !veryclose(cos[i], f) {
  2292  			t.Errorf("Cos(%g) = %g, want %g", vf[i], f, cos[i])
  2293  		}
  2294  	}
  2295  	for i := 0; i < len(vfcosSC); i++ {
  2296  		if f := Cos(vfcosSC[i]); !alike(cosSC[i], f) {
  2297  			t.Errorf("Cos(%g) = %g, want %g", vfcosSC[i], f, cosSC[i])
  2298  		}
  2299  	}
  2300  }
  2301  
  2302  func TestCosh(t *testing.T) {
  2303  	for i := 0; i < len(vf); i++ {
  2304  		if f := Cosh(vf[i]); !close(cosh[i], f) {
  2305  			t.Errorf("Cosh(%g) = %g, want %g", vf[i], f, cosh[i])
  2306  		}
  2307  	}
  2308  	for i := 0; i < len(vfcoshSC); i++ {
  2309  		if f := Cosh(vfcoshSC[i]); !alike(coshSC[i], f) {
  2310  			t.Errorf("Cosh(%g) = %g, want %g", vfcoshSC[i], f, coshSC[i])
  2311  		}
  2312  	}
  2313  }
  2314  
  2315  func TestErf(t *testing.T) {
  2316  	for i := 0; i < len(vf); i++ {
  2317  		a := vf[i] / 10
  2318  		if f := Erf(a); !veryclose(erf[i], f) {
  2319  			t.Errorf("Erf(%g) = %g, want %g", a, f, erf[i])
  2320  		}
  2321  	}
  2322  	for i := 0; i < len(vferfSC); i++ {
  2323  		if f := Erf(vferfSC[i]); !alike(erfSC[i], f) {
  2324  			t.Errorf("Erf(%g) = %g, want %g", vferfSC[i], f, erfSC[i])
  2325  		}
  2326  	}
  2327  }
  2328  
  2329  func TestErfc(t *testing.T) {
  2330  	for i := 0; i < len(vf); i++ {
  2331  		a := vf[i] / 10
  2332  		if f := Erfc(a); !veryclose(erfc[i], f) {
  2333  			t.Errorf("Erfc(%g) = %g, want %g", a, f, erfc[i])
  2334  		}
  2335  	}
  2336  	for i := 0; i < len(vferfcSC); i++ {
  2337  		if f := Erfc(vferfcSC[i]); !alike(erfcSC[i], f) {
  2338  			t.Errorf("Erfc(%g) = %g, want %g", vferfcSC[i], f, erfcSC[i])
  2339  		}
  2340  	}
  2341  }
  2342  
  2343  func TestErfinv(t *testing.T) {
  2344  	for i := 0; i < len(vf); i++ {
  2345  		a := vf[i] / 10
  2346  		if f := Erfinv(a); !veryclose(erfinv[i], f) {
  2347  			t.Errorf("Erfinv(%g) = %g, want %g", a, f, erfinv[i])
  2348  		}
  2349  	}
  2350  	for i := 0; i < len(vferfinvSC); i++ {
  2351  		if f := Erfinv(vferfinvSC[i]); !alike(erfinvSC[i], f) {
  2352  			t.Errorf("Erfinv(%g) = %g, want %g", vferfinvSC[i], f, erfinvSC[i])
  2353  		}
  2354  	}
  2355  	for x := -0.9; x <= 0.90; x += 1e-2 {
  2356  		if f := Erf(Erfinv(x)); !close(x, f) {
  2357  			t.Errorf("Erf(Erfinv(%g)) = %g, want %g", x, f, x)
  2358  		}
  2359  	}
  2360  	for x := -0.9; x <= 0.90; x += 1e-2 {
  2361  		if f := Erfinv(Erf(x)); !close(x, f) {
  2362  			t.Errorf("Erfinv(Erf(%g)) = %g, want %g", x, f, x)
  2363  		}
  2364  	}
  2365  }
  2366  
  2367  func TestErfcinv(t *testing.T) {
  2368  	for i := 0; i < len(vf); i++ {
  2369  		a := 1.0 - (vf[i] / 10)
  2370  		if f := Erfcinv(a); !veryclose(erfinv[i], f) {
  2371  			t.Errorf("Erfcinv(%g) = %g, want %g", a, f, erfinv[i])
  2372  		}
  2373  	}
  2374  	for i := 0; i < len(vferfcinvSC); i++ {
  2375  		if f := Erfcinv(vferfcinvSC[i]); !alike(erfcinvSC[i], f) {
  2376  			t.Errorf("Erfcinv(%g) = %g, want %g", vferfcinvSC[i], f, erfcinvSC[i])
  2377  		}
  2378  	}
  2379  	for x := 0.1; x <= 1.9; x += 1e-2 {
  2380  		if f := Erfc(Erfcinv(x)); !close(x, f) {
  2381  			t.Errorf("Erfc(Erfcinv(%g)) = %g, want %g", x, f, x)
  2382  		}
  2383  	}
  2384  	for x := 0.1; x <= 1.9; x += 1e-2 {
  2385  		if f := Erfcinv(Erfc(x)); !close(x, f) {
  2386  			t.Errorf("Erfcinv(Erfc(%g)) = %g, want %g", x, f, x)
  2387  		}
  2388  	}
  2389  }
  2390  
  2391  func TestExp(t *testing.T) {
  2392  	testExp(t, Exp, "Exp")
  2393  	testExp(t, ExpGo, "ExpGo")
  2394  }
  2395  
  2396  func testExp(t *testing.T, Exp func(float64) float64, name string) {
  2397  	for i := 0; i < len(vf); i++ {
  2398  		if f := Exp(vf[i]); !veryclose(exp[i], f) {
  2399  			t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp[i])
  2400  		}
  2401  	}
  2402  	for i := 0; i < len(vfexpSC); i++ {
  2403  		if f := Exp(vfexpSC[i]); !alike(expSC[i], f) {
  2404  			t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i])
  2405  		}
  2406  	}
  2407  }
  2408  
  2409  func TestExpm1(t *testing.T) {
  2410  	for i := 0; i < len(vf); i++ {
  2411  		a := vf[i] / 100
  2412  		if f := Expm1(a); !veryclose(expm1[i], f) {
  2413  			t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1[i])
  2414  		}
  2415  	}
  2416  	for i := 0; i < len(vf); i++ {
  2417  		a := vf[i] * 10
  2418  		if f := Expm1(a); !close(expm1Large[i], f) {
  2419  			t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1Large[i])
  2420  		}
  2421  	}
  2422  	for i := 0; i < len(vfexpm1SC); i++ {
  2423  		if f := Expm1(vfexpm1SC[i]); !alike(expm1SC[i], f) {
  2424  			t.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC[i], f, expm1SC[i])
  2425  		}
  2426  	}
  2427  }
  2428  
  2429  func TestExp2(t *testing.T) {
  2430  	testExp2(t, Exp2, "Exp2")
  2431  	testExp2(t, Exp2Go, "Exp2Go")
  2432  }
  2433  
  2434  func testExp2(t *testing.T, Exp2 func(float64) float64, name string) {
  2435  	for i := 0; i < len(vf); i++ {
  2436  		if f := Exp2(vf[i]); !close(exp2[i], f) {
  2437  			t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp2[i])
  2438  		}
  2439  	}
  2440  	for i := 0; i < len(vfexp2SC); i++ {
  2441  		if f := Exp2(vfexp2SC[i]); !alike(exp2SC[i], f) {
  2442  			t.Errorf("%s(%g) = %g, want %g", name, vfexp2SC[i], f, exp2SC[i])
  2443  		}
  2444  	}
  2445  	for n := -1074; n < 1024; n++ {
  2446  		f := Exp2(float64(n))
  2447  		vf := Ldexp(1, n)
  2448  		if f != vf {
  2449  			t.Errorf("%s(%d) = %g, want %g", name, n, f, vf)
  2450  		}
  2451  	}
  2452  }
  2453  
  2454  func TestAbs(t *testing.T) {
  2455  	for i := 0; i < len(vf); i++ {
  2456  		if f := Abs(vf[i]); fabs[i] != f {
  2457  			t.Errorf("Abs(%g) = %g, want %g", vf[i], f, fabs[i])
  2458  		}
  2459  	}
  2460  	for i := 0; i < len(vffabsSC); i++ {
  2461  		if f := Abs(vffabsSC[i]); !alike(fabsSC[i], f) {
  2462  			t.Errorf("Abs(%g) = %g, want %g", vffabsSC[i], f, fabsSC[i])
  2463  		}
  2464  	}
  2465  }
  2466  
  2467  func TestDim(t *testing.T) {
  2468  	for i := 0; i < len(vf); i++ {
  2469  		if f := Dim(vf[i], 0); fdim[i] != f {
  2470  			t.Errorf("Dim(%g, %g) = %g, want %g", vf[i], 0.0, f, fdim[i])
  2471  		}
  2472  	}
  2473  	for i := 0; i < len(vffdimSC); i++ {
  2474  		if f := Dim(vffdimSC[i][0], vffdimSC[i][1]); !alike(fdimSC[i], f) {
  2475  			t.Errorf("Dim(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fdimSC[i])
  2476  		}
  2477  	}
  2478  	for i := 0; i < len(vffdim2SC); i++ {
  2479  		if f := Dim(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fdimSC[i], f) {
  2480  			t.Errorf("Dim(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fdimSC[i])
  2481  		}
  2482  	}
  2483  }
  2484  
  2485  func TestFloor(t *testing.T) {
  2486  	for i := 0; i < len(vf); i++ {
  2487  		if f := Floor(vf[i]); !alike(floor[i], f) {
  2488  			t.Errorf("Floor(%g) = %g, want %g", vf[i], f, floor[i])
  2489  		}
  2490  	}
  2491  	for i := 0; i < len(vfceilSC); i++ {
  2492  		if f := Floor(vfceilSC[i]); !alike(ceilSC[i], f) {
  2493  			t.Errorf("Floor(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
  2494  		}
  2495  	}
  2496  }
  2497  
  2498  func TestMax(t *testing.T) {
  2499  	for i := 0; i < len(vf); i++ {
  2500  		if f := Max(vf[i], ceil[i]); ceil[i] != f {
  2501  			t.Errorf("Max(%g, %g) = %g, want %g", vf[i], ceil[i], f, ceil[i])
  2502  		}
  2503  	}
  2504  	for i := 0; i < len(vffdimSC); i++ {
  2505  		if f := Max(vffdimSC[i][0], vffdimSC[i][1]); !alike(fmaxSC[i], f) {
  2506  			t.Errorf("Max(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fmaxSC[i])
  2507  		}
  2508  	}
  2509  	for i := 0; i < len(vffdim2SC); i++ {
  2510  		if f := Max(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fmaxSC[i], f) {
  2511  			t.Errorf("Max(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fmaxSC[i])
  2512  		}
  2513  	}
  2514  }
  2515  
  2516  func TestMin(t *testing.T) {
  2517  	for i := 0; i < len(vf); i++ {
  2518  		if f := Min(vf[i], floor[i]); floor[i] != f {
  2519  			t.Errorf("Min(%g, %g) = %g, want %g", vf[i], floor[i], f, floor[i])
  2520  		}
  2521  	}
  2522  	for i := 0; i < len(vffdimSC); i++ {
  2523  		if f := Min(vffdimSC[i][0], vffdimSC[i][1]); !alike(fminSC[i], f) {
  2524  			t.Errorf("Min(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fminSC[i])
  2525  		}
  2526  	}
  2527  	for i := 0; i < len(vffdim2SC); i++ {
  2528  		if f := Min(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fminSC[i], f) {
  2529  			t.Errorf("Min(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fminSC[i])
  2530  		}
  2531  	}
  2532  }
  2533  
  2534  func TestMod(t *testing.T) {
  2535  	for i := 0; i < len(vf); i++ {
  2536  		if f := Mod(10, vf[i]); fmod[i] != f {
  2537  			t.Errorf("Mod(10, %g) = %g, want %g", vf[i], f, fmod[i])
  2538  		}
  2539  	}
  2540  	for i := 0; i < len(vffmodSC); i++ {
  2541  		if f := Mod(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
  2542  			t.Errorf("Mod(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
  2543  		}
  2544  	}
  2545  	// verify precision of result for extreme inputs
  2546  	if f := Mod(5.9790119248836734e+200, 1.1258465975523544); 0.6447968302508578 != f {
  2547  		t.Errorf("Remainder(5.9790119248836734e+200, 1.1258465975523544) = %g, want 0.6447968302508578", f)
  2548  	}
  2549  }
  2550  
  2551  func TestFrexp(t *testing.T) {
  2552  	for i := 0; i < len(vf); i++ {
  2553  		if f, j := Frexp(vf[i]); !veryclose(frexp[i].f, f) || frexp[i].i != j {
  2554  			t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vf[i], f, j, frexp[i].f, frexp[i].i)
  2555  		}
  2556  	}
  2557  	for i := 0; i < len(vffrexpSC); i++ {
  2558  		if f, j := Frexp(vffrexpSC[i]); !alike(frexpSC[i].f, f) || frexpSC[i].i != j {
  2559  			t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpSC[i], f, j, frexpSC[i].f, frexpSC[i].i)
  2560  		}
  2561  	}
  2562  	for i := 0; i < len(vffrexpBC); i++ {
  2563  		if f, j := Frexp(vffrexpBC[i]); !alike(frexpBC[i].f, f) || frexpBC[i].i != j {
  2564  			t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpBC[i], f, j, frexpBC[i].f, frexpBC[i].i)
  2565  		}
  2566  	}
  2567  }
  2568  
  2569  func TestGamma(t *testing.T) {
  2570  	for i := 0; i < len(vf); i++ {
  2571  		if f := Gamma(vf[i]); !close(gamma[i], f) {
  2572  			t.Errorf("Gamma(%g) = %g, want %g", vf[i], f, gamma[i])
  2573  		}
  2574  	}
  2575  	for _, g := range vfgamma {
  2576  		f := Gamma(g[0])
  2577  		var ok bool
  2578  		if IsNaN(g[1]) || IsInf(g[1], 0) || g[1] == 0 || f == 0 {
  2579  			ok = alike(g[1], f)
  2580  		} else if g[0] > -50 && g[0] <= 171 {
  2581  			ok = veryclose(g[1], f)
  2582  		} else {
  2583  			ok = close(g[1], f)
  2584  		}
  2585  		if !ok {
  2586  			t.Errorf("Gamma(%g) = %g, want %g", g[0], f, g[1])
  2587  		}
  2588  	}
  2589  }
  2590  
  2591  func TestHypot(t *testing.T) {
  2592  	for i := 0; i < len(vf); i++ {
  2593  		a := Abs(1e200 * tanh[i] * Sqrt(2))
  2594  		if f := Hypot(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
  2595  			t.Errorf("Hypot(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
  2596  		}
  2597  	}
  2598  	for i := 0; i < len(vfhypotSC); i++ {
  2599  		if f := Hypot(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) {
  2600  			t.Errorf("Hypot(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i])
  2601  		}
  2602  	}
  2603  }
  2604  
  2605  func TestHypotGo(t *testing.T) {
  2606  	for i := 0; i < len(vf); i++ {
  2607  		a := Abs(1e200 * tanh[i] * Sqrt(2))
  2608  		if f := HypotGo(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
  2609  			t.Errorf("HypotGo(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
  2610  		}
  2611  	}
  2612  	for i := 0; i < len(vfhypotSC); i++ {
  2613  		if f := HypotGo(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) {
  2614  			t.Errorf("HypotGo(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i])
  2615  		}
  2616  	}
  2617  }
  2618  
  2619  func TestIlogb(t *testing.T) {
  2620  	for i := 0; i < len(vf); i++ {
  2621  		a := frexp[i].i - 1 // adjust because fr in the interval [½, 1)
  2622  		if e := Ilogb(vf[i]); a != e {
  2623  			t.Errorf("Ilogb(%g) = %d, want %d", vf[i], e, a)
  2624  		}
  2625  	}
  2626  	for i := 0; i < len(vflogbSC); i++ {
  2627  		if e := Ilogb(vflogbSC[i]); ilogbSC[i] != e {
  2628  			t.Errorf("Ilogb(%g) = %d, want %d", vflogbSC[i], e, ilogbSC[i])
  2629  		}
  2630  	}
  2631  	for i := 0; i < len(vffrexpBC); i++ {
  2632  		if e := Ilogb(vffrexpBC[i]); int(logbBC[i]) != e {
  2633  			t.Errorf("Ilogb(%g) = %d, want %d", vffrexpBC[i], e, int(logbBC[i]))
  2634  		}
  2635  	}
  2636  }
  2637  
  2638  func TestJ0(t *testing.T) {
  2639  	for i := 0; i < len(vf); i++ {
  2640  		if f := J0(vf[i]); !soclose(j0[i], f, 4e-14) {
  2641  			t.Errorf("J0(%g) = %g, want %g", vf[i], f, j0[i])
  2642  		}
  2643  	}
  2644  	for i := 0; i < len(vfj0SC); i++ {
  2645  		if f := J0(vfj0SC[i]); !alike(j0SC[i], f) {
  2646  			t.Errorf("J0(%g) = %g, want %g", vfj0SC[i], f, j0SC[i])
  2647  		}
  2648  	}
  2649  }
  2650  
  2651  func TestJ1(t *testing.T) {
  2652  	for i := 0; i < len(vf); i++ {
  2653  		if f := J1(vf[i]); !close(j1[i], f) {
  2654  			t.Errorf("J1(%g) = %g, want %g", vf[i], f, j1[i])
  2655  		}
  2656  	}
  2657  	for i := 0; i < len(vfj0SC); i++ {
  2658  		if f := J1(vfj0SC[i]); !alike(j1SC[i], f) {
  2659  			t.Errorf("J1(%g) = %g, want %g", vfj0SC[i], f, j1SC[i])
  2660  		}
  2661  	}
  2662  }
  2663  
  2664  func TestJn(t *testing.T) {
  2665  	for i := 0; i < len(vf); i++ {
  2666  		if f := Jn(2, vf[i]); !close(j2[i], f) {
  2667  			t.Errorf("Jn(2, %g) = %g, want %g", vf[i], f, j2[i])
  2668  		}
  2669  		if f := Jn(-3, vf[i]); !close(jM3[i], f) {
  2670  			t.Errorf("Jn(-3, %g) = %g, want %g", vf[i], f, jM3[i])
  2671  		}
  2672  	}
  2673  	for i := 0; i < len(vfj0SC); i++ {
  2674  		if f := Jn(2, vfj0SC[i]); !alike(j2SC[i], f) {
  2675  			t.Errorf("Jn(2, %g) = %g, want %g", vfj0SC[i], f, j2SC[i])
  2676  		}
  2677  		if f := Jn(-3, vfj0SC[i]); !alike(jM3SC[i], f) {
  2678  			t.Errorf("Jn(-3, %g) = %g, want %g", vfj0SC[i], f, jM3SC[i])
  2679  		}
  2680  	}
  2681  }
  2682  
  2683  func TestLdexp(t *testing.T) {
  2684  	for i := 0; i < len(vf); i++ {
  2685  		if f := Ldexp(frexp[i].f, frexp[i].i); !veryclose(vf[i], f) {
  2686  			t.Errorf("Ldexp(%g, %d) = %g, want %g", frexp[i].f, frexp[i].i, f, vf[i])
  2687  		}
  2688  	}
  2689  	for i := 0; i < len(vffrexpSC); i++ {
  2690  		if f := Ldexp(frexpSC[i].f, frexpSC[i].i); !alike(vffrexpSC[i], f) {
  2691  			t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpSC[i].f, frexpSC[i].i, f, vffrexpSC[i])
  2692  		}
  2693  	}
  2694  	for i := 0; i < len(vfldexpSC); i++ {
  2695  		if f := Ldexp(vfldexpSC[i].f, vfldexpSC[i].i); !alike(ldexpSC[i], f) {
  2696  			t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpSC[i].f, vfldexpSC[i].i, f, ldexpSC[i])
  2697  		}
  2698  	}
  2699  	for i := 0; i < len(vffrexpBC); i++ {
  2700  		if f := Ldexp(frexpBC[i].f, frexpBC[i].i); !alike(vffrexpBC[i], f) {
  2701  			t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpBC[i].f, frexpBC[i].i, f, vffrexpBC[i])
  2702  		}
  2703  	}
  2704  	for i := 0; i < len(vfldexpBC); i++ {
  2705  		if f := Ldexp(vfldexpBC[i].f, vfldexpBC[i].i); !alike(ldexpBC[i], f) {
  2706  			t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpBC[i].f, vfldexpBC[i].i, f, ldexpBC[i])
  2707  		}
  2708  	}
  2709  }
  2710  
  2711  func TestLgamma(t *testing.T) {
  2712  	for i := 0; i < len(vf); i++ {
  2713  		if f, s := Lgamma(vf[i]); !close(lgamma[i].f, f) || lgamma[i].i != s {
  2714  			t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vf[i], f, s, lgamma[i].f, lgamma[i].i)
  2715  		}
  2716  	}
  2717  	for i := 0; i < len(vflgammaSC); i++ {
  2718  		if f, s := Lgamma(vflgammaSC[i]); !alike(lgammaSC[i].f, f) || lgammaSC[i].i != s {
  2719  			t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vflgammaSC[i], f, s, lgammaSC[i].f, lgammaSC[i].i)
  2720  		}
  2721  	}
  2722  }
  2723  
  2724  func TestLog(t *testing.T) {
  2725  	for i := 0; i < len(vf); i++ {
  2726  		a := Abs(vf[i])
  2727  		if f := Log(a); log[i] != f {
  2728  			t.Errorf("Log(%g) = %g, want %g", a, f, log[i])
  2729  		}
  2730  	}
  2731  	if f := Log(10); f != Ln10 {
  2732  		t.Errorf("Log(%g) = %g, want %g", 10.0, f, Ln10)
  2733  	}
  2734  	for i := 0; i < len(vflogSC); i++ {
  2735  		if f := Log(vflogSC[i]); !alike(logSC[i], f) {
  2736  			t.Errorf("Log(%g) = %g, want %g", vflogSC[i], f, logSC[i])
  2737  		}
  2738  	}
  2739  }
  2740  
  2741  func TestLogb(t *testing.T) {
  2742  	for i := 0; i < len(vf); i++ {
  2743  		if f := Logb(vf[i]); logb[i] != f {
  2744  			t.Errorf("Logb(%g) = %g, want %g", vf[i], f, logb[i])
  2745  		}
  2746  	}
  2747  	for i := 0; i < len(vflogbSC); i++ {
  2748  		if f := Logb(vflogbSC[i]); !alike(logbSC[i], f) {
  2749  			t.Errorf("Logb(%g) = %g, want %g", vflogbSC[i], f, logbSC[i])
  2750  		}
  2751  	}
  2752  	for i := 0; i < len(vffrexpBC); i++ {
  2753  		if f := Logb(vffrexpBC[i]); !alike(logbBC[i], f) {
  2754  			t.Errorf("Logb(%g) = %g, want %g", vffrexpBC[i], f, logbBC[i])
  2755  		}
  2756  	}
  2757  }
  2758  
  2759  func TestLog10(t *testing.T) {
  2760  	for i := 0; i < len(vf); i++ {
  2761  		a := Abs(vf[i])
  2762  		if f := Log10(a); !veryclose(log10[i], f) {
  2763  			t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i])
  2764  		}
  2765  	}
  2766  	if f := Log10(E); f != Log10E {
  2767  		t.Errorf("Log10(%g) = %g, want %g", E, f, Log10E)
  2768  	}
  2769  	for i := 0; i < len(vflogSC); i++ {
  2770  		if f := Log10(vflogSC[i]); !alike(logSC[i], f) {
  2771  			t.Errorf("Log10(%g) = %g, want %g", vflogSC[i], f, logSC[i])
  2772  		}
  2773  	}
  2774  }
  2775  
  2776  func TestLog1p(t *testing.T) {
  2777  	for i := 0; i < len(vf); i++ {
  2778  		a := vf[i] / 100
  2779  		if f := Log1p(a); !veryclose(log1p[i], f) {
  2780  			t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i])
  2781  		}
  2782  	}
  2783  	a := 9.0
  2784  	if f := Log1p(a); f != Ln10 {
  2785  		t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10)
  2786  	}
  2787  	for i := 0; i < len(vflogSC); i++ {
  2788  		if f := Log1p(vflog1pSC[i]); !alike(log1pSC[i], f) {
  2789  			t.Errorf("Log1p(%g) = %g, want %g", vflog1pSC[i], f, log1pSC[i])
  2790  		}
  2791  	}
  2792  }
  2793  
  2794  func TestLog2(t *testing.T) {
  2795  	for i := 0; i < len(vf); i++ {
  2796  		a := Abs(vf[i])
  2797  		if f := Log2(a); !veryclose(log2[i], f) {
  2798  			t.Errorf("Log2(%g) = %g, want %g", a, f, log2[i])
  2799  		}
  2800  	}
  2801  	if f := Log2(E); f != Log2E {
  2802  		t.Errorf("Log2(%g) = %g, want %g", E, f, Log2E)
  2803  	}
  2804  	for i := 0; i < len(vflogSC); i++ {
  2805  		if f := Log2(vflogSC[i]); !alike(logSC[i], f) {
  2806  			t.Errorf("Log2(%g) = %g, want %g", vflogSC[i], f, logSC[i])
  2807  		}
  2808  	}
  2809  	for i := -1074; i <= 1023; i++ {
  2810  		f := Ldexp(1, i)
  2811  		l := Log2(f)
  2812  		if l != float64(i) {
  2813  			t.Errorf("Log2(2**%d) = %g, want %d", i, l, i)
  2814  		}
  2815  	}
  2816  }
  2817  
  2818  func TestModf(t *testing.T) {
  2819  	for i := 0; i < len(vf); i++ {
  2820  		if f, g := Modf(vf[i]); !veryclose(modf[i][0], f) || !veryclose(modf[i][1], g) {
  2821  			t.Errorf("Modf(%g) = %g, %g, want %g, %g", vf[i], f, g, modf[i][0], modf[i][1])
  2822  		}
  2823  	}
  2824  	for i := 0; i < len(vfmodfSC); i++ {
  2825  		if f, g := Modf(vfmodfSC[i]); !alike(modfSC[i][0], f) || !alike(modfSC[i][1], g) {
  2826  			t.Errorf("Modf(%g) = %g, %g, want %g, %g", vfmodfSC[i], f, g, modfSC[i][0], modfSC[i][1])
  2827  		}
  2828  	}
  2829  }
  2830  
  2831  func TestNextafter32(t *testing.T) {
  2832  	for i := 0; i < len(vf); i++ {
  2833  		vfi := float32(vf[i])
  2834  		if f := Nextafter32(vfi, 10); nextafter32[i] != f {
  2835  			t.Errorf("Nextafter32(%g, %g) = %g want %g", vfi, 10.0, f, nextafter32[i])
  2836  		}
  2837  	}
  2838  	for i := 0; i < len(vfnextafter32SC); i++ {
  2839  		if f := Nextafter32(vfnextafter32SC[i][0], vfnextafter32SC[i][1]); !alike(float64(nextafter32SC[i]), float64(f)) {
  2840  			t.Errorf("Nextafter32(%g, %g) = %g want %g", vfnextafter32SC[i][0], vfnextafter32SC[i][1], f, nextafter32SC[i])
  2841  		}
  2842  	}
  2843  }
  2844  
  2845  func TestNextafter64(t *testing.T) {
  2846  	for i := 0; i < len(vf); i++ {
  2847  		if f := Nextafter(vf[i], 10); nextafter64[i] != f {
  2848  			t.Errorf("Nextafter64(%g, %g) = %g want %g", vf[i], 10.0, f, nextafter64[i])
  2849  		}
  2850  	}
  2851  	for i := 0; i < len(vfnextafter64SC); i++ {
  2852  		if f := Nextafter(vfnextafter64SC[i][0], vfnextafter64SC[i][1]); !alike(nextafter64SC[i], f) {
  2853  			t.Errorf("Nextafter64(%g, %g) = %g want %g", vfnextafter64SC[i][0], vfnextafter64SC[i][1], f, nextafter64SC[i])
  2854  		}
  2855  	}
  2856  }
  2857  
  2858  func TestPow(t *testing.T) {
  2859  	for i := 0; i < len(vf); i++ {
  2860  		if f := Pow(10, vf[i]); !close(pow[i], f) {
  2861  			t.Errorf("Pow(10, %g) = %g, want %g", vf[i], f, pow[i])
  2862  		}
  2863  	}
  2864  	for i := 0; i < len(vfpowSC); i++ {
  2865  		if f := Pow(vfpowSC[i][0], vfpowSC[i][1]); !alike(powSC[i], f) {
  2866  			t.Errorf("Pow(%g, %g) = %g, want %g", vfpowSC[i][0], vfpowSC[i][1], f, powSC[i])
  2867  		}
  2868  	}
  2869  }
  2870  
  2871  func TestPow10(t *testing.T) {
  2872  	for i := 0; i < len(vfpow10SC); i++ {
  2873  		if f := Pow10(vfpow10SC[i]); !alike(pow10SC[i], f) {
  2874  			t.Errorf("Pow10(%d) = %g, want %g", vfpow10SC[i], f, pow10SC[i])
  2875  		}
  2876  	}
  2877  }
  2878  
  2879  func TestRemainder(t *testing.T) {
  2880  	for i := 0; i < len(vf); i++ {
  2881  		if f := Remainder(10, vf[i]); remainder[i] != f {
  2882  			t.Errorf("Remainder(10, %g) = %g, want %g", vf[i], f, remainder[i])
  2883  		}
  2884  	}
  2885  	for i := 0; i < len(vffmodSC); i++ {
  2886  		if f := Remainder(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
  2887  			t.Errorf("Remainder(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
  2888  		}
  2889  	}
  2890  	// verify precision of result for extreme inputs
  2891  	if f := Remainder(5.9790119248836734e+200, 1.1258465975523544); -0.4810497673014966 != f {
  2892  		t.Errorf("Remainder(5.9790119248836734e+200, 1.1258465975523544) = %g, want -0.4810497673014966", f)
  2893  	}
  2894  	// verify that sign is correct when r == 0.
  2895  	test := func(x, y float64) {
  2896  		if r := Remainder(x, y); r == 0 && Signbit(r) != Signbit(x) {
  2897  			t.Errorf("Remainder(x=%f, y=%f) = %f, sign of (zero) result should agree with sign of x", x, y, r)
  2898  		}
  2899  	}
  2900  	for x := 0.0; x <= 3.0; x += 1 {
  2901  		for y := 1.0; y <= 3.0; y += 1 {
  2902  			test(x, y)
  2903  			test(x, -y)
  2904  			test(-x, y)
  2905  			test(-x, -y)
  2906  		}
  2907  	}
  2908  }
  2909  
  2910  func TestRound(t *testing.T) {
  2911  	for i := 0; i < len(vf); i++ {
  2912  		if f := Round(vf[i]); !alike(round[i], f) {
  2913  			t.Errorf("Round(%g) = %g, want %g", vf[i], f, round[i])
  2914  		}
  2915  	}
  2916  	for i := 0; i < len(vfroundSC); i++ {
  2917  		if f := Round(vfroundSC[i][0]); !alike(vfroundSC[i][1], f) {
  2918  			t.Errorf("Round(%g) = %g, want %g", vfroundSC[i][0], f, vfroundSC[i][1])
  2919  		}
  2920  	}
  2921  }
  2922  
  2923  func TestRoundToEven(t *testing.T) {
  2924  	for i := 0; i < len(vf); i++ {
  2925  		if f := RoundToEven(vf[i]); !alike(round[i], f) {
  2926  			t.Errorf("RoundToEven(%g) = %g, want %g", vf[i], f, round[i])
  2927  		}
  2928  	}
  2929  	for i := 0; i < len(vfroundEvenSC); i++ {
  2930  		if f := RoundToEven(vfroundEvenSC[i][0]); !alike(vfroundEvenSC[i][1], f) {
  2931  			t.Errorf("RoundToEven(%g) = %g, want %g", vfroundEvenSC[i][0], f, vfroundEvenSC[i][1])
  2932  		}
  2933  	}
  2934  }
  2935  
  2936  func TestSignbit(t *testing.T) {
  2937  	for i := 0; i < len(vf); i++ {
  2938  		if f := Signbit(vf[i]); signbit[i] != f {
  2939  			t.Errorf("Signbit(%g) = %t, want %t", vf[i], f, signbit[i])
  2940  		}
  2941  	}
  2942  	for i := 0; i < len(vfsignbitSC); i++ {
  2943  		if f := Signbit(vfsignbitSC[i]); signbitSC[i] != f {
  2944  			t.Errorf("Signbit(%g) = %t, want %t", vfsignbitSC[i], f, signbitSC[i])
  2945  		}
  2946  	}
  2947  }
  2948  func TestSin(t *testing.T) {
  2949  	for i := 0; i < len(vf); i++ {
  2950  		if f := Sin(vf[i]); !veryclose(sin[i], f) {
  2951  			t.Errorf("Sin(%g) = %g, want %g", vf[i], f, sin[i])
  2952  		}
  2953  	}
  2954  	for i := 0; i < len(vfsinSC); i++ {
  2955  		if f := Sin(vfsinSC[i]); !alike(sinSC[i], f) {
  2956  			t.Errorf("Sin(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
  2957  		}
  2958  	}
  2959  }
  2960  
  2961  func TestSincos(t *testing.T) {
  2962  	for i := 0; i < len(vf); i++ {
  2963  		if s, c := Sincos(vf[i]); !veryclose(sin[i], s) || !veryclose(cos[i], c) {
  2964  			t.Errorf("Sincos(%g) = %g, %g want %g, %g", vf[i], s, c, sin[i], cos[i])
  2965  		}
  2966  	}
  2967  }
  2968  
  2969  func TestSinh(t *testing.T) {
  2970  	for i := 0; i < len(vf); i++ {
  2971  		if f := Sinh(vf[i]); !close(sinh[i], f) {
  2972  			t.Errorf("Sinh(%g) = %g, want %g", vf[i], f, sinh[i])
  2973  		}
  2974  	}
  2975  	for i := 0; i < len(vfsinhSC); i++ {
  2976  		if f := Sinh(vfsinhSC[i]); !alike(sinhSC[i], f) {
  2977  			t.Errorf("Sinh(%g) = %g, want %g", vfsinhSC[i], f, sinhSC[i])
  2978  		}
  2979  	}
  2980  }
  2981  
  2982  func TestSqrt(t *testing.T) {
  2983  	for i := 0; i < len(vf); i++ {
  2984  		a := Abs(vf[i])
  2985  		if f := SqrtGo(a); sqrt[i] != f {
  2986  			t.Errorf("SqrtGo(%g) = %g, want %g", a, f, sqrt[i])
  2987  		}
  2988  		a = Abs(vf[i])
  2989  		if f := Sqrt(a); sqrt[i] != f {
  2990  			t.Errorf("Sqrt(%g) = %g, want %g", a, f, sqrt[i])
  2991  		}
  2992  	}
  2993  	for i := 0; i < len(vfsqrtSC); i++ {
  2994  		if f := SqrtGo(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
  2995  			t.Errorf("SqrtGo(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
  2996  		}
  2997  		if f := Sqrt(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
  2998  			t.Errorf("Sqrt(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
  2999  		}
  3000  	}
  3001  }
  3002  
  3003  func TestTan(t *testing.T) {
  3004  	for i := 0; i < len(vf); i++ {
  3005  		if f := Tan(vf[i]); !veryclose(tan[i], f) {
  3006  			t.Errorf("Tan(%g) = %g, want %g", vf[i], f, tan[i])
  3007  		}
  3008  	}
  3009  	// same special cases as Sin
  3010  	for i := 0; i < len(vfsinSC); i++ {
  3011  		if f := Tan(vfsinSC[i]); !alike(sinSC[i], f) {
  3012  			t.Errorf("Tan(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
  3013  		}
  3014  	}
  3015  }
  3016  
  3017  func TestTanh(t *testing.T) {
  3018  	for i := 0; i < len(vf); i++ {
  3019  		if f := Tanh(vf[i]); !veryclose(tanh[i], f) {
  3020  			t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i])
  3021  		}
  3022  	}
  3023  	for i := 0; i < len(vftanhSC); i++ {
  3024  		if f := Tanh(vftanhSC[i]); !alike(tanhSC[i], f) {
  3025  			t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i])
  3026  		}
  3027  	}
  3028  }
  3029  
  3030  func TestTrunc(t *testing.T) {
  3031  	for i := 0; i < len(vf); i++ {
  3032  		if f := Trunc(vf[i]); !alike(trunc[i], f) {
  3033  			t.Errorf("Trunc(%g) = %g, want %g", vf[i], f, trunc[i])
  3034  		}
  3035  	}
  3036  	for i := 0; i < len(vfceilSC); i++ {
  3037  		if f := Trunc(vfceilSC[i]); !alike(ceilSC[i], f) {
  3038  			t.Errorf("Trunc(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
  3039  		}
  3040  	}
  3041  }
  3042  
  3043  func TestY0(t *testing.T) {
  3044  	for i := 0; i < len(vf); i++ {
  3045  		a := Abs(vf[i])
  3046  		if f := Y0(a); !close(y0[i], f) {
  3047  			t.Errorf("Y0(%g) = %g, want %g", a, f, y0[i])
  3048  		}
  3049  	}
  3050  	for i := 0; i < len(vfy0SC); i++ {
  3051  		if f := Y0(vfy0SC[i]); !alike(y0SC[i], f) {
  3052  			t.Errorf("Y0(%g) = %g, want %g", vfy0SC[i], f, y0SC[i])
  3053  		}
  3054  	}
  3055  }
  3056  
  3057  func TestY1(t *testing.T) {
  3058  	for i := 0; i < len(vf); i++ {
  3059  		a := Abs(vf[i])
  3060  		if f := Y1(a); !soclose(y1[i], f, 2e-14) {
  3061  			t.Errorf("Y1(%g) = %g, want %g", a, f, y1[i])
  3062  		}
  3063  	}
  3064  	for i := 0; i < len(vfy0SC); i++ {
  3065  		if f := Y1(vfy0SC[i]); !alike(y1SC[i], f) {
  3066  			t.Errorf("Y1(%g) = %g, want %g", vfy0SC[i], f, y1SC[i])
  3067  		}
  3068  	}
  3069  }
  3070  
  3071  func TestYn(t *testing.T) {
  3072  	for i := 0; i < len(vf); i++ {
  3073  		a := Abs(vf[i])
  3074  		if f := Yn(2, a); !close(y2[i], f) {
  3075  			t.Errorf("Yn(2, %g) = %g, want %g", a, f, y2[i])
  3076  		}
  3077  		if f := Yn(-3, a); !close(yM3[i], f) {
  3078  			t.Errorf("Yn(-3, %g) = %g, want %g", a, f, yM3[i])
  3079  		}
  3080  	}
  3081  	for i := 0; i < len(vfy0SC); i++ {
  3082  		if f := Yn(2, vfy0SC[i]); !alike(y2SC[i], f) {
  3083  			t.Errorf("Yn(2, %g) = %g, want %g", vfy0SC[i], f, y2SC[i])
  3084  		}
  3085  		if f := Yn(-3, vfy0SC[i]); !alike(yM3SC[i], f) {
  3086  			t.Errorf("Yn(-3, %g) = %g, want %g", vfy0SC[i], f, yM3SC[i])
  3087  		}
  3088  	}
  3089  	if f := Yn(0, 0); !alike(Inf(-1), f) {
  3090  		t.Errorf("Yn(0, 0) = %g, want %g", f, Inf(-1))
  3091  	}
  3092  }
  3093  
  3094  var PortableFMA = FMA // hide call from compiler intrinsic; falls back to portable code
  3095  
  3096  func TestFMA(t *testing.T) {
  3097  	for _, c := range fmaC {
  3098  		got := FMA(c.x, c.y, c.z)
  3099  		if !alike(got, c.want) {
  3100  			t.Errorf("FMA(%g,%g,%g) == %g; want %g", c.x, c.y, c.z, got, c.want)
  3101  		}
  3102  		got = PortableFMA(c.x, c.y, c.z)
  3103  		if !alike(got, c.want) {
  3104  			t.Errorf("PortableFMA(%g,%g,%g) == %g; want %g", c.x, c.y, c.z, got, c.want)
  3105  		}
  3106  	}
  3107  }
  3108  
  3109  //go:noinline
  3110  func fmsub(x, y, z float64) float64 {
  3111  	return FMA(x, y, -z)
  3112  }
  3113  
  3114  //go:noinline
  3115  func fnmsub(x, y, z float64) float64 {
  3116  	return FMA(-x, y, z)
  3117  }
  3118  
  3119  //go:noinline
  3120  func fnmadd(x, y, z float64) float64 {
  3121  	return FMA(-x, y, -z)
  3122  }
  3123  
  3124  func TestFMANegativeArgs(t *testing.T) {
  3125  	// Some architectures have instructions for fused multiply-subtract and
  3126  	// also negated variants of fused multiply-add and subtract. This test
  3127  	// aims to check that the optimizations that generate those instructions
  3128  	// are applied correctly, if they exist.
  3129  	for _, c := range fmaC {
  3130  		want := PortableFMA(c.x, c.y, -c.z)
  3131  		got := fmsub(c.x, c.y, c.z)
  3132  		if !alike(got, want) {
  3133  			t.Errorf("FMA(%g, %g, -(%g)) == %g, want %g", c.x, c.y, c.z, got, want)
  3134  		}
  3135  		want = PortableFMA(-c.x, c.y, c.z)
  3136  		got = fnmsub(c.x, c.y, c.z)
  3137  		if !alike(got, want) {
  3138  			t.Errorf("FMA(-(%g), %g, %g) == %g, want %g", c.x, c.y, c.z, got, want)
  3139  		}
  3140  		want = PortableFMA(-c.x, c.y, -c.z)
  3141  		got = fnmadd(c.x, c.y, c.z)
  3142  		if !alike(got, want) {
  3143  			t.Errorf("FMA(-(%g), %g, -(%g)) == %g, want %g", c.x, c.y, c.z, got, want)
  3144  		}
  3145  	}
  3146  }
  3147  
  3148  // Check that math functions of high angle values
  3149  // return accurate results. [Since (vf[i] + large) - large != vf[i],
  3150  // testing for Trig(vf[i] + large) == Trig(vf[i]), where large is
  3151  // a multiple of 2*Pi, is misleading.]
  3152  func TestLargeCos(t *testing.T) {
  3153  	large := float64(100000 * Pi)
  3154  	for i := 0; i < len(vf); i++ {
  3155  		f1 := cosLarge[i]
  3156  		f2 := Cos(vf[i] + large)
  3157  		if !close(f1, f2) {
  3158  			t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1)
  3159  		}
  3160  	}
  3161  }
  3162  
  3163  func TestLargeSin(t *testing.T) {
  3164  	large := float64(100000 * Pi)
  3165  	for i := 0; i < len(vf); i++ {
  3166  		f1 := sinLarge[i]
  3167  		f2 := Sin(vf[i] + large)
  3168  		if !close(f1, f2) {
  3169  			t.Errorf("Sin(%g) = %g, want %g", vf[i]+large, f2, f1)
  3170  		}
  3171  	}
  3172  }
  3173  
  3174  func TestLargeSincos(t *testing.T) {
  3175  	large := float64(100000 * Pi)
  3176  	for i := 0; i < len(vf); i++ {
  3177  		f1, g1 := sinLarge[i], cosLarge[i]
  3178  		f2, g2 := Sincos(vf[i] + large)
  3179  		if !close(f1, f2) || !close(g1, g2) {
  3180  			t.Errorf("Sincos(%g) = %g, %g, want %g, %g", vf[i]+large, f2, g2, f1, g1)
  3181  		}
  3182  	}
  3183  }
  3184  
  3185  func TestLargeTan(t *testing.T) {
  3186  	large := float64(100000 * Pi)
  3187  	for i := 0; i < len(vf); i++ {
  3188  		f1 := tanLarge[i]
  3189  		f2 := Tan(vf[i] + large)
  3190  		if !close(f1, f2) {
  3191  			t.Errorf("Tan(%g) = %g, want %g", vf[i]+large, f2, f1)
  3192  		}
  3193  	}
  3194  }
  3195  
  3196  // Check that trigReduce matches the standard reduction results for input values
  3197  // below reduceThreshold.
  3198  func TestTrigReduce(t *testing.T) {
  3199  	inputs := make([]float64, len(vf))
  3200  	// all of the standard inputs
  3201  	copy(inputs, vf)
  3202  	// all of the large inputs
  3203  	large := float64(100000 * Pi)
  3204  	for _, v := range vf {
  3205  		inputs = append(inputs, v+large)
  3206  	}
  3207  	// Also test some special inputs, Pi and right below the reduceThreshold
  3208  	inputs = append(inputs, Pi, Nextafter(ReduceThreshold, 0))
  3209  	for _, x := range inputs {
  3210  		// reduce the value to compare
  3211  		j, z := TrigReduce(x)
  3212  		xred := float64(j)*(Pi/4) + z
  3213  
  3214  		if f, fred := Sin(x), Sin(xred); !close(f, fred) {
  3215  			t.Errorf("Sin(trigReduce(%g)) != Sin(%g), got %g, want %g", x, x, fred, f)
  3216  		}
  3217  		if f, fred := Cos(x), Cos(xred); !close(f, fred) {
  3218  			t.Errorf("Cos(trigReduce(%g)) != Cos(%g), got %g, want %g", x, x, fred, f)
  3219  		}
  3220  		if f, fred := Tan(x), Tan(xred); !close(f, fred) {
  3221  			t.Errorf(" Tan(trigReduce(%g)) != Tan(%g), got %g, want %g", x, x, fred, f)
  3222  		}
  3223  		f, g := Sincos(x)
  3224  		fred, gred := Sincos(xred)
  3225  		if !close(f, fred) || !close(g, gred) {
  3226  			t.Errorf(" Sincos(trigReduce(%g)) != Sincos(%g), got %g, %g, want %g, %g", x, x, fred, gred, f, g)
  3227  		}
  3228  	}
  3229  }
  3230  
  3231  // Check that math constants are accepted by compiler
  3232  // and have right value (assumes strconv.ParseFloat works).
  3233  // https://golang.org/issue/201
  3234  
  3235  type floatTest struct {
  3236  	val  any
  3237  	name string
  3238  	str  string
  3239  }
  3240  
  3241  var floatTests = []floatTest{
  3242  	{float64(MaxFloat64), "MaxFloat64", "1.7976931348623157e+308"},
  3243  	{float64(SmallestNonzeroFloat64), "SmallestNonzeroFloat64", "5e-324"},
  3244  	{float32(MaxFloat32), "MaxFloat32", "3.4028235e+38"},
  3245  	{float32(SmallestNonzeroFloat32), "SmallestNonzeroFloat32", "1e-45"},
  3246  }
  3247  
  3248  func TestFloatMinMax(t *testing.T) {
  3249  	for _, tt := range floatTests {
  3250  		s := fmt.Sprint(tt.val)
  3251  		if s != tt.str {
  3252  			t.Errorf("Sprint(%v) = %s, want %s", tt.name, s, tt.str)
  3253  		}
  3254  	}
  3255  }
  3256  
  3257  func TestFloatMinima(t *testing.T) {
  3258  	if q := float32(SmallestNonzeroFloat32 / 2); q != 0 {
  3259  		t.Errorf("float32(SmallestNonzeroFloat32 / 2) = %g, want 0", q)
  3260  	}
  3261  	if q := float64(SmallestNonzeroFloat64 / 2); q != 0 {
  3262  		t.Errorf("float64(SmallestNonzeroFloat64 / 2) = %g, want 0", q)
  3263  	}
  3264  }
  3265  
  3266  var indirectSqrt = Sqrt
  3267  
  3268  // TestFloat32Sqrt checks the correctness of the float32 square root optimization result.
  3269  func TestFloat32Sqrt(t *testing.T) {
  3270  	for _, v := range sqrt32 {
  3271  		want := float32(indirectSqrt(float64(v)))
  3272  		got := float32(Sqrt(float64(v)))
  3273  		if IsNaN(float64(want)) {
  3274  			if !IsNaN(float64(got)) {
  3275  				t.Errorf("got=%#v want=NaN, v=%#v", got, v)
  3276  			}
  3277  			continue
  3278  		}
  3279  		if got != want {
  3280  			t.Errorf("got=%#v want=%#v, v=%#v", got, want, v)
  3281  		}
  3282  	}
  3283  }
  3284  
  3285  // Benchmarks
  3286  
  3287  // Global exported variables are used to store the
  3288  // return values of functions measured in the benchmarks.
  3289  // Storing the results in these variables prevents the compiler
  3290  // from completely optimizing the benchmarked functions away.
  3291  var (
  3292  	GlobalI int
  3293  	GlobalB bool
  3294  	GlobalF float64
  3295  )
  3296  
  3297  func BenchmarkAcos(b *testing.B) {
  3298  	x := 0.0
  3299  	for i := 0; i < b.N; i++ {
  3300  		x = Acos(.5)
  3301  	}
  3302  	GlobalF = x
  3303  }
  3304  
  3305  func BenchmarkAcosh(b *testing.B) {
  3306  	x := 0.0
  3307  	for i := 0; i < b.N; i++ {
  3308  		x = Acosh(1.5)
  3309  	}
  3310  	GlobalF = x
  3311  }
  3312  
  3313  func BenchmarkAsin(b *testing.B) {
  3314  	x := 0.0
  3315  	for i := 0; i < b.N; i++ {
  3316  		x = Asin(.5)
  3317  	}
  3318  	GlobalF = x
  3319  }
  3320  
  3321  func BenchmarkAsinh(b *testing.B) {
  3322  	x := 0.0
  3323  	for i := 0; i < b.N; i++ {
  3324  		x = Asinh(.5)
  3325  	}
  3326  	GlobalF = x
  3327  }
  3328  
  3329  func BenchmarkAtan(b *testing.B) {
  3330  	x := 0.0
  3331  	for i := 0; i < b.N; i++ {
  3332  		x = Atan(.5)
  3333  	}
  3334  	GlobalF = x
  3335  }
  3336  
  3337  func BenchmarkAtanh(b *testing.B) {
  3338  	x := 0.0
  3339  	for i := 0; i < b.N; i++ {
  3340  		x = Atanh(.5)
  3341  	}
  3342  	GlobalF = x
  3343  }
  3344  
  3345  func BenchmarkAtan2(b *testing.B) {
  3346  	x := 0.0
  3347  	for i := 0; i < b.N; i++ {
  3348  		x = Atan2(.5, 1)
  3349  	}
  3350  	GlobalF = x
  3351  }
  3352  
  3353  func BenchmarkCbrt(b *testing.B) {
  3354  	x := 0.0
  3355  	for i := 0; i < b.N; i++ {
  3356  		x = Cbrt(10)
  3357  	}
  3358  	GlobalF = x
  3359  }
  3360  
  3361  func BenchmarkCeil(b *testing.B) {
  3362  	x := 0.0
  3363  	for i := 0; i < b.N; i++ {
  3364  		x = Ceil(.5)
  3365  	}
  3366  	GlobalF = x
  3367  }
  3368  
  3369  var copysignNeg = -1.0
  3370  
  3371  func BenchmarkCopysign(b *testing.B) {
  3372  	x := 0.0
  3373  	for i := 0; i < b.N; i++ {
  3374  		x = Copysign(.5, copysignNeg)
  3375  	}
  3376  	GlobalF = x
  3377  }
  3378  
  3379  func BenchmarkCos(b *testing.B) {
  3380  	x := 0.0
  3381  	for i := 0; i < b.N; i++ {
  3382  		x = Cos(.5)
  3383  	}
  3384  	GlobalF = x
  3385  }
  3386  
  3387  func BenchmarkCosh(b *testing.B) {
  3388  	x := 0.0
  3389  	for i := 0; i < b.N; i++ {
  3390  		x = Cosh(2.5)
  3391  	}
  3392  	GlobalF = x
  3393  }
  3394  
  3395  func BenchmarkErf(b *testing.B) {
  3396  	x := 0.0
  3397  	for i := 0; i < b.N; i++ {
  3398  		x = Erf(.5)
  3399  	}
  3400  	GlobalF = x
  3401  }
  3402  
  3403  func BenchmarkErfc(b *testing.B) {
  3404  	x := 0.0
  3405  	for i := 0; i < b.N; i++ {
  3406  		x = Erfc(.5)
  3407  	}
  3408  	GlobalF = x
  3409  }
  3410  
  3411  func BenchmarkErfinv(b *testing.B) {
  3412  	x := 0.0
  3413  	for i := 0; i < b.N; i++ {
  3414  		x = Erfinv(.5)
  3415  	}
  3416  	GlobalF = x
  3417  }
  3418  
  3419  func BenchmarkErfcinv(b *testing.B) {
  3420  	x := 0.0
  3421  	for i := 0; i < b.N; i++ {
  3422  		x = Erfcinv(.5)
  3423  	}
  3424  	GlobalF = x
  3425  }
  3426  
  3427  func BenchmarkExp(b *testing.B) {
  3428  	x := 0.0
  3429  	for i := 0; i < b.N; i++ {
  3430  		x = Exp(.5)
  3431  	}
  3432  	GlobalF = x
  3433  }
  3434  
  3435  func BenchmarkExpGo(b *testing.B) {
  3436  	x := 0.0
  3437  	for i := 0; i < b.N; i++ {
  3438  		x = ExpGo(.5)
  3439  	}
  3440  	GlobalF = x
  3441  }
  3442  
  3443  func BenchmarkExpm1(b *testing.B) {
  3444  	x := 0.0
  3445  	for i := 0; i < b.N; i++ {
  3446  		x = Expm1(.5)
  3447  	}
  3448  	GlobalF = x
  3449  }
  3450  
  3451  func BenchmarkExp2(b *testing.B) {
  3452  	x := 0.0
  3453  	for i := 0; i < b.N; i++ {
  3454  		x = Exp2(.5)
  3455  	}
  3456  	GlobalF = x
  3457  }
  3458  
  3459  func BenchmarkExp2Go(b *testing.B) {
  3460  	x := 0.0
  3461  	for i := 0; i < b.N; i++ {
  3462  		x = Exp2Go(.5)
  3463  	}
  3464  	GlobalF = x
  3465  }
  3466  
  3467  var absPos = .5
  3468  
  3469  func BenchmarkAbs(b *testing.B) {
  3470  	x := 0.0
  3471  	for i := 0; i < b.N; i++ {
  3472  		x = Abs(absPos)
  3473  	}
  3474  	GlobalF = x
  3475  
  3476  }
  3477  
  3478  func BenchmarkDim(b *testing.B) {
  3479  	x := 0.0
  3480  	for i := 0; i < b.N; i++ {
  3481  		x = Dim(GlobalF, x)
  3482  	}
  3483  	GlobalF = x
  3484  }
  3485  
  3486  func BenchmarkFloor(b *testing.B) {
  3487  	x := 0.0
  3488  	for i := 0; i < b.N; i++ {
  3489  		x = Floor(.5)
  3490  	}
  3491  	GlobalF = x
  3492  }
  3493  
  3494  func BenchmarkMax(b *testing.B) {
  3495  	x := 0.0
  3496  	for i := 0; i < b.N; i++ {
  3497  		x = Max(10, 3)
  3498  	}
  3499  	GlobalF = x
  3500  }
  3501  
  3502  func BenchmarkMin(b *testing.B) {
  3503  	x := 0.0
  3504  	for i := 0; i < b.N; i++ {
  3505  		x = Min(10, 3)
  3506  	}
  3507  	GlobalF = x
  3508  }
  3509  
  3510  func BenchmarkMod(b *testing.B) {
  3511  	x := 0.0
  3512  	for i := 0; i < b.N; i++ {
  3513  		x = Mod(10, 3)
  3514  	}
  3515  	GlobalF = x
  3516  }
  3517  
  3518  func BenchmarkFrexp(b *testing.B) {
  3519  	x := 0.0
  3520  	y := 0
  3521  	for i := 0; i < b.N; i++ {
  3522  		x, y = Frexp(8)
  3523  	}
  3524  	GlobalF = x
  3525  	GlobalI = y
  3526  }
  3527  
  3528  func BenchmarkGamma(b *testing.B) {
  3529  	x := 0.0
  3530  	for i := 0; i < b.N; i++ {
  3531  		x = Gamma(2.5)
  3532  	}
  3533  	GlobalF = x
  3534  }
  3535  
  3536  func BenchmarkHypot(b *testing.B) {
  3537  	x := 0.0
  3538  	for i := 0; i < b.N; i++ {
  3539  		x = Hypot(3, 4)
  3540  	}
  3541  	GlobalF = x
  3542  }
  3543  
  3544  func BenchmarkHypotGo(b *testing.B) {
  3545  	x := 0.0
  3546  	for i := 0; i < b.N; i++ {
  3547  		x = HypotGo(3, 4)
  3548  	}
  3549  	GlobalF = x
  3550  }
  3551  
  3552  func BenchmarkIlogb(b *testing.B) {
  3553  	x := 0
  3554  	for i := 0; i < b.N; i++ {
  3555  		x = Ilogb(.5)
  3556  	}
  3557  	GlobalI = x
  3558  }
  3559  
  3560  func BenchmarkJ0(b *testing.B) {
  3561  	x := 0.0
  3562  	for i := 0; i < b.N; i++ {
  3563  		x = J0(2.5)
  3564  	}
  3565  	GlobalF = x
  3566  }
  3567  
  3568  func BenchmarkJ1(b *testing.B) {
  3569  	x := 0.0
  3570  	for i := 0; i < b.N; i++ {
  3571  		x = J1(2.5)
  3572  	}
  3573  	GlobalF = x
  3574  }
  3575  
  3576  func BenchmarkJn(b *testing.B) {
  3577  	x := 0.0
  3578  	for i := 0; i < b.N; i++ {
  3579  		x = Jn(2, 2.5)
  3580  	}
  3581  	GlobalF = x
  3582  }
  3583  
  3584  func BenchmarkLdexp(b *testing.B) {
  3585  	x := 0.0
  3586  	for i := 0; i < b.N; i++ {
  3587  		x = Ldexp(.5, 2)
  3588  	}
  3589  	GlobalF = x
  3590  }
  3591  
  3592  func BenchmarkLgamma(b *testing.B) {
  3593  	x := 0.0
  3594  	y := 0
  3595  	for i := 0; i < b.N; i++ {
  3596  		x, y = Lgamma(2.5)
  3597  	}
  3598  	GlobalF = x
  3599  	GlobalI = y
  3600  }
  3601  
  3602  func BenchmarkLog(b *testing.B) {
  3603  	x := 0.0
  3604  	for i := 0; i < b.N; i++ {
  3605  		x = Log(.5)
  3606  	}
  3607  	GlobalF = x
  3608  }
  3609  
  3610  func BenchmarkLogb(b *testing.B) {
  3611  	x := 0.0
  3612  	for i := 0; i < b.N; i++ {
  3613  		x = Logb(.5)
  3614  	}
  3615  	GlobalF = x
  3616  }
  3617  
  3618  func BenchmarkLog1p(b *testing.B) {
  3619  	x := 0.0
  3620  	for i := 0; i < b.N; i++ {
  3621  		x = Log1p(.5)
  3622  	}
  3623  	GlobalF = x
  3624  }
  3625  
  3626  func BenchmarkLog10(b *testing.B) {
  3627  	x := 0.0
  3628  	for i := 0; i < b.N; i++ {
  3629  		x = Log10(.5)
  3630  	}
  3631  	GlobalF = x
  3632  }
  3633  
  3634  func BenchmarkLog2(b *testing.B) {
  3635  	x := 0.0
  3636  	for i := 0; i < b.N; i++ {
  3637  		x = Log2(.5)
  3638  	}
  3639  	GlobalF += x
  3640  }
  3641  
  3642  func BenchmarkModf(b *testing.B) {
  3643  	x := 0.0
  3644  	y := 0.0
  3645  	for i := 0; i < b.N; i++ {
  3646  		x, y = Modf(1.5)
  3647  	}
  3648  	GlobalF += x
  3649  	GlobalF += y
  3650  }
  3651  
  3652  func BenchmarkNextafter32(b *testing.B) {
  3653  	x := float32(0.0)
  3654  	for i := 0; i < b.N; i++ {
  3655  		x = Nextafter32(.5, 1)
  3656  	}
  3657  	GlobalF = float64(x)
  3658  }
  3659  
  3660  func BenchmarkNextafter64(b *testing.B) {
  3661  	x := 0.0
  3662  	for i := 0; i < b.N; i++ {
  3663  		x = Nextafter(.5, 1)
  3664  	}
  3665  	GlobalF = x
  3666  }
  3667  
  3668  func BenchmarkPowInt(b *testing.B) {
  3669  	x := 0.0
  3670  	for i := 0; i < b.N; i++ {
  3671  		x = Pow(2, 2)
  3672  	}
  3673  	GlobalF = x
  3674  }
  3675  
  3676  func BenchmarkPowFrac(b *testing.B) {
  3677  	x := 0.0
  3678  	for i := 0; i < b.N; i++ {
  3679  		x = Pow(2.5, 1.5)
  3680  	}
  3681  	GlobalF = x
  3682  }
  3683  
  3684  var pow10pos = int(300)
  3685  
  3686  func BenchmarkPow10Pos(b *testing.B) {
  3687  	x := 0.0
  3688  	for i := 0; i < b.N; i++ {
  3689  		x = Pow10(pow10pos)
  3690  	}
  3691  	GlobalF = x
  3692  }
  3693  
  3694  var pow10neg = int(-300)
  3695  
  3696  func BenchmarkPow10Neg(b *testing.B) {
  3697  	x := 0.0
  3698  	for i := 0; i < b.N; i++ {
  3699  		x = Pow10(pow10neg)
  3700  	}
  3701  	GlobalF = x
  3702  }
  3703  
  3704  var roundNeg = float64(-2.5)
  3705  
  3706  func BenchmarkRound(b *testing.B) {
  3707  	x := 0.0
  3708  	for i := 0; i < b.N; i++ {
  3709  		x = Round(roundNeg)
  3710  	}
  3711  	GlobalF = x
  3712  }
  3713  
  3714  func BenchmarkRoundToEven(b *testing.B) {
  3715  	x := 0.0
  3716  	for i := 0; i < b.N; i++ {
  3717  		x = RoundToEven(roundNeg)
  3718  	}
  3719  	GlobalF = x
  3720  }
  3721  
  3722  func BenchmarkRemainder(b *testing.B) {
  3723  	x := 0.0
  3724  	for i := 0; i < b.N; i++ {
  3725  		x = Remainder(10, 3)
  3726  	}
  3727  	GlobalF = x
  3728  }
  3729  
  3730  var signbitPos = 2.5
  3731  
  3732  func BenchmarkSignbit(b *testing.B) {
  3733  	x := false
  3734  	for i := 0; i < b.N; i++ {
  3735  		x = Signbit(signbitPos)
  3736  	}
  3737  	GlobalB = x
  3738  }
  3739  
  3740  func BenchmarkSin(b *testing.B) {
  3741  	x := 0.0
  3742  	for i := 0; i < b.N; i++ {
  3743  		x = Sin(.5)
  3744  	}
  3745  	GlobalF = x
  3746  }
  3747  
  3748  func BenchmarkSincos(b *testing.B) {
  3749  	x := 0.0
  3750  	y := 0.0
  3751  	for i := 0; i < b.N; i++ {
  3752  		x, y = Sincos(.5)
  3753  	}
  3754  	GlobalF += x
  3755  	GlobalF += y
  3756  }
  3757  
  3758  func BenchmarkSinh(b *testing.B) {
  3759  	x := 0.0
  3760  	for i := 0; i < b.N; i++ {
  3761  		x = Sinh(2.5)
  3762  	}
  3763  	GlobalF = x
  3764  }
  3765  
  3766  func BenchmarkSqrtIndirect(b *testing.B) {
  3767  	x, y := 0.0, 10.0
  3768  	f := Sqrt
  3769  	for i := 0; i < b.N; i++ {
  3770  		x += f(y)
  3771  	}
  3772  	GlobalF = x
  3773  }
  3774  
  3775  func BenchmarkSqrtLatency(b *testing.B) {
  3776  	x := 10.0
  3777  	for i := 0; i < b.N; i++ {
  3778  		x = Sqrt(x)
  3779  	}
  3780  	GlobalF = x
  3781  }
  3782  
  3783  func BenchmarkSqrtIndirectLatency(b *testing.B) {
  3784  	x := 10.0
  3785  	f := Sqrt
  3786  	for i := 0; i < b.N; i++ {
  3787  		x = f(x)
  3788  	}
  3789  	GlobalF = x
  3790  }
  3791  
  3792  func BenchmarkSqrtGoLatency(b *testing.B) {
  3793  	x := 10.0
  3794  	for i := 0; i < b.N; i++ {
  3795  		x = SqrtGo(x)
  3796  	}
  3797  	GlobalF = x
  3798  }
  3799  
  3800  func isPrime(i int) bool {
  3801  	// Yes, this is a dumb way to write this code,
  3802  	// but calling Sqrt repeatedly in this way demonstrates
  3803  	// the benefit of using a direct SQRT instruction on systems
  3804  	// that have one, whereas the obvious loop seems not to
  3805  	// demonstrate such a benefit.
  3806  	for j := 2; float64(j) <= Sqrt(float64(i)); j++ {
  3807  		if i%j == 0 {
  3808  			return false
  3809  		}
  3810  	}
  3811  	return true
  3812  }
  3813  
  3814  func BenchmarkSqrtPrime(b *testing.B) {
  3815  	x := false
  3816  	for i := 0; i < b.N; i++ {
  3817  		x = isPrime(100003)
  3818  	}
  3819  	GlobalB = x
  3820  }
  3821  
  3822  func BenchmarkTan(b *testing.B) {
  3823  	x := 0.0
  3824  	for i := 0; i < b.N; i++ {
  3825  		x = Tan(.5)
  3826  	}
  3827  	GlobalF = x
  3828  }
  3829  
  3830  func BenchmarkTanh(b *testing.B) {
  3831  	x := 0.0
  3832  	for i := 0; i < b.N; i++ {
  3833  		x = Tanh(2.5)
  3834  	}
  3835  	GlobalF = x
  3836  }
  3837  func BenchmarkTrunc(b *testing.B) {
  3838  	x := 0.0
  3839  	for i := 0; i < b.N; i++ {
  3840  		x = Trunc(.5)
  3841  	}
  3842  	GlobalF = x
  3843  }
  3844  
  3845  func BenchmarkY0(b *testing.B) {
  3846  	x := 0.0
  3847  	for i := 0; i < b.N; i++ {
  3848  		x = Y0(2.5)
  3849  	}
  3850  	GlobalF = x
  3851  }
  3852  
  3853  func BenchmarkY1(b *testing.B) {
  3854  	x := 0.0
  3855  	for i := 0; i < b.N; i++ {
  3856  		x = Y1(2.5)
  3857  	}
  3858  	GlobalF = x
  3859  }
  3860  
  3861  func BenchmarkYn(b *testing.B) {
  3862  	x := 0.0
  3863  	for i := 0; i < b.N; i++ {
  3864  		x = Yn(2, 2.5)
  3865  	}
  3866  	GlobalF = x
  3867  }
  3868  
  3869  func BenchmarkFloat64bits(b *testing.B) {
  3870  	y := uint64(0)
  3871  	for i := 0; i < b.N; i++ {
  3872  		y = Float64bits(roundNeg)
  3873  	}
  3874  	GlobalI = int(y)
  3875  }
  3876  
  3877  var roundUint64 = uint64(5)
  3878  
  3879  func BenchmarkFloat64frombits(b *testing.B) {
  3880  	x := 0.0
  3881  	for i := 0; i < b.N; i++ {
  3882  		x = Float64frombits(roundUint64)
  3883  	}
  3884  	GlobalF = x
  3885  }
  3886  
  3887  var roundFloat32 = float32(-2.5)
  3888  
  3889  func BenchmarkFloat32bits(b *testing.B) {
  3890  	y := uint32(0)
  3891  	for i := 0; i < b.N; i++ {
  3892  		y = Float32bits(roundFloat32)
  3893  	}
  3894  	GlobalI = int(y)
  3895  }
  3896  
  3897  var roundUint32 = uint32(5)
  3898  
  3899  func BenchmarkFloat32frombits(b *testing.B) {
  3900  	x := float32(0.0)
  3901  	for i := 0; i < b.N; i++ {
  3902  		x = Float32frombits(roundUint32)
  3903  	}
  3904  	GlobalF = float64(x)
  3905  }
  3906  
  3907  func BenchmarkFMA(b *testing.B) {
  3908  	x := 0.0
  3909  	for i := 0; i < b.N; i++ {
  3910  		x = FMA(E, Pi, x)
  3911  	}
  3912  	GlobalF = x
  3913  }
  3914  

View as plain text