Black Lives Matter. Support the Equal Justice Initiative.

# Source file src/math/all_test.go

## Documentation: math

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

View as plain text