1// 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net> 2// 3// Copyright (C) 2007-2015 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) \ 30if (!(A)) \ 31 { \ 32 std::cout << "line " << __LINE__ \ 33 << " max_abs_frac = " << max_abs_frac \ 34 << std::endl; \ 35 } 36#else 37#include <testsuite_hooks.h> 38#endif 39#include "../testcase.h" 40 41 42// Test data for l=0, m=0. 43testcase_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. 89template <typename Tp> 90void 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. 117testcase_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. 163template <typename Tp> 164void 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. 191testcase_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. 237template <typename Tp> 238void 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. 265testcase_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. 311template <typename Tp> 312void 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. 339testcase_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. 385template <typename Tp> 386void 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. 413testcase_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. 459template <typename Tp> 460void 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. 487testcase_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. 533template <typename Tp> 534void 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. 561testcase_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. 607template <typename Tp> 608void 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. 635testcase_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. 681template <typename Tp> 682void 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. 709testcase_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. 755template <typename Tp> 756void 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. 783testcase_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. 829template <typename Tp> 830void 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. 857testcase_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. 903template <typename Tp> 904void 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. 931testcase_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. 977template <typename Tp> 978void 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. 1005testcase_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. 1051template <typename Tp> 1052void 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. 1079testcase_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. 1125template <typename Tp> 1126void 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. 1153testcase_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. 1199template <typename Tp> 1200void 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. 1227testcase_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. 1273template <typename Tp> 1274void 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. 1301testcase_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. 1347template <typename Tp> 1348void 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. 1375testcase_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. 1421template <typename Tp> 1422void 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. 1449testcase_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. 1495template <typename Tp> 1496void 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. 1523testcase_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. 1569template <typename Tp> 1570void 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. 1597testcase_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. 1643template <typename Tp> 1644void 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. 1671testcase_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. 1717template <typename Tp> 1718void 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. 1745testcase_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. 1791template <typename Tp> 1792void 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. 1819testcase_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. 1865template <typename Tp> 1866void 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. 1893testcase_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. 1939template <typename Tp> 1940void 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. 1967testcase_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. 2013template <typename Tp> 2014void 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. 2041testcase_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. 2087template <typename Tp> 2088void 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. 2115testcase_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. 2161template <typename Tp> 2162void 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. 2189testcase_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. 2235template <typename Tp> 2236void 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. 2263testcase_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. 2309template <typename Tp> 2310void 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. 2337testcase_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. 2383template <typename Tp> 2384void 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. 2411testcase_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. 2457template <typename Tp> 2458void 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. 2485testcase_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. 2531template <typename Tp> 2532void 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. 2559testcase_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. 2605template <typename Tp> 2606void 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. 2633testcase_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. 2679template <typename Tp> 2680void 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 2706int 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} 2746