]> git.ipfire.org Git - thirdparty/gcc.git/blob - libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/22_sph_legendre/check_value.cc
projects / thirdparty / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update copyright years in libstdc++-v3/
[thirdparty/gcc.git] / libstdc++-v3 / testsuite / tr1 / 5_numerical_facilities / special_functions / 22_sph_legendre / check_value.cc
1 // 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net>
2 //
3 // Copyright (C) 2007-2014 Free Software Foundation, Inc.
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
8 // Free Software Foundation; either version 3, or (at your option)
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
17 // with this library; see the file COPYING3. If not see
18 // <http://www.gnu.org/licenses/>.
19
20 // sph_legendre
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) \
30 if (!(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 l=0, m=0.
43 testcase_sph_legendre<double> data001[] = {
44 { 0.28209479177387814, 0, 0,
45 0.0000000000000000 },
46 { 0.28209479177387814, 0, 0,
47 0.15707963267948966 },
48 { 0.28209479177387814, 0, 0,
49 0.31415926535897931 },
50 { 0.28209479177387814, 0, 0,
51 0.47123889803846897 },
52 { 0.28209479177387814, 0, 0,
53 0.62831853071795862 },
54 { 0.28209479177387814, 0, 0,
55 0.78539816339744828 },
56 { 0.28209479177387814, 0, 0,
57 0.94247779607693793 },
58 { 0.28209479177387814, 0, 0,
59 1.0995574287564276 },
60 { 0.28209479177387814, 0, 0,
61 1.2566370614359172 },
62 { 0.28209479177387814, 0, 0,
63 1.4137166941154069 },
64 { 0.28209479177387814, 0, 0,
65 1.5707963267948966 },
66 { 0.28209479177387814, 0, 0,
67 1.7278759594743860 },
68 { 0.28209479177387814, 0, 0,
69 1.8849555921538759 },
70 { 0.28209479177387814, 0, 0,
71 2.0420352248333655 },
72 { 0.28209479177387814, 0, 0,
73 2.1991148575128552 },
74 { 0.28209479177387814, 0, 0,
75 2.3561944901923448 },
76 { 0.28209479177387814, 0, 0,
77 2.5132741228718345 },
78 { 0.28209479177387814, 0, 0,
79 2.6703537555513241 },
80 { 0.28209479177387814, 0, 0,
81 2.8274333882308138 },
82 { 0.28209479177387814, 0, 0,
83 2.9845130209103035 },
84 { 0.28209479177387814, 0, 0,
85 3.1415926535897931 },
86 };
87
88 // Test function for l=0, m=0.
89 template <typename Tp>
90 void test001()
91 {
92 const Tp eps = std::numeric_limits<Tp>::epsilon();
93 Tp max_abs_diff = -Tp(1);
94 Tp max_abs_frac = -Tp(1);
95 unsigned int num_datum = sizeof(data001)
96 / sizeof(testcase_sph_legendre<double>);
97 for (unsigned int i = 0; i < num_datum; ++i)
98 {
99 const Tp f = std::tr1::sph_legendre(Tp(data001[i].l), Tp(data001[i].m),
100 Tp(data001[i].theta));
101 const Tp f0 = data001[i].f0;
102 const Tp diff = f - f0;
103 if (std::abs(diff) > max_abs_diff)
104 max_abs_diff = std::abs(diff);
105 if (std::abs(f0) > Tp(10) * eps
106 && std::abs(f) > Tp(10) * eps)
107 {
108 const Tp frac = diff / f0;
109 if (std::abs(frac) > max_abs_frac)
110 max_abs_frac = std::abs(frac);
111 }
112 }
113 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
114 }
115
116 // Test data for l=1, m=0.
117 testcase_sph_legendre<double> data002[] = {
118 { 0.48860251190291992, 1, 0,
119 0.0000000000000000 },
120 { 0.48258700419201100, 1, 0,
121 0.15707963267948966 },
122 { 0.46468860282345231, 1, 0,
123 0.31415926535897931 },
124 { 0.43534802584032634, 1, 0,
125 0.47123889803846897 },
126 { 0.39528773562374975, 1, 0,
127 0.62831853071795862 },
128 { 0.34549414947133544, 1, 0,
129 0.78539816339744828 },
130 { 0.28719335072959390, 1, 0,
131 0.94247779607693793 },
132 { 0.22182089855280451, 1, 0,
133 1.0995574287564276 },
134 { 0.15098647967228984, 1, 0,
135 1.2566370614359172 },
136 { 0.076434272566846345, 1, 0,
137 1.4137166941154069 },
138 { 2.9918275112863369e-17, 1, 0,
139 1.5707963267948966 },
140 { -0.076434272566846179, 1, 0,
141 1.7278759594743860 },
142 { -0.15098647967228976, 1, 0,
143 1.8849555921538759 },
144 { -0.22182089855280446, 1, 0,
145 2.0420352248333655 },
146 { -0.28719335072959390, 1, 0,
147 2.1991148575128552 },
148 { -0.34549414947133544, 1, 0,
149 2.3561944901923448 },
150 { -0.39528773562374969, 1, 0,
151 2.5132741228718345 },
152 { -0.43534802584032628, 1, 0,
153 2.6703537555513241 },
154 { -0.46468860282345231, 1, 0,
155 2.8274333882308138 },
156 { -0.48258700419201095, 1, 0,
157 2.9845130209103035 },
158 { -0.48860251190291992, 1, 0,
159 3.1415926535897931 },
160 };
161
162 // Test function for l=1, m=0.
163 template <typename Tp>
164 void test002()
165 {
166 const Tp eps = std::numeric_limits<Tp>::epsilon();
167 Tp max_abs_diff = -Tp(1);
168 Tp max_abs_frac = -Tp(1);
169 unsigned int num_datum = sizeof(data002)
170 / sizeof(testcase_sph_legendre<double>);
171 for (unsigned int i = 0; i < num_datum; ++i)
172 {
173 const Tp f = std::tr1::sph_legendre(Tp(data002[i].l), Tp(data002[i].m),
174 Tp(data002[i].theta));
175 const Tp f0 = data002[i].f0;
176 const Tp diff = f - f0;
177 if (std::abs(diff) > max_abs_diff)
178 max_abs_diff = std::abs(diff);
179 if (std::abs(f0) > Tp(10) * eps
180 && std::abs(f) > Tp(10) * eps)
181 {
182 const Tp frac = diff / f0;
183 if (std::abs(frac) > max_abs_frac)
184 max_abs_frac = std::abs(frac);
185 }
186 }
187 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
188 }
189
190 // Test data for l=1, m=1.
191 testcase_sph_legendre<double> data003[] = {
192 { 0.0000000000000000, 1, 1,
193 0.0000000000000000 },
194 { -0.054047192447077917, 1, 1,
195 0.15707963267948966 },
196 { -0.10676356364376104, 1, 1,
197 0.31415926535897931 },
198 { -0.15685106157558129, 1, 1,
199 0.47123889803846897 },
200 { -0.20307636581258243, 1, 1,
201 0.62831853071795862 },
202 { -0.24430125595146013, 1, 1,
203 0.78539816339744828 },
204 { -0.27951063837942880, 1, 1,
205 0.94247779607693793 },
206 { -0.30783754124787122, 1, 1,
207 1.0995574287564276 },
208 { -0.32858446219656551, 1, 1,
209 1.2566370614359172 },
210 { -0.34124054317667202, 1, 1,
211 1.4137166941154069 },
212 { -0.34549414947133567, 1, 1,
213 1.5707963267948966 },
214 { -0.34124054317667202, 1, 1,
215 1.7278759594743860 },
216 { -0.32858446219656556, 1, 1,
217 1.8849555921538759 },
218 { -0.30783754124787127, 1, 1,
219 2.0420352248333655 },
220 { -0.27951063837942880, 1, 1,
221 2.1991148575128552 },
222 { -0.24430125595146013, 1, 1,
223 2.3561944901923448 },
224 { -0.20307636581258248, 1, 1,
225 2.5132741228718345 },
226 { -0.15685106157558140, 1, 1,
227 2.6703537555513241 },
228 { -0.10676356364376104, 1, 1,
229 2.8274333882308138 },
230 { -0.054047192447078167, 1, 1,
231 2.9845130209103035 },
232 { 0.0000000000000000, 1, 1,
233 3.1415926535897931 },
234 };
235
236 // Test function for l=1, m=1.
237 template <typename Tp>
238 void test003()
239 {
240 const Tp eps = std::numeric_limits<Tp>::epsilon();
241 Tp max_abs_diff = -Tp(1);
242 Tp max_abs_frac = -Tp(1);
243 unsigned int num_datum = sizeof(data003)
244 / sizeof(testcase_sph_legendre<double>);
245 for (unsigned int i = 0; i < num_datum; ++i)
246 {
247 const Tp f = std::tr1::sph_legendre(Tp(data003[i].l), Tp(data003[i].m),
248 Tp(data003[i].theta));
249 const Tp f0 = data003[i].f0;
250 const Tp diff = f - f0;
251 if (std::abs(diff) > max_abs_diff)
252 max_abs_diff = std::abs(diff);
253 if (std::abs(f0) > Tp(10) * eps
254 && std::abs(f) > Tp(10) * eps)
255 {
256 const Tp frac = diff / f0;
257 if (std::abs(frac) > max_abs_frac)
258 max_abs_frac = std::abs(frac);
259 }
260 }
261 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
262 }
263
264 // Test data for l=2, m=0.
265 testcase_sph_legendre<double> data004[] = {
266 { 0.63078313050504009, 2, 0,
267 0.0000000000000000 },
268 { 0.60762858760316607, 2, 0,
269 0.15707963267948966 },
270 { 0.54043148688396569, 2, 0,
271 0.31415926535897931 },
272 { 0.43576954875556589, 2, 0,
273 0.47123889803846897 },
274 { 0.30388781294457579, 2, 0,
275 0.62831853071795862 },
276 { 0.15769578262625994, 2, 0,
277 0.78539816339744828 },
278 { 0.011503752307944235, 2, 0,
279 0.94247779607693793 },
280 { -0.12037798350304565, 2, 0,
281 1.0995574287564276 },
282 { -0.22503992163144573, 2, 0,
283 1.2566370614359172 },
284 { -0.29223702235064597, 2, 0,
285 1.4137166941154069 },
286 { -0.31539156525252005, 2, 0,
287 1.5707963267948966 },
288 { -0.29223702235064608, 2, 0,
289 1.7278759594743860 },
290 { -0.22503992163144584, 2, 0,
291 1.8849555921538759 },
292 { -0.12037798350304577, 2, 0,
293 2.0420352248333655 },
294 { 0.011503752307944235, 2, 0,
295 2.1991148575128552 },
296 { 0.15769578262625994, 2, 0,
297 2.3561944901923448 },
298 { 0.30388781294457567, 2, 0,
299 2.5132741228718345 },
300 { 0.43576954875556562, 2, 0,
301 2.6703537555513241 },
302 { 0.54043148688396569, 2, 0,
303 2.8274333882308138 },
304 { 0.60762858760316585, 2, 0,
305 2.9845130209103035 },
306 { 0.63078313050504009, 2, 0,
307 3.1415926535897931 },
308 };
309
310 // Test function for l=2, m=0.
311 template <typename Tp>
312 void test004()
313 {
314 const Tp eps = std::numeric_limits<Tp>::epsilon();
315 Tp max_abs_diff = -Tp(1);
316 Tp max_abs_frac = -Tp(1);
317 unsigned int num_datum = sizeof(data004)
318 / sizeof(testcase_sph_legendre<double>);
319 for (unsigned int i = 0; i < num_datum; ++i)
320 {
321 const Tp f = std::tr1::sph_legendre(Tp(data004[i].l), Tp(data004[i].m),
322 Tp(data004[i].theta));
323 const Tp f0 = data004[i].f0;
324 const Tp diff = f - f0;
325 if (std::abs(diff) > max_abs_diff)
326 max_abs_diff = std::abs(diff);
327 if (std::abs(f0) > Tp(10) * eps
328 && std::abs(f) > Tp(10) * eps)
329 {
330 const Tp frac = diff / f0;
331 if (std::abs(frac) > max_abs_frac)
332 max_abs_frac = std::abs(frac);
333 }
334 }
335 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
336 }
337
338 // Test data for l=2, m=1.
339 testcase_sph_legendre<double> data005[] = {
340 { 0.0000000000000000, 2, 1,
341 0.0000000000000000 },
342 { -0.11936529291378727, 2, 1,
343 0.15707963267948966 },
344 { -0.22704627929027449, 2, 1,
345 0.31415926535897931 },
346 { -0.31250239392538215, 2, 1,
347 0.47123889803846897 },
348 { -0.36736859691086526, 2, 1,
349 0.62831853071795862 },
350 { -0.38627420202318979, 2, 1,
351 0.78539816339744828 },
352 { -0.36736859691086526, 2, 1,
353 0.94247779607693793 },
354 { -0.31250239392538226, 2, 1,
355 1.0995574287564276 },
356 { -0.22704627929027435, 2, 1,
357 1.2566370614359172 },
358 { -0.11936529291378740, 2, 1,
359 1.4137166941154069 },
360 { -4.7304946510089748e-17, 2, 1,
361 1.5707963267948966 },
362 { 0.11936529291378714, 2, 1,
363 1.7278759594743860 },
364 { 0.22704627929027429, 2, 1,
365 1.8849555921538759 },
366 { 0.31250239392538226, 2, 1,
367 2.0420352248333655 },
368 { 0.36736859691086526, 2, 1,
369 2.1991148575128552 },
370 { 0.38627420202318979, 2, 1,
371 2.3561944901923448 },
372 { 0.36736859691086526, 2, 1,
373 2.5132741228718345 },
374 { 0.31250239392538232, 2, 1,
375 2.6703537555513241 },
376 { 0.22704627929027449, 2, 1,
377 2.8274333882308138 },
378 { 0.11936529291378781, 2, 1,
379 2.9845130209103035 },
380 { 0.0000000000000000, 2, 1,
381 3.1415926535897931 },
382 };
383
384 // Test function for l=2, m=1.
385 template <typename Tp>
386 void test005()
387 {
388 const Tp eps = std::numeric_limits<Tp>::epsilon();
389 Tp max_abs_diff = -Tp(1);
390 Tp max_abs_frac = -Tp(1);
391 unsigned int num_datum = sizeof(data005)
392 / sizeof(testcase_sph_legendre<double>);
393 for (unsigned int i = 0; i < num_datum; ++i)
394 {
395 const Tp f = std::tr1::sph_legendre(Tp(data005[i].l), Tp(data005[i].m),
396 Tp(data005[i].theta));
397 const Tp f0 = data005[i].f0;
398 const Tp diff = f - f0;
399 if (std::abs(diff) > max_abs_diff)
400 max_abs_diff = std::abs(diff);
401 if (std::abs(f0) > Tp(10) * eps
402 && std::abs(f) > Tp(10) * eps)
403 {
404 const Tp frac = diff / f0;
405 if (std::abs(frac) > max_abs_frac)
406 max_abs_frac = std::abs(frac);
407 }
408 }
409 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
410 }
411
412 // Test data for l=2, m=2.
413 testcase_sph_legendre<double> data006[] = {
414 { 0.0000000000000000, 2, 2,
415 0.0000000000000000 },
416 { 0.0094528025561622549, 2, 2,
417 0.15707963267948966 },
418 { 0.036885904048903795, 2, 2,
419 0.31415926535897931 },
420 { 0.079613961366457681, 2, 2,
421 0.47123889803846897 },
422 { 0.13345445455470123, 2, 2,
423 0.62831853071795862 },
424 { 0.19313710101159492, 2, 2,
425 0.78539816339744828 },
426 { 0.25281974746848851, 2, 2,
427 0.94247779607693793 },
428 { 0.30666024065673203, 2, 2,
429 1.0995574287564276 },
430 { 0.34938829797428600, 2, 2,
431 1.2566370614359172 },
432 { 0.37682139946702747, 2, 2,
433 1.4137166941154069 },
434 { 0.38627420202318979, 2, 2,
435 1.5707963267948966 },
436 { 0.37682139946702753, 2, 2,
437 1.7278759594743860 },
438 { 0.34938829797428606, 2, 2,
439 1.8849555921538759 },
440 { 0.30666024065673209, 2, 2,
441 2.0420352248333655 },
442 { 0.25281974746848851, 2, 2,
443 2.1991148575128552 },
444 { 0.19313710101159492, 2, 2,
445 2.3561944901923448 },
446 { 0.13345445455470126, 2, 2,
447 2.5132741228718345 },
448 { 0.079613961366457764, 2, 2,
449 2.6703537555513241 },
450 { 0.036885904048903795, 2, 2,
451 2.8274333882308138 },
452 { 0.0094528025561623433, 2, 2,
453 2.9845130209103035 },
454 { 0.0000000000000000, 2, 2,
455 3.1415926535897931 },
456 };
457
458 // Test function for l=2, m=2.
459 template <typename Tp>
460 void test006()
461 {
462 const Tp eps = std::numeric_limits<Tp>::epsilon();
463 Tp max_abs_diff = -Tp(1);
464 Tp max_abs_frac = -Tp(1);
465 unsigned int num_datum = sizeof(data006)
466 / sizeof(testcase_sph_legendre<double>);
467 for (unsigned int i = 0; i < num_datum; ++i)
468 {
469 const Tp f = std::tr1::sph_legendre(Tp(data006[i].l), Tp(data006[i].m),
470 Tp(data006[i].theta));
471 const Tp f0 = data006[i].f0;
472 const Tp diff = f - f0;
473 if (std::abs(diff) > max_abs_diff)
474 max_abs_diff = std::abs(diff);
475 if (std::abs(f0) > Tp(10) * eps
476 && std::abs(f) > Tp(10) * eps)
477 {
478 const Tp frac = diff / f0;
479 if (std::abs(frac) > max_abs_frac)
480 max_abs_frac = std::abs(frac);
481 }
482 }
483 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
484 }
485
486 // Test data for l=5, m=0.
487 testcase_sph_legendre<double> data007[] = {
488 { 0.93560257962738880, 5, 0,
489 0.0000000000000000 },
490 { 0.77014422942080019, 5, 0,
491 0.15707963267948966 },
492 { 0.35892185032365215, 5, 0,
493 0.31415926535897931 },
494 { -0.090214932090594183, 5, 0,
495 0.47123889803846897 },
496 { -0.36214460396518888, 5, 0,
497 0.62831853071795862 },
498 { -0.35145955579226890, 5, 0,
499 0.78539816339744828 },
500 { -0.11441703594725168, 5, 0,
501 0.94247779607693793 },
502 { 0.17248966720808098, 5, 0,
503 1.0995574287564276 },
504 { 0.32128384287200523, 5, 0,
505 1.2566370614359172 },
506 { 0.24377632246714948, 5, 0,
507 1.4137166941154069 },
508 { 1.0741712853887702e-16, 5, 0,
509 1.5707963267948966 },
510 { -0.24377632246714906, 5, 0,
511 1.7278759594743860 },
512 { -0.32128384287200534, 5, 0,
513 1.8849555921538759 },
514 { -0.17248966720808118, 5, 0,
515 2.0420352248333655 },
516 { 0.11441703594725168, 5, 0,
517 2.1991148575128552 },
518 { 0.35145955579226890, 5, 0,
519 2.3561944901923448 },
520 { 0.36214460396518910, 5, 0,
521 2.5132741228718345 },
522 { 0.090214932090594724, 5, 0,
523 2.6703537555513241 },
524 { -0.35892185032365215, 5, 0,
525 2.8274333882308138 },
526 { -0.77014422942079797, 5, 0,
527 2.9845130209103035 },
528 { -0.93560257962738880, 5, 0,
529 3.1415926535897931 },
530 };
531
532 // Test function for l=5, m=0.
533 template <typename Tp>
534 void test007()
535 {
536 const Tp eps = std::numeric_limits<Tp>::epsilon();
537 Tp max_abs_diff = -Tp(1);
538 Tp max_abs_frac = -Tp(1);
539 unsigned int num_datum = sizeof(data007)
540 / sizeof(testcase_sph_legendre<double>);
541 for (unsigned int i = 0; i < num_datum; ++i)
542 {
543 const Tp f = std::tr1::sph_legendre(Tp(data007[i].l), Tp(data007[i].m),
544 Tp(data007[i].theta));
545 const Tp f0 = data007[i].f0;
546 const Tp diff = f - f0;
547 if (std::abs(diff) > max_abs_diff)
548 max_abs_diff = std::abs(diff);
549 if (std::abs(f0) > Tp(10) * eps
550 && std::abs(f) > Tp(10) * eps)
551 {
552 const Tp frac = diff / f0;
553 if (std::abs(frac) > max_abs_frac)
554 max_abs_frac = std::abs(frac);
555 }
556 }
557 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
558 }
559
560 // Test data for l=5, m=1.
561 testcase_sph_legendre<double> data008[] = {
562 { 0.0000000000000000, 5, 1,
563 0.0000000000000000 },
564 { -0.36712373713318258, 5, 1,
565 0.15707963267948966 },
566 { -0.54610329010534753, 5, 1,
567 0.31415926535897931 },
568 { -0.45381991493631785, 5, 1,
569 0.47123889803846897 },
570 { -0.15679720635769953, 5, 1,
571 0.62831853071795862 },
572 { 0.16985499419838637, 5, 1,
573 0.78539816339744828 },
574 { 0.34468004499725180, 5, 1,
575 0.94247779607693793 },
576 { 0.28349471119605985, 5, 1,
577 1.0995574287564276 },
578 { 0.044286619339675856, 5, 1,
579 1.2566370614359172 },
580 { -0.21193784177193470, 5, 1,
581 1.4137166941154069 },
582 { -0.32028164857621527, 5, 1,
583 1.5707963267948966 },
584 { -0.21193784177193514, 5, 1,
585 1.7278759594743860 },
586 { 0.044286619339675606, 5, 1,
587 1.8849555921538759 },
588 { 0.28349471119605979, 5, 1,
589 2.0420352248333655 },
590 { 0.34468004499725180, 5, 1,
591 2.1991148575128552 },
592 { 0.16985499419838637, 5, 1,
593 2.3561944901923448 },
594 { -0.15679720635769920, 5, 1,
595 2.5132741228718345 },
596 { -0.45381991493631757, 5, 1,
597 2.6703537555513241 },
598 { -0.54610329010534753, 5, 1,
599 2.8274333882308138 },
600 { -0.36712373713318397, 5, 1,
601 2.9845130209103035 },
602 { 0.0000000000000000, 5, 1,
603 3.1415926535897931 },
604 };
605
606 // Test function for l=5, m=1.
607 template <typename Tp>
608 void test008()
609 {
610 const Tp eps = std::numeric_limits<Tp>::epsilon();
611 Tp max_abs_diff = -Tp(1);
612 Tp max_abs_frac = -Tp(1);
613 unsigned int num_datum = sizeof(data008)
614 / sizeof(testcase_sph_legendre<double>);
615 for (unsigned int i = 0; i < num_datum; ++i)
616 {
617 const Tp f = std::tr1::sph_legendre(Tp(data008[i].l), Tp(data008[i].m),
618 Tp(data008[i].theta));
619 const Tp f0 = data008[i].f0;
620 const Tp diff = f - f0;
621 if (std::abs(diff) > max_abs_diff)
622 max_abs_diff = std::abs(diff);
623 if (std::abs(f0) > Tp(10) * eps
624 && std::abs(f) > Tp(10) * eps)
625 {
626 const Tp frac = diff / f0;
627 if (std::abs(frac) > max_abs_frac)
628 max_abs_frac = std::abs(frac);
629 }
630 }
631 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
632 }
633
634 // Test data for l=5, m=2.
635 testcase_sph_legendre<double> data009[] = {
636 { 0.0000000000000000, 5, 2,
637 0.0000000000000000 },
638 { 0.078919441745546146, 5, 2,
639 0.15707963267948966 },
640 { 0.26373799140437981, 5, 2,
641 0.31415926535897931 },
642 { 0.43002359842080096, 5, 2,
643 0.47123889803846897 },
644 { 0.45642486439050994, 5, 2,
645 0.62831853071795862 },
646 { 0.29959604906083276, 5, 2,
647 0.78539816339744828 },
648 { 0.023781239849532242, 5, 2,
649 0.94247779607693793 },
650 { -0.23313989334673815, 5, 2,
651 1.0995574287564276 },
652 { -0.33799912776303714, 5, 2,
653 1.2566370614359172 },
654 { -0.23964508489529743, 5, 2,
655 1.4137166941154069 },
656 { -1.0377480524338170e-16, 5, 2,
657 1.5707963267948966 },
658 { 0.23964508489529704, 5, 2,
659 1.7278759594743860 },
660 { 0.33799912776303714, 5, 2,
661 1.8849555921538759 },
662 { 0.23313989334673837, 5, 2,
663 2.0420352248333655 },
664 { -0.023781239849532242, 5, 2,
665 2.1991148575128552 },
666 { -0.29959604906083276, 5, 2,
667 2.3561944901923448 },
668 { -0.45642486439050978, 5, 2,
669 2.5132741228718345 },
670 { -0.43002359842080118, 5, 2,
671 2.6703537555513241 },
672 { -0.26373799140437981, 5, 2,
673 2.8274333882308138 },
674 { -0.078919441745546867, 5, 2,
675 2.9845130209103035 },
676 { 0.0000000000000000, 5, 2,
677 3.1415926535897931 },
678 };
679
680 // Test function for l=5, m=2.
681 template <typename Tp>
682 void test009()
683 {
684 const Tp eps = std::numeric_limits<Tp>::epsilon();
685 Tp max_abs_diff = -Tp(1);
686 Tp max_abs_frac = -Tp(1);
687 unsigned int num_datum = sizeof(data009)
688 / sizeof(testcase_sph_legendre<double>);
689 for (unsigned int i = 0; i < num_datum; ++i)
690 {
691 const Tp f = std::tr1::sph_legendre(Tp(data009[i].l), Tp(data009[i].m),
692 Tp(data009[i].theta));
693 const Tp f0 = data009[i].f0;
694 const Tp diff = f - f0;
695 if (std::abs(diff) > max_abs_diff)
696 max_abs_diff = std::abs(diff);
697 if (std::abs(f0) > Tp(10) * eps
698 && std::abs(f) > Tp(10) * eps)
699 {
700 const Tp frac = diff / f0;
701 if (std::abs(frac) > max_abs_frac)
702 max_abs_frac = std::abs(frac);
703 }
704 }
705 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
706 }
707
708 // Test data for l=5, m=5.
709 testcase_sph_legendre<double> data010[] = {
710 { 0.0000000000000000, 5, 5,
711 0.0000000000000000 },
712 { -4.3481439097909148e-05, 5, 5,
713 0.15707963267948966 },
714 { -0.0013078367086431812, 5, 5,
715 0.31415926535897931 },
716 { -0.0089510818191922761, 5, 5,
717 0.47123889803846897 },
718 { -0.032563803777573896, 5, 5,
719 0.62831853071795862 },
720 { -0.082047757105021310, 5, 5,
721 0.78539816339744828 },
722 { -0.16085328164143819, 5, 5,
723 0.94247779607693793 },
724 { -0.26064303436645375, 5, 5,
725 1.0995574287564276 },
726 { -0.36113811790820566, 5, 5,
727 1.2566370614359172 },
728 { -0.43625592459446139, 5, 5,
729 1.4137166941154069 },
730 { -0.46413220344085809, 5, 5,
731 1.5707963267948966 },
732 { -0.43625592459446155, 5, 5,
733 1.7278759594743860 },
734 { -0.36113811790820577, 5, 5,
735 1.8849555921538759 },
736 { -0.26064303436645381, 5, 5,
737 2.0420352248333655 },
738 { -0.16085328164143819, 5, 5,
739 2.1991148575128552 },
740 { -0.082047757105021310, 5, 5,
741 2.3561944901923448 },
742 { -0.032563803777573924, 5, 5,
743 2.5132741228718345 },
744 { -0.0089510818191923004, 5, 5,
745 2.6703537555513241 },
746 { -0.0013078367086431812, 5, 5,
747 2.8274333882308138 },
748 { -4.3481439097910151e-05, 5, 5,
749 2.9845130209103035 },
750 { 0.0000000000000000, 5, 5,
751 3.1415926535897931 },
752 };
753
754 // Test function for l=5, m=5.
755 template <typename Tp>
756 void test010()
757 {
758 const Tp eps = std::numeric_limits<Tp>::epsilon();
759 Tp max_abs_diff = -Tp(1);
760 Tp max_abs_frac = -Tp(1);
761 unsigned int num_datum = sizeof(data010)
762 / sizeof(testcase_sph_legendre<double>);
763 for (unsigned int i = 0; i < num_datum; ++i)
764 {
765 const Tp f = std::tr1::sph_legendre(Tp(data010[i].l), Tp(data010[i].m),
766 Tp(data010[i].theta));
767 const Tp f0 = data010[i].f0;
768 const Tp diff = f - f0;
769 if (std::abs(diff) > max_abs_diff)
770 max_abs_diff = std::abs(diff);
771 if (std::abs(f0) > Tp(10) * eps
772 && std::abs(f) > Tp(10) * eps)
773 {
774 const Tp frac = diff / f0;
775 if (std::abs(frac) > max_abs_frac)
776 max_abs_frac = std::abs(frac);
777 }
778 }
779 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
780 }
781
782 // Test data for l=10, m=0.
783 testcase_sph_legendre<double> data011[] = {
784 { 1.2927207364566027, 10, 0,
785 0.0000000000000000 },
786 { 0.55288895150522632, 10, 0,
787 0.15707963267948966 },
788 { -0.44874428379711506, 10, 0,
789 0.31415926535897931 },
790 { -0.25532095827149692, 10, 0,
791 0.47123889803846897 },
792 { 0.36625249688013967, 10, 0,
793 0.62831853071795862 },
794 { 0.14880806329084145, 10, 0,
795 0.78539816339744828 },
796 { -0.33533356797848746, 10, 0,
797 0.94247779607693793 },
798 { -0.080639967662335818, 10, 0,
799 1.0995574287564276 },
800 { 0.32197986450174521, 10, 0,
801 1.2566370614359172 },
802 { 0.025713542103667848, 10, 0,
803 1.4137166941154069 },
804 { -0.31813049373736707, 10, 0,
805 1.5707963267948966 },
806 { 0.025713542103666668, 10, 0,
807 1.7278759594743860 },
808 { 0.32197986450174532, 10, 0,
809 1.8849555921538759 },
810 { -0.080639967662335416, 10, 0,
811 2.0420352248333655 },
812 { -0.33533356797848746, 10, 0,
813 2.1991148575128552 },
814 { 0.14880806329084145, 10, 0,
815 2.3561944901923448 },
816 { 0.36625249688013994, 10, 0,
817 2.5132741228718345 },
818 { -0.25532095827149576, 10, 0,
819 2.6703537555513241 },
820 { -0.44874428379711506, 10, 0,
821 2.8274333882308138 },
822 { 0.55288895150521977, 10, 0,
823 2.9845130209103035 },
824 { 1.2927207364566027, 10, 0,
825 3.1415926535897931 },
826 };
827
828 // Test function for l=10, m=0.
829 template <typename Tp>
830 void test011()
831 {
832 const Tp eps = std::numeric_limits<Tp>::epsilon();
833 Tp max_abs_diff = -Tp(1);
834 Tp max_abs_frac = -Tp(1);
835 unsigned int num_datum = sizeof(data011)
836 / sizeof(testcase_sph_legendre<double>);
837 for (unsigned int i = 0; i < num_datum; ++i)
838 {
839 const Tp f = std::tr1::sph_legendre(Tp(data011[i].l), Tp(data011[i].m),
840 Tp(data011[i].theta));
841 const Tp f0 = data011[i].f0;
842 const Tp diff = f - f0;
843 if (std::abs(diff) > max_abs_diff)
844 max_abs_diff = std::abs(diff);
845 if (std::abs(f0) > Tp(10) * eps
846 && std::abs(f) > Tp(10) * eps)
847 {
848 const Tp frac = diff / f0;
849 if (std::abs(frac) > max_abs_frac)
850 max_abs_frac = std::abs(frac);
851 }
852 }
853 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
854 }
855
856 // Test data for l=10, m=1.
857 testcase_sph_legendre<double> data012[] = {
858 { 0.0000000000000000, 10, 1,
859 0.0000000000000000 },
860 { -0.74373723919063905, 10, 1,
861 0.15707963267948966 },
862 { -0.29035110456209551, 10, 1,
863 0.31415926535897931 },
864 { 0.42219282075271497, 10, 1,
865 0.47123889803846897 },
866 { 0.17109256898931269, 10, 1,
867 0.62831853071795862 },
868 { -0.35583574648544292, 10, 1,
869 0.78539816339744828 },
870 { -0.10089212303543979, 10, 1,
871 0.94247779607693793 },
872 { 0.32997652649321085, 10, 1,
873 1.0995574287564276 },
874 { 0.047416376890033113, 10, 1,
875 1.2566370614359172 },
876 { -0.31999356750295654, 10, 1,
877 1.4137166941154069 },
878 { -2.0430664782290766e-16, 10, 1,
879 1.5707963267948966 },
880 { 0.31999356750295660, 10, 1,
881 1.7278759594743860 },
882 { -0.047416376890032523, 10, 1,
883 1.8849555921538759 },
884 { -0.32997652649321102, 10, 1,
885 2.0420352248333655 },
886 { 0.10089212303543979, 10, 1,
887 2.1991148575128552 },
888 { 0.35583574648544292, 10, 1,
889 2.3561944901923448 },
890 { -0.17109256898931186, 10, 1,
891 2.5132741228718345 },
892 { -0.42219282075271553, 10, 1,
893 2.6703537555513241 },
894 { 0.29035110456209551, 10, 1,
895 2.8274333882308138 },
896 { 0.74373723919064028, 10, 1,
897 2.9845130209103035 },
898 { 0.0000000000000000, 10, 1,
899 3.1415926535897931 },
900 };
901
902 // Test function for l=10, m=1.
903 template <typename Tp>
904 void test012()
905 {
906 const Tp eps = std::numeric_limits<Tp>::epsilon();
907 Tp max_abs_diff = -Tp(1);
908 Tp max_abs_frac = -Tp(1);
909 unsigned int num_datum = sizeof(data012)
910 / sizeof(testcase_sph_legendre<double>);
911 for (unsigned int i = 0; i < num_datum; ++i)
912 {
913 const Tp f = std::tr1::sph_legendre(Tp(data012[i].l), Tp(data012[i].m),
914 Tp(data012[i].theta));
915 const Tp f0 = data012[i].f0;
916 const Tp diff = f - f0;
917 if (std::abs(diff) > max_abs_diff)
918 max_abs_diff = std::abs(diff);
919 if (std::abs(f0) > Tp(10) * eps
920 && std::abs(f) > Tp(10) * eps)
921 {
922 const Tp frac = diff / f0;
923 if (std::abs(frac) > max_abs_frac)
924 max_abs_frac = std::abs(frac);
925 }
926 }
927 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
928 }
929
930 // Test data for l=10, m=2.
931 testcase_sph_legendre<double> data013[] = {
932 { 0.0000000000000000, 10, 2,
933 0.0000000000000000 },
934 { 0.34571695599980284, 10, 2,
935 0.15707963267948966 },
936 { 0.62485535978198059, 10, 2,
937 0.31415926535897931 },
938 { 0.098210039644716363, 10, 2,
939 0.47123889803846897 },
940 { -0.41494799233049656, 10, 2,
941 0.62831853071795862 },
942 { -0.081698973831472149, 10, 2,
943 0.78539816339744828 },
944 { 0.35253132222271272, 10, 2,
945 0.94247779607693793 },
946 { 0.049026298555981063, 10, 2,
947 1.0995574287564276 },
948 { -0.32791246874130797, 10, 2,
949 1.2566370614359172 },
950 { -0.016196782433946910, 10, 2,
951 1.4137166941154069 },
952 { 0.32106263400438328, 10, 2,
953 1.5707963267948966 },
954 { -0.016196782433945765, 10, 2,
955 1.7278759594743860 },
956 { -0.32791246874130797, 10, 2,
957 1.8849555921538759 },
958 { 0.049026298555980702, 10, 2,
959 2.0420352248333655 },
960 { 0.35253132222271272, 10, 2,
961 2.1991148575128552 },
962 { -0.081698973831472149, 10, 2,
963 2.3561944901923448 },
964 { -0.41494799233049667, 10, 2,
965 2.5132741228718345 },
966 { 0.098210039644714753, 10, 2,
967 2.6703537555513241 },
968 { 0.62485535978198059, 10, 2,
969 2.8274333882308138 },
970 { 0.34571695599980551, 10, 2,
971 2.9845130209103035 },
972 { 0.0000000000000000, 10, 2,
973 3.1415926535897931 },
974 };
975
976 // Test function for l=10, m=2.
977 template <typename Tp>
978 void test013()
979 {
980 const Tp eps = std::numeric_limits<Tp>::epsilon();
981 Tp max_abs_diff = -Tp(1);
982 Tp max_abs_frac = -Tp(1);
983 unsigned int num_datum = sizeof(data013)
984 / sizeof(testcase_sph_legendre<double>);
985 for (unsigned int i = 0; i < num_datum; ++i)
986 {
987 const Tp f = std::tr1::sph_legendre(Tp(data013[i].l), Tp(data013[i].m),
988 Tp(data013[i].theta));
989 const Tp f0 = data013[i].f0;
990 const Tp diff = f - f0;
991 if (std::abs(diff) > max_abs_diff)
992 max_abs_diff = std::abs(diff);
993 if (std::abs(f0) > Tp(10) * eps
994 && std::abs(f) > Tp(10) * eps)
995 {
996 const Tp frac = diff / f0;
997 if (std::abs(frac) > max_abs_frac)
998 max_abs_frac = std::abs(frac);
999 }
1000 }
1001 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
1002 }
1003
1004 // Test data for l=10, m=5.
1005 testcase_sph_legendre<double> data014[] = {
1006 { 0.0000000000000000, 10, 5,
1007 0.0000000000000000 },
1008 { -0.0030300124052750187, 10, 5,
1009 0.15707963267948966 },
1010 { -0.070348585248056830, 10, 5,
1011 0.31415926535897931 },
1012 { -0.30055029290703639, 10, 5,
1013 0.47123889803846897 },
1014 { -0.49987818144009166, 10, 5,
1015 0.62831853071795862 },
1016 { -0.28108771757150086, 10, 5,
1017 0.78539816339744828 },
1018 { 0.22068081187249308, 10, 5,
1019 0.94247779607693793 },
1020 { 0.33689502212592115, 10, 5,
1021 1.0995574287564276 },
1022 { -0.086095515520763985, 10, 5,
1023 1.2566370614359172 },
1024 { -0.33935827318511558, 10, 5,
1025 1.4137166941154069 },
1026 { -1.9213014340664578e-16, 10, 5,
1027 1.5707963267948966 },
1028 { 0.33935827318511552, 10, 5,
1029 1.7278759594743860 },
1030 { 0.086095515520764526, 10, 5,
1031 1.8849555921538759 },
1032 { -0.33689502212592098, 10, 5,
1033 2.0420352248333655 },
1034 { -0.22068081187249308, 10, 5,
1035 2.1991148575128552 },
1036 { 0.28108771757150086, 10, 5,
1037 2.3561944901923448 },
1038 { 0.49987818144009155, 10, 5,
1039 2.5132741228718345 },
1040 { 0.30055029290703678, 10, 5,
1041 2.6703537555513241 },
1042 { 0.070348585248056830, 10, 5,
1043 2.8274333882308138 },
1044 { 0.0030300124052750855, 10, 5,
1045 2.9845130209103035 },
1046 { 0.0000000000000000, 10, 5,
1047 3.1415926535897931 },
1048 };
1049
1050 // Test function for l=10, m=5.
1051 template <typename Tp>
1052 void test014()
1053 {
1054 const Tp eps = std::numeric_limits<Tp>::epsilon();
1055 Tp max_abs_diff = -Tp(1);
1056 Tp max_abs_frac = -Tp(1);
1057 unsigned int num_datum = sizeof(data014)
1058 / sizeof(testcase_sph_legendre<double>);
1059 for (unsigned int i = 0; i < num_datum; ++i)
1060 {
1061 const Tp f = std::tr1::sph_legendre(Tp(data014[i].l), Tp(data014[i].m),
1062 Tp(data014[i].theta));
1063 const Tp f0 = data014[i].f0;
1064 const Tp diff = f - f0;
1065 if (std::abs(diff) > max_abs_diff)
1066 max_abs_diff = std::abs(diff);
1067 if (std::abs(f0) > Tp(10) * eps
1068 && std::abs(f) > Tp(10) * eps)
1069 {
1070 const Tp frac = diff / f0;
1071 if (std::abs(frac) > max_abs_frac)
1072 max_abs_frac = std::abs(frac);
1073 }
1074 }
1075 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1076 }
1077
1078 // Test data for l=10, m=10.
1079 testcase_sph_legendre<double> data015[] = {
1080 { 0.0000000000000000, 10, 10,
1081 0.0000000000000000 },
1082 { 4.7624282733343473e-09, 10, 10,
1083 0.15707963267948966 },
1084 { 4.3085156534549772e-06, 10, 10,
1085 0.31415926535897931 },
1086 { 0.00020182347649472368, 10, 10,
1087 0.47123889803846897 },
1088 { 0.0026711045506511684, 10, 10,
1089 0.62831853071795862 },
1090 { 0.016957196623256943, 10, 10,
1091 0.78539816339744828 },
1092 { 0.065174916004990341, 10, 10,
1093 0.94247779607693793 },
1094 { 0.17112476903017843, 10, 10,
1095 1.0995574287564276 },
1096 { 0.32852414199733548, 10, 10,
1097 1.2566370614359172 },
1098 { 0.47940582314838287, 10, 10,
1099 1.4137166941154069 },
1100 { 0.54263029194422152, 10, 10,
1101 1.5707963267948966 },
1102 { 0.47940582314838309, 10, 10,
1103 1.7278759594743860 },
1104 { 0.32852414199733571, 10, 10,
1105 1.8849555921538759 },
1106 { 0.17112476903017854, 10, 10,
1107 2.0420352248333655 },
1108 { 0.065174916004990341, 10, 10,
1109 2.1991148575128552 },
1110 { 0.016957196623256943, 10, 10,
1111 2.3561944901923448 },
1112 { 0.0026711045506511706, 10, 10,
1113 2.5132741228718345 },
1114 { 0.00020182347649472493, 10, 10,
1115 2.6703537555513241 },
1116 { 4.3085156534549772e-06, 10, 10,
1117 2.8274333882308138 },
1118 { 4.7624282733345673e-09, 10, 10,
1119 2.9845130209103035 },
1120 { 0.0000000000000000, 10, 10,
1121 3.1415926535897931 },
1122 };
1123
1124 // Test function for l=10, m=10.
1125 template <typename Tp>
1126 void test015()
1127 {
1128 const Tp eps = std::numeric_limits<Tp>::epsilon();
1129 Tp max_abs_diff = -Tp(1);
1130 Tp max_abs_frac = -Tp(1);
1131 unsigned int num_datum = sizeof(data015)
1132 / sizeof(testcase_sph_legendre<double>);
1133 for (unsigned int i = 0; i < num_datum; ++i)
1134 {
1135 const Tp f = std::tr1::sph_legendre(Tp(data015[i].l), Tp(data015[i].m),
1136 Tp(data015[i].theta));
1137 const Tp f0 = data015[i].f0;
1138 const Tp diff = f - f0;
1139 if (std::abs(diff) > max_abs_diff)
1140 max_abs_diff = std::abs(diff);
1141 if (std::abs(f0) > Tp(10) * eps
1142 && std::abs(f) > Tp(10) * eps)
1143 {
1144 const Tp frac = diff / f0;
1145 if (std::abs(frac) > max_abs_frac)
1146 max_abs_frac = std::abs(frac);
1147 }
1148 }
1149 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1150 }
1151
1152 // Test data for l=20, m=0.
1153 testcase_sph_legendre<double> data016[] = {
1154 { 1.8062879984608917, 20, 0,
1155 0.0000000000000000 },
1156 { -0.58906549291415966, 20, 0,
1157 0.15707963267948966 },
1158 { 0.45624611402342408, 20, 0,
1159 0.31415926535897931 },
1160 { -0.39955402700466724, 20, 0,
1161 0.47123889803846897 },
1162 { 0.36818552901640750, 20, 0,
1163 0.62831853071795862 },
1164 { -0.34873131330857787, 20, 0,
1165 0.78539816339744828 },
1166 { 0.33600882829186501, 20, 0,
1167 0.94247779607693793 },
1168 { -0.32759286308122904, 20, 0,
1169 1.0995574287564276 },
1170 { 0.32222458068091320, 20, 0,
1171 1.2566370614359172 },
1172 { -0.31922731037135960, 20, 0,
1173 1.4137166941154069 },
1174 { 0.31826262039531755, 20, 0,
1175 1.5707963267948966 },
1176 { -0.31922731037135965, 20, 0,
1177 1.7278759594743860 },
1178 { 0.32222458068091336, 20, 0,
1179 1.8849555921538759 },
1180 { -0.32759286308122937, 20, 0,
1181 2.0420352248333655 },
1182 { 0.33600882829186501, 20, 0,
1183 2.1991148575128552 },
1184 { -0.34873131330857787, 20, 0,
1185 2.3561944901923448 },
1186 { 0.36818552901640839, 20, 0,
1187 2.5132741228718345 },
1188 { -0.39955402700466852, 20, 0,
1189 2.6703537555513241 },
1190 { 0.45624611402342408, 20, 0,
1191 2.8274333882308138 },
1192 { -0.58906549291416699, 20, 0,
1193 2.9845130209103035 },
1194 { 1.8062879984608917, 20, 0,
1195 3.1415926535897931 },
1196 };
1197
1198 // Test function for l=20, m=0.
1199 template <typename Tp>
1200 void test016()
1201 {
1202 const Tp eps = std::numeric_limits<Tp>::epsilon();
1203 Tp max_abs_diff = -Tp(1);
1204 Tp max_abs_frac = -Tp(1);
1205 unsigned int num_datum = sizeof(data016)
1206 / sizeof(testcase_sph_legendre<double>);
1207 for (unsigned int i = 0; i < num_datum; ++i)
1208 {
1209 const Tp f = std::tr1::sph_legendre(Tp(data016[i].l), Tp(data016[i].m),
1210 Tp(data016[i].theta));
1211 const Tp f0 = data016[i].f0;
1212 const Tp diff = f - f0;
1213 if (std::abs(diff) > max_abs_diff)
1214 max_abs_diff = std::abs(diff);
1215 if (std::abs(f0) > Tp(10) * eps
1216 && std::abs(f) > Tp(10) * eps)
1217 {
1218 const Tp frac = diff / f0;
1219 if (std::abs(frac) > max_abs_frac)
1220 max_abs_frac = std::abs(frac);
1221 }
1222 }
1223 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1224 }
1225
1226 // Test data for l=20, m=1.
1227 testcase_sph_legendre<double> data017[] = {
1228 { 0.0000000000000000, 20, 1,
1229 0.0000000000000000 },
1230 { -0.45905213045060206, 20, 1,
1231 0.15707963267948966 },
1232 { 0.31166370423309170, 20, 1,
1233 0.31415926535897931 },
1234 { -0.23278757741246814, 20, 1,
1235 0.47123889803846897 },
1236 { 0.17937240823504183, 20, 1,
1237 0.62831853071795862 },
1238 { -0.13857299972299736, 20, 1,
1239 0.78539816339744828 },
1240 { 0.10495324841927710, 20, 1,
1241 0.94247779607693793 },
1242 { -0.075707774352164178, 20, 1,
1243 1.0995574287564276 },
1244 { 0.049168697683476620, 20, 1,
1245 1.2566370614359172 },
1246 { -0.024216050551253254, 20, 1,
1247 1.4137166941154069 },
1248 { 3.9938443510694349e-16, 20, 1,
1249 1.5707963267948966 },
1250 { 0.024216050551250898, 20, 1,
1251 1.7278759594743860 },
1252 { -0.049168697683475482, 20, 1,
1253 1.8849555921538759 },
1254 { 0.075707774352163332, 20, 1,
1255 2.0420352248333655 },
1256 { -0.10495324841927710, 20, 1,
1257 2.1991148575128552 },
1258 { 0.13857299972299736, 20, 1,
1259 2.3561944901923448 },
1260 { -0.17937240823504039, 20, 1,
1261 2.5132741228718345 },
1262 { 0.23278757741246658, 20, 1,
1263 2.6703537555513241 },
1264 { -0.31166370423309170, 20, 1,
1265 2.8274333882308138 },
1266 { 0.45905213045059318, 20, 1,
1267 2.9845130209103035 },
1268 { 0.0000000000000000, 20, 1,
1269 3.1415926535897931 },
1270 };
1271
1272 // Test function for l=20, m=1.
1273 template <typename Tp>
1274 void test017()
1275 {
1276 const Tp eps = std::numeric_limits<Tp>::epsilon();
1277 Tp max_abs_diff = -Tp(1);
1278 Tp max_abs_frac = -Tp(1);
1279 unsigned int num_datum = sizeof(data017)
1280 / sizeof(testcase_sph_legendre<double>);
1281 for (unsigned int i = 0; i < num_datum; ++i)
1282 {
1283 const Tp f = std::tr1::sph_legendre(Tp(data017[i].l), Tp(data017[i].m),
1284 Tp(data017[i].theta));
1285 const Tp f0 = data017[i].f0;
1286 const Tp diff = f - f0;
1287 if (std::abs(diff) > max_abs_diff)
1288 max_abs_diff = std::abs(diff);
1289 if (std::abs(f0) > Tp(10) * eps
1290 && std::abs(f) > Tp(10) * eps)
1291 {
1292 const Tp frac = diff / f0;
1293 if (std::abs(frac) > max_abs_frac)
1294 max_abs_frac = std::abs(frac);
1295 }
1296 }
1297 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
1298 }
1299
1300 // Test data for l=20, m=2.
1301 testcase_sph_legendre<double> data018[] = {
1302 { 0.0000000000000000, 20, 2,
1303 0.0000000000000000 },
1304 { 0.87399805141574682, 20, 2,
1305 0.15707963267948966 },
1306 { -0.55116854080894984, 20, 2,
1307 0.31415926535897931 },
1308 { 0.44520137308557534, 20, 2,
1309 0.47123889803846897 },
1310 { -0.39321637877908228, 20, 2,
1311 0.62831853071795862 },
1312 { 0.36312025711350970, 20, 2,
1313 0.78539816339744828 },
1314 { -0.34427103004873094, 20, 2,
1315 0.94247779607693793 },
1316 { 0.33214917638387625, 20, 2,
1317 1.0995574287564276 },
1318 { -0.32455734448839091, 20, 2,
1319 1.2566370614359172 },
1320 { 0.32036529628513238, 20, 2,
1321 1.4137166941154069 },
1322 { -0.31902310563819986, 20, 2,
1323 1.5707963267948966 },
1324 { 0.32036529628513266, 20, 2,
1325 1.7278759594743860 },
1326 { -0.32455734448839102, 20, 2,
1327 1.8849555921538759 },
1328 { 0.33214917638387670, 20, 2,
1329 2.0420352248333655 },
1330 { -0.34427103004873094, 20, 2,
1331 2.1991148575128552 },
1332 { 0.36312025711350970, 20, 2,
1333 2.3561944901923448 },
1334 { -0.39321637877908278, 20, 2,
1335 2.5132741228718345 },
1336 { 0.44520137308557639, 20, 2,
1337 2.6703537555513241 },
1338 { -0.55116854080894984, 20, 2,
1339 2.8274333882308138 },
1340 { 0.87399805141574360, 20, 2,
1341 2.9845130209103035 },
1342 { 0.0000000000000000, 20, 2,
1343 3.1415926535897931 },
1344 };
1345
1346 // Test function for l=20, m=2.
1347 template <typename Tp>
1348 void test018()
1349 {
1350 const Tp eps = std::numeric_limits<Tp>::epsilon();
1351 Tp max_abs_diff = -Tp(1);
1352 Tp max_abs_frac = -Tp(1);
1353 unsigned int num_datum = sizeof(data018)
1354 / sizeof(testcase_sph_legendre<double>);
1355 for (unsigned int i = 0; i < num_datum; ++i)
1356 {
1357 const Tp f = std::tr1::sph_legendre(Tp(data018[i].l), Tp(data018[i].m),
1358 Tp(data018[i].theta));
1359 const Tp f0 = data018[i].f0;
1360 const Tp diff = f - f0;
1361 if (std::abs(diff) > max_abs_diff)
1362 max_abs_diff = std::abs(diff);
1363 if (std::abs(f0) > Tp(10) * eps
1364 && std::abs(f) > Tp(10) * eps)
1365 {
1366 const Tp frac = diff / f0;
1367 if (std::abs(frac) > max_abs_frac)
1368 max_abs_frac = std::abs(frac);
1369 }
1370 }
1371 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1372 }
1373
1374 // Test data for l=20, m=5.
1375 testcase_sph_legendre<double> data019[] = {
1376 { 0.0000000000000000, 20, 5,
1377 0.0000000000000000 },
1378 { -0.10024848623504846, 20, 5,
1379 0.15707963267948966 },
1380 { -0.68115361075940595, 20, 5,
1381 0.31415926535897931 },
1382 { 0.31774532551156237, 20, 5,
1383 0.47123889803846897 },
1384 { -0.16011868165390564, 20, 5,
1385 0.62831853071795862 },
1386 { 0.085844143304116230, 20, 5,
1387 0.78539816339744828 },
1388 { -0.047467540840864686, 20, 5,
1389 0.94247779607693793 },
1390 { 0.026283575189471282, 20, 5,
1391 1.0995574287564276 },
1392 { -0.013891104052597331, 20, 5,
1393 1.2566370614359172 },
1394 { 0.0059873308239496931, 20, 5,
1395 1.4137166941154069 },
1396 { 3.9355286582083095e-16, 20, 5,
1397 1.5707963267948966 },
1398 { -0.0059873308239519040, 20, 5,
1399 1.7278759594743860 },
1400 { 0.013891104052598531, 20, 5,
1401 1.8849555921538759 },
1402 { -0.026283575189472212, 20, 5,
1403 2.0420352248333655 },
1404 { 0.047467540840864686, 20, 5,
1405 2.1991148575128552 },
1406 { -0.085844143304116230, 20, 5,
1407 2.3561944901923448 },
1408 { 0.16011868165390636, 20, 5,
1409 2.5132741228718345 },
1410 { -0.31774532551156448, 20, 5,
1411 2.6703537555513241 },
1412 { 0.68115361075940595, 20, 5,
1413 2.8274333882308138 },
1414 { 0.10024848623505037, 20, 5,
1415 2.9845130209103035 },
1416 { 0.0000000000000000, 20, 5,
1417 3.1415926535897931 },
1418 };
1419
1420 // Test function for l=20, m=5.
1421 template <typename Tp>
1422 void test019()
1423 {
1424 const Tp eps = std::numeric_limits<Tp>::epsilon();
1425 Tp max_abs_diff = -Tp(1);
1426 Tp max_abs_frac = -Tp(1);
1427 unsigned int num_datum = sizeof(data019)
1428 / sizeof(testcase_sph_legendre<double>);
1429 for (unsigned int i = 0; i < num_datum; ++i)
1430 {
1431 const Tp f = std::tr1::sph_legendre(Tp(data019[i].l), Tp(data019[i].m),
1432 Tp(data019[i].theta));
1433 const Tp f0 = data019[i].f0;
1434 const Tp diff = f - f0;
1435 if (std::abs(diff) > max_abs_diff)
1436 max_abs_diff = std::abs(diff);
1437 if (std::abs(f0) > Tp(10) * eps
1438 && std::abs(f) > Tp(10) * eps)
1439 {
1440 const Tp frac = diff / f0;
1441 if (std::abs(frac) > max_abs_frac)
1442 max_abs_frac = std::abs(frac);
1443 }
1444 }
1445 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
1446 }
1447
1448 // Test data for l=20, m=10.
1449 testcase_sph_legendre<double> data020[] = {
1450 { 0.0000000000000000, 20, 10,
1451 0.0000000000000000 },
1452 { 3.0595797603706485e-05, 20, 10,
1453 0.15707963267948966 },
1454 { 0.015924453916397008, 20, 10,
1455 0.31415926535897931 },
1456 { 0.26588079118745700, 20, 10,
1457 0.47123889803846897 },
1458 { 0.54045081420686825, 20, 10,
1459 0.62831853071795862 },
1460 { -0.28215279394285597, 20, 10,
1461 0.78539816339744828 },
1462 { 0.0085297337582246665, 20, 10,
1463 0.94247779607693793 },
1464 { 0.16930127953533775, 20, 10,
1465 1.0995574287564276 },
1466 { -0.27215134048018352, 20, 10,
1467 1.2566370614359172 },
1468 { 0.32456597088029526, 20, 10,
1469 1.4137166941154069 },
1470 { -0.34057893241353715, 20, 10,
1471 1.5707963267948966 },
1472 { 0.32456597088029449, 20, 10,
1473 1.7278759594743860 },
1474 { -0.27215134048018308, 20, 10,
1475 1.8849555921538759 },
1476 { 0.16930127953533725, 20, 10,
1477 2.0420352248333655 },
1478 { 0.0085297337582246665, 20, 10,
1479 2.1991148575128552 },
1480 { -0.28215279394285597, 20, 10,
1481 2.3561944901923448 },
1482 { 0.54045081420686658, 20, 10,
1483 2.5132741228718345 },
1484 { 0.26588079118745822, 20, 10,
1485 2.6703537555513241 },
1486 { 0.015924453916397008, 20, 10,
1487 2.8274333882308138 },
1488 { 3.0595797603707854e-05, 20, 10,
1489 2.9845130209103035 },
1490 { 0.0000000000000000, 20, 10,
1491 3.1415926535897931 },
1492 };
1493
1494 // Test function for l=20, m=10.
1495 template <typename Tp>
1496 void test020()
1497 {
1498 const Tp eps = std::numeric_limits<Tp>::epsilon();
1499 Tp max_abs_diff = -Tp(1);
1500 Tp max_abs_frac = -Tp(1);
1501 unsigned int num_datum = sizeof(data020)
1502 / sizeof(testcase_sph_legendre<double>);
1503 for (unsigned int i = 0; i < num_datum; ++i)
1504 {
1505 const Tp f = std::tr1::sph_legendre(Tp(data020[i].l), Tp(data020[i].m),
1506 Tp(data020[i].theta));
1507 const Tp f0 = data020[i].f0;
1508 const Tp diff = f - f0;
1509 if (std::abs(diff) > max_abs_diff)
1510 max_abs_diff = std::abs(diff);
1511 if (std::abs(f0) > Tp(10) * eps
1512 && std::abs(f) > Tp(10) * eps)
1513 {
1514 const Tp frac = diff / f0;
1515 if (std::abs(frac) > max_abs_frac)
1516 max_abs_frac = std::abs(frac);
1517 }
1518 }
1519 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
1520 }
1521
1522 // Test data for l=20, m=20.
1523 testcase_sph_legendre<double> data021[] = {
1524 { 0.0000000000000000, 20, 20,
1525 0.0000000000000000 },
1526 { 4.9264471419245886e-17, 20, 20,
1527 0.15707963267948966 },
1528 { 4.0321091681531780e-11, 20, 20,
1529 0.31415926535897931 },
1530 { 8.8474944184471664e-08, 20, 20,
1531 0.47123889803846897 },
1532 { 1.5497395129387764e-05, 20, 20,
1533 0.62831853071795862 },
1534 { 0.00062457564282984723, 20, 20,
1535 0.78539816339744828 },
1536 { 0.0092265192458967603, 20, 20,
1537 0.94247779607693793 },
1538 { 0.063606673236323269, 20, 20,
1539 1.0995574287564276 },
1540 { 0.23442909509776308, 20, 20,
1541 1.2566370614359172 },
1542 { 0.49921030481087009, 20, 20,
1543 1.4137166941154069 },
1544 { 0.63956545825776223, 20, 20,
1545 1.5707963267948966 },
1546 { 0.49921030481087064, 20, 20,
1547 1.7278759594743860 },
1548 { 0.23442909509776344, 20, 20,
1549 1.8849555921538759 },
1550 { 0.063606673236323352, 20, 20,
1551 2.0420352248333655 },
1552 { 0.0092265192458967603, 20, 20,
1553 2.1991148575128552 },
1554 { 0.00062457564282984723, 20, 20,
1555 2.3561944901923448 },
1556 { 1.5497395129387818e-05, 20, 20,
1557 2.5132741228718345 },
1558 { 8.8474944184472617e-08, 20, 20,
1559 2.6703537555513241 },
1560 { 4.0321091681531780e-11, 20, 20,
1561 2.8274333882308138 },
1562 { 4.9264471419250786e-17, 20, 20,
1563 2.9845130209103035 },
1564 { 0.0000000000000000, 20, 20,
1565 3.1415926535897931 },
1566 };
1567
1568 // Test function for l=20, m=20.
1569 template <typename Tp>
1570 void test021()
1571 {
1572 const Tp eps = std::numeric_limits<Tp>::epsilon();
1573 Tp max_abs_diff = -Tp(1);
1574 Tp max_abs_frac = -Tp(1);
1575 unsigned int num_datum = sizeof(data021)
1576 / sizeof(testcase_sph_legendre<double>);
1577 for (unsigned int i = 0; i < num_datum; ++i)
1578 {
1579 const Tp f = std::tr1::sph_legendre(Tp(data021[i].l), Tp(data021[i].m),
1580 Tp(data021[i].theta));
1581 const Tp f0 = data021[i].f0;
1582 const Tp diff = f - f0;
1583 if (std::abs(diff) > max_abs_diff)
1584 max_abs_diff = std::abs(diff);
1585 if (std::abs(f0) > Tp(10) * eps
1586 && std::abs(f) > Tp(10) * eps)
1587 {
1588 const Tp frac = diff / f0;
1589 if (std::abs(frac) > max_abs_frac)
1590 max_abs_frac = std::abs(frac);
1591 }
1592 }
1593 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1594 }
1595
1596 // Test data for l=50, m=0.
1597 testcase_sph_legendre<double> data022[] = {
1598 { 2.8350175706934717, 50, 0,
1599 0.0000000000000000 },
1600 { 0.53157537495174845, 50, 0,
1601 0.15707963267948966 },
1602 { -0.46056183476301349, 50, 0,
1603 0.31415926535897931 },
1604 { -0.24876032079677909, 50, 0,
1605 0.47123889803846897 },
1606 { 0.36926172901532522, 50, 0,
1607 0.62831853071795862 },
1608 { 0.14571730283563306, 50, 0,
1609 0.78539816339744828 },
1610 { -0.33636199170850811, 50, 0,
1611 0.94247779607693793 },
1612 { -0.079132716267092035, 50, 0,
1613 1.0995574287564276 },
1614 { 0.32232921941301440, 50, 0,
1615 1.2566370614359172 },
1616 { 0.025253991969481446, 50, 0,
1617 1.4137166941154069 },
1618 { -0.31830208724152359, 50, 0,
1619 1.5707963267948966 },
1620 { 0.025253991969476128, 50, 0,
1621 1.7278759594743860 },
1622 { 0.32232921941301479, 50, 0,
1623 1.8849555921538759 },
1624 { -0.079132716267090078, 50, 0,
1625 2.0420352248333655 },
1626 { -0.33636199170850811, 50, 0,
1627 2.1991148575128552 },
1628 { 0.14571730283563306, 50, 0,
1629 2.3561944901923448 },
1630 { 0.36926172901532717, 50, 0,
1631 2.5132741228718345 },
1632 { -0.24876032079677393, 50, 0,
1633 2.6703537555513241 },
1634 { -0.46056183476301349, 50, 0,
1635 2.8274333882308138 },
1636 { 0.53157537495172380, 50, 0,
1637 2.9845130209103035 },
1638 { 2.8350175706934717, 50, 0,
1639 3.1415926535897931 },
1640 };
1641
1642 // Test function for l=50, m=0.
1643 template <typename Tp>
1644 void test022()
1645 {
1646 const Tp eps = std::numeric_limits<Tp>::epsilon();
1647 Tp max_abs_diff = -Tp(1);
1648 Tp max_abs_frac = -Tp(1);
1649 unsigned int num_datum = sizeof(data022)
1650 / sizeof(testcase_sph_legendre<double>);
1651 for (unsigned int i = 0; i < num_datum; ++i)
1652 {
1653 const Tp f = std::tr1::sph_legendre(Tp(data022[i].l), Tp(data022[i].m),
1654 Tp(data022[i].theta));
1655 const Tp f0 = data022[i].f0;
1656 const Tp diff = f - f0;
1657 if (std::abs(diff) > max_abs_diff)
1658 max_abs_diff = std::abs(diff);
1659 if (std::abs(f0) > Tp(10) * eps
1660 && std::abs(f) > Tp(10) * eps)
1661 {
1662 const Tp frac = diff / f0;
1663 if (std::abs(frac) > max_abs_frac)
1664 max_abs_frac = std::abs(frac);
1665 }
1666 }
1667 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
1668 }
1669
1670 // Test data for l=50, m=1.
1671 testcase_sph_legendre<double> data023[] = {
1672 { 0.0000000000000000, 50, 1,
1673 0.0000000000000000 },
1674 { -0.63751752155226116, 50, 1,
1675 0.15707963267948966 },
1676 { -0.32616619317604312, 50, 1,
1677 0.31415926535897931 },
1678 { 0.40649930826162706, 50, 1,
1679 0.47123889803846897 },
1680 { 0.18473991408344026, 50, 1,
1681 0.62831853071795862 },
1682 { -0.35083930302013211, 50, 1,
1683 0.78539816339744828 },
1684 { -0.10755382110947098, 50, 1,
1685 0.94247779607693793 },
1686 { 0.32822568316499862, 50, 1,
1687 1.0995574287564276 },
1688 { 0.050286056609798180, 50, 1,
1689 1.2566370614359172 },
1690 { -0.31935368562159638, 50, 1,
1691 1.4137166941154069 },
1692 { -9.8421602686195941e-16, 50, 1,
1693 1.5707963267948966 },
1694 { 0.31935368562159705, 50, 1,
1695 1.7278759594743860 },
1696 { -0.050286056609795383, 50, 1,
1697 1.8849555921538759 },
1698 { -0.32822568316499923, 50, 1,
1699 2.0420352248333655 },
1700 { 0.10755382110947098, 50, 1,
1701 2.1991148575128552 },
1702 { 0.35083930302013211, 50, 1,
1703 2.3561944901923448 },
1704 { -0.18473991408343632, 50, 1,
1705 2.5132741228718345 },
1706 { -0.40649930826163039, 50, 1,
1707 2.6703537555513241 },
1708 { 0.32616619317604312, 50, 1,
1709 2.8274333882308138 },
1710 { 0.63751752155227837, 50, 1,
1711 2.9845130209103035 },
1712 { 0.0000000000000000, 50, 1,
1713 3.1415926535897931 },
1714 };
1715
1716 // Test function for l=50, m=1.
1717 template <typename Tp>
1718 void test023()
1719 {
1720 const Tp eps = std::numeric_limits<Tp>::epsilon();
1721 Tp max_abs_diff = -Tp(1);
1722 Tp max_abs_frac = -Tp(1);
1723 unsigned int num_datum = sizeof(data023)
1724 / sizeof(testcase_sph_legendre<double>);
1725 for (unsigned int i = 0; i < num_datum; ++i)
1726 {
1727 const Tp f = std::tr1::sph_legendre(Tp(data023[i].l), Tp(data023[i].m),
1728 Tp(data023[i].theta));
1729 const Tp f0 = data023[i].f0;
1730 const Tp diff = f - f0;
1731 if (std::abs(diff) > max_abs_diff)
1732 max_abs_diff = std::abs(diff);
1733 if (std::abs(f0) > Tp(10) * eps
1734 && std::abs(f) > Tp(10) * eps)
1735 {
1736 const Tp frac = diff / f0;
1737 if (std::abs(frac) > max_abs_frac)
1738 max_abs_frac = std::abs(frac);
1739 }
1740 }
1741 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
1742 }
1743
1744 // Test data for l=50, m=2.
1745 testcase_sph_legendre<double> data024[] = {
1746 { 0.0000000000000000, 50, 2,
1747 0.0000000000000000 },
1748 { -0.37230261163839168, 50, 2,
1749 0.15707963267948966 },
1750 { 0.50051599680315972, 50, 2,
1751 0.31415926535897931 },
1752 { 0.21724795180329545, 50, 2,
1753 0.47123889803846897 },
1754 { -0.37948127307610940, 50, 2,
1755 0.62831853071795862 },
1756 { -0.13187372121003119, 50, 2,
1757 0.78539816339744828 },
1758 { 0.33959009162400194, 50, 2,
1759 0.94247779607693793 },
1760 { 0.072537503112490409, 50, 2,
1761 1.0995574287564276 },
1762 { -0.32310306941855271, 50, 2,
1763 1.2566370614359172 },
1764 { -0.023259822816436588, 50, 2,
1765 1.4137166941154069 },
1766 { 0.31842698506357275, 50, 2,
1767 1.5707963267948966 },
1768 { -0.023259822816431144, 50, 2,
1769 1.7278759594743860 },
1770 { -0.32310306941855299, 50, 2,
1771 1.8849555921538759 },
1772 { 0.072537503112488369, 50, 2,
1773 2.0420352248333655 },
1774 { 0.33959009162400194, 50, 2,
1775 2.1991148575128552 },
1776 { -0.13187372121003119, 50, 2,
1777 2.3561944901923448 },
1778 { -0.37948127307611074, 50, 2,
1779 2.5132741228718345 },
1780 { 0.21724795180328935, 50, 2,
1781 2.6703537555513241 },
1782 { 0.50051599680315972, 50, 2,
1783 2.8274333882308138 },
1784 { -0.37230261163836298, 50, 2,
1785 2.9845130209103035 },
1786 { 0.0000000000000000, 50, 2,
1787 3.1415926535897931 },
1788 };
1789
1790 // Test function for l=50, m=2.
1791 template <typename Tp>
1792 void test024()
1793 {
1794 const Tp eps = std::numeric_limits<Tp>::epsilon();
1795 Tp max_abs_diff = -Tp(1);
1796 Tp max_abs_frac = -Tp(1);
1797 unsigned int num_datum = sizeof(data024)
1798 / sizeof(testcase_sph_legendre<double>);
1799 for (unsigned int i = 0; i < num_datum; ++i)
1800 {
1801 const Tp f = std::tr1::sph_legendre(Tp(data024[i].l), Tp(data024[i].m),
1802 Tp(data024[i].theta));
1803 const Tp f0 = data024[i].f0;
1804 const Tp diff = f - f0;
1805 if (std::abs(diff) > max_abs_diff)
1806 max_abs_diff = std::abs(diff);
1807 if (std::abs(f0) > Tp(10) * eps
1808 && std::abs(f) > Tp(10) * eps)
1809 {
1810 const Tp frac = diff / f0;
1811 if (std::abs(frac) > max_abs_frac)
1812 max_abs_frac = std::abs(frac);
1813 }
1814 }
1815 VERIFY(max_abs_frac < Tp(2.5000000000000015e-12));
1816 }
1817
1818 // Test data for l=50, m=5.
1819 testcase_sph_legendre<double> data025[] = {
1820 { 0.0000000000000000, 50, 5,
1821 0.0000000000000000 },
1822 { -0.57750385903193069, 50, 5,
1823 0.15707963267948966 },
1824 { 0.077360497065584566, 50, 5,
1825 0.31415926535897931 },
1826 { 0.47707267400540210, 50, 5,
1827 0.47123889803846897 },
1828 { 0.055370615126630537, 50, 5,
1829 0.62831853071795862 },
1830 { -0.37629451847202855, 50, 5,
1831 0.78539816339744828 },
1832 { -0.048042277801960624, 50, 5,
1833 0.94247779607693793 },
1834 { 0.33619379362228685, 50, 5,
1835 1.0995574287564276 },
1836 { 0.025265227185719726, 50, 5,
1837 1.2566370614359172 },
1838 { -0.32083679430964518, 50, 5,
1839 1.4137166941154069 },
1840 { -9.8189201019751884e-16, 50, 5,
1841 1.5707963267948966 },
1842 { 0.32083679430964590, 50, 5,
1843 1.7278759594743860 },
1844 { -0.025265227185716856, 50, 5,
1845 1.8849555921538759 },
1846 { -0.33619379362228730, 50, 5,
1847 2.0420352248333655 },
1848 { 0.048042277801960624, 50, 5,
1849 2.1991148575128552 },
1850 { 0.37629451847202855, 50, 5,
1851 2.3561944901923448 },
1852 { -0.055370615126626936, 50, 5,
1853 2.5132741228718345 },
1854 { -0.47707267400540210, 50, 5,
1855 2.6703537555513241 },
1856 { -0.077360497065584566, 50, 5,
1857 2.8274333882308138 },
1858 { 0.57750385903191004, 50, 5,
1859 2.9845130209103035 },
1860 { 0.0000000000000000, 50, 5,
1861 3.1415926535897931 },
1862 };
1863
1864 // Test function for l=50, m=5.
1865 template <typename Tp>
1866 void test025()
1867 {
1868 const Tp eps = std::numeric_limits<Tp>::epsilon();
1869 Tp max_abs_diff = -Tp(1);
1870 Tp max_abs_frac = -Tp(1);
1871 unsigned int num_datum = sizeof(data025)
1872 / sizeof(testcase_sph_legendre<double>);
1873 for (unsigned int i = 0; i < num_datum; ++i)
1874 {
1875 const Tp f = std::tr1::sph_legendre(Tp(data025[i].l), Tp(data025[i].m),
1876 Tp(data025[i].theta));
1877 const Tp f0 = data025[i].f0;
1878 const Tp diff = f - f0;
1879 if (std::abs(diff) > max_abs_diff)
1880 max_abs_diff = std::abs(diff);
1881 if (std::abs(f0) > Tp(10) * eps
1882 && std::abs(f) > Tp(10) * eps)
1883 {
1884 const Tp frac = diff / f0;
1885 if (std::abs(frac) > max_abs_frac)
1886 max_abs_frac = std::abs(frac);
1887 }
1888 }
1889 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
1890 }
1891
1892 // Test data for l=50, m=10.
1893 testcase_sph_legendre<double> data026[] = {
1894 { 0.0000000000000000, 50, 10,
1895 0.0000000000000000 },
1896 { 0.15606941844800759, 50, 10,
1897 0.15707963267948966 },
1898 { -0.53748868836814601, 50, 10,
1899 0.31415926535897931 },
1900 { -0.49304919025183896, 50, 10,
1901 0.47123889803846897 },
1902 { -0.26267582750428264, 50, 10,
1903 0.62831853071795862 },
1904 { 0.22058983666314402, 50, 10,
1905 0.78539816339744828 },
1906 { 0.32936725160671759, 50, 10,
1907 0.94247779607693793 },
1908 { -0.092053311559446988, 50, 10,
1909 1.0995574287564276 },
1910 { -0.32542913495935555, 50, 10,
1911 1.2566370614359172 },
1912 { 0.025673223789103500, 50, 10,
1913 1.4137166941154069 },
1914 { 0.32150019350255743, 50, 10,
1915 1.5707963267948966 },
1916 { 0.025673223789108864, 50, 10,
1917 1.7278759594743860 },
1918 { -0.32542913495935494, 50, 10,
1919 1.8849555921538759 },
1920 { -0.092053311559448570, 50, 10,
1921 2.0420352248333655 },
1922 { 0.32936725160671759, 50, 10,
1923 2.1991148575128552 },
1924 { 0.22058983666314402, 50, 10,
1925 2.3561944901923448 },
1926 { -0.26267582750427909, 50, 10,
1927 2.5132741228718345 },
1928 { -0.49304919025184119, 50, 10,
1929 2.6703537555513241 },
1930 { -0.53748868836814601, 50, 10,
1931 2.8274333882308138 },
1932 { 0.15606941844801259, 50, 10,
1933 2.9845130209103035 },
1934 { 0.0000000000000000, 50, 10,
1935 3.1415926535897931 },
1936 };
1937
1938 // Test function for l=50, m=10.
1939 template <typename Tp>
1940 void test026()
1941 {
1942 const Tp eps = std::numeric_limits<Tp>::epsilon();
1943 Tp max_abs_diff = -Tp(1);
1944 Tp max_abs_frac = -Tp(1);
1945 unsigned int num_datum = sizeof(data026)
1946 / sizeof(testcase_sph_legendre<double>);
1947 for (unsigned int i = 0; i < num_datum; ++i)
1948 {
1949 const Tp f = std::tr1::sph_legendre(Tp(data026[i].l), Tp(data026[i].m),
1950 Tp(data026[i].theta));
1951 const Tp f0 = data026[i].f0;
1952 const Tp diff = f - f0;
1953 if (std::abs(diff) > max_abs_diff)
1954 max_abs_diff = std::abs(diff);
1955 if (std::abs(f0) > Tp(10) * eps
1956 && std::abs(f) > Tp(10) * eps)
1957 {
1958 const Tp frac = diff / f0;
1959 if (std::abs(frac) > max_abs_frac)
1960 max_abs_frac = std::abs(frac);
1961 }
1962 }
1963 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1964 }
1965
1966 // Test data for l=50, m=20.
1967 testcase_sph_legendre<double> data027[] = {
1968 { 0.0000000000000000, 50, 20,
1969 0.0000000000000000 },
1970 { 3.0409598712833082e-07, 50, 20,
1971 0.15707963267948966 },
1972 { 0.030940518122882305, 50, 20,
1973 0.31415926535897931 },
1974 { 0.64134588721659935, 50, 20,
1975 0.47123889803846897 },
1976 { 0.29895244392136394, 50, 20,
1977 0.62831853071795862 },
1978 { 0.25309324781874065, 50, 20,
1979 0.78539816339744828 },
1980 { 0.34368634714931712, 50, 20,
1981 0.94247779607693793 },
1982 { 0.33996764360663956, 50, 20,
1983 1.0995574287564276 },
1984 { 0.12866267745104118, 50, 20,
1985 1.2566370614359172 },
1986 { -0.18201114398922874, 50, 20,
1987 1.4137166941154069 },
1988 { -0.33216683431510857, 50, 20,
1989 1.5707963267948966 },
1990 { -0.18201114398923304, 50, 20,
1991 1.7278759594743860 },
1992 { 0.12866267745103846, 50, 20,
1993 1.8849555921538759 },
1994 { 0.33996764360663906, 50, 20,
1995 2.0420352248333655 },
1996 { 0.34368634714931712, 50, 20,
1997 2.1991148575128552 },
1998 { 0.25309324781874065, 50, 20,
1999 2.3561944901923448 },
2000 { 0.29895244392136738, 50, 20,
2001 2.5132741228718345 },
2002 { 0.64134588721659791, 50, 20,
2003 2.6703537555513241 },
2004 { 0.030940518122882305, 50, 20,
2005 2.8274333882308138 },
2006 { 3.0409598712835877e-07, 50, 20,
2007 2.9845130209103035 },
2008 { 0.0000000000000000, 50, 20,
2009 3.1415926535897931 },
2010 };
2011
2012 // Test function for l=50, m=20.
2013 template <typename Tp>
2014 void test027()
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(data027)
2020 / sizeof(testcase_sph_legendre<double>);
2021 for (unsigned int i = 0; i < num_datum; ++i)
2022 {
2023 const Tp f = std::tr1::sph_legendre(Tp(data027[i].l), Tp(data027[i].m),
2024 Tp(data027[i].theta));
2025 const Tp f0 = data027[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(5.0000000000000039e-13));
2038 }
2039
2040 // Test data for l=50, m=50.
2041 testcase_sph_legendre<double> data028[] = {
2042 { 0.0000000000000000, 50, 50,
2043 0.0000000000000000 },
2044 { 4.1649039898151844e-41, 50, 50,
2045 0.15707963267948966 },
2046 { 2.5240684647724192e-26, 50, 50,
2047 0.31415926535897931 },
2048 { 5.6927376423967334e-18, 50, 50,
2049 0.47123889803846897 },
2050 { 2.3116239814797057e-12, 50, 50,
2051 0.62831853071795862 },
2052 { 2.3835981241325311e-08, 50, 50,
2053 0.78539816339744828 },
2054 { 1.9992410287270356e-05, 50, 50,
2055 0.94247779607693793 },
2056 { 0.0024947505670829791, 50, 50,
2057 1.0995574287564276 },
2058 { 0.065057774647971175, 50, 50,
2059 1.2566370614359172 },
2060 { 0.43050607056732243, 50, 50,
2061 1.4137166941154069 },
2062 { 0.79980281171531975, 50, 50,
2063 1.5707963267948966 },
2064 { 0.43050607056732360, 50, 50,
2065 1.7278759594743860 },
2066 { 0.065057774647971384, 50, 50,
2067 1.8849555921538759 },
2068 { 0.0024947505670829856, 50, 50,
2069 2.0420352248333655 },
2070 { 1.9992410287270356e-05, 50, 50,
2071 2.1991148575128552 },
2072 { 2.3835981241325311e-08, 50, 50,
2073 2.3561944901923448 },
2074 { 2.3116239814797222e-12, 50, 50,
2075 2.5132741228718345 },
2076 { 5.6927376423968544e-18, 50, 50,
2077 2.6703537555513241 },
2078 { 2.5240684647724192e-26, 50, 50,
2079 2.8274333882308138 },
2080 { 4.1649039898161316e-41, 50, 50,
2081 2.9845130209103035 },
2082 { 0.0000000000000000, 50, 50,
2083 3.1415926535897931 },
2084 };
2085
2086 // Test function for l=50, m=50.
2087 template <typename Tp>
2088 void test028()
2089 {
2090 const Tp eps = std::numeric_limits<Tp>::epsilon();
2091 Tp max_abs_diff = -Tp(1);
2092 Tp max_abs_frac = -Tp(1);
2093 unsigned int num_datum = sizeof(data028)
2094 / sizeof(testcase_sph_legendre<double>);
2095 for (unsigned int i = 0; i < num_datum; ++i)
2096 {
2097 const Tp f = std::tr1::sph_legendre(Tp(data028[i].l), Tp(data028[i].m),
2098 Tp(data028[i].theta));
2099 const Tp f0 = data028[i].f0;
2100 const Tp diff = f - f0;
2101 if (std::abs(diff) > max_abs_diff)
2102 max_abs_diff = std::abs(diff);
2103 if (std::abs(f0) > Tp(10) * eps
2104 && std::abs(f) > Tp(10) * eps)
2105 {
2106 const Tp frac = diff / f0;
2107 if (std::abs(frac) > max_abs_frac)
2108 max_abs_frac = std::abs(frac);
2109 }
2110 }
2111 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2112 }
2113
2114 // Test data for l=100, m=0.
2115 testcase_sph_legendre<double> data029[] = {
2116 { 3.9993839251484076, 100, 0,
2117 0.0000000000000000 },
2118 { -0.60770160285935471, 100, 0,
2119 0.15707963267948966 },
2120 { 0.46193027883956100, 100, 0,
2121 0.31415926535897931 },
2122 { -0.40218718869815234, 100, 0,
2123 0.47123889803846897 },
2124 { 0.36960201406910737, 100, 0,
2125 0.62831853071795862 },
2126 { -0.34953726547378611, 100, 0,
2127 0.78539816339744828 },
2128 { 0.33646959352497846, 100, 0,
2129 0.94247779607693793 },
2130 { -0.32784733067663169, 100, 0,
2131 1.0995574287564276 },
2132 { 0.32235624474047936, 100, 0,
2133 1.2566370614359172 },
2134 { -0.31929330706601283, 100, 0,
2135 1.4137166941154069 },
2136 { 0.31830791662110325, 100, 0,
2137 1.5707963267948966 },
2138 { -0.31929330706601389, 100, 0,
2139 1.7278759594743860 },
2140 { 0.32235624474048052, 100, 0,
2141 1.8849555921538759 },
2142 { -0.32784733067663291, 100, 0,
2143 2.0420352248333655 },
2144 { 0.33646959352497846, 100, 0,
2145 2.1991148575128552 },
2146 { -0.34953726547378611, 100, 0,
2147 2.3561944901923448 },
2148 { 0.36960201406911114, 100, 0,
2149 2.5132741228718345 },
2150 { -0.40218718869815695, 100, 0,
2151 2.6703537555513241 },
2152 { 0.46193027883956100, 100, 0,
2153 2.8274333882308138 },
2154 { -0.60770160285939478, 100, 0,
2155 2.9845130209103035 },
2156 { 3.9993839251484076, 100, 0,
2157 3.1415926535897931 },
2158 };
2159
2160 // Test function for l=100, m=0.
2161 template <typename Tp>
2162 void test029()
2163 {
2164 const Tp eps = std::numeric_limits<Tp>::epsilon();
2165 Tp max_abs_diff = -Tp(1);
2166 Tp max_abs_frac = -Tp(1);
2167 unsigned int num_datum = sizeof(data029)
2168 / sizeof(testcase_sph_legendre<double>);
2169 for (unsigned int i = 0; i < num_datum; ++i)
2170 {
2171 const Tp f = std::tr1::sph_legendre(Tp(data029[i].l), Tp(data029[i].m),
2172 Tp(data029[i].theta));
2173 const Tp f0 = data029[i].f0;
2174 const Tp diff = f - f0;
2175 if (std::abs(diff) > max_abs_diff)
2176 max_abs_diff = std::abs(diff);
2177 if (std::abs(f0) > Tp(10) * eps
2178 && std::abs(f) > Tp(10) * eps)
2179 {
2180 const Tp frac = diff / f0;
2181 if (std::abs(frac) > max_abs_frac)
2182 max_abs_frac = std::abs(frac);
2183 }
2184 }
2185 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
2186 }
2187
2188 // Test data for l=100, m=1.
2189 testcase_sph_legendre<double> data030[] = {
2190 { 0.0000000000000000, 100, 1,
2191 0.0000000000000000 },
2192 { -0.50851949013719622, 100, 1,
2193 0.15707963267948966 },
2194 { 0.33129641402221310, 100, 1,
2195 0.31415926535897931 },
2196 { -0.24390405750942562, 100, 1,
2197 0.47123889803846897 },
2198 { 0.18659755088414165, 100, 1,
2199 0.62831853071795862 },
2200 { -0.14355908970516640, 100, 1,
2201 0.78539816339744828 },
2202 { 0.10844906813251093, 100, 1,
2203 0.94247779607693793 },
2204 { -0.078100088690859812, 100, 1,
2205 1.0995574287564276 },
2206 { 0.050670002998304528, 100, 1,
2207 1.2566370614359172 },
2208 { -0.024941251747138762, 100, 1,
2209 1.4137166941154069 },
2210 { 1.9587949830851639e-15, 100, 1,
2211 1.5707963267948966 },
2212 { 0.024941251747127649, 100, 1,
2213 1.7278759594743860 },
2214 { -0.050670002998298595, 100, 1,
2215 1.8849555921538759 },
2216 { 0.078100088690855676, 100, 1,
2217 2.0420352248333655 },
2218 { -0.10844906813251093, 100, 1,
2219 2.1991148575128552 },
2220 { 0.14355908970516640, 100, 1,
2221 2.3561944901923448 },
2222 { -0.18659755088413349, 100, 1,
2223 2.5132741228718345 },
2224 { 0.24390405750941485, 100, 1,
2225 2.6703537555513241 },
2226 { -0.33129641402221310, 100, 1,
2227 2.8274333882308138 },
2228 { 0.50851949013714548, 100, 1,
2229 2.9845130209103035 },
2230 { 0.0000000000000000, 100, 1,
2231 3.1415926535897931 },
2232 };
2233
2234 // Test function for l=100, m=1.
2235 template <typename Tp>
2236 void test030()
2237 {
2238 const Tp eps = std::numeric_limits<Tp>::epsilon();
2239 Tp max_abs_diff = -Tp(1);
2240 Tp max_abs_frac = -Tp(1);
2241 unsigned int num_datum = sizeof(data030)
2242 / sizeof(testcase_sph_legendre<double>);
2243 for (unsigned int i = 0; i < num_datum; ++i)
2244 {
2245 const Tp f = std::tr1::sph_legendre(Tp(data030[i].l), Tp(data030[i].m),
2246 Tp(data030[i].theta));
2247 const Tp f0 = data030[i].f0;
2248 const Tp diff = f - f0;
2249 if (std::abs(diff) > max_abs_diff)
2250 max_abs_diff = std::abs(diff);
2251 if (std::abs(f0) > Tp(10) * eps
2252 && std::abs(f) > Tp(10) * eps)
2253 {
2254 const Tp frac = diff / f0;
2255 if (std::abs(frac) > max_abs_frac)
2256 max_abs_frac = std::abs(frac);
2257 }
2258 }
2259 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
2260 }
2261
2262 // Test data for l=100, m=2.
2263 testcase_sph_legendre<double> data031[] = {
2264 { 0.0000000000000000, 100, 2,
2265 0.0000000000000000 },
2266 { 0.67166274297194040, 100, 2,
2267 0.15707963267948966 },
2268 { -0.48226933687995144, 100, 2,
2269 0.31415926535897931 },
2270 { 0.41175421895715447, 100, 2,
2271 0.47123889803846897 },
2272 { -0.37475021787822460, 100, 2,
2273 0.62831853071795862 },
2274 { 0.35242909383605475, 100, 2,
2275 0.78539816339744828 },
2276 { -0.33807110409160002, 100, 2,
2277 0.94247779607693793 },
2278 { 0.32867180390709999, 100, 2,
2279 1.0995574287564276 },
2280 { -0.32271583790278469, 100, 2,
2281 1.2566370614359172 },
2282 { 0.31940354677687433, 100, 2,
2283 1.4137166941154069 },
2284 { -0.31833943693772526, 100, 2,
2285 1.5707963267948966 },
2286 { 0.31940354677687521, 100, 2,
2287 1.7278759594743860 },
2288 { -0.32271583790278524, 100, 2,
2289 1.8849555921538759 },
2290 { 0.32867180390710143, 100, 2,
2291 2.0420352248333655 },
2292 { -0.33807110409160002, 100, 2,
2293 2.1991148575128552 },
2294 { 0.35242909383605475, 100, 2,
2295 2.3561944901923448 },
2296 { -0.37475021787822771, 100, 2,
2297 2.5132741228718345 },
2298 { 0.41175421895716069, 100, 2,
2299 2.6703537555513241 },
2300 { -0.48226933687995144, 100, 2,
2301 2.8274333882308138 },
2302 { 0.67166274297196804, 100, 2,
2303 2.9845130209103035 },
2304 { 0.0000000000000000, 100, 2,
2305 3.1415926535897931 },
2306 };
2307
2308 // Test function for l=100, m=2.
2309 template <typename Tp>
2310 void test031()
2311 {
2312 const Tp eps = std::numeric_limits<Tp>::epsilon();
2313 Tp max_abs_diff = -Tp(1);
2314 Tp max_abs_frac = -Tp(1);
2315 unsigned int num_datum = sizeof(data031)
2316 / sizeof(testcase_sph_legendre<double>);
2317 for (unsigned int i = 0; i < num_datum; ++i)
2318 {
2319 const Tp f = std::tr1::sph_legendre(Tp(data031[i].l), Tp(data031[i].m),
2320 Tp(data031[i].theta));
2321 const Tp f0 = data031[i].f0;
2322 const Tp diff = f - f0;
2323 if (std::abs(diff) > max_abs_diff)
2324 max_abs_diff = std::abs(diff);
2325 if (std::abs(f0) > Tp(10) * eps
2326 && std::abs(f) > Tp(10) * eps)
2327 {
2328 const Tp frac = diff / f0;
2329 if (std::abs(frac) > max_abs_frac)
2330 max_abs_frac = std::abs(frac);
2331 }
2332 }
2333 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2334 }
2335
2336 // Test data for l=100, m=5.
2337 testcase_sph_legendre<double> data032[] = {
2338 { 0.0000000000000000, 100, 5,
2339 0.0000000000000000 },
2340 { 0.062564361105907143, 100, 5,
2341 0.15707963267948966 },
2342 { 0.14179554455880186, 100, 5,
2343 0.31415926535897931 },
2344 { -0.14356866942906019, 100, 5,
2345 0.47123889803846897 },
2346 { 0.12355483388448507, 100, 5,
2347 0.62831853071795862 },
2348 { -0.10090029999681098, 100, 5,
2349 0.78539816339744828 },
2350 { 0.078905134460230564, 100, 5,
2351 0.94247779607693793 },
2352 { -0.058040182398187236, 100, 5,
2353 1.0995574287564276 },
2354 { 0.038142759389484152, 100, 5,
2355 1.2566370614359172 },
2356 { -0.018906264170660277, 100, 5,
2357 1.4137166941154069 },
2358 { 1.9576303042914544e-15, 100, 5,
2359 1.5707963267948966 },
2360 { 0.018906264170649747, 100, 5,
2361 1.7278759594743860 },
2362 { -0.038142759389478524, 100, 5,
2363 1.8849555921538759 },
2364 { 0.058040182398182996, 100, 5,
2365 2.0420352248333655 },
2366 { -0.078905134460230564, 100, 5,
2367 2.1991148575128552 },
2368 { 0.10090029999681098, 100, 5,
2369 2.3561944901923448 },
2370 { -0.12355483388447780, 100, 5,
2371 2.5132741228718345 },
2372 { 0.14356866942904903, 100, 5,
2373 2.6703537555513241 },
2374 { -0.14179554455880186, 100, 5,
2375 2.8274333882308138 },
2376 { -0.062564361105959004, 100, 5,
2377 2.9845130209103035 },
2378 { 0.0000000000000000, 100, 5,
2379 3.1415926535897931 },
2380 };
2381
2382 // Test function for l=100, m=5.
2383 template <typename Tp>
2384 void test032()
2385 {
2386 const Tp eps = std::numeric_limits<Tp>::epsilon();
2387 Tp max_abs_diff = -Tp(1);
2388 Tp max_abs_frac = -Tp(1);
2389 unsigned int num_datum = sizeof(data032)
2390 / sizeof(testcase_sph_legendre<double>);
2391 for (unsigned int i = 0; i < num_datum; ++i)
2392 {
2393 const Tp f = std::tr1::sph_legendre(Tp(data032[i].l), Tp(data032[i].m),
2394 Tp(data032[i].theta));
2395 const Tp f0 = data032[i].f0;
2396 const Tp diff = f - f0;
2397 if (std::abs(diff) > max_abs_diff)
2398 max_abs_diff = std::abs(diff);
2399 if (std::abs(f0) > Tp(10) * eps
2400 && std::abs(f) > Tp(10) * eps)
2401 {
2402 const Tp frac = diff / f0;
2403 if (std::abs(frac) > max_abs_frac)
2404 max_abs_frac = std::abs(frac);
2405 }
2406 }
2407 VERIFY(max_abs_frac < Tp(5.0000000000000029e-12));
2408 }
2409
2410 // Test data for l=100, m=10.
2411 testcase_sph_legendre<double> data033[] = {
2412 { 0.0000000000000000, 100, 10,
2413 0.0000000000000000 },
2414 { -0.75366545187995670, 100, 10,
2415 0.15707963267948966 },
2416 { -0.35914570017277186, 100, 10,
2417 0.31415926535897931 },
2418 { 0.43480692911578245, 100, 10,
2419 0.47123889803846897 },
2420 { -0.40862111080315705, 100, 10,
2421 0.62831853071795862 },
2422 { 0.37832688692909400, 100, 10,
2423 0.78539816339744828 },
2424 { -0.35484056194773472, 100, 10,
2425 0.94247779607693793 },
2426 { 0.33821981171196336, 100, 10,
2427 1.0995574287564276 },
2428 { -0.32729120767830605, 100, 10,
2429 1.2566370614359172 },
2430 { 0.32110336937091455, 100, 10,
2431 1.4137166941154069 },
2432 { -0.31910064020036194, 100, 10,
2433 1.5707963267948966 },
2434 { 0.32110336937091488, 100, 10,
2435 1.7278759594743860 },
2436 { -0.32729120767830577, 100, 10,
2437 1.8849555921538759 },
2438 { 0.33821981171196341, 100, 10,
2439 2.0420352248333655 },
2440 { -0.35484056194773472, 100, 10,
2441 2.1991148575128552 },
2442 { 0.37832688692909400, 100, 10,
2443 2.3561944901923448 },
2444 { -0.40862111080315433, 100, 10,
2445 2.5132741228718345 },
2446 { 0.43480692911577806, 100, 10,
2447 2.6703537555513241 },
2448 { -0.35914570017277186, 100, 10,
2449 2.8274333882308138 },
2450 { -0.75366545187998180, 100, 10,
2451 2.9845130209103035 },
2452 { 0.0000000000000000, 100, 10,
2453 3.1415926535897931 },
2454 };
2455
2456 // Test function for l=100, m=10.
2457 template <typename Tp>
2458 void test033()
2459 {
2460 const Tp eps = std::numeric_limits<Tp>::epsilon();
2461 Tp max_abs_diff = -Tp(1);
2462 Tp max_abs_frac = -Tp(1);
2463 unsigned int num_datum = sizeof(data033)
2464 / sizeof(testcase_sph_legendre<double>);
2465 for (unsigned int i = 0; i < num_datum; ++i)
2466 {
2467 const Tp f = std::tr1::sph_legendre(Tp(data033[i].l), Tp(data033[i].m),
2468 Tp(data033[i].theta));
2469 const Tp f0 = data033[i].f0;
2470 const Tp diff = f - f0;
2471 if (std::abs(diff) > max_abs_diff)
2472 max_abs_diff = std::abs(diff);
2473 if (std::abs(f0) > Tp(10) * eps
2474 && std::abs(f) > Tp(10) * eps)
2475 {
2476 const Tp frac = diff / f0;
2477 if (std::abs(frac) > max_abs_frac)
2478 max_abs_frac = std::abs(frac);
2479 }
2480 }
2481 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
2482 }
2483
2484 // Test data for l=100, m=20.
2485 testcase_sph_legendre<double> data034[] = {
2486 { 0.0000000000000000, 100, 20,
2487 0.0000000000000000 },
2488 { 0.053569660841553138, 100, 20,
2489 0.15707963267948966 },
2490 { 0.57154926874732426, 100, 20,
2491 0.31415926535897931 },
2492 { 0.47536909969585828, 100, 20,
2493 0.47123889803846897 },
2494 { -0.28882554564109014, 100, 20,
2495 0.62831853071795862 },
2496 { 0.020116179014049645, 100, 20,
2497 0.78539816339744828 },
2498 { 0.14752195931706580, 100, 20,
2499 0.94247779607693793 },
2500 { -0.24069428588868527, 100, 20,
2501 1.0995574287564276 },
2502 { 0.29031796025014395, 100, 20,
2503 1.2566370614359172 },
2504 { -0.31437256851143475, 100, 20,
2505 1.4137166941154069 },
2506 { 0.32153954851141792, 100, 20,
2507 1.5707963267948966 },
2508 { -0.31437256851143192, 100, 20,
2509 1.7278759594743860 },
2510 { 0.29031796025014112, 100, 20,
2511 1.8849555921538759 },
2512 { -0.24069428588868211, 100, 20,
2513 2.0420352248333655 },
2514 { 0.14752195931706580, 100, 20,
2515 2.1991148575128552 },
2516 { 0.020116179014049645, 100, 20,
2517 2.3561944901923448 },
2518 { -0.28882554564109658, 100, 20,
2519 2.5132741228718345 },
2520 { 0.47536909969585378, 100, 20,
2521 2.6703537555513241 },
2522 { 0.57154926874732426, 100, 20,
2523 2.8274333882308138 },
2524 { 0.053569660841557065, 100, 20,
2525 2.9845130209103035 },
2526 { 0.0000000000000000, 100, 20,
2527 3.1415926535897931 },
2528 };
2529
2530 // Test function for l=100, m=20.
2531 template <typename Tp>
2532 void test034()
2533 {
2534 const Tp eps = std::numeric_limits<Tp>::epsilon();
2535 Tp max_abs_diff = -Tp(1);
2536 Tp max_abs_frac = -Tp(1);
2537 unsigned int num_datum = sizeof(data034)
2538 / sizeof(testcase_sph_legendre<double>);
2539 for (unsigned int i = 0; i < num_datum; ++i)
2540 {
2541 const Tp f = std::tr1::sph_legendre(Tp(data034[i].l), Tp(data034[i].m),
2542 Tp(data034[i].theta));
2543 const Tp f0 = data034[i].f0;
2544 const Tp diff = f - f0;
2545 if (std::abs(diff) > max_abs_diff)
2546 max_abs_diff = std::abs(diff);
2547 if (std::abs(f0) > Tp(10) * eps
2548 && std::abs(f) > Tp(10) * eps)
2549 {
2550 const Tp frac = diff / f0;
2551 if (std::abs(frac) > max_abs_frac)
2552 max_abs_frac = std::abs(frac);
2553 }
2554 }
2555 VERIFY(max_abs_frac < Tp(2.5000000000000015e-12));
2556 }
2557
2558 // Test data for l=100, m=50.
2559 testcase_sph_legendre<double> data035[] = {
2560 { 0.0000000000000000, 100, 50,
2561 0.0000000000000000 },
2562 { 3.3047910392590630e-21, 100, 50,
2563 0.15707963267948966 },
2564 { 1.0592655372554983e-07, 100, 50,
2565 0.31415926535897931 },
2566 { 0.080418744223952635, 100, 50,
2567 0.47123889803846897 },
2568 { -0.56450600580393062, 100, 50,
2569 0.62831853071795862 },
2570 { 0.33338739844741766, 100, 50,
2571 0.78539816339744828 },
2572 { 0.39741714816514678, 100, 50,
2573 0.94247779607693793 },
2574 { 0.35223993750972293, 100, 50,
2575 1.0995574287564276 },
2576 { 0.17885891940721749, 100, 50,
2577 1.2566370614359172 },
2578 { -0.15341660126461953, 100, 50,
2579 1.4137166941154069 },
2580 { -0.34175924303503102, 100, 50,
2581 1.5707963267948966 },
2582 { -0.15341660126462864, 100, 50,
2583 1.7278759594743860 },
2584 { 0.17885891940721332, 100, 50,
2585 1.8849555921538759 },
2586 { 0.35223993750972149, 100, 50,
2587 2.0420352248333655 },
2588 { 0.39741714816514678, 100, 50,
2589 2.1991148575128552 },
2590 { 0.33338739844741766, 100, 50,
2591 2.3561944901923448 },
2592 { -0.56450600580392785, 100, 50,
2593 2.5132741228718345 },
2594 { 0.080418744223953439, 100, 50,
2595 2.6703537555513241 },
2596 { 1.0592655372554983e-07, 100, 50,
2597 2.8274333882308138 },
2598 { 3.3047910392597871e-21, 100, 50,
2599 2.9845130209103035 },
2600 { 0.0000000000000000, 100, 50,
2601 3.1415926535897931 },
2602 };
2603
2604 // Test function for l=100, m=50.
2605 template <typename Tp>
2606 void test035()
2607 {
2608 const Tp eps = std::numeric_limits<Tp>::epsilon();
2609 Tp max_abs_diff = -Tp(1);
2610 Tp max_abs_frac = -Tp(1);
2611 unsigned int num_datum = sizeof(data035)
2612 / sizeof(testcase_sph_legendre<double>);
2613 for (unsigned int i = 0; i < num_datum; ++i)
2614 {
2615 const Tp f = std::tr1::sph_legendre(Tp(data035[i].l), Tp(data035[i].m),
2616 Tp(data035[i].theta));
2617 const Tp f0 = data035[i].f0;
2618 const Tp diff = f - f0;
2619 if (std::abs(diff) > max_abs_diff)
2620 max_abs_diff = std::abs(diff);
2621 if (std::abs(f0) > Tp(10) * eps
2622 && std::abs(f) > Tp(10) * eps)
2623 {
2624 const Tp frac = diff / f0;
2625 if (std::abs(frac) > max_abs_frac)
2626 max_abs_frac = std::abs(frac);
2627 }
2628 }
2629 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
2630 }
2631
2632 // Test data for l=100, m=100.
2633 testcase_sph_legendre<double> data036[] = {
2634 { 0.0000000000000000, 100, 100,
2635 0.0000000000000000 },
2636 { 2.5744136608862186e-81, 100, 100,
2637 0.15707963267948966 },
2638 { 9.4551974868956498e-52, 100, 100,
2639 0.31415926535897931 },
2640 { 4.8096190703396912e-35, 100, 100,
2641 0.47123889803846897 },
2642 { 7.9305393636343450e-24, 100, 100,
2643 0.62831853071795862 },
2644 { 8.4320740610946652e-16, 100, 100,
2645 0.78539816339744828 },
2646 { 5.9319660146027522e-10, 100, 100,
2647 0.94247779607693793 },
2648 { 9.2368225946796921e-06, 100, 100,
2649 1.0995574287564276 },
2650 { 0.0062815489742043982, 100, 100,
2651 1.2566370614359172 },
2652 { 0.27505966018176986, 100, 100,
2653 1.4137166941154069 },
2654 { 0.94936713998764621, 100, 100,
2655 1.5707963267948966 },
2656 { 0.27505966018177136, 100, 100,
2657 1.7278759594743860 },
2658 { 0.0062815489742044433, 100, 100,
2659 1.8849555921538759 },
2660 { 9.2368225946797582e-06, 100, 100,
2661 2.0420352248333655 },
2662 { 5.9319660146027522e-10, 100, 100,
2663 2.1991148575128552 },
2664 { 8.4320740610946652e-16, 100, 100,
2665 2.3561944901923448 },
2666 { 7.9305393636344581e-24, 100, 100,
2667 2.5132741228718345 },
2668 { 4.8096190703399648e-35, 100, 100,
2669 2.6703537555513241 },
2670 { 9.4551974868956498e-52, 100, 100,
2671 2.8274333882308138 },
2672 { 2.5744136608873895e-81, 100, 100,
2673 2.9845130209103035 },
2674 { 0.0000000000000000, 100, 100,
2675 3.1415926535897931 },
2676 };
2677
2678 // Test function for l=100, m=100.
2679 template <typename Tp>
2680 void test036()
2681 {
2682 const Tp eps = std::numeric_limits<Tp>::epsilon();
2683 Tp max_abs_diff = -Tp(1);
2684 Tp max_abs_frac = -Tp(1);
2685 unsigned int num_datum = sizeof(data036)
2686 / sizeof(testcase_sph_legendre<double>);
2687 for (unsigned int i = 0; i < num_datum; ++i)
2688 {
2689 const Tp f = std::tr1::sph_legendre(Tp(data036[i].l), Tp(data036[i].m),
2690 Tp(data036[i].theta));
2691 const Tp f0 = data036[i].f0;
2692 const Tp diff = f - f0;
2693 if (std::abs(diff) > max_abs_diff)
2694 max_abs_diff = std::abs(diff);
2695 if (std::abs(f0) > Tp(10) * eps
2696 && std::abs(f) > Tp(10) * eps)
2697 {
2698 const Tp frac = diff / f0;
2699 if (std::abs(frac) > max_abs_frac)
2700 max_abs_frac = std::abs(frac);
2701 }
2702 }
2703 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
2704 }
2705
2706 int main(int, char**)
2707 {
2708 test001<double>();
2709 test002<double>();
2710 test003<double>();
2711 test004<double>();
2712 test005<double>();
2713 test006<double>();
2714 test007<double>();
2715 test008<double>();
2716 test009<double>();
2717 test010<double>();
2718 test011<double>();
2719 test012<double>();
2720 test013<double>();
2721 test014<double>();
2722 test015<double>();
2723 test016<double>();
2724 test017<double>();
2725 test018<double>();
2726 test019<double>();
2727 test020<double>();
2728 test021<double>();
2729 test022<double>();
2730 test023<double>();
2731 test024<double>();
2732 test025<double>();
2733 test026<double>();
2734 test027<double>();
2735 test028<double>();
2736 test029<double>();
2737 test030<double>();
2738 test031<double>();
2739 test032<double>();
2740 test033<double>();
2741 test034<double>();
2742 test035<double>();
2743 test036<double>();
2744 return 0;
2745 }
Mirror of https://gcc.gnu.org/git/gcc.git