libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/02_assoc_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 //  assoc_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_assoc_legendre<double> data001[] = {
  45   { 1.0000000000000000, 0, 0,
  46           -1.0000000000000000 },
  47   { 1.0000000000000000, 0, 0,
  48           -0.90000000000000002 },
  49   { 1.0000000000000000, 0, 0,
  50           -0.80000000000000004 },
  51   { 1.0000000000000000, 0, 0,
  52           -0.69999999999999996 },
  53   { 1.0000000000000000, 0, 0,
  54           -0.59999999999999998 },
  55   { 1.0000000000000000, 0, 0,
  56           -0.50000000000000000 },
  57   { 1.0000000000000000, 0, 0,
  58           -0.40000000000000002 },
  59   { 1.0000000000000000, 0, 0,
  60           -0.30000000000000004 },
  61   { 1.0000000000000000, 0, 0,
  62           -0.19999999999999996 },
  63   { 1.0000000000000000, 0, 0,
  64           -0.099999999999999978 },
  65   { 1.0000000000000000, 0, 0,
  66           0.0000000000000000 },
  67   { 1.0000000000000000, 0, 0,
  68           0.10000000000000009 },
  69   { 1.0000000000000000, 0, 0,
  70           0.19999999999999996 },
  71   { 1.0000000000000000, 0, 0,
  72           0.30000000000000004 },
  73   { 1.0000000000000000, 0, 0,
  74           0.39999999999999991 },
  75   { 1.0000000000000000, 0, 0,
  76           0.50000000000000000 },
  77   { 1.0000000000000000, 0, 0,
  78           0.60000000000000009 },
  79   { 1.0000000000000000, 0, 0,
  80           0.69999999999999996 },
  81   { 1.0000000000000000, 0, 0,
  82           0.80000000000000004 },
  83   { 1.0000000000000000, 0, 0,
  84           0.89999999999999991 },
  85   { 1.0000000000000000, 0, 0,
  86           1.0000000000000000 },
  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_assoc_legendre<double>);
  98   for (unsigned int i = 0; i < num_datum; ++i)
  99     {
 100       const Tp f = std::tr1::assoc_legendre(Tp(data001[i].l), Tp(data001[i].m),
 101                    Tp(data001[i].x));
 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_assoc_legendre<double> data002[] = {
 119   { -1.0000000000000000, 1, 0,
 120           -1.0000000000000000 },
 121   { -0.90000000000000002, 1, 0,
 122           -0.90000000000000002 },
 123   { -0.80000000000000004, 1, 0,
 124           -0.80000000000000004 },
 125   { -0.69999999999999996, 1, 0,
 126           -0.69999999999999996 },
 127   { -0.59999999999999998, 1, 0,
 128           -0.59999999999999998 },
 129   { -0.50000000000000000, 1, 0,
 130           -0.50000000000000000 },
 131   { -0.40000000000000002, 1, 0,
 132           -0.40000000000000002 },
 133   { -0.30000000000000004, 1, 0,
 134           -0.30000000000000004 },
 135   { -0.19999999999999996, 1, 0,
 136           -0.19999999999999996 },
 137   { -0.099999999999999978, 1, 0,
 138           -0.099999999999999978 },
 139   { 0.0000000000000000, 1, 0,
 140           0.0000000000000000 },
 141   { 0.10000000000000009, 1, 0,
 142           0.10000000000000009 },
 143   { 0.19999999999999996, 1, 0,
 144           0.19999999999999996 },
 145   { 0.30000000000000004, 1, 0,
 146           0.30000000000000004 },
 147   { 0.39999999999999991, 1, 0,
 148           0.39999999999999991 },
 149   { 0.50000000000000000, 1, 0,
 150           0.50000000000000000 },
 151   { 0.60000000000000009, 1, 0,
 152           0.60000000000000009 },
 153   { 0.69999999999999996, 1, 0,
 154           0.69999999999999996 },
 155   { 0.80000000000000004, 1, 0,
 156           0.80000000000000004 },
 157   { 0.89999999999999991, 1, 0,
 158           0.89999999999999991 },
 159   { 1.0000000000000000, 1, 0,
 160           1.0000000000000000 },
 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_assoc_legendre<double>);
 172   for (unsigned int i = 0; i < num_datum; ++i)
 173     {
 174       const Tp f = std::tr1::assoc_legendre(Tp(data002[i].l), Tp(data002[i].m),
 175                    Tp(data002[i].x));
 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_assoc_legendre<double> data003[] = {
 193   { -0.0000000000000000, 1, 1,
 194           -1.0000000000000000 },
 195   { -0.43588989435406728, 1, 1,
 196           -0.90000000000000002 },
 197   { -0.59999999999999987, 1, 1,
 198           -0.80000000000000004 },
 199   { -0.71414284285428509, 1, 1,
 200           -0.69999999999999996 },
 201   { -0.80000000000000004, 1, 1,
 202           -0.59999999999999998 },
 203   { -0.86602540378443860, 1, 1,
 204           -0.50000000000000000 },
 205   { -0.91651513899116799, 1, 1,
 206           -0.40000000000000002 },
 207   { -0.95393920141694577, 1, 1,
 208           -0.30000000000000004 },
 209   { -0.97979589711327120, 1, 1,
 210           -0.19999999999999996 },
 211   { -0.99498743710661997, 1, 1,
 212           -0.099999999999999978 },
 213   { -1.0000000000000000, 1, 1,
 214           0.0000000000000000 },
 215   { -0.99498743710661997, 1, 1,
 216           0.10000000000000009 },
 217   { -0.97979589711327120, 1, 1,
 218           0.19999999999999996 },
 219   { -0.95393920141694577, 1, 1,
 220           0.30000000000000004 },
 221   { -0.91651513899116799, 1, 1,
 222           0.39999999999999991 },
 223   { -0.86602540378443860, 1, 1,
 224           0.50000000000000000 },
 225   { -0.79999999999999993, 1, 1,
 226           0.60000000000000009 },
 227   { -0.71414284285428509, 1, 1,
 228           0.69999999999999996 },
 229   { -0.59999999999999987, 1, 1,
 230           0.80000000000000004 },
 231   { -0.43588989435406750, 1, 1,
 232           0.89999999999999991 },
 233   { -0.0000000000000000, 1, 1,
 234           1.0000000000000000 },
 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_assoc_legendre<double>);
 246   for (unsigned int i = 0; i < num_datum; ++i)
 247     {
 248       const Tp f = std::tr1::assoc_legendre(Tp(data003[i].l), Tp(data003[i].m),
 249                    Tp(data003[i].x));
 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_assoc_legendre<double> data004[] = {
 267   { 1.0000000000000000, 2, 0,
 268           -1.0000000000000000 },
 269   { 0.71500000000000008, 2, 0,
 270           -0.90000000000000002 },
 271   { 0.46000000000000019, 2, 0,
 272           -0.80000000000000004 },
 273   { 0.23499999999999982, 2, 0,
 274           -0.69999999999999996 },
 275   { 0.039999999999999925, 2, 0,
 276           -0.59999999999999998 },
 277   { -0.12500000000000000, 2, 0,
 278           -0.50000000000000000 },
 279   { -0.25999999999999995, 2, 0,
 280           -0.40000000000000002 },
 281   { -0.36499999999999994, 2, 0,
 282           -0.30000000000000004 },
 283   { -0.44000000000000000, 2, 0,
 284           -0.19999999999999996 },
 285   { -0.48499999999999999, 2, 0,
 286           -0.099999999999999978 },
 287   { -0.50000000000000000, 2, 0,
 288           0.0000000000000000 },
 289   { -0.48499999999999999, 2, 0,
 290           0.10000000000000009 },
 291   { -0.44000000000000000, 2, 0,
 292           0.19999999999999996 },
 293   { -0.36499999999999994, 2, 0,
 294           0.30000000000000004 },
 295   { -0.26000000000000012, 2, 0,
 296           0.39999999999999991 },
 297   { -0.12500000000000000, 2, 0,
 298           0.50000000000000000 },
 299   { 0.040000000000000160, 2, 0,
 300           0.60000000000000009 },
 301   { 0.23499999999999982, 2, 0,
 302           0.69999999999999996 },
 303   { 0.46000000000000019, 2, 0,
 304           0.80000000000000004 },
 305   { 0.71499999999999975, 2, 0,
 306           0.89999999999999991 },
 307   { 1.0000000000000000, 2, 0,
 308           1.0000000000000000 },
 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_assoc_legendre<double>);
 320   for (unsigned int i = 0; i < num_datum; ++i)
 321     {
 322       const Tp f = std::tr1::assoc_legendre(Tp(data004[i].l), Tp(data004[i].m),
 323                    Tp(data004[i].x));
 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_assoc_legendre<double> data005[] = {
 341   { 0.0000000000000000, 2, 1,
 342           -1.0000000000000000 },
 343   { 1.1769027147559816, 2, 1,
 344           -0.90000000000000002 },
 345   { 1.4399999999999999, 2, 1,
 346           -0.80000000000000004 },
 347   { 1.4996999699939983, 2, 1,
 348           -0.69999999999999996 },
 349   { 1.4399999999999999, 2, 1,
 350           -0.59999999999999998 },
 351   { 1.2990381056766580, 2, 1,
 352           -0.50000000000000000 },
 353   { 1.0998181667894018, 2, 1,
 354           -0.40000000000000002 },
 355   { 0.85854528127525132, 2, 1,
 356           -0.30000000000000004 },
 357   { 0.58787753826796263, 2, 1,
 358           -0.19999999999999996 },
 359   { 0.29849623113198592, 2, 1,
 360           -0.099999999999999978 },
 361   { -0.0000000000000000, 2, 1,
 362           0.0000000000000000 },
 363   { -0.29849623113198626, 2, 1,
 364           0.10000000000000009 },
 365   { -0.58787753826796263, 2, 1,
 366           0.19999999999999996 },
 367   { -0.85854528127525132, 2, 1,
 368           0.30000000000000004 },
 369   { -1.0998181667894014, 2, 1,
 370           0.39999999999999991 },
 371   { -1.2990381056766580, 2, 1,
 372           0.50000000000000000 },
 373   { -1.4400000000000002, 2, 1,
 374           0.60000000000000009 },
 375   { -1.4996999699939983, 2, 1,
 376           0.69999999999999996 },
 377   { -1.4399999999999999, 2, 1,
 378           0.80000000000000004 },
 379   { -1.1769027147559821, 2, 1,
 380           0.89999999999999991 },
 381   { -0.0000000000000000, 2, 1,
 382           1.0000000000000000 },
 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_assoc_legendre<double>);
 394   for (unsigned int i = 0; i < num_datum; ++i)
 395     {
 396       const Tp f = std::tr1::assoc_legendre(Tp(data005[i].l), Tp(data005[i].m),
 397                    Tp(data005[i].x));
 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_assoc_legendre<double> data006[] = {
 415   { 0.0000000000000000, 2, 2,
 416           -1.0000000000000000 },
 417   { 0.56999999999999984, 2, 2,
 418           -0.90000000000000002 },
 419   { 1.0799999999999996, 2, 2,
 420           -0.80000000000000004 },
 421   { 1.5300000000000005, 2, 2,
 422           -0.69999999999999996 },
 423   { 1.9200000000000004, 2, 2,
 424           -0.59999999999999998 },
 425   { 2.2500000000000000, 2, 2,
 426           -0.50000000000000000 },
 427   { 2.5200000000000000, 2, 2,
 428           -0.40000000000000002 },
 429   { 2.7300000000000004, 2, 2,
 430           -0.30000000000000004 },
 431   { 2.8799999999999999, 2, 2,
 432           -0.19999999999999996 },
 433   { 2.9700000000000002, 2, 2,
 434           -0.099999999999999978 },
 435   { 3.0000000000000000, 2, 2,
 436           0.0000000000000000 },
 437   { 2.9700000000000002, 2, 2,
 438           0.10000000000000009 },
 439   { 2.8799999999999999, 2, 2,
 440           0.19999999999999996 },
 441   { 2.7300000000000004, 2, 2,
 442           0.30000000000000004 },
 443   { 2.5200000000000000, 2, 2,
 444           0.39999999999999991 },
 445   { 2.2500000000000000, 2, 2,
 446           0.50000000000000000 },
 447   { 1.9199999999999997, 2, 2,
 448           0.60000000000000009 },
 449   { 1.5300000000000005, 2, 2,
 450           0.69999999999999996 },
 451   { 1.0799999999999996, 2, 2,
 452           0.80000000000000004 },
 453   { 0.57000000000000040, 2, 2,
 454           0.89999999999999991 },
 455   { 0.0000000000000000, 2, 2,
 456           1.0000000000000000 },
 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_assoc_legendre<double>);
 468   for (unsigned int i = 0; i < num_datum; ++i)
 469     {
 470       const Tp f = std::tr1::assoc_legendre(Tp(data006[i].l), Tp(data006[i].m),
 471                    Tp(data006[i].x));
 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_assoc_legendre<double> data007[] = {
 489   { -1.0000000000000000, 5, 0,
 490           -1.0000000000000000 },
 491   { 0.041141249999999997, 5, 0,
 492           -0.90000000000000002 },
 493   { 0.39951999999999993, 5, 0,
 494           -0.80000000000000004 },
 495   { 0.36519874999999991, 5, 0,
 496           -0.69999999999999996 },
 497   { 0.15263999999999994, 5, 0,
 498           -0.59999999999999998 },
 499   { -0.089843750000000000, 5, 0,
 500           -0.50000000000000000 },
 501   { -0.27063999999999988, 5, 0,
 502           -0.40000000000000002 },
 503   { -0.34538624999999995, 5, 0,
 504           -0.30000000000000004 },
 505   { -0.30751999999999996, 5, 0,
 506           -0.19999999999999996 },
 507   { -0.17882874999999995, 5, 0,
 508           -0.099999999999999978 },
 509   { 0.0000000000000000, 5, 0,
 510           0.0000000000000000 },
 511   { 0.17882875000000015, 5, 0,
 512           0.10000000000000009 },
 513   { 0.30751999999999996, 5, 0,
 514           0.19999999999999996 },
 515   { 0.34538624999999995, 5, 0,
 516           0.30000000000000004 },
 517   { 0.27064000000000010, 5, 0,
 518           0.39999999999999991 },
 519   { 0.089843750000000000, 5, 0,
 520           0.50000000000000000 },
 521   { -0.15264000000000022, 5, 0,
 522           0.60000000000000009 },
 523   { -0.36519874999999991, 5, 0,
 524           0.69999999999999996 },
 525   { -0.39951999999999993, 5, 0,
 526           0.80000000000000004 },
 527   { -0.041141250000000407, 5, 0,
 528           0.89999999999999991 },
 529   { 1.0000000000000000, 5, 0,
 530           1.0000000000000000 },
 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_assoc_legendre<double>);
 542   for (unsigned int i = 0; i < num_datum; ++i)
 543     {
 544       const Tp f = std::tr1::assoc_legendre(Tp(data007[i].l), Tp(data007[i].m),
 545                    Tp(data007[i].x));
 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_assoc_legendre<double> data008[] = {
 563   { 0.0000000000000000, 5, 1,
 564           -1.0000000000000000 },
 565   { -2.8099369608350973, 5, 1,
 566           -0.90000000000000002 },
 567   { -0.72180000000000089, 5, 1,
 568           -0.80000000000000004 },
 569   { 1.0951826834447254, 5, 1,
 570           -0.69999999999999996 },
 571   { 1.9775999999999998, 5, 1,
 572           -0.59999999999999998 },
 573   { 1.9282596881137892, 5, 1,
 574           -0.50000000000000000 },
 575   { 1.2070504380513685, 5, 1,
 576           -0.40000000000000002 },
 577   { 0.16079837663884430, 5, 1,
 578           -0.30000000000000004 },
 579   { -0.87005875663658538, 5, 1,
 580           -0.19999999999999996 },
 581   { -1.6083350053680323, 5, 1,
 582           -0.099999999999999978 },
 583   { -1.8750000000000000, 5, 1,
 584           0.0000000000000000 },
 585   { -1.6083350053680314, 5, 1,
 586           0.10000000000000009 },
 587   { -0.87005875663658538, 5, 1,
 588           0.19999999999999996 },
 589   { 0.16079837663884430, 5, 1,
 590           0.30000000000000004 },
 591   { 1.2070504380513674, 5, 1,
 592           0.39999999999999991 },
 593   { 1.9282596881137892, 5, 1,
 594           0.50000000000000000 },
 595   { 1.9775999999999996, 5, 1,
 596           0.60000000000000009 },
 597   { 1.0951826834447254, 5, 1,
 598           0.69999999999999996 },
 599   { -0.72180000000000089, 5, 1,
 600           0.80000000000000004 },
 601   { -2.8099369608350959, 5, 1,
 602           0.89999999999999991 },
 603   { 0.0000000000000000, 5, 1,
 604           1.0000000000000000 },
 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_assoc_legendre<double>);
 616   for (unsigned int i = 0; i < num_datum; ++i)
 617     {
 618       const Tp f = std::tr1::assoc_legendre(Tp(data008[i].l), Tp(data008[i].m),
 619                    Tp(data008[i].x));
 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_assoc_legendre<double> data009[] = {
 637   { 0.0000000000000000, 5, 2,
 638           -1.0000000000000000 },
 639   { -12.837824999999995, 5, 2,
 640           -0.90000000000000002 },
 641   { -13.910399999999997, 5, 2,
 642           -0.80000000000000004 },
 643   { -8.8089749999999984, 5, 2,
 644           -0.69999999999999996 },
 645   { -1.6128000000000009, 5, 2,
 646           -0.59999999999999998 },
 647   { 4.9218750000000000, 5, 2,
 648           -0.50000000000000000 },
 649   { 9.1728000000000005, 5, 2,
 650           -0.40000000000000002 },
 651   { 10.462725000000001, 5, 2,
 652           -0.30000000000000004 },
 653   { 8.8703999999999983, 5, 2,
 654           -0.19999999999999996 },
 655   { 5.0415749999999999, 5, 2,
 656           -0.099999999999999978 },
 657   { -0.0000000000000000, 5, 2,
 658           0.0000000000000000 },
 659   { -5.0415750000000044, 5, 2,
 660           0.10000000000000009 },
 661   { -8.8703999999999983, 5, 2,
 662           0.19999999999999996 },
 663   { -10.462725000000001, 5, 2,
 664           0.30000000000000004 },
 665   { -9.1728000000000005, 5, 2,
 666           0.39999999999999991 },
 667   { -4.9218750000000000, 5, 2,
 668           0.50000000000000000 },
 669   { 1.6128000000000071, 5, 2,
 670           0.60000000000000009 },
 671   { 8.8089749999999984, 5, 2,
 672           0.69999999999999996 },
 673   { 13.910399999999997, 5, 2,
 674           0.80000000000000004 },
 675   { 12.837825000000004, 5, 2,
 676           0.89999999999999991 },
 677   { 0.0000000000000000, 5, 2,
 678           1.0000000000000000 },
 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_assoc_legendre<double>);
 690   for (unsigned int i = 0; i < num_datum; ++i)
 691     {
 692       const Tp f = std::tr1::assoc_legendre(Tp(data009[i].l), Tp(data009[i].m),
 693                    Tp(data009[i].x));
 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_assoc_legendre<double> data010[] = {
 711   { -0.0000000000000000, 5, 5,
 712           -1.0000000000000000 },
 713   { -14.870165800941818, 5, 5,
 714           -0.90000000000000002 },
 715   { -73.483199999999925, 5, 5,
 716           -0.80000000000000004 },
 717   { -175.53238298794764, 5, 5,
 718           -0.69999999999999996 },
 719   { -309.65760000000006, 5, 5,
 720           -0.59999999999999998 },
 721   { -460.34662869916559, 5, 5,
 722           -0.50000000000000000 },
 723   { -611.12496255819883, 5, 5,
 724           -0.40000000000000002 },
 725   { -746.50941479523760, 5, 5,
 726           -0.30000000000000004 },
 727   { -853.31600434671316, 5, 5,
 728           -0.19999999999999996 },
 729   { -921.55189181724734, 5, 5,
 730           -0.099999999999999978 },
 731   { -945.00000000000000, 5, 5,
 732           0.0000000000000000 },
 733   { -921.55189181724734, 5, 5,
 734           0.10000000000000009 },
 735   { -853.31600434671316, 5, 5,
 736           0.19999999999999996 },
 737   { -746.50941479523760, 5, 5,
 738           0.30000000000000004 },
 739   { -611.12496255819883, 5, 5,
 740           0.39999999999999991 },
 741   { -460.34662869916559, 5, 5,
 742           0.50000000000000000 },
 743   { -309.65759999999989, 5, 5,
 744           0.60000000000000009 },
 745   { -175.53238298794764, 5, 5,
 746           0.69999999999999996 },
 747   { -73.483199999999925, 5, 5,
 748           0.80000000000000004 },
 749   { -14.870165800941855, 5, 5,
 750           0.89999999999999991 },
 751   { -0.0000000000000000, 5, 5,
 752           1.0000000000000000 },
 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_assoc_legendre<double>);
 764   for (unsigned int i = 0; i < num_datum; ++i)
 765     {
 766       const Tp f = std::tr1::assoc_legendre(Tp(data010[i].l), Tp(data010[i].m),
 767                    Tp(data010[i].x));
 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_assoc_legendre<double> data011[] = {
 785   { 1.0000000000000000, 10, 0,
 786           -1.0000000000000000 },
 787   { -0.26314561785585977, 10, 0,
 788           -0.90000000000000002 },
 789   { 0.30052979559999998, 10, 0,
 790           -0.80000000000000004 },
 791   { 0.085805795531640333, 10, 0,
 792           -0.69999999999999996 },
 793   { -0.24366274560000006, 10, 0,
 794           -0.59999999999999998 },
 795   { -0.18822860717773438, 10, 0,
 796           -0.50000000000000000 },
 797   { 0.096839064399999869, 10, 0,
 798           -0.40000000000000002 },
 799   { 0.25147634951601561, 10, 0,
 800           -0.30000000000000004 },
 801   { 0.12907202559999989, 10, 0,
 802           -0.19999999999999996 },
 803   { -0.12212499738710947, 10, 0,
 804           -0.099999999999999978 },
 805   { -0.24609375000000000, 10, 0,
 806           0.0000000000000000 },
 807   { -0.12212499738710922, 10, 0,
 808           0.10000000000000009 },
 809   { 0.12907202559999989, 10, 0,
 810           0.19999999999999996 },
 811   { 0.25147634951601561, 10, 0,
 812           0.30000000000000004 },
 813   { 0.096839064400000258, 10, 0,
 814           0.39999999999999991 },
 815   { -0.18822860717773438, 10, 0,
 816           0.50000000000000000 },
 817   { -0.24366274559999987, 10, 0,
 818           0.60000000000000009 },
 819   { 0.085805795531640333, 10, 0,
 820           0.69999999999999996 },
 821   { 0.30052979559999998, 10, 0,
 822           0.80000000000000004 },
 823   { -0.26314561785585888, 10, 0,
 824           0.89999999999999991 },
 825   { 1.0000000000000000, 10, 0,
 826           1.0000000000000000 },
 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_assoc_legendre<double>);
 838   for (unsigned int i = 0; i < num_datum; ++i)
 839     {
 840       const Tp f = std::tr1::assoc_legendre(Tp(data011[i].l), Tp(data011[i].m),
 841                    Tp(data011[i].x));
 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_assoc_legendre<double> data012[] = {
 859   { -0.0000000000000000, 10, 1,
 860           -1.0000000000000000 },
 861   { -3.0438748781479061, 10, 1,
 862           -0.90000000000000002 },
 863   { -0.87614260800000199, 10, 1,
 864           -0.80000000000000004 },
 865   { 2.9685359952934522, 10, 1,
 866           -0.69999999999999996 },
 867   { 1.2511825919999990, 10, 1,
 868           -0.59999999999999998 },
 869   { -2.0066877394361260, 10, 1,
 870           -0.50000000000000000 },
 871   { -2.4822196173476661, 10, 1,
 872           -0.40000000000000002 },
 873   { -0.12309508907433941, 10, 1,
 874           -0.30000000000000004 },
 875   { 2.2468221751958408, 10, 1,
 876           -0.19999999999999996 },
 877   { 2.2472659777983512, 10, 1,
 878           -0.099999999999999978 },
 879   { -0.0000000000000000, 10, 1,
 880           0.0000000000000000 },
 881   { -2.2472659777983530, 10, 1,
 882           0.10000000000000009 },
 883   { -2.2468221751958408, 10, 1,
 884           0.19999999999999996 },
 885   { 0.12309508907433941, 10, 1,
 886           0.30000000000000004 },
 887   { 2.4822196173476643, 10, 1,
 888           0.39999999999999991 },
 889   { 2.0066877394361260, 10, 1,
 890           0.50000000000000000 },
 891   { -1.2511825920000037, 10, 1,
 892           0.60000000000000009 },
 893   { -2.9685359952934522, 10, 1,
 894           0.69999999999999996 },
 895   { 0.87614260800000199, 10, 1,
 896           0.80000000000000004 },
 897   { 3.0438748781479110, 10, 1,
 898           0.89999999999999991 },
 899   { 0.0000000000000000, 10, 1,
 900           1.0000000000000000 },
 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_assoc_legendre<double>);
 912   for (unsigned int i = 0; i < num_datum; ++i)
 913     {
 914       const Tp f = std::tr1::assoc_legendre(Tp(data012[i].l), Tp(data012[i].m),
 915                    Tp(data012[i].x));
 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_assoc_legendre<double> data013[] = {
 933   { 0.0000000000000000, 10, 2,
 934           -1.0000000000000000 },
 935   { 16.376387762496122, 10, 2,
 936           -0.90000000000000002 },
 937   { -35.394657803999991, 10, 2,
 938           -0.80000000000000004 },
 939   { -3.6191429423788892, 10, 2,
 940           -0.69999999999999996 },
 941   { 28.679675904000010, 10, 2,
 942           -0.59999999999999998 },
 943   { 18.388023376464844, 10, 2,
 944           -0.50000000000000000 },
 945   { -12.818955995999996, 10, 2,
 946           -0.40000000000000002 },
 947   { -27.739821675972660, 10, 2,
 948           -0.30000000000000004 },
 949   { -13.280661503999987, 10, 2,
 950           -0.19999999999999996 },
 951   { 13.885467170308596, 10, 2,
 952           -0.099999999999999978 },
 953   { 27.070312500000000, 10, 2,
 954           0.0000000000000000 },
 955   { 13.885467170308573, 10, 2,
 956           0.10000000000000009 },
 957   { -13.280661503999987, 10, 2,
 958           0.19999999999999996 },
 959   { -27.739821675972660, 10, 2,
 960           0.30000000000000004 },
 961   { -12.818955996000019, 10, 2,
 962           0.39999999999999991 },
 963   { 18.388023376464844, 10, 2,
 964           0.50000000000000000 },
 965   { 28.679675903999982, 10, 2,
 966           0.60000000000000009 },
 967   { -3.6191429423788892, 10, 2,
 968           0.69999999999999996 },
 969   { -35.394657803999991, 10, 2,
 970           0.80000000000000004 },
 971   { 16.376387762495984, 10, 2,
 972           0.89999999999999991 },
 973   { 0.0000000000000000, 10, 2,
 974           1.0000000000000000 },
 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_assoc_legendre<double>);
 986   for (unsigned int i = 0; i < num_datum; ++i)
 987     {
 988       const Tp f = std::tr1::assoc_legendre(Tp(data013[i].l), Tp(data013[i].m),
 989                    Tp(data013[i].x));
 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_assoc_legendre<double> data014[] = {
1007   { 0.0000000000000000, 10, 5,
1008           -1.0000000000000000 },
1009   { 21343.618518164669, 10, 5,
1010           -0.90000000000000002 },
1011   { 40457.016407807983, 10, 5,
1012           -0.80000000000000004 },
1013   { 20321.279317331318, 10, 5,
1014           -0.69999999999999996 },
1015   { -14410.820616192013, 10, 5,
1016           -0.59999999999999998 },
1017   { -30086.169706116176, 10, 5,
1018           -0.50000000000000000 },
1019   { -17177.549337582859, 10, 5,
1020           -0.40000000000000002 },
1021   { 9272.5119495412346, 10, 5,
1022           -0.30000000000000004 },
1023   { 26591.511184414714, 10, 5,
1024           -0.19999999999999996 },
1025   { 21961.951238504211, 10, 5,
1026           -0.099999999999999978 },
1027   { -0.0000000000000000, 10, 5,
1028           0.0000000000000000 },
1029   { -21961.951238504229, 10, 5,
1030           0.10000000000000009 },
1031   { -26591.511184414714, 10, 5,
1032           0.19999999999999996 },
1033   { -9272.5119495412346, 10, 5,
1034           0.30000000000000004 },
1035   { 17177.549337582830, 10, 5,
1036           0.39999999999999991 },
1037   { 30086.169706116176, 10, 5,
1038           0.50000000000000000 },
1039   { 14410.820616191975, 10, 5,
1040           0.60000000000000009 },
1041   { -20321.279317331318, 10, 5,
1042           0.69999999999999996 },
1043   { -40457.016407807983, 10, 5,
1044           0.80000000000000004 },
1045   { -21343.618518164698, 10, 5,
1046           0.89999999999999991 },
1047   { 0.0000000000000000, 10, 5,
1048           1.0000000000000000 },
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_assoc_legendre<double>);
1060   for (unsigned int i = 0; i < num_datum; ++i)
1061     {
1062       const Tp f = std::tr1::assoc_legendre(Tp(data014[i].l), Tp(data014[i].m),
1063                    Tp(data014[i].x));
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_assoc_legendre<double> data015[] = {
1081   { 0.0000000000000000, 10, 10,
1082           -1.0000000000000000 },
1083   { 162117.40078784220, 10, 10,
1084           -0.90000000000000002 },
1085   { 3958896.3481267113, 10, 10,
1086           -0.80000000000000004 },
1087   { 22589806.343887307, 10, 10,
1088           -0.69999999999999996 },
1089   { 70300999.121633321, 10, 10,
1090           -0.59999999999999998 },
1091   { 155370278.54003900, 10, 10,
1092           -0.50000000000000000 },
1093   { 273815518.20150518, 10, 10,
1094           -0.40000000000000002 },
1095   { 408571989.13158917, 10, 10,
1096           -0.30000000000000004 },
1097   { 533848212.07990247, 10, 10,
1098           -0.19999999999999996 },
1099   { 622640835.70523083, 10, 10,
1100           -0.099999999999999978 },
1101   { 654729075.00000000, 10, 10,
1102           0.0000000000000000 },
1103   { 622640835.70523083, 10, 10,
1104           0.10000000000000009 },
1105   { 533848212.07990247, 10, 10,
1106           0.19999999999999996 },
1107   { 408571989.13158917, 10, 10,
1108           0.30000000000000004 },
1109   { 273815518.20150518, 10, 10,
1110           0.39999999999999991 },
1111   { 155370278.54003900, 10, 10,
1112           0.50000000000000000 },
1113   { 70300999.121633217, 10, 10,
1114           0.60000000000000009 },
1115   { 22589806.343887307, 10, 10,
1116           0.69999999999999996 },
1117   { 3958896.3481267113, 10, 10,
1118           0.80000000000000004 },
1119   { 162117.40078784304, 10, 10,
1120           0.89999999999999991 },
1121   { 0.0000000000000000, 10, 10,
1122           1.0000000000000000 },
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_assoc_legendre<double>);
1134   for (unsigned int i = 0; i < num_datum; ++i)
1135     {
1136       const Tp f = std::tr1::assoc_legendre(Tp(data015[i].l), Tp(data015[i].m),
1137                    Tp(data015[i].x));
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_assoc_legendre<double> data016[] = {
1155   { 1.0000000000000000, 20, 0,
1156           -1.0000000000000000 },
1157   { -0.14930823530984821, 20, 0,
1158           -0.90000000000000002 },
1159   { 0.22420460541741344, 20, 0,
1160           -0.80000000000000004 },
1161   { -0.20457394463834172, 20, 0,
1162           -0.69999999999999996 },
1163   { 0.15916752910098114, 20, 0,
1164           -0.59999999999999998 },
1165   { -0.048358381067373557, 20, 0,
1166           -0.50000000000000000 },
1167   { -0.10159261558628156, 20, 0,
1168           -0.40000000000000002 },
1169   { 0.18028715947998047, 20, 0,
1170           -0.30000000000000004 },
1171   { -0.098042194344594741, 20, 0,
1172           -0.19999999999999996 },
1173   { -0.082077130944527649, 20, 0,
1174           -0.099999999999999978 },
1175   { 0.17619705200195312, 20, 0,
1176           0.0000000000000000 },
1177   { -0.082077130944528037, 20, 0,
1178           0.10000000000000009 },
1179   { -0.098042194344594741, 20, 0,
1180           0.19999999999999996 },
1181   { 0.18028715947998047, 20, 0,
1182           0.30000000000000004 },
1183   { -0.10159261558628112, 20, 0,
1184           0.39999999999999991 },
1185   { -0.048358381067373557, 20, 0,
1186           0.50000000000000000 },
1187   { 0.15916752910098084, 20, 0,
1188           0.60000000000000009 },
1189   { -0.20457394463834172, 20, 0,
1190           0.69999999999999996 },
1191   { 0.22420460541741344, 20, 0,
1192           0.80000000000000004 },
1193   { -0.14930823530984949, 20, 0,
1194           0.89999999999999991 },
1195   { 1.0000000000000000, 20, 0,
1196           1.0000000000000000 },
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_assoc_legendre<double>);
1208   for (unsigned int i = 0; i < num_datum; ++i)
1209     {
1210       const Tp f = std::tr1::assoc_legendre(Tp(data016[i].l), Tp(data016[i].m),
1211                    Tp(data016[i].x));
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_assoc_legendre<double> data017[] = {
1229   { 0.0000000000000000, 20, 1,
1230           -1.0000000000000000 },
1231   { 4.3838334818220490, 20, 1,
1232           -0.90000000000000002 },
1233   { -0.63138296146340556, 20, 1,
1234           -0.80000000000000004 },
1235   { 0.72274871413391228, 20, 1,
1236           -0.69999999999999996 },
1237   { -2.3203528743824893, 20, 1,
1238           -0.59999999999999998 },
1239   { 3.7399919228791405, 20, 1,
1240           -0.50000000000000000 },
1241   { -3.1692202279270028, 20, 1,
1242           -0.40000000000000002 },
1243   { 0.15804468835344049, 20, 1,
1244           -0.30000000000000004 },
1245   { 3.0366182393271162, 20, 1,
1246           -0.19999999999999996 },
1247   { -3.2115523815580209, 20, 1,
1248           -0.099999999999999978 },
1249   { 0.0000000000000000, 20, 1,
1250           0.0000000000000000 },
1251   { 3.2115523815580160, 20, 1,
1252           0.10000000000000009 },
1253   { -3.0366182393271162, 20, 1,
1254           0.19999999999999996 },
1255   { -0.15804468835344049, 20, 1,
1256           0.30000000000000004 },
1257   { 3.1692202279270076, 20, 1,
1258           0.39999999999999991 },
1259   { -3.7399919228791405, 20, 1,
1260           0.50000000000000000 },
1261   { 2.3203528743825008, 20, 1,
1262           0.60000000000000009 },
1263   { -0.72274871413391228, 20, 1,
1264           0.69999999999999996 },
1265   { 0.63138296146340556, 20, 1,
1266           0.80000000000000004 },
1267   { -4.3838334818220304, 20, 1,
1268           0.89999999999999991 },
1269   { 0.0000000000000000, 20, 1,
1270           1.0000000000000000 },
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_assoc_legendre<double>);
1282   for (unsigned int i = 0; i < num_datum; ++i)
1283     {
1284       const Tp f = std::tr1::assoc_legendre(Tp(data017[i].l), Tp(data017[i].m),
1285                    Tp(data017[i].x));
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_assoc_legendre<double> data018[] = {
1303   { 0.0000000000000000, 20, 2,
1304           -1.0000000000000000 },
1305   { 80.812425587310116, 20, 2,
1306           -0.90000000000000002 },
1307   { -95.849622172549317, 20, 2,
1308           -0.80000000000000004 },
1309   { 87.337927630325510, 20, 2,
1310           -0.69999999999999996 },
1311   { -70.330891533985834, 20, 2,
1312           -0.59999999999999998 },
1313   { 24.629090735179489, 20, 2,
1314           -0.50000000000000000 },
1315   { 39.902576338912418, 20, 2,
1316           -0.40000000000000002 },
1317   { -75.621201471396589, 20, 2,
1318           -0.30000000000000004 },
1319   { 42.417415829726487, 20, 2,
1320           -0.19999999999999996 },
1321   { 33.826848678871301, 20, 2,
1322           -0.099999999999999978 },
1323   { -74.002761840820312, 20, 2,
1324           0.0000000000000000 },
1325   { 33.826848678871457, 20, 2,
1326           0.10000000000000009 },
1327   { 42.417415829726487, 20, 2,
1328           0.19999999999999996 },
1329   { -75.621201471396589, 20, 2,
1330           0.30000000000000004 },
1331   { 39.902576338912240, 20, 2,
1332           0.39999999999999991 },
1333   { 24.629090735179489, 20, 2,
1334           0.50000000000000000 },
1335   { -70.330891533985664, 20, 2,
1336           0.60000000000000009 },
1337   { 87.337927630325510, 20, 2,
1338           0.69999999999999996 },
1339   { -95.849622172549317, 20, 2,
1340           0.80000000000000004 },
1341   { 80.812425587310585, 20, 2,
1342           0.89999999999999991 },
1343   { 0.0000000000000000, 20, 2,
1344           1.0000000000000000 },
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_assoc_legendre<double>);
1356   for (unsigned int i = 0; i < num_datum; ++i)
1357     {
1358       const Tp f = std::tr1::assoc_legendre(Tp(data018[i].l), Tp(data018[i].m),
1359                    Tp(data018[i].x));
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_assoc_legendre<double> data019[] = {
1377   { -0.0000000000000000, 20, 5,
1378           -1.0000000000000000 },
1379   { -315702.32715134107, 20, 5,
1380           -0.90000000000000002 },
1381   { 503060.91484852595, 20, 5,
1382           -0.80000000000000004 },
1383   { -298127.28360361949, 20, 5,
1384           -0.69999999999999996 },
1385   { -114444.61447464002, 20, 5,
1386           -0.59999999999999998 },
1387   { 543428.40914592857, 20, 5,
1388           -0.50000000000000000 },
1389   { -613842.07728185481, 20, 5,
1390           -0.40000000000000002 },
1391   { 143765.42411270953, 20, 5,
1392           -0.30000000000000004 },
1393   { 472600.45321372297, 20, 5,
1394           -0.19999999999999996 },
1395   { -563861.76771496492, 20, 5,
1396           -0.099999999999999978 },
1397   { 0.0000000000000000, 20, 5,
1398           0.0000000000000000 },
1399   { 563861.76771496458, 20, 5,
1400           0.10000000000000009 },
1401   { -472600.45321372297, 20, 5,
1402           0.19999999999999996 },
1403   { -143765.42411270953, 20, 5,
1404           0.30000000000000004 },
1405   { 613842.07728185505, 20, 5,
1406           0.39999999999999991 },
1407   { -543428.40914592857, 20, 5,
1408           0.50000000000000000 },
1409   { 114444.61447464184, 20, 5,
1410           0.60000000000000009 },
1411   { 298127.28360361949, 20, 5,
1412           0.69999999999999996 },
1413   { -503060.91484852595, 20, 5,
1414           0.80000000000000004 },
1415   { 315702.32715134590, 20, 5,
1416           0.89999999999999991 },
1417   { 0.0000000000000000, 20, 5,
1418           1.0000000000000000 },
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_assoc_legendre<double>);
1430   for (unsigned int i = 0; i < num_datum; ++i)
1431     {
1432       const Tp f = std::tr1::assoc_legendre(Tp(data019[i].l), Tp(data019[i].m),
1433                    Tp(data019[i].x));
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(2.5000000000000020e-13));
1447 }
1448
1449 // Test data for l=20, m=10.
1450 testcase_assoc_legendre<double> data020[] = {
1451   { -0.0000000000000000, 20, 10,
1452           -1.0000000000000000 },
1453   { 990017476694.99084, 20, 10,
1454           -0.90000000000000002 },
1455   { 2392757933281.0503, 20, 10,
1456           -0.80000000000000004 },
1457   { -1548364524949.5808, 20, 10,
1458           -0.69999999999999996 },
1459   { -424471915195.05609, 20, 10,
1460           -0.59999999999999998 },
1461   { 1744502295946.2065, 20, 10,
1462           -0.50000000000000000 },
1463   { -899973487310.55212, 20, 10,
1464           -0.40000000000000002 },
1465   { -1092420454297.7164, 20, 10,
1466           -0.30000000000000004 },
1467   { 1466609267659.8816, 20, 10,
1468           -0.19999999999999996 },
1469   { 356041756390.71661, 20, 10,
1470           -0.099999999999999978 },
1471   { -1612052956674.3164, 20, 10,
1472           0.0000000000000000 },
1473   { 356041756390.71985, 20, 10,
1474           0.10000000000000009 },
1475   { 1466609267659.8816, 20, 10,
1476           0.19999999999999996 },
1477   { -1092420454297.7164, 20, 10,
1478           0.30000000000000004 },
1479   { -899973487310.55469, 20, 10,
1480           0.39999999999999991 },
1481   { 1744502295946.2065, 20, 10,
1482           0.50000000000000000 },
1483   { -424471915195.05914, 20, 10,
1484           0.60000000000000009 },
1485   { -1548364524949.5808, 20, 10,
1486           0.69999999999999996 },
1487   { 2392757933281.0503, 20, 10,
1488           0.80000000000000004 },
1489   { 990017476694.99353, 20, 10,
1490           0.89999999999999991 },
1491   { 0.0000000000000000, 20, 10,
1492           1.0000000000000000 },
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_assoc_legendre<double>);
1504   for (unsigned int i = 0; i < num_datum; ++i)
1505     {
1506       const Tp f = std::tr1::assoc_legendre(Tp(data020[i].l), Tp(data020[i].m),
1507                    Tp(data020[i].x));
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(2.5000000000000020e-13));
1521 }
1522
1523 // Test data for l=20, m=20.
1524 testcase_assoc_legendre<double> data021[] = {
1525   { 0.0000000000000000, 20, 20,
1526           -1.0000000000000000 },
1527   { 19609049712023808., 20, 20,
1528           -0.90000000000000002 },
1529   { 1.1693527616833221e+19, 20, 20,
1530           -0.80000000000000004 },
1531   { 3.8073455880620691e+20, 20, 20,
1532           -0.69999999999999996 },
1533   { 3.6874002249007927e+21, 20, 20,
1534           -0.59999999999999998 },
1535   { 1.8010806978179592e+22, 20, 20,
1536           -0.50000000000000000 },
1537   { 5.5938832584012466e+22, 20, 20,
1538           -0.40000000000000002 },
1539   { 1.2454734132297811e+23, 20, 20,
1540           -0.30000000000000004 },
1541   { 2.1263407800797497e+23, 20, 20,
1542           -0.19999999999999996 },
1543   { 2.8924941146976873e+23, 20, 20,
1544           -0.099999999999999978 },
1545   { 3.1983098677287775e+23, 20, 20,
1546           0.0000000000000000 },
1547   { 2.8924941146976873e+23, 20, 20,
1548           0.10000000000000009 },
1549   { 2.1263407800797497e+23, 20, 20,
1550           0.19999999999999996 },
1551   { 1.2454734132297811e+23, 20, 20,
1552           0.30000000000000004 },
1553   { 5.5938832584012466e+22, 20, 20,
1554           0.39999999999999991 },
1555   { 1.8010806978179592e+22, 20, 20,
1556           0.50000000000000000 },
1557   { 3.6874002249007807e+21, 20, 20,
1558           0.60000000000000009 },
1559   { 3.8073455880620691e+20, 20, 20,
1560           0.69999999999999996 },
1561   { 1.1693527616833221e+19, 20, 20,
1562           0.80000000000000004 },
1563   { 19609049712024020., 20, 20,
1564           0.89999999999999991 },
1565   { 0.0000000000000000, 20, 20,
1566           1.0000000000000000 },
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_assoc_legendre<double>);
1578   for (unsigned int i = 0; i < num_datum; ++i)
1579     {
1580       const Tp f = std::tr1::assoc_legendre(Tp(data021[i].l), Tp(data021[i].m),
1581                    Tp(data021[i].x));
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_assoc_legendre<double> data022[] = {
1599   { 1.0000000000000000, 50, 0,
1600           -1.0000000000000000 },
1601   { -0.17003765994383685, 50, 0,
1602           -0.90000000000000002 },
1603   { 0.13879737345093118, 50, 0,
1604           -0.80000000000000004 },
1605   { -0.014572731645892805, 50, 0,
1606           -0.69999999999999996 },
1607   { -0.058860798844002173, 50, 0,
1608           -0.59999999999999998 },
1609   { -0.031059099239609828, 50, 0,
1610           -0.50000000000000000 },
1611   { 0.041569033381825368, 50, 0,
1612           -0.40000000000000002 },
1613   { 0.10911051574714808, 50, 0,
1614           -0.30000000000000004 },
1615   { 0.083432272204197466, 50, 0,
1616           -0.19999999999999996 },
1617   { -0.038205812661313579, 50, 0,
1618           -0.099999999999999978 },
1619   { -0.11227517265921705, 50, 0,
1620           0.0000000000000000 },
1621   { -0.038205812661314169, 50, 0,
1622           0.10000000000000009 },
1623   { 0.083432272204197466, 50, 0,
1624           0.19999999999999996 },
1625   { 0.10911051574714808, 50, 0,
1626           0.30000000000000004 },
1627   { 0.041569033381824647, 50, 0,
1628           0.39999999999999991 },
1629   { -0.031059099239609828, 50, 0,
1630           0.50000000000000000 },
1631   { -0.058860798844001430, 50, 0,
1632           0.60000000000000009 },
1633   { -0.014572731645892805, 50, 0,
1634           0.69999999999999996 },
1635   { 0.13879737345093118, 50, 0,
1636           0.80000000000000004 },
1637   { -0.17003765994383663, 50, 0,
1638           0.89999999999999991 },
1639   { 1.0000000000000000, 50, 0,
1640           1.0000000000000000 },
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_assoc_legendre<double>);
1652   for (unsigned int i = 0; i < num_datum; ++i)
1653     {
1654       const Tp f = std::tr1::assoc_legendre(Tp(data022[i].l), Tp(data022[i].m),
1655                    Tp(data022[i].x));
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(2.5000000000000020e-13));
1669 }
1670
1671 // Test data for l=50, m=1.
1672 testcase_assoc_legendre<double> data023[] = {
1673   { 0.0000000000000000, 50, 1,
1674           -1.0000000000000000 },
1675   { -0.13424149984450387, 50, 1,
1676           -0.90000000000000002 },
1677   { 2.2011219672413085, 50, 1,
1678           -0.80000000000000004 },
1679   { 6.6622414993232013, 50, 1,
1680           -0.69999999999999996 },
1681   { 5.5772846936919231, 50, 1,
1682           -0.59999999999999998 },
1683   { 5.8787148815607617, 50, 1,
1684           -0.50000000000000000 },
1685   { 5.5473459458634000, 50, 1,
1686           -0.40000000000000002 },
1687   { 1.8444956647619912, 50, 1,
1688           -0.30000000000000004 },
1689   { -3.8722014306642150, 50, 1,
1690           -0.19999999999999996 },
1691   { -5.3488751322285593, 50, 1,
1692           -0.099999999999999978 },
1693   { -0.0000000000000000, 50, 1,
1694           0.0000000000000000 },
1695   { 5.3488751322285459, 50, 1,
1696           0.10000000000000009 },
1697   { 3.8722014306642150, 50, 1,
1698           0.19999999999999996 },
1699   { -1.8444956647619912, 50, 1,
1700           0.30000000000000004 },
1701   { -5.5473459458634098, 50, 1,
1702           0.39999999999999991 },
1703   { -5.8787148815607617, 50, 1,
1704           0.50000000000000000 },
1705   { -5.5772846936919489, 50, 1,
1706           0.60000000000000009 },
1707   { -6.6622414993232013, 50, 1,
1708           0.69999999999999996 },
1709   { -2.2011219672413085, 50, 1,
1710           0.80000000000000004 },
1711   { 0.13424149984460862, 50, 1,
1712           0.89999999999999991 },
1713   { 0.0000000000000000, 50, 1,
1714           1.0000000000000000 },
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_assoc_legendre<double>);
1726   for (unsigned int i = 0; i < num_datum; ++i)
1727     {
1728       const Tp f = std::tr1::assoc_legendre(Tp(data023[i].l), Tp(data023[i].m),
1729                    Tp(data023[i].x));
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.0000000000000029e-12));
1743 }
1744
1745 // Test data for l=50, m=2.
1746 testcase_assoc_legendre<double> data024[] = {
1747   { 0.0000000000000000, 50, 2,
1748           -1.0000000000000000 },
1749   { 433.04168483713448, 50, 2,
1750           -0.90000000000000002 },
1751   { -348.06364372056390, 50, 2,
1752           -0.80000000000000004 },
1753   { 50.221071418108465, 50, 2,
1754           -0.69999999999999996 },
1755   { 158.46096409274341, 50, 2,
1756           -0.59999999999999998 },
1757   { 85.988858299721414, 50, 2,
1758           -0.50000000000000000 },
1759   { -101.15891460879277, 50, 2,
1760           -0.40000000000000002 },
1761   { -277.07168105316612, 50, 2,
1762           -0.30000000000000004 },
1763   { -214.33311373510401, 50, 2,
1764           -0.19999999999999996 },
1765   { 96.349657930951722, 50, 2,
1766           -0.099999999999999978 },
1767   { 286.30169028100346, 50, 2,
1768           0.0000000000000000 },
1769   { 96.349657930953285, 50, 2,
1770           0.10000000000000009 },
1771   { -214.33311373510401, 50, 2,
1772           0.19999999999999996 },
1773   { -277.07168105316612, 50, 2,
1774           0.30000000000000004 },
1775   { -101.15891460879106, 50, 2,
1776           0.39999999999999991 },
1777   { 85.988858299721414, 50, 2,
1778           0.50000000000000000 },
1779   { 158.46096409274131, 50, 2,
1780           0.60000000000000009 },
1781   { 50.221071418108465, 50, 2,
1782           0.69999999999999996 },
1783   { -348.06364372056390, 50, 2,
1784           0.80000000000000004 },
1785   { 433.04168483713414, 50, 2,
1786           0.89999999999999991 },
1787   { 0.0000000000000000, 50, 2,
1788           1.0000000000000000 },
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_assoc_legendre<double>);
1800   for (unsigned int i = 0; i < num_datum; ++i)
1801     {
1802       const Tp f = std::tr1::assoc_legendre(Tp(data024[i].l), Tp(data024[i].m),
1803                    Tp(data024[i].x));
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.5000000000000020e-13));
1817 }
1818
1819 // Test data for l=50, m=5.
1820 testcase_assoc_legendre<double> data025[] = {
1821   { -0.0000000000000000, 50, 5,
1822           -1.0000000000000000 },
1823   { -27340473.952132788, 50, 5,
1824           -0.90000000000000002 },
1825   { 27753716.768532373, 50, 5,
1826           -0.80000000000000004 },
1827   { 40808153.913493626, 50, 5,
1828           -0.69999999999999996 },
1829   { 32071189.035790101, 50, 5,
1830           -0.59999999999999998 },
1831   { 36265736.218529105, 50, 5,
1832           -0.50000000000000000 },
1833   { 37089596.700204894, 50, 5,
1834           -0.40000000000000002 },
1835   { 14562029.629244510, 50, 5,
1836           -0.30000000000000004 },
1837   { -23686895.217517227, 50, 5,
1838           -0.19999999999999996 },
1839   { -34878992.965676002, 50, 5,
1840           -0.099999999999999978 },
1841   { -0.0000000000000000, 50, 5,
1842           0.0000000000000000 },
1843   { 34878992.965675950, 50, 5,
1844           0.10000000000000009 },
1845   { 23686895.217517227, 50, 5,
1846           0.19999999999999996 },
1847   { -14562029.629244510, 50, 5,
1848           0.30000000000000004 },
1849   { -37089596.700204931, 50, 5,
1850           0.39999999999999991 },
1851   { -36265736.218529105, 50, 5,
1852           0.50000000000000000 },
1853   { -32071189.035790265, 50, 5,
1854           0.60000000000000009 },
1855   { -40808153.913493626, 50, 5,
1856           0.69999999999999996 },
1857   { -27753716.768532373, 50, 5,
1858           0.80000000000000004 },
1859   { 27340473.952133406, 50, 5,
1860           0.89999999999999991 },
1861   { 0.0000000000000000, 50, 5,
1862           1.0000000000000000 },
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_assoc_legendre<double>);
1874   for (unsigned int i = 0; i < num_datum; ++i)
1875     {
1876       const Tp f = std::tr1::assoc_legendre(Tp(data025[i].l), Tp(data025[i].m),
1877                    Tp(data025[i].x));
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(2.5000000000000020e-13));
1891 }
1892
1893 // Test data for l=50, m=10.
1894 testcase_assoc_legendre<double> data026[] = {
1895   { -0.0000000000000000, 50, 10,
1896           -1.0000000000000000 },
1897   { -8994661710093158.0, 50, 10,
1898           -0.90000000000000002 },
1899   { 932311375306557.00, 50, 10,
1900           -0.80000000000000004 },
1901   { 12153535011507012., 50, 10,
1902           -0.69999999999999996 },
1903   { 12176690755542244., 50, 10,
1904           -0.59999999999999998 },
1905   { 9180035388465752.0, 50, 10,
1906           -0.50000000000000000 },
1907   { 889201701866911.12, 50, 10,
1908           -0.40000000000000002 },
1909   { -9451384032851600.0, 50, 10,
1910           -0.30000000000000004 },
1911   { -9926439446673564.0, 50, 10,
1912           -0.19999999999999996 },
1913   { 2794368162749970.5, 50, 10,
1914           -0.099999999999999978 },
1915   { 11452238249246346., 50, 10,
1916           0.0000000000000000 },
1917   { 2794368162750031.0, 50, 10,
1918           0.10000000000000009 },
1919   { -9926439446673564.0, 50, 10,
1920           0.19999999999999996 },
1921   { -9451384032851600.0, 50, 10,
1922           0.30000000000000004 },
1923   { 889201701866976.25, 50, 10,
1924           0.39999999999999991 },
1925   { 9180035388465752.0, 50, 10,
1926           0.50000000000000000 },
1927   { 12176690755542216., 50, 10,
1928           0.60000000000000009 },
1929   { 12153535011507012., 50, 10,
1930           0.69999999999999996 },
1931   { 932311375306557.00, 50, 10,
1932           0.80000000000000004 },
1933   { -8994661710093322.0, 50, 10,
1934           0.89999999999999991 },
1935   { 0.0000000000000000, 50, 10,
1936           1.0000000000000000 },
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_assoc_legendre<double>);
1948   for (unsigned int i = 0; i < num_datum; ++i)
1949     {
1950       const Tp f = std::tr1::assoc_legendre(Tp(data026[i].l), Tp(data026[i].m),
1951                    Tp(data026[i].x));
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(1.0000000000000008e-12));
1965 }
1966
1967 // Test data for l=50, m=20.
1968 testcase_assoc_legendre<double> data027[] = {
1969   { 0.0000000000000000, 50, 20,
1970           -1.0000000000000000 },
1971   { 1.6630925158645460e+33, 50, 20,
1972           -0.90000000000000002 },
1973   { 1.0622676657892043e+33, 50, 20,
1974           -0.80000000000000004 },
1975   { 8.6022521164717170e+32, 50, 20,
1976           -0.69999999999999996 },
1977   { 4.0860128756808430e+32, 50, 20,
1978           -0.59999999999999998 },
1979   { -4.0169860814274409e+32, 50, 20,
1980           -0.50000000000000000 },
1981   { -8.2324325279774008e+32, 50, 20,
1982           -0.40000000000000002 },
1983   { -4.0054067236243299e+31, 50, 20,
1984           -0.30000000000000004 },
1985   { 7.9309266056434309e+32, 50, 20,
1986           -0.19999999999999996 },
1987   { 5.4151358290899148e+31, 50, 20,
1988           -0.099999999999999978 },
1989   { -7.8735935697332210e+32, 50, 20,
1990           0.0000000000000000 },
1991   { 5.4151358290895032e+31, 50, 20,
1992           0.10000000000000009 },
1993   { 7.9309266056434309e+32, 50, 20,
1994           0.19999999999999996 },
1995   { -4.0054067236243299e+31, 50, 20,
1996           0.30000000000000004 },
1997   { -8.2324325279773965e+32, 50, 20,
1998           0.39999999999999991 },
1999   { -4.0169860814274409e+32, 50, 20,
2000           0.50000000000000000 },
2001   { 4.0860128756807882e+32, 50, 20,
2002           0.60000000000000009 },
2003   { 8.6022521164717170e+32, 50, 20,
2004           0.69999999999999996 },
2005   { 1.0622676657892043e+33, 50, 20,
2006           0.80000000000000004 },
2007   { 1.6630925158645483e+33, 50, 20,
2008           0.89999999999999991 },
2009   { 0.0000000000000000, 50, 20,
2010           1.0000000000000000 },
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_assoc_legendre<double>);
2022   for (unsigned int i = 0; i < num_datum; ++i)
2023     {
2024       const Tp f = std::tr1::assoc_legendre(Tp(data027[i].l), Tp(data027[i].m),
2025                    Tp(data027[i].x));
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(1.0000000000000008e-12));
2039 }
2040
2041 // Test data for l=50, m=50.
2042 testcase_assoc_legendre<double> data028[] = {
2043   { 0.0000000000000000, 50, 50,
2044           -1.0000000000000000 },
2045   { 2.5366994974431341e+60, 50, 50,
2046           -0.90000000000000002 },
2047   { 2.2028834403101213e+67, 50, 50,
2048           -0.80000000000000004 },
2049   { 1.3325496559566651e+71, 50, 50,
2050           -0.69999999999999996 },
2051   { 3.8898096431781969e+73, 50, 50,
2052           -0.59999999999999998 },
2053   { 2.0509760257037188e+75, 50, 50,
2054           -0.50000000000000000 },
2055   { 3.4866724533443283e+76, 50, 50,
2056           -0.40000000000000002 },
2057   { 2.5790740224150207e+77, 50, 50,
2058           -0.30000000000000004 },
2059   { 9.8222237931680989e+77, 50, 50,
2060           -0.19999999999999996 },
2061   { 2.1198682190366617e+78, 50, 50,
2062           -0.099999999999999978 },
2063   { 2.7253921397507295e+78, 50, 50,
2064           0.0000000000000000 },
2065   { 2.1198682190366617e+78, 50, 50,
2066           0.10000000000000009 },
2067   { 9.8222237931680989e+77, 50, 50,
2068           0.19999999999999996 },
2069   { 2.5790740224150207e+77, 50, 50,
2070           0.30000000000000004 },
2071   { 3.4866724533443283e+76, 50, 50,
2072           0.39999999999999991 },
2073   { 2.0509760257037188e+75, 50, 50,
2074           0.50000000000000000 },
2075   { 3.8898096431781724e+73, 50, 50,
2076           0.60000000000000009 },
2077   { 1.3325496559566651e+71, 50, 50,
2078           0.69999999999999996 },
2079   { 2.2028834403101213e+67, 50, 50,
2080           0.80000000000000004 },
2081   { 2.5366994974431990e+60, 50, 50,
2082           0.89999999999999991 },
2083   { 0.0000000000000000, 50, 50,
2084           1.0000000000000000 },
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_assoc_legendre<double>);
2096   for (unsigned int i = 0; i < num_datum; ++i)
2097     {
2098       const Tp f = std::tr1::assoc_legendre(Tp(data028[i].l), Tp(data028[i].m),
2099                    Tp(data028[i].x));
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_assoc_legendre<double> data029[] = {
2117   { 1.0000000000000000, 100, 0,
2118           -1.0000000000000000 },
2119   { 0.10226582055871908, 100, 0,
2120           -0.90000000000000002 },
2121   { 0.050861167913584124, 100, 0,
2122           -0.80000000000000004 },
2123   { -0.077132507199778780, 100, 0,
2124           -0.69999999999999996 },
2125   { -0.023747023905133110, 100, 0,
2126           -0.59999999999999998 },
2127   { -0.060518025961861198, 100, 0,
2128           -0.50000000000000000 },
2129   { -0.072258202125684429, 100, 0,
2130           -0.40000000000000002 },
2131   { 0.057127392202801719, 100, 0,
2132           -0.30000000000000004 },
2133   { 0.014681835355659636, 100, 0,
2134           -0.19999999999999996 },
2135   { -0.063895098434750303, 100, 0,
2136           -0.099999999999999978 },
2137   { 0.079589237387178727, 100, 0,
2138           0.0000000000000000 },
2139   { -0.063895098434749775, 100, 0,
2140           0.10000000000000009 },
2141   { 0.014681835355659636, 100, 0,
2142           0.19999999999999996 },
2143   { 0.057127392202801719, 100, 0,
2144           0.30000000000000004 },
2145   { -0.072258202125685012, 100, 0,
2146           0.39999999999999991 },
2147   { -0.060518025961861198, 100, 0,
2148           0.50000000000000000 },
2149   { -0.023747023905134217, 100, 0,
2150           0.60000000000000009 },
2151   { -0.077132507199778780, 100, 0,
2152           0.69999999999999996 },
2153   { 0.050861167913584124, 100, 0,
2154           0.80000000000000004 },
2155   { 0.10226582055871723, 100, 0,
2156           0.89999999999999991 },
2157   { 1.0000000000000000, 100, 0,
2158           1.0000000000000000 },
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_assoc_legendre<double>);
2170   for (unsigned int i = 0; i < num_datum; ++i)
2171     {
2172       const Tp f = std::tr1::assoc_legendre(Tp(data029[i].l), Tp(data029[i].m),
2173                    Tp(data029[i].x));
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(2.5000000000000020e-13));
2187 }
2188
2189 // Test data for l=100, m=1.
2190 testcase_assoc_legendre<double> data030[] = {
2191   { -0.0000000000000000, 100, 1,
2192           -1.0000000000000000 },
2193   { 6.5200167187780309, 100, 1,
2194           -0.90000000000000002 },
2195   { 9.0065170007027540, 100, 1,
2196           -0.80000000000000004 },
2197   { -5.4690908541181056, 100, 1,
2198           -0.69999999999999996 },
2199   { -8.6275439170430861, 100, 1,
2200           -0.59999999999999998 },
2201   { -6.0909031663448499, 100, 1,
2202           -0.50000000000000000 },
2203   { 4.1160338699561265, 100, 1,
2204           -0.40000000000000002 },
2205   { 5.8491043010758004, 100, 1,
2206           -0.30000000000000004 },
2207   { -7.9435138723089826, 100, 1,
2208           -0.19999999999999996 },
2209   { 4.7996285823989346, 100, 1,
2210           -0.099999999999999978 },
2211   { 0.0000000000000000, 100, 1,
2212           0.0000000000000000 },
2213   { -4.7996285823990057, 100, 1,
2214           0.10000000000000009 },
2215   { 7.9435138723089826, 100, 1,
2216           0.19999999999999996 },
2217   { -5.8491043010758004, 100, 1,
2218           0.30000000000000004 },
2219   { -4.1160338699560359, 100, 1,
2220           0.39999999999999991 },
2221   { 6.0909031663448499, 100, 1,
2222           0.50000000000000000 },
2223   { 8.6275439170430559, 100, 1,
2224           0.60000000000000009 },
2225   { 5.4690908541181056, 100, 1,
2226           0.69999999999999996 },
2227   { -9.0065170007027540, 100, 1,
2228           0.80000000000000004 },
2229   { -6.5200167187783133, 100, 1,
2230           0.89999999999999991 },
2231   { 0.0000000000000000, 100, 1,
2232           1.0000000000000000 },
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_assoc_legendre<double>);
2244   for (unsigned int i = 0; i < num_datum; ++i)
2245     {
2246       const Tp f = std::tr1::assoc_legendre(Tp(data030[i].l), Tp(data030[i].m),
2247                    Tp(data030[i].x));
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(5.0000000000000039e-13));
2261 }
2262
2263 // Test data for l=100, m=2.
2264 testcase_assoc_legendre<double> data031[] = {
2265   { 0.0000000000000000, 100, 2,
2266           -1.0000000000000000 },
2267   { -1005.9604880761007, 100, 2,
2268           -0.90000000000000002 },
2269   { -489.68041725865896, 100, 2,
2270           -0.80000000000000004 },
2271   { 768.31676011669970, 100, 2,
2272           -0.69999999999999996 },
2273   { 226.90362556628003, 100, 2,
2274           -0.59999999999999998 },
2275   { 604.19889304940330, 100, 2,
2276           -0.50000000000000000 },
2277   { 733.40061037838029, 100, 2,
2278           -0.40000000000000002 },
2279   { -573.30774483996402, 100, 2,
2280           -0.30000000000000004 },
2281   { -151.52946305080897, 100, 2,
2282           -0.19999999999999996 },
2283   { 646.30525583588019, 100, 2,
2284           -0.099999999999999978 },
2285   { -803.85129761050518, 100, 2,
2286           0.0000000000000000 },
2287   { 646.30525583587439, 100, 2,
2288           0.10000000000000009 },
2289   { -151.52946305080897, 100, 2,
2290           0.19999999999999996 },
2291   { -573.30774483996402, 100, 2,
2292           0.30000000000000004 },
2293   { 733.40061037838507, 100, 2,
2294           0.39999999999999991 },
2295   { 604.19889304940330, 100, 2,
2296           0.50000000000000000 },
2297   { 226.90362556629168, 100, 2,
2298           0.60000000000000009 },
2299   { 768.31676011669970, 100, 2,
2300           0.69999999999999996 },
2301   { -489.68041725865896, 100, 2,
2302           0.80000000000000004 },
2303   { -1005.9604880760811, 100, 2,
2304           0.89999999999999991 },
2305   { 0.0000000000000000, 100, 2,
2306           1.0000000000000000 },
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_assoc_legendre<double>);
2318   for (unsigned int i = 0; i < num_datum; ++i)
2319     {
2320       const Tp f = std::tr1::assoc_legendre(Tp(data031[i].l), Tp(data031[i].m),
2321                    Tp(data031[i].x));
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_assoc_legendre<double> data032[] = {
2339   { 0.0000000000000000, 100, 5,
2340           -1.0000000000000000 },
2341   { 900551126.09653592, 100, 5,
2342           -0.90000000000000002 },
2343   { 988567431.55756044, 100, 5,
2344           -0.80000000000000004 },
2345   { -645646451.90344620, 100, 5,
2346           -0.69999999999999996 },
2347   { -897114585.29920745, 100, 5,
2348           -0.59999999999999998 },
2349   { -661710744.42483830, 100, 5,
2350           -0.50000000000000000 },
2351   { 380163158.51425594, 100, 5,
2352           -0.40000000000000002 },
2353   { 617391071.36632609, 100, 5,
2354           -0.30000000000000004 },
2355   { -805288801.85509181, 100, 5,
2356           -0.19999999999999996 },
2357   { 481041740.16728652, 100, 5,
2358           -0.099999999999999978 },
2359   { 0.0000000000000000, 100, 5,
2360           0.0000000000000000 },
2361   { -481041740.16729414, 100, 5,
2362           0.10000000000000009 },
2363   { 805288801.85509181, 100, 5,
2364           0.19999999999999996 },
2365   { -617391071.36632609, 100, 5,
2366           0.30000000000000004 },
2367   { -380163158.51424748, 100, 5,
2368           0.39999999999999991 },
2369   { 661710744.42483830, 100, 5,
2370           0.50000000000000000 },
2371   { 897114585.29920506, 100, 5,
2372           0.60000000000000009 },
2373   { 645646451.90344620, 100, 5,
2374           0.69999999999999996 },
2375   { -988567431.55756044, 100, 5,
2376           0.80000000000000004 },
2377   { -900551126.09655809, 100, 5,
2378           0.89999999999999991 },
2379   { 0.0000000000000000, 100, 5,
2380           1.0000000000000000 },
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_assoc_legendre<double>);
2392   for (unsigned int i = 0; i < num_datum; ++i)
2393     {
2394       const Tp f = std::tr1::assoc_legendre(Tp(data032[i].l), Tp(data032[i].m),
2395                    Tp(data032[i].x));
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(2.5000000000000020e-13));
2409 }
2410
2411 // Test data for l=100, m=10.
2412 testcase_assoc_legendre<double> data033[] = {
2413   { 0.0000000000000000, 100, 10,
2414           -1.0000000000000000 },
2415   { 2.5643395957658915e+17, 100, 10,
2416           -0.90000000000000002 },
2417   { 1.5778673545673316e+18, 100, 10,
2418           -0.80000000000000004 },
2419   { 4.4355048487496776e+18, 100, 10,
2420           -0.69999999999999996 },
2421   { -9.5936111659124493e+17, 100, 10,
2422           -0.59999999999999998 },
2423   { 4.2387123021963372e+18, 100, 10,
2424           -0.50000000000000000 },
2425   { 8.2370834618426563e+18, 100, 10,
2426           -0.40000000000000002 },
2427   { -4.9089358388052890e+18, 100, 10,
2428           -0.30000000000000004 },
2429   { -2.3468810358091279e+18, 100, 10,
2430           -0.19999999999999996 },
2431   { 6.8627855225034568e+18, 100, 10,
2432           -0.099999999999999978 },
2433   { -8.2494597181670380e+18, 100, 10,
2434           0.0000000000000000 },
2435   { 6.8627855225034056e+18, 100, 10,
2436           0.10000000000000009 },
2437   { -2.3468810358091279e+18, 100, 10,
2438           0.19999999999999996 },
2439   { -4.9089358388052890e+18, 100, 10,
2440           0.30000000000000004 },
2441   { 8.2370834618426747e+18, 100, 10,
2442           0.39999999999999991 },
2443   { 4.2387123021963372e+18, 100, 10,
2444           0.50000000000000000 },
2445   { -9.5936111659112115e+17, 100, 10,
2446           0.60000000000000009 },
2447   { 4.4355048487496776e+18, 100, 10,
2448           0.69999999999999996 },
2449   { 1.5778673545673316e+18, 100, 10,
2450           0.80000000000000004 },
2451   { 2.5643395957690282e+17, 100, 10,
2452           0.89999999999999991 },
2453   { 0.0000000000000000, 100, 10,
2454           1.0000000000000000 },
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_assoc_legendre<double>);
2466   for (unsigned int i = 0; i < num_datum; ++i)
2467     {
2468       const Tp f = std::tr1::assoc_legendre(Tp(data033[i].l), Tp(data033[i].m),
2469                    Tp(data033[i].x));
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(2.5000000000000014e-11));
2483 }
2484
2485 // Test data for l=100, m=20.
2486 testcase_assoc_legendre<double> data034[] = {
2487   { 0.0000000000000000, 100, 20,
2488           -1.0000000000000000 },
2489   { 7.1604344878778576e+37, 100, 20,
2490           -0.90000000000000002 },
2491   { -8.3963895116962035e+38, 100, 20,
2492           -0.80000000000000004 },
2493   { 7.9022236853110024e+38, 100, 20,
2494           -0.69999999999999996 },
2495   { 8.2680005574120908e+38, 100, 20,
2496           -0.59999999999999998 },
2497   { 3.0750497039999469e+38, 100, 20,
2498           -0.50000000000000000 },
2499   { -7.6120586043843874e+38, 100, 20,
2500           -0.40000000000000002 },
2501   { 1.1474496891901873e+38, 100, 20,
2502           -0.30000000000000004 },
2503   { 4.3966251307444218e+38, 100, 20,
2504           -0.19999999999999996 },
2505   { -7.0503266451702621e+38, 100, 20,
2506           -0.099999999999999978 },
2507   { 7.7727439836159581e+38, 100, 20,
2508           0.0000000000000000 },
2509   { -7.0503266451702213e+38, 100, 20,
2510           0.10000000000000009 },
2511   { 4.3966251307444218e+38, 100, 20,
2512           0.19999999999999996 },
2513   { 1.1474496891901873e+38, 100, 20,
2514           0.30000000000000004 },
2515   { -7.6120586043843511e+38, 100, 20,
2516           0.39999999999999991 },
2517   { 3.0750497039999469e+38, 100, 20,
2518           0.50000000000000000 },
2519   { 8.2680005574120424e+38, 100, 20,
2520           0.60000000000000009 },
2521   { 7.9022236853110024e+38, 100, 20,
2522           0.69999999999999996 },
2523   { -8.3963895116962035e+38, 100, 20,
2524           0.80000000000000004 },
2525   { 7.1604344878809460e+37, 100, 20,
2526           0.89999999999999991 },
2527   { 0.0000000000000000, 100, 20,
2528           1.0000000000000000 },
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_assoc_legendre<double>);
2540   for (unsigned int i = 0; i < num_datum; ++i)
2541     {
2542       const Tp f = std::tr1::assoc_legendre(Tp(data034[i].l), Tp(data034[i].m),
2543                    Tp(data034[i].x));
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_assoc_legendre<double> data035[] = {
2561   { 0.0000000000000000, 100, 50,
2562           -1.0000000000000000 },
2563   { 9.3231278516893773e+96, 100, 50,
2564           -0.90000000000000002 },
2565   { -1.1029797977454331e+98, 100, 50,
2566           -0.80000000000000004 },
2567   { 1.8089333903465883e+97, 100, 50,
2568           -0.69999999999999996 },
2569   { 5.9364045925669389e+97, 100, 50,
2570           -0.59999999999999998 },
2571   { -8.2252620339727163e+97, 100, 50,
2572           -0.50000000000000000 },
2573   { 7.1431385093739848e+97, 100, 50,
2574           -0.40000000000000002 },
2575   { -3.3520602067479374e+97, 100, 50,
2576           -0.30000000000000004 },
2577   { -2.7791149588121386e+97, 100, 50,
2578           -0.19999999999999996 },
2579   { 9.0119338550180433e+97, 100, 50,
2580           -0.099999999999999978 },
2581   { -1.1712145031578381e+98, 100, 50,
2582           0.0000000000000000 },
2583   { 9.0119338550181176e+97, 100, 50,
2584           0.10000000000000009 },
2585   { -2.7791149588121386e+97, 100, 50,
2586           0.19999999999999996 },
2587   { -3.3520602067479374e+97, 100, 50,
2588           0.30000000000000004 },
2589   { 7.1431385093740728e+97, 100, 50,
2590           0.39999999999999991 },
2591   { -8.2252620339727163e+97, 100, 50,
2592           0.50000000000000000 },
2593   { 5.9364045925668061e+97, 100, 50,
2594           0.60000000000000009 },
2595   { 1.8089333903465883e+97, 100, 50,
2596           0.69999999999999996 },
2597   { -1.1029797977454331e+98, 100, 50,
2598           0.80000000000000004 },
2599   { 9.3231278516894892e+96, 100, 50,
2600           0.89999999999999991 },
2601   { 0.0000000000000000, 100, 50,
2602           1.0000000000000000 },
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_assoc_legendre<double>);
2614   for (unsigned int i = 0; i < num_datum; ++i)
2615     {
2616       const Tp f = std::tr1::assoc_legendre(Tp(data035[i].l), Tp(data035[i].m),
2617                    Tp(data035[i].x));
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(1.0000000000000008e-12));
2631 }
2632
2633 // Test data for l=100, m=100.
2634 testcase_assoc_legendre<double> data036[] = {
2635   { 0.0000000000000000, 100, 100,
2636           -1.0000000000000000 },
2637   { 5.7751792255758316e+150, 100, 100,
2638           -0.90000000000000002 },
2639   { 4.3552236041585515e+164, 100, 100,
2640           -0.80000000000000004 },
2641   { 1.5936546850595123e+172, 100, 100,
2642           -0.69999999999999996 },
2643   { 1.3579510590289176e+177, 100, 100,
2644           -0.59999999999999998 },
2645   { 3.7752749682889513e+180, 100, 100,
2646           -0.50000000000000000 },
2647   { 1.0910627330458913e+183, 100, 100,
2648           -0.40000000000000002 },
2649   { 5.9697347526822483e+184, 100, 100,
2650           -0.30000000000000004 },
2651   { 8.6585879147526714e+185, 100, 100,
2652           -0.19999999999999996 },
2653   { 4.0331571908057011e+186, 100, 100,
2654           -0.099999999999999978 },
2655   { 6.6663086700729543e+186, 100, 100,
2656           0.0000000000000000 },
2657   { 4.0331571908057011e+186, 100, 100,
2658           0.10000000000000009 },
2659   { 8.6585879147526714e+185, 100, 100,
2660           0.19999999999999996 },
2661   { 5.9697347526822483e+184, 100, 100,
2662           0.30000000000000004 },
2663   { 1.0910627330458913e+183, 100, 100,
2664           0.39999999999999991 },
2665   { 3.7752749682889513e+180, 100, 100,
2666           0.50000000000000000 },
2667   { 1.3579510590289000e+177, 100, 100,
2668           0.60000000000000009 },
2669   { 1.5936546850595123e+172, 100, 100,
2670           0.69999999999999996 },
2671   { 4.3552236041585515e+164, 100, 100,
2672           0.80000000000000004 },
2673   { 5.7751792255761289e+150, 100, 100,
2674           0.89999999999999991 },
2675   { 0.0000000000000000, 100, 100,
2676           1.0000000000000000 },
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_assoc_legendre<double>);
2688   for (unsigned int i = 0; i < num_datum; ++i)
2689     {
2690       const Tp f = std::tr1::assoc_legendre(Tp(data036[i].l), Tp(data036[i].m),
2691                    Tp(data036[i].x));
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(2.5000000000000020e-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 }