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
1557 var vflog2NearOne = []float64{
1558 0x1.0000000000001p+0,
1559 0x1.fffffffffffffp-1,
1560 0x1.0000000001p+0,
1561 0x1.fffffffffep-1,
1562 0x1.00001p+0,
1563 0x1.ffffep-1,
1564 0x1.004p+0,
1565 0x1.ff8p-1,
1566 0x1.4p+0,
1567 0x1.8p-1,
1568 0x1.fffffffffffffp+0,
1569 0x1.0000000000001p-1,
1570 }
1571 var log2NearOne = []float64{
1572 3.203426503814917e-16,
1573 -1.6017132519074588e-16,
1574 1.3121234959619935e-12,
1575 -1.312123495963187e-12,
1576 1.375860550841138e-06,
1577 -1.3758618629646341e-06,
1578 0.0014081943928083889,
1579 -0.0014095702546713536,
1580 0.32192809488736235,
1581 -0.4150374992788438,
1582 0.9999999999999999,
1583 -0.9999999999999997,
1584 }
1585
1586 var vflogbSC = []float64{
1587 Inf(-1),
1588 0,
1589 Inf(1),
1590 NaN(),
1591 }
1592 var logbSC = []float64{
1593 Inf(1),
1594 Inf(-1),
1595 Inf(1),
1596 NaN(),
1597 }
1598
1599 var vflog1pSC = []float64{
1600 Inf(-1),
1601 -Pi,
1602 -1,
1603 Copysign(0, -1),
1604 0,
1605 Inf(1),
1606 NaN(),
1607 4503599627370496.5,
1608 }
1609 var log1pSC = []float64{
1610 NaN(),
1611 NaN(),
1612 Inf(-1),
1613 Copysign(0, -1),
1614 0,
1615 Inf(1),
1616 NaN(),
1617 36.04365338911715,
1618 }
1619
1620 var vfmodfSC = []float64{
1621 Inf(-1),
1622 Copysign(0, -1),
1623 Inf(1),
1624 NaN(),
1625 }
1626 var modfSC = [][2]float64{
1627 {Inf(-1), NaN()},
1628 {Copysign(0, -1), Copysign(0, -1)},
1629 {Inf(1), NaN()},
1630 {NaN(), NaN()},
1631 }
1632
1633 var vfnextafter32SC = [][2]float32{
1634 {0, 0},
1635 {0, float32(Copysign(0, -1))},
1636 {0, -1},
1637 {0, float32(NaN())},
1638 {float32(Copysign(0, -1)), 1},
1639 {float32(Copysign(0, -1)), 0},
1640 {float32(Copysign(0, -1)), float32(Copysign(0, -1))},
1641 {float32(Copysign(0, -1)), -1},
1642 {float32(NaN()), 0},
1643 {float32(NaN()), float32(NaN())},
1644 }
1645 var nextafter32SC = []float32{
1646 0,
1647 0,
1648 -1.401298464e-45,
1649 float32(NaN()),
1650 1.401298464e-45,
1651 float32(Copysign(0, -1)),
1652 float32(Copysign(0, -1)),
1653 -1.401298464e-45,
1654 float32(NaN()),
1655 float32(NaN()),
1656 }
1657
1658 var vfnextafter64SC = [][2]float64{
1659 {0, 0},
1660 {0, Copysign(0, -1)},
1661 {0, -1},
1662 {0, NaN()},
1663 {Copysign(0, -1), 1},
1664 {Copysign(0, -1), 0},
1665 {Copysign(0, -1), Copysign(0, -1)},
1666 {Copysign(0, -1), -1},
1667 {NaN(), 0},
1668 {NaN(), NaN()},
1669 }
1670 var nextafter64SC = []float64{
1671 0,
1672 0,
1673 -4.9406564584124654418e-324,
1674 NaN(),
1675 4.9406564584124654418e-324,
1676 Copysign(0, -1),
1677 Copysign(0, -1),
1678 -4.9406564584124654418e-324,
1679 NaN(),
1680 NaN(),
1681 }
1682
1683 var vfpowSC = [][2]float64{
1684 {Inf(-1), -Pi},
1685 {Inf(-1), -3},
1686 {Inf(-1), Copysign(0, -1)},
1687 {Inf(-1), 0},
1688 {Inf(-1), 1},
1689 {Inf(-1), 3},
1690 {Inf(-1), Pi},
1691 {Inf(-1), 0.5},
1692 {Inf(-1), NaN()},
1693
1694 {-Pi, Inf(-1)},
1695 {-Pi, -Pi},
1696 {-Pi, Copysign(0, -1)},
1697 {-Pi, 0},
1698 {-Pi, 1},
1699 {-Pi, Pi},
1700 {-Pi, Inf(1)},
1701 {-Pi, NaN()},
1702
1703 {-1, Inf(-1)},
1704 {-1, Inf(1)},
1705 {-1, NaN()},
1706 {-0.5, Inf(-1)},
1707 {-0.5, Inf(1)},
1708 {Copysign(0, -1), Inf(-1)},
1709 {Copysign(0, -1), -Pi},
1710 {Copysign(0, -1), -0.5},
1711 {Copysign(0, -1), -3},
1712 {Copysign(0, -1), 3},
1713 {Copysign(0, -1), Pi},
1714 {Copysign(0, -1), 0.5},
1715 {Copysign(0, -1), Inf(1)},
1716
1717 {0, Inf(-1)},
1718 {0, -Pi},
1719 {0, -3},
1720 {0, Copysign(0, -1)},
1721 {0, 0},
1722 {0, 3},
1723 {0, Pi},
1724 {0, Inf(1)},
1725 {0, NaN()},
1726
1727 {0.5, Inf(-1)},
1728 {0.5, Inf(1)},
1729 {1, Inf(-1)},
1730 {1, Inf(1)},
1731 {1, NaN()},
1732
1733 {Pi, Inf(-1)},
1734 {Pi, Copysign(0, -1)},
1735 {Pi, 0},
1736 {Pi, 1},
1737 {Pi, Inf(1)},
1738 {Pi, NaN()},
1739 {Inf(1), -Pi},
1740 {Inf(1), Copysign(0, -1)},
1741 {Inf(1), 0},
1742 {Inf(1), 1},
1743 {Inf(1), Pi},
1744 {Inf(1), NaN()},
1745 {NaN(), -Pi},
1746 {NaN(), Copysign(0, -1)},
1747 {NaN(), 0},
1748 {NaN(), 1},
1749 {NaN(), Pi},
1750 {NaN(), NaN()},
1751
1752
1753 {2, float64(1 << 32)},
1754 {2, -float64(1 << 32)},
1755 {-2, float64(1<<32 + 1)},
1756 {0.5, float64(1 << 45)},
1757 {0.5, -float64(1 << 45)},
1758 {Nextafter(1, 2), float64(1 << 63)},
1759 {Nextafter(1, -2), float64(1 << 63)},
1760 {Nextafter(-1, 2), float64(1 << 63)},
1761 {Nextafter(-1, -2), float64(1 << 63)},
1762
1763
1764 {Copysign(0, -1), 1e19},
1765 {Copysign(0, -1), -1e19},
1766 {Copysign(0, -1), 1<<53 - 1},
1767 {Copysign(0, -1), -(1<<53 - 1)},
1768 }
1769 var powSC = []float64{
1770 0,
1771 Copysign(0, -1),
1772 1,
1773 1,
1774 Inf(-1),
1775 Inf(-1),
1776 Inf(1),
1777 Inf(1),
1778 NaN(),
1779 0,
1780 NaN(),
1781 1,
1782 1,
1783 -Pi,
1784 NaN(),
1785 Inf(1),
1786 NaN(),
1787 1,
1788 1,
1789 NaN(),
1790 Inf(1),
1791 0,
1792 Inf(1),
1793 Inf(1),
1794 Inf(1),
1795 Inf(-1),
1796 Copysign(0, -1),
1797 0,
1798 0,
1799 0,
1800 Inf(1),
1801 Inf(1),
1802 Inf(1),
1803 1,
1804 1,
1805 0,
1806 0,
1807 0,
1808 NaN(),
1809 Inf(1),
1810 0,
1811 1,
1812 1,
1813 1,
1814 0,
1815 1,
1816 1,
1817 Pi,
1818 Inf(1),
1819 NaN(),
1820 0,
1821 1,
1822 1,
1823 Inf(1),
1824 Inf(1),
1825 NaN(),
1826 NaN(),
1827 1,
1828 1,
1829 NaN(),
1830 NaN(),
1831 NaN(),
1832
1833
1834 Inf(1),
1835 0,
1836 Inf(-1),
1837 0,
1838 Inf(1),
1839 Inf(1),
1840 0,
1841 0,
1842 Inf(1),
1843
1844
1845 0,
1846 Inf(1),
1847 Copysign(0, -1),
1848 Inf(-1),
1849 }
1850
1851 var vfpow10SC = []int{
1852 MinInt32,
1853 -324,
1854 -323,
1855 -50,
1856 -22,
1857 -1,
1858 0,
1859 1,
1860 22,
1861 50,
1862 100,
1863 200,
1864 308,
1865 309,
1866 MaxInt32,
1867 }
1868
1869 var pow10SC = []float64{
1870 0,
1871 0,
1872 1.0e-323,
1873 1.0e-50,
1874 1.0e-22,
1875 1.0e-1,
1876 1.0e0,
1877 1.0e1,
1878 1.0e22,
1879 1.0e50,
1880 1.0e100,
1881 1.0e200,
1882 1.0e308,
1883 Inf(1),
1884 Inf(1),
1885 }
1886
1887 var vfroundSC = [][2]float64{
1888 {0, 0},
1889 {1.390671161567e-309, 0},
1890 {0.49999999999999994, 0},
1891 {0.5, 1},
1892 {0.5000000000000001, 1},
1893 {-1.5, -2},
1894 {-2.5, -3},
1895 {NaN(), NaN()},
1896 {Inf(1), Inf(1)},
1897 {2251799813685249.5, 2251799813685250},
1898 {2251799813685250.5, 2251799813685251},
1899 {4503599627370495.5, 4503599627370496},
1900 {4503599627370497, 4503599627370497},
1901 }
1902 var vfroundEvenSC = [][2]float64{
1903 {0, 0},
1904 {1.390671161567e-309, 0},
1905 {0.49999999999999994, 0},
1906 {0.5, 0},
1907 {0.5000000000000001, 1},
1908 {-1.5, -2},
1909 {-2.5, -2},
1910 {NaN(), NaN()},
1911 {Inf(1), Inf(1)},
1912 {2251799813685249.5, 2251799813685250},
1913 {2251799813685250.5, 2251799813685250},
1914 {4503599627370495.5, 4503599627370496},
1915 {4503599627370497, 4503599627370497},
1916 }
1917
1918 var vfsignbitSC = []float64{
1919 Inf(-1),
1920 Copysign(0, -1),
1921 0,
1922 Inf(1),
1923 NaN(),
1924 }
1925 var signbitSC = []bool{
1926 true,
1927 true,
1928 false,
1929 false,
1930 false,
1931 }
1932
1933 var vfsinSC = []float64{
1934 Inf(-1),
1935 Copysign(0, -1),
1936 0,
1937 Inf(1),
1938 NaN(),
1939 }
1940 var sinSC = []float64{
1941 NaN(),
1942 Copysign(0, -1),
1943 0,
1944 NaN(),
1945 NaN(),
1946 }
1947
1948 var vfsinhSC = []float64{
1949 Inf(-1),
1950 Copysign(0, -1),
1951 0,
1952 Inf(1),
1953 NaN(),
1954 }
1955 var sinhSC = []float64{
1956 Inf(-1),
1957 Copysign(0, -1),
1958 0,
1959 Inf(1),
1960 NaN(),
1961 }
1962
1963 var vfsqrtSC = []float64{
1964 Inf(-1),
1965 -Pi,
1966 Copysign(0, -1),
1967 0,
1968 Inf(1),
1969 NaN(),
1970 Float64frombits(2),
1971 }
1972 var sqrtSC = []float64{
1973 NaN(),
1974 NaN(),
1975 Copysign(0, -1),
1976 0,
1977 Inf(1),
1978 NaN(),
1979 3.1434555694052576e-162,
1980 }
1981
1982 var vftanhSC = []float64{
1983 Inf(-1),
1984 Copysign(0, -1),
1985 0,
1986 Inf(1),
1987 NaN(),
1988 }
1989 var tanhSC = []float64{
1990 -1,
1991 Copysign(0, -1),
1992 0,
1993 1,
1994 NaN(),
1995 }
1996
1997 var vfy0SC = []float64{
1998 Inf(-1),
1999 0,
2000 Inf(1),
2001 NaN(),
2002 -1,
2003 }
2004 var y0SC = []float64{
2005 NaN(),
2006 Inf(-1),
2007 0,
2008 NaN(),
2009 NaN(),
2010 }
2011 var y1SC = []float64{
2012 NaN(),
2013 Inf(-1),
2014 0,
2015 NaN(),
2016 NaN(),
2017 }
2018 var y2SC = []float64{
2019 NaN(),
2020 Inf(-1),
2021 0,
2022 NaN(),
2023 NaN(),
2024 }
2025 var yM3SC = []float64{
2026 NaN(),
2027 Inf(1),
2028 0,
2029 NaN(),
2030 NaN(),
2031 }
2032
2033
2034 const (
2035 SmallestNormalFloat64 = 2.2250738585072014e-308
2036 LargestSubnormalFloat64 = SmallestNormalFloat64 - SmallestNonzeroFloat64
2037 )
2038
2039 var vffrexpBC = []float64{
2040 SmallestNormalFloat64,
2041 LargestSubnormalFloat64,
2042 SmallestNonzeroFloat64,
2043 MaxFloat64,
2044 -SmallestNormalFloat64,
2045 -LargestSubnormalFloat64,
2046 -SmallestNonzeroFloat64,
2047 -MaxFloat64,
2048 }
2049 var frexpBC = []fi{
2050 {0.5, -1021},
2051 {0.99999999999999978, -1022},
2052 {0.5, -1073},
2053 {0.99999999999999989, 1024},
2054 {-0.5, -1021},
2055 {-0.99999999999999978, -1022},
2056 {-0.5, -1073},
2057 {-0.99999999999999989, 1024},
2058 }
2059
2060 var vfldexpBC = []fi{
2061 {SmallestNormalFloat64, -52},
2062 {LargestSubnormalFloat64, -51},
2063 {SmallestNonzeroFloat64, 1074},
2064 {MaxFloat64, -(1023 + 1074)},
2065 {1, -1075},
2066 {-1, -1075},
2067 {1, 1024},
2068 {-1, 1024},
2069 {1.0000000000000002, -1075},
2070 {1, -1075},
2071 }
2072 var ldexpBC = []float64{
2073 SmallestNonzeroFloat64,
2074 1e-323,
2075 1,
2076 1e-323,
2077 0,
2078 Copysign(0, -1),
2079 Inf(1),
2080 Inf(-1),
2081 SmallestNonzeroFloat64,
2082 0,
2083 }
2084
2085 var logbBC = []float64{
2086 -1022,
2087 -1023,
2088 -1074,
2089 1023,
2090 -1022,
2091 -1023,
2092 -1074,
2093 1023,
2094 }
2095
2096
2097
2098
2099 var fmaC = []struct{ x, y, z, want float64 }{
2100
2101 {-3.999999999999087, -1.1123914289620494e-16, -7.999877929687506, -7.999877929687505},
2102 {-262112.0000004768, -0.06251525855623184, 1.1102230248837136e-16, 16385.99945072085},
2103 {-6.462348523533467e-27, -2.3763644720331857e-211, 4.000000000931324, 4.000000000931324},
2104
2105
2106 {-2.0000000037252907, 6.7904383376e-313, -3.3951933161e-313, -1.697607001654e-312},
2107 {-0.12499999999999999, 512.007568359375, -1.4193627164960366e-16, -64.00094604492188},
2108 {-2.7550648847397148e-39, -3.4028301595800694e+38, 0.9960937495343386, 1.9335955376735676},
2109 {5.723369164769208e+24, 3.8149300927159385e-06, 1.84489958778182e+19, 4.028324913621874e+19},
2110 {-0.4843749999990904, -3.6893487872543293e+19, 9.223653786709391e+18, 2.7093936974938993e+19},
2111 {-3.8146972665201165e-06, 4.2949672959999385e+09, -2.2204460489938386e-16, -16384.000003844263},
2112 {6.98156394130982e-309, -1.1072962560000002e+09, -4.4414561548793455e-308, -7.73065965765153e-300},
2113
2114
2115 {5e-324, 4.5, -2e-323, 0},
2116 {5e-324, 7, -3.5e-323, 0},
2117 {5e-324, 0.5000000000000001, -5e-324, Copysign(0, -1)},
2118 {-2.1240680525e-314, -1.233647078189316e+308, -0.25781249999954525, -0.25780987964919844},
2119 {8.579992955364441e-308, 0.6037391876780558, -4.4501307410480706e-308, 7.29947236107098e-309},
2120 {-4.450143471986689e-308, -0.9960937499927239, -4.450419332475649e-308, -1.7659233458788e-310},
2121 {1.4932076393918112, -2.2248022430460833e-308, 4.449875571054211e-308, 1.127783865601762e-308},
2122
2123
2124 {-2.288020632214759e+38, -8.98846570988901e+307, 1.7696041796300924e+308, Inf(0)},
2125 {1.4888652783208255e+308, -9.007199254742012e+15, -6.807282911929205e+38, Inf(-1)},
2126 {9.142703268902826e+192, -1.3504889569802838e+296, -1.9082200803806996e-89, Inf(-1)},
2127
2128
2129 {31.99218749627471, -1.7976930544991702e+308, Inf(0), Inf(0)},
2130 {-1.7976931281784667e+308, -2.0009765625002265, Inf(-1), Inf(-1)},
2131
2132
2133 {0, 0, 0, 0},
2134 {Copysign(0, -1), 0, 0, 0},
2135 {0, 0, Copysign(0, -1), 0},
2136 {Copysign(0, -1), 0, Copysign(0, -1), Copysign(0, -1)},
2137 {-1.1754226043408471e-38, NaN(), Inf(0), NaN()},
2138 {0, 0, 2.22507385643494e-308, 2.22507385643494e-308},
2139 {-8.65697792e+09, NaN(), -7.516192799999999e+09, NaN()},
2140 {-0.00012207403779029757, 3.221225471996093e+09, NaN(), NaN()},
2141 {Inf(-1), 0.1252441407414153, -1.387184532981584e-76, Inf(-1)},
2142 {Inf(0), 1.525878907671432e-05, -9.214364835452549e+18, Inf(0)},
2143
2144
2145 {0.1777916152213626, -32.000015266239636, -2.2204459148334633e-16, -5.689334401293007},
2146 {-2.0816681711722314e-16, -0.4997558592585846, -0.9465627129124969, -0.9465627129124968},
2147 {-1.9999997615814211, 1.8518819259933516e+19, 16.874999999999996, -3.703763410463646e+19},
2148 {-0.12499994039717421, 32767.99999976135, -2.0752587082923246e+19, -2.075258708292325e+19},
2149 {7.705600568510257e-34, -1.801432979000528e+16, -0.17224197722973714, -0.17224197722973716},
2150 {3.8988133103758913e-308, -0.9848632812499999, 3.893879244098556e-308, 5.40811742605814e-310},
2151 {-0.012651981190687427, 6.911985574912436e+38, 6.669240527007144e+18, -8.745031148409496e+36},
2152 {4.612811918325842e+18, 1.4901161193847641e-08, 2.6077032311277997e-08, 6.873625395187494e+10},
2153 {-9.094947033611148e-13, 4.450691014249257e-308, 2.086006742350485e-308, 2.086006742346437e-308},
2154 {-7.751454006381804e-05, 5.588653777189071e-308, -2.2207280111272877e-308, -2.2211612130544025e-308},
2155
2156
2157 {-1, 1, 1, 0},
2158 {1, 1, -1, 0},
2159
2160
2161 {0x1p-1022, -0x1p-1022, 0, Copysign(0, -1)},
2162 {Copysign(0, -1), 1, 0, 0},
2163 {1, Copysign(0, -1), 0, 0},
2164 }
2165
2166 var sqrt32 = []float32{
2167 0,
2168 float32(Copysign(0, -1)),
2169 float32(NaN()),
2170 float32(Inf(1)),
2171 float32(Inf(-1)),
2172 1,
2173 2,
2174 -2,
2175 4.9790119248836735e+00,
2176 7.7388724745781045e+00,
2177 -2.7688005719200159e-01,
2178 -5.0106036182710749e+00,
2179 }
2180
2181 func tolerance(a, b, e float64) bool {
2182
2183
2184
2185 if a == b {
2186 return true
2187 }
2188 d := a - b
2189 if d < 0 {
2190 d = -d
2191 }
2192
2193
2194
2195 if b != 0 {
2196 e = e * b
2197 if e < 0 {
2198 e = -e
2199 }
2200 }
2201 return d < e
2202 }
2203 func close(a, b float64) bool { return tolerance(a, b, 1e-14) }
2204 func veryclose(a, b float64) bool { return tolerance(a, b, 4e-16) }
2205 func soclose(a, b, e float64) bool { return tolerance(a, b, e) }
2206 func alike(a, b float64) bool {
2207 switch {
2208 case IsNaN(a) && IsNaN(b):
2209 return true
2210 case a == b:
2211 return Signbit(a) == Signbit(b)
2212 }
2213 return false
2214 }
2215
2216 func TestNaN(t *testing.T) {
2217 f64 := NaN()
2218 if f64 == f64 {
2219 t.Fatalf("NaN() returns %g, expected NaN", f64)
2220 }
2221 f32 := float32(f64)
2222 if f32 == f32 {
2223 t.Fatalf("float32(NaN()) is %g, expected NaN", f32)
2224 }
2225 }
2226
2227 func TestAcos(t *testing.T) {
2228 for i := 0; i < len(vf); i++ {
2229 a := vf[i] / 10
2230 if f := Acos(a); !close(acos[i], f) {
2231 t.Errorf("Acos(%g) = %g, want %g", a, f, acos[i])
2232 }
2233 }
2234 for i := 0; i < len(vfacosSC); i++ {
2235 if f := Acos(vfacosSC[i]); !alike(acosSC[i], f) {
2236 t.Errorf("Acos(%g) = %g, want %g", vfacosSC[i], f, acosSC[i])
2237 }
2238 }
2239 }
2240
2241 func TestAcosh(t *testing.T) {
2242 for i := 0; i < len(vf); i++ {
2243 a := 1 + Abs(vf[i])
2244 if f := Acosh(a); !veryclose(acosh[i], f) {
2245 t.Errorf("Acosh(%g) = %g, want %g", a, f, acosh[i])
2246 }
2247 }
2248 for i := 0; i < len(vfacoshSC); i++ {
2249 if f := Acosh(vfacoshSC[i]); !alike(acoshSC[i], f) {
2250 t.Errorf("Acosh(%g) = %g, want %g", vfacoshSC[i], f, acoshSC[i])
2251 }
2252 }
2253 }
2254
2255 func TestAsin(t *testing.T) {
2256 for i := 0; i < len(vf); i++ {
2257 a := vf[i] / 10
2258 if f := Asin(a); !veryclose(asin[i], f) {
2259 t.Errorf("Asin(%g) = %g, want %g", a, f, asin[i])
2260 }
2261 }
2262 for i := 0; i < len(vfasinSC); i++ {
2263 if f := Asin(vfasinSC[i]); !alike(asinSC[i], f) {
2264 t.Errorf("Asin(%g) = %g, want %g", vfasinSC[i], f, asinSC[i])
2265 }
2266 }
2267 }
2268
2269 func TestAsinh(t *testing.T) {
2270 for i := 0; i < len(vf); i++ {
2271 if f := Asinh(vf[i]); !veryclose(asinh[i], f) {
2272 t.Errorf("Asinh(%g) = %g, want %g", vf[i], f, asinh[i])
2273 }
2274 }
2275 for i := 0; i < len(vfasinhSC); i++ {
2276 if f := Asinh(vfasinhSC[i]); !alike(asinhSC[i], f) {
2277 t.Errorf("Asinh(%g) = %g, want %g", vfasinhSC[i], f, asinhSC[i])
2278 }
2279 }
2280 }
2281
2282 func TestAtan(t *testing.T) {
2283 for i := 0; i < len(vf); i++ {
2284 if f := Atan(vf[i]); !veryclose(atan[i], f) {
2285 t.Errorf("Atan(%g) = %g, want %g", vf[i], f, atan[i])
2286 }
2287 }
2288 for i := 0; i < len(vfatanSC); i++ {
2289 if f := Atan(vfatanSC[i]); !alike(atanSC[i], f) {
2290 t.Errorf("Atan(%g) = %g, want %g", vfatanSC[i], f, atanSC[i])
2291 }
2292 }
2293 }
2294
2295 func TestAtanh(t *testing.T) {
2296 for i := 0; i < len(vf); i++ {
2297 a := vf[i] / 10
2298 if f := Atanh(a); !veryclose(atanh[i], f) {
2299 t.Errorf("Atanh(%g) = %g, want %g", a, f, atanh[i])
2300 }
2301 }
2302 for i := 0; i < len(vfatanhSC); i++ {
2303 if f := Atanh(vfatanhSC[i]); !alike(atanhSC[i], f) {
2304 t.Errorf("Atanh(%g) = %g, want %g", vfatanhSC[i], f, atanhSC[i])
2305 }
2306 }
2307 }
2308
2309 func TestAtan2(t *testing.T) {
2310 for i := 0; i < len(vf); i++ {
2311 if f := Atan2(10, vf[i]); !veryclose(atan2[i], f) {
2312 t.Errorf("Atan2(10, %g) = %g, want %g", vf[i], f, atan2[i])
2313 }
2314 }
2315 for i := 0; i < len(vfatan2SC); i++ {
2316 if f := Atan2(vfatan2SC[i][0], vfatan2SC[i][1]); !alike(atan2SC[i], f) {
2317 t.Errorf("Atan2(%g, %g) = %g, want %g", vfatan2SC[i][0], vfatan2SC[i][1], f, atan2SC[i])
2318 }
2319 }
2320 }
2321
2322 func TestCbrt(t *testing.T) {
2323 for i := 0; i < len(vf); i++ {
2324 if f := Cbrt(vf[i]); !veryclose(cbrt[i], f) {
2325 t.Errorf("Cbrt(%g) = %g, want %g", vf[i], f, cbrt[i])
2326 }
2327 }
2328 for i := 0; i < len(vfcbrtSC); i++ {
2329 if f := Cbrt(vfcbrtSC[i]); !alike(cbrtSC[i], f) {
2330 t.Errorf("Cbrt(%g) = %g, want %g", vfcbrtSC[i], f, cbrtSC[i])
2331 }
2332 }
2333 }
2334
2335 func TestCeil(t *testing.T) {
2336 for i := 0; i < len(vf); i++ {
2337 if f := Ceil(vf[i]); !alike(ceil[i], f) {
2338 t.Errorf("Ceil(%g) = %g, want %g", vf[i], f, ceil[i])
2339 }
2340 }
2341 for i := 0; i < len(vfceilSC); i++ {
2342 if f := Ceil(vfceilSC[i]); !alike(ceilSC[i], f) {
2343 t.Errorf("Ceil(%g) = %g, want %g", vfceilSC[i], f, ceilSC[i])
2344 }
2345 }
2346 }
2347
2348 func TestCopysign(t *testing.T) {
2349 for i := 0; i < len(vf); i++ {
2350 if f := Copysign(vf[i], -1); copysign[i] != f {
2351 t.Errorf("Copysign(%g, -1) = %g, want %g", vf[i], f, copysign[i])
2352 }
2353 }
2354 for i := 0; i < len(vf); i++ {
2355 if f := Copysign(vf[i], 1); -copysign[i] != f {
2356 t.Errorf("Copysign(%g, 1) = %g, want %g", vf[i], f, -copysign[i])
2357 }
2358 }
2359 for i := 0; i < len(vfcopysignSC); i++ {
2360 if f := Copysign(vfcopysignSC[i], -1); !alike(copysignSC[i], f) {
2361 t.Errorf("Copysign(%g, -1) = %g, want %g", vfcopysignSC[i], f, copysignSC[i])
2362 }
2363 }
2364 }
2365
2366 func TestCos(t *testing.T) {
2367 for i := 0; i < len(vf); i++ {
2368 if f := Cos(vf[i]); !veryclose(cos[i], f) {
2369 t.Errorf("Cos(%g) = %g, want %g", vf[i], f, cos[i])
2370 }
2371 }
2372 for i := 0; i < len(vfcosSC); i++ {
2373 if f := Cos(vfcosSC[i]); !alike(cosSC[i], f) {
2374 t.Errorf("Cos(%g) = %g, want %g", vfcosSC[i], f, cosSC[i])
2375 }
2376 }
2377 }
2378
2379 func TestCosh(t *testing.T) {
2380 for i := 0; i < len(vf); i++ {
2381 if f := Cosh(vf[i]); !close(cosh[i], f) {
2382 t.Errorf("Cosh(%g) = %g, want %g", vf[i], f, cosh[i])
2383 }
2384 }
2385 for i := 0; i < len(vfcoshSC); i++ {
2386 if f := Cosh(vfcoshSC[i]); !alike(coshSC[i], f) {
2387 t.Errorf("Cosh(%g) = %g, want %g", vfcoshSC[i], f, coshSC[i])
2388 }
2389 }
2390 }
2391
2392 func TestErf(t *testing.T) {
2393 for i := 0; i < len(vf); i++ {
2394 a := vf[i] / 10
2395 if f := Erf(a); !veryclose(erf[i], f) {
2396 t.Errorf("Erf(%g) = %g, want %g", a, f, erf[i])
2397 }
2398 }
2399 for i := 0; i < len(vferfSC); i++ {
2400 if f := Erf(vferfSC[i]); !alike(erfSC[i], f) {
2401 t.Errorf("Erf(%g) = %g, want %g", vferfSC[i], f, erfSC[i])
2402 }
2403 }
2404 }
2405
2406 func TestErfc(t *testing.T) {
2407 for i := 0; i < len(vf); i++ {
2408 a := vf[i] / 10
2409 if f := Erfc(a); !veryclose(erfc[i], f) {
2410 t.Errorf("Erfc(%g) = %g, want %g", a, f, erfc[i])
2411 }
2412 }
2413 for i := 0; i < len(vferfcSC); i++ {
2414 if f := Erfc(vferfcSC[i]); !alike(erfcSC[i], f) {
2415 t.Errorf("Erfc(%g) = %g, want %g", vferfcSC[i], f, erfcSC[i])
2416 }
2417 }
2418 }
2419
2420 func TestErfinv(t *testing.T) {
2421 for i := 0; i < len(vf); i++ {
2422 a := vf[i] / 10
2423 if f := Erfinv(a); !veryclose(erfinv[i], f) {
2424 t.Errorf("Erfinv(%g) = %g, want %g", a, f, erfinv[i])
2425 }
2426 }
2427 for i := 0; i < len(vferfinvSC); i++ {
2428 if f := Erfinv(vferfinvSC[i]); !alike(erfinvSC[i], f) {
2429 t.Errorf("Erfinv(%g) = %g, want %g", vferfinvSC[i], f, erfinvSC[i])
2430 }
2431 }
2432 for x := -0.9; x <= 0.90; x += 1e-2 {
2433 if f := Erf(Erfinv(x)); !close(x, f) {
2434 t.Errorf("Erf(Erfinv(%g)) = %g, want %g", x, f, x)
2435 }
2436 }
2437 for x := -0.9; x <= 0.90; x += 1e-2 {
2438 if f := Erfinv(Erf(x)); !close(x, f) {
2439 t.Errorf("Erfinv(Erf(%g)) = %g, want %g", x, f, x)
2440 }
2441 }
2442 }
2443
2444 func TestErfcinv(t *testing.T) {
2445 for i := 0; i < len(vf); i++ {
2446 a := 1.0 - (vf[i] / 10)
2447 if f := Erfcinv(a); !veryclose(erfinv[i], f) {
2448 t.Errorf("Erfcinv(%g) = %g, want %g", a, f, erfinv[i])
2449 }
2450 }
2451 for i := 0; i < len(vferfcinvSC); i++ {
2452 if f := Erfcinv(vferfcinvSC[i]); !alike(erfcinvSC[i], f) {
2453 t.Errorf("Erfcinv(%g) = %g, want %g", vferfcinvSC[i], f, erfcinvSC[i])
2454 }
2455 }
2456 for x := 0.1; x <= 1.9; x += 1e-2 {
2457 if f := Erfc(Erfcinv(x)); !close(x, f) {
2458 t.Errorf("Erfc(Erfcinv(%g)) = %g, want %g", x, f, x)
2459 }
2460 }
2461 for x := 0.1; x <= 1.9; x += 1e-2 {
2462 if f := Erfcinv(Erfc(x)); !close(x, f) {
2463 t.Errorf("Erfcinv(Erfc(%g)) = %g, want %g", x, f, x)
2464 }
2465 }
2466 }
2467
2468 func TestExp(t *testing.T) {
2469 testExp(t, Exp, "Exp")
2470 testExp(t, ExpGo, "ExpGo")
2471 }
2472
2473 func testExp(t *testing.T, Exp func(float64) float64, name string) {
2474 for i := 0; i < len(vf); i++ {
2475 if f := Exp(vf[i]); !veryclose(exp[i], f) {
2476 t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp[i])
2477 }
2478 }
2479 for i := 0; i < len(vfexpSC); i++ {
2480 if f := Exp(vfexpSC[i]); !alike(expSC[i], f) {
2481 t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i])
2482 }
2483 }
2484 }
2485
2486 func TestExpm1(t *testing.T) {
2487 for i := 0; i < len(vf); i++ {
2488 a := vf[i] / 100
2489 if f := Expm1(a); !veryclose(expm1[i], f) {
2490 t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1[i])
2491 }
2492 }
2493 for i := 0; i < len(vf); i++ {
2494 a := vf[i] * 10
2495 if f := Expm1(a); !close(expm1Large[i], f) {
2496 t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1Large[i])
2497 }
2498 }
2499 for i := 0; i < len(vfexpm1SC); i++ {
2500 if f := Expm1(vfexpm1SC[i]); !alike(expm1SC[i], f) {
2501 t.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC[i], f, expm1SC[i])
2502 }
2503 }
2504 }
2505
2506 func TestExp2(t *testing.T) {
2507 testExp2(t, Exp2, "Exp2")
2508 testExp2(t, Exp2Go, "Exp2Go")
2509 }
2510
2511 func testExp2(t *testing.T, Exp2 func(float64) float64, name string) {
2512 for i := 0; i < len(vf); i++ {
2513 if f := Exp2(vf[i]); !close(exp2[i], f) {
2514 t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp2[i])
2515 }
2516 }
2517 for i := 0; i < len(vfexp2SC); i++ {
2518 if f := Exp2(vfexp2SC[i]); !alike(exp2SC[i], f) {
2519 t.Errorf("%s(%g) = %g, want %g", name, vfexp2SC[i], f, exp2SC[i])
2520 }
2521 }
2522 for n := -1074; n < 1024; n++ {
2523 f := Exp2(float64(n))
2524 vf := Ldexp(1, n)
2525 if f != vf {
2526 t.Errorf("%s(%d) = %g, want %g", name, n, f, vf)
2527 }
2528 }
2529 }
2530
2531 func TestAbs(t *testing.T) {
2532 for i := 0; i < len(vf); i++ {
2533 if f := Abs(vf[i]); fabs[i] != f {
2534 t.Errorf("Abs(%g) = %g, want %g", vf[i], f, fabs[i])
2535 }
2536 }
2537 for i := 0; i < len(vffabsSC); i++ {
2538 if f := Abs(vffabsSC[i]); !alike(fabsSC[i], f) {
2539 t.Errorf("Abs(%g) = %g, want %g", vffabsSC[i], f, fabsSC[i])
2540 }
2541 }
2542 }
2543
2544 func TestDim(t *testing.T) {
2545 for i := 0; i < len(vf); i++ {
2546 if f := Dim(vf[i], 0); fdim[i] != f {
2547 t.Errorf("Dim(%g, %g) = %g, want %g", vf[i], 0.0, f, fdim[i])
2548 }
2549 }
2550 for i := 0; i < len(vffdimSC); i++ {
2551 if f := Dim(vffdimSC[i][0], vffdimSC[i][1]); !alike(fdimSC[i], f) {
2552 t.Errorf("Dim(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fdimSC[i])
2553 }
2554 }
2555 for i := 0; i < len(vffdim2SC); i++ {
2556 if f := Dim(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fdimSC[i], f) {
2557 t.Errorf("Dim(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fdimSC[i])
2558 }
2559 }
2560 }
2561
2562 func TestFloor(t *testing.T) {
2563 for i := 0; i < len(vf); i++ {
2564 if f := Floor(vf[i]); !alike(floor[i], f) {
2565 t.Errorf("Floor(%g) = %g, want %g", vf[i], f, floor[i])
2566 }
2567 }
2568 for i := 0; i < len(vfceilSC); i++ {
2569 if f := Floor(vfceilSC[i]); !alike(floorSC[i], f) {
2570 t.Errorf("Floor(%g) = %g, want %g", vfceilSC[i], f, floorSC[i])
2571 }
2572 }
2573 }
2574
2575 func TestMax(t *testing.T) {
2576 for i := 0; i < len(vf); i++ {
2577 if f := Max(vf[i], ceil[i]); ceil[i] != f {
2578 t.Errorf("Max(%g, %g) = %g, want %g", vf[i], ceil[i], f, ceil[i])
2579 }
2580 }
2581 for i := 0; i < len(vffdimSC); i++ {
2582 if f := Max(vffdimSC[i][0], vffdimSC[i][1]); !alike(fmaxSC[i], f) {
2583 t.Errorf("Max(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fmaxSC[i])
2584 }
2585 }
2586 for i := 0; i < len(vffdim2SC); i++ {
2587 if f := Max(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fmaxSC[i], f) {
2588 t.Errorf("Max(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fmaxSC[i])
2589 }
2590 }
2591 }
2592
2593 func TestMin(t *testing.T) {
2594 for i := 0; i < len(vf); i++ {
2595 if f := Min(vf[i], floor[i]); floor[i] != f {
2596 t.Errorf("Min(%g, %g) = %g, want %g", vf[i], floor[i], f, floor[i])
2597 }
2598 }
2599 for i := 0; i < len(vffdimSC); i++ {
2600 if f := Min(vffdimSC[i][0], vffdimSC[i][1]); !alike(fminSC[i], f) {
2601 t.Errorf("Min(%g, %g) = %g, want %g", vffdimSC[i][0], vffdimSC[i][1], f, fminSC[i])
2602 }
2603 }
2604 for i := 0; i < len(vffdim2SC); i++ {
2605 if f := Min(vffdim2SC[i][0], vffdim2SC[i][1]); !alike(fminSC[i], f) {
2606 t.Errorf("Min(%g, %g) = %g, want %g", vffdim2SC[i][0], vffdim2SC[i][1], f, fminSC[i])
2607 }
2608 }
2609 }
2610
2611 func TestMod(t *testing.T) {
2612 for i := 0; i < len(vf); i++ {
2613 if f := Mod(10, vf[i]); fmod[i] != f {
2614 t.Errorf("Mod(10, %g) = %g, want %g", vf[i], f, fmod[i])
2615 }
2616 }
2617 for i := 0; i < len(vffmodSC); i++ {
2618 if f := Mod(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
2619 t.Errorf("Mod(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
2620 }
2621 }
2622
2623 if f := Mod(5.9790119248836734e+200, 1.1258465975523544); 0.6447968302508578 != f {
2624 t.Errorf("Remainder(5.9790119248836734e+200, 1.1258465975523544) = %g, want 0.6447968302508578", f)
2625 }
2626 }
2627
2628 func TestFrexp(t *testing.T) {
2629 for i := 0; i < len(vf); i++ {
2630 if f, j := Frexp(vf[i]); !veryclose(frexp[i].f, f) || frexp[i].i != j {
2631 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vf[i], f, j, frexp[i].f, frexp[i].i)
2632 }
2633 }
2634 for i := 0; i < len(vffrexpSC); i++ {
2635 if f, j := Frexp(vffrexpSC[i]); !alike(frexpSC[i].f, f) || frexpSC[i].i != j {
2636 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpSC[i], f, j, frexpSC[i].f, frexpSC[i].i)
2637 }
2638 }
2639 for i := 0; i < len(vffrexpBC); i++ {
2640 if f, j := Frexp(vffrexpBC[i]); !alike(frexpBC[i].f, f) || frexpBC[i].i != j {
2641 t.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpBC[i], f, j, frexpBC[i].f, frexpBC[i].i)
2642 }
2643 }
2644 }
2645
2646 func TestGamma(t *testing.T) {
2647 for i := 0; i < len(vf); i++ {
2648 if f := Gamma(vf[i]); !close(gamma[i], f) {
2649 t.Errorf("Gamma(%g) = %g, want %g", vf[i], f, gamma[i])
2650 }
2651 }
2652 for _, g := range vfgamma {
2653 f := Gamma(g[0])
2654 var ok bool
2655 if IsNaN(g[1]) || IsInf(g[1], 0) || g[1] == 0 || f == 0 {
2656 ok = alike(g[1], f)
2657 } else if g[0] > -50 && g[0] <= 171 {
2658 ok = veryclose(g[1], f)
2659 } else {
2660 ok = close(g[1], f)
2661 }
2662 if !ok {
2663 t.Errorf("Gamma(%g) = %g, want %g", g[0], f, g[1])
2664 }
2665 }
2666 }
2667
2668 func TestHypot(t *testing.T) {
2669 for i := 0; i < len(vf); i++ {
2670 a := Abs(1e200 * tanh[i] * Sqrt(2))
2671 if f := Hypot(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
2672 t.Errorf("Hypot(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
2673 }
2674 }
2675 for i := 0; i < len(vfhypotSC); i++ {
2676 if f := Hypot(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) {
2677 t.Errorf("Hypot(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i])
2678 }
2679 }
2680 }
2681
2682 func TestHypotGo(t *testing.T) {
2683 for i := 0; i < len(vf); i++ {
2684 a := Abs(1e200 * tanh[i] * Sqrt(2))
2685 if f := HypotGo(1e200*tanh[i], 1e200*tanh[i]); !veryclose(a, f) {
2686 t.Errorf("HypotGo(%g, %g) = %g, want %g", 1e200*tanh[i], 1e200*tanh[i], f, a)
2687 }
2688 }
2689 for i := 0; i < len(vfhypotSC); i++ {
2690 if f := HypotGo(vfhypotSC[i][0], vfhypotSC[i][1]); !alike(hypotSC[i], f) {
2691 t.Errorf("HypotGo(%g, %g) = %g, want %g", vfhypotSC[i][0], vfhypotSC[i][1], f, hypotSC[i])
2692 }
2693 }
2694 }
2695
2696 func TestIlogb(t *testing.T) {
2697 for i := 0; i < len(vf); i++ {
2698 a := frexp[i].i - 1
2699 if e := Ilogb(vf[i]); a != e {
2700 t.Errorf("Ilogb(%g) = %d, want %d", vf[i], e, a)
2701 }
2702 }
2703 for i := 0; i < len(vflogbSC); i++ {
2704 if e := Ilogb(vflogbSC[i]); ilogbSC[i] != e {
2705 t.Errorf("Ilogb(%g) = %d, want %d", vflogbSC[i], e, ilogbSC[i])
2706 }
2707 }
2708 for i := 0; i < len(vffrexpBC); i++ {
2709 if e := Ilogb(vffrexpBC[i]); int(logbBC[i]) != e {
2710 t.Errorf("Ilogb(%g) = %d, want %d", vffrexpBC[i], e, int(logbBC[i]))
2711 }
2712 }
2713 }
2714
2715 func TestJ0(t *testing.T) {
2716 for i := 0; i < len(vf); i++ {
2717 if f := J0(vf[i]); !soclose(j0[i], f, 4e-14) {
2718 t.Errorf("J0(%g) = %g, want %g", vf[i], f, j0[i])
2719 }
2720 }
2721 for i := 0; i < len(vfj0SC); i++ {
2722 if f := J0(vfj0SC[i]); !alike(j0SC[i], f) {
2723 t.Errorf("J0(%g) = %g, want %g", vfj0SC[i], f, j0SC[i])
2724 }
2725 }
2726 }
2727
2728 func TestJ1(t *testing.T) {
2729 for i := 0; i < len(vf); i++ {
2730 if f := J1(vf[i]); !close(j1[i], f) {
2731 t.Errorf("J1(%g) = %g, want %g", vf[i], f, j1[i])
2732 }
2733 }
2734 for i := 0; i < len(vfj0SC); i++ {
2735 if f := J1(vfj0SC[i]); !alike(j1SC[i], f) {
2736 t.Errorf("J1(%g) = %g, want %g", vfj0SC[i], f, j1SC[i])
2737 }
2738 }
2739 }
2740
2741 func TestJn(t *testing.T) {
2742 for i := 0; i < len(vf); i++ {
2743 if f := Jn(2, vf[i]); !close(j2[i], f) {
2744 t.Errorf("Jn(2, %g) = %g, want %g", vf[i], f, j2[i])
2745 }
2746 if f := Jn(-3, vf[i]); !close(jM3[i], f) {
2747 t.Errorf("Jn(-3, %g) = %g, want %g", vf[i], f, jM3[i])
2748 }
2749 }
2750 for i := 0; i < len(vfj0SC); i++ {
2751 if f := Jn(2, vfj0SC[i]); !alike(j2SC[i], f) {
2752 t.Errorf("Jn(2, %g) = %g, want %g", vfj0SC[i], f, j2SC[i])
2753 }
2754 if f := Jn(-3, vfj0SC[i]); !alike(jM3SC[i], f) {
2755 t.Errorf("Jn(-3, %g) = %g, want %g", vfj0SC[i], f, jM3SC[i])
2756 }
2757 }
2758 }
2759
2760 func TestLdexp(t *testing.T) {
2761 for i := 0; i < len(vf); i++ {
2762 if f := Ldexp(frexp[i].f, frexp[i].i); !veryclose(vf[i], f) {
2763 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexp[i].f, frexp[i].i, f, vf[i])
2764 }
2765 }
2766 for i := 0; i < len(vffrexpSC); i++ {
2767 if f := Ldexp(frexpSC[i].f, frexpSC[i].i); !alike(vffrexpSC[i], f) {
2768 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpSC[i].f, frexpSC[i].i, f, vffrexpSC[i])
2769 }
2770 }
2771 for i := 0; i < len(vfldexpSC); i++ {
2772 if f := Ldexp(vfldexpSC[i].f, vfldexpSC[i].i); !alike(ldexpSC[i], f) {
2773 t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpSC[i].f, vfldexpSC[i].i, f, ldexpSC[i])
2774 }
2775 }
2776 for i := 0; i < len(vffrexpBC); i++ {
2777 if f := Ldexp(frexpBC[i].f, frexpBC[i].i); !alike(vffrexpBC[i], f) {
2778 t.Errorf("Ldexp(%g, %d) = %g, want %g", frexpBC[i].f, frexpBC[i].i, f, vffrexpBC[i])
2779 }
2780 }
2781 for i := 0; i < len(vfldexpBC); i++ {
2782 if f := Ldexp(vfldexpBC[i].f, vfldexpBC[i].i); !alike(ldexpBC[i], f) {
2783 t.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpBC[i].f, vfldexpBC[i].i, f, ldexpBC[i])
2784 }
2785 }
2786 }
2787
2788 func TestLgamma(t *testing.T) {
2789 for i := 0; i < len(vf); i++ {
2790 if f, s := Lgamma(vf[i]); !close(lgamma[i].f, f) || lgamma[i].i != s {
2791 t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vf[i], f, s, lgamma[i].f, lgamma[i].i)
2792 }
2793 }
2794 for i := 0; i < len(vflgammaSC); i++ {
2795 if f, s := Lgamma(vflgammaSC[i]); !alike(lgammaSC[i].f, f) || lgammaSC[i].i != s {
2796 t.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vflgammaSC[i], f, s, lgammaSC[i].f, lgammaSC[i].i)
2797 }
2798 }
2799 }
2800
2801 func TestLog(t *testing.T) {
2802 for i := 0; i < len(vf); i++ {
2803 a := Abs(vf[i])
2804 if f := Log(a); log[i] != f {
2805 t.Errorf("Log(%g) = %g, want %g", a, f, log[i])
2806 }
2807 }
2808 if f := Log(10); f != Ln10 {
2809 t.Errorf("Log(%g) = %g, want %g", 10.0, f, Ln10)
2810 }
2811 for i := 0; i < len(vflogSC); i++ {
2812 if f := Log(vflogSC[i]); !alike(logSC[i], f) {
2813 t.Errorf("Log(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2814 }
2815 }
2816 }
2817
2818 func TestLogb(t *testing.T) {
2819 for i := 0; i < len(vf); i++ {
2820 if f := Logb(vf[i]); logb[i] != f {
2821 t.Errorf("Logb(%g) = %g, want %g", vf[i], f, logb[i])
2822 }
2823 }
2824 for i := 0; i < len(vflogbSC); i++ {
2825 if f := Logb(vflogbSC[i]); !alike(logbSC[i], f) {
2826 t.Errorf("Logb(%g) = %g, want %g", vflogbSC[i], f, logbSC[i])
2827 }
2828 }
2829 for i := 0; i < len(vffrexpBC); i++ {
2830 if f := Logb(vffrexpBC[i]); !alike(logbBC[i], f) {
2831 t.Errorf("Logb(%g) = %g, want %g", vffrexpBC[i], f, logbBC[i])
2832 }
2833 }
2834 }
2835
2836 func TestLog10(t *testing.T) {
2837 for i := 0; i < len(vf); i++ {
2838 a := Abs(vf[i])
2839 if f := Log10(a); !veryclose(log10[i], f) {
2840 t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i])
2841 }
2842 }
2843 if f := Log10(E); f != Log10E {
2844 t.Errorf("Log10(%g) = %g, want %g", E, f, Log10E)
2845 }
2846 for i := 0; i < len(vflogSC); i++ {
2847 if f := Log10(vflogSC[i]); !alike(logSC[i], f) {
2848 t.Errorf("Log10(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2849 }
2850 }
2851 }
2852
2853 func TestLog1p(t *testing.T) {
2854 for i := 0; i < len(vf); i++ {
2855 a := vf[i] / 100
2856 if f := Log1p(a); !veryclose(log1p[i], f) {
2857 t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i])
2858 }
2859 }
2860 a := 9.0
2861 if f := Log1p(a); f != Ln10 {
2862 t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10)
2863 }
2864 for i := 0; i < len(vflogSC); i++ {
2865 if f := Log1p(vflog1pSC[i]); !alike(log1pSC[i], f) {
2866 t.Errorf("Log1p(%g) = %g, want %g", vflog1pSC[i], f, log1pSC[i])
2867 }
2868 }
2869 }
2870
2871 func TestLog2(t *testing.T) {
2872 for i := 0; i < len(vf); i++ {
2873 a := Abs(vf[i])
2874 if f := Log2(a); !veryclose(log2[i], f) {
2875 t.Errorf("Log2(%g) = %g, want %g", a, f, log2[i])
2876 }
2877 }
2878 if f := Log2(E); f != Log2E {
2879 t.Errorf("Log2(%g) = %g, want %g", E, f, Log2E)
2880 }
2881 for i := 0; i < len(vflogSC); i++ {
2882 if f := Log2(vflogSC[i]); !alike(logSC[i], f) {
2883 t.Errorf("Log2(%g) = %g, want %g", vflogSC[i], f, logSC[i])
2884 }
2885 }
2886 for i := 0; i < len(vflog2NearOne); i++ {
2887 if f := Log2(vflog2NearOne[i]); !veryclose(log2NearOne[i], f) {
2888 t.Errorf("Log2(%g) = %g, want %g", vflog2NearOne[i], f, log2NearOne[i])
2889 }
2890 }
2891 for i := -1074; i <= 1023; i++ {
2892 f := Ldexp(1, i)
2893 l := Log2(f)
2894 if l != float64(i) {
2895 t.Errorf("Log2(2**%d) = %g, want %d", i, l, i)
2896 }
2897 }
2898 }
2899
2900 func TestModf(t *testing.T) {
2901 for i := 0; i < len(vf); i++ {
2902 if f, g := Modf(vf[i]); !veryclose(modf[i][0], f) || !veryclose(modf[i][1], g) {
2903 t.Errorf("Modf(%g) = %g, %g, want %g, %g", vf[i], f, g, modf[i][0], modf[i][1])
2904 }
2905 }
2906 for i := 0; i < len(vfmodfSC); i++ {
2907 if f, g := Modf(vfmodfSC[i]); !alike(modfSC[i][0], f) || !alike(modfSC[i][1], g) {
2908 t.Errorf("Modf(%g) = %g, %g, want %g, %g", vfmodfSC[i], f, g, modfSC[i][0], modfSC[i][1])
2909 }
2910 }
2911 }
2912
2913 func TestNextafter32(t *testing.T) {
2914 for i := 0; i < len(vf); i++ {
2915 vfi := float32(vf[i])
2916 if f := Nextafter32(vfi, 10); nextafter32[i] != f {
2917 t.Errorf("Nextafter32(%g, %g) = %g want %g", vfi, 10.0, f, nextafter32[i])
2918 }
2919 }
2920 for i := 0; i < len(vfnextafter32SC); i++ {
2921 if f := Nextafter32(vfnextafter32SC[i][0], vfnextafter32SC[i][1]); !alike(float64(nextafter32SC[i]), float64(f)) {
2922 t.Errorf("Nextafter32(%g, %g) = %g want %g", vfnextafter32SC[i][0], vfnextafter32SC[i][1], f, nextafter32SC[i])
2923 }
2924 }
2925 }
2926
2927 func TestNextafter64(t *testing.T) {
2928 for i := 0; i < len(vf); i++ {
2929 if f := Nextafter(vf[i], 10); nextafter64[i] != f {
2930 t.Errorf("Nextafter64(%g, %g) = %g want %g", vf[i], 10.0, f, nextafter64[i])
2931 }
2932 }
2933 for i := 0; i < len(vfnextafter64SC); i++ {
2934 if f := Nextafter(vfnextafter64SC[i][0], vfnextafter64SC[i][1]); !alike(nextafter64SC[i], f) {
2935 t.Errorf("Nextafter64(%g, %g) = %g want %g", vfnextafter64SC[i][0], vfnextafter64SC[i][1], f, nextafter64SC[i])
2936 }
2937 }
2938 }
2939
2940 func TestPow(t *testing.T) {
2941 for i := 0; i < len(vf); i++ {
2942 if f := Pow(10, vf[i]); !close(pow[i], f) {
2943 t.Errorf("Pow(10, %g) = %g, want %g", vf[i], f, pow[i])
2944 }
2945 }
2946 for i := 0; i < len(vfpowSC); i++ {
2947 if f := Pow(vfpowSC[i][0], vfpowSC[i][1]); !alike(powSC[i], f) {
2948 t.Errorf("Pow(%g, %g) = %g, want %g", vfpowSC[i][0], vfpowSC[i][1], f, powSC[i])
2949 }
2950 }
2951 }
2952
2953 func TestPow10(t *testing.T) {
2954 for i := 0; i < len(vfpow10SC); i++ {
2955 if f := Pow10(vfpow10SC[i]); !alike(pow10SC[i], f) {
2956 t.Errorf("Pow10(%d) = %g, want %g", vfpow10SC[i], f, pow10SC[i])
2957 }
2958 }
2959 }
2960
2961 func TestRemainder(t *testing.T) {
2962 for i := 0; i < len(vf); i++ {
2963 if f := Remainder(10, vf[i]); remainder[i] != f {
2964 t.Errorf("Remainder(10, %g) = %g, want %g", vf[i], f, remainder[i])
2965 }
2966 }
2967 for i := 0; i < len(vffmodSC); i++ {
2968 if f := Remainder(vffmodSC[i][0], vffmodSC[i][1]); !alike(fmodSC[i], f) {
2969 t.Errorf("Remainder(%g, %g) = %g, want %g", vffmodSC[i][0], vffmodSC[i][1], f, fmodSC[i])
2970 }
2971 }
2972
2973 if f := Remainder(5.9790119248836734e+200, 1.1258465975523544); -0.4810497673014966 != f {
2974 t.Errorf("Remainder(5.9790119248836734e+200, 1.1258465975523544) = %g, want -0.4810497673014966", f)
2975 }
2976
2977 test := func(x, y float64) {
2978 if r := Remainder(x, y); r == 0 && Signbit(r) != Signbit(x) {
2979 t.Errorf("Remainder(x=%f, y=%f) = %f, sign of (zero) result should agree with sign of x", x, y, r)
2980 }
2981 }
2982 for x := 0.0; x <= 3.0; x += 1 {
2983 for y := 1.0; y <= 3.0; y += 1 {
2984 test(x, y)
2985 test(x, -y)
2986 test(-x, y)
2987 test(-x, -y)
2988 }
2989 }
2990 }
2991
2992 func TestRound(t *testing.T) {
2993 for i := 0; i < len(vf); i++ {
2994 if f := Round(vf[i]); !alike(round[i], f) {
2995 t.Errorf("Round(%g) = %g, want %g", vf[i], f, round[i])
2996 }
2997 }
2998 for i := 0; i < len(vfroundSC); i++ {
2999 if f := Round(vfroundSC[i][0]); !alike(vfroundSC[i][1], f) {
3000 t.Errorf("Round(%g) = %g, want %g", vfroundSC[i][0], f, vfroundSC[i][1])
3001 }
3002 }
3003 }
3004
3005 func TestRoundToEven(t *testing.T) {
3006 for i := 0; i < len(vf); i++ {
3007 if f := RoundToEven(vf[i]); !alike(round[i], f) {
3008 t.Errorf("RoundToEven(%g) = %g, want %g", vf[i], f, round[i])
3009 }
3010 }
3011 for i := 0; i < len(vfroundEvenSC); i++ {
3012 if f := RoundToEven(vfroundEvenSC[i][0]); !alike(vfroundEvenSC[i][1], f) {
3013 t.Errorf("RoundToEven(%g) = %g, want %g", vfroundEvenSC[i][0], f, vfroundEvenSC[i][1])
3014 }
3015 }
3016 }
3017
3018 func TestSignbit(t *testing.T) {
3019 for i := 0; i < len(vf); i++ {
3020 if f := Signbit(vf[i]); signbit[i] != f {
3021 t.Errorf("Signbit(%g) = %t, want %t", vf[i], f, signbit[i])
3022 }
3023 }
3024 for i := 0; i < len(vfsignbitSC); i++ {
3025 if f := Signbit(vfsignbitSC[i]); signbitSC[i] != f {
3026 t.Errorf("Signbit(%g) = %t, want %t", vfsignbitSC[i], f, signbitSC[i])
3027 }
3028 }
3029 }
3030 func TestSin(t *testing.T) {
3031 for i := 0; i < len(vf); i++ {
3032 if f := Sin(vf[i]); !veryclose(sin[i], f) {
3033 t.Errorf("Sin(%g) = %g, want %g", vf[i], f, sin[i])
3034 }
3035 }
3036 for i := 0; i < len(vfsinSC); i++ {
3037 if f := Sin(vfsinSC[i]); !alike(sinSC[i], f) {
3038 t.Errorf("Sin(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
3039 }
3040 }
3041 }
3042
3043 func TestSincos(t *testing.T) {
3044 for i := 0; i < len(vf); i++ {
3045 if s, c := Sincos(vf[i]); !veryclose(sin[i], s) || !veryclose(cos[i], c) {
3046 t.Errorf("Sincos(%g) = %g, %g want %g, %g", vf[i], s, c, sin[i], cos[i])
3047 }
3048 }
3049 }
3050
3051 func TestSinh(t *testing.T) {
3052 for i := 0; i < len(vf); i++ {
3053 if f := Sinh(vf[i]); !close(sinh[i], f) {
3054 t.Errorf("Sinh(%g) = %g, want %g", vf[i], f, sinh[i])
3055 }
3056 }
3057 for i := 0; i < len(vfsinhSC); i++ {
3058 if f := Sinh(vfsinhSC[i]); !alike(sinhSC[i], f) {
3059 t.Errorf("Sinh(%g) = %g, want %g", vfsinhSC[i], f, sinhSC[i])
3060 }
3061 }
3062 }
3063
3064 func TestSqrt(t *testing.T) {
3065 for i := 0; i < len(vf); i++ {
3066 a := Abs(vf[i])
3067 if f := SqrtGo(a); sqrt[i] != f {
3068 t.Errorf("SqrtGo(%g) = %g, want %g", a, f, sqrt[i])
3069 }
3070 a = Abs(vf[i])
3071 if f := Sqrt(a); sqrt[i] != f {
3072 t.Errorf("Sqrt(%g) = %g, want %g", a, f, sqrt[i])
3073 }
3074 }
3075 for i := 0; i < len(vfsqrtSC); i++ {
3076 if f := SqrtGo(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
3077 t.Errorf("SqrtGo(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
3078 }
3079 if f := Sqrt(vfsqrtSC[i]); !alike(sqrtSC[i], f) {
3080 t.Errorf("Sqrt(%g) = %g, want %g", vfsqrtSC[i], f, sqrtSC[i])
3081 }
3082 }
3083 }
3084
3085 func TestTan(t *testing.T) {
3086 for i := 0; i < len(vf); i++ {
3087 if f := Tan(vf[i]); !veryclose(tan[i], f) {
3088 t.Errorf("Tan(%g) = %g, want %g", vf[i], f, tan[i])
3089 }
3090 }
3091
3092 for i := 0; i < len(vfsinSC); i++ {
3093 if f := Tan(vfsinSC[i]); !alike(sinSC[i], f) {
3094 t.Errorf("Tan(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
3095 }
3096 }
3097 }
3098
3099 func TestTanh(t *testing.T) {
3100 for i := 0; i < len(vf); i++ {
3101 if f := Tanh(vf[i]); !veryclose(tanh[i], f) {
3102 t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i])
3103 }
3104 }
3105 for i := 0; i < len(vftanhSC); i++ {
3106 if f := Tanh(vftanhSC[i]); !alike(tanhSC[i], f) {
3107 t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i])
3108 }
3109 }
3110 }
3111
3112 func TestTrunc(t *testing.T) {
3113 for i := 0; i < len(vf); i++ {
3114 if f := Trunc(vf[i]); !alike(trunc[i], f) {
3115 t.Errorf("Trunc(%g) = %g, want %g", vf[i], f, trunc[i])
3116 }
3117 }
3118 for i := 0; i < len(vfceilSC); i++ {
3119 if f := Trunc(vfceilSC[i]); !alike(truncSC[i], f) {
3120 t.Errorf("Trunc(%g) = %g, want %g", vfceilSC[i], f, truncSC[i])
3121 }
3122 }
3123 }
3124
3125 func TestY0(t *testing.T) {
3126 for i := 0; i < len(vf); i++ {
3127 a := Abs(vf[i])
3128 if f := Y0(a); !close(y0[i], f) {
3129 t.Errorf("Y0(%g) = %g, want %g", a, f, y0[i])
3130 }
3131 }
3132 for i := 0; i < len(vfy0SC); i++ {
3133 if f := Y0(vfy0SC[i]); !alike(y0SC[i], f) {
3134 t.Errorf("Y0(%g) = %g, want %g", vfy0SC[i], f, y0SC[i])
3135 }
3136 }
3137 }
3138
3139 func TestY1(t *testing.T) {
3140 for i := 0; i < len(vf); i++ {
3141 a := Abs(vf[i])
3142 if f := Y1(a); !soclose(y1[i], f, 2e-14) {
3143 t.Errorf("Y1(%g) = %g, want %g", a, f, y1[i])
3144 }
3145 }
3146 for i := 0; i < len(vfy0SC); i++ {
3147 if f := Y1(vfy0SC[i]); !alike(y1SC[i], f) {
3148 t.Errorf("Y1(%g) = %g, want %g", vfy0SC[i], f, y1SC[i])
3149 }
3150 }
3151 }
3152
3153 func TestYn(t *testing.T) {
3154 for i := 0; i < len(vf); i++ {
3155 a := Abs(vf[i])
3156 if f := Yn(2, a); !close(y2[i], f) {
3157 t.Errorf("Yn(2, %g) = %g, want %g", a, f, y2[i])
3158 }
3159 if f := Yn(-3, a); !close(yM3[i], f) {
3160 t.Errorf("Yn(-3, %g) = %g, want %g", a, f, yM3[i])
3161 }
3162 }
3163 for i := 0; i < len(vfy0SC); i++ {
3164 if f := Yn(2, vfy0SC[i]); !alike(y2SC[i], f) {
3165 t.Errorf("Yn(2, %g) = %g, want %g", vfy0SC[i], f, y2SC[i])
3166 }
3167 if f := Yn(-3, vfy0SC[i]); !alike(yM3SC[i], f) {
3168 t.Errorf("Yn(-3, %g) = %g, want %g", vfy0SC[i], f, yM3SC[i])
3169 }
3170 }
3171 if f := Yn(0, 0); !alike(Inf(-1), f) {
3172 t.Errorf("Yn(0, 0) = %g, want %g", f, Inf(-1))
3173 }
3174 }
3175
3176 var PortableFMA = FMA
3177
3178 func TestFMA(t *testing.T) {
3179 for _, c := range fmaC {
3180 got := FMA(c.x, c.y, c.z)
3181 if !alike(got, c.want) {
3182 t.Errorf("FMA(%g,%g,%g) == %g; want %g", c.x, c.y, c.z, got, c.want)
3183 }
3184 got = PortableFMA(c.x, c.y, c.z)
3185 if !alike(got, c.want) {
3186 t.Errorf("PortableFMA(%g,%g,%g) == %g; want %g", c.x, c.y, c.z, got, c.want)
3187 }
3188 }
3189 }
3190
3191
3192 func fmsub(x, y, z float64) float64 {
3193 return FMA(x, y, -z)
3194 }
3195
3196
3197 func fnmsub(x, y, z float64) float64 {
3198 return FMA(-x, y, z)
3199 }
3200
3201
3202 func fnmadd(x, y, z float64) float64 {
3203 return FMA(-x, y, -z)
3204 }
3205
3206 func TestFMANegativeArgs(t *testing.T) {
3207
3208
3209
3210
3211 for _, c := range fmaC {
3212 want := PortableFMA(c.x, c.y, -c.z)
3213 got := fmsub(c.x, c.y, c.z)
3214 if !alike(got, want) {
3215 t.Errorf("FMA(%g, %g, -(%g)) == %g, want %g", c.x, c.y, c.z, got, want)
3216 }
3217 want = PortableFMA(-c.x, c.y, c.z)
3218 got = fnmsub(c.x, c.y, c.z)
3219 if !alike(got, want) {
3220 t.Errorf("FMA(-(%g), %g, %g) == %g, want %g", c.x, c.y, c.z, got, want)
3221 }
3222 want = PortableFMA(-c.x, c.y, -c.z)
3223 got = fnmadd(c.x, c.y, c.z)
3224 if !alike(got, want) {
3225 t.Errorf("FMA(-(%g), %g, -(%g)) == %g, want %g", c.x, c.y, c.z, got, want)
3226 }
3227 }
3228 }
3229
3230
3231
3232
3233
3234 func TestLargeCos(t *testing.T) {
3235 large := float64(100000 * Pi)
3236 for i := 0; i < len(vf); i++ {
3237 f1 := cosLarge[i]
3238 f2 := Cos(vf[i] + large)
3239 if !close(f1, f2) {
3240 t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1)
3241 }
3242 }
3243 }
3244
3245 func TestLargeSin(t *testing.T) {
3246 large := float64(100000 * Pi)
3247 for i := 0; i < len(vf); i++ {
3248 f1 := sinLarge[i]
3249 f2 := Sin(vf[i] + large)
3250 if !close(f1, f2) {
3251 t.Errorf("Sin(%g) = %g, want %g", vf[i]+large, f2, f1)
3252 }
3253 }
3254 }
3255
3256 func TestLargeSincos(t *testing.T) {
3257 large := float64(100000 * Pi)
3258 for i := 0; i < len(vf); i++ {
3259 f1, g1 := sinLarge[i], cosLarge[i]
3260 f2, g2 := Sincos(vf[i] + large)
3261 if !close(f1, f2) || !close(g1, g2) {
3262 t.Errorf("Sincos(%g) = %g, %g, want %g, %g", vf[i]+large, f2, g2, f1, g1)
3263 }
3264 }
3265 }
3266
3267 func TestLargeTan(t *testing.T) {
3268 large := float64(100000 * Pi)
3269 for i := 0; i < len(vf); i++ {
3270 f1 := tanLarge[i]
3271 f2 := Tan(vf[i] + large)
3272 if !close(f1, f2) {
3273 t.Errorf("Tan(%g) = %g, want %g", vf[i]+large, f2, f1)
3274 }
3275 }
3276 }
3277
3278
3279
3280 func TestTrigReduce(t *testing.T) {
3281 inputs := make([]float64, len(vf))
3282
3283 copy(inputs, vf)
3284
3285 large := float64(100000 * Pi)
3286 for _, v := range vf {
3287 inputs = append(inputs, v+large)
3288 }
3289
3290 inputs = append(inputs, Pi, Nextafter(ReduceThreshold, 0))
3291 for _, x := range inputs {
3292
3293 j, z := TrigReduce(x)
3294 xred := float64(j)*(Pi/4) + z
3295
3296 if f, fred := Sin(x), Sin(xred); !close(f, fred) {
3297 t.Errorf("Sin(trigReduce(%g)) != Sin(%g), got %g, want %g", x, x, fred, f)
3298 }
3299 if f, fred := Cos(x), Cos(xred); !close(f, fred) {
3300 t.Errorf("Cos(trigReduce(%g)) != Cos(%g), got %g, want %g", x, x, fred, f)
3301 }
3302 if f, fred := Tan(x), Tan(xred); !close(f, fred) {
3303 t.Errorf(" Tan(trigReduce(%g)) != Tan(%g), got %g, want %g", x, x, fred, f)
3304 }
3305 f, g := Sincos(x)
3306 fred, gred := Sincos(xred)
3307 if !close(f, fred) || !close(g, gred) {
3308 t.Errorf(" Sincos(trigReduce(%g)) != Sincos(%g), got %g, %g, want %g, %g", x, x, fred, gred, f, g)
3309 }
3310 }
3311 }
3312
3313
3314
3315
3316
3317 type floatTest struct {
3318 val any
3319 name string
3320 str string
3321 }
3322
3323 var floatTests = []floatTest{
3324 {float64(MaxFloat64), "MaxFloat64", "1.7976931348623157e+308"},
3325 {float64(SmallestNonzeroFloat64), "SmallestNonzeroFloat64", "5e-324"},
3326 {float32(MaxFloat32), "MaxFloat32", "3.4028235e+38"},
3327 {float32(SmallestNonzeroFloat32), "SmallestNonzeroFloat32", "1e-45"},
3328 }
3329
3330 func TestFloatMinMax(t *testing.T) {
3331 for _, tt := range floatTests {
3332 s := fmt.Sprint(tt.val)
3333 if s != tt.str {
3334 t.Errorf("Sprint(%v) = %s, want %s", tt.name, s, tt.str)
3335 }
3336 }
3337 }
3338
3339 func TestFloatMinima(t *testing.T) {
3340 if q := float32(SmallestNonzeroFloat32 / 2); q != 0 {
3341 t.Errorf("float32(SmallestNonzeroFloat32 / 2) = %g, want 0", q)
3342 }
3343 if q := float64(SmallestNonzeroFloat64 / 2); q != 0 {
3344 t.Errorf("float64(SmallestNonzeroFloat64 / 2) = %g, want 0", q)
3345 }
3346 }
3347
3348 var indirectSqrt = Sqrt
3349
3350
3351 func TestFloat32Sqrt(t *testing.T) {
3352 for _, v := range sqrt32 {
3353 want := float32(indirectSqrt(float64(v)))
3354 got := float32(Sqrt(float64(v)))
3355 if IsNaN(float64(want)) {
3356 if !IsNaN(float64(got)) {
3357 t.Errorf("got=%#v want=NaN, v=%#v", got, v)
3358 }
3359 continue
3360 }
3361 if got != want {
3362 t.Errorf("got=%#v want=%#v, v=%#v", got, want, v)
3363 }
3364 }
3365 }
3366
3367
3368
3369
3370
3371
3372
3373 var (
3374 GlobalI int
3375 GlobalB bool
3376 GlobalF float64
3377 GlobalF32 float32
3378 )
3379
3380 func BenchmarkAcos(b *testing.B) {
3381 x := 0.0
3382 for i := 0; i < b.N; i++ {
3383 x = Acos(.5)
3384 }
3385 GlobalF = x
3386 }
3387
3388 func BenchmarkAcosh(b *testing.B) {
3389 x := 0.0
3390 for i := 0; i < b.N; i++ {
3391 x = Acosh(1.5)
3392 }
3393 GlobalF = x
3394 }
3395
3396 func BenchmarkAsin(b *testing.B) {
3397 x := 0.0
3398 for i := 0; i < b.N; i++ {
3399 x = Asin(.5)
3400 }
3401 GlobalF = x
3402 }
3403
3404 func BenchmarkAsinh(b *testing.B) {
3405 x := 0.0
3406 for i := 0; i < b.N; i++ {
3407 x = Asinh(.5)
3408 }
3409 GlobalF = x
3410 }
3411
3412 func BenchmarkAtan(b *testing.B) {
3413 x := 0.0
3414 for i := 0; i < b.N; i++ {
3415 x = Atan(.5)
3416 }
3417 GlobalF = x
3418 }
3419
3420 func BenchmarkAtanh(b *testing.B) {
3421 x := 0.0
3422 for i := 0; i < b.N; i++ {
3423 x = Atanh(.5)
3424 }
3425 GlobalF = x
3426 }
3427
3428 func BenchmarkAtan2(b *testing.B) {
3429 x := 0.0
3430 for i := 0; i < b.N; i++ {
3431 x = Atan2(.5, 1)
3432 }
3433 GlobalF = x
3434 }
3435
3436 func BenchmarkCbrt(b *testing.B) {
3437 x := 0.0
3438 for i := 0; i < b.N; i++ {
3439 x = Cbrt(10)
3440 }
3441 GlobalF = x
3442 }
3443
3444 func BenchmarkCeil(b *testing.B) {
3445 x := 0.0
3446 for i := 0; i < b.N; i++ {
3447 x = Ceil(.5)
3448 }
3449 GlobalF = x
3450 }
3451
3452 func BenchmarkCeil32(b *testing.B) {
3453 var x, src float32 = 0.0, 0.5
3454 for i := 0; i < b.N; i++ {
3455 x = float32(Ceil(float64(src)))
3456 }
3457 GlobalF32 = x
3458 }
3459
3460 var copysignNeg = -1.0
3461
3462 func BenchmarkCopysign(b *testing.B) {
3463 x := 0.0
3464 for i := 0; i < b.N; i++ {
3465 x = Copysign(.5, copysignNeg)
3466 }
3467 GlobalF = x
3468 }
3469
3470 func BenchmarkCos(b *testing.B) {
3471 x := 0.0
3472 for i := 0; i < b.N; i++ {
3473 x = Cos(.5)
3474 }
3475 GlobalF = x
3476 }
3477
3478 func BenchmarkCosh(b *testing.B) {
3479 x := 0.0
3480 for i := 0; i < b.N; i++ {
3481 x = Cosh(2.5)
3482 }
3483 GlobalF = x
3484 }
3485
3486 func BenchmarkErf(b *testing.B) {
3487 x := 0.0
3488 for i := 0; i < b.N; i++ {
3489 x = Erf(.5)
3490 }
3491 GlobalF = x
3492 }
3493
3494 func BenchmarkErfc(b *testing.B) {
3495 x := 0.0
3496 for i := 0; i < b.N; i++ {
3497 x = Erfc(.5)
3498 }
3499 GlobalF = x
3500 }
3501
3502 func BenchmarkErfinv(b *testing.B) {
3503 x := 0.0
3504 for i := 0; i < b.N; i++ {
3505 x = Erfinv(.5)
3506 }
3507 GlobalF = x
3508 }
3509
3510 func BenchmarkErfcinv(b *testing.B) {
3511 x := 0.0
3512 for i := 0; i < b.N; i++ {
3513 x = Erfcinv(.5)
3514 }
3515 GlobalF = x
3516 }
3517
3518 func BenchmarkExp(b *testing.B) {
3519 x := 0.0
3520 for i := 0; i < b.N; i++ {
3521 x = Exp(.5)
3522 }
3523 GlobalF = x
3524 }
3525
3526 func BenchmarkExpGo(b *testing.B) {
3527 x := 0.0
3528 for i := 0; i < b.N; i++ {
3529 x = ExpGo(.5)
3530 }
3531 GlobalF = x
3532 }
3533
3534 func BenchmarkExpm1(b *testing.B) {
3535 x := 0.0
3536 for i := 0; i < b.N; i++ {
3537 x = Expm1(.5)
3538 }
3539 GlobalF = x
3540 }
3541
3542 func BenchmarkExp2(b *testing.B) {
3543 x := 0.0
3544 for i := 0; i < b.N; i++ {
3545 x = Exp2(.5)
3546 }
3547 GlobalF = x
3548 }
3549
3550 func BenchmarkExp2Go(b *testing.B) {
3551 x := 0.0
3552 for i := 0; i < b.N; i++ {
3553 x = Exp2Go(.5)
3554 }
3555 GlobalF = x
3556 }
3557
3558 var absPos = .5
3559 var absPos32 float32 = .5
3560
3561 func BenchmarkAbs(b *testing.B) {
3562 x := 0.0
3563 for i := 0; i < b.N; i++ {
3564 x = Abs(absPos)
3565 }
3566 GlobalF = x
3567
3568 }
3569
3570 func BenchmarkAbs32(b *testing.B) {
3571 var x float32 = 0.0
3572 for i := 0; i < b.N; i++ {
3573 x = float32(Abs(float64(absPos32)))
3574 }
3575 GlobalF32 = x
3576
3577 }
3578
3579 func BenchmarkDim(b *testing.B) {
3580 x := 0.0
3581 for i := 0; i < b.N; i++ {
3582 x = Dim(GlobalF, x)
3583 }
3584 GlobalF = x
3585 }
3586
3587 func BenchmarkFloor(b *testing.B) {
3588 x := 0.0
3589 for i := 0; i < b.N; i++ {
3590 x = Floor(.5)
3591 }
3592 GlobalF = x
3593 }
3594
3595 func BenchmarkFloor32(b *testing.B) {
3596 var x, src float32 = 0.0, .5
3597 for i := 0; i < b.N; i++ {
3598 x = float32(Floor(float64(src)))
3599 }
3600 GlobalF32 = x
3601 }
3602
3603 func BenchmarkMax(b *testing.B) {
3604 x := 0.0
3605 for i := 0; i < b.N; i++ {
3606 x = Max(10, 3)
3607 }
3608 GlobalF = x
3609 }
3610
3611 func BenchmarkMin(b *testing.B) {
3612 x := 0.0
3613 for i := 0; i < b.N; i++ {
3614 x = Min(10, 3)
3615 }
3616 GlobalF = x
3617 }
3618
3619 func BenchmarkMod(b *testing.B) {
3620 x := 0.0
3621 for i := 0; i < b.N; i++ {
3622 x = Mod(10, 3)
3623 }
3624 GlobalF = x
3625 }
3626
3627 func BenchmarkFrexp(b *testing.B) {
3628 x := 0.0
3629 y := 0
3630 for i := 0; i < b.N; i++ {
3631 x, y = Frexp(8)
3632 }
3633 GlobalF = x
3634 GlobalI = y
3635 }
3636
3637 func BenchmarkGamma(b *testing.B) {
3638 x := 0.0
3639 for i := 0; i < b.N; i++ {
3640 x = Gamma(2.5)
3641 }
3642 GlobalF = x
3643 }
3644
3645 func BenchmarkHypot(b *testing.B) {
3646 x := 0.0
3647 for i := 0; i < b.N; i++ {
3648 x = Hypot(3, 4)
3649 }
3650 GlobalF = x
3651 }
3652
3653 func BenchmarkHypotGo(b *testing.B) {
3654 x := 0.0
3655 for i := 0; i < b.N; i++ {
3656 x = HypotGo(3, 4)
3657 }
3658 GlobalF = x
3659 }
3660
3661 func BenchmarkIlogb(b *testing.B) {
3662 x := 0
3663 for i := 0; i < b.N; i++ {
3664 x = Ilogb(.5)
3665 }
3666 GlobalI = x
3667 }
3668
3669 func BenchmarkJ0(b *testing.B) {
3670 x := 0.0
3671 for i := 0; i < b.N; i++ {
3672 x = J0(2.5)
3673 }
3674 GlobalF = x
3675 }
3676
3677 func BenchmarkJ1(b *testing.B) {
3678 x := 0.0
3679 for i := 0; i < b.N; i++ {
3680 x = J1(2.5)
3681 }
3682 GlobalF = x
3683 }
3684
3685 func BenchmarkJn(b *testing.B) {
3686 x := 0.0
3687 for i := 0; i < b.N; i++ {
3688 x = Jn(2, 2.5)
3689 }
3690 GlobalF = x
3691 }
3692
3693 func BenchmarkLdexp(b *testing.B) {
3694 x := 0.0
3695 for i := 0; i < b.N; i++ {
3696 x = Ldexp(.5, 2)
3697 }
3698 GlobalF = x
3699 }
3700
3701 func BenchmarkLgamma(b *testing.B) {
3702 x := 0.0
3703 y := 0
3704 for i := 0; i < b.N; i++ {
3705 x, y = Lgamma(2.5)
3706 }
3707 GlobalF = x
3708 GlobalI = y
3709 }
3710
3711 func BenchmarkLog(b *testing.B) {
3712 x := 0.0
3713 for i := 0; i < b.N; i++ {
3714 x = Log(.5)
3715 }
3716 GlobalF = x
3717 }
3718
3719 func BenchmarkLogb(b *testing.B) {
3720 x := 0.0
3721 for i := 0; i < b.N; i++ {
3722 x = Logb(.5)
3723 }
3724 GlobalF = x
3725 }
3726
3727 func BenchmarkLog1p(b *testing.B) {
3728 x := 0.0
3729 for i := 0; i < b.N; i++ {
3730 x = Log1p(.5)
3731 }
3732 GlobalF = x
3733 }
3734
3735 func BenchmarkLog10(b *testing.B) {
3736 x := 0.0
3737 for i := 0; i < b.N; i++ {
3738 x = Log10(.5)
3739 }
3740 GlobalF = x
3741 }
3742
3743 func BenchmarkLog2(b *testing.B) {
3744 x := 0.0
3745 for i := 0; i < b.N; i++ {
3746 x = Log2(.5)
3747 }
3748 GlobalF += x
3749 }
3750
3751 func BenchmarkModf(b *testing.B) {
3752 x := 0.0
3753 y := 0.0
3754 for i := 0; i < b.N; i++ {
3755 x, y = Modf(1.5)
3756 }
3757 GlobalF += x
3758 GlobalF += y
3759 }
3760
3761 func BenchmarkNextafter32(b *testing.B) {
3762 x := float32(0.0)
3763 for i := 0; i < b.N; i++ {
3764 x = Nextafter32(.5, 1)
3765 }
3766 GlobalF = float64(x)
3767 }
3768
3769 func BenchmarkNextafter64(b *testing.B) {
3770 x := 0.0
3771 for i := 0; i < b.N; i++ {
3772 x = Nextafter(.5, 1)
3773 }
3774 GlobalF = x
3775 }
3776
3777 func BenchmarkPowInt(b *testing.B) {
3778 x := 0.0
3779 for i := 0; i < b.N; i++ {
3780 x = Pow(2, 2)
3781 }
3782 GlobalF = x
3783 }
3784
3785 func BenchmarkPowFrac(b *testing.B) {
3786 x := 0.0
3787 for i := 0; i < b.N; i++ {
3788 x = Pow(2.5, 1.5)
3789 }
3790 GlobalF = x
3791 }
3792
3793 var pow10pos = int(300)
3794
3795 func BenchmarkPow10Pos(b *testing.B) {
3796 x := 0.0
3797 for i := 0; i < b.N; i++ {
3798 x = Pow10(pow10pos)
3799 }
3800 GlobalF = x
3801 }
3802
3803 var pow10neg = int(-300)
3804
3805 func BenchmarkPow10Neg(b *testing.B) {
3806 x := 0.0
3807 for i := 0; i < b.N; i++ {
3808 x = Pow10(pow10neg)
3809 }
3810 GlobalF = x
3811 }
3812
3813 var roundNeg = float64(-2.5)
3814 var roundNeg32 float32 = -2.5
3815
3816 func BenchmarkRound(b *testing.B) {
3817 x := 0.0
3818 for i := 0; i < b.N; i++ {
3819 x = Round(roundNeg)
3820 }
3821 GlobalF = x
3822 }
3823
3824 func BenchmarkRound32(b *testing.B) {
3825 var x float32 = 0.0
3826 for i := 0; i < b.N; i++ {
3827 x = float32(Round(float64(roundNeg32)))
3828 }
3829 GlobalF32 = x
3830 }
3831
3832 func BenchmarkRoundToEven(b *testing.B) {
3833 x := 0.0
3834 for i := 0; i < b.N; i++ {
3835 x = RoundToEven(roundNeg)
3836 }
3837 GlobalF = x
3838 }
3839
3840 func BenchmarkRoundToEven32(b *testing.B) {
3841 var x float32 = 0.0
3842 for i := 0; i < b.N; i++ {
3843 x = float32(RoundToEven(float64(roundNeg32)))
3844 }
3845 GlobalF32 = x
3846 }
3847
3848 func BenchmarkRemainder(b *testing.B) {
3849 x := 0.0
3850 for i := 0; i < b.N; i++ {
3851 x = Remainder(10, 3)
3852 }
3853 GlobalF = x
3854 }
3855
3856 var signbitPos = 2.5
3857
3858 func BenchmarkSignbit(b *testing.B) {
3859 x := false
3860 for i := 0; i < b.N; i++ {
3861 x = Signbit(signbitPos)
3862 }
3863 GlobalB = x
3864 }
3865
3866 func BenchmarkSin(b *testing.B) {
3867 x := 0.0
3868 for i := 0; i < b.N; i++ {
3869 x = Sin(.5)
3870 }
3871 GlobalF = x
3872 }
3873
3874 func BenchmarkSincos(b *testing.B) {
3875 x := 0.0
3876 y := 0.0
3877 for i := 0; i < b.N; i++ {
3878 x, y = Sincos(.5)
3879 }
3880 GlobalF += x
3881 GlobalF += y
3882 }
3883
3884 func BenchmarkSinh(b *testing.B) {
3885 x := 0.0
3886 for i := 0; i < b.N; i++ {
3887 x = Sinh(2.5)
3888 }
3889 GlobalF = x
3890 }
3891
3892 func BenchmarkSqrtIndirect(b *testing.B) {
3893 x, y := 0.0, 10.0
3894 f := Sqrt
3895 for i := 0; i < b.N; i++ {
3896 x += f(y)
3897 }
3898 GlobalF = x
3899 }
3900
3901 func BenchmarkSqrtLatency(b *testing.B) {
3902 x := 10.0
3903 for i := 0; i < b.N; i++ {
3904 x = Sqrt(x)
3905 }
3906 GlobalF = x
3907 }
3908
3909 func BenchmarkSqrt32Latency(b *testing.B) {
3910 var x float32 = 10.0
3911 for i := 0; i < b.N; i++ {
3912 x = float32(Sqrt(float64(x)))
3913 }
3914 GlobalF32 = x
3915 }
3916
3917 func BenchmarkSqrtIndirectLatency(b *testing.B) {
3918 x := 10.0
3919 f := Sqrt
3920 for i := 0; i < b.N; i++ {
3921 x = f(x)
3922 }
3923 GlobalF = x
3924 }
3925
3926 func BenchmarkSqrtGoLatency(b *testing.B) {
3927 x := 10.0
3928 for i := 0; i < b.N; i++ {
3929 x = SqrtGo(x)
3930 }
3931 GlobalF = x
3932 }
3933
3934 func isPrime(i int) bool {
3935
3936
3937
3938
3939
3940 for j := 2; float64(j) <= Sqrt(float64(i)); j++ {
3941 if i%j == 0 {
3942 return false
3943 }
3944 }
3945 return true
3946 }
3947
3948 func BenchmarkSqrtPrime(b *testing.B) {
3949 x := false
3950 for i := 0; i < b.N; i++ {
3951 x = isPrime(100003)
3952 }
3953 GlobalB = x
3954 }
3955
3956 func BenchmarkTan(b *testing.B) {
3957 x := 0.0
3958 for i := 0; i < b.N; i++ {
3959 x = Tan(.5)
3960 }
3961 GlobalF = x
3962 }
3963
3964 func BenchmarkTanh(b *testing.B) {
3965 x := 0.0
3966 for i := 0; i < b.N; i++ {
3967 x = Tanh(2.5)
3968 }
3969 GlobalF = x
3970 }
3971 func BenchmarkTrunc(b *testing.B) {
3972 x := 0.0
3973 for i := 0; i < b.N; i++ {
3974 x = Trunc(.5)
3975 }
3976 GlobalF = x
3977 }
3978
3979 func BenchmarkTrunc32(b *testing.B) {
3980 var x, src float32 = 0.0, .5
3981 for i := 0; i < b.N; i++ {
3982 x = float32(Trunc(float64(src)))
3983 }
3984 GlobalF32 = x
3985 }
3986
3987 func BenchmarkY0(b *testing.B) {
3988 x := 0.0
3989 for i := 0; i < b.N; i++ {
3990 x = Y0(2.5)
3991 }
3992 GlobalF = x
3993 }
3994
3995 func BenchmarkY1(b *testing.B) {
3996 x := 0.0
3997 for i := 0; i < b.N; i++ {
3998 x = Y1(2.5)
3999 }
4000 GlobalF = x
4001 }
4002
4003 func BenchmarkYn(b *testing.B) {
4004 x := 0.0
4005 for i := 0; i < b.N; i++ {
4006 x = Yn(2, 2.5)
4007 }
4008 GlobalF = x
4009 }
4010
4011 func BenchmarkFloat64bits(b *testing.B) {
4012 y := uint64(0)
4013 for i := 0; i < b.N; i++ {
4014 y = Float64bits(roundNeg)
4015 }
4016 GlobalI = int(y)
4017 }
4018
4019 var roundUint64 = uint64(5)
4020
4021 func BenchmarkFloat64frombits(b *testing.B) {
4022 x := 0.0
4023 for i := 0; i < b.N; i++ {
4024 x = Float64frombits(roundUint64)
4025 }
4026 GlobalF = x
4027 }
4028
4029 var roundFloat32 = float32(-2.5)
4030
4031 func BenchmarkFloat32bits(b *testing.B) {
4032 y := uint32(0)
4033 for i := 0; i < b.N; i++ {
4034 y = Float32bits(roundFloat32)
4035 }
4036 GlobalI = int(y)
4037 }
4038
4039 var roundUint32 = uint32(5)
4040
4041 func BenchmarkFloat32frombits(b *testing.B) {
4042 x := float32(0.0)
4043 for i := 0; i < b.N; i++ {
4044 x = Float32frombits(roundUint32)
4045 }
4046 GlobalF = float64(x)
4047 }
4048
4049 func BenchmarkFMA(b *testing.B) {
4050 x := 0.0
4051 for i := 0; i < b.N; i++ {
4052 x = FMA(E, Pi, x)
4053 }
4054 GlobalF = x
4055 }
4056
View as plain text