]> git.ipfire.org Git - thirdparty/gcc.git/blame - libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/10_cyl_bessel_k/check_value.cc
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Implement TR29124 C++ special Math Functions.
[thirdparty/gcc.git] / libstdc++-v3 / testsuite / tr1 / 5_numerical_facilities / special_functions / 10_cyl_bessel_k / check_value.cc
CommitLineData
7c62b943
BK		 1// 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net>
2//
818ab71a 3// Copyright (C) 2007-2016 Free Software Foundation, Inc.
7c62b943
BK		 4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
748086b7 8// Free Software Foundation; either version 3, or (at your option)
7c62b943
BK		 9// any later version.
10//
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15//
16// You should have received a copy of the GNU General Public License along
748086b7
JJ		 17// with this library; see the file COPYING3. If not see
18// <http://www.gnu.org/licenses/>.
7c62b943
BK		 19
20// cyl_bessel_k
21
22
23// Compare against values generated by the GNU Scientific Library.
24// The GSL can be found on the web: http://www.gnu.org/software/gsl/
25
26#include <tr1/cmath>
27#if defined(__TEST_DEBUG)
28#include <iostream>
29#define VERIFY(A) \
30if (!(A)) \
31 { \
32 std::cout << "line " << __LINE__ \
33 << " max_abs_frac = " << max_abs_frac \
34 << std::endl; \
35 }
36#else
37#include <testsuite_hooks.h>
38#endif
39#include "../testcase.h"
40
41
42// Test data for nu=0.0000000000000000.
43testcase_cyl_bessel_k<double> data001[] = {
2be75957
ESR		 44 { 1.5415067512483025, 0.0000000000000000, 0.25000000000000000 },
45 { 0.92441907122766565, 0.0000000000000000, 0.50000000000000000 },
46 { 0.61058242211646430, 0.0000000000000000, 0.75000000000000000 },
47 { 0.42102443824070829, 0.0000000000000000, 1.0000000000000000 },
48 { 0.29760308908410588, 0.0000000000000000, 1.2500000000000000 },
49 { 0.21380556264752565, 0.0000000000000000, 1.5000000000000000 },
50 { 0.15537981238660362, 0.0000000000000000, 1.7500000000000000 },
51 { 0.11389387274953360, 0.0000000000000000, 2.0000000000000000 },
52 { 0.084043111974658191, 0.0000000000000000, 2.2500000000000000 },
53 { 0.062347553200366168, 0.0000000000000000, 2.5000000000000000 },
54 { 0.046454901308760774, 0.0000000000000000, 2.7500000000000000 },
55 { 0.034739504386279256, 0.0000000000000000, 3.0000000000000000 },
56 { 0.026058755255154966, 0.0000000000000000, 3.2500000000000000 },
57 { 0.019598897170368501, 0.0000000000000000, 3.5000000000000000 },
58 { 0.014774250877128706, 0.0000000000000000, 3.7500000000000000 },
59 { 0.011159676085853026, 0.0000000000000000, 4.0000000000000000 },
60 { 0.0084443877245429649, 0.0000000000000000, 4.2500000000000000 },
61 { 0.0063998572432339747, 0.0000000000000000, 4.5000000000000000 },
62 { 0.0048572045578879524, 0.0000000000000000, 4.7500000000000000 },
63 { 0.0036910983340425947, 0.0000000000000000, 5.0000000000000000 },
64};
65
66// Test function for nu=0.0000000000000000.
67template<typename Tp>
68 void
69 test001()
70 {
71 bool test [[gnu::unused]] = true;
72 const Tp eps = std::numeric_limits<Tp>::epsilon();
73 Tp max_abs_diff = -Tp(1);
74 Tp max_abs_frac = -Tp(1);
75 unsigned int num_datum = sizeof(data001)
76 / sizeof(testcase_cyl_bessel_k<double>);
77 for (unsigned int i = 0; i < num_datum; ++i)
78 {
79 const Tp f = std::tr1::cyl_bessel_k(Tp(data001[i].nu), Tp(data001[i].x));
80 const Tp f0 = data001[i].f0;
81 const Tp diff = f - f0;
82 if (std::abs(diff) > max_abs_diff)
83 max_abs_diff = std::abs(diff);
84 if (std::abs(f0) > Tp(10) * eps
85 && std::abs(f) > Tp(10) * eps)
86 {
87 const Tp frac = diff / f0;
88 if (std::abs(frac) > max_abs_frac)
89 max_abs_frac = std::abs(frac);
90 }
91 }
92 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
93 }
94
95// Test data for nu=0.33333333333333331.
96testcase_cyl_bessel_k<double> data002[] = {
97 { 1.7144912564234518, 0.33333333333333331, 0.25000000000000000 },
98 { 0.98903107424672421, 0.33333333333333331, 0.50000000000000000 },
99 { 0.64216899667282989, 0.33333333333333331, 0.75000000000000000 },
100 { 0.43843063344153432, 0.33333333333333331, 1.0000000000000000 },
101 { 0.30788192414945043, 0.33333333333333331, 1.2500000000000000 },
102 { 0.22015769026776688, 0.33333333333333331, 1.5000000000000000 },
103 { 0.15943413057311245, 0.33333333333333331, 1.7500000000000000 },
104 { 0.11654496129616534, 0.33333333333333331, 2.0000000000000000 },
105 { 0.085809609306439674, 0.33333333333333331, 2.2500000000000000 },
106 { 0.063542537454733386, 0.33333333333333331, 2.5000000000000000 },
107 { 0.047273354184795509, 0.33333333333333331, 2.7500000000000000 },
108 { 0.035305904902162587, 0.33333333333333331, 3.0000000000000000 },
109 { 0.026454186892773169, 0.33333333333333331, 3.2500000000000000 },
110 { 0.019877061407943805, 0.33333333333333331, 3.5000000000000000 },
111 { 0.014971213514760214, 0.33333333333333331, 3.7500000000000000 },
112 { 0.011299947573672165, 0.33333333333333331, 4.0000000000000000 },
113 { 0.0085447959546110473, 0.33333333333333331, 4.2500000000000000 },
114 { 0.0064720581217078237, 0.33333333333333331, 4.5000000000000000 },
115 { 0.0049093342803275264, 0.33333333333333331, 4.7500000000000000 },
116 { 0.0037288750960535887, 0.33333333333333331, 5.0000000000000000 },
117};
118
119// Test function for nu=0.33333333333333331.
120template<typename Tp>
121 void
122 test002()
123 {
124 bool test [[gnu::unused]] = true;
125 const Tp eps = std::numeric_limits<Tp>::epsilon();
126 Tp max_abs_diff = -Tp(1);
127 Tp max_abs_frac = -Tp(1);
128 unsigned int num_datum = sizeof(data002)
129 / sizeof(testcase_cyl_bessel_k<double>);
130 for (unsigned int i = 0; i < num_datum; ++i)
131 {
132 const Tp f = std::tr1::cyl_bessel_k(Tp(data002[i].nu), Tp(data002[i].x));
133 const Tp f0 = data002[i].f0;
134 const Tp diff = f - f0;
135 if (std::abs(diff) > max_abs_diff)
136 max_abs_diff = std::abs(diff);
137 if (std::abs(f0) > Tp(10) * eps
138 && std::abs(f) > Tp(10) * eps)
139 {
140 const Tp frac = diff / f0;
141 if (std::abs(frac) > max_abs_frac)
142 max_abs_frac = std::abs(frac);
143 }
144 }
145 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
146 }
147
148// Test data for nu=0.50000000000000000.
149testcase_cyl_bessel_k<double> data003[] = {
150 { 1.9521640631515476, 0.50000000000000000, 0.25000000000000000 },
151 { 1.0750476034999195, 0.50000000000000000, 0.50000000000000000 },
152 { 0.68361006034952421, 0.50000000000000000, 0.75000000000000000 },
153 { 0.46106850444789454, 0.50000000000000000, 1.0000000000000000 },
154 { 0.32117137397144746, 0.50000000000000000, 1.2500000000000000 },
155 { 0.22833505222826550, 0.50000000000000000, 1.5000000000000000 },
156 { 0.16463628997380864, 0.50000000000000000, 1.7500000000000000 },
157 { 0.11993777196806145, 0.50000000000000000, 2.0000000000000000 },
158 { 0.088065558803650454, 0.50000000000000000, 2.2500000000000000 },
159 { 0.065065943154009986, 0.50000000000000000, 2.5000000000000000 },
160 { 0.048315198301417825, 0.50000000000000000, 2.7500000000000000 },
161 { 0.036025985131764589, 0.50000000000000000, 3.0000000000000000 },
162 { 0.026956356532443351, 0.50000000000000000, 3.2500000000000000 },
163 { 0.020229969578139294, 0.50000000000000000, 3.5000000000000000 },
164 { 0.015220888252975564, 0.50000000000000000, 3.7500000000000000 },
165 { 0.011477624576608052, 0.50000000000000000, 4.0000000000000000 },
166 { 0.0086718932956978342, 0.50000000000000000, 4.2500000000000000 },
167 { 0.0065633945646345407, 0.50000000000000000, 4.5000000000000000 },
168 { 0.0049752435421262292, 0.50000000000000000, 4.7500000000000000 },
169 { 0.0037766133746428825, 0.50000000000000000, 5.0000000000000000 },
170};
171
172// Test function for nu=0.50000000000000000.
173template<typename Tp>
174 void
175 test003()
176 {
177 bool test [[gnu::unused]] = true;
178 const Tp eps = std::numeric_limits<Tp>::epsilon();
179 Tp max_abs_diff = -Tp(1);
180 Tp max_abs_frac = -Tp(1);
181 unsigned int num_datum = sizeof(data003)
182 / sizeof(testcase_cyl_bessel_k<double>);
183 for (unsigned int i = 0; i < num_datum; ++i)
184 {
185 const Tp f = std::tr1::cyl_bessel_k(Tp(data003[i].nu), Tp(data003[i].x));
186 const Tp f0 = data003[i].f0;
187 const Tp diff = f - f0;
188 if (std::abs(diff) > max_abs_diff)
189 max_abs_diff = std::abs(diff);
190 if (std::abs(f0) > Tp(10) * eps
191 && std::abs(f) > Tp(10) * eps)
192 {
193 const Tp frac = diff / f0;
194 if (std::abs(frac) > max_abs_frac)
195 max_abs_frac = std::abs(frac);
196 }
197 }
198 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
199 }
200
201// Test data for nu=0.66666666666666663.
202testcase_cyl_bessel_k<double> data004[] = {
203 { 2.3289060745544101, 0.66666666666666663, 0.25000000000000000 },
204 { 1.2059304647203353, 0.66666666666666663, 0.50000000000000000 },
205 { 0.74547232976647215, 0.66666666666666663, 0.75000000000000000 },
206 { 0.49447506210420827, 0.66666666666666663, 1.0000000000000000 },
207 { 0.34062994813514252, 0.66666666666666663, 1.2500000000000000 },
208 { 0.24024045240315581, 0.66666666666666663, 1.5000000000000000 },
209 { 0.17217716908452310, 0.66666666666666663, 1.7500000000000000 },
210 { 0.12483892748812841, 0.66666666666666663, 2.0000000000000000 },
211 { 0.091315296079621050, 0.66666666666666663, 2.2500000000000000 },
212 { 0.067255322171623361, 0.66666666666666663, 2.5000000000000000 },
213 { 0.049809546542402224, 0.66666666666666663, 2.7500000000000000 },
214 { 0.037057074495188531, 0.66666666666666663, 3.0000000000000000 },
215 { 0.027674365504886729, 0.66666666666666663, 3.2500000000000000 },
216 { 0.020733915836010912, 0.66666666666666663, 3.5000000000000000 },
217 { 0.015577015510251332, 0.66666666666666663, 3.7500000000000000 },
218 { 0.011730801456525336, 0.66666666666666663, 4.0000000000000000 },
219 { 0.0088528343204658851, 0.66666666666666663, 4.2500000000000000 },
220 { 0.0066933190915775560, 0.66666666666666663, 4.5000000000000000 },
221 { 0.0050689292106255480, 0.66666666666666663, 4.7500000000000000 },
222 { 0.0038444246344968226, 0.66666666666666663, 5.0000000000000000 },
223};
224
225// Test function for nu=0.66666666666666663.
226template<typename Tp>
227 void
228 test004()
229 {
230 bool test [[gnu::unused]] = true;
231 const Tp eps = std::numeric_limits<Tp>::epsilon();
232 Tp max_abs_diff = -Tp(1);
233 Tp max_abs_frac = -Tp(1);
234 unsigned int num_datum = sizeof(data004)
235 / sizeof(testcase_cyl_bessel_k<double>);
236 for (unsigned int i = 0; i < num_datum; ++i)
237 {
238 const Tp f = std::tr1::cyl_bessel_k(Tp(data004[i].nu), Tp(data004[i].x));
239 const Tp f0 = data004[i].f0;
240 const Tp diff = f - f0;
241 if (std::abs(diff) > max_abs_diff)
242 max_abs_diff = std::abs(diff);
243 if (std::abs(f0) > Tp(10) * eps
244 && std::abs(f) > Tp(10) * eps)
245 {
246 const Tp frac = diff / f0;
247 if (std::abs(frac) > max_abs_frac)
248 max_abs_frac = std::abs(frac);
249 }
250 }
251 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
252 }
253
254// Test data for nu=1.0000000000000000.
255testcase_cyl_bessel_k<double> data005[] = {
256 { 3.7470259744407115, 1.0000000000000000, 0.25000000000000000 },
257 { 1.6564411200033007, 1.0000000000000000, 0.50000000000000000 },
258 { 0.94958046696214016, 1.0000000000000000, 0.75000000000000000 },
259 { 0.60190723019723458, 1.0000000000000000, 1.0000000000000000 },
260 { 0.40212407978419540, 1.0000000000000000, 1.2500000000000000 },
261 { 0.27738780045684375, 1.0000000000000000, 1.5000000000000000 },
262 { 0.19547745347439310, 1.0000000000000000, 1.7500000000000000 },
263 { 0.13986588181652262, 1.0000000000000000, 2.0000000000000000 },
264 { 0.10121630256832535, 1.0000000000000000, 2.2500000000000000 },
265 { 0.073890816347747038, 1.0000000000000000, 2.5000000000000000 },
266 { 0.054318522758919859, 1.0000000000000000, 2.7500000000000000 },
267 { 0.040156431128194198, 1.0000000000000000, 3.0000000000000000 },
268 { 0.029825529796040143, 1.0000000000000000, 3.2500000000000000 },
269 { 0.022239392925923845, 1.0000000000000000, 3.5000000000000000 },
270 { 0.016638191754688912, 1.0000000000000000, 3.7500000000000000 },
271 { 0.012483498887268435, 1.0000000000000000, 4.0000000000000000 },
272 { 0.0093896806560432589, 1.0000000000000000, 4.2500000000000000 },
273 { 0.0070780949089680901, 1.0000000000000000, 4.5000000000000000 },
274 { 0.0053459218178228390, 1.0000000000000000, 4.7500000000000000 },
275 { 0.0040446134454521655, 1.0000000000000000, 5.0000000000000000 },
276};
277
278// Test function for nu=1.0000000000000000.
279template<typename Tp>
280 void
281 test005()
282 {
283 bool test [[gnu::unused]] = true;
284 const Tp eps = std::numeric_limits<Tp>::epsilon();
285 Tp max_abs_diff = -Tp(1);
286 Tp max_abs_frac = -Tp(1);
287 unsigned int num_datum = sizeof(data005)
288 / sizeof(testcase_cyl_bessel_k<double>);
289 for (unsigned int i = 0; i < num_datum; ++i)
290 {
291 const Tp f = std::tr1::cyl_bessel_k(Tp(data005[i].nu), Tp(data005[i].x));
292 const Tp f0 = data005[i].f0;
293 const Tp diff = f - f0;
294 if (std::abs(diff) > max_abs_diff)
295 max_abs_diff = std::abs(diff);
296 if (std::abs(f0) > Tp(10) * eps
297 && std::abs(f) > Tp(10) * eps)
298 {
299 const Tp frac = diff / f0;
300 if (std::abs(frac) > max_abs_frac)
301 max_abs_frac = std::abs(frac);
302 }
303 }
304 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
305 }
306
307// Test data for nu=2.0000000000000000.
308testcase_cyl_bessel_k<double> data006[] = {
309 { 31.517714546773998, 2.0000000000000000, 0.25000000000000000 },
310 { 7.5501835512408695, 2.0000000000000000, 0.50000000000000000 },
311 { 3.1427970006821715, 2.0000000000000000, 0.75000000000000000 },
312 { 1.6248388986351774, 2.0000000000000000, 1.0000000000000000 },
313 { 0.94100161673881855, 2.0000000000000000, 1.2500000000000000 },
314 { 0.58365596325665070, 2.0000000000000000, 1.5000000000000000 },
315 { 0.37878261635733856, 2.0000000000000000, 1.7500000000000000 },
316 { 0.25375975456605621, 2.0000000000000000, 2.0000000000000000 },
317 { 0.17401315870205850, 2.0000000000000000, 2.2500000000000000 },
318 { 0.12146020627856381, 2.0000000000000000, 2.5000000000000000 },
319 { 0.085959281497066137, 2.0000000000000000, 2.7500000000000000 },
320 { 0.061510458471742059, 2.0000000000000000, 3.0000000000000000 },
321 { 0.044412927437333515, 2.0000000000000000, 3.2500000000000000 },
322 { 0.032307121699467839, 2.0000000000000000, 3.5000000000000000 },
323 { 0.023647953146296127, 2.0000000000000000, 3.7500000000000000 },
324 { 0.017401425529487244, 2.0000000000000000, 4.0000000000000000 },
325 { 0.012863060974445674, 2.0000000000000000, 4.2500000000000000 },
326 { 0.0095456772027753475, 2.0000000000000000, 4.5000000000000000 },
327 { 0.0071081190074975690, 2.0000000000000000, 4.7500000000000000 },
328 { 0.0053089437122234608, 2.0000000000000000, 5.0000000000000000 },
329};
330
331// Test function for nu=2.0000000000000000.
332template<typename Tp>
333 void
334 test006()
335 {
336 bool test [[gnu::unused]] = true;
337 const Tp eps = std::numeric_limits<Tp>::epsilon();
338 Tp max_abs_diff = -Tp(1);
339 Tp max_abs_frac = -Tp(1);
340 unsigned int num_datum = sizeof(data006)
341 / sizeof(testcase_cyl_bessel_k<double>);
342 for (unsigned int i = 0; i < num_datum; ++i)
343 {
344 const Tp f = std::tr1::cyl_bessel_k(Tp(data006[i].nu), Tp(data006[i].x));
345 const Tp f0 = data006[i].f0;
346 const Tp diff = f - f0;
347 if (std::abs(diff) > max_abs_diff)
348 max_abs_diff = std::abs(diff);
349 if (std::abs(f0) > Tp(10) * eps
350 && std::abs(f) > Tp(10) * eps)
351 {
352 const Tp frac = diff / f0;
353 if (std::abs(frac) > max_abs_frac)
354 max_abs_frac = std::abs(frac);
355 }
356 }
357 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
358 }
359
360// Test data for nu=5.0000000000000000.
361testcase_cyl_bessel_k<double> data007[] = {
362 { 391683.98962334893, 5.0000000000000000, 0.25000000000000000 },
363 { 12097.979476096394, 5.0000000000000000, 0.50000000000000000 },
364 { 1562.5870339691098, 5.0000000000000000, 0.75000000000000000 },
365 { 360.96058960124066, 5.0000000000000000, 1.0000000000000000 },
366 { 114.29321426334016, 5.0000000000000000, 1.2500000000000000 },
367 { 44.067781159301056, 5.0000000000000000, 1.5000000000000000 },
368 { 19.426568687730292, 5.0000000000000000, 1.7500000000000000 },
369 { 9.4310491005964820, 5.0000000000000000, 2.0000000000000000 },
370 { 4.9221270549918685, 5.0000000000000000, 2.2500000000000000 },
371 { 2.7168842907865423, 5.0000000000000000, 2.5000000000000000 },
372 { 1.5677685890536335, 5.0000000000000000, 2.7500000000000000 },
373 { 0.93777360238680818, 5.0000000000000000, 3.0000000000000000 },
374 { 0.57775534736785106, 5.0000000000000000, 3.2500000000000000 },
375 { 0.36482440208451983, 5.0000000000000000, 3.5000000000000000 },
376 { 0.23520290620082257, 5.0000000000000000, 3.7500000000000000 },
377 { 0.15434254872599723, 5.0000000000000000, 4.0000000000000000 },
378 { 0.10283347176876455, 5.0000000000000000, 4.2500000000000000 },
379 { 0.069423643150881773, 5.0000000000000000, 4.5000000000000000 },
380 { 0.047410616917942211, 5.0000000000000000, 4.7500000000000000 },
381 { 0.032706273712031865, 5.0000000000000000, 5.0000000000000000 },
382};
383
384// Test function for nu=5.0000000000000000.
385template<typename Tp>
386 void
387 test007()
388 {
389 bool test [[gnu::unused]] = true;
390 const Tp eps = std::numeric_limits<Tp>::epsilon();
391 Tp max_abs_diff = -Tp(1);
392 Tp max_abs_frac = -Tp(1);
393 unsigned int num_datum = sizeof(data007)
394 / sizeof(testcase_cyl_bessel_k<double>);
395 for (unsigned int i = 0; i < num_datum; ++i)
396 {
397 const Tp f = std::tr1::cyl_bessel_k(Tp(data007[i].nu), Tp(data007[i].x));
398 const Tp f0 = data007[i].f0;
399 const Tp diff = f - f0;
400 if (std::abs(diff) > max_abs_diff)
401 max_abs_diff = std::abs(diff);
402 if (std::abs(f0) > Tp(10) * eps
403 && std::abs(f) > Tp(10) * eps)
404 {
405 const Tp frac = diff / f0;
406 if (std::abs(frac) > max_abs_frac)
407 max_abs_frac = std::abs(frac);
408 }
409 }
410 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
411 }
412
413// Test data for nu=10.000000000000000.
414testcase_cyl_bessel_k<double> data008[] = {
415 { 194481817927839.88, 10.000000000000000, 0.25000000000000000 },
416 { 188937569319.90030, 10.000000000000000, 0.50000000000000000 },
417 { 3248187687.8018155, 10.000000000000000, 0.75000000000000000 },
418 { 180713289.90102941, 10.000000000000000, 1.0000000000000000 },
419 { 19104425.945252180, 10.000000000000000, 1.2500000000000000 },
420 { 3027483.5236822353, 10.000000000000000, 1.5000000000000000 },
421 { 633724.71555087867, 10.000000000000000, 1.7500000000000000 },
422 { 162482.40397955943, 10.000000000000000, 2.0000000000000000 },
423 { 48602.446087749791, 10.000000000000000, 2.2500000000000000 },
424 { 16406.916416341937, 10.000000000000000, 2.5000000000000000 },
425 { 6104.1720745909606, 10.000000000000000, 2.7500000000000000 },
426 { 2459.6204220569480, 10.000000000000000, 3.0000000000000000 },
427 { 1059.2358443703381, 10.000000000000000, 3.2500000000000000 },
428 { 482.53582096664758, 10.000000000000000, 3.5000000000000000 },
429 { 230.64249314993776, 10.000000000000000, 3.7500000000000000 },
430 { 114.91408364049620, 10.000000000000000, 4.0000000000000000 },
431 { 59.361613632706479, 10.000000000000000, 4.2500000000000000 },
432 { 31.652958759229868, 10.000000000000000, 4.5000000000000000 },
433 { 17.357723966417399, 10.000000000000000, 4.7500000000000000 },
434 { 9.7585628291778121, 10.000000000000000, 5.0000000000000000 },
435};
436
437// Test function for nu=10.000000000000000.
438template<typename Tp>
439 void
440 test008()
441 {
442 bool test [[gnu::unused]] = true;
443 const Tp eps = std::numeric_limits<Tp>::epsilon();
444 Tp max_abs_diff = -Tp(1);
445 Tp max_abs_frac = -Tp(1);
446 unsigned int num_datum = sizeof(data008)
447 / sizeof(testcase_cyl_bessel_k<double>);
448 for (unsigned int i = 0; i < num_datum; ++i)
449 {
450 const Tp f = std::tr1::cyl_bessel_k(Tp(data008[i].nu), Tp(data008[i].x));
451 const Tp f0 = data008[i].f0;
452 const Tp diff = f - f0;
453 if (std::abs(diff) > max_abs_diff)
454 max_abs_diff = std::abs(diff);
455 if (std::abs(f0) > Tp(10) * eps
456 && std::abs(f) > Tp(10) * eps)
457 {
458 const Tp frac = diff / f0;
459 if (std::abs(frac) > max_abs_frac)
460 max_abs_frac = std::abs(frac);
461 }
462 }
463 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
464 }
465
466// Test data for nu=20.000000000000000.
467testcase_cyl_bessel_k<double> data009[] = {
468 { 7.0065983661641184e+34, 20.000000000000000, 0.25000000000000000 },
469 { 6.6655498744171593e+28, 20.000000000000000, 0.50000000000000000 },
470 { 1.9962989615380379e+25, 20.000000000000000, 0.75000000000000000 },
471 { 6.2943693604245335e+22, 20.000000000000000, 1.0000000000000000 },
472 { 7.2034511920074182e+20, 20.000000000000000, 1.2500000000000000 },
473 { 1.8620549984645546e+19, 20.000000000000000, 1.5000000000000000 },
474 { 8.4415605303952486e+17, 20.000000000000000, 1.7500000000000000 },
475 { 57708568527002520., 20.000000000000000, 2.0000000000000000 },
476 { 5396824209986879.0, 20.000000000000000, 2.2500000000000000 },
477 { 645996884063683.62, 20.000000000000000, 2.5000000000000000 },
478 { 94387401970996.328, 20.000000000000000, 2.7500000000000000 },
479 { 16254643952204.371, 20.000000000000000, 3.0000000000000000 },
480 { 3212694836166.4053, 20.000000000000000, 3.2500000000000000 },
481 { 713857897923.74072, 20.000000000000000, 3.5000000000000000 },
482 { 175423421958.35925, 20.000000000000000, 3.7500000000000000 },
483 { 47050078926.298080, 20.000000000000000, 4.0000000000000000 },
484 { 13625066095.067503, 20.000000000000000, 4.2500000000000000 },
485 { 4222179870.6810656, 20.000000000000000, 4.5000000000000000 },
486 { 1389634112.7516634, 20.000000000000000, 4.7500000000000000 },
487 { 482700052.06214869, 20.000000000000000, 5.0000000000000000 },
488};
489
490// Test function for nu=20.000000000000000.
491template<typename Tp>
492 void
493 test009()
494 {
495 bool test [[gnu::unused]] = true;
496 const Tp eps = std::numeric_limits<Tp>::epsilon();
497 Tp max_abs_diff = -Tp(1);
498 Tp max_abs_frac = -Tp(1);
499 unsigned int num_datum = sizeof(data009)
500 / sizeof(testcase_cyl_bessel_k<double>);
501 for (unsigned int i = 0; i < num_datum; ++i)
502 {
503 const Tp f = std::tr1::cyl_bessel_k(Tp(data009[i].nu), Tp(data009[i].x));
504 const Tp f0 = data009[i].f0;
505 const Tp diff = f - f0;
506 if (std::abs(diff) > max_abs_diff)
507 max_abs_diff = std::abs(diff);
508 if (std::abs(f0) > Tp(10) * eps
509 && std::abs(f) > Tp(10) * eps)
510 {
511 const Tp frac = diff / f0;
512 if (std::abs(frac) > max_abs_frac)
513 max_abs_frac = std::abs(frac);
514 }
515 }
516 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
517 }
518
519// Test data for nu=50.000000000000000.
520testcase_cyl_bessel_k<double> data010[] = {
521 { 4.3394604622138714e+107, 50.000000000000000, 0.25000000000000000 },
522 { 3.8505298918269003e+92, 50.000000000000000, 0.50000000000000000 },
523 { 6.0292756894842793e+83, 50.000000000000000, 0.75000000000000000 },
524 { 3.4068968541616991e+77, 50.000000000000000, 1.0000000000000000 },
525 { 4.8485527365039051e+72, 50.000000000000000, 1.2500000000000000 },
526 { 5.3091717574907920e+68, 50.000000000000000, 1.5000000000000000 },
527 { 2.3762245257445824e+65, 50.000000000000000, 1.7500000000000000 },
528 { 2.9799817396049268e+62, 50.000000000000000, 2.0000000000000000 },
529 { 8.2079431233488581e+59, 50.000000000000000, 2.2500000000000000 },
530 { 4.2046528212987503e+57, 50.000000000000000, 2.5000000000000000 },
531 { 3.5578676911884825e+55, 50.000000000000000, 2.7500000000000000 },
532 { 4.5559542293221535e+53, 50.000000000000000, 3.0000000000000000 },
533 { 8.2606735967628997e+51, 50.000000000000000, 3.2500000000000000 },
534 { 2.0139406747903812e+50, 50.000000000000000, 3.5000000000000000 },
535 { 6.3368727837484600e+48, 50.000000000000000, 3.7500000000000000 },
536 { 2.4897317389325753e+47, 50.000000000000000, 4.0000000000000000 },
537 { 1.1888958173039699e+46, 50.000000000000000, 4.2500000000000000 },
538 { 6.7472593648148542e+44, 50.000000000000000, 4.5000000000000000 },
539 { 4.4664266585930700e+43, 50.000000000000000, 4.7500000000000000 },
540 { 3.3943222434301628e+42, 50.000000000000000, 5.0000000000000000 },
541};
542
543// Test function for nu=50.000000000000000.
544template<typename Tp>
545 void
546 test010()
547 {
548 bool test [[gnu::unused]] = true;
549 const Tp eps = std::numeric_limits<Tp>::epsilon();
550 Tp max_abs_diff = -Tp(1);
551 Tp max_abs_frac = -Tp(1);
552 unsigned int num_datum = sizeof(data010)
553 / sizeof(testcase_cyl_bessel_k<double>);
554 for (unsigned int i = 0; i < num_datum; ++i)
555 {
556 const Tp f = std::tr1::cyl_bessel_k(Tp(data010[i].nu), Tp(data010[i].x));
557 const Tp f0 = data010[i].f0;
558 const Tp diff = f - f0;
559 if (std::abs(diff) > max_abs_diff)
560 max_abs_diff = std::abs(diff);
561 if (std::abs(f0) > Tp(10) * eps
562 && std::abs(f) > Tp(10) * eps)
563 {
564 const Tp frac = diff / f0;
565 if (std::abs(frac) > max_abs_frac)
566 max_abs_frac = std::abs(frac);
567 }
568 }
569 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
570 }
571
572// Test data for nu=100.00000000000000.
573testcase_cyl_bessel_k<double> data011[] = {
574 { 9.5039428115809898e+245, 100.00000000000000, 0.25000000000000000 },
575 { 7.4937399313533112e+215, 100.00000000000000, 0.50000000000000000 },
576 { 1.8417471020730701e+198, 100.00000000000000, 0.75000000000000000 },
577 { 5.9003331836386410e+185, 100.00000000000000, 1.0000000000000000 },
578 { 1.2002130935576950e+176, 100.00000000000000, 1.2500000000000000 },
579 { 1.4467044226487075e+168, 100.00000000000000, 1.5000000000000000 },
580 { 2.9161498411497642e+161, 100.00000000000000, 1.7500000000000000 },
581 { 4.6194159776013925e+155, 100.00000000000000, 2.0000000000000000 },
582 { 3.5332121583541727e+150, 100.00000000000000, 2.2500000000000000 },
583 { 9.3566097231039940e+145, 100.00000000000000, 2.5000000000000000 },
584 { 6.7672283615134532e+141, 100.00000000000000, 2.7500000000000000 },
585 { 1.1219630864949494e+138, 100.00000000000000, 3.0000000000000000 },
586 { 3.7329723699990903e+134, 100.00000000000000, 3.2500000000000000 },
587 { 2.2476893883855163e+131, 100.00000000000000, 3.5000000000000000 },
588 { 2.2564559319883196e+128, 100.00000000000000, 3.7500000000000000 },
589 { 3.5353340499626455e+125, 100.00000000000000, 4.0000000000000000 },
590 { 8.1898439213010234e+122, 100.00000000000000, 4.2500000000000000 },
591 { 2.6823744110726800e+120, 100.00000000000000, 4.5000000000000000 },
592 { 1.1963963615212274e+118, 100.00000000000000, 4.7500000000000000 },
593 { 7.0398601930616815e+115, 100.00000000000000, 5.0000000000000000 },
594};
595
596// Test function for nu=100.00000000000000.
597template<typename Tp>
598 void
599 test011()
600 {
601 bool test [[gnu::unused]] = true;
602 const Tp eps = std::numeric_limits<Tp>::epsilon();
603 Tp max_abs_diff = -Tp(1);
604 Tp max_abs_frac = -Tp(1);
605 unsigned int num_datum = sizeof(data011)
606 / sizeof(testcase_cyl_bessel_k<double>);
607 for (unsigned int i = 0; i < num_datum; ++i)
608 {
609 const Tp f = std::tr1::cyl_bessel_k(Tp(data011[i].nu), Tp(data011[i].x));
610 const Tp f0 = data011[i].f0;
611 const Tp diff = f - f0;
612 if (std::abs(diff) > max_abs_diff)
613 max_abs_diff = std::abs(diff);
614 if (std::abs(f0) > Tp(10) * eps
615 && std::abs(f) > Tp(10) * eps)
616 {
617 const Tp frac = diff / f0;
618 if (std::abs(frac) > max_abs_frac)
619 max_abs_frac = std::abs(frac);
620 }
621 }
622 VERIFY(max_abs_frac < Tp(5.0000000000000029e-12));
623 }
624// cyl_bessel_k
625
626// Test data for nu=0.0000000000000000.
627testcase_cyl_bessel_k<double> data012[] = {
7c62b943
BK		 628 { 0.0036910983340425947, 0.0000000000000000, 5.0000000000000000 },
629 { 1.7780062316167650e-05, 0.0000000000000000, 10.000000000000000 },
630 { 9.8195364823964333e-08, 0.0000000000000000, 15.000000000000000 },
631 { 5.7412378153365238e-10, 0.0000000000000000, 20.000000000000000 },
632 { 3.4641615622131151e-12, 0.0000000000000000, 25.000000000000000 },
633 { 2.1324774964630566e-14, 0.0000000000000000, 30.000000000000000 },
634 { 1.3310351491429464e-16, 0.0000000000000000, 35.000000000000000 },
635 { 8.3928611000995700e-19, 0.0000000000000000, 40.000000000000000 },
2be75957 636 { 5.3334561226187247e-21, 0.0000000000000000, 45.000000000000000 },
7c62b943
BK		 637 { 3.4101677497894956e-23, 0.0000000000000000, 50.000000000000000 },
638 { 2.1913102183534147e-25, 0.0000000000000000, 55.000000000000000 },
639 { 1.4138978405591074e-27, 0.0000000000000000, 60.000000000000000 },
640 { 9.1544673210030045e-30, 0.0000000000000000, 65.000000000000000 },
641 { 5.9446613372925013e-32, 0.0000000000000000, 70.000000000000000 },
642 { 3.8701170455869113e-34, 0.0000000000000000, 75.000000000000000 },
643 { 2.5251198425054723e-36, 0.0000000000000000, 80.000000000000000 },
644 { 1.6507623579783908e-38, 0.0000000000000000, 85.000000000000000 },
645 { 1.0810242556984256e-40, 0.0000000000000000, 90.000000000000000 },
646 { 7.0901249699001278e-43, 0.0000000000000000, 95.000000000000000 },
647 { 4.6566282291759032e-45, 0.0000000000000000, 100.00000000000000 },
648};
649
650// Test function for nu=0.0000000000000000.
2be75957
ESR		 651template<typename Tp>
652 void
653 test012()
654 {
655 bool test [[gnu::unused]] = true;
656 const Tp eps = std::numeric_limits<Tp>::epsilon();
657 Tp max_abs_diff = -Tp(1);
658 Tp max_abs_frac = -Tp(1);
659 unsigned int num_datum = sizeof(data012)
660 / sizeof(testcase_cyl_bessel_k<double>);
661 for (unsigned int i = 0; i < num_datum; ++i)
662 {
663 const Tp f = std::tr1::cyl_bessel_k(Tp(data012[i].nu), Tp(data012[i].x));
664 const Tp f0 = data012[i].f0;
665 const Tp diff = f - f0;
666 if (std::abs(diff) > max_abs_diff)
667 max_abs_diff = std::abs(diff);
668 if (std::abs(f0) > Tp(10) * eps
669 && std::abs(f) > Tp(10) * eps)
670 {
671 const Tp frac = diff / f0;
672 if (std::abs(frac) > max_abs_frac)
673 max_abs_frac = std::abs(frac);
674 }
675 }
676 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
677 }
7c62b943
BK		 678
679// Test data for nu=0.33333333333333331.
2be75957 680testcase_cyl_bessel_k<double> data013[] = {
7c62b943
BK		 681 { 0.0037288750960535887, 0.33333333333333331, 5.0000000000000000 },
682 { 1.7874608271055339e-05, 0.33333333333333331, 10.000000000000000 },
683 { 9.8548341568798317e-08, 0.33333333333333331, 15.000000000000000 },
684 { 5.7568278247790865e-10, 0.33333333333333331, 20.000000000000000 },
685 { 3.4717201424907059e-12, 0.33333333333333331, 25.000000000000000 },
686 { 2.1363664736611189e-14, 0.33333333333333331, 30.000000000000000 },
687 { 1.3331202314165813e-16, 0.33333333333333331, 35.000000000000000 },
688 { 8.4043837769480934e-19, 0.33333333333333331, 40.000000000000000 },
689 { 5.3399731261024948e-21, 0.33333333333333331, 45.000000000000000 },
690 { 3.4139217813583632e-23, 0.33333333333333331, 50.000000000000000 },
691 { 2.1935050179185627e-25, 0.33333333333333331, 55.000000000000000 },
692 { 1.4151968805623662e-27, 0.33333333333333331, 60.000000000000000 },
693 { 9.1622357217019043e-30, 0.33333333333333331, 65.000000000000000 },
694 { 5.9493479703461315e-32, 0.33333333333333331, 70.000000000000000 },
695 { 3.8729660011055947e-34, 0.33333333333333331, 75.000000000000000 },
696 { 2.5268631828013877e-36, 0.33333333333333331, 80.000000000000000 },
697 { 1.6518353676138867e-38, 0.33333333333333331, 85.000000000000000 },
2be75957 698 { 1.0816880942511494e-40, 0.33333333333333331, 90.000000000000000 },
7c62b943
BK		 699 { 7.0942508599231512e-43, 0.33333333333333331, 95.000000000000000 },
700 { 4.6592031570213454e-45, 0.33333333333333331, 100.00000000000000 },
701};
702
703// Test function for nu=0.33333333333333331.
2be75957
ESR		 704template<typename Tp>
705 void
706 test013()
707 {
708 bool test [[gnu::unused]] = true;
709 const Tp eps = std::numeric_limits<Tp>::epsilon();
710 Tp max_abs_diff = -Tp(1);
711 Tp max_abs_frac = -Tp(1);
712 unsigned int num_datum = sizeof(data013)
713 / sizeof(testcase_cyl_bessel_k<double>);
714 for (unsigned int i = 0; i < num_datum; ++i)
715 {
716 const Tp f = std::tr1::cyl_bessel_k(Tp(data013[i].nu), Tp(data013[i].x));
717 const Tp f0 = data013[i].f0;
718 const Tp diff = f - f0;
719 if (std::abs(diff) > max_abs_diff)
720 max_abs_diff = std::abs(diff);
721 if (std::abs(f0) > Tp(10) * eps
722 && std::abs(f) > Tp(10) * eps)
723 {
724 const Tp frac = diff / f0;
725 if (std::abs(frac) > max_abs_frac)
726 max_abs_frac = std::abs(frac);
727 }
728 }
729 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
730 }
7c62b943
BK		 731
732// Test data for nu=0.50000000000000000.
2be75957 733testcase_cyl_bessel_k<double> data014[] = {
7c62b943
BK		 734 { 0.0037766133746428825, 0.50000000000000000, 5.0000000000000000 },
735 { 1.7993478093705181e-05, 0.50000000000000000, 10.000000000000000 },
736 { 9.8991312032877236e-08, 0.50000000000000000, 15.000000000000000 },
737 { 5.7763739747074450e-10, 0.50000000000000000, 20.000000000000000 },
738 { 3.4811912768406949e-12, 0.50000000000000000, 25.000000000000000 },
739 { 2.1412375659560111e-14, 0.50000000000000000, 30.000000000000000 },
740 { 1.3357311366035824e-16, 0.50000000000000000, 35.000000000000000 },
741 { 8.4188091949489049e-19, 0.50000000000000000, 40.000000000000000 },
742 { 5.3481305002517408e-21, 0.50000000000000000, 45.000000000000000 },
743 { 3.4186200954570754e-23, 0.50000000000000000, 50.000000000000000 },
744 { 2.1962515908772453e-25, 0.50000000000000000, 55.000000000000000 },
745 { 1.4168223500353693e-27, 0.50000000000000000, 60.000000000000000 },
746 { 9.1719554473256892e-30, 0.50000000000000000, 65.000000000000000 },
747 { 5.9552114337788932e-32, 0.50000000000000000, 70.000000000000000 },
748 { 3.8765301321409432e-34, 0.50000000000000000, 75.000000000000000 },
749 { 2.5290440439442910e-36, 0.50000000000000000, 80.000000000000000 },
750 { 1.6531776067605980e-38, 0.50000000000000000, 85.000000000000000 },
751 { 1.0825184636529955e-40, 0.50000000000000000, 90.000000000000000 },
752 { 7.0994115873258822e-43, 0.50000000000000000, 95.000000000000000 },
753 { 4.6624238126346715e-45, 0.50000000000000000, 100.00000000000000 },
754};
755
756// Test function for nu=0.50000000000000000.
2be75957
ESR		 757template<typename Tp>
758 void
759 test014()
760 {
761 bool test [[gnu::unused]] = true;
762 const Tp eps = std::numeric_limits<Tp>::epsilon();
763 Tp max_abs_diff = -Tp(1);
764 Tp max_abs_frac = -Tp(1);
765 unsigned int num_datum = sizeof(data014)
766 / sizeof(testcase_cyl_bessel_k<double>);
767 for (unsigned int i = 0; i < num_datum; ++i)
768 {
769 const Tp f = std::tr1::cyl_bessel_k(Tp(data014[i].nu), Tp(data014[i].x));
770 const Tp f0 = data014[i].f0;
771 const Tp diff = f - f0;
772 if (std::abs(diff) > max_abs_diff)
773 max_abs_diff = std::abs(diff);
774 if (std::abs(f0) > Tp(10) * eps
775 && std::abs(f) > Tp(10) * eps)
776 {
777 const Tp frac = diff / f0;
778 if (std::abs(frac) > max_abs_frac)
779 max_abs_frac = std::abs(frac);
780 }
781 }
782 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
783 }
7c62b943
BK		 784
785// Test data for nu=0.66666666666666663.
2be75957 786testcase_cyl_bessel_k<double> data015[] = {
7c62b943
BK		 787 { 0.0038444246344968226, 0.66666666666666663, 5.0000000000000000 },
788 { 1.8161187569530204e-05, 0.66666666666666663, 10.000000000000000 },
789 { 9.9614751542305571e-08, 0.66666666666666663, 15.000000000000000 },
790 { 5.8038484271925811e-10, 0.66666666666666663, 20.000000000000000 },
791 { 3.4944937498488603e-12, 0.66666666666666663, 25.000000000000000 },
792 { 2.1480755645577720e-14, 0.66666666666666663, 30.000000000000000 },
793 { 1.3393949190152161e-16, 0.66666666666666663, 35.000000000000000 },
794 { 8.4390460553642992e-19, 0.66666666666666663, 40.000000000000000 },
795 { 5.3595716143622089e-21, 0.66666666666666663, 45.000000000000000 },
796 { 3.4252085301433749e-23, 0.66666666666666663, 50.000000000000000 },
797 { 2.2001025377982308e-25, 0.66666666666666663, 55.000000000000000 },
798 { 1.4191011274172078e-27, 0.66666666666666663, 60.000000000000000 },
799 { 9.1855803020269763e-30, 0.66666666666666663, 65.000000000000000 },
800 { 5.9634299472578764e-32, 0.66666666666666663, 70.000000000000000 },
801 { 3.8815254026478500e-34, 0.66666666666666663, 75.000000000000000 },
802 { 2.5321003991943851e-36, 0.66666666666666663, 80.000000000000000 },
803 { 1.6550585670593067e-38, 0.66666666666666663, 85.000000000000000 },
2be75957 804 { 1.0836820479428605e-40, 0.66666666666666663, 90.000000000000000 },
7c62b943
BK		 805 { 7.1066428916285356e-43, 0.66666666666666663, 95.000000000000000 },
806 { 4.6669364587280465e-45, 0.66666666666666663, 100.00000000000000 },
807};
808
809// Test function for nu=0.66666666666666663.
2be75957
ESR		 810template<typename Tp>
811 void
812 test015()
813 {
814 bool test [[gnu::unused]] = true;
815 const Tp eps = std::numeric_limits<Tp>::epsilon();
816 Tp max_abs_diff = -Tp(1);
817 Tp max_abs_frac = -Tp(1);
818 unsigned int num_datum = sizeof(data015)
819 / sizeof(testcase_cyl_bessel_k<double>);
820 for (unsigned int i = 0; i < num_datum; ++i)
821 {
822 const Tp f = std::tr1::cyl_bessel_k(Tp(data015[i].nu), Tp(data015[i].x));
823 const Tp f0 = data015[i].f0;
824 const Tp diff = f - f0;
825 if (std::abs(diff) > max_abs_diff)
826 max_abs_diff = std::abs(diff);
827 if (std::abs(f0) > Tp(10) * eps
828 && std::abs(f) > Tp(10) * eps)
829 {
830 const Tp frac = diff / f0;
831 if (std::abs(frac) > max_abs_frac)
832 max_abs_frac = std::abs(frac);
833 }
834 }
835 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
836 }
7c62b943
BK		 837
838// Test data for nu=1.0000000000000000.
2be75957 839testcase_cyl_bessel_k<double> data016[] = {
7c62b943
BK		 840 { 0.0040446134454521655, 1.0000000000000000, 5.0000000000000000 },
841 { 1.8648773453825582e-05, 1.0000000000000000, 10.000000000000000 },
842 { 1.0141729369762091e-07, 1.0000000000000000, 15.000000000000000 },
843 { 5.8830579695570384e-10, 1.0000000000000000, 20.000000000000000 },
844 { 3.5327780731999345e-12, 1.0000000000000000, 25.000000000000000 },
845 { 2.1677320018915498e-14, 1.0000000000000000, 30.000000000000000 },
846 { 1.3499178340011053e-16, 1.0000000000000000, 35.000000000000000 },
847 { 8.4971319548610435e-19, 1.0000000000000000, 40.000000000000000 },
2be75957 848 { 5.3923945937225035e-21, 1.0000000000000000, 45.000000000000000 },
7c62b943
BK		 849 { 3.4441022267175555e-23, 1.0000000000000000, 50.000000000000000 },
850 { 2.2111422716117463e-25, 1.0000000000000000, 55.000000000000000 },
851 { 1.4256320265171041e-27, 1.0000000000000000, 60.000000000000000 },
852 { 9.2246195278906156e-30, 1.0000000000000000, 65.000000000000000 },
853 { 5.9869736739138550e-32, 1.0000000000000000, 70.000000000000000 },
854 { 3.8958329467421912e-34, 1.0000000000000000, 75.000000000000000 },
855 { 2.5408531275211708e-36, 1.0000000000000000, 80.000000000000000 },
856 { 1.6604444948567571e-38, 1.0000000000000000, 85.000000000000000 },
857 { 1.0870134457498335e-40, 1.0000000000000000, 90.000000000000000 },
858 { 7.1273442329907240e-43, 1.0000000000000000, 95.000000000000000 },
859 { 4.6798537356369101e-45, 1.0000000000000000, 100.00000000000000 },
860};
861
862// Test function for nu=1.0000000000000000.
2be75957
ESR		 863template<typename Tp>
864 void
865 test016()
866 {
867 bool test [[gnu::unused]] = true;
868 const Tp eps = std::numeric_limits<Tp>::epsilon();
869 Tp max_abs_diff = -Tp(1);
870 Tp max_abs_frac = -Tp(1);
871 unsigned int num_datum = sizeof(data016)
872 / sizeof(testcase_cyl_bessel_k<double>);
873 for (unsigned int i = 0; i < num_datum; ++i)
874 {
875 const Tp f = std::tr1::cyl_bessel_k(Tp(data016[i].nu), Tp(data016[i].x));
876 const Tp f0 = data016[i].f0;
877 const Tp diff = f - f0;
878 if (std::abs(diff) > max_abs_diff)
879 max_abs_diff = std::abs(diff);
880 if (std::abs(f0) > Tp(10) * eps
881 && std::abs(f) > Tp(10) * eps)
882 {
883 const Tp frac = diff / f0;
884 if (std::abs(frac) > max_abs_frac)
885 max_abs_frac = std::abs(frac);
886 }
887 }
888 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
889 }
7c62b943
BK		 890
891// Test data for nu=2.0000000000000000.
2be75957 892testcase_cyl_bessel_k<double> data017[] = {
7c62b943
BK		 893 { 0.0053089437122234608, 2.0000000000000000, 5.0000000000000000 },
894 { 2.1509817006932767e-05, 2.0000000000000000, 10.000000000000000 },
895 { 1.1171767065031378e-07, 2.0000000000000000, 15.000000000000000 },
896 { 6.3295436122922281e-10, 2.0000000000000000, 20.000000000000000 },
897 { 3.7467838080691102e-12, 2.0000000000000000, 25.000000000000000 },
898 { 2.2769929632558265e-14, 2.0000000000000000, 30.000000000000000 },
899 { 1.4081733110858665e-16, 2.0000000000000000, 35.000000000000000 },
900 { 8.8177176978426223e-19, 2.0000000000000000, 40.000000000000000 },
2be75957 901 { 5.5731181045619470e-21, 2.0000000000000000, 45.000000000000000 },
7c62b943
BK		 902 { 3.5479318388581979e-23, 2.0000000000000000, 50.000000000000000 },
903 { 2.2717153918665688e-25, 2.0000000000000000, 55.000000000000000 },
904 { 1.4614189081096777e-27, 2.0000000000000000, 60.000000000000000 },
905 { 9.4383017680150234e-30, 2.0000000000000000, 65.000000000000000 },
906 { 6.1157177279757537e-32, 2.0000000000000000, 70.000000000000000 },
907 { 3.9740059241667034e-34, 2.0000000000000000, 75.000000000000000 },
908 { 2.5886411706935015e-36, 2.0000000000000000, 80.000000000000000 },
2be75957 909 { 1.6898316402103142e-38, 2.0000000000000000, 85.000000000000000 },
7c62b943
BK		 910 { 1.1051801100484218e-40, 2.0000000000000000, 90.000000000000000 },
911 { 7.2401743221736176e-43, 2.0000000000000000, 95.000000000000000 },
912 { 4.7502253038886413e-45, 2.0000000000000000, 100.00000000000000 },
913};
914
915// Test function for nu=2.0000000000000000.
2be75957
ESR		 916template<typename Tp>
917 void
918 test017()
919 {
920 bool test [[gnu::unused]] = true;
921 const Tp eps = std::numeric_limits<Tp>::epsilon();
922 Tp max_abs_diff = -Tp(1);
923 Tp max_abs_frac = -Tp(1);
924 unsigned int num_datum = sizeof(data017)
925 / sizeof(testcase_cyl_bessel_k<double>);
926 for (unsigned int i = 0; i < num_datum; ++i)
927 {
928 const Tp f = std::tr1::cyl_bessel_k(Tp(data017[i].nu), Tp(data017[i].x));
929 const Tp f0 = data017[i].f0;
930 const Tp diff = f - f0;
931 if (std::abs(diff) > max_abs_diff)
932 max_abs_diff = std::abs(diff);
933 if (std::abs(f0) > Tp(10) * eps
934 && std::abs(f) > Tp(10) * eps)
935 {
936 const Tp frac = diff / f0;
937 if (std::abs(frac) > max_abs_frac)
938 max_abs_frac = std::abs(frac);
939 }
940 }
941 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
942 }
7c62b943
BK		 943
944// Test data for nu=5.0000000000000000.
2be75957 945testcase_cyl_bessel_k<double> data018[] = {
7c62b943 946 { 0.032706273712031865, 5.0000000000000000, 5.0000000000000000 },
2be75957 947 { 5.7541849985312288e-05, 5.0000000000000000, 10.000000000000000 },
7c62b943
BK		 948 { 2.1878261369258224e-07, 5.0000000000000000, 15.000000000000000 },
949 { 1.0538660139974233e-09, 5.0000000000000000, 20.000000000000000 },
950 { 5.6485921365284157e-12, 5.0000000000000000, 25.000000000000000 },
951 { 3.2103335105890266e-14, 5.0000000000000000, 30.000000000000000 },
952 { 1.8919208406439644e-16, 5.0000000000000000, 35.000000000000000 },
953 { 1.1423814375953188e-18, 5.0000000000000000, 40.000000000000000 },
2be75957 954 { 7.0181216822204101e-21, 5.0000000000000000, 45.000000000000000 },
7c62b943
BK		 955 { 4.3671822541009859e-23, 5.0000000000000000, 50.000000000000000 },
956 { 2.7444967640357869e-25, 5.0000000000000000, 55.000000000000000 },
957 { 1.7382232741886986e-27, 5.0000000000000000, 60.000000000000000 },
958 { 1.1078474298959669e-29, 5.0000000000000000, 65.000000000000000 },
959 { 7.0974537081794416e-32, 5.0000000000000000, 70.000000000000000 },
960 { 4.5667269500061064e-34, 5.0000000000000000, 75.000000000000000 },
961 { 2.9491764420206150e-36, 5.0000000000000000, 80.000000000000000 },
962 { 1.9105685973117463e-38, 5.0000000000000000, 85.000000000000000 },
963 { 1.2411034311592645e-40, 5.0000000000000000, 90.000000000000000 },
964 { 8.0814211331379146e-43, 5.0000000000000000, 95.000000000000000 },
965 { 5.2732561132929509e-45, 5.0000000000000000, 100.00000000000000 },
966};
967
968// Test function for nu=5.0000000000000000.
2be75957
ESR		 969template<typename Tp>
970 void
971 test018()
972 {
973 bool test [[gnu::unused]] = true;
974 const Tp eps = std::numeric_limits<Tp>::epsilon();
975 Tp max_abs_diff = -Tp(1);
976 Tp max_abs_frac = -Tp(1);
977 unsigned int num_datum = sizeof(data018)
978 / sizeof(testcase_cyl_bessel_k<double>);
979 for (unsigned int i = 0; i < num_datum; ++i)
980 {
981 const Tp f = std::tr1::cyl_bessel_k(Tp(data018[i].nu), Tp(data018[i].x));
982 const Tp f0 = data018[i].f0;
983 const Tp diff = f - f0;
984 if (std::abs(diff) > max_abs_diff)
985 max_abs_diff = std::abs(diff);
986 if (std::abs(f0) > Tp(10) * eps
987 && std::abs(f) > Tp(10) * eps)
988 {
989 const Tp frac = diff / f0;
990 if (std::abs(frac) > max_abs_frac)
991 max_abs_frac = std::abs(frac);
992 }
993 }
994 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
995 }
7c62b943
BK		 996
997// Test data for nu=10.000000000000000.
2be75957 998testcase_cyl_bessel_k<double> data019[] = {
7c62b943
BK		 999 { 9.7585628291778121, 10.000000000000000, 5.0000000000000000 },
1000 { 0.0016142553003906700, 10.000000000000000, 10.000000000000000 },
2be75957
ESR		 1001 { 2.2605303776606435e-06, 10.000000000000000, 15.000000000000000 },
1002 { 6.3162145283215804e-09, 10.000000000000000, 20.000000000000000 },
1003 { 2.4076769602801233e-11, 10.000000000000000, 25.000000000000000 },
7c62b943
BK		 1004 { 1.0842816942222975e-13, 10.000000000000000, 30.000000000000000 },
1005 { 5.3976770429777191e-16, 10.000000000000000, 35.000000000000000 },
1006 { 2.8680293113671932e-18, 10.000000000000000, 40.000000000000000 },
2be75957 1007 { 1.5939871900169600e-20, 10.000000000000000, 45.000000000000000 },
7c62b943
BK		 1008 { 9.1509882099879962e-23, 10.000000000000000, 50.000000000000000 },
1009 { 5.3823846249592858e-25, 10.000000000000000, 55.000000000000000 },
1010 { 3.2253408700563144e-27, 10.000000000000000, 60.000000000000000 },
1011 { 1.9613367530075138e-29, 10.000000000000000, 65.000000000000000 },
1012 { 1.2068471495933484e-31, 10.000000000000000, 70.000000000000000 },
1013 { 7.4979152649449644e-34, 10.000000000000000, 75.000000000000000 },
1014 { 4.6957285830490538e-36, 10.000000000000000, 80.000000000000000 },
2be75957 1015 { 2.9606323347034079e-38, 10.000000000000000, 85.000000000000000 },
7c62b943
BK		 1016 { 1.8773542561131613e-40, 10.000000000000000, 90.000000000000000 },
1017 { 1.1962899527846350e-42, 10.000000000000000, 95.000000000000000 },
1018 { 7.6554279773881018e-45, 10.000000000000000, 100.00000000000000 },
1019};
1020
1021// Test function for nu=10.000000000000000.
2be75957
ESR		 1022template<typename Tp>
1023 void
1024 test019()
1025 {
1026 bool test [[gnu::unused]] = true;
1027 const Tp eps = std::numeric_limits<Tp>::epsilon();
1028 Tp max_abs_diff = -Tp(1);
1029 Tp max_abs_frac = -Tp(1);
1030 unsigned int num_datum = sizeof(data019)
1031 / sizeof(testcase_cyl_bessel_k<double>);
1032 for (unsigned int i = 0; i < num_datum; ++i)
1033 {
1034 const Tp f = std::tr1::cyl_bessel_k(Tp(data019[i].nu), Tp(data019[i].x));
1035 const Tp f0 = data019[i].f0;
1036 const Tp diff = f - f0;
1037 if (std::abs(diff) > max_abs_diff)
1038 max_abs_diff = std::abs(diff);
1039 if (std::abs(f0) > Tp(10) * eps
1040 && std::abs(f) > Tp(10) * eps)
1041 {
1042 const Tp frac = diff / f0;
1043 if (std::abs(frac) > max_abs_frac)
1044 max_abs_frac = std::abs(frac);
1045 }
1046 }
1047 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1048 }
7c62b943
BK		 1049
1050// Test data for nu=20.000000000000000.
2be75957 1051testcase_cyl_bessel_k<double> data020[] = {
7c62b943 1052 { 482700052.06214869, 20.000000000000000, 5.0000000000000000 },
2be75957
ESR		 1053 { 178.74427820770546, 20.000000000000000, 10.000000000000000 },
1054 { 0.012141257729731143, 20.000000000000000, 15.000000000000000 },
7c62b943 1055 { 5.5431116361258155e-06, 20.000000000000000, 20.000000000000000 },
2be75957 1056 { 6.3744029330352113e-09, 20.000000000000000, 25.000000000000000 },
7c62b943 1057 { 1.2304516475442478e-11, 20.000000000000000, 30.000000000000000 },
2be75957 1058 { 3.2673136479809018e-14, 20.000000000000000, 35.000000000000000 },
7c62b943 1059 { 1.0703023799997383e-16, 20.000000000000000, 40.000000000000000 },
2be75957
ESR		 1060 { 4.0549953175660457e-19, 20.000000000000000, 45.000000000000000 },
1061 { 1.7061483797220349e-21, 20.000000000000000, 50.000000000000000 },
7c62b943 1062 { 7.7617008115659413e-24, 20.000000000000000, 55.000000000000000 },
2be75957
ESR		 1063 { 3.7482954006874720e-26, 20.000000000000000, 60.000000000000000 },
1064 { 1.8966880763956576e-28, 20.000000000000000, 65.000000000000000 },
1065 { 9.9615763479998864e-31, 20.000000000000000, 70.000000000000000 },
7c62b943
BK		 1066 { 5.3921623063091066e-33, 20.000000000000000, 75.000000000000000 },
1067 { 2.9920407657642272e-35, 20.000000000000000, 80.000000000000000 },
2be75957
ESR		 1068 { 1.6948662723618255e-37, 20.000000000000000, 85.000000000000000 },
1069 { 9.7689149642963042e-40, 20.000000000000000, 90.000000000000000 },
7c62b943
BK		 1070 { 5.7143603019220823e-42, 20.000000000000000, 95.000000000000000 },
1071 { 3.3852054148901700e-44, 20.000000000000000, 100.00000000000000 },
1072};
1073
1074// Test function for nu=20.000000000000000.
2be75957
ESR		 1075template<typename Tp>
1076 void
1077 test020()
1078 {
1079 bool test [[gnu::unused]] = true;
1080 const Tp eps = std::numeric_limits<Tp>::epsilon();
1081 Tp max_abs_diff = -Tp(1);
1082 Tp max_abs_frac = -Tp(1);
1083 unsigned int num_datum = sizeof(data020)
1084 / sizeof(testcase_cyl_bessel_k<double>);
1085 for (unsigned int i = 0; i < num_datum; ++i)
1086 {
1087 const Tp f = std::tr1::cyl_bessel_k(Tp(data020[i].nu), Tp(data020[i].x));
1088 const Tp f0 = data020[i].f0;
1089 const Tp diff = f - f0;
1090 if (std::abs(diff) > max_abs_diff)
1091 max_abs_diff = std::abs(diff);
1092 if (std::abs(f0) > Tp(10) * eps
1093 && std::abs(f) > Tp(10) * eps)
1094 {
1095 const Tp frac = diff / f0;
1096 if (std::abs(frac) > max_abs_frac)
1097 max_abs_frac = std::abs(frac);
1098 }
1099 }
1100 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1101 }
7c62b943
BK		 1102
1103// Test data for nu=50.000000000000000.
2be75957 1104testcase_cyl_bessel_k<double> data021[] = {
7c62b943 1105 { 3.3943222434301628e+42, 50.000000000000000, 5.0000000000000000 },
2be75957
ESR		 1106 { 2.0613737753892557e+27, 50.000000000000000, 10.000000000000000 },
1107 { 1.7267736974519188e+18, 50.000000000000000, 15.000000000000000 },
1108 { 411711209122.01788, 50.000000000000000, 20.000000000000000 },
1109 { 1972478.7419813874, 50.000000000000000, 25.000000000000000 },
7c62b943 1110 { 58.770686258007267, 50.000000000000000, 30.000000000000000 },
2be75957
ESR		 1111 { 0.0058659391182535178, 50.000000000000000, 35.000000000000000 },
1112 { 1.3634854128794101e-06, 50.000000000000000, 40.000000000000000 },
1113 { 5.8652396362160819e-10, 50.000000000000000, 45.000000000000000 },
1114 { 4.0060134766400893e-13, 50.000000000000000, 50.000000000000000 },
7c62b943 1115 { 3.9062324485711016e-16, 50.000000000000000, 55.000000000000000 },
2be75957
ESR		 1116 { 5.0389298085176510e-19, 50.000000000000000, 60.000000000000000 },
1117 { 8.1305344250110424e-22, 50.000000000000000, 65.000000000000000 },
1118 { 1.5732816234948991e-24, 50.000000000000000, 70.000000000000000 },
1119 { 3.5349854993874412e-27, 50.000000000000000, 75.000000000000000 },
7c62b943
BK		 1120 { 8.9940101003189485e-30, 50.000000000000000, 80.000000000000000 },
1121 { 2.5403205503080723e-32, 50.000000000000000, 85.000000000000000 },
2be75957
ESR		 1122 { 7.8397596486715721e-35, 50.000000000000000, 90.000000000000000 },
1123 { 2.6098900651329542e-37, 50.000000000000000, 95.000000000000000 },
1124 { 9.2745226536133258e-40, 50.000000000000000, 100.00000000000000 },
7c62b943
BK		 1125};
1126
1127// Test function for nu=50.000000000000000.
2be75957
ESR		 1128template<typename Tp>
1129 void
1130 test021()
1131 {
1132 bool test [[gnu::unused]] = true;
1133 const Tp eps = std::numeric_limits<Tp>::epsilon();
1134 Tp max_abs_diff = -Tp(1);
1135 Tp max_abs_frac = -Tp(1);
1136 unsigned int num_datum = sizeof(data021)
1137 / sizeof(testcase_cyl_bessel_k<double>);
1138 for (unsigned int i = 0; i < num_datum; ++i)
1139 {
1140 const Tp f = std::tr1::cyl_bessel_k(Tp(data021[i].nu), Tp(data021[i].x));
1141 const Tp f0 = data021[i].f0;
1142 const Tp diff = f - f0;
1143 if (std::abs(diff) > max_abs_diff)
1144 max_abs_diff = std::abs(diff);
1145 if (std::abs(f0) > Tp(10) * eps
1146 && std::abs(f) > Tp(10) * eps)
1147 {
1148 const Tp frac = diff / f0;
1149 if (std::abs(frac) > max_abs_frac)
1150 max_abs_frac = std::abs(frac);
1151 }
1152 }
1153 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1154 }
7c62b943
BK		 1155
1156// Test data for nu=100.00000000000000.
2be75957
ESR		 1157testcase_cyl_bessel_k<double> data022[] = {
1158 { 7.0398601930616815e+115, 100.00000000000000, 5.0000000000000000 },
1159 { 4.5966740842695238e+85, 100.00000000000000, 10.000000000000000 },
1160 { 8.2565552242653946e+67, 100.00000000000000, 15.000000000000000 },
1161 { 1.7081356456876041e+55, 100.00000000000000, 20.000000000000000 },
1162 { 1.9858028128780610e+45, 100.00000000000000, 25.000000000000000 },
7c62b943 1163 { 1.2131584253026677e+37, 100.00000000000000, 30.000000000000000 },
2be75957 1164 { 1.1016916354696688e+30, 100.00000000000000, 35.000000000000000 },
7c62b943 1165 { 7.0074023297775712e+23, 100.00000000000000, 40.000000000000000 },
2be75957
ESR		 1166 { 1.9236643958470894e+18, 100.00000000000000, 45.000000000000000 },
1167 { 16394035276269.250, 100.00000000000000, 50.000000000000000 },
1168 { 343254952.89495474, 100.00000000000000, 55.000000000000000 },
1169 { 14870.012754946298, 100.00000000000000, 60.000000000000000 },
1170 { 1.1708099078572216, 100.00000000000000, 65.000000000000000 },
1171 { 0.00015161193930722313, 100.00000000000000, 70.000000000000000 },
1172 { 2.9850234381623443e-08, 100.00000000000000, 75.000000000000000 },
1173 { 8.3928710724649129e-12, 100.00000000000000, 80.000000000000000 },
1174 { 3.2033435630927732e-15, 100.00000000000000, 85.000000000000000 },
1175 { 1.5922281431788096e-18, 100.00000000000000, 90.000000000000000 },
1176 { 9.9589454577674131e-22, 100.00000000000000, 95.000000000000000 },
1177 { 7.6171296304940840e-25, 100.00000000000000, 100.00000000000000 },
7c62b943
BK		 1178};
1179
1180// Test function for nu=100.00000000000000.
2be75957
ESR		 1181template<typename Tp>
1182 void
1183 test022()
1184 {
1185 bool test [[gnu::unused]] = true;
1186 const Tp eps = std::numeric_limits<Tp>::epsilon();
1187 Tp max_abs_diff = -Tp(1);
1188 Tp max_abs_frac = -Tp(1);
1189 unsigned int num_datum = sizeof(data022)
1190 / sizeof(testcase_cyl_bessel_k<double>);
1191 for (unsigned int i = 0; i < num_datum; ++i)
1192 {
1193 const Tp f = std::tr1::cyl_bessel_k(Tp(data022[i].nu), Tp(data022[i].x));
1194 const Tp f0 = data022[i].f0;
1195 const Tp diff = f - f0;
1196 if (std::abs(diff) > max_abs_diff)
1197 max_abs_diff = std::abs(diff);
1198 if (std::abs(f0) > Tp(10) * eps
1199 && std::abs(f) > Tp(10) * eps)
1200 {
1201 const Tp frac = diff / f0;
1202 if (std::abs(frac) > max_abs_frac)
1203 max_abs_frac = std::abs(frac);
1204 }
1205 }
1206 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1207 }
7c62b943 1208
2be75957
ESR		 1209int
1210main()
7c62b943
BK		 1211{
1212 test001<double>();
1213 test002<double>();
1214 test003<double>();
1215 test004<double>();
1216 test005<double>();
1217 test006<double>();
1218 test007<double>();
1219 test008<double>();
1220 test009<double>();
1221 test010<double>();
1222 test011<double>();
2be75957
ESR		 1223 test012<double>();
1224 test013<double>();
1225 test014<double>();
1226 test015<double>();
1227 test016<double>();
1228 test017<double>();
1229 test018<double>();
1230 test019<double>();
1231 test020<double>();
1232 test021<double>();
1233 test022<double>();
7c62b943
BK		 1234 return 0;
1235}
Mirror of https://gcc.gnu.org/git/gcc.git