]> git.ipfire.org Git - thirdparty/gcc.git/blame - libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/01_assoc_laguerre/check_value.cc
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update copyright years in libstdc++-v3/
[thirdparty/gcc.git] / libstdc++-v3 / testsuite / tr1 / 5_numerical_facilities / special_functions / 01_assoc_laguerre / check_value.cc
CommitLineData
7c62b943
BK		 1// 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net>
2//
aa118a03 3// Copyright (C) 2007-2014 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// assoc_laguerre
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 n=0, m=0.
43testcase_assoc_laguerre<double> data001[] = {
44 { 1.0000000000000000, 0, 0,
45 0.0000000000000000 },
46 { 1.0000000000000000, 0, 0,
47 10.000000000000000 },
48 { 1.0000000000000000, 0, 0,
49 20.000000000000000 },
50 { 1.0000000000000000, 0, 0,
51 30.000000000000000 },
52 { 1.0000000000000000, 0, 0,
53 40.000000000000000 },
54 { 1.0000000000000000, 0, 0,
55 50.000000000000000 },
56 { 1.0000000000000000, 0, 0,
57 60.000000000000000 },
58 { 1.0000000000000000, 0, 0,
59 70.000000000000000 },
60 { 1.0000000000000000, 0, 0,
61 80.000000000000000 },
62 { 1.0000000000000000, 0, 0,
63 90.000000000000000 },
64 { 1.0000000000000000, 0, 0,
65 100.00000000000000 },
66};
67
68// Test function for n=0, m=0.
69template <typename Tp>
70void test001()
71{
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_assoc_laguerre<double>);
77 for (unsigned int i = 0; i < num_datum; ++i)
78 {
79 const Tp f = std::tr1::assoc_laguerre(Tp(data001[i].n), Tp(data001[i].m),
80 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 n=0, m=1.
97testcase_assoc_laguerre<double> data002[] = {
98 { 1.0000000000000000, 0, 1,
99 0.0000000000000000 },
100 { 1.0000000000000000, 0, 1,
101 10.000000000000000 },
102 { 1.0000000000000000, 0, 1,
103 20.000000000000000 },
104 { 1.0000000000000000, 0, 1,
105 30.000000000000000 },
106 { 1.0000000000000000, 0, 1,
107 40.000000000000000 },
108 { 1.0000000000000000, 0, 1,
109 50.000000000000000 },
110 { 1.0000000000000000, 0, 1,
111 60.000000000000000 },
112 { 1.0000000000000000, 0, 1,
113 70.000000000000000 },
114 { 1.0000000000000000, 0, 1,
115 80.000000000000000 },
116 { 1.0000000000000000, 0, 1,
117 90.000000000000000 },
118 { 1.0000000000000000, 0, 1,
119 100.00000000000000 },
120};
121
122// Test function for n=0, m=1.
123template <typename Tp>
124void test002()
125{
126 const Tp eps = std::numeric_limits<Tp>::epsilon();
127 Tp max_abs_diff = -Tp(1);
128 Tp max_abs_frac = -Tp(1);
129 unsigned int num_datum = sizeof(data002)
130 / sizeof(testcase_assoc_laguerre<double>);
131 for (unsigned int i = 0; i < num_datum; ++i)
132 {
133 const Tp f = std::tr1::assoc_laguerre(Tp(data002[i].n), Tp(data002[i].m),
134 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 n=0, m=2.
151testcase_assoc_laguerre<double> data003[] = {
152 { 1.0000000000000000, 0, 2,
153 0.0000000000000000 },
154 { 1.0000000000000000, 0, 2,
155 10.000000000000000 },
156 { 1.0000000000000000, 0, 2,
157 20.000000000000000 },
158 { 1.0000000000000000, 0, 2,
159 30.000000000000000 },
160 { 1.0000000000000000, 0, 2,
161 40.000000000000000 },
162 { 1.0000000000000000, 0, 2,
163 50.000000000000000 },
164 { 1.0000000000000000, 0, 2,
165 60.000000000000000 },
166 { 1.0000000000000000, 0, 2,
167 70.000000000000000 },
168 { 1.0000000000000000, 0, 2,
169 80.000000000000000 },
170 { 1.0000000000000000, 0, 2,
171 90.000000000000000 },
172 { 1.0000000000000000, 0, 2,
173 100.00000000000000 },
174};
175
176// Test function for n=0, m=2.
177template <typename Tp>
178void test003()
179{
180 const Tp eps = std::numeric_limits<Tp>::epsilon();
181 Tp max_abs_diff = -Tp(1);
182 Tp max_abs_frac = -Tp(1);
183 unsigned int num_datum = sizeof(data003)
184 / sizeof(testcase_assoc_laguerre<double>);
185 for (unsigned int i = 0; i < num_datum; ++i)
186 {
187 const Tp f = std::tr1::assoc_laguerre(Tp(data003[i].n), Tp(data003[i].m),
188 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 n=0, m=5.
205testcase_assoc_laguerre<double> data004[] = {
206 { 1.0000000000000000, 0, 5,
207 0.0000000000000000 },
208 { 1.0000000000000000, 0, 5,
209 10.000000000000000 },
210 { 1.0000000000000000, 0, 5,
211 20.000000000000000 },
212 { 1.0000000000000000, 0, 5,
213 30.000000000000000 },
214 { 1.0000000000000000, 0, 5,
215 40.000000000000000 },
216 { 1.0000000000000000, 0, 5,
217 50.000000000000000 },
218 { 1.0000000000000000, 0, 5,
219 60.000000000000000 },
220 { 1.0000000000000000, 0, 5,
221 70.000000000000000 },
222 { 1.0000000000000000, 0, 5,
223 80.000000000000000 },
224 { 1.0000000000000000, 0, 5,
225 90.000000000000000 },
226 { 1.0000000000000000, 0, 5,
227 100.00000000000000 },
228};
229
230// Test function for n=0, m=5.
231template <typename Tp>
232void test004()
233{
234 const Tp eps = std::numeric_limits<Tp>::epsilon();
235 Tp max_abs_diff = -Tp(1);
236 Tp max_abs_frac = -Tp(1);
237 unsigned int num_datum = sizeof(data004)
238 / sizeof(testcase_assoc_laguerre<double>);
239 for (unsigned int i = 0; i < num_datum; ++i)
240 {
241 const Tp f = std::tr1::assoc_laguerre(Tp(data004[i].n), Tp(data004[i].m),
242 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 n=0, m=10.
259testcase_assoc_laguerre<double> data005[] = {
260 { 1.0000000000000000, 0, 10,
261 0.0000000000000000 },
262 { 1.0000000000000000, 0, 10,
263 10.000000000000000 },
264 { 1.0000000000000000, 0, 10,
265 20.000000000000000 },
266 { 1.0000000000000000, 0, 10,
267 30.000000000000000 },
268 { 1.0000000000000000, 0, 10,
269 40.000000000000000 },
270 { 1.0000000000000000, 0, 10,
271 50.000000000000000 },
272 { 1.0000000000000000, 0, 10,
273 60.000000000000000 },
274 { 1.0000000000000000, 0, 10,
275 70.000000000000000 },
276 { 1.0000000000000000, 0, 10,
277 80.000000000000000 },
278 { 1.0000000000000000, 0, 10,
279 90.000000000000000 },
280 { 1.0000000000000000, 0, 10,
281 100.00000000000000 },
282};
283
284// Test function for n=0, m=10.
285template <typename Tp>
286void test005()
287{
288 const Tp eps = std::numeric_limits<Tp>::epsilon();
289 Tp max_abs_diff = -Tp(1);
290 Tp max_abs_frac = -Tp(1);
291 unsigned int num_datum = sizeof(data005)
292 / sizeof(testcase_assoc_laguerre<double>);
293 for (unsigned int i = 0; i < num_datum; ++i)
294 {
295 const Tp f = std::tr1::assoc_laguerre(Tp(data005[i].n), Tp(data005[i].m),
296 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 n=0, m=20.
313testcase_assoc_laguerre<double> data006[] = {
314 { 1.0000000000000000, 0, 20,
315 0.0000000000000000 },
316 { 1.0000000000000000, 0, 20,
317 10.000000000000000 },
318 { 1.0000000000000000, 0, 20,
319 20.000000000000000 },
320 { 1.0000000000000000, 0, 20,
321 30.000000000000000 },
322 { 1.0000000000000000, 0, 20,
323 40.000000000000000 },
324 { 1.0000000000000000, 0, 20,
325 50.000000000000000 },
326 { 1.0000000000000000, 0, 20,
327 60.000000000000000 },
328 { 1.0000000000000000, 0, 20,
329 70.000000000000000 },
330 { 1.0000000000000000, 0, 20,
331 80.000000000000000 },
332 { 1.0000000000000000, 0, 20,
333 90.000000000000000 },
334 { 1.0000000000000000, 0, 20,
335 100.00000000000000 },
336};
337
338// Test function for n=0, m=20.
339template <typename Tp>
340void test006()
341{
342 const Tp eps = std::numeric_limits<Tp>::epsilon();
343 Tp max_abs_diff = -Tp(1);
344 Tp max_abs_frac = -Tp(1);
345 unsigned int num_datum = sizeof(data006)
346 / sizeof(testcase_assoc_laguerre<double>);
347 for (unsigned int i = 0; i < num_datum; ++i)
348 {
349 const Tp f = std::tr1::assoc_laguerre(Tp(data006[i].n), Tp(data006[i].m),
350 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 n=0, m=50.
367testcase_assoc_laguerre<double> data007[] = {
368 { 1.0000000000000000, 0, 50,
369 0.0000000000000000 },
370 { 1.0000000000000000, 0, 50,
371 10.000000000000000 },
372 { 1.0000000000000000, 0, 50,
373 20.000000000000000 },
374 { 1.0000000000000000, 0, 50,
375 30.000000000000000 },
376 { 1.0000000000000000, 0, 50,
377 40.000000000000000 },
378 { 1.0000000000000000, 0, 50,
379 50.000000000000000 },
380 { 1.0000000000000000, 0, 50,
381 60.000000000000000 },
382 { 1.0000000000000000, 0, 50,
383 70.000000000000000 },
384 { 1.0000000000000000, 0, 50,
385 80.000000000000000 },
386 { 1.0000000000000000, 0, 50,
387 90.000000000000000 },
388 { 1.0000000000000000, 0, 50,
389 100.00000000000000 },
390};
391
392// Test function for n=0, m=50.
393template <typename Tp>
394void test007()
395{
396 const Tp eps = std::numeric_limits<Tp>::epsilon();
397 Tp max_abs_diff = -Tp(1);
398 Tp max_abs_frac = -Tp(1);
399 unsigned int num_datum = sizeof(data007)
400 / sizeof(testcase_assoc_laguerre<double>);
401 for (unsigned int i = 0; i < num_datum; ++i)
402 {
403 const Tp f = std::tr1::assoc_laguerre(Tp(data007[i].n), Tp(data007[i].m),
404 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 n=0, m=100.
421testcase_assoc_laguerre<double> data008[] = {
422 { 1.0000000000000000, 0, 100,
423 0.0000000000000000 },
424 { 1.0000000000000000, 0, 100,
425 10.000000000000000 },
426 { 1.0000000000000000, 0, 100,
427 20.000000000000000 },
428 { 1.0000000000000000, 0, 100,
429 30.000000000000000 },
430 { 1.0000000000000000, 0, 100,
431 40.000000000000000 },
432 { 1.0000000000000000, 0, 100,
433 50.000000000000000 },
434 { 1.0000000000000000, 0, 100,
435 60.000000000000000 },
436 { 1.0000000000000000, 0, 100,
437 70.000000000000000 },
438 { 1.0000000000000000, 0, 100,
439 80.000000000000000 },
440 { 1.0000000000000000, 0, 100,
441 90.000000000000000 },
442 { 1.0000000000000000, 0, 100,
443 100.00000000000000 },
444};
445
446// Test function for n=0, m=100.
447template <typename Tp>
448void test008()
449{
450 const Tp eps = std::numeric_limits<Tp>::epsilon();
451 Tp max_abs_diff = -Tp(1);
452 Tp max_abs_frac = -Tp(1);
453 unsigned int num_datum = sizeof(data008)
454 / sizeof(testcase_assoc_laguerre<double>);
455 for (unsigned int i = 0; i < num_datum; ++i)
456 {
457 const Tp f = std::tr1::assoc_laguerre(Tp(data008[i].n), Tp(data008[i].m),
458 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 n=1, m=0.
475testcase_assoc_laguerre<double> data009[] = {
476 { 1.0000000000000000, 1, 0,
477 0.0000000000000000 },
478 { -9.0000000000000000, 1, 0,
479 10.000000000000000 },
480 { -19.000000000000000, 1, 0,
481 20.000000000000000 },
482 { -29.000000000000000, 1, 0,
483 30.000000000000000 },
484 { -39.000000000000000, 1, 0,
485 40.000000000000000 },
486 { -49.000000000000000, 1, 0,
487 50.000000000000000 },
488 { -59.000000000000000, 1, 0,
489 60.000000000000000 },
490 { -69.000000000000000, 1, 0,
491 70.000000000000000 },
492 { -79.000000000000000, 1, 0,
493 80.000000000000000 },
494 { -89.000000000000000, 1, 0,
495 90.000000000000000 },
496 { -99.000000000000000, 1, 0,
497 100.00000000000000 },
498};
499
500// Test function for n=1, m=0.
501template <typename Tp>
502void test009()
503{
504 const Tp eps = std::numeric_limits<Tp>::epsilon();
505 Tp max_abs_diff = -Tp(1);
506 Tp max_abs_frac = -Tp(1);
507 unsigned int num_datum = sizeof(data009)
508 / sizeof(testcase_assoc_laguerre<double>);
509 for (unsigned int i = 0; i < num_datum; ++i)
510 {
511 const Tp f = std::tr1::assoc_laguerre(Tp(data009[i].n), Tp(data009[i].m),
512 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
528// Test data for n=1, m=1.
529testcase_assoc_laguerre<double> data010[] = {
530 { 2.0000000000000000, 1, 1,
531 0.0000000000000000 },
532 { -8.0000000000000000, 1, 1,
533 10.000000000000000 },
534 { -18.000000000000000, 1, 1,
535 20.000000000000000 },
536 { -28.000000000000000, 1, 1,
537 30.000000000000000 },
538 { -38.000000000000000, 1, 1,
539 40.000000000000000 },
540 { -48.000000000000000, 1, 1,
541 50.000000000000000 },
542 { -58.000000000000000, 1, 1,
543 60.000000000000000 },
544 { -68.000000000000000, 1, 1,
545 70.000000000000000 },
546 { -78.000000000000000, 1, 1,
547 80.000000000000000 },
548 { -88.000000000000000, 1, 1,
549 90.000000000000000 },
550 { -98.000000000000000, 1, 1,
551 100.00000000000000 },
552};
553
554// Test function for n=1, m=1.
555template <typename Tp>
556void test010()
557{
558 const Tp eps = std::numeric_limits<Tp>::epsilon();
559 Tp max_abs_diff = -Tp(1);
560 Tp max_abs_frac = -Tp(1);
561 unsigned int num_datum = sizeof(data010)
562 / sizeof(testcase_assoc_laguerre<double>);
563 for (unsigned int i = 0; i < num_datum; ++i)
564 {
565 const Tp f = std::tr1::assoc_laguerre(Tp(data010[i].n), Tp(data010[i].m),
566 Tp(data010[i].x));
567 const Tp f0 = data010[i].f0;
568 const Tp diff = f - f0;
569 if (std::abs(diff) > max_abs_diff)
570 max_abs_diff = std::abs(diff);
571 if (std::abs(f0) > Tp(10) * eps
572 && std::abs(f) > Tp(10) * eps)
573 {
574 const Tp frac = diff / f0;
575 if (std::abs(frac) > max_abs_frac)
576 max_abs_frac = std::abs(frac);
577 }
578 }
579 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
580}
581
582// Test data for n=1, m=2.
583testcase_assoc_laguerre<double> data011[] = {
584 { 3.0000000000000000, 1, 2,
585 0.0000000000000000 },
586 { -7.0000000000000000, 1, 2,
587 10.000000000000000 },
588 { -17.000000000000000, 1, 2,
589 20.000000000000000 },
590 { -27.000000000000000, 1, 2,
591 30.000000000000000 },
592 { -37.000000000000000, 1, 2,
593 40.000000000000000 },
594 { -47.000000000000000, 1, 2,
595 50.000000000000000 },
596 { -57.000000000000000, 1, 2,
597 60.000000000000000 },
598 { -67.000000000000000, 1, 2,
599 70.000000000000000 },
600 { -77.000000000000000, 1, 2,
601 80.000000000000000 },
602 { -87.000000000000000, 1, 2,
603 90.000000000000000 },
604 { -97.000000000000000, 1, 2,
605 100.00000000000000 },
606};
607
608// Test function for n=1, m=2.
609template <typename Tp>
610void test011()
611{
612 const Tp eps = std::numeric_limits<Tp>::epsilon();
613 Tp max_abs_diff = -Tp(1);
614 Tp max_abs_frac = -Tp(1);
615 unsigned int num_datum = sizeof(data011)
616 / sizeof(testcase_assoc_laguerre<double>);
617 for (unsigned int i = 0; i < num_datum; ++i)
618 {
619 const Tp f = std::tr1::assoc_laguerre(Tp(data011[i].n), Tp(data011[i].m),
620 Tp(data011[i].x));
621 const Tp f0 = data011[i].f0;
622 const Tp diff = f - f0;
623 if (std::abs(diff) > max_abs_diff)
624 max_abs_diff = std::abs(diff);
625 if (std::abs(f0) > Tp(10) * eps
626 && std::abs(f) > Tp(10) * eps)
627 {
628 const Tp frac = diff / f0;
629 if (std::abs(frac) > max_abs_frac)
630 max_abs_frac = std::abs(frac);
631 }
632 }
633 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
634}
635
636// Test data for n=1, m=5.
637testcase_assoc_laguerre<double> data012[] = {
638 { 6.0000000000000000, 1, 5,
639 0.0000000000000000 },
640 { -4.0000000000000000, 1, 5,
641 10.000000000000000 },
642 { -14.000000000000000, 1, 5,
643 20.000000000000000 },
644 { -24.000000000000000, 1, 5,
645 30.000000000000000 },
646 { -34.000000000000000, 1, 5,
647 40.000000000000000 },
648 { -44.000000000000000, 1, 5,
649 50.000000000000000 },
650 { -54.000000000000000, 1, 5,
651 60.000000000000000 },
652 { -64.000000000000000, 1, 5,
653 70.000000000000000 },
654 { -74.000000000000000, 1, 5,
655 80.000000000000000 },
656 { -84.000000000000000, 1, 5,
657 90.000000000000000 },
658 { -94.000000000000000, 1, 5,
659 100.00000000000000 },
660};
661
662// Test function for n=1, m=5.
663template <typename Tp>
664void test012()
665{
666 const Tp eps = std::numeric_limits<Tp>::epsilon();
667 Tp max_abs_diff = -Tp(1);
668 Tp max_abs_frac = -Tp(1);
669 unsigned int num_datum = sizeof(data012)
670 / sizeof(testcase_assoc_laguerre<double>);
671 for (unsigned int i = 0; i < num_datum; ++i)
672 {
673 const Tp f = std::tr1::assoc_laguerre(Tp(data012[i].n), Tp(data012[i].m),
674 Tp(data012[i].x));
675 const Tp f0 = data012[i].f0;
676 const Tp diff = f - f0;
677 if (std::abs(diff) > max_abs_diff)
678 max_abs_diff = std::abs(diff);
679 if (std::abs(f0) > Tp(10) * eps
680 && std::abs(f) > Tp(10) * eps)
681 {
682 const Tp frac = diff / f0;
683 if (std::abs(frac) > max_abs_frac)
684 max_abs_frac = std::abs(frac);
685 }
686 }
687 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
688}
689
690// Test data for n=1, m=10.
691testcase_assoc_laguerre<double> data013[] = {
692 { 11.000000000000000, 1, 10,
693 0.0000000000000000 },
694 { 1.0000000000000000, 1, 10,
695 10.000000000000000 },
696 { -9.0000000000000000, 1, 10,
697 20.000000000000000 },
698 { -19.000000000000000, 1, 10,
699 30.000000000000000 },
700 { -29.000000000000000, 1, 10,
701 40.000000000000000 },
702 { -39.000000000000000, 1, 10,
703 50.000000000000000 },
704 { -49.000000000000000, 1, 10,
705 60.000000000000000 },
706 { -59.000000000000000, 1, 10,
707 70.000000000000000 },
708 { -69.000000000000000, 1, 10,
709 80.000000000000000 },
710 { -79.000000000000000, 1, 10,
711 90.000000000000000 },
712 { -89.000000000000000, 1, 10,
713 100.00000000000000 },
714};
715
716// Test function for n=1, m=10.
717template <typename Tp>
718void test013()
719{
720 const Tp eps = std::numeric_limits<Tp>::epsilon();
721 Tp max_abs_diff = -Tp(1);
722 Tp max_abs_frac = -Tp(1);
723 unsigned int num_datum = sizeof(data013)
724 / sizeof(testcase_assoc_laguerre<double>);
725 for (unsigned int i = 0; i < num_datum; ++i)
726 {
727 const Tp f = std::tr1::assoc_laguerre(Tp(data013[i].n), Tp(data013[i].m),
728 Tp(data013[i].x));
729 const Tp f0 = data013[i].f0;
730 const Tp diff = f - f0;
731 if (std::abs(diff) > max_abs_diff)
732 max_abs_diff = std::abs(diff);
733 if (std::abs(f0) > Tp(10) * eps
734 && std::abs(f) > Tp(10) * eps)
735 {
736 const Tp frac = diff / f0;
737 if (std::abs(frac) > max_abs_frac)
738 max_abs_frac = std::abs(frac);
739 }
740 }
741 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
742}
743
744// Test data for n=1, m=20.
745testcase_assoc_laguerre<double> data014[] = {
746 { 21.000000000000000, 1, 20,
747 0.0000000000000000 },
748 { 11.000000000000000, 1, 20,
749 10.000000000000000 },
750 { 1.0000000000000000, 1, 20,
751 20.000000000000000 },
752 { -9.0000000000000000, 1, 20,
753 30.000000000000000 },
754 { -19.000000000000000, 1, 20,
755 40.000000000000000 },
756 { -29.000000000000000, 1, 20,
757 50.000000000000000 },
758 { -39.000000000000000, 1, 20,
759 60.000000000000000 },
760 { -49.000000000000000, 1, 20,
761 70.000000000000000 },
762 { -59.000000000000000, 1, 20,
763 80.000000000000000 },
764 { -69.000000000000000, 1, 20,
765 90.000000000000000 },
766 { -79.000000000000000, 1, 20,
767 100.00000000000000 },
768};
769
770// Test function for n=1, m=20.
771template <typename Tp>
772void test014()
773{
774 const Tp eps = std::numeric_limits<Tp>::epsilon();
775 Tp max_abs_diff = -Tp(1);
776 Tp max_abs_frac = -Tp(1);
777 unsigned int num_datum = sizeof(data014)
778 / sizeof(testcase_assoc_laguerre<double>);
779 for (unsigned int i = 0; i < num_datum; ++i)
780 {
781 const Tp f = std::tr1::assoc_laguerre(Tp(data014[i].n), Tp(data014[i].m),
782 Tp(data014[i].x));
783 const Tp f0 = data014[i].f0;
784 const Tp diff = f - f0;
785 if (std::abs(diff) > max_abs_diff)
786 max_abs_diff = std::abs(diff);
787 if (std::abs(f0) > Tp(10) * eps
788 && std::abs(f) > Tp(10) * eps)
789 {
790 const Tp frac = diff / f0;
791 if (std::abs(frac) > max_abs_frac)
792 max_abs_frac = std::abs(frac);
793 }
794 }
795 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
796}
797
798// Test data for n=1, m=50.
799testcase_assoc_laguerre<double> data015[] = {
800 { 51.000000000000000, 1, 50,
801 0.0000000000000000 },
802 { 41.000000000000000, 1, 50,
803 10.000000000000000 },
804 { 31.000000000000000, 1, 50,
805 20.000000000000000 },
806 { 21.000000000000000, 1, 50,
807 30.000000000000000 },
808 { 11.000000000000000, 1, 50,
809 40.000000000000000 },
810 { 1.0000000000000000, 1, 50,
811 50.000000000000000 },
812 { -9.0000000000000000, 1, 50,
813 60.000000000000000 },
814 { -19.000000000000000, 1, 50,
815 70.000000000000000 },
816 { -29.000000000000000, 1, 50,
817 80.000000000000000 },
818 { -39.000000000000000, 1, 50,
819 90.000000000000000 },
820 { -49.000000000000000, 1, 50,
821 100.00000000000000 },
822};
823
824// Test function for n=1, m=50.
825template <typename Tp>
826void test015()
827{
828 const Tp eps = std::numeric_limits<Tp>::epsilon();
829 Tp max_abs_diff = -Tp(1);
830 Tp max_abs_frac = -Tp(1);
831 unsigned int num_datum = sizeof(data015)
832 / sizeof(testcase_assoc_laguerre<double>);
833 for (unsigned int i = 0; i < num_datum; ++i)
834 {
835 const Tp f = std::tr1::assoc_laguerre(Tp(data015[i].n), Tp(data015[i].m),
836 Tp(data015[i].x));
837 const Tp f0 = data015[i].f0;
838 const Tp diff = f - f0;
839 if (std::abs(diff) > max_abs_diff)
840 max_abs_diff = std::abs(diff);
841 if (std::abs(f0) > Tp(10) * eps
842 && std::abs(f) > Tp(10) * eps)
843 {
844 const Tp frac = diff / f0;
845 if (std::abs(frac) > max_abs_frac)
846 max_abs_frac = std::abs(frac);
847 }
848 }
849 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
850}
851
852// Test data for n=1, m=100.
853testcase_assoc_laguerre<double> data016[] = {
854 { 101.00000000000000, 1, 100,
855 0.0000000000000000 },
856 { 91.000000000000000, 1, 100,
857 10.000000000000000 },
858 { 81.000000000000000, 1, 100,
859 20.000000000000000 },
860 { 71.000000000000000, 1, 100,
861 30.000000000000000 },
862 { 61.000000000000000, 1, 100,
863 40.000000000000000 },
864 { 51.000000000000000, 1, 100,
865 50.000000000000000 },
866 { 41.000000000000000, 1, 100,
867 60.000000000000000 },
868 { 31.000000000000000, 1, 100,
869 70.000000000000000 },
870 { 21.000000000000000, 1, 100,
871 80.000000000000000 },
872 { 11.000000000000000, 1, 100,
873 90.000000000000000 },
874 { 1.0000000000000000, 1, 100,
875 100.00000000000000 },
876};
877
878// Test function for n=1, m=100.
879template <typename Tp>
880void test016()
881{
882 const Tp eps = std::numeric_limits<Tp>::epsilon();
883 Tp max_abs_diff = -Tp(1);
884 Tp max_abs_frac = -Tp(1);
885 unsigned int num_datum = sizeof(data016)
886 / sizeof(testcase_assoc_laguerre<double>);
887 for (unsigned int i = 0; i < num_datum; ++i)
888 {
889 const Tp f = std::tr1::assoc_laguerre(Tp(data016[i].n), Tp(data016[i].m),
890 Tp(data016[i].x));
891 const Tp f0 = data016[i].f0;
892 const Tp diff = f - f0;
893 if (std::abs(diff) > max_abs_diff)
894 max_abs_diff = std::abs(diff);
895 if (std::abs(f0) > Tp(10) * eps
896 && std::abs(f) > Tp(10) * eps)
897 {
898 const Tp frac = diff / f0;
899 if (std::abs(frac) > max_abs_frac)
900 max_abs_frac = std::abs(frac);
901 }
902 }
903 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
904}
905
906// Test data for n=2, m=0.
907testcase_assoc_laguerre<double> data017[] = {
908 { 1.0000000000000000, 2, 0,
909 0.0000000000000000 },
910 { 31.000000000000000, 2, 0,
911 10.000000000000000 },
912 { 161.00000000000000, 2, 0,
913 20.000000000000000 },
914 { 391.00000000000000, 2, 0,
915 30.000000000000000 },
916 { 721.00000000000000, 2, 0,
917 40.000000000000000 },
918 { 1151.0000000000000, 2, 0,
919 50.000000000000000 },
920 { 1681.0000000000000, 2, 0,
921 60.000000000000000 },
922 { 2311.0000000000000, 2, 0,
923 70.000000000000000 },
924 { 3041.0000000000000, 2, 0,
925 80.000000000000000 },
926 { 3871.0000000000000, 2, 0,
927 90.000000000000000 },
928 { 4801.0000000000000, 2, 0,
929 100.00000000000000 },
930};
931
932// Test function for n=2, m=0.
933template <typename Tp>
934void test017()
935{
936 const Tp eps = std::numeric_limits<Tp>::epsilon();
937 Tp max_abs_diff = -Tp(1);
938 Tp max_abs_frac = -Tp(1);
939 unsigned int num_datum = sizeof(data017)
940 / sizeof(testcase_assoc_laguerre<double>);
941 for (unsigned int i = 0; i < num_datum; ++i)
942 {
943 const Tp f = std::tr1::assoc_laguerre(Tp(data017[i].n), Tp(data017[i].m),
944 Tp(data017[i].x));
945 const Tp f0 = data017[i].f0;
946 const Tp diff = f - f0;
947 if (std::abs(diff) > max_abs_diff)
948 max_abs_diff = std::abs(diff);
949 if (std::abs(f0) > Tp(10) * eps
950 && std::abs(f) > Tp(10) * eps)
951 {
952 const Tp frac = diff / f0;
953 if (std::abs(frac) > max_abs_frac)
954 max_abs_frac = std::abs(frac);
955 }
956 }
957 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
958}
959
960// Test data for n=2, m=1.
961testcase_assoc_laguerre<double> data018[] = {
962 { 3.0000000000000000, 2, 1,
963 0.0000000000000000 },
964 { 23.000000000000000, 2, 1,
965 10.000000000000000 },
966 { 143.00000000000000, 2, 1,
967 20.000000000000000 },
968 { 363.00000000000000, 2, 1,
969 30.000000000000000 },
970 { 683.00000000000000, 2, 1,
971 40.000000000000000 },
972 { 1103.0000000000000, 2, 1,
973 50.000000000000000 },
974 { 1623.0000000000000, 2, 1,
975 60.000000000000000 },
976 { 2243.0000000000000, 2, 1,
977 70.000000000000000 },
978 { 2963.0000000000000, 2, 1,
979 80.000000000000000 },
980 { 3783.0000000000000, 2, 1,
981 90.000000000000000 },
982 { 4703.0000000000000, 2, 1,
983 100.00000000000000 },
984};
985
986// Test function for n=2, m=1.
987template <typename Tp>
988void test018()
989{
990 const Tp eps = std::numeric_limits<Tp>::epsilon();
991 Tp max_abs_diff = -Tp(1);
992 Tp max_abs_frac = -Tp(1);
993 unsigned int num_datum = sizeof(data018)
994 / sizeof(testcase_assoc_laguerre<double>);
995 for (unsigned int i = 0; i < num_datum; ++i)
996 {
997 const Tp f = std::tr1::assoc_laguerre(Tp(data018[i].n), Tp(data018[i].m),
998 Tp(data018[i].x));
999 const Tp f0 = data018[i].f0;
1000 const Tp diff = f - f0;
1001 if (std::abs(diff) > max_abs_diff)
1002 max_abs_diff = std::abs(diff);
1003 if (std::abs(f0) > Tp(10) * eps
1004 && std::abs(f) > Tp(10) * eps)
1005 {
1006 const Tp frac = diff / f0;
1007 if (std::abs(frac) > max_abs_frac)
1008 max_abs_frac = std::abs(frac);
1009 }
1010 }
1011 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1012}
1013
1014// Test data for n=2, m=2.
1015testcase_assoc_laguerre<double> data019[] = {
1016 { 6.0000000000000000, 2, 2,
1017 0.0000000000000000 },
1018 { 16.000000000000000, 2, 2,
1019 10.000000000000000 },
1020 { 126.00000000000000, 2, 2,
1021 20.000000000000000 },
1022 { 336.00000000000000, 2, 2,
1023 30.000000000000000 },
1024 { 646.00000000000000, 2, 2,
1025 40.000000000000000 },
1026 { 1056.0000000000000, 2, 2,
1027 50.000000000000000 },
1028 { 1566.0000000000000, 2, 2,
1029 60.000000000000000 },
1030 { 2176.0000000000000, 2, 2,
1031 70.000000000000000 },
1032 { 2886.0000000000000, 2, 2,
1033 80.000000000000000 },
1034 { 3696.0000000000000, 2, 2,
1035 90.000000000000000 },
1036 { 4606.0000000000000, 2, 2,
1037 100.00000000000000 },
1038};
1039
1040// Test function for n=2, m=2.
1041template <typename Tp>
1042void test019()
1043{
1044 const Tp eps = std::numeric_limits<Tp>::epsilon();
1045 Tp max_abs_diff = -Tp(1);
1046 Tp max_abs_frac = -Tp(1);
1047 unsigned int num_datum = sizeof(data019)
1048 / sizeof(testcase_assoc_laguerre<double>);
1049 for (unsigned int i = 0; i < num_datum; ++i)
1050 {
1051 const Tp f = std::tr1::assoc_laguerre(Tp(data019[i].n), Tp(data019[i].m),
1052 Tp(data019[i].x));
1053 const Tp f0 = data019[i].f0;
1054 const Tp diff = f - f0;
1055 if (std::abs(diff) > max_abs_diff)
1056 max_abs_diff = std::abs(diff);
1057 if (std::abs(f0) > Tp(10) * eps
1058 && std::abs(f) > Tp(10) * eps)
1059 {
1060 const Tp frac = diff / f0;
1061 if (std::abs(frac) > max_abs_frac)
1062 max_abs_frac = std::abs(frac);
1063 }
1064 }
1065 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1066}
1067
1068// Test data for n=2, m=5.
1069testcase_assoc_laguerre<double> data020[] = {
1070 { 21.000000000000000, 2, 5,
1071 0.0000000000000000 },
1072 { 0.99999999999999645, 2, 5,
1073 10.000000000000000 },
1074 { 81.000000000000000, 2, 5,
1075 20.000000000000000 },
1076 { 261.00000000000000, 2, 5,
1077 30.000000000000000 },
1078 { 541.00000000000000, 2, 5,
1079 40.000000000000000 },
1080 { 921.00000000000000, 2, 5,
1081 50.000000000000000 },
1082 { 1401.0000000000000, 2, 5,
1083 60.000000000000000 },
1084 { 1981.0000000000000, 2, 5,
1085 70.000000000000000 },
1086 { 2661.0000000000000, 2, 5,
1087 80.000000000000000 },
1088 { 3441.0000000000000, 2, 5,
1089 90.000000000000000 },
1090 { 4321.0000000000000, 2, 5,
1091 100.00000000000000 },
1092};
1093
1094// Test function for n=2, m=5.
1095template <typename Tp>
1096void test020()
1097{
1098 const Tp eps = std::numeric_limits<Tp>::epsilon();
1099 Tp max_abs_diff = -Tp(1);
1100 Tp max_abs_frac = -Tp(1);
1101 unsigned int num_datum = sizeof(data020)
1102 / sizeof(testcase_assoc_laguerre<double>);
1103 for (unsigned int i = 0; i < num_datum; ++i)
1104 {
1105 const Tp f = std::tr1::assoc_laguerre(Tp(data020[i].n), Tp(data020[i].m),
1106 Tp(data020[i].x));
1107 const Tp f0 = data020[i].f0;
1108 const Tp diff = f - f0;
1109 if (std::abs(diff) > max_abs_diff)
1110 max_abs_diff = std::abs(diff);
1111 if (std::abs(f0) > Tp(10) * eps
1112 && std::abs(f) > Tp(10) * eps)
1113 {
1114 const Tp frac = diff / f0;
1115 if (std::abs(frac) > max_abs_frac)
1116 max_abs_frac = std::abs(frac);
1117 }
1118 }
1119 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1120}
1121
1122// Test data for n=2, m=10.
1123testcase_assoc_laguerre<double> data021[] = {
1124 { 66.000000000000000, 2, 10,
1125 0.0000000000000000 },
1126 { -4.0000000000000089, 2, 10,
1127 10.000000000000000 },
1128 { 25.999999999999964, 2, 10,
1129 20.000000000000000 },
1130 { 156.00000000000000, 2, 10,
1131 30.000000000000000 },
1132 { 386.00000000000000, 2, 10,
1133 40.000000000000000 },
1134 { 716.00000000000000, 2, 10,
1135 50.000000000000000 },
1136 { 1146.0000000000000, 2, 10,
1137 60.000000000000000 },
1138 { 1676.0000000000000, 2, 10,
1139 70.000000000000000 },
1140 { 2306.0000000000000, 2, 10,
1141 80.000000000000000 },
1142 { 3036.0000000000000, 2, 10,
1143 90.000000000000000 },
1144 { 3866.0000000000000, 2, 10,
1145 100.00000000000000 },
1146};
1147
1148// Test function for n=2, m=10.
1149template <typename Tp>
1150void test021()
1151{
1152 const Tp eps = std::numeric_limits<Tp>::epsilon();
1153 Tp max_abs_diff = -Tp(1);
1154 Tp max_abs_frac = -Tp(1);
1155 unsigned int num_datum = sizeof(data021)
1156 / sizeof(testcase_assoc_laguerre<double>);
1157 for (unsigned int i = 0; i < num_datum; ++i)
1158 {
1159 const Tp f = std::tr1::assoc_laguerre(Tp(data021[i].n), Tp(data021[i].m),
1160 Tp(data021[i].x));
1161 const Tp f0 = data021[i].f0;
1162 const Tp diff = f - f0;
1163 if (std::abs(diff) > max_abs_diff)
1164 max_abs_diff = std::abs(diff);
1165 if (std::abs(f0) > Tp(10) * eps
1166 && std::abs(f) > Tp(10) * eps)
1167 {
1168 const Tp frac = diff / f0;
1169 if (std::abs(frac) > max_abs_frac)
1170 max_abs_frac = std::abs(frac);
1171 }
1172 }
1173 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1174}
1175
1176// Test data for n=2, m=20.
1177testcase_assoc_laguerre<double> data022[] = {
1178 { 231.00000000000000, 2, 20,
1179 0.0000000000000000 },
1180 { 61.000000000000206, 2, 20,
1181 10.000000000000000 },
1182 { -8.9999999999999982, 2, 20,
1183 20.000000000000000 },
1184 { 21.000000000000135, 2, 20,
1185 30.000000000000000 },
1186 { 151.00000000000054, 2, 20,
1187 40.000000000000000 },
1188 { 381.00000000000000, 2, 20,
1189 50.000000000000000 },
1190 { 711.00000000000000, 2, 20,
1191 60.000000000000000 },
1192 { 1141.0000000000000, 2, 20,
1193 70.000000000000000 },
1194 { 1670.9999999999998, 2, 20,
1195 80.000000000000000 },
1196 { 2301.0000000000000, 2, 20,
1197 90.000000000000000 },
1198 { 3031.0000000000000, 2, 20,
1199 100.00000000000000 },
1200};
1201
1202// Test function for n=2, m=20.
1203template <typename Tp>
1204void test022()
1205{
1206 const Tp eps = std::numeric_limits<Tp>::epsilon();
1207 Tp max_abs_diff = -Tp(1);
1208 Tp max_abs_frac = -Tp(1);
1209 unsigned int num_datum = sizeof(data022)
1210 / sizeof(testcase_assoc_laguerre<double>);
1211 for (unsigned int i = 0; i < num_datum; ++i)
1212 {
1213 const Tp f = std::tr1::assoc_laguerre(Tp(data022[i].n), Tp(data022[i].m),
1214 Tp(data022[i].x));
1215 const Tp f0 = data022[i].f0;
1216 const Tp diff = f - f0;
1217 if (std::abs(diff) > max_abs_diff)
1218 max_abs_diff = std::abs(diff);
1219 if (std::abs(f0) > Tp(10) * eps
1220 && std::abs(f) > Tp(10) * eps)
1221 {
1222 const Tp frac = diff / f0;
1223 if (std::abs(frac) > max_abs_frac)
1224 max_abs_frac = std::abs(frac);
1225 }
1226 }
1227 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
1228}
1229
1230// Test data for n=2, m=50.
1231testcase_assoc_laguerre<double> data023[] = {
1232 { 1326.0000000000000, 2, 50,
1233 0.0000000000000000 },
1234 { 855.99999999999716, 2, 50,
1235 10.000000000000000 },
1236 { 485.99999999999829, 2, 50,
1237 20.000000000000000 },
1238 { 215.99999999999935, 2, 50,
1239 30.000000000000000 },
1240 { 45.999999999999787, 2, 50,
1241 40.000000000000000 },
1242 { -23.999999999999684, 2, 50,
1243 50.000000000000000 },
1244 { 6.0000000000001217, 2, 50,
1245 60.000000000000000 },
1246 { 135.99999999999972, 2, 50,
1247 70.000000000000000 },
1248 { 365.99999999999892, 2, 50,
1249 80.000000000000000 },
1250 { 695.99999999999784, 2, 50,
1251 90.000000000000000 },
1252 { 1125.9999999999964, 2, 50,
1253 100.00000000000000 },
1254};
1255
1256// Test function for n=2, m=50.
1257template <typename Tp>
1258void test023()
1259{
1260 const Tp eps = std::numeric_limits<Tp>::epsilon();
1261 Tp max_abs_diff = -Tp(1);
1262 Tp max_abs_frac = -Tp(1);
1263 unsigned int num_datum = sizeof(data023)
1264 / sizeof(testcase_assoc_laguerre<double>);
1265 for (unsigned int i = 0; i < num_datum; ++i)
1266 {
1267 const Tp f = std::tr1::assoc_laguerre(Tp(data023[i].n), Tp(data023[i].m),
1268 Tp(data023[i].x));
1269 const Tp f0 = data023[i].f0;
1270 const Tp diff = f - f0;
1271 if (std::abs(diff) > max_abs_diff)
1272 max_abs_diff = std::abs(diff);
1273 if (std::abs(f0) > Tp(10) * eps
1274 && std::abs(f) > Tp(10) * eps)
1275 {
1276 const Tp frac = diff / f0;
1277 if (std::abs(frac) > max_abs_frac)
1278 max_abs_frac = std::abs(frac);
1279 }
1280 }
1281 VERIFY(max_abs_frac < Tp(2.5000000000000015e-12));
1282}
1283
1284// Test data for n=2, m=100.
1285testcase_assoc_laguerre<double> data024[] = {
1286 { 5151.0000000000000, 2, 100,
1287 0.0000000000000000 },
1288 { 4181.0000000000655, 2, 100,
1289 10.000000000000000 },
1290 { 3311.0000000000518, 2, 100,
1291 20.000000000000000 },
1292 { 2541.0000000000400, 2, 100,
1293 30.000000000000000 },
1294 { 1871.0000000000291, 2, 100,
1295 40.000000000000000 },
1296 { 1301.0000000000207, 2, 100,
1297 50.000000000000000 },
1298 { 831.00000000001364, 2, 100,
1299 60.000000000000000 },
1300 { 461.00000000000682, 2, 100,
1301 70.000000000000000 },
1302 { 191.00000000000227, 2, 100,
1303 80.000000000000000 },
1304 { 21.000000000000128, 2, 100,
1305 90.000000000000000 },
1306 { -49.000000000000369, 2, 100,
1307 100.00000000000000 },
1308};
1309
1310// Test function for n=2, m=100.
1311template <typename Tp>
1312void test024()
1313{
1314 const Tp eps = std::numeric_limits<Tp>::epsilon();
1315 Tp max_abs_diff = -Tp(1);
1316 Tp max_abs_frac = -Tp(1);
1317 unsigned int num_datum = sizeof(data024)
1318 / sizeof(testcase_assoc_laguerre<double>);
1319 for (unsigned int i = 0; i < num_datum; ++i)
1320 {
1321 const Tp f = std::tr1::assoc_laguerre(Tp(data024[i].n), Tp(data024[i].m),
1322 Tp(data024[i].x));
1323 const Tp f0 = data024[i].f0;
1324 const Tp diff = f - f0;
1325 if (std::abs(diff) > max_abs_diff)
1326 max_abs_diff = std::abs(diff);
1327 if (std::abs(f0) > Tp(10) * eps
1328 && std::abs(f) > Tp(10) * eps)
1329 {
1330 const Tp frac = diff / f0;
1331 if (std::abs(frac) > max_abs_frac)
1332 max_abs_frac = std::abs(frac);
1333 }
1334 }
1335 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
1336}
1337
1338// Test data for n=5, m=0.
1339testcase_assoc_laguerre<double> data025[] = {
1340 { 1.0000000000000000, 5, 0,
1341 0.0000000000000000 },
1342 { 34.333333333333329, 5, 0,
1343 10.000000000000000 },
1344 { -4765.6666666666670, 5, 0,
1345 20.000000000000000 },
1346 { -74399.000000000000, 5, 0,
1347 30.000000000000000 },
1348 { -418865.66666666663, 5, 0,
1349 40.000000000000000 },
1350 { -1498165.6666666665, 5, 0,
1351 50.000000000000000 },
1352 { -4122299.0000000000, 5, 0,
1353 60.000000000000000 },
1354 { -9551265.6666666679, 5, 0,
1355 70.000000000000000 },
1356 { -19595065.666666664, 5, 0,
1357 80.000000000000000 },
1358 { -36713699.000000000, 5, 0,
1359 90.000000000000000 },
1360 { -64117165.666666664, 5, 0,
1361 100.00000000000000 },
1362};
1363
1364// Test function for n=5, m=0.
1365template <typename Tp>
1366void test025()
1367{
1368 const Tp eps = std::numeric_limits<Tp>::epsilon();
1369 Tp max_abs_diff = -Tp(1);
1370 Tp max_abs_frac = -Tp(1);
1371 unsigned int num_datum = sizeof(data025)
1372 / sizeof(testcase_assoc_laguerre<double>);
1373 for (unsigned int i = 0; i < num_datum; ++i)
1374 {
1375 const Tp f = std::tr1::assoc_laguerre(Tp(data025[i].n), Tp(data025[i].m),
1376 Tp(data025[i].x));
1377 const Tp f0 = data025[i].f0;
1378 const Tp diff = f - f0;
1379 if (std::abs(diff) > max_abs_diff)
1380 max_abs_diff = std::abs(diff);
1381 if (std::abs(f0) > Tp(10) * eps
1382 && std::abs(f) > Tp(10) * eps)
1383 {
1384 const Tp frac = diff / f0;
1385 if (std::abs(frac) > max_abs_frac)
1386 max_abs_frac = std::abs(frac);
1387 }
1388 }
1389 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1390}
1391
1392// Test data for n=5, m=1.
1393testcase_assoc_laguerre<double> data026[] = {
1394 { 6.0000000000000000, 5, 1,
1395 0.0000000000000000 },
1396 { 22.666666666666661, 5, 1,
1397 10.000000000000000 },
1398 { -2960.6666666666661, 5, 1,
1399 20.000000000000000 },
1400 { -58944.000000000000, 5, 1,
1401 30.000000000000000 },
1402 { -357927.33333333326, 5, 1,
1403 40.000000000000000 },
1404 { -1329910.6666666665, 5, 1,
1405 50.000000000000000 },
1406 { -3744894.0000000000, 5, 1,
1407 60.000000000000000 },
1408 { -8812877.3333333321, 5, 1,
1409 70.000000000000000 },
1410 { -18283860.666666664, 5, 1,
1411 80.000000000000000 },
1412 { -34547844.000000000, 5, 1,
1413 90.000000000000000 },
1414 { -60734827.333333336, 5, 1,
1415 100.00000000000000 },
1416};
1417
1418// Test function for n=5, m=1.
1419template <typename Tp>
1420void test026()
1421{
1422 const Tp eps = std::numeric_limits<Tp>::epsilon();
1423 Tp max_abs_diff = -Tp(1);
1424 Tp max_abs_frac = -Tp(1);
1425 unsigned int num_datum = sizeof(data026)
1426 / sizeof(testcase_assoc_laguerre<double>);
1427 for (unsigned int i = 0; i < num_datum; ++i)
1428 {
1429 const Tp f = std::tr1::assoc_laguerre(Tp(data026[i].n), Tp(data026[i].m),
1430 Tp(data026[i].x));
1431 const Tp f0 = data026[i].f0;
1432 const Tp diff = f - f0;
1433 if (std::abs(diff) > max_abs_diff)
1434 max_abs_diff = std::abs(diff);
1435 if (std::abs(f0) > Tp(10) * eps
1436 && std::abs(f) > Tp(10) * eps)
1437 {
1438 const Tp frac = diff / f0;
1439 if (std::abs(frac) > max_abs_frac)
1440 max_abs_frac = std::abs(frac);
1441 }
1442 }
1443 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1444}
1445
1446// Test data for n=5, m=2.
1447testcase_assoc_laguerre<double> data027[] = {
1448 { 21.000000000000000, 5, 2,
1449 0.0000000000000000 },
1450 { 4.3333333333333339, 5, 2,
1451 10.000000000000000 },
1452 { -1679.0000000000000, 5, 2,
1453 20.000000000000000 },
1454 { -46029.000000000000, 5, 2,
1455 30.000000000000000 },
1456 { -304045.66666666669, 5, 2,
1457 40.000000000000000 },
1458 { -1176729.0000000002, 5, 2,
1459 50.000000000000000 },
1460 { -3395079.0000000000, 5, 2,
1461 60.000000000000000 },
1462 { -8120095.6666666660, 5, 2,
1463 70.000000000000000 },
1464 { -17042778.999999996, 5, 2,
1465 80.000000000000000 },
1466 { -32484129.000000000, 5, 2,
1467 90.000000000000000 },
1468 { -57495145.666666664, 5, 2,
1469 100.00000000000000 },
1470};
1471
1472// Test function for n=5, m=2.
1473template <typename Tp>
1474void test027()
1475{
1476 const Tp eps = std::numeric_limits<Tp>::epsilon();
1477 Tp max_abs_diff = -Tp(1);
1478 Tp max_abs_frac = -Tp(1);
1479 unsigned int num_datum = sizeof(data027)
1480 / sizeof(testcase_assoc_laguerre<double>);
1481 for (unsigned int i = 0; i < num_datum; ++i)
1482 {
1483 const Tp f = std::tr1::assoc_laguerre(Tp(data027[i].n), Tp(data027[i].m),
1484 Tp(data027[i].x));
1485 const Tp f0 = data027[i].f0;
1486 const Tp diff = f - f0;
1487 if (std::abs(diff) > max_abs_diff)
1488 max_abs_diff = std::abs(diff);
1489 if (std::abs(f0) > Tp(10) * eps
1490 && std::abs(f) > Tp(10) * eps)
1491 {
1492 const Tp frac = diff / f0;
1493 if (std::abs(frac) > max_abs_frac)
1494 max_abs_frac = std::abs(frac);
1495 }
1496 }
1497 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1498}
1499
1500// Test data for n=5, m=5.
1501testcase_assoc_laguerre<double> data028[] = {
1502 { 252.00000000000000, 5, 5,
1503 0.0000000000000000 },
1504 { -14.666666666666657, 5, 5,
1505 10.000000000000000 },
1506 { 51.999999999999957, 5, 5,
1507 20.000000000000000 },
1508 { -19548.000000000000, 5, 5,
1509 30.000000000000000 },
1510 { -178814.66666666660, 5, 5,
1511 40.000000000000000 },
1512 { -797747.99999999977, 5, 5,
1513 50.000000000000000 },
1514 { -2496348.0000000000, 5, 5,
1515 60.000000000000000 },
1516 { -6294614.6666666660, 5, 5,
1517 70.000000000000000 },
1518 { -13712547.999999996, 5, 5,
1519 80.000000000000000 },
1520 { -26870147.999999993, 5, 5,
1521 90.000000000000000 },
1522 { -48587414.666666672, 5, 5,
1523 100.00000000000000 },
1524};
1525
1526// Test function for n=5, m=5.
1527template <typename Tp>
1528void test028()
1529{
1530 const Tp eps = std::numeric_limits<Tp>::epsilon();
1531 Tp max_abs_diff = -Tp(1);
1532 Tp max_abs_frac = -Tp(1);
1533 unsigned int num_datum = sizeof(data028)
1534 / sizeof(testcase_assoc_laguerre<double>);
1535 for (unsigned int i = 0; i < num_datum; ++i)
1536 {
1537 const Tp f = std::tr1::assoc_laguerre(Tp(data028[i].n), Tp(data028[i].m),
1538 Tp(data028[i].x));
1539 const Tp f0 = data028[i].f0;
1540 const Tp diff = f - f0;
1541 if (std::abs(diff) > max_abs_diff)
1542 max_abs_diff = std::abs(diff);
1543 if (std::abs(f0) > Tp(10) * eps
1544 && std::abs(f) > Tp(10) * eps)
1545 {
1546 const Tp frac = diff / f0;
1547 if (std::abs(frac) > max_abs_frac)
1548 max_abs_frac = std::abs(frac);
1549 }
1550 }
1551 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1552}
1553
1554// Test data for n=5, m=10.
1555testcase_assoc_laguerre<double> data029[] = {
1556 { 3003.0000000000000, 5, 10,
1557 0.0000000000000000 },
1558 { 19.666666666666668, 5, 10,
1559 10.000000000000000 },
1560 { 36.333333333333272, 5, 10,
1561 20.000000000000000 },
1562 { -1947.0000000000000, 5, 10,
1563 30.000000000000000 },
1564 { -60930.333333333314, 5, 10,
1565 40.000000000000000 },
1566 { -381913.66666666651, 5, 10,
1567 50.000000000000000 },
1568 { -1419897.0000000000, 5, 10,
1569 60.000000000000000 },
1570 { -3979880.3333333330, 5, 10,
1571 70.000000000000000 },
1572 { -9316863.6666666642, 5, 10,
1573 80.000000000000000 },
1574 { -19235847.000000000, 5, 10,
1575 90.000000000000000 },
1576 { -36191830.333333328, 5, 10,
1577 100.00000000000000 },
1578};
1579
1580// Test function for n=5, m=10.
1581template <typename Tp>
1582void test029()
1583{
1584 const Tp eps = std::numeric_limits<Tp>::epsilon();
1585 Tp max_abs_diff = -Tp(1);
1586 Tp max_abs_frac = -Tp(1);
1587 unsigned int num_datum = sizeof(data029)
1588 / sizeof(testcase_assoc_laguerre<double>);
1589 for (unsigned int i = 0; i < num_datum; ++i)
1590 {
1591 const Tp f = std::tr1::assoc_laguerre(Tp(data029[i].n), Tp(data029[i].m),
1592 Tp(data029[i].x));
1593 const Tp f0 = data029[i].f0;
1594 const Tp diff = f - f0;
1595 if (std::abs(diff) > max_abs_diff)
1596 max_abs_diff = std::abs(diff);
1597 if (std::abs(f0) > Tp(10) * eps
1598 && std::abs(f) > Tp(10) * eps)
1599 {
1600 const Tp frac = diff / f0;
1601 if (std::abs(frac) > max_abs_frac)
1602 max_abs_frac = std::abs(frac);
1603 }
1604 }
1605 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1606}
1607
1608// Test data for n=5, m=20.
1609testcase_assoc_laguerre<double> data030[] = {
1610 { 53130.000000000000, 5, 20,
1611 0.0000000000000000 },
1612 { 1213.3333333333335, 5, 20,
1613 10.000000000000000 },
1614 { 129.99999999999963, 5, 20,
1615 20.000000000000000 },
1616 { -119.99999999999974, 5, 20,
1617 30.000000000000000 },
1618 { 463.33333333333320, 5, 20,
1619 40.000000000000000 },
1620 { -48120.000000000015, 5, 20,
1621 50.000000000000000 },
1622 { -345870.00000000017, 5, 20,
1623 60.000000000000000 },
1624 { -1342786.6666666667, 5, 20,
1625 70.000000000000000 },
1626 { -3838870.0000000009, 5, 20,
1627 80.000000000000000 },
1628 { -9084120.0000000000, 5, 20,
1629 90.000000000000000 },
1630 { -18878536.666666668, 5, 20,
1631 100.00000000000000 },
1632};
1633
1634// Test function for n=5, m=20.
1635template <typename Tp>
1636void test030()
1637{
1638 const Tp eps = std::numeric_limits<Tp>::epsilon();
1639 Tp max_abs_diff = -Tp(1);
1640 Tp max_abs_frac = -Tp(1);
1641 unsigned int num_datum = sizeof(data030)
1642 / sizeof(testcase_assoc_laguerre<double>);
1643 for (unsigned int i = 0; i < num_datum; ++i)
1644 {
1645 const Tp f = std::tr1::assoc_laguerre(Tp(data030[i].n), Tp(data030[i].m),
1646 Tp(data030[i].x));
1647 const Tp f0 = data030[i].f0;
1648 const Tp diff = f - f0;
1649 if (std::abs(diff) > max_abs_diff)
1650 max_abs_diff = std::abs(diff);
1651 if (std::abs(f0) > Tp(10) * eps
1652 && std::abs(f) > Tp(10) * eps)
1653 {
1654 const Tp frac = diff / f0;
1655 if (std::abs(frac) > max_abs_frac)
1656 max_abs_frac = std::abs(frac);
1657 }
1658 }
1659 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1660}
1661
1662// Test data for n=5, m=50.
1663testcase_assoc_laguerre<double> data031[] = {
1664 { 3478761.0000000000, 5, 50,
1665 0.0000000000000000 },
1666 { 1154544.3333333335, 5, 50,
1667 10.000000000000000 },
1668 { 264661.00000000006, 5, 50,
1669 20.000000000000000 },
1670 { 24111.000000000000, 5, 50,
1671 30.000000000000000 },
1672 { -2105.6666666666665, 5, 50,
1673 40.000000000000000 },
1674 { 1011.0000000000000, 5, 50,
1675 50.000000000000000 },
1676 { -1538.9999999999955, 5, 50,
1677 60.000000000000000 },
1678 { 5244.3333333333449, 5, 50,
1679 70.000000000000000 },
1680 { -13639.000000000015, 5, 50,
1681 80.000000000000000 },
1682 { -243189.00000000006, 5, 50,
1683 90.000000000000000 },
1684 { -1118405.6666666667, 5, 50,
1685 100.00000000000000 },
1686};
1687
1688// Test function for n=5, m=50.
1689template <typename Tp>
1690void test031()
1691{
1692 const Tp eps = std::numeric_limits<Tp>::epsilon();
1693 Tp max_abs_diff = -Tp(1);
1694 Tp max_abs_frac = -Tp(1);
1695 unsigned int num_datum = sizeof(data031)
1696 / sizeof(testcase_assoc_laguerre<double>);
1697 for (unsigned int i = 0; i < num_datum; ++i)
1698 {
1699 const Tp f = std::tr1::assoc_laguerre(Tp(data031[i].n), Tp(data031[i].m),
1700 Tp(data031[i].x));
1701 const Tp f0 = data031[i].f0;
1702 const Tp diff = f - f0;
1703 if (std::abs(diff) > max_abs_diff)
1704 max_abs_diff = std::abs(diff);
1705 if (std::abs(f0) > Tp(10) * eps
1706 && std::abs(f) > Tp(10) * eps)
1707 {
1708 const Tp frac = diff / f0;
1709 if (std::abs(frac) > max_abs_frac)
1710 max_abs_frac = std::abs(frac);
1711 }
1712 }
1713 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1714}
1715
1716// Test data for n=5, m=100.
1717testcase_assoc_laguerre<double> data032[] = {
1718 { 96560646.000000000, 5, 100,
1719 0.0000000000000000 },
1720 { 57264262.666666649, 5, 100,
1721 10.000000000000000 },
1722 { 31841379.333333332, 5, 100,
1723 20.000000000000000 },
1724 { 16281996.000000000, 5, 100,
1725 30.000000000000000 },
1726 { 7426112.6666666670, 5, 100,
1727 40.000000000000000 },
1728 { 2863729.3333333330, 5, 100,
1729 50.000000000000000 },
1730 { 834846.00000000000, 5, 100,
1731 60.000000000000000 },
1732 { 129462.66666666663, 5, 100,
1733 70.000000000000000 },
1734 { -12420.666666666666, 5, 100,
1735 80.000000000000000 },
1736 { -804.00000000000000, 5, 100,
1737 90.000000000000000 },
1738 { 4312.6666666666661, 5, 100,
1739 100.00000000000000 },
1740};
1741
1742// Test function for n=5, m=100.
1743template <typename Tp>
1744void test032()
1745{
1746 const Tp eps = std::numeric_limits<Tp>::epsilon();
1747 Tp max_abs_diff = -Tp(1);
1748 Tp max_abs_frac = -Tp(1);
1749 unsigned int num_datum = sizeof(data032)
1750 / sizeof(testcase_assoc_laguerre<double>);
1751 for (unsigned int i = 0; i < num_datum; ++i)
1752 {
1753 const Tp f = std::tr1::assoc_laguerre(Tp(data032[i].n), Tp(data032[i].m),
1754 Tp(data032[i].x));
1755 const Tp f0 = data032[i].f0;
1756 const Tp diff = f - f0;
1757 if (std::abs(diff) > max_abs_diff)
1758 max_abs_diff = std::abs(diff);
1759 if (std::abs(f0) > Tp(10) * eps
1760 && std::abs(f) > Tp(10) * eps)
1761 {
1762 const Tp frac = diff / f0;
1763 if (std::abs(frac) > max_abs_frac)
1764 max_abs_frac = std::abs(frac);
1765 }
1766 }
1767 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1768}
1769
1770// Test data for n=10, m=0.
1771testcase_assoc_laguerre<double> data033[] = {
1772 { 1.0000000000000000, 10, 0,
1773 0.0000000000000000 },
1774 { 27.984126984126981, 10, 0,
1775 10.000000000000000 },
1776 { 3227.8077601410932, 10, 0,
1777 20.000000000000000 },
1778 { 15129.571428571489, 10, 0,
1779 30.000000000000000 },
1780 { 79724066.608465582, 10, 0,
1781 40.000000000000000 },
1782 { 2037190065.3738980, 10, 0,
1783 50.000000000000000 },
1784 { 21804200401.000000, 10, 0,
1785 60.000000000000000 },
1786 { 144688291819.51855, 10, 0,
1787 70.000000000000000 },
1788 { 703324772760.08276, 10, 0,
1789 80.000000000000000 },
1790 { 2741055412243.8569, 10, 0,
1791 90.000000000000000 },
1792 { 9051283795429.5723, 10, 0,
1793 100.00000000000000 },
1794};
1795
1796// Test function for n=10, m=0.
1797template <typename Tp>
1798void test033()
1799{
1800 const Tp eps = std::numeric_limits<Tp>::epsilon();
1801 Tp max_abs_diff = -Tp(1);
1802 Tp max_abs_frac = -Tp(1);
1803 unsigned int num_datum = sizeof(data033)
1804 / sizeof(testcase_assoc_laguerre<double>);
1805 for (unsigned int i = 0; i < num_datum; ++i)
1806 {
1807 const Tp f = std::tr1::assoc_laguerre(Tp(data033[i].n), Tp(data033[i].m),
1808 Tp(data033[i].x));
1809 const Tp f0 = data033[i].f0;
1810 const Tp diff = f - f0;
1811 if (std::abs(diff) > max_abs_diff)
1812 max_abs_diff = std::abs(diff);
1813 if (std::abs(f0) > Tp(10) * eps
1814 && std::abs(f) > Tp(10) * eps)
1815 {
1816 const Tp frac = diff / f0;
1817 if (std::abs(frac) > max_abs_frac)
1818 max_abs_frac = std::abs(frac);
1819 }
1820 }
1821 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
1822}
1823
1824// Test data for n=10, m=1.
1825testcase_assoc_laguerre<double> data034[] = {
1826 { 11.000000000000000, 10, 1,
1827 0.0000000000000000 },
1828 { 14.791887125220455, 10, 1,
1829 10.000000000000000 },
1830 { 2704.6507936507933, 10, 1,
1831 20.000000000000000 },
1832 { -182924.71428571426, 10, 1,
1833 30.000000000000000 },
1834 { 48066036.749559075, 10, 1,
1835 40.000000000000000 },
1836 { 1486264192.2169311, 10, 1,
1837 50.000000000000000 },
1838 { 17239562282.428574, 10, 1,
1839 60.000000000000000 },
1840 { 119837491630.13579, 10, 1,
1841 70.000000000000000 },
1842 { 600681375251.21167, 10, 1,
1843 80.000000000000000 },
1844 { 2392908405632.4287, 10, 1,
1845 90.000000000000000 },
1846 { 8033035722509.2373, 10, 1,
1847 100.00000000000000 },
1848};
1849
1850// Test function for n=10, m=1.
1851template <typename Tp>
1852void test034()
1853{
1854 const Tp eps = std::numeric_limits<Tp>::epsilon();
1855 Tp max_abs_diff = -Tp(1);
1856 Tp max_abs_frac = -Tp(1);
1857 unsigned int num_datum = sizeof(data034)
1858 / sizeof(testcase_assoc_laguerre<double>);
1859 for (unsigned int i = 0; i < num_datum; ++i)
1860 {
1861 const Tp f = std::tr1::assoc_laguerre(Tp(data034[i].n), Tp(data034[i].m),
1862 Tp(data034[i].x));
1863 const Tp f0 = data034[i].f0;
1864 const Tp diff = f - f0;
1865 if (std::abs(diff) > max_abs_diff)
1866 max_abs_diff = std::abs(diff);
1867 if (std::abs(f0) > Tp(10) * eps
1868 && std::abs(f) > Tp(10) * eps)
1869 {
1870 const Tp frac = diff / f0;
1871 if (std::abs(frac) > max_abs_frac)
1872 max_abs_frac = std::abs(frac);
1873 }
1874 }
1875 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1876}
1877
1878// Test data for n=10, m=2.
1879testcase_assoc_laguerre<double> data035[] = {
1880 { 66.000000000000000, 10, 2,
1881 0.0000000000000000 },
1882 { -14.511463844797174, 10, 2,
1883 10.000000000000000 },
1884 { 1064.5890652557318, 10, 2,
1885 20.000000000000000 },
1886 { -194569.71428571426, 10, 2,
1887 30.000000000000000 },
1888 { 27343569.350970022, 10, 2,
1889 40.000000000000000 },
1890 { 1067807661.6790125, 10, 2,
1891 50.000000000000000 },
1892 { 13529451580.285713, 10, 2,
1893 60.000000000000000 },
1894 { 98812724224.641937, 10, 2,
1895 70.000000000000000 },
1896 { 511482736187.34021, 10, 2,
1897 80.000000000000000 },
1898 { 2084478393087.4285, 10, 2,
1899 90.000000000000000 },
1900 { 7117724862237.0752, 10, 2,
1901 100.00000000000000 },
1902};
1903
1904// Test function for n=10, m=2.
1905template <typename Tp>
1906void test035()
1907{
1908 const Tp eps = std::numeric_limits<Tp>::epsilon();
1909 Tp max_abs_diff = -Tp(1);
1910 Tp max_abs_frac = -Tp(1);
1911 unsigned int num_datum = sizeof(data035)
1912 / sizeof(testcase_assoc_laguerre<double>);
1913 for (unsigned int i = 0; i < num_datum; ++i)
1914 {
1915 const Tp f = std::tr1::assoc_laguerre(Tp(data035[i].n), Tp(data035[i].m),
1916 Tp(data035[i].x));
1917 const Tp f0 = data035[i].f0;
1918 const Tp diff = f - f0;
1919 if (std::abs(diff) > max_abs_diff)
1920 max_abs_diff = std::abs(diff);
1921 if (std::abs(f0) > Tp(10) * eps
1922 && std::abs(f) > Tp(10) * eps)
1923 {
1924 const Tp frac = diff / f0;
1925 if (std::abs(frac) > max_abs_frac)
1926 max_abs_frac = std::abs(frac);
1927 }
1928 }
1929 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1930}
1931
1932// Test data for n=10, m=5.
1933testcase_assoc_laguerre<double> data036[] = {
1934 { 3003.0000000000000, 10, 5,
1935 0.0000000000000000 },
1936 { 11.641975308642024, 10, 5,
1937 10.000000000000000 },
1938 { -1137.5643738977069, 10, 5,
1939 20.000000000000000 },
1940 { -9254.1428571428605, 10, 5,
1941 30.000000000000000 },
1942 { 2121878.8377425023, 10, 5,
1943 40.000000000000000 },
1944 { 352060171.43033499, 10, 5,
1945 50.000000000000000 },
1946 { 6212028560.1428576, 10, 5,
1947 60.000000000000000 },
1948 { 53782171674.604919, 10, 5,
1949 70.000000000000000 },
1950 { 309720255837.56775, 10, 5,
1951 80.000000000000000 },
1952 { 1359043035731.5713, 10, 5,
1953 90.000000000000000 },
1954 { 4900625954398.9434, 10, 5,
1955 100.00000000000000 },
1956};
1957
1958// Test function for n=10, m=5.
1959template <typename Tp>
1960void test036()
1961{
1962 const Tp eps = std::numeric_limits<Tp>::epsilon();
1963 Tp max_abs_diff = -Tp(1);
1964 Tp max_abs_frac = -Tp(1);
1965 unsigned int num_datum = sizeof(data036)
1966 / sizeof(testcase_assoc_laguerre<double>);
1967 for (unsigned int i = 0; i < num_datum; ++i)
1968 {
1969 const Tp f = std::tr1::assoc_laguerre(Tp(data036[i].n), Tp(data036[i].m),
1970 Tp(data036[i].x));
1971 const Tp f0 = data036[i].f0;
1972 const Tp diff = f - f0;
1973 if (std::abs(diff) > max_abs_diff)
1974 max_abs_diff = std::abs(diff);
1975 if (std::abs(f0) > Tp(10) * eps
1976 && std::abs(f) > Tp(10) * eps)
1977 {
1978 const Tp frac = diff / f0;
1979 if (std::abs(frac) > max_abs_frac)
1980 max_abs_frac = std::abs(frac);
1981 }
1982 }
1983 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1984}
1985
1986// Test data for n=10, m=10.
1987testcase_assoc_laguerre<double> data037[] = {
1988 { 184756.00000000000, 10, 10,
1989 0.0000000000000000 },
1990 { -210.84303350970018, 10, 10,
1991 10.000000000000000 },
1992 { 508.38095238095184, 10, 10,
1993 20.000000000000000 },
1994 { 2098.8571428571431, 10, 10,
1995 30.000000000000000 },
1996 { -536338.88536155189, 10, 10,
1997 40.000000000000000 },
1998 { 24865988.804232784, 10, 10,
1999 50.000000000000000 },
2000 { 1343756013.1428571, 10, 10,
2001 60.000000000000000 },
2002 { 17298791247.358025, 10, 10,
2003 70.000000000000000 },
2004 { 124528450897.79892, 10, 10,
2005 80.000000000000000 },
2006 { 632674413641.71423, 10, 10,
2007 90.000000000000000 },
2008 { 2533008935405.0298, 10, 10,
2009 100.00000000000000 },
2010};
2011
2012// Test function for n=10, m=10.
2013template <typename Tp>
2014void test037()
2015{
2016 const Tp eps = std::numeric_limits<Tp>::epsilon();
2017 Tp max_abs_diff = -Tp(1);
2018 Tp max_abs_frac = -Tp(1);
2019 unsigned int num_datum = sizeof(data037)
2020 / sizeof(testcase_assoc_laguerre<double>);
2021 for (unsigned int i = 0; i < num_datum; ++i)
2022 {
2023 const Tp f = std::tr1::assoc_laguerre(Tp(data037[i].n), Tp(data037[i].m),
2024 Tp(data037[i].x));
2025 const Tp f0 = data037[i].f0;
2026 const Tp diff = f - f0;
2027 if (std::abs(diff) > max_abs_diff)
2028 max_abs_diff = std::abs(diff);
2029 if (std::abs(f0) > Tp(10) * eps
2030 && std::abs(f) > Tp(10) * eps)
2031 {
2032 const Tp frac = diff / f0;
2033 if (std::abs(frac) > max_abs_frac)
2034 max_abs_frac = std::abs(frac);
2035 }
2036 }
2037 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2038}
2039
2040// Test data for n=10, m=20.
2041testcase_assoc_laguerre<double> data038[] = {
2042 { 30045014.999999993, 10, 20,
2043 0.0000000000000000 },
2044 { -23087.733686067022, 10, 20,
2045 10.000000000000000 },
2046 { 207.23985890652347, 10, 20,
2047 20.000000000000000 },
2048 { 1407.8571428571497, 10, 20,
2049 30.000000000000000 },
2050 { -44618.156966490329, 10, 20,
2051 40.000000000000000 },
2052 { 158690.04409171085, 10, 20,
2053 50.000000000000000 },
2054 { -6870413.5714285728, 10, 20,
2055 60.000000000000000 },
2056 { 793841351.41975331, 10, 20,
2057 70.000000000000000 },
2058 { 13358288958.562618, 10, 20,
2059 80.000000000000000 },
2060 { 106073722407.85715, 10, 20,
2061 90.000000000000000 },
2062 { 566337213392.42493, 10, 20,
2063 100.00000000000000 },
2064};
2065
2066// Test function for n=10, m=20.
2067template <typename Tp>
2068void test038()
2069{
2070 const Tp eps = std::numeric_limits<Tp>::epsilon();
2071 Tp max_abs_diff = -Tp(1);
2072 Tp max_abs_frac = -Tp(1);
2073 unsigned int num_datum = sizeof(data038)
2074 / sizeof(testcase_assoc_laguerre<double>);
2075 for (unsigned int i = 0; i < num_datum; ++i)
2076 {
2077 const Tp f = std::tr1::assoc_laguerre(Tp(data038[i].n), Tp(data038[i].m),
2078 Tp(data038[i].x));
2079 const Tp f0 = data038[i].f0;
2080 const Tp diff = f - f0;
2081 if (std::abs(diff) > max_abs_diff)
2082 max_abs_diff = std::abs(diff);
2083 if (std::abs(f0) > Tp(10) * eps
2084 && std::abs(f) > Tp(10) * eps)
2085 {
2086 const Tp frac = diff / f0;
2087 if (std::abs(frac) > max_abs_frac)
2088 max_abs_frac = std::abs(frac);
2089 }
2090 }
2091 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
2092}
2093
2094// Test data for n=10, m=50.
2095testcase_assoc_laguerre<double> data039[] = {
2096 { 75394027566.000000, 10, 50,
2097 0.0000000000000000 },
2098 { 8048106183.3721361, 10, 50,
2099 10.000000000000000 },
2100 { 328045023.84832466, 10, 50,
2101 20.000000000000000 },
2102 { -2568769.7142857141, 10, 50,
2103 30.000000000000000 },
2104 { 6971.9964726631733, 10, 50,
2105 40.000000000000000 },
2106 { 136111.41446208110, 10, 50,
2107 50.000000000000000 },
2108 { -62462.571428570242, 10, 50,
2109 60.000000000000000 },
2110 { -248167.95061728527, 10, 50,
2111 70.000000000000000 },
2112 { 1941270.4091710777, 10, 50,
2113 80.000000000000000 },
2114 { -8643512.5714285783, 10, 50,
2115 90.000000000000000 },
2116 { -140863522.18342155, 10, 50,
2117 100.00000000000000 },
2118};
2119
2120// Test function for n=10, m=50.
2121template <typename Tp>
2122void test039()
2123{
2124 const Tp eps = std::numeric_limits<Tp>::epsilon();
2125 Tp max_abs_diff = -Tp(1);
2126 Tp max_abs_frac = -Tp(1);
2127 unsigned int num_datum = sizeof(data039)
2128 / sizeof(testcase_assoc_laguerre<double>);
2129 for (unsigned int i = 0; i < num_datum; ++i)
2130 {
2131 const Tp f = std::tr1::assoc_laguerre(Tp(data039[i].n), Tp(data039[i].m),
2132 Tp(data039[i].x));
2133 const Tp f0 = data039[i].f0;
2134 const Tp diff = f - f0;
2135 if (std::abs(diff) > max_abs_diff)
2136 max_abs_diff = std::abs(diff);
2137 if (std::abs(f0) > Tp(10) * eps
2138 && std::abs(f) > Tp(10) * eps)
2139 {
2140 const Tp frac = diff / f0;
2141 if (std::abs(frac) > max_abs_frac)
2142 max_abs_frac = std::abs(frac);
2143 }
2144 }
2145 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
2146}
2147
2148// Test data for n=10, m=100.
2149testcase_assoc_laguerre<double> data040[] = {
2150 { 46897636623981.000, 10, 100,
2151 0.0000000000000000 },
2152 { 16444031323272.084, 10, 100,
2153 10.000000000000000 },
2154 { 5020343986463.5391, 10, 100,
2155 20.000000000000000 },
2156 { 1270977490645.2859, 10, 100,
2157 30.000000000000000 },
2158 { 244835756822.62262, 10, 100,
2159 40.000000000000000 },
2160 { 29786827693.962963, 10, 100,
2161 50.000000000000000 },
2162 { 1127612095.2857144, 10, 100,
2163 60.000000000000000 },
2164 { -66370555.419753075, 10, 100,
2165 70.000000000000000 },
2166 { 10420852.957671957, 10, 100,
2167 80.000000000000000 },
2168 { -3373097.5714285718, 10, 100,
2169 90.000000000000000 },
2170 { 2065423.6807760142, 10, 100,
2171 100.00000000000000 },
2172};
2173
2174// Test function for n=10, m=100.
2175template <typename Tp>
2176void test040()
2177{
2178 const Tp eps = std::numeric_limits<Tp>::epsilon();
2179 Tp max_abs_diff = -Tp(1);
2180 Tp max_abs_frac = -Tp(1);
2181 unsigned int num_datum = sizeof(data040)
2182 / sizeof(testcase_assoc_laguerre<double>);
2183 for (unsigned int i = 0; i < num_datum; ++i)
2184 {
2185 const Tp f = std::tr1::assoc_laguerre(Tp(data040[i].n), Tp(data040[i].m),
2186 Tp(data040[i].x));
2187 const Tp f0 = data040[i].f0;
2188 const Tp diff = f - f0;
2189 if (std::abs(diff) > max_abs_diff)
2190 max_abs_diff = std::abs(diff);
2191 if (std::abs(f0) > Tp(10) * eps
2192 && std::abs(f) > Tp(10) * eps)
2193 {
2194 const Tp frac = diff / f0;
2195 if (std::abs(frac) > max_abs_frac)
2196 max_abs_frac = std::abs(frac);
2197 }
2198 }
2199 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2200}
2201
2202// Test data for n=20, m=0.
2203testcase_assoc_laguerre<double> data041[] = {
2204 { 1.0000000000000000, 20, 0,
2205 0.0000000000000000 },
2206 { -11.961333867812119, 20, 0,
2207 10.000000000000000 },
2208 { 2829.4728613531738, 20, 0,
2209 20.000000000000000 },
2210 { -18439.424502520938, 20, 0,
2211 30.000000000000000 },
2212 { 24799805.877530701, 20, 0,
2213 40.000000000000000 },
2214 { 7551960453.7672529, 20, 0,
2215 50.000000000000000 },
2216 { -1379223608444.9155, 20, 0,
2217 60.000000000000000 },
2218 { 165423821874449.94, 20, 0,
2219 70.000000000000000 },
2220 { 29500368536981676., 20, 0,
2221 80.000000000000000 },
2222 { 1.1292309514432899e+18, 20, 0,
2223 90.000000000000000 },
2224 { 2.2061882785931735e+19, 20, 0,
2225 100.00000000000000 },
2226};
2227
2228// Test function for n=20, m=0.
2229template <typename Tp>
2230void test041()
2231{
2232 const Tp eps = std::numeric_limits<Tp>::epsilon();
2233 Tp max_abs_diff = -Tp(1);
2234 Tp max_abs_frac = -Tp(1);
2235 unsigned int num_datum = sizeof(data041)
2236 / sizeof(testcase_assoc_laguerre<double>);
2237 for (unsigned int i = 0; i < num_datum; ++i)
2238 {
2239 const Tp f = std::tr1::assoc_laguerre(Tp(data041[i].n), Tp(data041[i].m),
2240 Tp(data041[i].x));
2241 const Tp f0 = data041[i].f0;
2242 const Tp diff = f - f0;
2243 if (std::abs(diff) > max_abs_diff)
2244 max_abs_diff = std::abs(diff);
2245 if (std::abs(f0) > Tp(10) * eps
2246 && std::abs(f) > Tp(10) * eps)
2247 {
2248 const Tp frac = diff / f0;
2249 if (std::abs(frac) > max_abs_frac)
2250 max_abs_frac = std::abs(frac);
2251 }
2252 }
2253 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2254}
2255
2256// Test data for n=20, m=1.
2257testcase_assoc_laguerre<double> data042[] = {
2258 { 21.000000000000000, 20, 1,
2259 0.0000000000000000 },
2260 { 19.900488129734079, 20, 1,
2261 10.000000000000000 },
2262 { 2208.0318569557589, 20, 1,
2263 20.000000000000000 },
2264 { 263690.96303121914, 20, 1,
2265 30.000000000000000 },
2266 { 40667285.630564235, 20, 1,
2267 40.000000000000000 },
2268 { 1737442572.8115418, 20, 1,
2269 50.000000000000000 },
2270 { -588280953643.28125, 20, 1,
2271 60.000000000000000 },
2272 { 45617733778241.359, 20, 1,
2273 70.000000000000000 },
2274 { 17293487114876860., 20, 1,
2275 80.000000000000000 },
2276 { 7.6219135858585024e+17, 20, 1,
2277 90.000000000000000 },
2278 { 1.6037288204336759e+19, 20, 1,
2279 100.00000000000000 },
2280};
2281
2282// Test function for n=20, m=1.
2283template <typename Tp>
2284void test042()
2285{
2286 const Tp eps = std::numeric_limits<Tp>::epsilon();
2287 Tp max_abs_diff = -Tp(1);
2288 Tp max_abs_frac = -Tp(1);
2289 unsigned int num_datum = sizeof(data042)
2290 / sizeof(testcase_assoc_laguerre<double>);
2291 for (unsigned int i = 0; i < num_datum; ++i)
2292 {
2293 const Tp f = std::tr1::assoc_laguerre(Tp(data042[i].n), Tp(data042[i].m),
2294 Tp(data042[i].x));
2295 const Tp f0 = data042[i].f0;
2296 const Tp diff = f - f0;
2297 if (std::abs(diff) > max_abs_diff)
2298 max_abs_diff = std::abs(diff);
2299 if (std::abs(f0) > Tp(10) * eps
2300 && std::abs(f) > Tp(10) * eps)
2301 {
2302 const Tp frac = diff / f0;
2303 if (std::abs(frac) > max_abs_frac)
2304 max_abs_frac = std::abs(frac);
2305 }
2306 }
2307 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2308}
2309
2310// Test data for n=20, m=2.
2311testcase_assoc_laguerre<double> data043[] = {
2312 { 231.00000000000003, 20, 2,
2313 0.0000000000000000 },
2314 { 47.009338065112935, 20, 2,
2315 10.000000000000000 },
2316 { -652.51305461728566, 20, 2,
2317 20.000000000000000 },
2318 { 285388.25895069109, 20, 2,
2319 30.000000000000000 },
2320 { 28664069.685624726, 20, 2,
2321 40.000000000000000 },
2322 { -1399631966.3144732, 20, 2,
2323 50.000000000000000 },
2324 { -115357373248.28198, 20, 2,
2325 60.000000000000000 },
2326 { -3357730872975.8545, 20, 2,
2327 70.000000000000000 },
2328 { 9765808962855122.0, 20, 2,
2329 80.000000000000000 },
2330 { 5.0717292945559181e+17, 20, 2,
2331 90.000000000000000 },
2332 { 1.1564665701334458e+19, 20, 2,
2333 100.00000000000000 },
2334};
2335
2336// Test function for n=20, m=2.
2337template <typename Tp>
2338void test043()
2339{
2340 const Tp eps = std::numeric_limits<Tp>::epsilon();
2341 Tp max_abs_diff = -Tp(1);
2342 Tp max_abs_frac = -Tp(1);
2343 unsigned int num_datum = sizeof(data043)
2344 / sizeof(testcase_assoc_laguerre<double>);
2345 for (unsigned int i = 0; i < num_datum; ++i)
2346 {
2347 const Tp f = std::tr1::assoc_laguerre(Tp(data043[i].n), Tp(data043[i].m),
2348 Tp(data043[i].x));
2349 const Tp f0 = data043[i].f0;
2350 const Tp diff = f - f0;
2351 if (std::abs(diff) > max_abs_diff)
2352 max_abs_diff = std::abs(diff);
2353 if (std::abs(f0) > Tp(10) * eps
2354 && std::abs(f) > Tp(10) * eps)
2355 {
2356 const Tp frac = diff / f0;
2357 if (std::abs(frac) > max_abs_frac)
2358 max_abs_frac = std::abs(frac);
2359 }
2360 }
2361 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2362}
2363
2364// Test data for n=20, m=5.
2365testcase_assoc_laguerre<double> data044[] = {
2366 { 53130.000000000000, 20, 5,
2367 0.0000000000000000 },
2368 { -158.69554500944145, 20, 5,
2369 10.000000000000000 },
2370 { 334.08012288038969, 20, 5,
2371 20.000000000000000 },
2372 { -198372.47662554169, 20, 5,
2373 30.000000000000000 },
2374 { -13627144.088579427, 20, 5,
2375 40.000000000000000 },
2376 { -780579985.44731593, 20, 5,
2377 50.000000000000000 },
2378 { 116648634237.73526, 20, 5,
2379 60.000000000000000 },
2380 { -12347348707739.742, 20, 5,
2381 70.000000000000000 },
2382 { 1199516248034090.8, 20, 5,
2383 80.000000000000000 },
2384 { 1.3451503195078531e+17, 20, 5,
2385 90.000000000000000 },
2386 { 4.1058904276111483e+18, 20, 5,
2387 100.00000000000000 },
2388};
2389
2390// Test function for n=20, m=5.
2391template <typename Tp>
2392void test044()
2393{
2394 const Tp eps = std::numeric_limits<Tp>::epsilon();
2395 Tp max_abs_diff = -Tp(1);
2396 Tp max_abs_frac = -Tp(1);
2397 unsigned int num_datum = sizeof(data044)
2398 / sizeof(testcase_assoc_laguerre<double>);
2399 for (unsigned int i = 0; i < num_datum; ++i)
2400 {
2401 const Tp f = std::tr1::assoc_laguerre(Tp(data044[i].n), Tp(data044[i].m),
2402 Tp(data044[i].x));
2403 const Tp f0 = data044[i].f0;
2404 const Tp diff = f - f0;
2405 if (std::abs(diff) > max_abs_diff)
2406 max_abs_diff = std::abs(diff);
2407 if (std::abs(f0) > Tp(10) * eps
2408 && std::abs(f) > Tp(10) * eps)
2409 {
2410 const Tp frac = diff / f0;
2411 if (std::abs(frac) > max_abs_frac)
2412 max_abs_frac = std::abs(frac);
2413 }
2414 }
2415 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2416}
2417
2418// Test data for n=20, m=10.
2419testcase_assoc_laguerre<double> data045[] = {
2420 { 30045015.000000000, 20, 10,
2421 0.0000000000000000 },
2422 { -1755.6226861258590, 20, 10,
2423 10.000000000000000 },
2424 { -9081.6726644737901, 20, 10,
2425 20.000000000000000 },
2426 { 95771.650912113109, 20, 10,
2427 30.000000000000000 },
2428 { 5089151.9272779226, 20, 10,
2429 40.000000000000000 },
2430 { 97400399.450206712, 20, 10,
2431 50.000000000000000 },
2432 { -16009352450.477026, 20, 10,
2433 60.000000000000000 },
2434 { 842271286905.01038, 20, 10,
2435 70.000000000000000 },
2436 { -79901725466796.938, 20, 10,
2437 80.000000000000000 },
2438 { 7944103675858638.0, 20, 10,
2439 90.000000000000000 },
2440 { 5.7429821893388288e+17, 20, 10,
2441 100.00000000000000 },
2442};
2443
2444// Test function for n=20, m=10.
2445template <typename Tp>
2446void test045()
2447{
2448 const Tp eps = std::numeric_limits<Tp>::epsilon();
2449 Tp max_abs_diff = -Tp(1);
2450 Tp max_abs_frac = -Tp(1);
2451 unsigned int num_datum = sizeof(data045)
2452 / sizeof(testcase_assoc_laguerre<double>);
2453 for (unsigned int i = 0; i < num_datum; ++i)
2454 {
2455 const Tp f = std::tr1::assoc_laguerre(Tp(data045[i].n), Tp(data045[i].m),
2456 Tp(data045[i].x));
2457 const Tp f0 = data045[i].f0;
2458 const Tp diff = f - f0;
2459 if (std::abs(diff) > max_abs_diff)
2460 max_abs_diff = std::abs(diff);
2461 if (std::abs(f0) > Tp(10) * eps
2462 && std::abs(f) > Tp(10) * eps)
2463 {
2464 const Tp frac = diff / f0;
2465 if (std::abs(frac) > max_abs_frac)
2466 max_abs_frac = std::abs(frac);
2467 }
2468 }
2469 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2470}
2471
2472// Test data for n=20, m=20.
2473testcase_assoc_laguerre<double> data046[] = {
2474 { 137846528819.99994, 20, 20,
2475 0.0000000000000000 },
2476 { -136976.49571333214, 20, 20,
2477 10.000000000000000 },
2478 { 113878.49908041637, 20, 20,
2479 20.000000000000000 },
2480 { -342529.21778796182, 20, 20,
2481 30.000000000000000 },
2482 { -350112.66981443466, 20, 20,
2483 40.000000000000000 },
2484 { -10791735.172977794, 20, 20,
2485 50.000000000000000 },
2486 { -1038073940.0811402, 20, 20,
2487 60.000000000000000 },
2488 { 667312550.63616371, 20, 20,
2489 70.000000000000000 },
2490 { 741537869902.29028, 20, 20,
2491 80.000000000000000 },
2492 { -32378376755737.418, 20, 20,
2493 90.000000000000000 },
2494 { -601760332167934.75, 20, 20,
2495 100.00000000000000 },
2496};
2497
2498// Test function for n=20, m=20.
2499template <typename Tp>
2500void test046()
2501{
2502 const Tp eps = std::numeric_limits<Tp>::epsilon();
2503 Tp max_abs_diff = -Tp(1);
2504 Tp max_abs_frac = -Tp(1);
2505 unsigned int num_datum = sizeof(data046)
2506 / sizeof(testcase_assoc_laguerre<double>);
2507 for (unsigned int i = 0; i < num_datum; ++i)
2508 {
2509 const Tp f = std::tr1::assoc_laguerre(Tp(data046[i].n), Tp(data046[i].m),
2510 Tp(data046[i].x));
2511 const Tp f0 = data046[i].f0;
2512 const Tp diff = f - f0;
2513 if (std::abs(diff) > max_abs_diff)
2514 max_abs_diff = std::abs(diff);
2515 if (std::abs(f0) > Tp(10) * eps
2516 && std::abs(f) > Tp(10) * eps)
2517 {
2518 const Tp frac = diff / f0;
2519 if (std::abs(frac) > max_abs_frac)
2520 max_abs_frac = std::abs(frac);
2521 }
2522 }
2523 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
2524}
2525
2526// Test data for n=20, m=50.
2527testcase_assoc_laguerre<double> data047[] = {
2528 { 1.6188460366265789e+17, 20, 50,
2529 0.0000000000000000 },
2530 { 1599011936804291.5, 20, 50,
2531 10.000000000000000 },
2532 { -131273880831.42412, 20, 50,
2533 20.000000000000000 },
2534 { -3133213093.6903501, 20, 50,
2535 30.000000000000000 },
2536 { -213935628.04985175, 20, 50,
2537 40.000000000000000 },
2538 { -47375578.495921209, 20, 50,
2539 50.000000000000000 },
2540 { -115731015.14034875, 20, 50,
2541 60.000000000000000 },
2542 { -737415147.29420292, 20, 50,
2543 70.000000000000000 },
2544 { -2123455626.8621781, 20, 50,
2545 80.000000000000000 },
2546 { 29801266858.608925, 20, 50,
2547 90.000000000000000 },
2548 { -132886631026.82561, 20, 50,
2549 100.00000000000000 },
2550};
2551
2552// Test function for n=20, m=50.
2553template <typename Tp>
2554void test047()
2555{
2556 const Tp eps = std::numeric_limits<Tp>::epsilon();
2557 Tp max_abs_diff = -Tp(1);
2558 Tp max_abs_frac = -Tp(1);
2559 unsigned int num_datum = sizeof(data047)
2560 / sizeof(testcase_assoc_laguerre<double>);
2561 for (unsigned int i = 0; i < num_datum; ++i)
2562 {
2563 const Tp f = std::tr1::assoc_laguerre(Tp(data047[i].n), Tp(data047[i].m),
2564 Tp(data047[i].x));
2565 const Tp f0 = data047[i].f0;
2566 const Tp diff = f - f0;
2567 if (std::abs(diff) > max_abs_diff)
2568 max_abs_diff = std::abs(diff);
2569 if (std::abs(f0) > Tp(10) * eps
2570 && std::abs(f) > Tp(10) * eps)
2571 {
2572 const Tp frac = diff / f0;
2573 if (std::abs(frac) > max_abs_frac)
2574 max_abs_frac = std::abs(frac);
2575 }
2576 }
2577 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
2578}
2579
2580// Test data for n=20, m=100.
2581testcase_assoc_laguerre<double> data048[] = {
2582 { 2.9462227291176643e+22, 20, 100,
2583 0.0000000000000000 },
2584 { 3.5777890748701244e+21, 20, 100,
2585 10.000000000000000 },
2586 { 3.1584925521456765e+20, 20, 100,
2587 20.000000000000000 },
2588 { 1.7389599388424860e+19, 20, 100,
2589 30.000000000000000 },
2590 { 4.1401342745980646e+17, 20, 100,
2591 40.000000000000000 },
2592 { -79359706102062.672, 20, 100,
2593 50.000000000000000 },
2594 { 22736203650743.145, 20, 100,
2595 60.000000000000000 },
2596 { 65679006380.095215, 20, 100,
2597 70.000000000000000 },
2598 { -236263257610.77969, 20, 100,
2599 80.000000000000000 },
2600 { -38072644585.303085, 20, 100,
2601 90.000000000000000 },
2602 { 68236474365.173950, 20, 100,
2603 100.00000000000000 },
2604};
2605
2606// Test function for n=20, m=100.
2607template <typename Tp>
2608void test048()
2609{
2610 const Tp eps = std::numeric_limits<Tp>::epsilon();
2611 Tp max_abs_diff = -Tp(1);
2612 Tp max_abs_frac = -Tp(1);
2613 unsigned int num_datum = sizeof(data048)
2614 / sizeof(testcase_assoc_laguerre<double>);
2615 for (unsigned int i = 0; i < num_datum; ++i)
2616 {
2617 const Tp f = std::tr1::assoc_laguerre(Tp(data048[i].n), Tp(data048[i].m),
2618 Tp(data048[i].x));
2619 const Tp f0 = data048[i].f0;
2620 const Tp diff = f - f0;
2621 if (std::abs(diff) > max_abs_diff)
2622 max_abs_diff = std::abs(diff);
2623 if (std::abs(f0) > Tp(10) * eps
2624 && std::abs(f) > Tp(10) * eps)
2625 {
2626 const Tp frac = diff / f0;
2627 if (std::abs(frac) > max_abs_frac)
2628 max_abs_frac = std::abs(frac);
2629 }
2630 }
2631 VERIFY(max_abs_frac < Tp(2.5000000000000015e-12));
2632}
2633
2634// Test data for n=50, m=0.
2635testcase_assoc_laguerre<double> data049[] = {
2636 { 1.0000000000000000, 50, 0,
2637 0.0000000000000000 },
2638 { 17.534183446338233, 50, 0,
2639 10.000000000000000 },
2640 { 980.26961889790766, 50, 0,
2641 20.000000000000000 },
2642 { 293000.50735962350, 50, 0,
2643 30.000000000000000 },
2644 { -14896937.968694847, 50, 0,
2645 40.000000000000000 },
2646 { 2513677852.6916885, 50, 0,
2647 50.000000000000000 },
2648 { -883876565337.99207, 50, 0,
2649 60.000000000000000 },
2650 { -80967880733583.219, 50, 0,
2651 70.000000000000000 },
2652 { -8217471769564850.0, 50, 0,
2653 80.000000000000000 },
2654 { -2.1140031308048906e+18, 50, 0,
2655 90.000000000000000 },
2656 { -3.9710103487094673e+20, 50, 0,
2657 100.00000000000000 },
2658};
2659
2660// Test function for n=50, m=0.
2661template <typename Tp>
2662void test049()
2663{
2664 const Tp eps = std::numeric_limits<Tp>::epsilon();
2665 Tp max_abs_diff = -Tp(1);
2666 Tp max_abs_frac = -Tp(1);
2667 unsigned int num_datum = sizeof(data049)
2668 / sizeof(testcase_assoc_laguerre<double>);
2669 for (unsigned int i = 0; i < num_datum; ++i)
2670 {
2671 const Tp f = std::tr1::assoc_laguerre(Tp(data049[i].n), Tp(data049[i].m),
2672 Tp(data049[i].x));
2673 const Tp f0 = data049[i].f0;
2674 const Tp diff = f - f0;
2675 if (std::abs(diff) > max_abs_diff)
2676 max_abs_diff = std::abs(diff);
2677 if (std::abs(f0) > Tp(10) * eps
2678 && std::abs(f) > Tp(10) * eps)
2679 {
2680 const Tp frac = diff / f0;
2681 if (std::abs(frac) > max_abs_frac)
2682 max_abs_frac = std::abs(frac);
2683 }
2684 }
2685 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2686}
2687
2688// Test data for n=50, m=1.
2689testcase_assoc_laguerre<double> data050[] = {
2690 { 51.000000000000021, 50, 1,
2691 0.0000000000000000 },
2692 { 1.4214573271640045, 50, 1,
2693 10.000000000000000 },
2694 { -2574.8072295127863, 50, 1,
2695 20.000000000000000 },
2696 { 35846.479728359256, 50, 1,
2697 30.000000000000000 },
2698 { -48263698.768318526, 50, 1,
2699 40.000000000000000 },
2700 { 6161525870.2738571, 50, 1,
2701 50.000000000000000 },
2702 { -382655486658.47101, 50, 1,
2703 60.000000000000000 },
2704 { -109635579833241.69, 50, 1,
2705 70.000000000000000 },
2706 { -14623805817283476., 50, 1,
2707 80.000000000000000 },
2708 { -2.0666847190878118e+18, 50, 1,
2709 90.000000000000000 },
2710 { -1.4385187953997626e+20, 50, 1,
2711 100.00000000000000 },
2712};
2713
2714// Test function for n=50, m=1.
2715template <typename Tp>
2716void test050()
2717{
2718 const Tp eps = std::numeric_limits<Tp>::epsilon();
2719 Tp max_abs_diff = -Tp(1);
2720 Tp max_abs_frac = -Tp(1);
2721 unsigned int num_datum = sizeof(data050)
2722 / sizeof(testcase_assoc_laguerre<double>);
2723 for (unsigned int i = 0; i < num_datum; ++i)
2724 {
2725 const Tp f = std::tr1::assoc_laguerre(Tp(data050[i].n), Tp(data050[i].m),
2726 Tp(data050[i].x));
2727 const Tp f0 = data050[i].f0;
2728 const Tp diff = f - f0;
2729 if (std::abs(diff) > max_abs_diff)
2730 max_abs_diff = std::abs(diff);
2731 if (std::abs(f0) > Tp(10) * eps
2732 && std::abs(f) > Tp(10) * eps)
2733 {
2734 const Tp frac = diff / f0;
2735 if (std::abs(frac) > max_abs_frac)
2736 max_abs_frac = std::abs(frac);
2737 }
2738 }
2739 VERIFY(max_abs_frac < Tp(5.0000000000000029e-12));
2740}
2741
2742// Test data for n=50, m=2.
2743testcase_assoc_laguerre<double> data051[] = {
2744 { 1326.0000000000000, 50, 2,
2745 0.0000000000000000 },
2746 { -87.860732516444671, 50, 2,
2747 10.000000000000000 },
2748 { -5203.2351191780890, 50, 2,
2749 20.000000000000000 },
2750 { -461059.50012538873, 50, 2,
2751 30.000000000000000 },
2752 { -30476695.327440601, 50, 2,
2753 40.000000000000000 },
2754 { 3720804977.9338136, 50, 2,
2755 50.000000000000000 },
2756 { 362262002434.51440, 50, 2,
2757 60.000000000000000 },
2758 { -52210917867820.273, 50, 2,
2759 70.000000000000000 },
2760 { -9567965136901918.0, 50, 2,
2761 80.000000000000000 },
2762 { -8.9171277517712806e+17, 50, 2,
2763 90.000000000000000 },
2764 { 5.7231129448807039e+19, 50, 2,
2765 100.00000000000000 },
2766};
2767
2768// Test function for n=50, m=2.
2769template <typename Tp>
2770void test051()
2771{
2772 const Tp eps = std::numeric_limits<Tp>::epsilon();
2773 Tp max_abs_diff = -Tp(1);
2774 Tp max_abs_frac = -Tp(1);
2775 unsigned int num_datum = sizeof(data051)
2776 / sizeof(testcase_assoc_laguerre<double>);
2777 for (unsigned int i = 0; i < num_datum; ++i)
2778 {
2779 const Tp f = std::tr1::assoc_laguerre(Tp(data051[i].n), Tp(data051[i].m),
2780 Tp(data051[i].x));
2781 const Tp f0 = data051[i].f0;
2782 const Tp diff = f - f0;
2783 if (std::abs(diff) > max_abs_diff)
2784 max_abs_diff = std::abs(diff);
2785 if (std::abs(f0) > Tp(10) * eps
2786 && std::abs(f) > Tp(10) * eps)
2787 {
2788 const Tp frac = diff / f0;
2789 if (std::abs(frac) > max_abs_frac)
2790 max_abs_frac = std::abs(frac);
2791 }
2792 }
2793 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2794}
2795
2796// Test data for n=50, m=5.
2797testcase_assoc_laguerre<double> data052[] = {
2798 { 3478761.0000000000, 50, 5,
2799 0.0000000000000000 },
2800 { 1055.8381917651493, 50, 5,
2801 10.000000000000000 },
2802 { 15264.646660345048, 50, 5,
2803 20.000000000000000 },
2804 { 1229651.8966600855, 50, 5,
2805 30.000000000000000 },
2806 { 39270451.823656857, 50, 5,
2807 40.000000000000000 },
2808 { -4424062601.1152067, 50, 5,
2809 50.000000000000000 },
2810 { -186017434284.19220, 50, 5,
2811 60.000000000000000 },
2812 { 50972853949302.602, 50, 5,
2813 70.000000000000000 },
2814 { 6530702754012518.0, 50, 5,
2815 80.000000000000000 },
2816 { 6.8387592714678016e+17, 50, 5,
2817 90.000000000000000 },
2818 { 3.9198742504338366e+19, 50, 5,
2819 100.00000000000000 },
2820};
2821
2822// Test function for n=50, m=5.
2823template <typename Tp>
2824void test052()
2825{
2826 const Tp eps = std::numeric_limits<Tp>::epsilon();
2827 Tp max_abs_diff = -Tp(1);
2828 Tp max_abs_frac = -Tp(1);
2829 unsigned int num_datum = sizeof(data052)
2830 / sizeof(testcase_assoc_laguerre<double>);
2831 for (unsigned int i = 0; i < num_datum; ++i)
2832 {
2833 const Tp f = std::tr1::assoc_laguerre(Tp(data052[i].n), Tp(data052[i].m),
2834 Tp(data052[i].x));
2835 const Tp f0 = data052[i].f0;
2836 const Tp diff = f - f0;
2837 if (std::abs(diff) > max_abs_diff)
2838 max_abs_diff = std::abs(diff);
2839 if (std::abs(f0) > Tp(10) * eps
2840 && std::abs(f) > Tp(10) * eps)
2841 {
2842 const Tp frac = diff / f0;
2843 if (std::abs(frac) > max_abs_frac)
2844 max_abs_frac = std::abs(frac);
2845 }
2846 }
2847 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2848}
2849
2850// Test data for n=50, m=10.
2851testcase_assoc_laguerre<double> data053[] = {
2852 { 75394027565.999985, 50, 10,
2853 0.0000000000000000 },
2854 { 91833.924098770134, 50, 10,
2855 10.000000000000000 },
2856 { 330501.87929778261, 50, 10,
2857 20.000000000000000 },
2858 { 3625088.1635972545, 50, 10,
2859 30.000000000000000 },
2860 { 213954727.28632003, 50, 10,
2861 40.000000000000000 },
2862 { -9381006937.7517643, 50, 10,
2863 50.000000000000000 },
2864 { 535333683777.48627, 50, 10,
2865 60.000000000000000 },
2866 { 18824406573722.156, 50, 10,
2867 70.000000000000000 },
2868 { -533858276780012.81, 50, 10,
2869 80.000000000000000 },
2870 { -52995774666704024., 50, 10,
2871 90.000000000000000 },
2872 { 6.0504182862448855e+18, 50, 10,
2873 100.00000000000000 },
2874};
2875
2876// Test function for n=50, m=10.
2877template <typename Tp>
2878void test053()
2879{
2880 const Tp eps = std::numeric_limits<Tp>::epsilon();
2881 Tp max_abs_diff = -Tp(1);
2882 Tp max_abs_frac = -Tp(1);
2883 unsigned int num_datum = sizeof(data053)
2884 / sizeof(testcase_assoc_laguerre<double>);
2885 for (unsigned int i = 0; i < num_datum; ++i)
2886 {
2887 const Tp f = std::tr1::assoc_laguerre(Tp(data053[i].n), Tp(data053[i].m),
2888 Tp(data053[i].x));
2889 const Tp f0 = data053[i].f0;
2890 const Tp diff = f - f0;
2891 if (std::abs(diff) > max_abs_diff)
2892 max_abs_diff = std::abs(diff);
2893 if (std::abs(f0) > Tp(10) * eps
2894 && std::abs(f) > Tp(10) * eps)
2895 {
2896 const Tp frac = diff / f0;
2897 if (std::abs(frac) > max_abs_frac)
2898 max_abs_frac = std::abs(frac);
2899 }
2900 }
2901 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2902}
2903
2904// Test data for n=50, m=20.
2905testcase_assoc_laguerre<double> data054[] = {
2906 { 1.6188460366265779e+17, 50, 20,
2907 0.0000000000000000 },
2908 { -307637087.25169420, 50, 20,
2909 10.000000000000000 },
2910 { 12524651.102974579, 50, 20,
2911 20.000000000000000 },
2912 { -315460483.86210549, 50, 20,
2913 30.000000000000000 },
2914 { -1889683587.3459976, 50, 20,
2915 40.000000000000000 },
2916 { 37457044404.200340, 50, 20,
2917 50.000000000000000 },
2918 { -843831858224.71826, 50, 20,
2919 60.000000000000000 },
2920 { -92231643172.313248, 50, 20,
2921 70.000000000000000 },
2922 { 904211757769501.25, 50, 20,
2923 80.000000000000000 },
2924 { 46508193600283288., 50, 20,
2925 90.000000000000000 },
2926 { 2.3216887928162714e+18, 50, 20,
2927 100.00000000000000 },
2928};
2929
2930// Test function for n=50, m=20.
2931template <typename Tp>
2932void test054()
2933{
2934 const Tp eps = std::numeric_limits<Tp>::epsilon();
2935 Tp max_abs_diff = -Tp(1);
2936 Tp max_abs_frac = -Tp(1);
2937 unsigned int num_datum = sizeof(data054)
2938 / sizeof(testcase_assoc_laguerre<double>);
2939 for (unsigned int i = 0; i < num_datum; ++i)
2940 {
2941 const Tp f = std::tr1::assoc_laguerre(Tp(data054[i].n), Tp(data054[i].m),
2942 Tp(data054[i].x));
2943 const Tp f0 = data054[i].f0;
2944 const Tp diff = f - f0;
2945 if (std::abs(diff) > max_abs_diff)
2946 max_abs_diff = std::abs(diff);
2947 if (std::abs(f0) > Tp(10) * eps
2948 && std::abs(f) > Tp(10) * eps)
2949 {
2950 const Tp frac = diff / f0;
2951 if (std::abs(frac) > max_abs_frac)
2952 max_abs_frac = std::abs(frac);
2953 }
2954 }
2955 VERIFY(max_abs_frac < Tp(2.5000000000000015e-12));
2956}
2957
2958// Test data for n=50, m=50.
2959testcase_assoc_laguerre<double> data055[] = {
2960 { 1.0089134454556417e+29, 50, 50,
2961 0.0000000000000000 },
2962 { 1.3822795753070569e+23, 50, 50,
2963 10.000000000000000 },
2964 { 95817260381628416., 50, 50,
2965 20.000000000000000 },
2966 { -910798580856013.88, 50, 50,
2967 30.000000000000000 },
2968 { 50513254049166.719, 50, 50,
2969 40.000000000000000 },
2970 { 84159703903349.859, 50, 50,
2971 50.000000000000000 },
2972 { -138805244691822.69, 50, 50,
2973 60.000000000000000 },
2974 { 181046391269246.25, 50, 50,
2975 70.000000000000000 },
2976 { 2086884905317107.2, 50, 50,
2977 80.000000000000000 },
2978 { -2765620139862432.5, 50, 50,
2979 90.000000000000000 },
2980 { -1.3706751678146291e+17, 50, 50,
2981 100.00000000000000 },
2982};
2983
2984// Test function for n=50, m=50.
2985template <typename Tp>
2986void test055()
2987{
2988 const Tp eps = std::numeric_limits<Tp>::epsilon();
2989 Tp max_abs_diff = -Tp(1);
2990 Tp max_abs_frac = -Tp(1);
2991 unsigned int num_datum = sizeof(data055)
2992 / sizeof(testcase_assoc_laguerre<double>);
2993 for (unsigned int i = 0; i < num_datum; ++i)
2994 {
2995 const Tp f = std::tr1::assoc_laguerre(Tp(data055[i].n), Tp(data055[i].m),
2996 Tp(data055[i].x));
2997 const Tp f0 = data055[i].f0;
2998 const Tp diff = f - f0;
2999 if (std::abs(diff) > max_abs_diff)
3000 max_abs_diff = std::abs(diff);
3001 if (std::abs(f0) > Tp(10) * eps
3002 && std::abs(f) > Tp(10) * eps)
3003 {
3004 const Tp frac = diff / f0;
3005 if (std::abs(frac) > max_abs_frac)
3006 max_abs_frac = std::abs(frac);
3007 }
3008 }
3009 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
3010}
3011
3012// Test data for n=50, m=100.
3013testcase_assoc_laguerre<double> data056[] = {
3014 { 2.0128660909731929e+40, 50, 100,
3015 0.0000000000000000 },
3016 { 9.3675094807695474e+37, 50, 100,
3017 10.000000000000000 },
3018 { 1.3009321481877196e+35, 50, 100,
3019 20.000000000000000 },
3020 { 7.3720026893233823e+30, 50, 100,
3021 30.000000000000000 },
3022 { -6.0824679079634607e+25, 50, 100,
3023 40.000000000000000 },
3024 { -6.0053188793543624e+23, 50, 100,
3025 50.000000000000000 },
3026 { 1.4178129287264701e+22, 50, 100,
3027 60.000000000000000 },
3028 { -5.4652099341566765e+20, 50, 100,
3029 70.000000000000000 },
3030 { -1.0817271759263398e+20, 50, 100,
3031 80.000000000000000 },
3032 { 3.8058734007924187e+19, 50, 100,
3033 90.000000000000000 },
3034 { 4.7439240848028353e+19, 50, 100,
3035 100.00000000000000 },
3036};
3037
3038// Test function for n=50, m=100.
3039template <typename Tp>
3040void test056()
3041{
3042 const Tp eps = std::numeric_limits<Tp>::epsilon();
3043 Tp max_abs_diff = -Tp(1);
3044 Tp max_abs_frac = -Tp(1);
3045 unsigned int num_datum = sizeof(data056)
3046 / sizeof(testcase_assoc_laguerre<double>);
3047 for (unsigned int i = 0; i < num_datum; ++i)
3048 {
3049 const Tp f = std::tr1::assoc_laguerre(Tp(data056[i].n), Tp(data056[i].m),
3050 Tp(data056[i].x));
3051 const Tp f0 = data056[i].f0;
3052 const Tp diff = f - f0;
3053 if (std::abs(diff) > max_abs_diff)
3054 max_abs_diff = std::abs(diff);
3055 if (std::abs(f0) > Tp(10) * eps
3056 && std::abs(f) > Tp(10) * eps)
3057 {
3058 const Tp frac = diff / f0;
3059 if (std::abs(frac) > max_abs_frac)
3060 max_abs_frac = std::abs(frac);
3061 }
3062 }
3063 VERIFY(max_abs_frac < Tp(2.5000000000000015e-12));
3064}
3065
3066// Test data for n=100, m=0.
3067testcase_assoc_laguerre<double> data057[] = {
3068 { 1.0000000000000000, 100, 0,
3069 0.0000000000000000 },
3070 { 13.277662844303402, 100, 0,
3071 10.000000000000000 },
3072 { 1854.0367283243393, 100, 0,
3073 20.000000000000000 },
3074 { 170141.86987046539, 100, 0,
3075 30.000000000000000 },
3076 { -7272442.3156007063, 100, 0,
3077 40.000000000000000 },
3078 { 4847420871.2690468, 100, 0,
3079 50.000000000000000 },
3080 { 693492765740.29736, 100, 0,
3081 60.000000000000000 },
3082 { 17125518672239.707, 100, 0,
3083 70.000000000000000 },
3084 { -13763178176383754., 100, 0,
3085 80.000000000000000 },
3086 { 2.1307220490380198e+18, 100, 0,
3087 90.000000000000000 },
3088 { -2.6292260693068920e+20, 100, 0,
3089 100.00000000000000 },
3090};
3091
3092// Test function for n=100, m=0.
3093template <typename Tp>
3094void test057()
3095{
3096 const Tp eps = std::numeric_limits<Tp>::epsilon();
3097 Tp max_abs_diff = -Tp(1);
3098 Tp max_abs_frac = -Tp(1);
3099 unsigned int num_datum = sizeof(data057)
3100 / sizeof(testcase_assoc_laguerre<double>);
3101 for (unsigned int i = 0; i < num_datum; ++i)
3102 {
3103 const Tp f = std::tr1::assoc_laguerre(Tp(data057[i].n), Tp(data057[i].m),
3104 Tp(data057[i].x));
3105 const Tp f0 = data057[i].f0;
3106 const Tp diff = f - f0;
3107 if (std::abs(diff) > max_abs_diff)
3108 max_abs_diff = std::abs(diff);
3109 if (std::abs(f0) > Tp(10) * eps
3110 && std::abs(f) > Tp(10) * eps)
3111 {
3112 const Tp frac = diff / f0;
3113 if (std::abs(frac) > max_abs_frac)
3114 max_abs_frac = std::abs(frac);
3115 }
3116 }
3117 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
3118}
3119
3120// Test data for n=100, m=1.
3121testcase_assoc_laguerre<double> data058[] = {
3122 { 101.00000000000003, 100, 1,
3123 0.0000000000000000 },
3124 { -14.650661983680466, 100, 1,
3125 10.000000000000000 },
3126 { 1626.5010939361609, 100, 1,
3127 20.000000000000000 },
3128 { 417884.77658268705, 100, 1,
3129 30.000000000000000 },
3130 { -55617646.951649830, 100, 1,
3131 40.000000000000000 },
3132 { 884829874.26626098, 100, 1,
3133 50.000000000000000 },
3134 { 154466082750.32114, 100, 1,
3135 60.000000000000000 },
3136 { -101423973484646.05, 100, 1,
3137 70.000000000000000 },
3138 { -1388352348671755.5, 100, 1,
3139 80.000000000000000 },
3140 { 7.8048705513268326e+17, 100, 1,
3141 90.000000000000000 },
3142 { 1.6948925059042787e+19, 100, 1,
3143 100.00000000000000 },
3144};
3145
3146// Test function for n=100, m=1.
3147template <typename Tp>
3148void test058()
3149{
3150 const Tp eps = std::numeric_limits<Tp>::epsilon();
3151 Tp max_abs_diff = -Tp(1);
3152 Tp max_abs_frac = -Tp(1);
3153 unsigned int num_datum = sizeof(data058)
3154 / sizeof(testcase_assoc_laguerre<double>);
3155 for (unsigned int i = 0; i < num_datum; ++i)
3156 {
3157 const Tp f = std::tr1::assoc_laguerre(Tp(data058[i].n), Tp(data058[i].m),
3158 Tp(data058[i].x));
3159 const Tp f0 = data058[i].f0;
3160 const Tp diff = f - f0;
3161 if (std::abs(diff) > max_abs_diff)
3162 max_abs_diff = std::abs(diff);
3163 if (std::abs(f0) > Tp(10) * eps
3164 && std::abs(f) > Tp(10) * eps)
3165 {
3166 const Tp frac = diff / f0;
3167 if (std::abs(frac) > max_abs_frac)
3168 max_abs_frac = std::abs(frac);
3169 }
3170 }
3171 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
3172}
3173
3174// Test data for n=100, m=2.
3175testcase_assoc_laguerre<double> data059[] = {
3176 { 5151.0000000000055, 100, 2,
3177 0.0000000000000000 },
3178 { -150.22012290951341, 100, 2,
3179 10.000000000000000 },
3180 { -7655.0593294049440, 100, 2,
3181 20.000000000000000 },
3182 { -140996.69276179170, 100, 2,
3183 30.000000000000000 },
3184 { -38645171.278549291, 100, 2,
3185 40.000000000000000 },
3186 { -8889263688.2118778, 100, 2,
3187 50.000000000000000 },
3188 { -1010338971533.3397, 100, 2,
3189 60.000000000000000 },
3190 { -127582564332943.91, 100, 2,
3191 70.000000000000000 },
3192 { 15970305694654336., 100, 2,
3193 80.000000000000000 },
3194 { -1.6019844992862840e+18, 100, 2,
3195 90.000000000000000 },
3196 { 2.8267024730962919e+20, 100, 2,
3197 100.00000000000000 },
3198};
3199
3200// Test function for n=100, m=2.
3201template <typename Tp>
3202void test059()
3203{
3204 const Tp eps = std::numeric_limits<Tp>::epsilon();
3205 Tp max_abs_diff = -Tp(1);
3206 Tp max_abs_frac = -Tp(1);
3207 unsigned int num_datum = sizeof(data059)
3208 / sizeof(testcase_assoc_laguerre<double>);
3209 for (unsigned int i = 0; i < num_datum; ++i)
3210 {
3211 const Tp f = std::tr1::assoc_laguerre(Tp(data059[i].n), Tp(data059[i].m),
3212 Tp(data059[i].x));
3213 const Tp f0 = data059[i].f0;
3214 const Tp diff = f - f0;
3215 if (std::abs(diff) > max_abs_diff)
3216 max_abs_diff = std::abs(diff);
3217 if (std::abs(f0) > Tp(10) * eps
3218 && std::abs(f) > Tp(10) * eps)
3219 {
3220 const Tp frac = diff / f0;
3221 if (std::abs(frac) > max_abs_frac)
3222 max_abs_frac = std::abs(frac);
3223 }
3224 }
3225 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
3226}
3227
3228// Test data for n=100, m=5.
3229testcase_assoc_laguerre<double> data060[] = {
3230 { 96560646.000000030, 100, 5,
3231 0.0000000000000000 },
3232 { 2430.6732236677576, 100, 5,
3233 10.000000000000000 },
3234 { 111162.32026994640, 100, 5,
3235 20.000000000000000 },
3236 { 4036708.2599413753, 100, 5,
3237 30.000000000000000 },
3238 { -34055982.664405435, 100, 5,
3239 40.000000000000000 },
3240 { 30110688343.562344, 100, 5,
3241 50.000000000000000 },
3242 { 2651429940558.2920, 100, 5,
3243 60.000000000000000 },
3244 { 192108556058942.84, 100, 5,
3245 70.000000000000000 },
3246 { -25410533973455528., 100, 5,
3247 80.000000000000000 },
3248 { 2.1072955633564431e+18, 100, 5,
3249 90.000000000000000 },
3250 { -2.9434005355877260e+20, 100, 5,
3251 100.00000000000000 },
3252};
3253
3254// Test function for n=100, m=5.
3255template <typename Tp>
3256void test060()
3257{
3258 const Tp eps = std::numeric_limits<Tp>::epsilon();
3259 Tp max_abs_diff = -Tp(1);
3260 Tp max_abs_frac = -Tp(1);
3261 unsigned int num_datum = sizeof(data060)
3262 / sizeof(testcase_assoc_laguerre<double>);
3263 for (unsigned int i = 0; i < num_datum; ++i)
3264 {
3265 const Tp f = std::tr1::assoc_laguerre(Tp(data060[i].n), Tp(data060[i].m),
3266 Tp(data060[i].x));
3267 const Tp f0 = data060[i].f0;
3268 const Tp diff = f - f0;
3269 if (std::abs(diff) > max_abs_diff)
3270 max_abs_diff = std::abs(diff);
3271 if (std::abs(f0) > Tp(10) * eps
3272 && std::abs(f) > Tp(10) * eps)
3273 {
3274 const Tp frac = diff / f0;
3275 if (std::abs(frac) > max_abs_frac)
3276 max_abs_frac = std::abs(frac);
3277 }
3278 }
3279 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
3280}
3281
3282// Test data for n=100, m=10.
3283testcase_assoc_laguerre<double> data061[] = {
3284 { 46897636623981.039, 100, 10,
3285 0.0000000000000000 },
3286 { 529208.11550990446, 100, 10,
3287 10.000000000000000 },
3288 { 7402892.1748803742, 100, 10,
3289 20.000000000000000 },
3290 { 88369632.083243459, 100, 10,
3291 30.000000000000000 },
3292 { 822187797.59096730, 100, 10,
3293 40.000000000000000 },
3294 { 180231446033.06866, 100, 10,
3295 50.000000000000000 },
3296 { 7922942703798.1309, 100, 10,
3297 60.000000000000000 },
3298 { 784424250559043.38, 100, 10,
3299 70.000000000000000 },
3300 { -16325634720239362., 100, 10,
3301 80.000000000000000 },
3302 { -1.0879588307443181e+18, 100, 10,
3303 90.000000000000000 },
3304 { 3.0114394463610495e+19, 100, 10,
3305 100.00000000000000 },
3306};
3307
3308// Test function for n=100, m=10.
3309template <typename Tp>
3310void test061()
3311{
3312 const Tp eps = std::numeric_limits<Tp>::epsilon();
3313 Tp max_abs_diff = -Tp(1);
3314 Tp max_abs_frac = -Tp(1);
3315 unsigned int num_datum = sizeof(data061)
3316 / sizeof(testcase_assoc_laguerre<double>);
3317 for (unsigned int i = 0; i < num_datum; ++i)
3318 {
3319 const Tp f = std::tr1::assoc_laguerre(Tp(data061[i].n), Tp(data061[i].m),
3320 Tp(data061[i].x));
3321 const Tp f0 = data061[i].f0;
3322 const Tp diff = f - f0;
3323 if (std::abs(diff) > max_abs_diff)
3324 max_abs_diff = std::abs(diff);
3325 if (std::abs(f0) > Tp(10) * eps
3326 && std::abs(f) > Tp(10) * eps)
3327 {
3328 const Tp frac = diff / f0;
3329 if (std::abs(frac) > max_abs_frac)
3330 max_abs_frac = std::abs(frac);
3331 }
3332 }
3333 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
3334}
3335
3336// Test data for n=100, m=20.
3337testcase_assoc_laguerre<double> data062[] = {
3338 { 2.9462227291176614e+22, 100, 20,
3339 0.0000000000000000 },
3340 { 313694958939.90436, 100, 20,
3341 10.000000000000000 },
3342 { 45396489338.096252, 100, 20,
3343 20.000000000000000 },
3344 { -7215826758.0078783, 100, 20,
3345 30.000000000000000 },
3346 { 825949194005.88831, 100, 20,
3347 40.000000000000000 },
3348 { -2764742119971.0747, 100, 20,
3349 50.000000000000000 },
3350 { -219802198273516.03, 100, 20,
3351 60.000000000000000 },
3352 { -1699053306145266.0, 100, 20,
3353 70.000000000000000 },
3354 { 3.5495709345023853e+17, 100, 20,
3355 80.000000000000000 },
3356 { -9.6128675110292439e+18, 100, 20,
3357 90.000000000000000 },
3358 { 4.3619868422072153e+20, 100, 20,
3359 100.00000000000000 },
3360};
3361
3362// Test function for n=100, m=20.
3363template <typename Tp>
3364void test062()
3365{
3366 const Tp eps = std::numeric_limits<Tp>::epsilon();
3367 Tp max_abs_diff = -Tp(1);
3368 Tp max_abs_frac = -Tp(1);
3369 unsigned int num_datum = sizeof(data062)
3370 / sizeof(testcase_assoc_laguerre<double>);
3371 for (unsigned int i = 0; i < num_datum; ++i)
3372 {
3373 const Tp f = std::tr1::assoc_laguerre(Tp(data062[i].n), Tp(data062[i].m),
3374 Tp(data062[i].x));
3375 const Tp f0 = data062[i].f0;
3376 const Tp diff = f - f0;
3377 if (std::abs(diff) > max_abs_diff)
3378 max_abs_diff = std::abs(diff);
3379 if (std::abs(f0) > Tp(10) * eps
3380 && std::abs(f) > Tp(10) * eps)
3381 {
3382 const Tp frac = diff / f0;
3383 if (std::abs(frac) > max_abs_frac)
3384 max_abs_frac = std::abs(frac);
3385 }
3386 }
3387 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
3388}
3389
3390// Test data for n=100, m=50.
3391testcase_assoc_laguerre<double> data063[] = {
3392 { 2.0128660909731931e+40, 100, 50,
3393 0.0000000000000000 },
3394 { -4.0151443913473681e+28, 100, 50,
3395 10.000000000000000 },
3396 { 3.2199632594552201e+22, 100, 50,
3397 20.000000000000000 },
3398 { -2.7568702092659717e+20, 100, 50,
3399 30.000000000000000 },
3400 { 7.5553066015421530e+19, 100, 50,
3401 40.000000000000000 },
3402 { -2.7651625252388041e+19, 100, 50,
3403 50.000000000000000 },
3404 { -5.8963680147283821e+19, 100, 50,
3405 60.000000000000000 },
3406 { -1.8082798163033126e+20, 100, 50,
3407 70.000000000000000 },
3408 { -3.9044276986817249e+20, 100, 50,
3409 80.000000000000000 },
3410 { 6.9926310700401904e+21, 100, 50,
3411 90.000000000000000 },
3412 { -5.5727272809923697e+22, 100, 50,
3413 100.00000000000000 },
3414};
3415
3416// Test function for n=100, m=50.
3417template <typename Tp>
3418void test063()
3419{
3420 const Tp eps = std::numeric_limits<Tp>::epsilon();
3421 Tp max_abs_diff = -Tp(1);
3422 Tp max_abs_frac = -Tp(1);
3423 unsigned int num_datum = sizeof(data063)
3424 / sizeof(testcase_assoc_laguerre<double>);
3425 for (unsigned int i = 0; i < num_datum; ++i)
3426 {
3427 const Tp f = std::tr1::assoc_laguerre(Tp(data063[i].n), Tp(data063[i].m),
3428 Tp(data063[i].x));
3429 const Tp f0 = data063[i].f0;
3430 const Tp diff = f - f0;
3431 if (std::abs(diff) > max_abs_diff)
3432 max_abs_diff = std::abs(diff);
3433 if (std::abs(f0) > Tp(10) * eps
3434 && std::abs(f) > Tp(10) * eps)
3435 {
3436 const Tp frac = diff / f0;
3437 if (std::abs(frac) > max_abs_frac)
3438 max_abs_frac = std::abs(frac);
3439 }
3440 }
3441 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
3442}
3443
3444// Test data for n=100, m=100.
3445testcase_assoc_laguerre<double> data064[] = {
3446 { 9.0548514656103225e+58, 100, 100,
3447 0.0000000000000000 },
3448 { 1.3334078033060576e+54, 100, 100,
3449 10.000000000000000 },
3450 { 2.1002639254211231e+46, 100, 100,
3451 20.000000000000000 },
3452 { -1.1073158068796240e+39, 100, 100,
3453 30.000000000000000 },
3454 { -8.3640937363981405e+35, 100, 100,
3455 40.000000000000000 },
3456 { -6.5879339429312671e+32, 100, 100,
3457 50.000000000000000 },
3458 { -2.4190645077698453e+30, 100, 100,
3459 60.000000000000000 },
3460 { -7.9224960465662002e+29, 100, 100,
3461 70.000000000000000 },
3462 { -2.8605772478408853e+29, 100, 100,
3463 80.000000000000000 },
3464 { 2.4149589189610125e+28, 100, 100,
3465 90.000000000000000 },
3466 { 5.1146476014859003e+28, 100, 100,
3467 100.00000000000000 },
3468};
3469
3470// Test function for n=100, m=100.
3471template <typename Tp>
3472void test064()
3473{
3474 const Tp eps = std::numeric_limits<Tp>::epsilon();
3475 Tp max_abs_diff = -Tp(1);
3476 Tp max_abs_frac = -Tp(1);
3477 unsigned int num_datum = sizeof(data064)
3478 / sizeof(testcase_assoc_laguerre<double>);
3479 for (unsigned int i = 0; i < num_datum; ++i)
3480 {
3481 const Tp f = std::tr1::assoc_laguerre(Tp(data064[i].n), Tp(data064[i].m),
3482 Tp(data064[i].x));
3483 const Tp f0 = data064[i].f0;
3484 const Tp diff = f - f0;
3485 if (std::abs(diff) > max_abs_diff)
3486 max_abs_diff = std::abs(diff);
3487 if (std::abs(f0) > Tp(10) * eps
3488 && std::abs(f) > Tp(10) * eps)
3489 {
3490 const Tp frac = diff / f0;
3491 if (std::abs(frac) > max_abs_frac)
3492 max_abs_frac = std::abs(frac);
3493 }
3494 }
3495 VERIFY(max_abs_frac < Tp(2.5000000000000015e-12));
3496}
3497
3498int main(int, char**)
3499{
3500 test001<double>();
3501 test002<double>();
3502 test003<double>();
3503 test004<double>();
3504 test005<double>();
3505 test006<double>();
3506 test007<double>();
3507 test008<double>();
3508 test009<double>();
3509 test010<double>();
3510 test011<double>();
3511 test012<double>();
3512 test013<double>();
3513 test014<double>();
3514 test015<double>();
3515 test016<double>();
3516 test017<double>();
3517 test018<double>();
3518 test019<double>();
3519 test020<double>();
3520 test021<double>();
3521 test022<double>();
3522 test023<double>();
3523 test024<double>();
3524 test025<double>();
3525 test026<double>();
3526 test027<double>();
3527 test028<double>();
3528 test029<double>();
3529 test030<double>();
3530 test031<double>();
3531 test032<double>();
3532 test033<double>();
3533 test034<double>();
3534 test035<double>();
3535 test036<double>();
3536 test037<double>();
3537 test038<double>();
3538 test039<double>();
3539 test040<double>();
3540 test041<double>();
3541 test042<double>();
3542 test043<double>();
3543 test044<double>();
3544 test045<double>();
3545 test046<double>();
3546 test047<double>();
3547 test048<double>();
3548 test049<double>();
3549 test050<double>();
3550 test051<double>();
3551 test052<double>();
3552 test053<double>();
3553 test054<double>();
3554 test055<double>();
3555 test056<double>();
3556 test057<double>();
3557 test058<double>();
3558 test059<double>();
3559 test060<double>();
3560 test061<double>();
3561 test062<double>();
3562 test063<double>();
3563 test064<double>();
3564 return 0;
3565}
Mirror of https://gcc.gnu.org/git/gcc.git