]> git.ipfire.org Git - thirdparty/gcc.git/blame - libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/08_cyl_bessel_i/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 / 08_cyl_bessel_i / 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_i
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_i<double> data001[] = {
2be75957
ESR		 44 { 1.0000000000000000, 0.0000000000000000, 0.0000000000000000 },
45 { 1.0156861412236078, 0.0000000000000000, 0.25000000000000000 },
46 { 1.0634833707413236, 0.0000000000000000, 0.50000000000000000 },
47 { 1.1456467780440014, 0.0000000000000000, 0.75000000000000000 },
48 { 1.2660658777520082, 0.0000000000000000, 1.0000000000000000 },
49 { 1.4304687177218294, 0.0000000000000000, 1.2500000000000000 },
50 { 1.6467231897728904, 0.0000000000000000, 1.5000000000000000 },
51 { 1.9252521538585023, 0.0000000000000000, 1.7500000000000000 },
52 { 2.2795853023360668, 0.0000000000000000, 2.0000000000000000 },
53 { 2.7270783071907951, 0.0000000000000000, 2.2500000000000000 },
54 { 3.2898391440501231, 0.0000000000000000, 2.5000000000000000 },
55 { 3.9959131072376550, 0.0000000000000000, 2.7500000000000000 },
56 { 4.8807925858650245, 0.0000000000000000, 3.0000000000000000 },
57 { 5.9893359979395138, 0.0000000000000000, 3.2500000000000000 },
58 { 7.3782034322254750, 0.0000000000000000, 3.5000000000000000 },
59 { 9.1189458608445655, 0.0000000000000000, 3.7500000000000000 },
60 { 11.301921952136325, 0.0000000000000000, 4.0000000000000000 },
61 { 14.041263683000595, 0.0000000000000000, 4.2500000000000000 },
62 { 17.481171855609272, 0.0000000000000000, 4.5000000000000000 },
63 { 21.803898740902120, 0.0000000000000000, 4.7500000000000000 },
64 { 27.239871823604439, 0.0000000000000000, 5.0000000000000000 },
65};
66
67// Test function for nu=0.0000000000000000.
68template<typename Tp>
69 void
70 test001()
71 {
72 bool test [[gnu::unused]] = true;
73 const Tp eps = std::numeric_limits<Tp>::epsilon();
74 Tp max_abs_diff = -Tp(1);
75 Tp max_abs_frac = -Tp(1);
76 unsigned int num_datum = sizeof(data001)
77 / sizeof(testcase_cyl_bessel_i<double>);
78 for (unsigned int i = 0; i < num_datum; ++i)
79 {
80 const Tp f = std::tr1::cyl_bessel_i(Tp(data001[i].nu), Tp(data001[i].x));
81 const Tp f0 = data001[i].f0;
82 const Tp diff = f - f0;
83 if (std::abs(diff) > max_abs_diff)
84 max_abs_diff = std::abs(diff);
85 if (std::abs(f0) > Tp(10) * eps
86 && std::abs(f) > Tp(10) * eps)
87 {
88 const Tp frac = diff / f0;
89 if (std::abs(frac) > max_abs_frac)
90 max_abs_frac = std::abs(frac);
91 }
92 }
93 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
94 }
95
96// Test data for nu=0.33333333333333331.
97testcase_cyl_bessel_i<double> data002[] = {
98 { 0.0000000000000000, 0.33333333333333331, 0.0000000000000000 },
99 { 0.56650686557808660, 0.33333333333333331, 0.25000000000000000 },
100 { 0.73897315642511863, 0.33333333333333331, 0.50000000000000000 },
101 { 0.89532320365836804, 0.33333333333333331, 0.75000000000000000 },
102 { 1.0646313978895285, 0.33333333333333331, 1.0000000000000000 },
103 { 1.2623776732605250, 0.33333333333333331, 1.2500000000000000 },
104 { 1.5014290000224382, 0.33333333333333331, 1.5000000000000000 },
105 { 1.7951195525946044, 0.33333333333333331, 1.7500000000000000 },
106 { 2.1587825813728614, 0.33333333333333331, 2.0000000000000000 },
107 { 2.6109134564811405, 0.33333333333333331, 2.2500000000000000 },
108 { 3.1743242297241938, 0.33333333333333331, 2.5000000000000000 },
109 { 3.8774551722182107, 0.33333333333333331, 2.7500000000000000 },
110 { 4.7559569371646946, 0.33333333333333331, 3.0000000000000000 },
111 { 5.8546499652731825, 0.33333333333333331, 3.2500000000000000 },
112 { 7.2299798619171147, 0.33333333333333331, 3.5000000000000000 },
113 { 8.9531114355506318, 0.33333333333333331, 3.7500000000000000 },
114 { 11.113838389991479, 0.33333333333333331, 4.0000000000000000 },
115 { 13.825531136529117, 0.33333333333333331, 4.2500000000000000 },
116 { 17.231403968478318, 0.33333333333333331, 4.5000000000000000 },
117 { 21.512458099556554, 0.33333333333333331, 4.7500000000000000 },
118 { 26.897553069268362, 0.33333333333333331, 5.0000000000000000 },
119};
120
121// Test function for nu=0.33333333333333331.
122template<typename Tp>
123 void
124 test002()
125 {
126 bool test [[gnu::unused]] = true;
127 const Tp eps = std::numeric_limits<Tp>::epsilon();
128 Tp max_abs_diff = -Tp(1);
129 Tp max_abs_frac = -Tp(1);
130 unsigned int num_datum = sizeof(data002)
131 / sizeof(testcase_cyl_bessel_i<double>);
132 for (unsigned int i = 0; i < num_datum; ++i)
133 {
134 const Tp f = std::tr1::cyl_bessel_i(Tp(data002[i].nu), Tp(data002[i].x));
135 const Tp f0 = data002[i].f0;
136 const Tp diff = f - f0;
137 if (std::abs(diff) > max_abs_diff)
138 max_abs_diff = std::abs(diff);
139 if (std::abs(f0) > Tp(10) * eps
140 && std::abs(f) > Tp(10) * eps)
141 {
142 const Tp frac = diff / f0;
143 if (std::abs(frac) > max_abs_frac)
144 max_abs_frac = std::abs(frac);
145 }
146 }
147 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
148 }
149
150// Test data for nu=0.50000000000000000.
151testcase_cyl_bessel_i<double> data003[] = {
152 { 0.0000000000000000, 0.50000000000000000, 0.0000000000000000 },
153 { 0.40311093489975897, 0.50000000000000000, 0.25000000000000000 },
154 { 0.58799308679041573, 0.50000000000000000, 0.50000000000000000 },
155 { 0.75761498638991298, 0.50000000000000000, 0.75000000000000000 },
156 { 0.93767488824548695, 0.50000000000000000, 1.0000000000000000 },
157 { 1.1432089853159872, 0.50000000000000000, 1.2500000000000000 },
158 { 1.3871617204034761, 0.50000000000000000, 1.5000000000000000 },
159 { 1.6830217804556815, 0.50000000000000000, 1.7500000000000000 },
160 { 2.0462368630890526, 0.50000000000000000, 2.0000000000000000 },
161 { 2.4953405089360041, 0.50000000000000000, 2.2500000000000000 },
162 { 3.0530935381967175, 0.50000000000000000, 2.5000000000000000 },
163 { 3.7477882494879449, 0.50000000000000000, 2.7500000000000000 },
164 { 4.6148229034075969, 0.50000000000000000, 3.0000000000000000 },
165 { 5.6986505325335495, 0.50000000000000000, 3.2500000000000000 },
166 { 7.0552194086911877, 0.50000000000000000, 3.5000000000000000 },
167 { 8.7550467841188944, 0.50000000000000000, 3.7500000000000000 },
168 { 10.887101798588422, 0.50000000000000000, 4.0000000000000000 },
169 { 13.563718712579764, 0.50000000000000000, 4.2500000000000000 },
170 { 16.926820080158183, 0.50000000000000000, 4.5000000000000000 },
171 { 21.155804306570005, 0.50000000000000000, 4.7500000000000000 },
172 { 26.477547497559065, 0.50000000000000000, 5.0000000000000000 },
173};
174
175// Test function for nu=0.50000000000000000.
176template<typename Tp>
177 void
178 test003()
179 {
180 bool test [[gnu::unused]] = true;
181 const Tp eps = std::numeric_limits<Tp>::epsilon();
182 Tp max_abs_diff = -Tp(1);
183 Tp max_abs_frac = -Tp(1);
184 unsigned int num_datum = sizeof(data003)
185 / sizeof(testcase_cyl_bessel_i<double>);
186 for (unsigned int i = 0; i < num_datum; ++i)
187 {
188 const Tp f = std::tr1::cyl_bessel_i(Tp(data003[i].nu), Tp(data003[i].x));
189 const Tp f0 = data003[i].f0;
190 const Tp diff = f - f0;
191 if (std::abs(diff) > max_abs_diff)
192 max_abs_diff = std::abs(diff);
193 if (std::abs(f0) > Tp(10) * eps
194 && std::abs(f) > Tp(10) * eps)
195 {
196 const Tp frac = diff / f0;
197 if (std::abs(frac) > max_abs_frac)
198 max_abs_frac = std::abs(frac);
199 }
200 }
201 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
202 }
203
204// Test data for nu=0.66666666666666663.
205testcase_cyl_bessel_i<double> data004[] = {
206 { 0.0000000000000000, 0.66666666666666663, 0.0000000000000000 },
207 { 0.27953690613200438, 0.66666666666666663, 0.25000000000000000 },
208 { 0.45628323113556879, 0.66666666666666663, 0.50000000000000000 },
209 { 0.62594569838182612, 0.66666666666666663, 0.75000000000000000 },
210 { 0.80752128860612948, 0.66666666666666663, 1.0000000000000000 },
211 { 1.0139484513577168, 0.66666666666666663, 1.2500000000000000 },
212 { 1.2572918396962991, 0.66666666666666663, 1.5000000000000000 },
213 { 1.5505806938325577, 0.66666666666666663, 1.7500000000000000 },
214 { 1.9089492968236206, 0.66666666666666663, 2.0000000000000000 },
215 { 2.3506463490300331, 0.66666666666666663, 2.2500000000000000 },
216 { 2.8981161894224892, 0.66666666666666663, 2.5000000000000000 },
217 { 3.5792654911068720, 0.66666666666666663, 2.7500000000000000 },
218 { 4.4290087213549505, 0.66666666666666663, 3.0000000000000000 },
219 { 5.4911895720097688, 0.66666666666666663, 3.2500000000000000 },
220 { 6.8209918044137305, 0.66666666666666663, 3.5000000000000000 },
221 { 8.4879784249619767, 0.66666666666666663, 3.7500000000000000 },
222 { 10.579932774013002, 0.66666666666666663, 4.0000000000000000 },
223 { 13.207720355482458, 0.66666666666666663, 4.2500000000000000 },
224 { 16.511448404200543, 0.66666666666666663, 4.5000000000000000 },
225 { 20.668274532832392, 0.66666666666666663, 4.7500000000000000 },
226 { 25.902310583215122, 0.66666666666666663, 5.0000000000000000 },
227};
228
229// Test function for nu=0.66666666666666663.
230template<typename Tp>
231 void
232 test004()
233 {
234 bool test [[gnu::unused]] = true;
235 const Tp eps = std::numeric_limits<Tp>::epsilon();
236 Tp max_abs_diff = -Tp(1);
237 Tp max_abs_frac = -Tp(1);
238 unsigned int num_datum = sizeof(data004)
239 / sizeof(testcase_cyl_bessel_i<double>);
240 for (unsigned int i = 0; i < num_datum; ++i)
241 {
242 const Tp f = std::tr1::cyl_bessel_i(Tp(data004[i].nu), Tp(data004[i].x));
243 const Tp f0 = data004[i].f0;
244 const Tp diff = f - f0;
245 if (std::abs(diff) > max_abs_diff)
246 max_abs_diff = std::abs(diff);
247 if (std::abs(f0) > Tp(10) * eps
248 && std::abs(f) > Tp(10) * eps)
249 {
250 const Tp frac = diff / f0;
251 if (std::abs(frac) > max_abs_frac)
252 max_abs_frac = std::abs(frac);
253 }
254 }
255 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
256 }
257
258// Test data for nu=1.0000000000000000.
259testcase_cyl_bessel_i<double> data005[] = {
260 { 0.0000000000000000, 1.0000000000000000, 0.0000000000000000 },
261 { 0.12597910894546793, 1.0000000000000000, 0.25000000000000000 },
262 { 0.25789430539089631, 1.0000000000000000, 0.50000000000000000 },
263 { 0.40199246158092228, 1.0000000000000000, 0.75000000000000000 },
264 { 0.56515910399248503, 1.0000000000000000, 1.0000000000000000 },
265 { 0.75528141834074725, 1.0000000000000000, 1.2500000000000000 },
266 { 0.98166642857790720, 1.0000000000000000, 1.5000000000000000 },
267 { 1.2555375122401731, 1.0000000000000000, 1.7500000000000000 },
268 { 1.5906368546373291, 1.0000000000000000, 2.0000000000000000 },
269 { 2.0039674569295931, 1.0000000000000000, 2.2500000000000000 },
270 { 2.5167162452886984, 1.0000000000000000, 2.5000000000000000 },
271 { 3.1554101386190028, 1.0000000000000000, 2.7500000000000000 },
272 { 3.9533702174026097, 1.0000000000000000, 3.0000000000000000 },
273 { 4.9525461659085490, 1.0000000000000000, 3.2500000000000000 },
274 { 6.2058349222583642, 1.0000000000000000, 3.5000000000000000 },
275 { 7.7800152298244161, 1.0000000000000000, 3.7500000000000000 },
276 { 9.7594651537044488, 1.0000000000000000, 4.0000000000000000 },
277 { 12.250874667409304, 1.0000000000000000, 4.2500000000000000 },
278 { 15.389222753735924, 1.0000000000000000, 4.5000000000000000 },
279 { 19.345361447520226, 1.0000000000000000, 4.7500000000000000 },
280 { 24.335642142450524, 1.0000000000000000, 5.0000000000000000 },
281};
282
283// Test function for nu=1.0000000000000000.
284template<typename Tp>
285 void
286 test005()
287 {
288 bool test [[gnu::unused]] = true;
289 const Tp eps = std::numeric_limits<Tp>::epsilon();
290 Tp max_abs_diff = -Tp(1);
291 Tp max_abs_frac = -Tp(1);
292 unsigned int num_datum = sizeof(data005)
293 / sizeof(testcase_cyl_bessel_i<double>);
294 for (unsigned int i = 0; i < num_datum; ++i)
295 {
296 const Tp f = std::tr1::cyl_bessel_i(Tp(data005[i].nu), Tp(data005[i].x));
297 const Tp f0 = data005[i].f0;
298 const Tp diff = f - f0;
299 if (std::abs(diff) > max_abs_diff)
300 max_abs_diff = std::abs(diff);
301 if (std::abs(f0) > Tp(10) * eps
302 && std::abs(f) > Tp(10) * eps)
303 {
304 const Tp frac = diff / f0;
305 if (std::abs(frac) > max_abs_frac)
306 max_abs_frac = std::abs(frac);
307 }
308 }
309 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
310 }
311
312// Test data for nu=2.0000000000000000.
313testcase_cyl_bessel_i<double> data006[] = {
314 { 0.0000000000000000, 2.0000000000000000, 0.0000000000000000 },
315 { 0.0078532696598645167, 2.0000000000000000, 0.25000000000000000 },
316 { 0.031906149177738249, 2.0000000000000000, 0.50000000000000000 },
317 { 0.073666880494875436, 2.0000000000000000, 0.75000000000000000 },
318 { 0.13574766976703831, 2.0000000000000000, 1.0000000000000000 },
319 { 0.22201844837663415, 2.0000000000000000, 1.2500000000000000 },
320 { 0.33783461833568068, 2.0000000000000000, 1.5000000000000000 },
321 { 0.49035213986973319, 2.0000000000000000, 1.7500000000000000 },
322 { 0.68894844769873831, 2.0000000000000000, 2.0000000000000000 },
323 { 0.94577390103115722, 2.0000000000000000, 2.2500000000000000 },
324 { 1.2764661478191643, 2.0000000000000000, 2.5000000000000000 },
325 { 1.7010693700601991, 2.0000000000000000, 2.7500000000000000 },
326 { 2.2452124409299512, 2.0000000000000000, 3.0000000000000000 },
327 { 2.9416152804573357, 2.0000000000000000, 3.2500000000000000 },
328 { 3.8320120480778415, 2.0000000000000000, 3.5000000000000000 },
329 { 4.9696044049382113, 2.0000000000000000, 3.7500000000000000 },
330 { 6.4221893752841046, 2.0000000000000000, 4.0000000000000000 },
331 { 8.2761461924550552, 2.0000000000000000, 4.2500000000000000 },
332 { 10.641517298393307, 2.0000000000000000, 4.5000000000000000 },
333 { 13.658483394577813, 2.0000000000000000, 4.7500000000000000 },
334 { 17.505614966624233, 2.0000000000000000, 5.0000000000000000 },
335};
336
337// Test function for nu=2.0000000000000000.
338template<typename Tp>
339 void
340 test006()
341 {
342 bool test [[gnu::unused]] = true;
343 const Tp eps = std::numeric_limits<Tp>::epsilon();
344 Tp max_abs_diff = -Tp(1);
345 Tp max_abs_frac = -Tp(1);
346 unsigned int num_datum = sizeof(data006)
347 / sizeof(testcase_cyl_bessel_i<double>);
348 for (unsigned int i = 0; i < num_datum; ++i)
349 {
350 const Tp f = std::tr1::cyl_bessel_i(Tp(data006[i].nu), Tp(data006[i].x));
351 const Tp f0 = data006[i].f0;
352 const Tp diff = f - f0;
353 if (std::abs(diff) > max_abs_diff)
354 max_abs_diff = std::abs(diff);
355 if (std::abs(f0) > Tp(10) * eps
356 && std::abs(f) > Tp(10) * eps)
357 {
358 const Tp frac = diff / f0;
359 if (std::abs(frac) > max_abs_frac)
360 max_abs_frac = std::abs(frac);
361 }
362 }
363 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
364 }
365
366// Test data for nu=5.0000000000000000.
367testcase_cyl_bessel_i<double> data007[] = {
368 { 0.0000000000000000, 5.0000000000000000, 0.0000000000000000 },
369 { 2.5497616449882785e-07, 5.0000000000000000, 0.25000000000000000 },
370 { 8.2231713131092646e-06, 5.0000000000000000, 0.50000000000000000 },
371 { 6.3261122739811725e-05, 5.0000000000000000, 0.75000000000000000 },
372 { 0.00027146315595697195, 5.0000000000000000, 1.0000000000000000 },
373 { 0.00084793613616686856, 5.0000000000000000, 1.2500000000000000 },
374 { 0.0021705595690975554, 5.0000000000000000, 1.5000000000000000 },
375 { 0.0048504513371845394, 5.0000000000000000, 1.7500000000000000 },
376 { 0.0098256793231317023, 5.0000000000000000, 2.0000000000000000 },
377 { 0.018486577941045829, 5.0000000000000000, 2.2500000000000000 },
378 { 0.032843475172023219, 5.0000000000000000, 2.5000000000000000 },
379 { 0.055750882754221943, 5.0000000000000000, 2.7500000000000000 },
380 { 0.091206477661513338, 5.0000000000000000, 3.0000000000000000 },
381 { 0.14474880546308083, 5.0000000000000000, 3.2500000000000000 },
382 { 0.22398495470190780, 5.0000000000000000, 3.5000000000000000 },
383 { 0.33928899170999866, 5.0000000000000000, 3.7500000000000000 },
384 { 0.50472436311316626, 5.0000000000000000, 4.0000000000000000 },
385 { 0.73925961816682961, 5.0000000000000000, 4.2500000000000000 },
386 { 1.0683677743764699, 5.0000000000000000, 4.5000000000000000 },
387 { 1.5261268693599621, 5.0000000000000000, 4.7500000000000000 },
388 { 2.1579745473225476, 5.0000000000000000, 5.0000000000000000 },
389};
390
391// Test function for nu=5.0000000000000000.
392template<typename Tp>
393 void
394 test007()
395 {
396 bool test [[gnu::unused]] = true;
397 const Tp eps = std::numeric_limits<Tp>::epsilon();
398 Tp max_abs_diff = -Tp(1);
399 Tp max_abs_frac = -Tp(1);
400 unsigned int num_datum = sizeof(data007)
401 / sizeof(testcase_cyl_bessel_i<double>);
402 for (unsigned int i = 0; i < num_datum; ++i)
403 {
404 const Tp f = std::tr1::cyl_bessel_i(Tp(data007[i].nu), Tp(data007[i].x));
405 const Tp f0 = data007[i].f0;
406 const Tp diff = f - f0;
407 if (std::abs(diff) > max_abs_diff)
408 max_abs_diff = std::abs(diff);
409 if (std::abs(f0) > Tp(10) * eps
410 && std::abs(f) > Tp(10) * eps)
411 {
412 const Tp frac = diff / f0;
413 if (std::abs(frac) > max_abs_frac)
414 max_abs_frac = std::abs(frac);
415 }
416 }
417 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
418 }
419
420// Test data for nu=10.000000000000000.
421testcase_cyl_bessel_i<double> data008[] = {
422 { 0.0000000000000000, 10.000000000000000, 0.0000000000000000 },
423 { 2.5701232848571186e-16, 10.000000000000000, 0.25000000000000000 },
424 { 2.6430419258812784e-13, 10.000000000000000, 0.50000000000000000 },
425 { 1.5349659676120412e-11, 10.000000000000000, 0.75000000000000000 },
426 { 2.7529480398368732e-10, 10.000000000000000, 1.0000000000000000 },
427 { 2.5967897782035928e-09, 10.000000000000000, 1.2500000000000000 },
428 { 1.6330924437799743e-08, 10.000000000000000, 1.5000000000000000 },
429 { 7.7706676834614093e-08, 10.000000000000000, 1.7500000000000000 },
430 { 3.0169638793506839e-07, 10.000000000000000, 2.0000000000000000 },
431 { 1.0034459057774481e-06, 10.000000000000000, 2.2500000000000000 },
432 { 2.9557436109680578e-06, 10.000000000000000, 2.5000000000000000 },
433 { 7.8955603774082724e-06, 10.000000000000000, 2.7500000000000000 },
434 { 1.9464393470612970e-05, 10.000000000000000, 3.0000000000000000 },
435 { 4.4875369479742435e-05, 10.000000000000000, 3.2500000000000000 },
436 { 9.7760848514528916e-05, 10.000000000000000, 3.5000000000000000 },
437 { 0.00020289011210063493, 10.000000000000000, 3.7500000000000000 },
438 { 0.00040378896132693047, 10.000000000000000, 4.0000000000000000 },
439 { 0.00077478519551669892, 10.000000000000000, 4.2500000000000000 },
440 { 0.0014397060684919682, 10.000000000000000, 4.5000000000000000 },
441 { 0.0026004486016189452, 10.000000000000000, 4.7500000000000000 },
442 { 0.0045800444191760525, 10.000000000000000, 5.0000000000000000 },
443};
444
445// Test function for nu=10.000000000000000.
446template<typename Tp>
447 void
448 test008()
449 {
450 bool test [[gnu::unused]] = true;
451 const Tp eps = std::numeric_limits<Tp>::epsilon();
452 Tp max_abs_diff = -Tp(1);
453 Tp max_abs_frac = -Tp(1);
454 unsigned int num_datum = sizeof(data008)
455 / sizeof(testcase_cyl_bessel_i<double>);
456 for (unsigned int i = 0; i < num_datum; ++i)
457 {
458 const Tp f = std::tr1::cyl_bessel_i(Tp(data008[i].nu), Tp(data008[i].x));
459 const Tp f0 = data008[i].f0;
460 const Tp diff = f - f0;
461 if (std::abs(diff) > max_abs_diff)
462 max_abs_diff = std::abs(diff);
463 if (std::abs(f0) > Tp(10) * eps
464 && std::abs(f) > Tp(10) * eps)
465 {
466 const Tp frac = diff / f0;
467 if (std::abs(frac) > max_abs_frac)
468 max_abs_frac = std::abs(frac);
469 }
470 }
471 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
472 }
473
474// Test data for nu=20.000000000000000.
475testcase_cyl_bessel_i<double> data009[] = {
476 { 0.0000000000000000, 20.000000000000000, 0.0000000000000000 },
477 { 3.5677858077910353e-37, 20.000000000000000, 0.25000000000000000 },
478 { 3.7494538480790194e-31, 20.000000000000000, 0.50000000000000000 },
479 { 1.2514356342425337e-27, 20.000000000000000, 0.75000000000000000 },
480 { 3.9668359858190197e-25, 20.000000000000000, 1.0000000000000000 },
481 { 3.4637832909868234e-23, 20.000000000000000, 1.2500000000000000 },
482 { 1.3388331839683472e-21, 20.000000000000000, 1.5000000000000000 },
483 { 2.9502376732679751e-20, 20.000000000000000, 1.7500000000000000 },
484 { 4.3105605761095479e-19, 20.000000000000000, 2.0000000000000000 },
485 { 4.6032451406433059e-18, 20.000000000000000, 2.2500000000000000 },
486 { 3.8400317244170310e-17, 20.000000000000000, 2.5000000000000000 },
487 { 2.6239115263043263e-16, 20.000000000000000, 2.7500000000000000 },
488 { 1.5209660019426689e-15, 20.000000000000000, 3.0000000000000000 },
489 { 7.6806450728249953e-15, 20.000000000000000, 3.2500000000000000 },
490 { 3.4495528847222945e-14, 20.000000000000000, 3.5000000000000000 },
491 { 1.4006589294850672e-13, 20.000000000000000, 3.7500000000000000 },
492 { 5.2100734221993044e-13, 20.000000000000000, 4.0000000000000000 },
493 { 1.7946903269488168e-12, 20.000000000000000, 4.2500000000000000 },
494 { 5.7763830562279683e-12, 20.000000000000000, 4.5000000000000000 },
495 { 1.7502433074548735e-11, 20.000000000000000, 4.7500000000000000 },
496 { 5.0242393579718066e-11, 20.000000000000000, 5.0000000000000000 },
497};
498
499// Test function for nu=20.000000000000000.
500template<typename Tp>
501 void
502 test009()
503 {
504 bool test [[gnu::unused]] = true;
505 const Tp eps = std::numeric_limits<Tp>::epsilon();
506 Tp max_abs_diff = -Tp(1);
507 Tp max_abs_frac = -Tp(1);
508 unsigned int num_datum = sizeof(data009)
509 / sizeof(testcase_cyl_bessel_i<double>);
510 for (unsigned int i = 0; i < num_datum; ++i)
511 {
512 const Tp f = std::tr1::cyl_bessel_i(Tp(data009[i].nu), Tp(data009[i].x));
513 const Tp f0 = data009[i].f0;
514 const Tp diff = f - f0;
515 if (std::abs(diff) > max_abs_diff)
516 max_abs_diff = std::abs(diff);
517 if (std::abs(f0) > Tp(10) * eps
518 && std::abs(f) > Tp(10) * eps)
519 {
520 const Tp frac = diff / f0;
521 if (std::abs(frac) > max_abs_frac)
522 max_abs_frac = std::abs(frac);
523 }
524 }
525 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
526 }
527// cyl_bessel_i
528
529// Test data for nu=0.0000000000000000.
530testcase_cyl_bessel_i<double> data010[] = {
7c62b943
BK		 531 { 1.0000000000000000, 0.0000000000000000, 0.0000000000000000 },
532 { 27.239871823604439, 0.0000000000000000, 5.0000000000000000 },
533 { 2815.7166284662558, 0.0000000000000000, 10.000000000000000 },
534 { 339649.37329791381, 0.0000000000000000, 15.000000000000000 },
535 { 43558282.559553474, 0.0000000000000000, 20.000000000000000 },
536 { 5774560606.4663124, 0.0000000000000000, 25.000000000000000 },
537 { 781672297823.97925, 0.0000000000000000, 30.000000000000000 },
538 { 107338818494514.42, 0.0000000000000000, 35.000000000000000 },
539 { 14894774793419918., 0.0000000000000000, 40.000000000000000 },
2be75957
ESR		 540 { 2.0834140751773164e+18, 0.0000000000000000, 45.000000000000000 },
541 { 2.9325537838493457e+20, 0.0000000000000000, 50.000000000000000 },
7c62b943
BK		 542 { 4.1487895607332160e+22, 0.0000000000000000, 55.000000000000000 },
543 { 5.8940770556098216e+24, 0.0000000000000000, 60.000000000000000 },
2be75957
ESR		 544 { 8.4030398456255596e+26, 0.0000000000000000, 65.000000000000000 },
545 { 1.2015889579125424e+29, 0.0000000000000000, 70.000000000000000 },
546 { 1.7226390780357976e+31, 0.0000000000000000, 75.000000000000000 },
547 { 2.4751784043341661e+33, 0.0000000000000000, 80.000000000000000 },
548 { 3.5634776304081403e+35, 0.0000000000000000, 85.000000000000000 },
7c62b943 549 { 5.1392383455086475e+37, 0.0000000000000000, 90.000000000000000 },
2be75957 550 { 7.4233258618752072e+39, 0.0000000000000000, 95.000000000000000 },
7c62b943
BK		 551 { 1.0737517071310986e+42, 0.0000000000000000, 100.00000000000000 },
552};
553
554// Test function for nu=0.0000000000000000.
2be75957
ESR		 555template<typename Tp>
556 void
557 test010()
558 {
559 bool test [[gnu::unused]] = true;
560 const Tp eps = std::numeric_limits<Tp>::epsilon();
561 Tp max_abs_diff = -Tp(1);
562 Tp max_abs_frac = -Tp(1);
563 unsigned int num_datum = sizeof(data010)
564 / sizeof(testcase_cyl_bessel_i<double>);
565 for (unsigned int i = 0; i < num_datum; ++i)
566 {
567 const Tp f = std::tr1::cyl_bessel_i(Tp(data010[i].nu), Tp(data010[i].x));
568 const Tp f0 = data010[i].f0;
569 const Tp diff = f - f0;
570 if (std::abs(diff) > max_abs_diff)
571 max_abs_diff = std::abs(diff);
572 if (std::abs(f0) > Tp(10) * eps
573 && std::abs(f) > Tp(10) * eps)
574 {
575 const Tp frac = diff / f0;
576 if (std::abs(frac) > max_abs_frac)
577 max_abs_frac = std::abs(frac);
578 }
579 }
580 VERIFY(max_abs_frac < Tp(2.5000000000000015e-12));
581 }
7c62b943
BK		 582
583// Test data for nu=0.33333333333333331.
2be75957 584testcase_cyl_bessel_i<double> data011[] = {
7c62b943
BK		 585 { 0.0000000000000000, 0.33333333333333331, 0.0000000000000000 },
586 { 26.897553069268362, 0.33333333333333331, 5.0000000000000000 },
587 { 2799.2396097056790, 0.33333333333333331, 10.000000000000000 },
2be75957
ESR		 588 { 338348.63146593666, 0.33333333333333331, 15.000000000000000 },
589 { 43434263.927938424, 0.33333333333333331, 20.000000000000000 },
7c62b943 590 { 5761474759.6213636, 0.33333333333333331, 25.000000000000000 },
2be75957
ESR		 591 { 780201111830.30237, 0.33333333333333331, 30.000000000000000 },
592 { 107166066959051.91, 0.33333333333333331, 35.000000000000000 },
593 { 14873836574083764., 0.33333333333333331, 40.000000000000000 },
7c62b943 594 { 2.0808143020217085e+18, 0.33333333333333331, 45.000000000000000 },
2be75957 595 { 2.9292639365644226e+20, 0.33333333333333331, 50.000000000000000 },
7c62b943
BK		 596 { 4.1445621624120489e+22, 0.33333333333333331, 55.000000000000000 },
597 { 5.8885758374365916e+24, 0.33333333333333331, 60.000000000000000 },
598 { 8.3958047021083955e+26, 0.33333333333333331, 65.000000000000000 },
599 { 1.2006287819446431e+29, 0.33333333333333331, 70.000000000000000 },
600 { 1.7213548977150022e+31, 0.33333333333333331, 75.000000000000000 },
601 { 2.4734492458444449e+33, 0.33333333333333331, 80.000000000000000 },
602 { 3.5611354547857122e+35, 0.33333333333333331, 85.000000000000000 },
2be75957 603 { 5.1360491295551848e+37, 0.33333333333333331, 90.000000000000000 },
7c62b943
BK		 604 { 7.4189629097600431e+39, 0.33333333333333331, 95.000000000000000 },
605 { 1.0731523308358370e+42, 0.33333333333333331, 100.00000000000000 },
606};
607
608// Test function for nu=0.33333333333333331.
2be75957
ESR		 609template<typename Tp>
610 void
611 test011()
612 {
613 bool test [[gnu::unused]] = true;
614 const Tp eps = std::numeric_limits<Tp>::epsilon();
615 Tp max_abs_diff = -Tp(1);
616 Tp max_abs_frac = -Tp(1);
617 unsigned int num_datum = sizeof(data011)
618 / sizeof(testcase_cyl_bessel_i<double>);
619 for (unsigned int i = 0; i < num_datum; ++i)
620 {
621 const Tp f = std::tr1::cyl_bessel_i(Tp(data011[i].nu), Tp(data011[i].x));
622 const Tp f0 = data011[i].f0;
623 const Tp diff = f - f0;
624 if (std::abs(diff) > max_abs_diff)
625 max_abs_diff = std::abs(diff);
626 if (std::abs(f0) > Tp(10) * eps
627 && std::abs(f) > Tp(10) * eps)
628 {
629 const Tp frac = diff / f0;
630 if (std::abs(frac) > max_abs_frac)
631 max_abs_frac = std::abs(frac);
632 }
633 }
634 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
635 }
7c62b943
BK		 636
637// Test data for nu=0.50000000000000000.
2be75957 638testcase_cyl_bessel_i<double> data012[] = {
7c62b943
BK		 639 { 0.0000000000000000, 0.50000000000000000, 0.0000000000000000 },
640 { 26.477547497559065, 0.50000000000000000, 5.0000000000000000 },
641 { 2778.7846038745711, 0.50000000000000000, 10.000000000000000 },
642 { 336729.88718706399, 0.50000000000000000, 15.000000000000000 },
643 { 43279746.272428922, 0.50000000000000000, 20.000000000000000 },
644 { 5745159748.3464680, 0.50000000000000000, 25.000000000000000 },
645 { 778366068840.44580, 0.50000000000000000, 30.000000000000000 },
646 { 106950522408567.66, 0.50000000000000000, 35.000000000000000 },
647 { 14847705549021962., 0.50000000000000000, 40.000000000000000 },
648 { 2.0775691824625661e+18, 0.50000000000000000, 45.000000000000000 },
2be75957 649 { 2.9251568529912984e+20, 0.50000000000000000, 50.000000000000000 },
7c62b943
BK		 650 { 4.1392840094781220e+22, 0.50000000000000000, 55.000000000000000 },
651 { 5.8817065760751945e+24, 0.50000000000000000, 60.000000000000000 },
2be75957 652 { 8.3867695787277258e+26, 0.50000000000000000, 65.000000000000000 },
7c62b943 653 { 1.1994296461653203e+29, 0.50000000000000000, 70.000000000000000 },
2be75957 654 { 1.7197510246063334e+31, 0.50000000000000000, 75.000000000000000 },
7c62b943
BK		 655 { 2.4712895036230794e+33, 0.50000000000000000, 80.000000000000000 },
656 { 3.5582099086757769e+35, 0.50000000000000000, 85.000000000000000 },
2be75957
ESR		 657 { 5.1320654031231128e+37, 0.50000000000000000, 90.000000000000000 },
658 { 7.4135128383495239e+39, 0.50000000000000000, 95.000000000000000 },
7c62b943
BK		 659 { 1.0724035825423179e+42, 0.50000000000000000, 100.00000000000000 },
660};
661
662// Test function for nu=0.50000000000000000.
2be75957
ESR		 663template<typename Tp>
664 void
665 test012()
666 {
667 bool test [[gnu::unused]] = true;
668 const Tp eps = std::numeric_limits<Tp>::epsilon();
669 Tp max_abs_diff = -Tp(1);
670 Tp max_abs_frac = -Tp(1);
671 unsigned int num_datum = sizeof(data012)
672 / sizeof(testcase_cyl_bessel_i<double>);
673 for (unsigned int i = 0; i < num_datum; ++i)
674 {
675 const Tp f = std::tr1::cyl_bessel_i(Tp(data012[i].nu), Tp(data012[i].x));
676 const Tp f0 = data012[i].f0;
677 const Tp diff = f - f0;
678 if (std::abs(diff) > max_abs_diff)
679 max_abs_diff = std::abs(diff);
680 if (std::abs(f0) > Tp(10) * eps
681 && std::abs(f) > Tp(10) * eps)
682 {
683 const Tp frac = diff / f0;
684 if (std::abs(frac) > max_abs_frac)
685 max_abs_frac = std::abs(frac);
686 }
687 }
688 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
689 }
7c62b943
BK		 690
691// Test data for nu=0.66666666666666663.
2be75957 692testcase_cyl_bessel_i<double> data013[] = {
7c62b943
BK		 693 { 0.0000000000000000, 0.66666666666666663, 0.0000000000000000 },
694 { 25.902310583215122, 0.66666666666666663, 5.0000000000000000 },
695 { 2750.4090423459315, 0.66666666666666663, 10.000000000000000 },
2be75957 696 { 334476.98138574377, 0.66666666666666663, 15.000000000000000 },
7c62b943
BK		 697 { 43064361.686912313, 0.66666666666666663, 20.000000000000000 },
698 { 5722397441.9603882, 0.66666666666666663, 25.000000000000000 },
699 { 775804343498.02661, 0.66666666666666663, 30.000000000000000 },
2be75957 700 { 106649495512800.88, 0.66666666666666663, 35.000000000000000 },
7c62b943
BK		 701 { 14811199896983756., 0.66666666666666663, 40.000000000000000 },
702 { 2.0730345814356961e+18, 0.66666666666666663, 45.000000000000000 },
703 { 2.9194166755257467e+20, 0.66666666666666663, 50.000000000000000 },
2be75957 704 { 4.1319059569935374e+22, 0.66666666666666663, 55.000000000000000 },
7c62b943 705 { 5.8721031476386222e+24, 0.66666666666666663, 60.000000000000000 },
2be75957 706 { 8.3741368248217844e+26, 0.66666666666666663, 65.000000000000000 },
7c62b943
BK		 707 { 1.1977528777008688e+29, 0.66666666666666663, 70.000000000000000 },
708 { 1.7175081240014333e+31, 0.66666666666666663, 75.000000000000000 },
709 { 2.4682690458513916e+33, 0.66666666666666663, 80.000000000000000 },
710 { 3.5541181975850724e+35, 0.66666666666666663, 85.000000000000000 },
2be75957 711 { 5.1264933963228892e+37, 0.66666666666666663, 90.000000000000000 },
7c62b943
BK		 712 { 7.4058894880134064e+39, 0.66666666666666663, 95.000000000000000 },
713 { 1.0713562154788124e+42, 0.66666666666666663, 100.00000000000000 },
714};
715
716// Test function for nu=0.66666666666666663.
2be75957
ESR		 717template<typename Tp>
718 void
719 test013()
720 {
721 bool test [[gnu::unused]] = true;
722 const Tp eps = std::numeric_limits<Tp>::epsilon();
723 Tp max_abs_diff = -Tp(1);
724 Tp max_abs_frac = -Tp(1);
725 unsigned int num_datum = sizeof(data013)
726 / sizeof(testcase_cyl_bessel_i<double>);
727 for (unsigned int i = 0; i < num_datum; ++i)
728 {
729 const Tp f = std::tr1::cyl_bessel_i(Tp(data013[i].nu), Tp(data013[i].x));
730 const Tp f0 = data013[i].f0;
731 const Tp diff = f - f0;
732 if (std::abs(diff) > max_abs_diff)
733 max_abs_diff = std::abs(diff);
734 if (std::abs(f0) > Tp(10) * eps
735 && std::abs(f) > Tp(10) * eps)
736 {
737 const Tp frac = diff / f0;
738 if (std::abs(frac) > max_abs_frac)
739 max_abs_frac = std::abs(frac);
740 }
741 }
742 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
743 }
7c62b943
BK		 744
745// Test data for nu=1.0000000000000000.
2be75957 746testcase_cyl_bessel_i<double> data014[] = {
7c62b943
BK		 747 { 0.0000000000000000, 1.0000000000000000, 0.0000000000000000 },
748 { 24.335642142450524, 1.0000000000000000, 5.0000000000000000 },
749 { 2670.9883037012560, 1.0000000000000000, 10.000000000000000 },
750 { 328124.92197020649, 1.0000000000000000, 15.000000000000000 },
2be75957 751 { 42454973.385127783, 1.0000000000000000, 20.000000000000000 },
7c62b943
BK		 752 { 5657865129.8787022, 1.0000000000000000, 25.000000000000000 },
753 { 768532038938.95667, 1.0000000000000000, 30.000000000000000 },
754 { 105794126051896.17, 1.0000000000000000, 35.000000000000000 },
755 { 14707396163259354., 1.0000000000000000, 40.000000000000000 },
2be75957
ESR		 756 { 2.0601334620815780e+18, 1.0000000000000000, 45.000000000000000 },
757 { 2.9030785901035638e+20, 1.0000000000000000, 50.000000000000000 },
7c62b943
BK		 758 { 4.1108986452992812e+22, 1.0000000000000000, 55.000000000000000 },
759 { 5.8447515883904527e+24, 1.0000000000000000, 60.000000000000000 },
760 { 8.3381485471501302e+26, 1.0000000000000000, 65.000000000000000 },
761 { 1.1929750788892366e+29, 1.0000000000000000, 70.000000000000000 },
2be75957 762 { 1.7111160152965382e+31, 1.0000000000000000, 75.000000000000000 },
7c62b943
BK		 763 { 2.4596595795675343e+33, 1.0000000000000000, 80.000000000000000 },
764 { 3.5424536064404024e+35, 1.0000000000000000, 85.000000000000000 },
765 { 5.1106068152566129e+37, 1.0000000000000000, 90.000000000000000 },
2be75957 766 { 7.3841518091360182e+39, 1.0000000000000000, 95.000000000000000 },
7c62b943
BK		 767 { 1.0683693903381569e+42, 1.0000000000000000, 100.00000000000000 },
768};
769
770// Test function for nu=1.0000000000000000.
2be75957
ESR		 771template<typename Tp>
772 void
773 test014()
774 {
775 bool test [[gnu::unused]] = true;
776 const Tp eps = std::numeric_limits<Tp>::epsilon();
777 Tp max_abs_diff = -Tp(1);
778 Tp max_abs_frac = -Tp(1);
779 unsigned int num_datum = sizeof(data014)
780 / sizeof(testcase_cyl_bessel_i<double>);
781 for (unsigned int i = 0; i < num_datum; ++i)
782 {
783 const Tp f = std::tr1::cyl_bessel_i(Tp(data014[i].nu), Tp(data014[i].x));
784 const Tp f0 = data014[i].f0;
785 const Tp diff = f - f0;
786 if (std::abs(diff) > max_abs_diff)
787 max_abs_diff = std::abs(diff);
788 if (std::abs(f0) > Tp(10) * eps
789 && std::abs(f) > Tp(10) * eps)
790 {
791 const Tp frac = diff / f0;
792 if (std::abs(frac) > max_abs_frac)
793 max_abs_frac = std::abs(frac);
794 }
795 }
796 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
797 }
7c62b943
BK		 798
799// Test data for nu=2.0000000000000000.
2be75957 800testcase_cyl_bessel_i<double> data015[] = {
7c62b943
BK		 801 { 0.0000000000000000, 2.0000000000000000, 0.0000000000000000 },
802 { 17.505614966624233, 2.0000000000000000, 5.0000000000000000 },
803 { 2281.5189677260046, 2.0000000000000000, 10.000000000000000 },
2be75957 804 { 295899.38370188628, 2.0000000000000000, 15.000000000000000 },
7c62b943 805 { 39312785.221040756, 2.0000000000000000, 20.000000000000000 },
2be75957 806 { 5321931396.0760155, 2.0000000000000000, 25.000000000000000 },
7c62b943
BK		 807 { 730436828561.38013, 2.0000000000000000, 30.000000000000000 },
808 { 101293439862977.19, 2.0000000000000000, 35.000000000000000 },
2be75957 809 { 14159404985256922., 2.0000000000000000, 40.000000000000000 },
7c62b943
BK		 810 { 1.9918525879736883e+18, 2.0000000000000000, 45.000000000000000 },
811 { 2.8164306402451938e+20, 2.0000000000000000, 50.000000000000000 },
2be75957 812 { 3.9993023372677540e+22, 2.0000000000000000, 55.000000000000000 },
7c62b943
BK		 813 { 5.6992520026634433e+24, 2.0000000000000000, 60.000000000000000 },
814 { 8.1464814287900378e+26, 2.0000000000000000, 65.000000000000000 },
815 { 1.1675039556585663e+29, 2.0000000000000000, 70.000000000000000 },
816 { 1.6770093176278926e+31, 2.0000000000000000, 75.000000000000000 },
817 { 2.4136869148449879e+33, 2.0000000000000000, 80.000000000000000 },
818 { 3.4801257808448186e+35, 2.0000000000000000, 85.000000000000000 },
819 { 5.0256693051696307e+37, 2.0000000000000000, 90.000000000000000 },
2be75957 820 { 7.2678700343145818e+39, 2.0000000000000000, 95.000000000000000 },
7c62b943
BK		 821 { 1.0523843193243042e+42, 2.0000000000000000, 100.00000000000000 },
822};
823
824// Test function for nu=2.0000000000000000.
2be75957
ESR		 825template<typename Tp>
826 void
827 test015()
828 {
829 bool test [[gnu::unused]] = true;
830 const Tp eps = std::numeric_limits<Tp>::epsilon();
831 Tp max_abs_diff = -Tp(1);
832 Tp max_abs_frac = -Tp(1);
833 unsigned int num_datum = sizeof(data015)
834 / sizeof(testcase_cyl_bessel_i<double>);
835 for (unsigned int i = 0; i < num_datum; ++i)
836 {
837 const Tp f = std::tr1::cyl_bessel_i(Tp(data015[i].nu), Tp(data015[i].x));
838 const Tp f0 = data015[i].f0;
839 const Tp diff = f - f0;
840 if (std::abs(diff) > max_abs_diff)
841 max_abs_diff = std::abs(diff);
842 if (std::abs(f0) > Tp(10) * eps
843 && std::abs(f) > Tp(10) * eps)
844 {
845 const Tp frac = diff / f0;
846 if (std::abs(frac) > max_abs_frac)
847 max_abs_frac = std::abs(frac);
848 }
849 }
850 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
851 }
7c62b943
BK		 852
853// Test data for nu=5.0000000000000000.
2be75957 854testcase_cyl_bessel_i<double> data016[] = {
7c62b943
BK		 855 { 0.0000000000000000, 5.0000000000000000, 0.0000000000000000 },
856 { 2.1579745473225476, 5.0000000000000000, 5.0000000000000000 },
857 { 777.18828640326012, 5.0000000000000000, 10.000000000000000 },
2be75957 858 { 144572.01120063409, 5.0000000000000000, 15.000000000000000 },
7c62b943
BK		 859 { 23018392.213413671, 5.0000000000000000, 20.000000000000000 },
860 { 3472466208.7419176, 5.0000000000000000, 25.000000000000000 },
861 { 512151465476.93494, 5.0000000000000000, 30.000000000000000 },
2be75957
ESR		 862 { 74756743552251.547, 5.0000000000000000, 35.000000000000000 },
863 { 10858318337624280., 5.0000000000000000, 40.000000000000000 },
864 { 1.5736087399245911e+18, 5.0000000000000000, 45.000000000000000 },
865 { 2.2785483079112825e+20, 5.0000000000000000, 50.000000000000000 },
7c62b943 866 { 3.2989391052963687e+22, 5.0000000000000000, 55.000000000000000 },
2be75957
ESR		 867 { 4.7777652072561732e+24, 5.0000000000000000, 60.000000000000000 },
868 { 6.9232165147172657e+26, 5.0000000000000000, 65.000000000000000 },
869 { 1.0038643002095155e+29, 5.0000000000000000, 70.000000000000000 },
870 { 1.4566328222327073e+31, 5.0000000000000000, 75.000000000000000 },
871 { 2.1151488565944835e+33, 5.0000000000000000, 80.000000000000000 },
872 { 3.0735883450768239e+35, 5.0000000000000000, 85.000000000000000 },
7c62b943 873 { 4.4694790189230327e+37, 5.0000000000000000, 90.000000000000000 },
2be75957 874 { 6.5037505570430995e+39, 5.0000000000000000, 95.000000000000000 },
7c62b943
BK		 875 { 9.4700938730355882e+41, 5.0000000000000000, 100.00000000000000 },
876};
877
878// Test function for nu=5.0000000000000000.
2be75957
ESR		 879template<typename Tp>
880 void
881 test016()
882 {
883 bool test [[gnu::unused]] = true;
884 const Tp eps = std::numeric_limits<Tp>::epsilon();
885 Tp max_abs_diff = -Tp(1);
886 Tp max_abs_frac = -Tp(1);
887 unsigned int num_datum = sizeof(data016)
888 / sizeof(testcase_cyl_bessel_i<double>);
889 for (unsigned int i = 0; i < num_datum; ++i)
890 {
891 const Tp f = std::tr1::cyl_bessel_i(Tp(data016[i].nu), Tp(data016[i].x));
892 const Tp f0 = data016[i].f0;
893 const Tp diff = f - f0;
894 if (std::abs(diff) > max_abs_diff)
895 max_abs_diff = std::abs(diff);
896 if (std::abs(f0) > Tp(10) * eps
897 && std::abs(f) > Tp(10) * eps)
898 {
899 const Tp frac = diff / f0;
900 if (std::abs(frac) > max_abs_frac)
901 max_abs_frac = std::abs(frac);
902 }
903 }
904 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
905 }
7c62b943
BK		 906
907// Test data for nu=10.000000000000000.
2be75957 908testcase_cyl_bessel_i<double> data017[] = {
7c62b943
BK		 909 { 0.0000000000000000, 10.000000000000000, 0.0000000000000000 },
910 { 0.0045800444191760525, 10.000000000000000, 5.0000000000000000 },
911 { 21.891706163723381, 10.000000000000000, 10.000000000000000 },
912 { 12267.475049806462, 10.000000000000000, 15.000000000000000 },
913 { 3540200.2090195213, 10.000000000000000, 20.000000000000000 },
914 { 771298871.17072666, 10.000000000000000, 25.000000000000000 },
2be75957
ESR		 915 { 145831809975.96710, 10.000000000000000, 30.000000000000000 },
916 { 25449470018534.777, 10.000000000000000, 35.000000000000000 },
7c62b943 917 { 4228469210516757.5, 10.000000000000000, 40.000000000000000 },
2be75957 918 { 6.8049404557505165e+17, 10.000000000000000, 45.000000000000000 },
7c62b943
BK		 919 { 1.0715971594776370e+20, 10.000000000000000, 50.000000000000000 },
920 { 1.6618215752886714e+22, 10.000000000000000, 55.000000000000000 },
921 { 2.5486246072566784e+24, 10.000000000000000, 60.000000000000000 },
922 { 3.8764628702155481e+26, 10.000000000000000, 65.000000000000000 },
923 { 5.8592538145409686e+28, 10.000000000000000, 70.000000000000000 },
924 { 8.8135370711317444e+30, 10.000000000000000, 75.000000000000000 },
925 { 1.3207418268325279e+33, 10.000000000000000, 80.000000000000000 },
2be75957 926 { 1.9732791360862190e+35, 10.000000000000000, 85.000000000000000 },
7c62b943 927 { 2.9411893748384672e+37, 10.000000000000000, 90.000000000000000 },
2be75957 928 { 4.3754494922439984e+39, 10.000000000000000, 95.000000000000000 },
7c62b943
BK		 929 { 6.4989755247201446e+41, 10.000000000000000, 100.00000000000000 },
930};
931
932// Test function for nu=10.000000000000000.
2be75957
ESR		 933template<typename Tp>
934 void
935 test017()
936 {
937 bool test [[gnu::unused]] = true;
938 const Tp eps = std::numeric_limits<Tp>::epsilon();
939 Tp max_abs_diff = -Tp(1);
940 Tp max_abs_frac = -Tp(1);
941 unsigned int num_datum = sizeof(data017)
942 / sizeof(testcase_cyl_bessel_i<double>);
943 for (unsigned int i = 0; i < num_datum; ++i)
944 {
945 const Tp f = std::tr1::cyl_bessel_i(Tp(data017[i].nu), Tp(data017[i].x));
946 const Tp f0 = data017[i].f0;
947 const Tp diff = f - f0;
948 if (std::abs(diff) > max_abs_diff)
949 max_abs_diff = std::abs(diff);
950 if (std::abs(f0) > Tp(10) * eps
951 && std::abs(f) > Tp(10) * eps)
952 {
953 const Tp frac = diff / f0;
954 if (std::abs(frac) > max_abs_frac)
955 max_abs_frac = std::abs(frac);
956 }
957 }
958 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
959 }
7c62b943
BK		 960
961// Test data for nu=20.000000000000000.
2be75957 962testcase_cyl_bessel_i<double> data018[] = {
7c62b943
BK		 963 { 0.0000000000000000, 20.000000000000000, 0.0000000000000000 },
964 { 5.0242393579718066e-11, 20.000000000000000, 5.0000000000000000 },
965 { 0.00012507997356449481, 20.000000000000000, 10.000000000000000 },
2be75957 966 { 1.6470152535015836, 20.000000000000000, 15.000000000000000 },
7c62b943
BK		 967 { 3188.7503288536154, 20.000000000000000, 20.000000000000000 },
968 { 2449840.5422952301, 20.000000000000000, 25.000000000000000 },
969 { 1126985104.4483771, 20.000000000000000, 30.000000000000000 },
2be75957 970 { 379617876611.88580, 20.000000000000000, 35.000000000000000 },
7c62b943 971 { 104459633129479.89, 20.000000000000000, 40.000000000000000 },
2be75957
ESR		 972 { 25039579987216524., 20.000000000000000, 45.000000000000000 },
973 { 5.4420084027529984e+18, 20.000000000000000, 50.000000000000000 },
974 { 1.1007498584335495e+21, 20.000000000000000, 55.000000000000000 },
7c62b943
BK		 975 { 2.1091734863057236e+23, 20.000000000000000, 60.000000000000000 },
976 { 3.8763618091286899e+25, 20.000000000000000, 65.000000000000000 },
2be75957 977 { 6.8946130527930870e+27, 20.000000000000000, 70.000000000000000 },
7c62b943 978 { 1.1946319948836447e+30, 20.000000000000000, 75.000000000000000 },
2be75957
ESR		 979 { 2.0265314377577587e+32, 20.000000000000000, 80.000000000000000 },
980 { 3.3784665214179985e+34, 20.000000000000000, 85.000000000000000 },
981 { 5.5516089411796646e+36, 20.000000000000000, 90.000000000000000 },
7c62b943
BK		 982 { 9.0129310795305151e+38, 20.000000000000000, 95.000000000000000 },
983 { 1.4483461256427176e+41, 20.000000000000000, 100.00000000000000 },
984};
985
986// Test function for nu=20.000000000000000.
2be75957
ESR		 987template<typename Tp>
988 void
989 test018()
990 {
991 bool test [[gnu::unused]] = true;
992 const Tp eps = std::numeric_limits<Tp>::epsilon();
993 Tp max_abs_diff = -Tp(1);
994 Tp max_abs_frac = -Tp(1);
995 unsigned int num_datum = sizeof(data018)
996 / sizeof(testcase_cyl_bessel_i<double>);
997 for (unsigned int i = 0; i < num_datum; ++i)
998 {
999 const Tp f = std::tr1::cyl_bessel_i(Tp(data018[i].nu), Tp(data018[i].x));
1000 const Tp f0 = data018[i].f0;
1001 const Tp diff = f - f0;
1002 if (std::abs(diff) > max_abs_diff)
1003 max_abs_diff = std::abs(diff);
1004 if (std::abs(f0) > Tp(10) * eps
1005 && std::abs(f) > Tp(10) * eps)
1006 {
1007 const Tp frac = diff / f0;
1008 if (std::abs(frac) > max_abs_frac)
1009 max_abs_frac = std::abs(frac);
1010 }
1011 }
1012 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1013 }
7c62b943
BK		 1014
1015// Test data for nu=50.000000000000000.
2be75957 1016testcase_cyl_bessel_i<double> data019[] = {
7c62b943
BK		 1017 { 0.0000000000000000, 50.000000000000000, 0.0000000000000000 },
1018 { 2.9314696468108517e-45, 50.000000000000000, 5.0000000000000000 },
1019 { 4.7568945607268442e-30, 50.000000000000000, 10.000000000000000 },
1020 { 5.5468372730667069e-21, 50.000000000000000, 15.000000000000000 },
1021 { 2.2551205757604056e-14, 50.000000000000000, 20.000000000000000 },
2be75957
ESR		 1022 { 4.5344251866130257e-09, 50.000000000000000, 25.000000000000000 },
1023 { 0.00014590106916468940, 50.000000000000000, 30.000000000000000 },
1024 { 1.3965549457254882, 50.000000000000000, 35.000000000000000 },
1025 { 5726.8656631289896, 50.000000000000000, 40.000000000000000 },
1026 { 12672593.113027781, 50.000000000000000, 45.000000000000000 },
1027 { 17650802430.016712, 50.000000000000000, 50.000000000000000 },
7c62b943 1028 { 17220231607789.926, 50.000000000000000, 55.000000000000000 },
2be75957
ESR		 1029 { 12704607933652176., 50.000000000000000, 60.000000000000000 },
1030 { 7.4989491942193725e+18, 50.000000000000000, 65.000000000000000 },
1031 { 3.6944034898904922e+21, 50.000000000000000, 70.000000000000000 },
1032 { 1.5691634774370186e+24, 50.000000000000000, 75.000000000000000 },
7c62b943
BK		 1033 { 5.8927749458163587e+26, 50.000000000000000, 80.000000000000000 },
1034 { 1.9958849054749339e+29, 50.000000000000000, 85.000000000000000 },
2be75957
ESR		 1035 { 6.1946050361781500e+31, 50.000000000000000, 90.000000000000000 },
1036 { 1.7845429728697119e+34, 50.000000000000000, 95.000000000000000 },
1037 { 4.8219580855940819e+36, 50.000000000000000, 100.00000000000000 },
7c62b943
BK		 1038};
1039
1040// Test function for nu=50.000000000000000.
2be75957
ESR		 1041template<typename Tp>
1042 void
1043 test019()
1044 {
1045 bool test [[gnu::unused]] = true;
1046 const Tp eps = std::numeric_limits<Tp>::epsilon();
1047 Tp max_abs_diff = -Tp(1);
1048 Tp max_abs_frac = -Tp(1);
1049 unsigned int num_datum = sizeof(data019)
1050 / sizeof(testcase_cyl_bessel_i<double>);
1051 for (unsigned int i = 0; i < num_datum; ++i)
1052 {
1053 const Tp f = std::tr1::cyl_bessel_i(Tp(data019[i].nu), Tp(data019[i].x));
1054 const Tp f0 = data019[i].f0;
1055 const Tp diff = f - f0;
1056 if (std::abs(diff) > max_abs_diff)
1057 max_abs_diff = std::abs(diff);
1058 if (std::abs(f0) > Tp(10) * eps
1059 && std::abs(f) > Tp(10) * eps)
1060 {
1061 const Tp frac = diff / f0;
1062 if (std::abs(frac) > max_abs_frac)
1063 max_abs_frac = std::abs(frac);
1064 }
1065 }
1066 VERIFY(max_abs_frac < Tp(5.0000000000000029e-12));
1067 }
7c62b943
BK		 1068
1069// Test data for nu=100.00000000000000.
2be75957 1070testcase_cyl_bessel_i<double> data020[] = {
7c62b943
BK		 1071 { 0.0000000000000000, 100.00000000000000, 0.0000000000000000 },
1072 { 7.0935514885313123e-119, 100.00000000000000, 5.0000000000000000 },
1073 { 1.0823442017492018e-88, 100.00000000000000, 10.000000000000000 },
1074 { 5.9887888536468904e-71, 100.00000000000000, 15.000000000000000 },
1075 { 2.8703193216428771e-58, 100.00000000000000, 20.000000000000000 },
1076 { 2.4426896913122370e-48, 100.00000000000000, 25.000000000000000 },
1077 { 3.9476420053334271e-40, 100.00000000000000, 30.000000000000000 },
2be75957 1078 { 4.2836596180818780e-33, 100.00000000000000, 35.000000000000000 },
7c62b943 1079 { 6.6249380222596129e-27, 100.00000000000000, 40.000000000000000 },
2be75957
ESR		 1080 { 2.3702587262788900e-21, 100.00000000000000, 45.000000000000000 },
1081 { 2.7278879470966917e-16, 100.00000000000000, 50.000000000000000 },
1082 { 1.2763258878228082e-11, 100.00000000000000, 55.000000000000000 },
1083 { 2.8832770906491972e-07, 100.00000000000000, 60.000000000000000 },
1084 { 0.0035805902717061227, 100.00000000000000, 65.000000000000000 },
1085 { 27.017219102595387, 100.00000000000000, 70.000000000000000 },
7c62b943 1086 { 134001.44891209516, 100.00000000000000, 75.000000000000000 },
2be75957
ESR		 1087 { 465194832.85060996, 100.00000000000000, 80.000000000000000 },
1088 { 1189280653119.4814, 100.00000000000000, 85.000000000000000 },
1089 { 2334119331258728.0, 100.00000000000000, 90.000000000000000 },
1090 { 3.6399223078502436e+18, 100.00000000000000, 95.000000000000000 },
1091 { 4.6415349416162005e+21, 100.00000000000000, 100.00000000000000 },
7c62b943
BK		 1092};
1093
1094// Test function for nu=100.00000000000000.
2be75957
ESR		 1095template<typename Tp>
1096 void
1097 test020()
1098 {
1099 bool test [[gnu::unused]] = true;
1100 const Tp eps = std::numeric_limits<Tp>::epsilon();
1101 Tp max_abs_diff = -Tp(1);
1102 Tp max_abs_frac = -Tp(1);
1103 unsigned int num_datum = sizeof(data020)
1104 / sizeof(testcase_cyl_bessel_i<double>);
1105 for (unsigned int i = 0; i < num_datum; ++i)
1106 {
1107 const Tp f = std::tr1::cyl_bessel_i(Tp(data020[i].nu), Tp(data020[i].x));
1108 const Tp f0 = data020[i].f0;
1109 const Tp diff = f - f0;
1110 if (std::abs(diff) > max_abs_diff)
1111 max_abs_diff = std::abs(diff);
1112 if (std::abs(f0) > Tp(10) * eps
1113 && std::abs(f) > Tp(10) * eps)
1114 {
1115 const Tp frac = diff / f0;
1116 if (std::abs(frac) > max_abs_frac)
1117 max_abs_frac = std::abs(frac);
1118 }
1119 }
1120 VERIFY(max_abs_frac < Tp(2.5000000000000014e-11));
1121 }
7c62b943 1122
2be75957
ESR		 1123int
1124main()
7c62b943
BK		 1125{
1126 test001<double>();
1127 test002<double>();
1128 test003<double>();
1129 test004<double>();
1130 test005<double>();
1131 test006<double>();
1132 test007<double>();
1133 test008<double>();
1134 test009<double>();
1135 test010<double>();
1136 test011<double>();
2be75957
ESR		 1137 test012<double>();
1138 test013<double>();
1139 test014<double>();
1140 test015<double>();
1141 test016<double>();
1142 test017<double>();
1143 test018<double>();
1144 test019<double>();
1145 test020<double>();
7c62b943
BK		 1146 return 0;
1147}
Mirror of https://gcc.gnu.org/git/gcc.git