1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
14 4.9790119248836735e+00,
15 7.7388724745781045e+00,
16 -2.7688005719200159e-01,
17 -5.0106036182710749e+00,
18 9.6362937071984173e+00,
19 2.9263772392439646e+00,
20 5.2290834314593066e+00,
21 2.7279399104360102e+00,
22 1.8253080916808550e+00,
23 -8.6859247685756013e+00,
26 // The expected results below were computed by the high precision calculators
27 // at http://keisan.casio.com/. More exact input values (array vf[], above)
28 // were obtained by printing them with "%.26f". The answers were calculated
29 // to 26 digits (by using the "Digit number" drop-down control of each
32 1.0496193546107222142571536e+00,
33 6.8584012813664425171660692e-01,
34 1.5984878714577160325521819e+00,
35 2.0956199361475859327461799e+00,
36 2.7053008467824138592616927e-01,
37 1.2738121680361776018155625e+00,
38 1.0205369421140629186287407e+00,
39 1.2945003481781246062157835e+00,
40 1.3872364345374451433846657e+00,
41 2.6231510803970463967294145e+00,
43 var acosh
= []float64{
44 2.4743347004159012494457618e+00,
45 2.8576385344292769649802701e+00,
46 7.2796961502981066190593175e-01,
47 2.4796794418831451156471977e+00,
48 3.0552020742306061857212962e+00,
49 2.044238592688586588942468e+00,
50 2.5158701513104513595766636e+00,
51 1.99050839282411638174299e+00,
52 1.6988625798424034227205445e+00,
53 2.9611454842470387925531875e+00,
56 5.2117697218417440497416805e-01,
57 8.8495619865825236751471477e-01,
58 -02.769154466281941332086016e-02,
59 -5.2482360935268931351485822e-01,
60 1.3002662421166552333051524e+00,
61 2.9698415875871901741575922e-01,
62 5.5025938468083370060258102e-01,
63 2.7629597861677201301553823e-01,
64 1.83559892257451475846656e-01,
65 -1.0523547536021497774980928e+00,
67 var asinh
= []float64{
68 2.3083139124923523427628243e+00,
69 2.743551594301593620039021e+00,
70 -2.7345908534880091229413487e-01,
71 -2.3145157644718338650499085e+00,
72 2.9613652154015058521951083e+00,
73 1.7949041616585821933067568e+00,
74 2.3564032905983506405561554e+00,
75 1.7287118790768438878045346e+00,
76 1.3626658083714826013073193e+00,
77 -2.8581483626513914445234004e+00,
80 1.372590262129621651920085e+00,
81 1.442290609645298083020664e+00,
82 -2.7011324359471758245192595e-01,
83 -1.3738077684543379452781531e+00,
84 1.4673921193587666049154681e+00,
85 1.2415173565870168649117764e+00,
86 1.3818396865615168979966498e+00,
87 1.2194305844639670701091426e+00,
88 1.0696031952318783760193244e+00,
89 -1.4561721938838084990898679e+00,
91 var atanh
= []float64{
92 5.4651163712251938116878204e-01,
93 1.0299474112843111224914709e+00,
94 -2.7695084420740135145234906e-02,
95 -5.5072096119207195480202529e-01,
96 1.9943940993171843235906642e+00,
97 3.01448604578089708203017e-01,
98 5.8033427206942188834370595e-01,
99 2.7987997499441511013958297e-01,
100 1.8459947964298794318714228e-01,
101 -1.3273186910532645867272502e+00,
103 var atan2
= []float64{
104 1.1088291730037004444527075e+00,
105 9.1218183188715804018797795e-01,
106 1.5984772603216203736068915e+00,
107 2.0352918654092086637227327e+00,
108 8.0391819139044720267356014e-01,
109 1.2861075249894661588866752e+00,
110 1.0889904479131695712182587e+00,
111 1.3044821793397925293797357e+00,
112 1.3902530903455392306872261e+00,
113 2.2859857424479142655411058e+00,
115 var cbrt
= []float64{
116 1.7075799841925094446722675e+00,
117 1.9779982212970353936691498e+00,
118 -6.5177429017779910853339447e-01,
119 -1.7111838886544019873338113e+00,
120 2.1279920909827937423960472e+00,
121 1.4303536770460741452312367e+00,
122 1.7357021059106154902341052e+00,
123 1.3972633462554328350552916e+00,
124 1.2221149580905388454977636e+00,
125 -2.0556003730500069110343596e+00,
127 var ceil
= []float64{
128 5.0000000000000000e+00,
129 8.0000000000000000e+00,
130 0.0000000000000000e+00,
131 -5.0000000000000000e+00,
132 1.0000000000000000e+01,
133 3.0000000000000000e+00,
134 6.0000000000000000e+00,
135 3.0000000000000000e+00,
136 2.0000000000000000e+00,
137 -8.0000000000000000e+00,
139 var copysign
= []float64{
140 -4.9790119248836735e+00,
141 -7.7388724745781045e+00,
142 -2.7688005719200159e-01,
143 -5.0106036182710749e+00,
144 -9.6362937071984173e+00,
145 -2.9263772392439646e+00,
146 -5.2290834314593066e+00,
147 -2.7279399104360102e+00,
148 -1.8253080916808550e+00,
149 -8.6859247685756013e+00,
152 2.634752140995199110787593e-01,
153 1.148551260848219865642039e-01,
154 9.6191297325640768154550453e-01,
155 2.938141150061714816890637e-01,
156 -9.777138189897924126294461e-01,
157 -9.7693041344303219127199518e-01,
158 4.940088096948647263961162e-01,
159 -9.1565869021018925545016502e-01,
160 -2.517729313893103197176091e-01,
161 -7.39241351595676573201918e-01,
164 // Results for 100000 * Pi + vf[i]
165 var cosLarge
= []float64{
166 2.634752141185559426744e-01,
167 1.14855126055543100712e-01,
168 9.61912973266488928113e-01,
169 2.9381411499556122552e-01,
170 -9.777138189880161924641e-01,
171 -9.76930413445147608049e-01,
172 4.940088097314976789841e-01,
173 -9.15658690217517835002e-01,
174 -2.51772931436786954751e-01,
175 -7.3924135157173099849e-01,
177 var cosh
= []float64{
178 7.2668796942212842775517446e+01,
179 1.1479413465659254502011135e+03,
180 1.0385767908766418550935495e+00,
181 7.5000957789658051428857788e+01,
182 7.655246669605357888468613e+03,
183 9.3567491758321272072888257e+00,
184 9.331351599270605471131735e+01,
185 7.6833430994624643209296404e+00,
186 3.1829371625150718153881164e+00,
187 2.9595059261916188501640911e+03,
190 5.1865354817738701906913566e-01,
191 7.2623875834137295116929844e-01,
192 -3.123458688281309990629839e-02,
193 -5.2143121110253302920437013e-01,
194 8.2704742671312902508629582e-01,
195 3.2101767558376376743993945e-01,
196 5.403990312223245516066252e-01,
197 3.0034702916738588551174831e-01,
198 2.0369924417882241241559589e-01,
199 -7.8069386968009226729944677e-01,
201 var erfc
= []float64{
202 4.8134645182261298093086434e-01,
203 2.7376124165862704883070156e-01,
204 1.0312345868828130999062984e+00,
205 1.5214312111025330292043701e+00,
206 1.7295257328687097491370418e-01,
207 6.7898232441623623256006055e-01,
208 4.596009687776754483933748e-01,
209 6.9965297083261411448825169e-01,
210 7.9630075582117758758440411e-01,
211 1.7806938696800922672994468e+00,
214 1.4533071302642137507696589e+02,
215 2.2958822575694449002537581e+03,
216 7.5814542574851666582042306e-01,
217 6.6668778421791005061482264e-03,
218 1.5310493273896033740861206e+04,
219 1.8659907517999328638667732e+01,
220 1.8662167355098714543942057e+02,
221 1.5301332413189378961665788e+01,
222 6.2047063430646876349125085e+00,
223 1.6894712385826521111610438e-04,
225 var expm1
= []float64{
226 5.105047796122957327384770212e-02,
227 8.046199708567344080562675439e-02,
228 -2.764970978891639815187418703e-03,
229 -4.8871434888875355394330300273e-02,
230 1.0115864277221467777117227494e-01,
231 2.969616407795910726014621657e-02,
232 5.368214487944892300914037972e-02,
233 2.765488851131274068067445335e-02,
234 1.842068661871398836913874273e-02,
235 -8.3193870863553801814961137573e-02,
237 var expm1Large
= []float64{
238 4.2031418113550844e+21,
239 4.0690789717473863e+33,
240 -0.9372627915981363e+00,
242 7.077694784145933e+41,
243 5.117936223839153e+12,
244 5.124137759001189e+22,
245 7.03546003972584e+11,
246 8.456921800389698e+07,
249 var exp2
= []float64{
250 3.1537839463286288034313104e+01,
251 2.1361549283756232296144849e+02,
252 8.2537402562185562902577219e-01,
253 3.1021158628740294833424229e-02,
254 7.9581744110252191462569661e+02,
255 7.6019905892596359262696423e+00,
256 3.7506882048388096973183084e+01,
257 6.6250893439173561733216375e+00,
258 3.5438267900243941544605339e+00,
259 2.4281533133513300984289196e-03,
261 var fabs
= []float64{
262 4.9790119248836735e+00,
263 7.7388724745781045e+00,
264 2.7688005719200159e-01,
265 5.0106036182710749e+00,
266 9.6362937071984173e+00,
267 2.9263772392439646e+00,
268 5.2290834314593066e+00,
269 2.7279399104360102e+00,
270 1.8253080916808550e+00,
271 8.6859247685756013e+00,
273 var fdim
= []float64{
274 4.9790119248836735e+00,
275 7.7388724745781045e+00,
276 0.0000000000000000e+00,
277 0.0000000000000000e+00,
278 9.6362937071984173e+00,
279 2.9263772392439646e+00,
280 5.2290834314593066e+00,
281 2.7279399104360102e+00,
282 1.8253080916808550e+00,
283 0.0000000000000000e+00,
285 var floor
= []float64{
286 4.0000000000000000e+00,
287 7.0000000000000000e+00,
288 -1.0000000000000000e+00,
289 -6.0000000000000000e+00,
290 9.0000000000000000e+00,
291 2.0000000000000000e+00,
292 5.0000000000000000e+00,
293 2.0000000000000000e+00,
294 1.0000000000000000e+00,
295 -9.0000000000000000e+00,
297 var fmod
= []float64{
298 4.197615023265299782906368e-02,
299 2.261127525421895434476482e+00,
300 3.231794108794261433104108e-02,
301 4.989396381728925078391512e+00,
302 3.637062928015826201999516e-01,
303 1.220868282268106064236690e+00,
304 4.770916568540693347699744e+00,
305 1.816180268691969246219742e+00,
306 8.734595415957246977711748e-01,
307 1.314075231424398637614104e+00,
316 {6.2237649061045918750e-01, 3},
317 {9.6735905932226306250e-01, 3},
318 {-5.5376011438400318000e-01, -1},
319 {-6.2632545228388436250e-01, 3},
320 {6.02268356699901081250e-01, 4},
321 {7.3159430981099115000e-01, 2},
322 {6.5363542893241332500e-01, 3},
323 {6.8198497760900255000e-01, 2},
324 {9.1265404584042750000e-01, 1},
325 {-5.4287029803597508250e-01, 4},
327 var gamma
= []float64{
328 2.3254348370739963835386613898e+01,
329 2.991153837155317076427529816e+03,
330 -4.561154336726758060575129109e+00,
331 7.719403468842639065959210984e-01,
332 1.6111876618855418534325755566e+05,
333 1.8706575145216421164173224946e+00,
334 3.4082787447257502836734201635e+01,
335 1.579733951448952054898583387e+00,
336 9.3834586598354592860187267089e-01,
337 -2.093995902923148389186189429e-05,
340 -1.8444682230601672018219338e-01,
341 2.27353668906331975435892e-01,
342 9.809259936157051116270273e-01,
343 -1.741170131426226587841181e-01,
344 -2.1389448451144143352039069e-01,
345 -2.340905848928038763337414e-01,
346 -1.0029099691890912094586326e-01,
347 -1.5466726714884328135358907e-01,
348 3.252650187653420388714693e-01,
349 -8.72218484409407250005360235e-03,
352 -3.251526395295203422162967e-01,
353 1.893581711430515718062564e-01,
354 -1.3711761352467242914491514e-01,
355 3.287486536269617297529617e-01,
356 1.3133899188830978473849215e-01,
357 3.660243417832986825301766e-01,
358 -3.4436769271848174665420672e-01,
359 4.329481396640773768835036e-01,
360 5.8181350531954794639333955e-01,
361 -2.7030574577733036112996607e-01,
364 5.3837518920137802565192769e-02,
365 -1.7841678003393207281244667e-01,
366 9.521746934916464142495821e-03,
367 4.28958355470987397983072e-02,
368 2.4115371837854494725492872e-01,
369 4.842458532394520316844449e-01,
370 -3.142145220618633390125946e-02,
371 4.720849184745124761189957e-01,
372 3.122312022520957042957497e-01,
373 7.096213118930231185707277e-02,
376 -3.684042080996403091021151e-01,
377 2.8157665936340887268092661e-01,
378 4.401005480841948348343589e-04,
379 3.629926999056814081597135e-01,
380 3.123672198825455192489266e-02,
381 -2.958805510589623607540455e-01,
382 -3.2033177696533233403289416e-01,
383 -2.592737332129663376736604e-01,
384 -1.0241334641061485092351251e-01,
385 -2.3762660886100206491674503e-01,
388 {3.146492141244545774319734e+00, 1},
389 {8.003414490659126375852113e+00, 1},
390 {1.517575735509779707488106e+00, -1},
391 {-2.588480028182145853558748e-01, 1},
392 {1.1989897050205555002007985e+01, 1},
393 {6.262899811091257519386906e-01, 1},
394 {3.5287924899091566764846037e+00, 1},
395 {4.5725644770161182299423372e-01, 1},
396 {-6.363667087767961257654854e-02, 1},
397 {-1.077385130910300066425564e+01, -1},
400 1.605231462693062999102599e+00,
401 2.0462560018708770653153909e+00,
402 -1.2841708730962657801275038e+00,
403 1.6115563905281545116286206e+00,
404 2.2655365644872016636317461e+00,
405 1.0737652208918379856272735e+00,
406 1.6542360106073546632707956e+00,
407 1.0035467127723465801264487e+00,
408 6.0174879014578057187016475e-01,
409 2.161703872847352815363655e+00,
411 var logb
= []float64{
412 2.0000000000000000e+00,
413 2.0000000000000000e+00,
414 -2.0000000000000000e+00,
415 2.0000000000000000e+00,
416 3.0000000000000000e+00,
417 1.0000000000000000e+00,
418 2.0000000000000000e+00,
419 1.0000000000000000e+00,
420 0.0000000000000000e+00,
421 3.0000000000000000e+00,
423 var log10
= []float64{
424 6.9714316642508290997617083e-01,
425 8.886776901739320576279124e-01,
426 -5.5770832400658929815908236e-01,
427 6.998900476822994346229723e-01,
428 9.8391002850684232013281033e-01,
429 4.6633031029295153334285302e-01,
430 7.1842557117242328821552533e-01,
431 4.3583479968917773161304553e-01,
432 2.6133617905227038228626834e-01,
433 9.3881606348649405716214241e-01,
435 var log1p
= []float64{
436 4.8590257759797794104158205e-02,
437 7.4540265965225865330849141e-02,
438 -2.7726407903942672823234024e-03,
439 -5.1404917651627649094953380e-02,
440 9.1998280672258624681335010e-02,
441 2.8843762576593352865894824e-02,
442 5.0969534581863707268992645e-02,
443 2.6913947602193238458458594e-02,
444 1.8088493239630770262045333e-02,
445 -9.0865245631588989681559268e-02,
447 var log2
= []float64{
448 2.3158594707062190618898251e+00,
449 2.9521233862883917703341018e+00,
450 -1.8526669502700329984917062e+00,
451 2.3249844127278861543568029e+00,
452 3.268478366538305087466309e+00,
453 1.5491157592596970278166492e+00,
454 2.3865580889631732407886495e+00,
455 1.447811865817085365540347e+00,
456 8.6813999540425116282815557e-01,
457 3.118679457227342224364709e+00,
459 var modf
= [][2]float64{
460 {4.0000000000000000e+00, 9.7901192488367350108546816e-01},
461 {7.0000000000000000e+00, 7.3887247457810456552351752e-01},
462 {Copysign(0, -1), -2.7688005719200159404635997e-01},
463 {-5.0000000000000000e+00, -1.060361827107492160848778e-02},
464 {9.0000000000000000e+00, 6.3629370719841737980004837e-01},
465 {2.0000000000000000e+00, 9.2637723924396464525443662e-01},
466 {5.0000000000000000e+00, 2.2908343145930665230025625e-01},
467 {2.0000000000000000e+00, 7.2793991043601025126008608e-01},
468 {1.0000000000000000e+00, 8.2530809168085506044576505e-01},
469 {-8.0000000000000000e+00, -6.8592476857560136238589621e-01},
471 var nextafter32
= []float32{
472 4.979012489318848e+00,
473 7.738873004913330e+00,
474 -2.768800258636475e-01,
475 -5.010602951049805e+00,
476 9.636294364929199e+00,
477 2.926377534866333e+00,
478 5.229084014892578e+00,
479 2.727940082550049e+00,
480 1.825308203697205e+00,
481 -8.685923576354980e+00,
483 var nextafter64
= []float64{
484 4.97901192488367438926388786e+00,
485 7.73887247457810545370193722e+00,
486 -2.7688005719200153853520874e-01,
487 -5.01060361827107403343006808e+00,
488 9.63629370719841915615688777e+00,
489 2.92637723924396508934364647e+00,
490 5.22908343145930754047867595e+00,
491 2.72793991043601069534929593e+00,
492 1.82530809168085528249036997e+00,
493 -8.68592476857559958602905681e+00,
496 9.5282232631648411840742957e+04,
497 5.4811599352999901232411871e+07,
498 5.2859121715894396531132279e-01,
499 9.7587991957286474464259698e-06,
500 4.328064329346044846740467e+09,
501 8.4406761805034547437659092e+02,
502 1.6946633276191194947742146e+05,
503 5.3449040147551939075312879e+02,
504 6.688182138451414936380374e+01,
505 2.0609869004248742886827439e-09,
507 var remainder
= []float64{
508 4.197615023265299782906368e-02,
509 2.261127525421895434476482e+00,
510 3.231794108794261433104108e-02,
511 -2.120723654214984321697556e-02,
512 3.637062928015826201999516e-01,
513 1.220868282268106064236690e+00,
514 -4.581668629186133046005125e-01,
515 -9.117596417440410050403443e-01,
516 8.734595415957246977711748e-01,
517 1.314075231424398637614104e+00,
519 var signbit
= []bool{
532 -9.6466616586009283766724726e-01,
533 9.9338225271646545763467022e-01,
534 -2.7335587039794393342449301e-01,
535 9.5586257685042792878173752e-01,
536 -2.099421066779969164496634e-01,
537 2.135578780799860532750616e-01,
538 -8.694568971167362743327708e-01,
539 4.019566681155577786649878e-01,
540 9.6778633541687993721617774e-01,
541 -6.734405869050344734943028e-01,
544 // Results for 100000 * Pi + vf[i]
545 var sinLarge
= []float64{
546 -9.646661658548936063912e-01,
547 9.933822527198506903752e-01,
548 -2.7335587036246899796e-01,
549 9.55862576853689321268e-01,
550 -2.099421066862688873691e-01,
551 2.13557878070308981163e-01,
552 -8.694568970959221300497e-01,
553 4.01956668098863248917e-01,
554 9.67786335404528727927e-01,
555 -6.7344058693131973066e-01,
557 var sinh
= []float64{
558 7.2661916084208532301448439e+01,
559 1.1479409110035194500526446e+03,
560 -2.8043136512812518927312641e-01,
561 -7.499429091181587232835164e+01,
562 7.6552466042906758523925934e+03,
563 9.3031583421672014313789064e+00,
564 9.330815755828109072810322e+01,
565 7.6179893137269146407361477e+00,
566 3.021769180549615819524392e+00,
567 -2.95950575724449499189888e+03,
569 var sqrt
= []float64{
570 2.2313699659365484748756904e+00,
571 2.7818829009464263511285458e+00,
572 5.2619393496314796848143251e-01,
573 2.2384377628763938724244104e+00,
574 3.1042380236055381099288487e+00,
575 1.7106657298385224403917771e+00,
576 2.286718922705479046148059e+00,
577 1.6516476350711159636222979e+00,
578 1.3510396336454586262419247e+00,
579 2.9471892997524949215723329e+00,
582 -3.661316565040227801781974e+00,
583 8.64900232648597589369854e+00,
584 -2.8417941955033612725238097e-01,
585 3.253290185974728640827156e+00,
586 2.147275640380293804770778e-01,
587 -2.18600910711067004921551e-01,
588 -1.760002817872367935518928e+00,
589 -4.389808914752818126249079e-01,
590 -3.843885560201130679995041e+00,
591 9.10988793377685105753416e-01,
594 // Results for 100000 * Pi + vf[i]
595 var tanLarge
= []float64{
596 -3.66131656475596512705e+00,
597 8.6490023287202547927e+00,
598 -2.841794195104782406e-01,
599 3.2532901861033120983e+00,
600 2.14727564046880001365e-01,
601 -2.18600910700688062874e-01,
602 -1.760002817699722747043e+00,
603 -4.38980891453536115952e-01,
604 -3.84388555942723509071e+00,
605 9.1098879344275101051e-01,
607 var tanh
= []float64{
608 9.9990531206936338549262119e-01,
609 9.9999962057085294197613294e-01,
610 -2.7001505097318677233756845e-01,
611 -9.9991110943061718603541401e-01,
612 9.9999999146798465745022007e-01,
613 9.9427249436125236705001048e-01,
614 9.9994257600983138572705076e-01,
615 9.9149409509772875982054701e-01,
616 9.4936501296239685514466577e-01,
617 -9.9999994291374030946055701e-01,
619 var trunc
= []float64{
620 4.0000000000000000e+00,
621 7.0000000000000000e+00,
622 -0.0000000000000000e+00,
623 -5.0000000000000000e+00,
624 9.0000000000000000e+00,
625 2.0000000000000000e+00,
626 5.0000000000000000e+00,
627 2.0000000000000000e+00,
628 1.0000000000000000e+00,
629 -8.0000000000000000e+00,
632 -3.053399153780788357534855e-01,
633 1.7437227649515231515503649e-01,
634 -8.6221781263678836910392572e-01,
635 -3.100664880987498407872839e-01,
636 1.422200649300982280645377e-01,
637 4.000004067997901144239363e-01,
638 -3.3340749753099352392332536e-01,
639 4.5399790746668954555205502e-01,
640 4.8290004112497761007536522e-01,
641 2.7036697826604756229601611e-01,
644 0.15494213737457922210218611,
645 -0.2165955142081145245075746,
646 -2.4644949631241895201032829,
647 0.1442740489541836405154505,
648 0.2215379960518984777080163,
649 0.3038800915160754150565448,
650 0.0691107642452362383808547,
651 0.2380116417809914424860165,
652 -0.20849492979459761009678934,
653 0.0242503179793232308250804,
656 0.3675780219390303613394936,
657 -0.23034826393250119879267257,
658 -16.939677983817727205631397,
659 0.367653980523052152867791,
660 -0.0962401471767804440353136,
661 -0.1923169356184851105200523,
662 0.35984072054267882391843766,
663 -0.2794987252299739821654982,
664 -0.7113490692587462579757954,
665 -0.2647831587821263302087457,
668 -0.14035984421094849100895341,
669 -0.097535139617792072703973,
670 242.25775994555580176377379,
671 -0.1492267014802818619511046,
672 0.26148702629155918694500469,
673 0.56675383593895176530394248,
674 -0.206150264009006981070575,
675 0.64784284687568332737963658,
676 1.3503631555901938037008443,
677 0.1461869756579956803341844,
680 // arguments and expected results for special cases
681 var vfacosSC
= []float64{
687 var acosSC
= []float64{
694 var vfacoshSC
= []float64{
701 var acoshSC
= []float64{
709 var vfasinSC
= []float64{
716 var asinSC
= []float64{
724 var vfasinhSC
= []float64{
731 var asinhSC
= []float64{
739 var vfatanSC
= []float64{
746 var atanSC
= []float64{
754 var vfatanhSC
= []float64{
765 var atanhSC
= []float64{
776 var vfatan2SC
= [][2]float64{
787 {Copysign(0, -1), Inf(-1)},
788 {Copysign(0, -1), -Pi
},
789 {Copysign(0, -1), Copysign(0, -1)},
790 {Copysign(0, -1), 0},
791 {Copysign(0, -1), +Pi
},
792 {Copysign(0, -1), Inf(1)},
793 {Copysign(0, -1), NaN()},
796 {0, Copysign(0, -1)},
813 var atan2SC
= []float64{
814 -3 * Pi
/ 4, // atan2(-Inf, -Inf)
815 -Pi
/ 2, // atan2(-Inf, -Pi)
816 -Pi
/ 2, // atan2(-Inf, +0)
817 -Pi
/ 2, // atan2(-Inf, +Pi)
818 -Pi
/ 4, // atan2(-Inf, +Inf)
819 NaN(), // atan2(-Inf, NaN)
820 -Pi
, // atan2(-Pi, -Inf)
821 -Pi
/ 2, // atan2(-Pi, +0)
822 Copysign(0, -1), // atan2(-Pi, Inf)
823 NaN(), // atan2(-Pi, NaN)
824 -Pi
, // atan2(-0, -Inf)
825 -Pi
, // atan2(-0, -Pi)
826 -Pi
, // atan2(-0, -0)
827 Copysign(0, -1), // atan2(-0, +0)
828 Copysign(0, -1), // atan2(-0, +Pi)
829 Copysign(0, -1), // atan2(-0, +Inf)
830 NaN(), // atan2(-0, NaN)
831 Pi
, // atan2(+0, -Inf)
832 Pi
, // atan2(+0, -Pi)
836 0, // atan2(+0, +Inf)
837 NaN(), // atan2(+0, NaN)
838 Pi
, // atan2(+Pi, -Inf)
839 Pi
/ 2, // atan2(+Pi, +0)
840 0, // atan2(+Pi, +Inf)
841 NaN(), // atan2(+Pi, NaN)
842 3 * Pi
/ 4, // atan2(+Inf, -Inf)
843 Pi
/ 2, // atan2(+Inf, -Pi)
844 Pi
/ 2, // atan2(+Inf, +0)
845 Pi
/ 2, // atan2(+Inf, +Pi)
846 Pi
/ 4, // atan2(+Inf, +Inf)
847 NaN(), // atan2(+Inf, NaN)
848 NaN(), // atan2(NaN, NaN)
851 var vfcbrtSC
= []float64{
858 var cbrtSC
= []float64{
866 var vfceilSC
= []float64{
873 var ceilSC
= []float64{
881 var vfcopysignSC
= []float64{
886 var copysignSC
= []float64{
892 var vfcosSC
= []float64{
897 var cosSC
= []float64{
903 var vfcoshSC
= []float64{
910 var coshSC
= []float64{
918 var vferfSC
= []float64{
925 var erfSC
= []float64{
933 var vferfcSC
= []float64{
938 var erfcSC
= []float64{
944 var vfexpSC
= []float64{
951 var expSC
= []float64{
959 var vfexpm1SC
= []float64{
968 var expm1SC
= []float64{
978 var vffabsSC
= []float64{
985 var fabsSC
= []float64{
993 var vffdimSC
= [][2]float64{
997 {Copysign(0, -1), Copysign(0, -1)},
998 {Copysign(0, -1), 0},
999 {0, Copysign(0, -1)},
1005 {NaN(), Copysign(0, -1)},
1010 var nan
= Float64frombits(0xFFF8000000000000) // SSE2 DIVSD 0/0
1011 var vffdim2SC
= [][2]float64{
1015 {Copysign(0, -1), Copysign(0, -1)},
1016 {Copysign(0, -1), 0},
1017 {0, Copysign(0, -1)},
1023 {nan
, Copysign(0, -1)},
1028 var fdimSC
= []float64{
1045 var fmaxSC
= []float64{
1062 var fminSC
= []float64{
1080 var vffmodSC
= [][2]float64{
1091 {Copysign(0, -1), Inf(-1)},
1092 {Copysign(0, -1), 0},
1093 {Copysign(0, -1), Inf(1)},
1094 {Copysign(0, -1), NaN()},
1116 var fmodSC
= []float64{
1117 NaN(), // fmod(-Inf, -Inf)
1118 NaN(), // fmod(-Inf, -Pi)
1119 NaN(), // fmod(-Inf, 0)
1120 NaN(), // fmod(-Inf, Pi)
1121 NaN(), // fmod(-Inf, +Inf)
1122 NaN(), // fmod(-Inf, NaN)
1123 -Pi
, // fmod(-Pi, -Inf)
1124 NaN(), // fmod(-Pi, 0)
1125 -Pi
, // fmod(-Pi, +Inf)
1126 NaN(), // fmod(-Pi, NaN)
1127 Copysign(0, -1), // fmod(-0, -Inf)
1128 NaN(), // fmod(-0, 0)
1129 Copysign(0, -1), // fmod(-0, Inf)
1130 NaN(), // fmod(-0, NaN)
1132 NaN(), // fmod(0, 0)
1134 NaN(), // fmod(0, NaN)
1135 Pi
, // fmod(Pi, -Inf)
1136 NaN(), // fmod(Pi, 0)
1137 Pi
, // fmod(Pi, +Inf)
1138 NaN(), // fmod(Pi, NaN)
1139 NaN(), // fmod(+Inf, -Inf)
1140 NaN(), // fmod(+Inf, -Pi)
1141 NaN(), // fmod(+Inf, 0)
1142 NaN(), // fmod(+Inf, Pi)
1143 NaN(), // fmod(+Inf, +Inf)
1144 NaN(), // fmod(+Inf, NaN)
1145 NaN(), // fmod(NaN, -Inf)
1146 NaN(), // fmod(NaN, -Pi)
1147 NaN(), // fmod(NaN, 0)
1148 NaN(), // fmod(NaN, Pi)
1149 NaN(), // fmod(NaN, +Inf)
1150 NaN(), // fmod(NaN, NaN)
1153 var vffrexpSC
= []float64{
1162 {Copysign(0, -1), 0},
1168 var vfgammaSC
= []float64{
1176 var gammaSC
= []float64{
1185 var vfhypotSC
= [][2]float64{
1190 {Copysign(0, -1), Copysign(0, -1)},
1191 {Copysign(0, -1), 0},
1192 {0, Copysign(0, -1)},
1206 var hypotSC
= []float64{
1228 var ilogbSC
= []int{
1235 var vfj0SC
= []float64{
1241 var j0SC
= []float64{
1247 var j1SC
= []float64{
1253 var j2SC
= []float64{
1259 var jM3SC
= []float64{
1266 var vfldexpSC
= []fi
{
1270 {Copysign(0, -1), 0},
1271 {Copysign(0, -1), -1075},
1272 {Copysign(0, -1), 1024},
1279 var ldexpSC
= []float64{
1293 var vflgammaSC
= []float64{
1302 var lgammaSC
= []fi
{
1312 var vflogSC
= []float64{
1321 var logSC
= []float64{
1331 var vflogbSC
= []float64{
1337 var logbSC
= []float64{
1344 var vflog1pSC
= []float64{
1353 var log1pSC
= []float64{
1363 var vfmodfSC
= []float64{
1369 var modfSC
= [][2]float64{
1370 {Inf(-1), NaN()}, // [2]float64{Copysign(0, -1), Inf(-1)},
1371 {Copysign(0, -1), Copysign(0, -1)},
1372 {Inf(1), NaN()}, // [2]float64{0, Inf(1)},
1376 var vfnextafter32SC
= [][2]float32{
1378 {0, float32(Copysign(0, -1))},
1380 {0, float32(NaN())},
1381 {float32(Copysign(0, -1)), 1},
1382 {float32(Copysign(0, -1)), 0},
1383 {float32(Copysign(0, -1)), float32(Copysign(0, -1))},
1384 {float32(Copysign(0, -1)), -1},
1385 {float32(NaN()), 0},
1386 {float32(NaN()), float32(NaN())},
1388 var nextafter32SC
= []float32{
1391 -1.401298464e-45, // Float32frombits(0x80000001)
1393 1.401298464e-45, // Float32frombits(0x00000001)
1394 float32(Copysign(0, -1)),
1395 float32(Copysign(0, -1)),
1396 -1.401298464e-45, // Float32frombits(0x80000001)
1401 var vfnextafter64SC
= [][2]float64{
1403 {0, Copysign(0, -1)},
1406 {Copysign(0, -1), 1},
1407 {Copysign(0, -1), 0},
1408 {Copysign(0, -1), Copysign(0, -1)},
1409 {Copysign(0, -1), -1},
1413 var nextafter64SC
= []float64{
1416 -4.9406564584124654418e-324, // Float64frombits(0x8000000000000001)
1418 4.9406564584124654418e-324, // Float64frombits(0x0000000000000001)
1421 -4.9406564584124654418e-324, // Float64frombits(0x8000000000000001)
1426 var vfpowSC
= [][2]float64{
1429 {Inf(-1), Copysign(0, -1)},
1438 {-Pi
, Copysign(0, -1)},
1450 {Copysign(0, -1), Inf(-1)},
1451 {Copysign(0, -1), -Pi
},
1452 {Copysign(0, -1), -3},
1453 {Copysign(0, -1), 3},
1454 {Copysign(0, -1), Pi
},
1455 {Copysign(0, -1), Inf(1)},
1460 {0, Copysign(0, -1)},
1474 {Pi
, Copysign(0, -1)},
1480 {Inf(1), Copysign(0, -1)},
1486 {NaN(), Copysign(0, -1)},
1492 var powSC
= []float64{
1493 0, // pow(-Inf, -Pi)
1494 Copysign(0, -1), // pow(-Inf, -3)
1497 Inf(-1), // pow(-Inf, 1)
1498 Inf(-1), // pow(-Inf, 3)
1499 Inf(1), // pow(-Inf, Pi)
1500 NaN(), // pow(-Inf, NaN)
1501 0, // pow(-Pi, -Inf)
1502 NaN(), // pow(-Pi, -Pi)
1506 NaN(), // pow(-Pi, Pi)
1507 Inf(1), // pow(-Pi, +Inf)
1508 NaN(), // pow(-Pi, NaN)
1509 1, // pow(-1, -Inf) IEEE 754-2008
1510 1, // pow(-1, +Inf) IEEE 754-2008
1511 NaN(), // pow(-1, NaN)
1512 Inf(1), // pow(-1/2, -Inf)
1513 0, // pow(-1/2, +Inf)
1514 Inf(1), // pow(-0, -Inf)
1515 Inf(1), // pow(-0, -Pi)
1516 Inf(-1), // pow(-0, -3) IEEE 754-2008
1517 Copysign(0, -1), // pow(-0, 3) IEEE 754-2008
1520 Inf(1), // pow(+0, -Inf)
1521 Inf(1), // pow(+0, -Pi)
1522 Inf(1), // pow(+0, -3)
1528 NaN(), // pow(+0, NaN)
1529 Inf(1), // pow(1/2, -Inf)
1530 0, // pow(1/2, +Inf)
1531 1, // pow(1, -Inf) IEEE 754-2008
1532 1, // pow(1, +Inf) IEEE 754-2008
1533 1, // pow(1, NaN) IEEE 754-2008
1534 0, // pow(+Pi, -Inf)
1538 Inf(1), // pow(+Pi, +Inf)
1539 NaN(), // pow(+Pi, NaN)
1540 0, // pow(+Inf, -Pi)
1543 Inf(1), // pow(+Inf, 1)
1544 Inf(1), // pow(+Inf, Pi)
1545 NaN(), // pow(+Inf, NaN)
1546 NaN(), // pow(NaN, -Pi)
1549 NaN(), // pow(NaN, 1)
1550 NaN(), // pow(NaN, +Pi)
1551 NaN(), // pow(NaN, NaN)
1554 var vfpow10SC
= []int{
1561 var pow10SC
= []float64{
1562 0, // pow10(MinInt32)
1563 Inf(1), // pow10(MaxInt32)
1565 Inf(1), // pow10(309)
1568 var vfsignbitSC
= []float64{
1575 var signbitSC
= []bool{
1583 var vfsinSC
= []float64{
1590 var sinSC
= []float64{
1598 var vfsinhSC
= []float64{
1605 var sinhSC
= []float64{
1613 var vfsqrtSC
= []float64{
1620 Float64frombits(2), // subnormal; see https://golang.org/issue/13013
1622 var sqrtSC
= []float64{
1629 3.1434555694052576e-162,
1632 var vftanhSC
= []float64{
1639 var tanhSC
= []float64{
1647 var vfy0SC
= []float64{
1653 var y0SC
= []float64{
1659 var y1SC
= []float64{
1665 var y2SC
= []float64{
1671 var yM3SC
= []float64{
1678 // arguments and expected results for boundary cases
1680 SmallestNormalFloat64
= 2.2250738585072014e-308 // 2**-1022
1681 LargestSubnormalFloat64
= SmallestNormalFloat64
- SmallestNonzeroFloat64
1684 var vffrexpBC
= []float64{
1685 SmallestNormalFloat64
,
1686 LargestSubnormalFloat64
,
1687 SmallestNonzeroFloat64
,
1689 -SmallestNormalFloat64
,
1690 -LargestSubnormalFloat64
,
1691 -SmallestNonzeroFloat64
,
1696 {0.99999999999999978, -1022},
1698 {0.99999999999999989, 1024},
1700 {-0.99999999999999978, -1022},
1702 {-0.99999999999999989, 1024},
1705 var vfldexpBC
= []fi
{
1706 {SmallestNormalFloat64
, -52},
1707 {LargestSubnormalFloat64
, -51},
1708 {SmallestNonzeroFloat64
, 1074},
1709 {MaxFloat64
, -(1023 + 1074)},
1715 var ldexpBC
= []float64{
1716 SmallestNonzeroFloat64
,
1726 var logbBC
= []float64{
1737 func tolerance(a
, b
, e
float64) bool {
1743 // note: b is correct (expected) value, a is actual value.
1744 // make error tolerance a fraction of b, not a.
1753 func close(a
, b
float64) bool { return tolerance(a
, b
, 1e-14) }
1754 func veryclose(a
, b
float64) bool { return tolerance(a
, b
, 4e-16) }
1755 func soclose(a
, b
, e
float64) bool { return tolerance(a
, b
, e
) }
1756 func alike(a
, b
float64) bool {
1758 case IsNaN(a
) && IsNaN(b
):
1761 return Signbit(a
) == Signbit(b
)
1766 func TestNaN(t
*testing
.T
) {
1769 t
.Fatalf("NaN() returns %g, expected NaN", f64
)
1773 t
.Fatalf("float32(NaN()) is %g, expected NaN", f32
)
1777 func TestAcos(t
*testing
.T
) {
1778 for i
:= 0; i
< len(vf
); i
++ {
1780 if f
:= Acos(a
); !close(acos
[i
], f
) {
1781 t
.Errorf("Acos(%g) = %g, want %g", a
, f
, acos
[i
])
1784 for i
:= 0; i
< len(vfacosSC
); i
++ {
1785 if f
:= Acos(vfacosSC
[i
]); !alike(acosSC
[i
], f
) {
1786 t
.Errorf("Acos(%g) = %g, want %g", vfacosSC
[i
], f
, acosSC
[i
])
1791 func TestAcosh(t
*testing
.T
) {
1792 for i
:= 0; i
< len(vf
); i
++ {
1794 if f
:= Acosh(a
); !veryclose(acosh
[i
], f
) {
1795 t
.Errorf("Acosh(%g) = %g, want %g", a
, f
, acosh
[i
])
1798 for i
:= 0; i
< len(vfacoshSC
); i
++ {
1799 if f
:= Acosh(vfacoshSC
[i
]); !alike(acoshSC
[i
], f
) {
1800 t
.Errorf("Acosh(%g) = %g, want %g", vfacoshSC
[i
], f
, acoshSC
[i
])
1805 func TestAsin(t
*testing
.T
) {
1806 for i
:= 0; i
< len(vf
); i
++ {
1808 if f
:= Asin(a
); !veryclose(asin
[i
], f
) {
1809 t
.Errorf("Asin(%g) = %g, want %g", a
, f
, asin
[i
])
1812 for i
:= 0; i
< len(vfasinSC
); i
++ {
1813 if f
:= Asin(vfasinSC
[i
]); !alike(asinSC
[i
], f
) {
1814 t
.Errorf("Asin(%g) = %g, want %g", vfasinSC
[i
], f
, asinSC
[i
])
1819 func TestAsinh(t
*testing
.T
) {
1820 for i
:= 0; i
< len(vf
); i
++ {
1821 if f
:= Asinh(vf
[i
]); !veryclose(asinh
[i
], f
) {
1822 t
.Errorf("Asinh(%g) = %g, want %g", vf
[i
], f
, asinh
[i
])
1825 for i
:= 0; i
< len(vfasinhSC
); i
++ {
1826 if f
:= Asinh(vfasinhSC
[i
]); !alike(asinhSC
[i
], f
) {
1827 t
.Errorf("Asinh(%g) = %g, want %g", vfasinhSC
[i
], f
, asinhSC
[i
])
1832 func TestAtan(t
*testing
.T
) {
1833 for i
:= 0; i
< len(vf
); i
++ {
1834 if f
:= Atan(vf
[i
]); !veryclose(atan
[i
], f
) {
1835 t
.Errorf("Atan(%g) = %g, want %g", vf
[i
], f
, atan
[i
])
1838 for i
:= 0; i
< len(vfatanSC
); i
++ {
1839 if f
:= Atan(vfatanSC
[i
]); !alike(atanSC
[i
], f
) {
1840 t
.Errorf("Atan(%g) = %g, want %g", vfatanSC
[i
], f
, atanSC
[i
])
1845 func TestAtanh(t
*testing
.T
) {
1846 for i
:= 0; i
< len(vf
); i
++ {
1848 if f
:= Atanh(a
); !veryclose(atanh
[i
], f
) {
1849 t
.Errorf("Atanh(%g) = %g, want %g", a
, f
, atanh
[i
])
1852 for i
:= 0; i
< len(vfatanhSC
); i
++ {
1853 if f
:= Atanh(vfatanhSC
[i
]); !alike(atanhSC
[i
], f
) {
1854 t
.Errorf("Atanh(%g) = %g, want %g", vfatanhSC
[i
], f
, atanhSC
[i
])
1859 func TestAtan2(t
*testing
.T
) {
1860 for i
:= 0; i
< len(vf
); i
++ {
1861 if f
:= Atan2(10, vf
[i
]); !veryclose(atan2
[i
], f
) {
1862 t
.Errorf("Atan2(10, %g) = %g, want %g", vf
[i
], f
, atan2
[i
])
1865 for i
:= 0; i
< len(vfatan2SC
); i
++ {
1866 if f
:= Atan2(vfatan2SC
[i
][0], vfatan2SC
[i
][1]); !alike(atan2SC
[i
], f
) {
1867 t
.Errorf("Atan2(%g, %g) = %g, want %g", vfatan2SC
[i
][0], vfatan2SC
[i
][1], f
, atan2SC
[i
])
1872 func TestCbrt(t
*testing
.T
) {
1873 for i
:= 0; i
< len(vf
); i
++ {
1874 if f
:= Cbrt(vf
[i
]); !veryclose(cbrt
[i
], f
) {
1875 t
.Errorf("Cbrt(%g) = %g, want %g", vf
[i
], f
, cbrt
[i
])
1878 for i
:= 0; i
< len(vfcbrtSC
); i
++ {
1879 if f
:= Cbrt(vfcbrtSC
[i
]); !alike(cbrtSC
[i
], f
) {
1880 t
.Errorf("Cbrt(%g) = %g, want %g", vfcbrtSC
[i
], f
, cbrtSC
[i
])
1885 func TestCeil(t
*testing
.T
) {
1886 for i
:= 0; i
< len(vf
); i
++ {
1887 if f
:= Ceil(vf
[i
]); ceil
[i
] != f
{
1888 t
.Errorf("Ceil(%g) = %g, want %g", vf
[i
], f
, ceil
[i
])
1891 for i
:= 0; i
< len(vfceilSC
); i
++ {
1892 if f
:= Ceil(vfceilSC
[i
]); !alike(ceilSC
[i
], f
) {
1893 t
.Errorf("Ceil(%g) = %g, want %g", vfceilSC
[i
], f
, ceilSC
[i
])
1898 func TestCopysign(t
*testing
.T
) {
1899 for i
:= 0; i
< len(vf
); i
++ {
1900 if f
:= Copysign(vf
[i
], -1); copysign
[i
] != f
{
1901 t
.Errorf("Copysign(%g, -1) = %g, want %g", vf
[i
], f
, copysign
[i
])
1904 for i
:= 0; i
< len(vf
); i
++ {
1905 if f
:= Copysign(vf
[i
], 1); -copysign
[i
] != f
{
1906 t
.Errorf("Copysign(%g, 1) = %g, want %g", vf
[i
], f
, -copysign
[i
])
1909 for i
:= 0; i
< len(vfcopysignSC
); i
++ {
1910 if f
:= Copysign(vfcopysignSC
[i
], -1); !alike(copysignSC
[i
], f
) {
1911 t
.Errorf("Copysign(%g, -1) = %g, want %g", vfcopysignSC
[i
], f
, copysignSC
[i
])
1916 func TestCos(t
*testing
.T
) {
1917 for i
:= 0; i
< len(vf
); i
++ {
1918 if f
:= Cos(vf
[i
]); !veryclose(cos
[i
], f
) {
1919 t
.Errorf("Cos(%g) = %g, want %g", vf
[i
], f
, cos
[i
])
1922 for i
:= 0; i
< len(vfcosSC
); i
++ {
1923 if f
:= Cos(vfcosSC
[i
]); !alike(cosSC
[i
], f
) {
1924 t
.Errorf("Cos(%g) = %g, want %g", vfcosSC
[i
], f
, cosSC
[i
])
1929 func TestCosh(t
*testing
.T
) {
1930 for i
:= 0; i
< len(vf
); i
++ {
1931 if f
:= Cosh(vf
[i
]); !close(cosh
[i
], f
) {
1932 t
.Errorf("Cosh(%g) = %g, want %g", vf
[i
], f
, cosh
[i
])
1935 for i
:= 0; i
< len(vfcoshSC
); i
++ {
1936 if f
:= Cosh(vfcoshSC
[i
]); !alike(coshSC
[i
], f
) {
1937 t
.Errorf("Cosh(%g) = %g, want %g", vfcoshSC
[i
], f
, coshSC
[i
])
1942 func TestErf(t
*testing
.T
) {
1943 for i
:= 0; i
< len(vf
); i
++ {
1945 if f
:= Erf(a
); !veryclose(erf
[i
], f
) {
1946 t
.Errorf("Erf(%g) = %g, want %g", a
, f
, erf
[i
])
1949 for i
:= 0; i
< len(vferfSC
); i
++ {
1950 if f
:= Erf(vferfSC
[i
]); !alike(erfSC
[i
], f
) {
1951 t
.Errorf("Erf(%g) = %g, want %g", vferfSC
[i
], f
, erfSC
[i
])
1956 func TestErfc(t
*testing
.T
) {
1957 for i
:= 0; i
< len(vf
); i
++ {
1959 if f
:= Erfc(a
); !veryclose(erfc
[i
], f
) {
1960 t
.Errorf("Erfc(%g) = %g, want %g", a
, f
, erfc
[i
])
1963 for i
:= 0; i
< len(vferfcSC
); i
++ {
1964 if f
:= Erfc(vferfcSC
[i
]); !alike(erfcSC
[i
], f
) {
1965 t
.Errorf("Erfc(%g) = %g, want %g", vferfcSC
[i
], f
, erfcSC
[i
])
1970 func TestExp(t
*testing
.T
) {
1971 testExp(t
, Exp
, "Exp")
1972 testExp(t
, ExpGo
, "ExpGo")
1975 func testExp(t
*testing
.T
, Exp
func(float64) float64, name
string) {
1976 for i
:= 0; i
< len(vf
); i
++ {
1977 if f
:= Exp(vf
[i
]); !close(exp
[i
], f
) {
1978 t
.Errorf("%s(%g) = %g, want %g", name
, vf
[i
], f
, exp
[i
])
1981 for i
:= 0; i
< len(vfexpSC
); i
++ {
1982 if f
:= Exp(vfexpSC
[i
]); !alike(expSC
[i
], f
) {
1983 t
.Errorf("%s(%g) = %g, want %g", name
, vfexpSC
[i
], f
, expSC
[i
])
1988 func TestExpm1(t
*testing
.T
) {
1989 for i
:= 0; i
< len(vf
); i
++ {
1991 if f
:= Expm1(a
); !veryclose(expm1
[i
], f
) {
1992 t
.Errorf("Expm1(%g) = %g, want %g", a
, f
, expm1
[i
])
1995 for i
:= 0; i
< len(vf
); i
++ {
1997 if f
:= Expm1(a
); !close(expm1Large
[i
], f
) {
1998 t
.Errorf("Expm1(%g) = %g, want %g", a
, f
, expm1Large
[i
])
2001 for i
:= 0; i
< len(vfexpm1SC
); i
++ {
2002 if f
:= Expm1(vfexpm1SC
[i
]); !alike(expm1SC
[i
], f
) {
2003 t
.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC
[i
], f
, expm1SC
[i
])
2008 func TestExp2(t
*testing
.T
) {
2009 testExp2(t
, Exp2
, "Exp2")
2010 testExp2(t
, Exp2Go
, "Exp2Go")
2013 func testExp2(t
*testing
.T
, Exp2
func(float64) float64, name
string) {
2014 for i
:= 0; i
< len(vf
); i
++ {
2015 if f
:= Exp2(vf
[i
]); !close(exp2
[i
], f
) {
2016 t
.Errorf("%s(%g) = %g, want %g", name
, vf
[i
], f
, exp2
[i
])
2019 for i
:= 0; i
< len(vfexpSC
); i
++ {
2020 if f
:= Exp2(vfexpSC
[i
]); !alike(expSC
[i
], f
) {
2021 t
.Errorf("%s(%g) = %g, want %g", name
, vfexpSC
[i
], f
, expSC
[i
])
2024 for n
:= -1074; n
< 1024; n
++ {
2025 f
:= Exp2(float64(n
))
2028 t
.Errorf("%s(%d) = %g, want %g", name
, n
, f
, vf
)
2033 func TestAbs(t
*testing
.T
) {
2034 for i
:= 0; i
< len(vf
); i
++ {
2035 if f
:= Abs(vf
[i
]); fabs
[i
] != f
{
2036 t
.Errorf("Abs(%g) = %g, want %g", vf
[i
], f
, fabs
[i
])
2039 for i
:= 0; i
< len(vffabsSC
); i
++ {
2040 if f
:= Abs(vffabsSC
[i
]); !alike(fabsSC
[i
], f
) {
2041 t
.Errorf("Abs(%g) = %g, want %g", vffabsSC
[i
], f
, fabsSC
[i
])
2046 func TestDim(t
*testing
.T
) {
2047 for i
:= 0; i
< len(vf
); i
++ {
2048 if f
:= Dim(vf
[i
], 0); fdim
[i
] != f
{
2049 t
.Errorf("Dim(%g, %g) = %g, want %g", vf
[i
], 0.0, f
, fdim
[i
])
2052 for i
:= 0; i
< len(vffdimSC
); i
++ {
2053 if f
:= Dim(vffdimSC
[i
][0], vffdimSC
[i
][1]); !alike(fdimSC
[i
], f
) {
2054 t
.Errorf("Dim(%g, %g) = %g, want %g", vffdimSC
[i
][0], vffdimSC
[i
][1], f
, fdimSC
[i
])
2057 for i
:= 0; i
< len(vffdim2SC
); i
++ {
2058 if f
:= Dim(vffdim2SC
[i
][0], vffdim2SC
[i
][1]); !alike(fdimSC
[i
], f
) {
2059 t
.Errorf("Dim(%g, %g) = %g, want %g", vffdim2SC
[i
][0], vffdim2SC
[i
][1], f
, fdimSC
[i
])
2064 func TestFloor(t
*testing
.T
) {
2065 for i
:= 0; i
< len(vf
); i
++ {
2066 if f
:= Floor(vf
[i
]); floor
[i
] != f
{
2067 t
.Errorf("Floor(%g) = %g, want %g", vf
[i
], f
, floor
[i
])
2070 for i
:= 0; i
< len(vfceilSC
); i
++ {
2071 if f
:= Floor(vfceilSC
[i
]); !alike(ceilSC
[i
], f
) {
2072 t
.Errorf("Floor(%g) = %g, want %g", vfceilSC
[i
], f
, ceilSC
[i
])
2077 func TestMax(t
*testing
.T
) {
2078 for i
:= 0; i
< len(vf
); i
++ {
2079 if f
:= Max(vf
[i
], ceil
[i
]); ceil
[i
] != f
{
2080 t
.Errorf("Max(%g, %g) = %g, want %g", vf
[i
], ceil
[i
], f
, ceil
[i
])
2083 for i
:= 0; i
< len(vffdimSC
); i
++ {
2084 if f
:= Max(vffdimSC
[i
][0], vffdimSC
[i
][1]); !alike(fmaxSC
[i
], f
) {
2085 t
.Errorf("Max(%g, %g) = %g, want %g", vffdimSC
[i
][0], vffdimSC
[i
][1], f
, fmaxSC
[i
])
2088 for i
:= 0; i
< len(vffdim2SC
); i
++ {
2089 if f
:= Max(vffdim2SC
[i
][0], vffdim2SC
[i
][1]); !alike(fmaxSC
[i
], f
) {
2090 t
.Errorf("Max(%g, %g) = %g, want %g", vffdim2SC
[i
][0], vffdim2SC
[i
][1], f
, fmaxSC
[i
])
2095 func TestMin(t
*testing
.T
) {
2096 for i
:= 0; i
< len(vf
); i
++ {
2097 if f
:= Min(vf
[i
], floor
[i
]); floor
[i
] != f
{
2098 t
.Errorf("Min(%g, %g) = %g, want %g", vf
[i
], floor
[i
], f
, floor
[i
])
2101 for i
:= 0; i
< len(vffdimSC
); i
++ {
2102 if f
:= Min(vffdimSC
[i
][0], vffdimSC
[i
][1]); !alike(fminSC
[i
], f
) {
2103 t
.Errorf("Min(%g, %g) = %g, want %g", vffdimSC
[i
][0], vffdimSC
[i
][1], f
, fminSC
[i
])
2106 for i
:= 0; i
< len(vffdim2SC
); i
++ {
2107 if f
:= Min(vffdim2SC
[i
][0], vffdim2SC
[i
][1]); !alike(fminSC
[i
], f
) {
2108 t
.Errorf("Min(%g, %g) = %g, want %g", vffdim2SC
[i
][0], vffdim2SC
[i
][1], f
, fminSC
[i
])
2113 func TestMod(t
*testing
.T
) {
2114 for i
:= 0; i
< len(vf
); i
++ {
2115 if f
:= Mod(10, vf
[i
]); fmod
[i
] != f
{
2116 t
.Errorf("Mod(10, %g) = %g, want %g", vf
[i
], f
, fmod
[i
])
2119 for i
:= 0; i
< len(vffmodSC
); i
++ {
2120 if f
:= Mod(vffmodSC
[i
][0], vffmodSC
[i
][1]); !alike(fmodSC
[i
], f
) {
2121 t
.Errorf("Mod(%g, %g) = %g, want %g", vffmodSC
[i
][0], vffmodSC
[i
][1], f
, fmodSC
[i
])
2126 func TestFrexp(t
*testing
.T
) {
2127 for i
:= 0; i
< len(vf
); i
++ {
2128 if f
, j
:= Frexp(vf
[i
]); !veryclose(frexp
[i
].f
, f
) || frexp
[i
].i
!= j
{
2129 t
.Errorf("Frexp(%g) = %g, %d, want %g, %d", vf
[i
], f
, j
, frexp
[i
].f
, frexp
[i
].i
)
2132 for i
:= 0; i
< len(vffrexpSC
); i
++ {
2133 if f
, j
:= Frexp(vffrexpSC
[i
]); !alike(frexpSC
[i
].f
, f
) || frexpSC
[i
].i
!= j
{
2134 t
.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpSC
[i
], f
, j
, frexpSC
[i
].f
, frexpSC
[i
].i
)
2137 for i
:= 0; i
< len(vffrexpBC
); i
++ {
2138 if f
, j
:= Frexp(vffrexpBC
[i
]); !alike(frexpBC
[i
].f
, f
) || frexpBC
[i
].i
!= j
{
2139 t
.Errorf("Frexp(%g) = %g, %d, want %g, %d", vffrexpBC
[i
], f
, j
, frexpBC
[i
].f
, frexpBC
[i
].i
)
2144 func TestGamma(t
*testing
.T
) {
2145 for i
:= 0; i
< len(vf
); i
++ {
2146 if f
:= Gamma(vf
[i
]); !close(gamma
[i
], f
) {
2147 t
.Errorf("Gamma(%g) = %g, want %g", vf
[i
], f
, gamma
[i
])
2150 for i
:= 0; i
< len(vfgammaSC
); i
++ {
2151 if f
:= Gamma(vfgammaSC
[i
]); !alike(gammaSC
[i
], f
) {
2152 t
.Errorf("Gamma(%g) = %g, want %g", vfgammaSC
[i
], f
, gammaSC
[i
])
2157 func TestHypot(t
*testing
.T
) {
2158 for i
:= 0; i
< len(vf
); i
++ {
2159 a
:= Abs(1e200
* tanh
[i
] * Sqrt(2))
2160 if f
:= Hypot(1e200
*tanh
[i
], 1e200
*tanh
[i
]); !veryclose(a
, f
) {
2161 t
.Errorf("Hypot(%g, %g) = %g, want %g", 1e200
*tanh
[i
], 1e200
*tanh
[i
], f
, a
)
2164 for i
:= 0; i
< len(vfhypotSC
); i
++ {
2165 if f
:= Hypot(vfhypotSC
[i
][0], vfhypotSC
[i
][1]); !alike(hypotSC
[i
], f
) {
2166 t
.Errorf("Hypot(%g, %g) = %g, want %g", vfhypotSC
[i
][0], vfhypotSC
[i
][1], f
, hypotSC
[i
])
2171 func TestHypotGo(t
*testing
.T
) {
2172 for i
:= 0; i
< len(vf
); i
++ {
2173 a
:= Abs(1e200
* tanh
[i
] * Sqrt(2))
2174 if f
:= HypotGo(1e200
*tanh
[i
], 1e200
*tanh
[i
]); !veryclose(a
, f
) {
2175 t
.Errorf("HypotGo(%g, %g) = %g, want %g", 1e200
*tanh
[i
], 1e200
*tanh
[i
], f
, a
)
2178 for i
:= 0; i
< len(vfhypotSC
); i
++ {
2179 if f
:= HypotGo(vfhypotSC
[i
][0], vfhypotSC
[i
][1]); !alike(hypotSC
[i
], f
) {
2180 t
.Errorf("HypotGo(%g, %g) = %g, want %g", vfhypotSC
[i
][0], vfhypotSC
[i
][1], f
, hypotSC
[i
])
2185 func TestIlogb(t
*testing
.T
) {
2186 for i
:= 0; i
< len(vf
); i
++ {
2187 a
:= frexp
[i
].i
- 1 // adjust because fr in the interval [½, 1)
2188 if e
:= Ilogb(vf
[i
]); a
!= e
{
2189 t
.Errorf("Ilogb(%g) = %d, want %d", vf
[i
], e
, a
)
2192 for i
:= 0; i
< len(vflogbSC
); i
++ {
2193 if e
:= Ilogb(vflogbSC
[i
]); ilogbSC
[i
] != e
{
2194 t
.Errorf("Ilogb(%g) = %d, want %d", vflogbSC
[i
], e
, ilogbSC
[i
])
2197 for i
:= 0; i
< len(vffrexpBC
); i
++ {
2198 if e
:= Ilogb(vffrexpBC
[i
]); int(logbBC
[i
]) != e
{
2199 t
.Errorf("Ilogb(%g) = %d, want %d", vffrexpBC
[i
], e
, int(logbBC
[i
]))
2204 func TestJ0(t
*testing
.T
) {
2205 for i
:= 0; i
< len(vf
); i
++ {
2206 if f
:= J0(vf
[i
]); !soclose(j0
[i
], f
, 4e-14) {
2207 t
.Errorf("J0(%g) = %g, want %g", vf
[i
], f
, j0
[i
])
2210 for i
:= 0; i
< len(vfj0SC
); i
++ {
2211 if f
:= J0(vfj0SC
[i
]); !alike(j0SC
[i
], f
) {
2212 t
.Errorf("J0(%g) = %g, want %g", vfj0SC
[i
], f
, j0SC
[i
])
2217 func TestJ1(t
*testing
.T
) {
2218 for i
:= 0; i
< len(vf
); i
++ {
2219 if f
:= J1(vf
[i
]); !close(j1
[i
], f
) {
2220 t
.Errorf("J1(%g) = %g, want %g", vf
[i
], f
, j1
[i
])
2223 for i
:= 0; i
< len(vfj0SC
); i
++ {
2224 if f
:= J1(vfj0SC
[i
]); !alike(j1SC
[i
], f
) {
2225 t
.Errorf("J1(%g) = %g, want %g", vfj0SC
[i
], f
, j1SC
[i
])
2230 func TestJn(t
*testing
.T
) {
2231 for i
:= 0; i
< len(vf
); i
++ {
2232 if f
:= Jn(2, vf
[i
]); !close(j2
[i
], f
) {
2233 t
.Errorf("Jn(2, %g) = %g, want %g", vf
[i
], f
, j2
[i
])
2235 if f
:= Jn(-3, vf
[i
]); !close(jM3
[i
], f
) {
2236 t
.Errorf("Jn(-3, %g) = %g, want %g", vf
[i
], f
, jM3
[i
])
2239 for i
:= 0; i
< len(vfj0SC
); i
++ {
2240 if f
:= Jn(2, vfj0SC
[i
]); !alike(j2SC
[i
], f
) {
2241 t
.Errorf("Jn(2, %g) = %g, want %g", vfj0SC
[i
], f
, j2SC
[i
])
2243 if f
:= Jn(-3, vfj0SC
[i
]); !alike(jM3SC
[i
], f
) {
2244 t
.Errorf("Jn(-3, %g) = %g, want %g", vfj0SC
[i
], f
, jM3SC
[i
])
2249 func TestLdexp(t
*testing
.T
) {
2250 for i
:= 0; i
< len(vf
); i
++ {
2251 if f
:= Ldexp(frexp
[i
].f
, frexp
[i
].i
); !veryclose(vf
[i
], f
) {
2252 t
.Errorf("Ldexp(%g, %d) = %g, want %g", frexp
[i
].f
, frexp
[i
].i
, f
, vf
[i
])
2255 for i
:= 0; i
< len(vffrexpSC
); i
++ {
2256 if f
:= Ldexp(frexpSC
[i
].f
, frexpSC
[i
].i
); !alike(vffrexpSC
[i
], f
) {
2257 t
.Errorf("Ldexp(%g, %d) = %g, want %g", frexpSC
[i
].f
, frexpSC
[i
].i
, f
, vffrexpSC
[i
])
2260 for i
:= 0; i
< len(vfldexpSC
); i
++ {
2261 if f
:= Ldexp(vfldexpSC
[i
].f
, vfldexpSC
[i
].i
); !alike(ldexpSC
[i
], f
) {
2262 t
.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpSC
[i
].f
, vfldexpSC
[i
].i
, f
, ldexpSC
[i
])
2265 for i
:= 0; i
< len(vffrexpBC
); i
++ {
2266 if f
:= Ldexp(frexpBC
[i
].f
, frexpBC
[i
].i
); !alike(vffrexpBC
[i
], f
) {
2267 t
.Errorf("Ldexp(%g, %d) = %g, want %g", frexpBC
[i
].f
, frexpBC
[i
].i
, f
, vffrexpBC
[i
])
2270 for i
:= 0; i
< len(vfldexpBC
); i
++ {
2271 if f
:= Ldexp(vfldexpBC
[i
].f
, vfldexpBC
[i
].i
); !alike(ldexpBC
[i
], f
) {
2272 t
.Errorf("Ldexp(%g, %d) = %g, want %g", vfldexpBC
[i
].f
, vfldexpBC
[i
].i
, f
, ldexpBC
[i
])
2277 func TestLgamma(t
*testing
.T
) {
2278 for i
:= 0; i
< len(vf
); i
++ {
2279 if f
, s
:= Lgamma(vf
[i
]); !close(lgamma
[i
].f
, f
) || lgamma
[i
].i
!= s
{
2280 t
.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vf
[i
], f
, s
, lgamma
[i
].f
, lgamma
[i
].i
)
2283 for i
:= 0; i
< len(vflgammaSC
); i
++ {
2284 if f
, s
:= Lgamma(vflgammaSC
[i
]); !alike(lgammaSC
[i
].f
, f
) || lgammaSC
[i
].i
!= s
{
2285 t
.Errorf("Lgamma(%g) = %g, %d, want %g, %d", vflgammaSC
[i
], f
, s
, lgammaSC
[i
].f
, lgammaSC
[i
].i
)
2290 func TestLog(t
*testing
.T
) {
2291 for i
:= 0; i
< len(vf
); i
++ {
2293 if f
:= Log(a
); log
[i
] != f
{
2294 t
.Errorf("Log(%g) = %g, want %g", a
, f
, log
[i
])
2297 if f
:= Log(10); f
!= Ln10
{
2298 t
.Errorf("Log(%g) = %g, want %g", 10.0, f
, Ln10
)
2300 for i
:= 0; i
< len(vflogSC
); i
++ {
2301 if f
:= Log(vflogSC
[i
]); !alike(logSC
[i
], f
) {
2302 t
.Errorf("Log(%g) = %g, want %g", vflogSC
[i
], f
, logSC
[i
])
2307 func TestLogb(t
*testing
.T
) {
2308 for i
:= 0; i
< len(vf
); i
++ {
2309 if f
:= Logb(vf
[i
]); logb
[i
] != f
{
2310 t
.Errorf("Logb(%g) = %g, want %g", vf
[i
], f
, logb
[i
])
2313 for i
:= 0; i
< len(vflogbSC
); i
++ {
2314 if f
:= Logb(vflogbSC
[i
]); !alike(logbSC
[i
], f
) {
2315 t
.Errorf("Logb(%g) = %g, want %g", vflogbSC
[i
], f
, logbSC
[i
])
2318 for i
:= 0; i
< len(vffrexpBC
); i
++ {
2319 if f
:= Logb(vffrexpBC
[i
]); !alike(logbBC
[i
], f
) {
2320 t
.Errorf("Logb(%g) = %g, want %g", vffrexpBC
[i
], f
, logbBC
[i
])
2325 func TestLog10(t
*testing
.T
) {
2326 for i
:= 0; i
< len(vf
); i
++ {
2328 if f
:= Log10(a
); !veryclose(log10
[i
], f
) {
2329 t
.Errorf("Log10(%g) = %g, want %g", a
, f
, log10
[i
])
2332 if f
:= Log10(E
); f
!= Log10E
{
2333 t
.Errorf("Log10(%g) = %g, want %g", E
, f
, Log10E
)
2335 for i
:= 0; i
< len(vflogSC
); i
++ {
2336 if f
:= Log10(vflogSC
[i
]); !alike(logSC
[i
], f
) {
2337 t
.Errorf("Log10(%g) = %g, want %g", vflogSC
[i
], f
, logSC
[i
])
2342 func TestLog1p(t
*testing
.T
) {
2343 for i
:= 0; i
< len(vf
); i
++ {
2345 if f
:= Log1p(a
); !veryclose(log1p
[i
], f
) {
2346 t
.Errorf("Log1p(%g) = %g, want %g", a
, f
, log1p
[i
])
2350 if f
:= Log1p(a
); f
!= Ln10
{
2351 t
.Errorf("Log1p(%g) = %g, want %g", a
, f
, Ln10
)
2353 for i
:= 0; i
< len(vflogSC
); i
++ {
2354 if f
:= Log1p(vflog1pSC
[i
]); !alike(log1pSC
[i
], f
) {
2355 t
.Errorf("Log1p(%g) = %g, want %g", vflog1pSC
[i
], f
, log1pSC
[i
])
2360 func TestLog2(t
*testing
.T
) {
2361 for i
:= 0; i
< len(vf
); i
++ {
2363 if f
:= Log2(a
); !veryclose(log2
[i
], f
) {
2364 t
.Errorf("Log2(%g) = %g, want %g", a
, f
, log2
[i
])
2367 if f
:= Log2(E
); f
!= Log2E
{
2368 t
.Errorf("Log2(%g) = %g, want %g", E
, f
, Log2E
)
2370 for i
:= 0; i
< len(vflogSC
); i
++ {
2371 if f
:= Log2(vflogSC
[i
]); !alike(logSC
[i
], f
) {
2372 t
.Errorf("Log2(%g) = %g, want %g", vflogSC
[i
], f
, logSC
[i
])
2375 for i
:= -1074; i
<= 1023; i
++ {
2378 if l
!= float64(i
) {
2379 t
.Errorf("Log2(2**%d) = %g, want %d", i
, l
, i
)
2384 func TestModf(t
*testing
.T
) {
2385 for i
:= 0; i
< len(vf
); i
++ {
2386 if f
, g
:= Modf(vf
[i
]); !veryclose(modf
[i
][0], f
) ||
!veryclose(modf
[i
][1], g
) {
2387 t
.Errorf("Modf(%g) = %g, %g, want %g, %g", vf
[i
], f
, g
, modf
[i
][0], modf
[i
][1])
2390 for i
:= 0; i
< len(vfmodfSC
); i
++ {
2391 if f
, g
:= Modf(vfmodfSC
[i
]); !alike(modfSC
[i
][0], f
) ||
!alike(modfSC
[i
][1], g
) {
2392 t
.Errorf("Modf(%g) = %g, %g, want %g, %g", vfmodfSC
[i
], f
, g
, modfSC
[i
][0], modfSC
[i
][1])
2397 func TestNextafter32(t
*testing
.T
) {
2398 for i
:= 0; i
< len(vf
); i
++ {
2399 vfi
:= float32(vf
[i
])
2400 if f
:= Nextafter32(vfi
, 10); nextafter32
[i
] != f
{
2401 t
.Errorf("Nextafter32(%g, %g) = %g want %g", vfi
, 10.0, f
, nextafter32
[i
])
2404 for i
:= 0; i
< len(vfnextafter32SC
); i
++ {
2405 if f
:= Nextafter32(vfnextafter32SC
[i
][0], vfnextafter32SC
[i
][1]); !alike(float64(nextafter32SC
[i
]), float64(f
)) {
2406 t
.Errorf("Nextafter32(%g, %g) = %g want %g", vfnextafter32SC
[i
][0], vfnextafter32SC
[i
][1], f
, nextafter32SC
[i
])
2411 func TestNextafter64(t
*testing
.T
) {
2412 for i
:= 0; i
< len(vf
); i
++ {
2413 if f
:= Nextafter(vf
[i
], 10); nextafter64
[i
] != f
{
2414 t
.Errorf("Nextafter64(%g, %g) = %g want %g", vf
[i
], 10.0, f
, nextafter64
[i
])
2417 for i
:= 0; i
< len(vfnextafter64SC
); i
++ {
2418 if f
:= Nextafter(vfnextafter64SC
[i
][0], vfnextafter64SC
[i
][1]); !alike(nextafter64SC
[i
], f
) {
2419 t
.Errorf("Nextafter64(%g, %g) = %g want %g", vfnextafter64SC
[i
][0], vfnextafter64SC
[i
][1], f
, nextafter64SC
[i
])
2424 func TestPow(t
*testing
.T
) {
2425 for i
:= 0; i
< len(vf
); i
++ {
2426 if f
:= Pow(10, vf
[i
]); !close(pow
[i
], f
) {
2427 t
.Errorf("Pow(10, %g) = %g, want %g", vf
[i
], f
, pow
[i
])
2430 for i
:= 0; i
< len(vfpowSC
); i
++ {
2431 if f
:= Pow(vfpowSC
[i
][0], vfpowSC
[i
][1]); !alike(powSC
[i
], f
) {
2432 t
.Errorf("Pow(%g, %g) = %g, want %g", vfpowSC
[i
][0], vfpowSC
[i
][1], f
, powSC
[i
])
2437 func TestPow10(t
*testing
.T
) {
2438 for i
:= 0; i
< len(vfpow10SC
); i
++ {
2439 if f
:= Pow10(vfpow10SC
[i
]); !alike(pow10SC
[i
], f
) {
2440 t
.Errorf("Pow10(%d) = %g, want %g", vfpow10SC
[i
], f
, pow10SC
[i
])
2445 func TestRemainder(t
*testing
.T
) {
2446 for i
:= 0; i
< len(vf
); i
++ {
2447 if f
:= Remainder(10, vf
[i
]); remainder
[i
] != f
{
2448 t
.Errorf("Remainder(10, %g) = %g, want %g", vf
[i
], f
, remainder
[i
])
2451 for i
:= 0; i
< len(vffmodSC
); i
++ {
2452 if f
:= Remainder(vffmodSC
[i
][0], vffmodSC
[i
][1]); !alike(fmodSC
[i
], f
) {
2453 t
.Errorf("Remainder(%g, %g) = %g, want %g", vffmodSC
[i
][0], vffmodSC
[i
][1], f
, fmodSC
[i
])
2458 func TestSignbit(t
*testing
.T
) {
2459 for i
:= 0; i
< len(vf
); i
++ {
2460 if f
:= Signbit(vf
[i
]); signbit
[i
] != f
{
2461 t
.Errorf("Signbit(%g) = %t, want %t", vf
[i
], f
, signbit
[i
])
2464 for i
:= 0; i
< len(vfsignbitSC
); i
++ {
2465 if f
:= Signbit(vfsignbitSC
[i
]); signbitSC
[i
] != f
{
2466 t
.Errorf("Signbit(%g) = %t, want %t", vfsignbitSC
[i
], f
, signbitSC
[i
])
2470 func TestSin(t
*testing
.T
) {
2471 for i
:= 0; i
< len(vf
); i
++ {
2472 if f
:= Sin(vf
[i
]); !veryclose(sin
[i
], f
) {
2473 t
.Errorf("Sin(%g) = %g, want %g", vf
[i
], f
, sin
[i
])
2476 for i
:= 0; i
< len(vfsinSC
); i
++ {
2477 if f
:= Sin(vfsinSC
[i
]); !alike(sinSC
[i
], f
) {
2478 t
.Errorf("Sin(%g) = %g, want %g", vfsinSC
[i
], f
, sinSC
[i
])
2483 func TestSincos(t
*testing
.T
) {
2484 for i
:= 0; i
< len(vf
); i
++ {
2485 if s
, c
:= Sincos(vf
[i
]); !veryclose(sin
[i
], s
) ||
!veryclose(cos
[i
], c
) {
2486 t
.Errorf("Sincos(%g) = %g, %g want %g, %g", vf
[i
], s
, c
, sin
[i
], cos
[i
])
2491 func TestSinh(t
*testing
.T
) {
2492 for i
:= 0; i
< len(vf
); i
++ {
2493 if f
:= Sinh(vf
[i
]); !close(sinh
[i
], f
) {
2494 t
.Errorf("Sinh(%g) = %g, want %g", vf
[i
], f
, sinh
[i
])
2497 for i
:= 0; i
< len(vfsinhSC
); i
++ {
2498 if f
:= Sinh(vfsinhSC
[i
]); !alike(sinhSC
[i
], f
) {
2499 t
.Errorf("Sinh(%g) = %g, want %g", vfsinhSC
[i
], f
, sinhSC
[i
])
2504 func TestSqrt(t
*testing
.T
) {
2505 for i
:= 0; i
< len(vf
); i
++ {
2507 if f
:= SqrtGo(a
); sqrt
[i
] != f
{
2508 t
.Errorf("SqrtGo(%g) = %g, want %g", a
, f
, sqrt
[i
])
2511 if f
:= Sqrt(a
); sqrt
[i
] != f
{
2512 t
.Errorf("Sqrt(%g) = %g, want %g", a
, f
, sqrt
[i
])
2515 for i
:= 0; i
< len(vfsqrtSC
); i
++ {
2516 if f
:= SqrtGo(vfsqrtSC
[i
]); !alike(sqrtSC
[i
], f
) {
2517 t
.Errorf("SqrtGo(%g) = %g, want %g", vfsqrtSC
[i
], f
, sqrtSC
[i
])
2519 if f
:= Sqrt(vfsqrtSC
[i
]); !alike(sqrtSC
[i
], f
) {
2520 t
.Errorf("Sqrt(%g) = %g, want %g", vfsqrtSC
[i
], f
, sqrtSC
[i
])
2525 func TestTan(t
*testing
.T
) {
2526 for i
:= 0; i
< len(vf
); i
++ {
2527 if f
:= Tan(vf
[i
]); !veryclose(tan
[i
], f
) {
2528 t
.Errorf("Tan(%g) = %g, want %g", vf
[i
], f
, tan
[i
])
2531 // same special cases as Sin
2532 for i
:= 0; i
< len(vfsinSC
); i
++ {
2533 if f
:= Tan(vfsinSC
[i
]); !alike(sinSC
[i
], f
) {
2534 t
.Errorf("Tan(%g) = %g, want %g", vfsinSC
[i
], f
, sinSC
[i
])
2539 func TestTanh(t
*testing
.T
) {
2540 for i
:= 0; i
< len(vf
); i
++ {
2541 if f
:= Tanh(vf
[i
]); !veryclose(tanh
[i
], f
) {
2542 t
.Errorf("Tanh(%g) = %g, want %g", vf
[i
], f
, tanh
[i
])
2545 for i
:= 0; i
< len(vftanhSC
); i
++ {
2546 if f
:= Tanh(vftanhSC
[i
]); !alike(tanhSC
[i
], f
) {
2547 t
.Errorf("Tanh(%g) = %g, want %g", vftanhSC
[i
], f
, tanhSC
[i
])
2552 func TestTrunc(t
*testing
.T
) {
2553 for i
:= 0; i
< len(vf
); i
++ {
2554 if f
:= Trunc(vf
[i
]); trunc
[i
] != f
{
2555 t
.Errorf("Trunc(%g) = %g, want %g", vf
[i
], f
, trunc
[i
])
2558 for i
:= 0; i
< len(vfceilSC
); i
++ {
2559 if f
:= Trunc(vfceilSC
[i
]); !alike(ceilSC
[i
], f
) {
2560 t
.Errorf("Trunc(%g) = %g, want %g", vfceilSC
[i
], f
, ceilSC
[i
])
2565 func TestY0(t
*testing
.T
) {
2566 for i
:= 0; i
< len(vf
); i
++ {
2568 if f
:= Y0(a
); !close(y0
[i
], f
) {
2569 t
.Errorf("Y0(%g) = %g, want %g", a
, f
, y0
[i
])
2572 for i
:= 0; i
< len(vfy0SC
); i
++ {
2573 if f
:= Y0(vfy0SC
[i
]); !alike(y0SC
[i
], f
) {
2574 t
.Errorf("Y0(%g) = %g, want %g", vfy0SC
[i
], f
, y0SC
[i
])
2579 func TestY1(t
*testing
.T
) {
2580 for i
:= 0; i
< len(vf
); i
++ {
2582 if f
:= Y1(a
); !soclose(y1
[i
], f
, 2e-14) {
2583 t
.Errorf("Y1(%g) = %g, want %g", a
, f
, y1
[i
])
2586 for i
:= 0; i
< len(vfy0SC
); i
++ {
2587 if f
:= Y1(vfy0SC
[i
]); !alike(y1SC
[i
], f
) {
2588 t
.Errorf("Y1(%g) = %g, want %g", vfy0SC
[i
], f
, y1SC
[i
])
2593 func TestYn(t
*testing
.T
) {
2594 for i
:= 0; i
< len(vf
); i
++ {
2596 if f
:= Yn(2, a
); !close(y2
[i
], f
) {
2597 t
.Errorf("Yn(2, %g) = %g, want %g", a
, f
, y2
[i
])
2599 if f
:= Yn(-3, a
); !close(yM3
[i
], f
) {
2600 t
.Errorf("Yn(-3, %g) = %g, want %g", a
, f
, yM3
[i
])
2603 for i
:= 0; i
< len(vfy0SC
); i
++ {
2604 if f
:= Yn(2, vfy0SC
[i
]); !alike(y2SC
[i
], f
) {
2605 t
.Errorf("Yn(2, %g) = %g, want %g", vfy0SC
[i
], f
, y2SC
[i
])
2607 if f
:= Yn(-3, vfy0SC
[i
]); !alike(yM3SC
[i
], f
) {
2608 t
.Errorf("Yn(-3, %g) = %g, want %g", vfy0SC
[i
], f
, yM3SC
[i
])
2613 // Check that math functions of high angle values
2614 // return accurate results. [Since (vf[i] + large) - large != vf[i],
2615 // testing for Trig(vf[i] + large) == Trig(vf[i]), where large is
2616 // a multiple of 2*Pi, is misleading.]
2617 func TestLargeCos(t
*testing
.T
) {
2618 large
:= float64(100000 * Pi
)
2619 for i
:= 0; i
< len(vf
); i
++ {
2621 f2
:= Cos(vf
[i
] + large
)
2623 t
.Errorf("Cos(%g) = %g, want %g", vf
[i
]+large
, f2
, f1
)
2628 func TestLargeSin(t
*testing
.T
) {
2629 large
:= float64(100000 * Pi
)
2630 for i
:= 0; i
< len(vf
); i
++ {
2632 f2
:= Sin(vf
[i
] + large
)
2634 t
.Errorf("Sin(%g) = %g, want %g", vf
[i
]+large
, f2
, f1
)
2639 func TestLargeSincos(t
*testing
.T
) {
2640 large
:= float64(100000 * Pi
)
2641 for i
:= 0; i
< len(vf
); i
++ {
2642 f1
, g1
:= sinLarge
[i
], cosLarge
[i
]
2643 f2
, g2
:= Sincos(vf
[i
] + large
)
2644 if !close(f1
, f2
) ||
!close(g1
, g2
) {
2645 t
.Errorf("Sincos(%g) = %g, %g, want %g, %g", vf
[i
]+large
, f2
, g2
, f1
, g1
)
2650 func TestLargeTan(t
*testing
.T
) {
2651 large
:= float64(100000 * Pi
)
2652 for i
:= 0; i
< len(vf
); i
++ {
2654 f2
:= Tan(vf
[i
] + large
)
2656 t
.Errorf("Tan(%g) = %g, want %g", vf
[i
]+large
, f2
, f1
)
2661 // Check that math constants are accepted by compiler
2662 // and have right value (assumes strconv.ParseFloat works).
2663 // https://golang.org/issue/201
2665 type floatTest
struct {
2671 var floatTests
= []floatTest
{
2672 {float64(MaxFloat64
), "MaxFloat64", "1.7976931348623157e+308"},
2673 {float64(SmallestNonzeroFloat64
), "SmallestNonzeroFloat64", "5e-324"},
2674 {float32(MaxFloat32
), "MaxFloat32", "3.4028235e+38"},
2675 {float32(SmallestNonzeroFloat32
), "SmallestNonzeroFloat32", "1e-45"},
2678 func TestFloatMinMax(t
*testing
.T
) {
2679 for _
, tt
:= range floatTests
{
2680 s
:= fmt
.Sprint(tt
.val
)
2682 t
.Errorf("Sprint(%v) = %s, want %s", tt
.name
, s
, tt
.str
)
2689 func BenchmarkAcos(b
*testing
.B
) {
2690 for i
:= 0; i
< b
.N
; i
++ {
2695 func BenchmarkAcosh(b
*testing
.B
) {
2696 for i
:= 0; i
< b
.N
; i
++ {
2701 func BenchmarkAsin(b
*testing
.B
) {
2702 for i
:= 0; i
< b
.N
; i
++ {
2707 func BenchmarkAsinh(b
*testing
.B
) {
2708 for i
:= 0; i
< b
.N
; i
++ {
2713 func BenchmarkAtan(b
*testing
.B
) {
2714 for i
:= 0; i
< b
.N
; i
++ {
2719 func BenchmarkAtanh(b
*testing
.B
) {
2720 for i
:= 0; i
< b
.N
; i
++ {
2725 func BenchmarkAtan2(b
*testing
.B
) {
2726 for i
:= 0; i
< b
.N
; i
++ {
2731 func BenchmarkCbrt(b
*testing
.B
) {
2732 for i
:= 0; i
< b
.N
; i
++ {
2737 func BenchmarkCeil(b
*testing
.B
) {
2738 for i
:= 0; i
< b
.N
; i
++ {
2743 func BenchmarkCopysign(b
*testing
.B
) {
2744 for i
:= 0; i
< b
.N
; i
++ {
2749 func BenchmarkCos(b
*testing
.B
) {
2750 for i
:= 0; i
< b
.N
; i
++ {
2755 func BenchmarkCosh(b
*testing
.B
) {
2756 for i
:= 0; i
< b
.N
; i
++ {
2761 func BenchmarkErf(b
*testing
.B
) {
2762 for i
:= 0; i
< b
.N
; i
++ {
2767 func BenchmarkErfc(b
*testing
.B
) {
2768 for i
:= 0; i
< b
.N
; i
++ {
2773 func BenchmarkExp(b
*testing
.B
) {
2774 for i
:= 0; i
< b
.N
; i
++ {
2779 func BenchmarkExpGo(b
*testing
.B
) {
2780 for i
:= 0; i
< b
.N
; i
++ {
2785 func BenchmarkExpm1(b
*testing
.B
) {
2786 for i
:= 0; i
< b
.N
; i
++ {
2791 func BenchmarkExp2(b
*testing
.B
) {
2792 for i
:= 0; i
< b
.N
; i
++ {
2797 func BenchmarkExp2Go(b
*testing
.B
) {
2798 for i
:= 0; i
< b
.N
; i
++ {
2803 func BenchmarkAbs(b
*testing
.B
) {
2804 for i
:= 0; i
< b
.N
; i
++ {
2809 func BenchmarkDim(b
*testing
.B
) {
2810 for i
:= 0; i
< b
.N
; i
++ {
2815 func BenchmarkFloor(b
*testing
.B
) {
2816 for i
:= 0; i
< b
.N
; i
++ {
2821 func BenchmarkMax(b
*testing
.B
) {
2822 for i
:= 0; i
< b
.N
; i
++ {
2827 func BenchmarkMin(b
*testing
.B
) {
2828 for i
:= 0; i
< b
.N
; i
++ {
2833 func BenchmarkMod(b
*testing
.B
) {
2834 for i
:= 0; i
< b
.N
; i
++ {
2839 func BenchmarkFrexp(b
*testing
.B
) {
2840 for i
:= 0; i
< b
.N
; i
++ {
2845 func BenchmarkGamma(b
*testing
.B
) {
2846 for i
:= 0; i
< b
.N
; i
++ {
2851 func BenchmarkHypot(b
*testing
.B
) {
2852 for i
:= 0; i
< b
.N
; i
++ {
2857 func BenchmarkHypotGo(b
*testing
.B
) {
2858 for i
:= 0; i
< b
.N
; i
++ {
2863 func BenchmarkIlogb(b
*testing
.B
) {
2864 for i
:= 0; i
< b
.N
; i
++ {
2869 func BenchmarkJ0(b
*testing
.B
) {
2870 for i
:= 0; i
< b
.N
; i
++ {
2875 func BenchmarkJ1(b
*testing
.B
) {
2876 for i
:= 0; i
< b
.N
; i
++ {
2881 func BenchmarkJn(b
*testing
.B
) {
2882 for i
:= 0; i
< b
.N
; i
++ {
2887 func BenchmarkLdexp(b
*testing
.B
) {
2888 for i
:= 0; i
< b
.N
; i
++ {
2893 func BenchmarkLgamma(b
*testing
.B
) {
2894 for i
:= 0; i
< b
.N
; i
++ {
2899 func BenchmarkLog(b
*testing
.B
) {
2900 for i
:= 0; i
< b
.N
; i
++ {
2905 func BenchmarkLogb(b
*testing
.B
) {
2906 for i
:= 0; i
< b
.N
; i
++ {
2911 func BenchmarkLog1p(b
*testing
.B
) {
2912 for i
:= 0; i
< b
.N
; i
++ {
2917 func BenchmarkLog10(b
*testing
.B
) {
2918 for i
:= 0; i
< b
.N
; i
++ {
2923 func BenchmarkLog2(b
*testing
.B
) {
2924 for i
:= 0; i
< b
.N
; i
++ {
2929 func BenchmarkModf(b
*testing
.B
) {
2930 for i
:= 0; i
< b
.N
; i
++ {
2935 func BenchmarkNextafter32(b
*testing
.B
) {
2936 for i
:= 0; i
< b
.N
; i
++ {
2941 func BenchmarkNextafter64(b
*testing
.B
) {
2942 for i
:= 0; i
< b
.N
; i
++ {
2947 func BenchmarkPowInt(b
*testing
.B
) {
2948 for i
:= 0; i
< b
.N
; i
++ {
2953 func BenchmarkPowFrac(b
*testing
.B
) {
2954 for i
:= 0; i
< b
.N
; i
++ {
2959 func BenchmarkPow10Pos(b
*testing
.B
) {
2960 for i
:= 0; i
< b
.N
; i
++ {
2965 func BenchmarkPow10Neg(b
*testing
.B
) {
2966 for i
:= 0; i
< b
.N
; i
++ {
2971 func BenchmarkRemainder(b
*testing
.B
) {
2972 for i
:= 0; i
< b
.N
; i
++ {
2977 func BenchmarkSignbit(b
*testing
.B
) {
2978 for i
:= 0; i
< b
.N
; i
++ {
2983 func BenchmarkSin(b
*testing
.B
) {
2984 for i
:= 0; i
< b
.N
; i
++ {
2989 func BenchmarkSincos(b
*testing
.B
) {
2990 for i
:= 0; i
< b
.N
; i
++ {
2995 func BenchmarkSinh(b
*testing
.B
) {
2996 for i
:= 0; i
< b
.N
; i
++ {
3003 func BenchmarkSqrt(b
*testing
.B
) {
3005 for i
:= 0; i
< b
.N
; i
++ {
3011 func BenchmarkSqrtIndirect(b
*testing
.B
) {
3014 for i
:= 0; i
< b
.N
; i
++ {
3020 func BenchmarkSqrtGo(b
*testing
.B
) {
3022 for i
:= 0; i
< b
.N
; i
++ {
3028 func isPrime(i
int) bool {
3029 // Yes, this is a dumb way to write this code,
3030 // but calling Sqrt repeatedly in this way demonstrates
3031 // the benefit of using a direct SQRT instruction on systems
3032 // that have one, whereas the obvious loop seems not to
3033 // demonstrate such a benefit.
3034 for j
:= 2; float64(j
) <= Sqrt(float64(i
)); j
++ {
3042 func BenchmarkSqrtPrime(b
*testing
.B
) {
3044 for i
:= 0; i
< b
.N
; i
++ {
3045 if isPrime(100003) {
3054 func BenchmarkTan(b
*testing
.B
) {
3055 for i
:= 0; i
< b
.N
; i
++ {
3060 func BenchmarkTanh(b
*testing
.B
) {
3061 for i
:= 0; i
< b
.N
; i
++ {
3065 func BenchmarkTrunc(b
*testing
.B
) {
3066 for i
:= 0; i
< b
.N
; i
++ {
3071 func BenchmarkY0(b
*testing
.B
) {
3072 for i
:= 0; i
< b
.N
; i
++ {
3077 func BenchmarkY1(b
*testing
.B
) {
3078 for i
:= 0; i
< b
.N
; i
++ {
3083 func BenchmarkYn(b
*testing
.B
) {
3084 for i
:= 0; i
< b
.N
; i
++ {