Source file src/math/all_test.go

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

View as plain text