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