...
Run Format

Source file src/math/all_test.go

Documentation: math

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

View as plain text