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