// 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net>
//
// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// .
// ellint_3
// Compare against values generated by the GNU Scientific Library.
// The GSL can be found on the web: http://www.gnu.org/software/gsl/
#include
#if defined(__TEST_DEBUG)
#include
#define VERIFY(A) \
if (!(A)) \
{ \
std::cout << "line " << __LINE__ \
<< " max_abs_frac = " << max_abs_frac \
<< std::endl; \
}
#else
#include
#endif
#include "../testcase.h"
// Test data for k=-0.90000000000000002, nu=0.0000000000000000.
testcase_ellint_3 data001[] = {
{ -0.0000000000000000, -0.90000000000000002, 0.0000000000000000,
0.0000000000000000 },
{ 0.17525427376115027, -0.90000000000000002, 0.0000000000000000,
0.17453292519943295 },
{ 0.35492464591297446, -0.90000000000000002, 0.0000000000000000,
0.34906585039886590 },
{ 0.54388221416157134, -0.90000000000000002, 0.0000000000000000,
0.52359877559829882 },
{ 0.74797400423532523, -0.90000000000000002, 0.0000000000000000,
0.69813170079773179 },
{ 0.97463898451966458, -0.90000000000000002, 0.0000000000000000,
0.87266462599716477 },
{ 1.2334463254523440, -0.90000000000000002, 0.0000000000000000,
1.0471975511965976 },
{ 1.5355247765594910, -0.90000000000000002, 0.0000000000000000,
1.2217304763960306 },
{ 1.8882928567775124, -0.90000000000000002, 0.0000000000000000,
1.3962634015954636 },
{ 2.2805491384227703, -0.90000000000000002, 0.0000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.90000000000000002, nu=0.0000000000000000.
template
void test001()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data001)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data001[i].k), Tp(data001[i].nu),
Tp(data001[i].phi));
const Tp f0 = data001[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.90000000000000002, nu=0.10000000000000001.
testcase_ellint_3 data002[] = {
{ -0.0000000000000000, -0.90000000000000002, 0.10000000000000001,
0.0000000000000000 },
{ 0.17507714233254659, -0.90000000000000002, 0.10000000000000001,
0.17453292519943295 },
{ 0.35350932904326521, -0.90000000000000002, 0.10000000000000001,
0.34906585039886590 },
{ 0.53911129989870998, -0.90000000000000002, 0.10000000000000001,
0.52359877559829882 },
{ 0.73666644254508429, -0.90000000000000002, 0.10000000000000001,
0.69813170079773179 },
{ 0.95250736612100184, -0.90000000000000002, 0.10000000000000001,
0.87266462599716477 },
{ 1.1950199550905594, -0.90000000000000002, 0.10000000000000001,
1.0471975511965976 },
{ 1.4741687286340848, -0.90000000000000002, 0.10000000000000001,
1.2217304763960306 },
{ 1.7968678183506059, -0.90000000000000002, 0.10000000000000001,
1.3962634015954636 },
{ 2.1537868513875287, -0.90000000000000002, 0.10000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.90000000000000002, nu=0.10000000000000001.
template
void test002()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data002)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data002[i].k), Tp(data002[i].nu),
Tp(data002[i].phi));
const Tp f0 = data002[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.90000000000000002, nu=0.20000000000000001.
testcase_ellint_3 data003[] = {
{ -0.0000000000000000, -0.90000000000000002, 0.20000000000000001,
0.0000000000000000 },
{ 0.17490065089140930, -0.90000000000000002, 0.20000000000000001,
0.17453292519943295 },
{ 0.35211377590661436, -0.90000000000000002, 0.20000000000000001,
0.34906585039886590 },
{ 0.53448220334204122, -0.90000000000000002, 0.20000000000000001,
0.52359877559829882 },
{ 0.72591368943179613, -0.90000000000000002, 0.20000000000000001,
0.69813170079773179 },
{ 0.93192539780038763, -0.90000000000000002, 0.20000000000000001,
0.87266462599716477 },
{ 1.1600809679692683, -0.90000000000000002, 0.20000000000000001,
1.0471975511965976 },
{ 1.4195407225882508, -0.90000000000000002, 0.20000000000000001,
1.2217304763960306 },
{ 1.7168966476424528, -0.90000000000000002, 0.20000000000000001,
1.3962634015954636 },
{ 2.0443194576468890, -0.90000000000000002, 0.20000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.90000000000000002, nu=0.20000000000000001.
template
void test003()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data003)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data003[i].k), Tp(data003[i].nu),
Tp(data003[i].phi));
const Tp f0 = data003[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.90000000000000002, nu=0.29999999999999999.
testcase_ellint_3 data004[] = {
{ -0.0000000000000000, -0.90000000000000002, 0.29999999999999999,
0.0000000000000000 },
{ 0.17472479532647534, -0.90000000000000002, 0.29999999999999999,
0.17453292519943295 },
{ 0.35073750187374114, -0.90000000000000002, 0.29999999999999999,
0.34906585039886590 },
{ 0.52998766129466979, -0.90000000000000002, 0.29999999999999999,
0.52359877559829882 },
{ 0.71566993548699587, -0.90000000000000002, 0.29999999999999999,
0.69813170079773179 },
{ 0.91271517762560195, -0.90000000000000002, 0.29999999999999999,
0.87266462599716477 },
{ 1.1281241199843370, -0.90000000000000002, 0.29999999999999999,
1.0471975511965976 },
{ 1.3704929576917448, -0.90000000000000002, 0.29999999999999999,
1.2217304763960306 },
{ 1.6461981511487715, -0.90000000000000002, 0.29999999999999999,
1.3962634015954636 },
{ 1.9486280260314426, -0.90000000000000002, 0.29999999999999999,
1.5707963267948966 },
};
// Test function for k=-0.90000000000000002, nu=0.29999999999999999.
template
void test004()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data004)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data004[i].k), Tp(data004[i].nu),
Tp(data004[i].phi));
const Tp f0 = data004[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.90000000000000002, nu=0.40000000000000002.
testcase_ellint_3 data005[] = {
{ -0.0000000000000000, -0.90000000000000002, 0.40000000000000002,
0.0000000000000000 },
{ 0.17454957156468839, -0.90000000000000002, 0.40000000000000002,
0.17453292519943295 },
{ 0.34938003933330430, -0.90000000000000002, 0.40000000000000002,
0.34906585039886590 },
{ 0.52562093533067455, -0.90000000000000002, 0.40000000000000002,
0.52359877559829882 },
{ 0.70589461324915703, -0.90000000000000002, 0.40000000000000002,
0.69813170079773179 },
{ 0.89472658511942849, -0.90000000000000002, 0.40000000000000002,
0.87266462599716477 },
{ 1.0987419542323440, -0.90000000000000002, 0.40000000000000002,
1.0471975511965976 },
{ 1.3261349565496301, -0.90000000000000002, 0.40000000000000002,
1.2217304763960306 },
{ 1.5831293909853767, -0.90000000000000002, 0.40000000000000002,
1.3962634015954636 },
{ 1.8641114227238349, -0.90000000000000002, 0.40000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.90000000000000002, nu=0.40000000000000002.
template
void test005()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data005)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data005[i].k), Tp(data005[i].nu),
Tp(data005[i].phi));
const Tp f0 = data005[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.90000000000000002, nu=0.50000000000000000.
testcase_ellint_3 data006[] = {
{ -0.0000000000000000, -0.90000000000000002, 0.50000000000000000,
0.0000000000000000 },
{ 0.17437497557073336, -0.90000000000000002, 0.50000000000000000,
0.17453292519943295 },
{ 0.34804093691586013, -0.90000000000000002, 0.50000000000000000,
0.34906585039886590 },
{ 0.52137576320372914, -0.90000000000000002, 0.50000000000000000,
0.52359877559829882 },
{ 0.69655163996912284, -0.90000000000000002, 0.50000000000000000,
0.69813170079773179 },
{ 0.87783188683054236, -0.90000000000000002, 0.50000000000000000,
0.87266462599716477 },
{ 1.0716015959755185, -0.90000000000000002, 0.50000000000000000,
1.0471975511965976 },
{ 1.2857636916026747, -0.90000000000000002, 0.50000000000000000,
1.2217304763960306 },
{ 1.5264263913252365, -0.90000000000000002, 0.50000000000000000,
1.3962634015954636 },
{ 1.7888013241937861, -0.90000000000000002, 0.50000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.90000000000000002, nu=0.50000000000000000.
template
void test006()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data006)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data006[i].k), Tp(data006[i].nu),
Tp(data006[i].phi));
const Tp f0 = data006[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.90000000000000002, nu=0.59999999999999998.
testcase_ellint_3 data007[] = {
{ -0.0000000000000000, -0.90000000000000002, 0.59999999999999998,
0.0000000000000000 },
{ 0.17420100334657815, -0.90000000000000002, 0.59999999999999998,
0.17453292519943295 },
{ 0.34671975876122157, -0.90000000000000002, 0.59999999999999998,
0.34906585039886590 },
{ 0.51724631570707968, -0.90000000000000002, 0.59999999999999998,
0.52359877559829882 },
{ 0.68760879113743056, -0.90000000000000002, 0.59999999999999998,
0.69813170079773179 },
{ 0.86192157779698364, -0.90000000000000002, 0.59999999999999998,
0.87266462599716477 },
{ 1.0464279696166354, -0.90000000000000002, 0.59999999999999998,
1.0471975511965976 },
{ 1.2488156247094004, -0.90000000000000002, 0.59999999999999998,
1.2217304763960306 },
{ 1.4750988777188474, -0.90000000000000002, 0.59999999999999998,
1.3962634015954636 },
{ 1.7211781128919523, -0.90000000000000002, 0.59999999999999998,
1.5707963267948966 },
};
// Test function for k=-0.90000000000000002, nu=0.59999999999999998.
template
void test007()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data007)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data007[i].k), Tp(data007[i].nu),
Tp(data007[i].phi));
const Tp f0 = data007[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.90000000000000002, nu=0.69999999999999996.
testcase_ellint_3 data008[] = {
{ -0.0000000000000000, -0.90000000000000002, 0.69999999999999996,
0.0000000000000000 },
{ 0.17402765093102210, -0.90000000000000002, 0.69999999999999996,
0.17453292519943295 },
{ 0.34541608382635131, -0.90000000000000002, 0.69999999999999996,
0.34906585039886590 },
{ 0.51322715827061705, -0.90000000000000002, 0.69999999999999996,
0.52359877559829882 },
{ 0.67903717872440306, -0.90000000000000002, 0.69999999999999996,
0.69813170079773179 },
{ 0.84690113601682671, -0.90000000000000002, 0.69999999999999996,
0.87266462599716477 },
{ 1.0229914311548418, -0.90000000000000002, 0.69999999999999996,
1.0471975511965976 },
{ 1.2148329639709381, -0.90000000000000002, 0.69999999999999996,
1.2217304763960306 },
{ 1.4283586501307806, -0.90000000000000002, 0.69999999999999996,
1.3962634015954636 },
{ 1.6600480747670938, -0.90000000000000002, 0.69999999999999996,
1.5707963267948966 },
};
// Test function for k=-0.90000000000000002, nu=0.69999999999999996.
template
void test008()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data008)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data008[i].k), Tp(data008[i].nu),
Tp(data008[i].phi));
const Tp f0 = data008[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.90000000000000002, nu=0.80000000000000004.
testcase_ellint_3 data009[] = {
{ -0.0000000000000000, -0.90000000000000002, 0.80000000000000004,
0.0000000000000000 },
{ 0.17385491439925149, -0.90000000000000002, 0.80000000000000004,
0.17453292519943295 },
{ 0.34412950523113928, -0.90000000000000002, 0.80000000000000004,
0.34906585039886590 },
{ 0.50931321668729612, -0.90000000000000002, 0.80000000000000004,
0.52359877559829882 },
{ 0.67081081392296349, -0.90000000000000002, 0.80000000000000004,
0.69813170079773179 },
{ 0.83268846097293259, -0.90000000000000002, 0.80000000000000004,
0.87266462599716477 },
{ 1.0010985015814027, -0.90000000000000002, 0.80000000000000004,
1.0471975511965976 },
{ 1.1834394045489678, -0.90000000000000002, 0.80000000000000004,
1.2217304763960306 },
{ 1.3855695891683188, -0.90000000000000002, 0.80000000000000004,
1.3962634015954636 },
{ 1.6044591960982204, -0.90000000000000002, 0.80000000000000004,
1.5707963267948966 },
};
// Test function for k=-0.90000000000000002, nu=0.80000000000000004.
template
void test009()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data009)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data009[i].k), Tp(data009[i].nu),
Tp(data009[i].phi));
const Tp f0 = data009[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.90000000000000002, nu=0.90000000000000002.
testcase_ellint_3 data010[] = {
{ -0.0000000000000000, -0.90000000000000002, 0.90000000000000002,
0.0000000000000000 },
{ 0.17368278986240138, -0.90000000000000002, 0.90000000000000002,
0.17453292519943295 },
{ 0.34285962963961397, -0.90000000000000002, 0.90000000000000002,
0.34906585039886590 },
{ 0.50549974644993323, -0.90000000000000002, 0.90000000000000002,
0.52359877559829882 },
{ 0.66290623857720898, -0.90000000000000002, 0.90000000000000002,
0.69813170079773179 },
{ 0.81921183128847164, -0.90000000000000002, 0.90000000000000002,
0.87266462599716477 },
{ 0.98058481956066390, -0.90000000000000002, 0.90000000000000002,
1.0471975511965976 },
{ 1.1543223520473567, -0.90000000000000002, 0.90000000000000002,
1.2217304763960306 },
{ 1.3462119782292938, -0.90000000000000002, 0.90000000000000002,
1.3962634015954636 },
{ 1.5536420236310946, -0.90000000000000002, 0.90000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.90000000000000002, nu=0.90000000000000002.
template
void test010()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data010)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data010[i].k), Tp(data010[i].nu),
Tp(data010[i].phi));
const Tp f0 = data010[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.80000000000000004, nu=0.0000000000000000.
testcase_ellint_3 data011[] = {
{ -0.0000000000000000, -0.80000000000000004, 0.0000000000000000,
0.0000000000000000 },
{ 0.17510154241338902, -0.80000000000000004, 0.0000000000000000,
0.17453292519943295 },
{ 0.35365068839779390, -0.80000000000000004, 0.0000000000000000,
0.34906585039886590 },
{ 0.53926804409084561, -0.80000000000000004, 0.0000000000000000,
0.52359877559829882 },
{ 0.73587926028070383, -0.80000000000000004, 0.0000000000000000,
0.69813170079773179 },
{ 0.94770942970071170, -0.80000000000000004, 0.0000000000000000,
0.87266462599716477 },
{ 1.1789022995388239, -0.80000000000000004, 0.0000000000000000,
1.0471975511965976 },
{ 1.4323027881876009, -0.80000000000000004, 0.0000000000000000,
1.2217304763960306 },
{ 1.7069629739121674, -0.80000000000000004, 0.0000000000000000,
1.3962634015954636 },
{ 1.9953027776647296, -0.80000000000000004, 0.0000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.80000000000000004, nu=0.0000000000000000.
template
void test011()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data011)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data011[i].k), Tp(data011[i].nu),
Tp(data011[i].phi));
const Tp f0 = data011[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.80000000000000004, nu=0.10000000000000001.
testcase_ellint_3 data012[] = {
{ -0.0000000000000000, -0.80000000000000004, 0.10000000000000001,
0.0000000000000000 },
{ 0.17492468824017166, -0.80000000000000004, 0.10000000000000001,
0.17453292519943295 },
{ 0.35224443521476911, -0.80000000000000004, 0.10000000000000001,
0.34906585039886590 },
{ 0.53456851853226961, -0.80000000000000004, 0.10000000000000001,
0.52359877559829882 },
{ 0.72488875602364944, -0.80000000000000004, 0.10000000000000001,
0.69813170079773179 },
{ 0.92661354274638952, -0.80000000000000004, 0.10000000000000001,
0.87266462599716477 },
{ 1.1432651144499077, -0.80000000000000004, 0.10000000000000001,
1.0471975511965976 },
{ 1.3774479927211429, -0.80000000000000004, 0.10000000000000001,
1.2217304763960306 },
{ 1.6287092337196041, -0.80000000000000004, 0.10000000000000001,
1.3962634015954636 },
{ 1.8910755418379521, -0.80000000000000004, 0.10000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.80000000000000004, nu=0.10000000000000001.
template
void test012()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data012)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data012[i].k), Tp(data012[i].nu),
Tp(data012[i].phi));
const Tp f0 = data012[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.80000000000000004, nu=0.20000000000000001.
testcase_ellint_3 data013[] = {
{ -0.0000000000000000, -0.80000000000000004, 0.20000000000000001,
0.0000000000000000 },
{ 0.17474847286224943, -0.80000000000000004, 0.20000000000000001,
0.17453292519943295 },
{ 0.35085779529084682, -0.80000000000000004, 0.20000000000000001,
0.34906585039886590 },
{ 0.53000829263059157, -0.80000000000000004, 0.20000000000000001,
0.52359877559829882 },
{ 0.71443466027453406, -0.80000000000000004, 0.20000000000000001,
0.69813170079773179 },
{ 0.90698196872715420, -0.80000000000000004, 0.20000000000000001,
0.87266462599716477 },
{ 1.1108198200558581, -0.80000000000000004, 0.20000000000000001,
1.0471975511965976 },
{ 1.3284988909963957, -0.80000000000000004, 0.20000000000000001,
1.2217304763960306 },
{ 1.5600369318140328, -0.80000000000000004, 0.20000000000000001,
1.3962634015954636 },
{ 1.8007226661734588, -0.80000000000000004, 0.20000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.80000000000000004, nu=0.20000000000000001.
template
void test013()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data013)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data013[i].k), Tp(data013[i].nu),
Tp(data013[i].phi));
const Tp f0 = data013[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.80000000000000004, nu=0.29999999999999999.
testcase_ellint_3 data014[] = {
{ -0.0000000000000000, -0.80000000000000004, 0.29999999999999999,
0.0000000000000000 },
{ 0.17457289217669891, -0.80000000000000004, 0.29999999999999999,
0.17453292519943295 },
{ 0.34949028801501258, -0.80000000000000004, 0.29999999999999999,
0.34906585039886590 },
{ 0.52558024362769318, -0.80000000000000004, 0.29999999999999999,
0.52359877559829882 },
{ 0.70447281740094914, -0.80000000000000004, 0.29999999999999999,
0.69813170079773179 },
{ 0.88864745641528986, -0.80000000000000004, 0.29999999999999999,
0.87266462599716477 },
{ 1.0811075819341465, -0.80000000000000004, 0.29999999999999999,
1.0471975511965976 },
{ 1.2844589654082377, -0.80000000000000004, 0.29999999999999999,
1.2217304763960306 },
{ 1.4991461361277849, -0.80000000000000004, 0.29999999999999999,
1.3962634015954636 },
{ 1.7214611048717301, -0.80000000000000004, 0.29999999999999999,
1.5707963267948966 },
};
// Test function for k=-0.80000000000000004, nu=0.29999999999999999.
template
void test014()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data014)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data014[i].k), Tp(data014[i].nu),
Tp(data014[i].phi));
const Tp f0 = data014[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.80000000000000004, nu=0.40000000000000002.
testcase_ellint_3 data015[] = {
{ -0.0000000000000000, -0.80000000000000004, 0.40000000000000002,
0.0000000000000000 },
{ 0.17439794211872178, -0.80000000000000004, 0.40000000000000002,
0.17453292519943295 },
{ 0.34814144964568972, -0.80000000000000004, 0.40000000000000002,
0.34906585039886590 },
{ 0.52127776285273075, -0.80000000000000004, 0.40000000000000002,
0.52359877559829882 },
{ 0.69496411438966599, -0.80000000000000004, 0.40000000000000002,
0.69813170079773179 },
{ 0.87146878427509589, -0.80000000000000004, 0.40000000000000002,
0.87266462599716477 },
{ 1.0537579024937762, -0.80000000000000004, 0.40000000000000002,
1.0471975511965976 },
{ 1.2445534387922637, -0.80000000000000004, 0.40000000000000002,
1.2217304763960306 },
{ 1.4446769766361993, -0.80000000000000004, 0.40000000000000002,
1.3962634015954636 },
{ 1.6512267838651289, -0.80000000000000004, 0.40000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.80000000000000004, nu=0.40000000000000002.
template
void test015()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data015)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data015[i].k), Tp(data015[i].nu),
Tp(data015[i].phi));
const Tp f0 = data015[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.80000000000000004, nu=0.50000000000000000.
testcase_ellint_3 data016[] = {
{ -0.0000000000000000, -0.80000000000000004, 0.50000000000000000,
0.0000000000000000 },
{ 0.17422361866118047, -0.80000000000000004, 0.50000000000000000,
0.17453292519943295 },
{ 0.34681083254170475, -0.80000000000000004, 0.50000000000000000,
0.34906585039886590 },
{ 0.51709470815494440, -0.80000000000000004, 0.50000000000000000,
0.52359877559829882 },
{ 0.68587375344080259, -0.80000000000000004, 0.50000000000000000,
0.69813170079773179 },
{ 0.85532571852810624, -0.80000000000000004, 0.50000000000000000,
0.87266462599716477 },
{ 1.0284677391874906, -0.80000000000000004, 0.50000000000000000,
1.0471975511965976 },
{ 1.2081693942686225, -0.80000000000000004, 0.50000000000000000,
1.2217304763960306 },
{ 1.3955803006426311, -0.80000000000000004, 0.50000000000000000,
1.3962634015954636 },
{ 1.5884528947755532, -0.80000000000000004, 0.50000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.80000000000000004, nu=0.50000000000000000.
template
void test016()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data016)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data016[i].k), Tp(data016[i].nu),
Tp(data016[i].phi));
const Tp f0 = data016[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.80000000000000004, nu=0.59999999999999998.
testcase_ellint_3 data017[] = {
{ -0.0000000000000000, -0.80000000000000004, 0.59999999999999998,
0.0000000000000000 },
{ 0.17404991781414092, -0.80000000000000004, 0.59999999999999998,
0.17453292519943295 },
{ 0.34549800443625167, -0.80000000000000004, 0.59999999999999998,
0.34906585039886590 },
{ 0.51302536167001556, -0.80000000000000004, 0.59999999999999998,
0.52359877559829882 },
{ 0.67717065003912258, -0.80000000000000004, 0.59999999999999998,
0.69813170079773179 },
{ 0.84011512421134416, -0.80000000000000004, 0.59999999999999998,
0.87266462599716477 },
{ 1.0049863847088742, -0.80000000000000004, 0.59999999999999998,
1.0471975511965976 },
{ 1.1748145941898918, -0.80000000000000004, 0.59999999999999998,
1.2217304763960306 },
{ 1.3510319699755071, -0.80000000000000004, 0.59999999999999998,
1.3962634015954636 },
{ 1.5319262547427865, -0.80000000000000004, 0.59999999999999998,
1.5707963267948966 },
};
// Test function for k=-0.80000000000000004, nu=0.59999999999999998.
template
void test017()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data017)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data017[i].k), Tp(data017[i].nu),
Tp(data017[i].phi));
const Tp f0 = data017[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.80000000000000004, nu=0.69999999999999996.
testcase_ellint_3 data018[] = {
{ -0.0000000000000000, -0.80000000000000004, 0.69999999999999996,
0.0000000000000000 },
{ 0.17387683562442202, -0.80000000000000004, 0.69999999999999996,
0.17453292519943295 },
{ 0.34420254775101611, -0.80000000000000004, 0.69999999999999996,
0.34906585039886590 },
{ 0.50906439222143685, -0.80000000000000004, 0.69999999999999996,
0.52359877559829882 },
{ 0.66882693152688433, -0.80000000000000004, 0.69999999999999996,
0.69813170079773179 },
{ 0.82574792844091316, -0.80000000000000004, 0.69999999999999996,
0.87266462599716477 },
{ 0.98310431309490953, -0.80000000000000004, 0.69999999999999996,
1.0471975511965976 },
{ 1.1440884535113258, -0.80000000000000004, 0.69999999999999996,
1.2217304763960306 },
{ 1.3103743938952537, -0.80000000000000004, 0.69999999999999996,
1.3962634015954636 },
{ 1.4806912324625332, -0.80000000000000004, 0.69999999999999996,
1.5707963267948966 },
};
// Test function for k=-0.80000000000000004, nu=0.69999999999999996.
template
void test018()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data018)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data018[i].k), Tp(data018[i].nu),
Tp(data018[i].phi));
const Tp f0 = data018[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.80000000000000004, nu=0.80000000000000004.
testcase_ellint_3 data019[] = {
{ -0.0000000000000000, -0.80000000000000004, 0.80000000000000004,
0.0000000000000000 },
{ 0.17370436817515206, -0.80000000000000004, 0.80000000000000004,
0.17453292519943295 },
{ 0.34292405894783395, -0.80000000000000004, 0.80000000000000004,
0.34906585039886590 },
{ 0.50520682176250087, -0.80000000000000004, 0.80000000000000004,
0.52359877559829882 },
{ 0.66081751679736189, -0.80000000000000004, 0.80000000000000004,
0.69813170079773179 },
{ 0.81214672249355102, -0.80000000000000004, 0.80000000000000004,
0.87266462599716477 },
{ 0.96264481387685574, -0.80000000000000004, 0.80000000000000004,
1.0471975511965976 },
{ 1.1156611352656258, -0.80000000000000004, 0.80000000000000004,
1.2217304763960306 },
{ 1.2730756225143889, -0.80000000000000004, 0.80000000000000004,
1.3962634015954636 },
{ 1.4339837018309474, -0.80000000000000004, 0.80000000000000004,
1.5707963267948966 },
};
// Test function for k=-0.80000000000000004, nu=0.80000000000000004.
template
void test019()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data019)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data019[i].k), Tp(data019[i].nu),
Tp(data019[i].phi));
const Tp f0 = data019[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.80000000000000004, nu=0.90000000000000002.
testcase_ellint_3 data020[] = {
{ -0.0000000000000000, -0.80000000000000004, 0.90000000000000002,
0.0000000000000000 },
{ 0.17353251158533153, -0.80000000000000004, 0.90000000000000002,
0.17453292519943295 },
{ 0.34166214791545768, -0.80000000000000004, 0.90000000000000002,
0.34906585039886590 },
{ 0.50144799535130580, -0.80000000000000004, 0.90000000000000002,
0.52359877559829882 },
{ 0.65311976193814447, -0.80000000000000004, 0.90000000000000002,
0.69813170079773179 },
{ 0.79924384892320866, -0.80000000000000004, 0.90000000000000002,
0.87266462599716477 },
{ 0.94345762353365625, -0.80000000000000004, 0.90000000000000002,
1.0471975511965976 },
{ 1.0892582069219159, -0.80000000000000004, 0.90000000000000002,
1.2217304763960306 },
{ 1.2387000876610268, -0.80000000000000004, 0.90000000000000002,
1.3962634015954636 },
{ 1.3911845406776222, -0.80000000000000004, 0.90000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.80000000000000004, nu=0.90000000000000002.
template
void test020()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data020)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data020[i].k), Tp(data020[i].nu),
Tp(data020[i].phi));
const Tp f0 = data020[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.69999999999999996, nu=0.0000000000000000.
testcase_ellint_3 data021[] = {
{ -0.0000000000000000, -0.69999999999999996, 0.0000000000000000,
0.0000000000000000 },
{ 0.17496737466916720, -0.69999999999999996, 0.0000000000000000,
0.17453292519943295 },
{ 0.35254687535677925, -0.69999999999999996, 0.0000000000000000,
0.34906585039886590 },
{ 0.53536740275997130, -0.69999999999999996, 0.0000000000000000,
0.52359877559829882 },
{ 0.72603797651684465, -0.69999999999999996, 0.0000000000000000,
0.69813170079773179 },
{ 0.92698296348313458, -0.69999999999999996, 0.0000000000000000,
0.87266462599716477 },
{ 1.1400447527693316, -0.69999999999999996, 0.0000000000000000,
1.0471975511965976 },
{ 1.3657668117194071, -0.69999999999999996, 0.0000000000000000,
1.2217304763960306 },
{ 1.6024686895959159, -0.69999999999999996, 0.0000000000000000,
1.3962634015954636 },
{ 1.8456939983747236, -0.69999999999999996, 0.0000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.69999999999999996, nu=0.0000000000000000.
template
void test021()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data021)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data021[i].k), Tp(data021[i].nu),
Tp(data021[i].phi));
const Tp f0 = data021[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.69999999999999996, nu=0.10000000000000001.
testcase_ellint_3 data022[] = {
{ -0.0000000000000000, -0.69999999999999996, 0.10000000000000001,
0.0000000000000000 },
{ 0.17479076384884681, -0.69999999999999996, 0.10000000000000001,
0.17453292519943295 },
{ 0.35114844900396364, -0.69999999999999996, 0.10000000000000001,
0.34906585039886590 },
{ 0.53072776947527012, -0.69999999999999996, 0.10000000000000001,
0.52359877559829882 },
{ 0.71530198262386246, -0.69999999999999996, 0.10000000000000001,
0.69813170079773179 },
{ 0.90666760677828306, -0.69999999999999996, 0.10000000000000001,
0.87266462599716477 },
{ 1.1063366517438080, -0.69999999999999996, 0.10000000000000001,
1.0471975511965976 },
{ 1.3149477243092147, -0.69999999999999996, 0.10000000000000001,
1.2217304763960306 },
{ 1.5314886725038925, -0.69999999999999996, 0.10000000000000001,
1.3962634015954636 },
{ 1.7528050171757608, -0.69999999999999996, 0.10000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.69999999999999996, nu=0.10000000000000001.
template
void test022()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data022)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data022[i].k), Tp(data022[i].nu),
Tp(data022[i].phi));
const Tp f0 = data022[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.69999999999999996, nu=0.20000000000000001.
testcase_ellint_3 data023[] = {
{ -0.0000000000000000, -0.69999999999999996, 0.20000000000000001,
0.0000000000000000 },
{ 0.17461479077791472, -0.69999999999999996, 0.20000000000000001,
0.17453292519943295 },
{ 0.34976950621407538, -0.69999999999999996, 0.20000000000000001,
0.34906585039886590 },
{ 0.52622533231350188, -0.69999999999999996, 0.20000000000000001,
0.52359877559829882 },
{ 0.70508774017895226, -0.69999999999999996, 0.20000000000000001,
0.69813170079773179 },
{ 0.88775302531730294, -0.69999999999999996, 0.20000000000000001,
0.87266462599716477 },
{ 1.0756195476149006, -0.69999999999999996, 0.20000000000000001,
1.0471975511965976 },
{ 1.2695349716654372, -0.69999999999999996, 0.20000000000000001,
1.2217304763960306 },
{ 1.4690814617070540, -0.69999999999999996, 0.20000000000000001,
1.3962634015954636 },
{ 1.6721098780092147, -0.69999999999999996, 0.20000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.69999999999999996, nu=0.20000000000000001.
template
void test023()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data023)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data023[i].k), Tp(data023[i].nu),
Tp(data023[i].phi));
const Tp f0 = data023[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.69999999999999996, nu=0.29999999999999999.
testcase_ellint_3 data024[] = {
{ -0.0000000000000000, -0.69999999999999996, 0.29999999999999999,
0.0000000000000000 },
{ 0.17443945136076172, -0.69999999999999996, 0.29999999999999999,
0.17453292519943295 },
{ 0.34840956983535287, -0.69999999999999996, 0.29999999999999999,
0.34906585039886590 },
{ 0.52185308551329179, -0.69999999999999996, 0.29999999999999999,
0.52359877559829882 },
{ 0.69535240431168266, -0.69999999999999996, 0.29999999999999999,
0.69813170079773179 },
{ 0.87007983473964923, -0.69999999999999996, 0.29999999999999999,
0.87266462599716477 },
{ 1.0474657975577066, -0.69999999999999996, 0.29999999999999999,
1.0471975511965976 },
{ 1.2286225419931889, -0.69999999999999996, 0.29999999999999999,
1.2217304763960306 },
{ 1.4136490671013271, -0.69999999999999996, 0.29999999999999999,
1.3962634015954636 },
{ 1.6011813647733213, -0.69999999999999996, 0.29999999999999999,
1.5707963267948966 },
};
// Test function for k=-0.69999999999999996, nu=0.29999999999999999.
template
void test024()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data024)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data024[i].k), Tp(data024[i].nu),
Tp(data024[i].phi));
const Tp f0 = data024[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.69999999999999996, nu=0.40000000000000002.
testcase_ellint_3 data025[] = {
{ -0.0000000000000000, -0.69999999999999996, 0.40000000000000002,
0.0000000000000000 },
{ 0.17426474153983226, -0.69999999999999996, 0.40000000000000002,
0.17453292519943295 },
{ 0.34706817945773732, -0.69999999999999996, 0.40000000000000002,
0.34906585039886590 },
{ 0.51760452851738159, -0.69999999999999996, 0.40000000000000002,
0.52359877559829882 },
{ 0.68605801534722766, -0.69999999999999996, 0.40000000000000002,
0.69813170079773179 },
{ 0.85351339387296532, -0.69999999999999996, 0.40000000000000002,
0.87266462599716477 },
{ 1.0215297967969537, -0.69999999999999996, 0.40000000000000002,
1.0471975511965976 },
{ 1.1915051074460528, -0.69999999999999996, 0.40000000000000002,
1.2217304763960306 },
{ 1.3639821911744707, -0.69999999999999996, 0.40000000000000002,
1.3962634015954636 },
{ 1.5382162002954762, -0.69999999999999996, 0.40000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.69999999999999996, nu=0.40000000000000002.
template
void test025()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data025)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data025[i].k), Tp(data025[i].nu),
Tp(data025[i].phi));
const Tp f0 = data025[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.69999999999999996, nu=0.50000000000000000.
testcase_ellint_3 data026[] = {
{ -0.0000000000000000, -0.69999999999999996, 0.50000000000000000,
0.0000000000000000 },
{ 0.17409065729516093, -0.69999999999999996, 0.50000000000000000,
0.17453292519943295 },
{ 0.34574489064986091, -0.69999999999999996, 0.50000000000000000,
0.34906585039886590 },
{ 0.51347361925579793, -0.69999999999999996, 0.50000000000000000,
0.52359877559829882 },
{ 0.67717079489579290, -0.69999999999999996, 0.50000000000000000,
0.69813170079773179 },
{ 0.83793902055292280, -0.69999999999999996, 0.50000000000000000,
0.87266462599716477 },
{ 0.99752863545289705, -0.69999999999999996, 0.50000000000000000,
1.0471975511965976 },
{ 1.1576240080401499, -0.69999999999999996, 0.50000000000000000,
1.2217304763960306 },
{ 1.3191464023923762, -0.69999999999999996, 0.50000000000000000,
1.3962634015954636 },
{ 1.4818433192178544, -0.69999999999999996, 0.50000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.69999999999999996, nu=0.50000000000000000.
template
void test026()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data026)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data026[i].k), Tp(data026[i].nu),
Tp(data026[i].phi));
const Tp f0 = data026[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.69999999999999996, nu=0.59999999999999998.
testcase_ellint_3 data027[] = {
{ -0.0000000000000000, -0.69999999999999996, 0.59999999999999998,
0.0000000000000000 },
{ 0.17391719464391611, -0.69999999999999996, 0.59999999999999998,
0.17453292519943295 },
{ 0.34443927423869031, -0.69999999999999996, 0.59999999999999998,
0.34906585039886590 },
{ 0.50945473266486074, -0.69999999999999996, 0.59999999999999998,
0.52359877559829882 },
{ 0.66866056326513823, -0.69999999999999996, 0.59999999999999998,
0.69813170079773179 },
{ 0.82325830002337352, -0.69999999999999996, 0.59999999999999998,
0.87266462599716477 },
{ 0.97522808245669357, -0.69999999999999996, 0.59999999999999998,
1.0471975511965976 },
{ 1.1265300613705282, -0.69999999999999996, 0.59999999999999998,
1.2217304763960306 },
{ 1.2784066076152003, -0.69999999999999996, 0.59999999999999998,
1.3962634015954636 },
{ 1.4309994736080540, -0.69999999999999996, 0.59999999999999998,
1.5707963267948966 },
};
// Test function for k=-0.69999999999999996, nu=0.59999999999999998.
template
void test027()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data027)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data027[i].k), Tp(data027[i].nu),
Tp(data027[i].phi));
const Tp f0 = data027[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.69999999999999996, nu=0.69999999999999996.
testcase_ellint_3 data028[] = {
{ -0.0000000000000000, -0.69999999999999996, 0.69999999999999996,
0.0000000000000000 },
{ 0.17374434963995028, -0.69999999999999996, 0.69999999999999996,
0.17453292519943295 },
{ 0.34315091562900674, -0.69999999999999996, 0.69999999999999996,
0.34906585039886590 },
{ 0.50554262375653358, -0.69999999999999996, 0.69999999999999996,
0.52359877559829882 },
{ 0.66050025406305812, -0.69999999999999996, 0.69999999999999996,
0.69813170079773179 },
{ 0.80938620118847404, -0.69999999999999996, 0.69999999999999996,
0.87266462599716477 },
{ 0.95443223855852144, -0.69999999999999996, 0.69999999999999996,
1.0471975511965976 },
{ 1.0978573207128302, -0.69999999999999996, 0.69999999999999996,
1.2217304763960306 },
{ 1.2411754575007123, -0.69999999999999996, 0.69999999999999996,
1.3962634015954636 },
{ 1.3848459188329196, -0.69999999999999996, 0.69999999999999996,
1.5707963267948966 },
};
// Test function for k=-0.69999999999999996, nu=0.69999999999999996.
template
void test028()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data028)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data028[i].k), Tp(data028[i].nu),
Tp(data028[i].phi));
const Tp f0 = data028[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.69999999999999996, nu=0.80000000000000004.
testcase_ellint_3 data029[] = {
{ -0.0000000000000000, -0.69999999999999996, 0.80000000000000004,
0.0000000000000000 },
{ 0.17357211837335737, -0.69999999999999996, 0.80000000000000004,
0.17453292519943295 },
{ 0.34187941416012108, -0.69999999999999996, 0.80000000000000004,
0.34906585039886590 },
{ 0.50173239465478270, -0.69999999999999996, 0.80000000000000004,
0.52359877559829882 },
{ 0.65266550725988315, -0.69999999999999996, 0.80000000000000004,
0.69813170079773179 },
{ 0.79624879865249298, -0.69999999999999996, 0.80000000000000004,
0.87266462599716477 },
{ 0.93497577043296920, -0.69999999999999996, 0.80000000000000004,
1.0471975511965976 },
{ 1.0713041566930748, -0.69999999999999996, 0.80000000000000004,
1.2217304763960306 },
{ 1.2069772023255652, -0.69999999999999996, 0.80000000000000004,
1.3962634015954636 },
{ 1.3427110650397533, -0.69999999999999996, 0.80000000000000004,
1.5707963267948966 },
};
// Test function for k=-0.69999999999999996, nu=0.80000000000000004.
template
void test029()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data029)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data029[i].k), Tp(data029[i].nu),
Tp(data029[i].phi));
const Tp f0 = data029[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.69999999999999996, nu=0.90000000000000002.
testcase_ellint_3 data030[] = {
{ -0.0000000000000000, -0.69999999999999996, 0.90000000000000002,
0.0000000000000000 },
{ 0.17340049697003634, -0.69999999999999996, 0.90000000000000002,
0.17453292519943295 },
{ 0.34062438249741556, -0.69999999999999996, 0.90000000000000002,
0.34906585039886590 },
{ 0.49801946510076878, -0.69999999999999996, 0.90000000000000002,
0.52359877559829882 },
{ 0.64513432604750487, -0.69999999999999996, 0.90000000000000002,
0.69813170079773179 },
{ 0.78378145487573758, -0.69999999999999996, 0.90000000000000002,
0.87266462599716477 },
{ 0.91671799500854634, -0.69999999999999996, 0.90000000000000002,
1.0471975511965976 },
{ 1.0466193579463123, -0.69999999999999996, 0.90000000000000002,
1.2217304763960306 },
{ 1.1754218079199146, -0.69999999999999996, 0.90000000000000002,
1.3962634015954636 },
{ 1.3040500499695911, -0.69999999999999996, 0.90000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.69999999999999996, nu=0.90000000000000002.
template
void test030()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data030)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data030[i].k), Tp(data030[i].nu),
Tp(data030[i].phi));
const Tp f0 = data030[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.59999999999999998, nu=0.0000000000000000.
testcase_ellint_3 data031[] = {
{ -0.0000000000000000, -0.59999999999999998, 0.0000000000000000,
0.0000000000000000 },
{ 0.17485154362988362, -0.59999999999999998, 0.0000000000000000,
0.17453292519943295 },
{ 0.35160509865544326, -0.59999999999999998, 0.0000000000000000,
0.34906585039886590 },
{ 0.53210652578446160, -0.59999999999999998, 0.0000000000000000,
0.52359877559829882 },
{ 0.71805304664485670, -0.59999999999999998, 0.0000000000000000,
0.69813170079773179 },
{ 0.91082759030195970, -0.59999999999999998, 0.0000000000000000,
0.87266462599716477 },
{ 1.1112333229323361, -0.59999999999999998, 0.0000000000000000,
1.0471975511965976 },
{ 1.3191461190365270, -0.59999999999999998, 0.0000000000000000,
1.2217304763960306 },
{ 1.5332022105084773, -0.59999999999999998, 0.0000000000000000,
1.3962634015954636 },
{ 1.7507538029157526, -0.59999999999999998, 0.0000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.59999999999999998, nu=0.0000000000000000.
template
void test031()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data031)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data031[i].k), Tp(data031[i].nu),
Tp(data031[i].phi));
const Tp f0 = data031[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.59999999999999998, nu=0.10000000000000001.
testcase_ellint_3 data032[] = {
{ -0.0000000000000000, -0.59999999999999998, 0.10000000000000001,
0.0000000000000000 },
{ 0.17467514275022014, -0.59999999999999998, 0.10000000000000001,
0.17453292519943295 },
{ 0.35021333086258255, -0.59999999999999998, 0.10000000000000001,
0.34906585039886590 },
{ 0.52751664092962713, -0.59999999999999998, 0.10000000000000001,
0.52359877559829882 },
{ 0.70752126971957885, -0.59999999999999998, 0.10000000000000001,
0.69813170079773179 },
{ 0.89111058756112871, -0.59999999999999998, 0.10000000000000001,
0.87266462599716477 },
{ 1.0789241202877768, -0.59999999999999998, 0.10000000000000001,
1.0471975511965976 },
{ 1.2710800210399946, -0.59999999999999998, 0.10000000000000001,
1.2217304763960306 },
{ 1.4669060574440276, -0.59999999999999998, 0.10000000000000001,
1.3962634015954636 },
{ 1.6648615773343014, -0.59999999999999998, 0.10000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.59999999999999998, nu=0.10000000000000001.
template
void test032()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data032)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data032[i].k), Tp(data032[i].nu),
Tp(data032[i].phi));
const Tp f0 = data032[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.59999999999999998, nu=0.20000000000000001.
testcase_ellint_3 data033[] = {
{ -0.0000000000000000, -0.59999999999999998, 0.20000000000000001,
0.0000000000000000 },
{ 0.17449937871800653, -0.59999999999999998, 0.20000000000000001,
0.17453292519943295 },
{ 0.34884093647346553, -0.59999999999999998, 0.20000000000000001,
0.34906585039886590 },
{ 0.52306221119844110, -0.59999999999999998, 0.20000000000000001,
0.52359877559829882 },
{ 0.69749955678982223, -0.59999999999999998, 0.20000000000000001,
0.69813170079773179 },
{ 0.87274610682416853, -0.59999999999999998, 0.20000000000000001,
0.87266462599716477 },
{ 1.0494620540750792, -0.59999999999999998, 0.20000000000000001,
1.0471975511965976 },
{ 1.2280847305507339, -0.59999999999999998, 0.20000000000000001,
1.2217304763960306 },
{ 1.4085436279696886, -0.59999999999999998, 0.20000000000000001,
1.3962634015954636 },
{ 1.5901418016279374, -0.59999999999999998, 0.20000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.59999999999999998, nu=0.20000000000000001.
template
void test033()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data033)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data033[i].k), Tp(data033[i].nu),
Tp(data033[i].phi));
const Tp f0 = data033[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.59999999999999998, nu=0.29999999999999999.
testcase_ellint_3 data034[] = {
{ -0.0000000000000000, -0.59999999999999998, 0.29999999999999999,
0.0000000000000000 },
{ 0.17432424744393935, -0.59999999999999998, 0.29999999999999999,
0.17453292519943295 },
{ 0.34748744127146447, -0.59999999999999998, 0.29999999999999999,
0.34906585039886590 },
{ 0.51873632743924847, -0.59999999999999998, 0.29999999999999999,
0.52359877559829882 },
{ 0.68794610396313127, -0.59999999999999998, 0.29999999999999999,
0.69813170079773179 },
{ 0.85558070175468726, -0.59999999999999998, 0.29999999999999999,
0.87266462599716477 },
{ 1.0224416343605653, -0.59999999999999998, 0.29999999999999999,
1.0471975511965976 },
{ 1.1893144457936788, -0.59999999999999998, 0.29999999999999999,
1.2217304763960306 },
{ 1.3566435377982575, -0.59999999999999998, 0.29999999999999999,
1.3962634015954636 },
{ 1.5243814243493585, -0.59999999999999998, 0.29999999999999999,
1.5707963267948966 },
};
// Test function for k=-0.59999999999999998, nu=0.29999999999999999.
template
void test034()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data034)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data034[i].k), Tp(data034[i].nu),
Tp(data034[i].phi));
const Tp f0 = data034[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.59999999999999998, nu=0.40000000000000002.
testcase_ellint_3 data035[] = {
{ -0.0000000000000000, -0.59999999999999998, 0.40000000000000002,
0.0000000000000000 },
{ 0.17414974487670720, -0.59999999999999998, 0.40000000000000002,
0.17453292519943295 },
{ 0.34615238767335027, -0.59999999999999998, 0.40000000000000002,
0.34906585039886590 },
{ 0.51453257838108579, -0.59999999999999998, 0.40000000000000002,
0.52359877559829882 },
{ 0.67882386787534410, -0.59999999999999998, 0.40000000000000002,
0.69813170079773179 },
{ 0.83948470233173578, -0.59999999999999998, 0.40000000000000002,
0.87266462599716477 },
{ 0.99753496200073977, -0.59999999999999998, 0.40000000000000002,
1.0471975511965976 },
{ 1.1541101404388487, -0.59999999999999998, 0.40000000000000002,
1.2217304763960306 },
{ 1.3100911323398814, -0.59999999999999998, 0.40000000000000002,
1.3962634015954636 },
{ 1.4659345278069984, -0.59999999999999998, 0.40000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.59999999999999998, nu=0.40000000000000002.
template
void test035()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data035)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data035[i].k), Tp(data035[i].nu),
Tp(data035[i].phi));
const Tp f0 = data035[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.59999999999999998, nu=0.50000000000000000.
testcase_ellint_3 data036[] = {
{ -0.0000000000000000, -0.59999999999999998, 0.50000000000000000,
0.0000000000000000 },
{ 0.17397586700252810, -0.59999999999999998, 0.50000000000000000,
0.17453292519943295 },
{ 0.34483533397138516, -0.59999999999999998, 0.50000000000000000,
0.34906585039886590 },
{ 0.51044500461706499, -0.59999999999999998, 0.50000000000000000,
0.52359877559829882 },
{ 0.67009988034712675, -0.59999999999999998, 0.50000000000000000,
0.69813170079773179 },
{ 0.82434762375735193, -0.59999999999999998, 0.50000000000000000,
0.87266462599716477 },
{ 0.97447346702798998, -0.59999999999999998, 0.50000000000000000,
1.0471975511965976 },
{ 1.1219494000522143, -0.59999999999999998, 0.50000000000000000,
1.2217304763960306 },
{ 1.2680242605954486, -0.59999999999999998, 0.50000000000000000,
1.3962634015954636 },
{ 1.4135484285693078, -0.59999999999999998, 0.50000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.59999999999999998, nu=0.50000000000000000.
template
void test036()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data036)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data036[i].k), Tp(data036[i].nu),
Tp(data036[i].phi));
const Tp f0 = data036[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.59999999999999998, nu=0.59999999999999998.
testcase_ellint_3 data037[] = {
{ -0.0000000000000000, -0.59999999999999998, 0.59999999999999998,
0.0000000000000000 },
{ 0.17380260984469356, -0.59999999999999998, 0.59999999999999998,
0.17453292519943295 },
{ 0.34353585361777839, -0.59999999999999998, 0.59999999999999998,
0.34906585039886590 },
{ 0.50646805774321402, -0.59999999999999998, 0.59999999999999998,
0.52359877559829882 },
{ 0.66174468108625517, -0.59999999999999998, 0.59999999999999998,
0.69813170079773179 },
{ 0.81007462280278408, -0.59999999999999998, 0.59999999999999998,
0.87266462599716477 },
{ 0.95303466945718729, -0.59999999999999998, 0.59999999999999998,
1.0471975511965976 },
{ 1.0924118588677503, -0.59999999999999998, 0.59999999999999998,
1.2217304763960306 },
{ 1.2297640574847937, -0.59999999999999998, 0.59999999999999998,
1.3962634015954636 },
{ 1.3662507535812816, -0.59999999999999998, 0.59999999999999998,
1.5707963267948966 },
};
// Test function for k=-0.59999999999999998, nu=0.59999999999999998.
template
void test037()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data037)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data037[i].k), Tp(data037[i].nu),
Tp(data037[i].phi));
const Tp f0 = data037[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.59999999999999998, nu=0.69999999999999996.
testcase_ellint_3 data038[] = {
{ -0.0000000000000000, -0.59999999999999998, 0.69999999999999996,
0.0000000000000000 },
{ 0.17362996946312009, -0.59999999999999998, 0.69999999999999996,
0.17453292519943295 },
{ 0.34225353454870588, -0.59999999999999998, 0.69999999999999996,
0.34906585039886590 },
{ 0.50259656397799546, -0.59999999999999998, 0.69999999999999996,
0.52359877559829882 },
{ 0.65373184496628944, -0.59999999999999998, 0.69999999999999996,
0.69813170079773179 },
{ 0.79658372884056439, -0.59999999999999998, 0.69999999999999996,
0.87266462599716477 },
{ 0.93303240100245421, -0.59999999999999998, 0.69999999999999996,
1.0471975511965976 },
{ 1.0651547944716557, -0.59999999999999998, 0.69999999999999996,
1.2217304763960306 },
{ 1.1947676204853441, -0.59999999999999998, 0.69999999999999996,
1.3962634015954636 },
{ 1.3232737468822811, -0.59999999999999998, 0.69999999999999996,
1.5707963267948966 },
};
// Test function for k=-0.59999999999999998, nu=0.69999999999999996.
template
void test038()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data038)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data038[i].k), Tp(data038[i].nu),
Tp(data038[i].phi));
const Tp f0 = data038[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.59999999999999998, nu=0.80000000000000004.
testcase_ellint_3 data039[] = {
{ -0.0000000000000000, -0.59999999999999998, 0.80000000000000004,
0.0000000000000000 },
{ 0.17345794195390687, -0.59999999999999998, 0.80000000000000004,
0.17453292519943295 },
{ 0.34098797854531027, -0.59999999999999998, 0.80000000000000004,
0.34906585039886590 },
{ 0.49882569168826230, -0.59999999999999998, 0.80000000000000004,
0.52359877559829882 },
{ 0.64603758566475511, -0.59999999999999998, 0.80000000000000004,
0.69813170079773179 },
{ 0.78380365594769730, -0.59999999999999998, 0.80000000000000004,
0.87266462599716477 },
{ 0.91430946255611190, -0.59999999999999998, 0.80000000000000004,
1.0471975511965976 },
{ 1.0398955217270607, -0.59999999999999998, 0.80000000000000004,
1.2217304763960306 },
{ 1.1625948314277676, -0.59999999999999998, 0.80000000000000004,
1.3962634015954636 },
{ 1.2840021261752192, -0.59999999999999998, 0.80000000000000004,
1.5707963267948966 },
};
// Test function for k=-0.59999999999999998, nu=0.80000000000000004.
template
void test039()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data039)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data039[i].k), Tp(data039[i].nu),
Tp(data039[i].phi));
const Tp f0 = data039[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.59999999999999998, nu=0.90000000000000002.
testcase_ellint_3 data040[] = {
{ -0.0000000000000000, -0.59999999999999998, 0.90000000000000002,
0.0000000000000000 },
{ 0.17328652344890033, -0.59999999999999998, 0.90000000000000002,
0.17453292519943295 },
{ 0.33973880062929018, -0.59999999999999998, 0.90000000000000002,
0.34906585039886590 },
{ 0.49515092233122765, -0.59999999999999998, 0.90000000000000002,
0.52359877559829882 },
{ 0.63864042139737043, -0.59999999999999998, 0.90000000000000002,
0.69813170079773179 },
{ 0.77167205646538850, -0.59999999999999998, 0.90000000000000002,
0.87266462599716477 },
{ 0.89673202848034383, -0.59999999999999998, 0.90000000000000002,
1.0471975511965976 },
{ 1.0163984492661304, -0.59999999999999998, 0.90000000000000002,
1.2217304763960306 },
{ 1.1328845785162431, -0.59999999999999998, 0.90000000000000002,
1.3962634015954636 },
{ 1.2479362973851875, -0.59999999999999998, 0.90000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.59999999999999998, nu=0.90000000000000002.
template
void test040()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data040)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data040[i].k), Tp(data040[i].nu),
Tp(data040[i].phi));
const Tp f0 = data040[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.50000000000000000, nu=0.0000000000000000.
testcase_ellint_3 data041[] = {
{ -0.0000000000000000, -0.50000000000000000, 0.0000000000000000,
0.0000000000000000 },
{ 0.17475385514035785, -0.50000000000000000, 0.0000000000000000,
0.17453292519943295 },
{ 0.35081868470101585, -0.50000000000000000, 0.0000000000000000,
0.34906585039886590 },
{ 0.52942862705190585, -0.50000000000000000, 0.0000000000000000,
0.52359877559829882 },
{ 0.71164727562630326, -0.50000000000000000, 0.0000000000000000,
0.69813170079773179 },
{ 0.89824523594227768, -0.50000000000000000, 0.0000000000000000,
0.87266462599716477 },
{ 1.0895506700518851, -0.50000000000000000, 0.0000000000000000,
1.0471975511965976 },
{ 1.2853005857432933, -0.50000000000000000, 0.0000000000000000,
1.2217304763960306 },
{ 1.4845545520549484, -0.50000000000000000, 0.0000000000000000,
1.3962634015954636 },
{ 1.6857503548125963, -0.50000000000000000, 0.0000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.50000000000000000, nu=0.0000000000000000.
template
void test041()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data041)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data041[i].k), Tp(data041[i].nu),
Tp(data041[i].phi));
const Tp f0 = data041[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.50000000000000000, nu=0.10000000000000001.
testcase_ellint_3 data042[] = {
{ -0.0000000000000000, -0.50000000000000000, 0.10000000000000001,
0.0000000000000000 },
{ 0.17457763120814676, -0.50000000000000000, 0.10000000000000001,
0.17453292519943295 },
{ 0.34943246340849154, -0.50000000000000000, 0.10000000000000001,
0.34906585039886590 },
{ 0.52487937869610801, -0.50000000000000000, 0.10000000000000001,
0.52359877559829882 },
{ 0.70127785096388395, -0.50000000000000000, 0.10000000000000001,
0.69813170079773179 },
{ 0.87898815988624479, -0.50000000000000000, 0.10000000000000001,
0.87266462599716477 },
{ 1.0582764576094172, -0.50000000000000000, 0.10000000000000001,
1.0471975511965976 },
{ 1.2391936844060207, -0.50000000000000000, 0.10000000000000001,
1.2217304763960306 },
{ 1.4214793542995841, -0.50000000000000000, 0.10000000000000001,
1.3962634015954636 },
{ 1.6045524936084892, -0.50000000000000000, 0.10000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.50000000000000000, nu=0.10000000000000001.
template
void test042()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data042)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data042[i].k), Tp(data042[i].nu),
Tp(data042[i].phi));
const Tp f0 = data042[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.50000000000000000, nu=0.20000000000000001.
testcase_ellint_3 data043[] = {
{ -0.0000000000000000, -0.50000000000000000, 0.20000000000000001,
0.0000000000000000 },
{ 0.17440204336345433, -0.50000000000000000, 0.20000000000000001,
0.17453292519943295 },
{ 0.34806552388338824, -0.50000000000000000, 0.20000000000000001,
0.34906585039886590 },
{ 0.52046416757129821, -0.50000000000000000, 0.20000000000000001,
0.52359877559829882 },
{ 0.69140924550993876, -0.50000000000000000, 0.20000000000000001,
0.69813170079773179 },
{ 0.86104678636125520, -0.50000000000000000, 0.20000000000000001,
0.87266462599716477 },
{ 1.0297439459053981, -0.50000000000000000, 0.20000000000000001,
1.0471975511965976 },
{ 1.1979214112912036, -0.50000000000000000, 0.20000000000000001,
1.2217304763960306 },
{ 1.3659033858648930, -0.50000000000000000, 0.20000000000000001,
1.3962634015954636 },
{ 1.5338490483665983, -0.50000000000000000, 0.20000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.50000000000000000, nu=0.20000000000000001.
template
void test043()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data043)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data043[i].k), Tp(data043[i].nu),
Tp(data043[i].phi));
const Tp f0 = data043[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.50000000000000000, nu=0.29999999999999999.
testcase_ellint_3 data044[] = {
{ -0.0000000000000000, -0.50000000000000000, 0.29999999999999999,
0.0000000000000000 },
{ 0.17422708752228896, -0.50000000000000000, 0.29999999999999999,
0.17453292519943295 },
{ 0.34671739434855858, -0.50000000000000000, 0.29999999999999999,
0.34906585039886590 },
{ 0.51617616305641889, -0.50000000000000000, 0.29999999999999999,
0.52359877559829882 },
{ 0.68200047612545178, -0.50000000000000000, 0.29999999999999999,
0.69813170079773179 },
{ 0.84427217869498372, -0.50000000000000000, 0.29999999999999999,
0.87266462599716477 },
{ 1.0035637821389782, -0.50000000000000000, 0.29999999999999999,
1.0471975511965976 },
{ 1.1606800483933113, -0.50000000000000000, 0.29999999999999999,
1.2217304763960306 },
{ 1.3164407134643459, -0.50000000000000000, 0.29999999999999999,
1.3962634015954636 },
{ 1.4715681939859637, -0.50000000000000000, 0.29999999999999999,
1.5707963267948966 },
};
// Test function for k=-0.50000000000000000, nu=0.29999999999999999.
template
void test044()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data044)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data044[i].k), Tp(data044[i].nu),
Tp(data044[i].phi));
const Tp f0 = data044[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.50000000000000000, nu=0.40000000000000002.
testcase_ellint_3 data045[] = {
{ -0.0000000000000000, -0.50000000000000000, 0.40000000000000002,
0.0000000000000000 },
{ 0.17405275963859917, -0.50000000000000000, 0.40000000000000002,
0.17453292519943295 },
{ 0.34538761957029329, -0.50000000000000000, 0.40000000000000002,
0.34906585039886590 },
{ 0.51200902646603919, -0.50000000000000000, 0.40000000000000002,
0.52359877559829882 },
{ 0.67301522212868792, -0.50000000000000000, 0.40000000000000002,
0.69813170079773179 },
{ 0.82853844466313320, -0.50000000000000000, 0.40000000000000002,
0.87266462599716477 },
{ 0.97942097862681488, -0.50000000000000000, 0.40000000000000002,
1.0471975511965976 },
{ 1.1268429801220616, -0.50000000000000000, 0.40000000000000002,
1.2217304763960306 },
{ 1.2720406704533922, -0.50000000000000000, 0.40000000000000002,
1.3962634015954636 },
{ 1.4161679518465340, -0.50000000000000000, 0.40000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.50000000000000000, nu=0.40000000000000002.
template
void test045()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data045)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data045[i].k), Tp(data045[i].nu),
Tp(data045[i].phi));
const Tp f0 = data045[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.50000000000000000, nu=0.50000000000000000.
testcase_ellint_3 data046[] = {
{ -0.0000000000000000, -0.50000000000000000, 0.50000000000000000,
0.0000000000000000 },
{ 0.17387905570381157, -0.50000000000000000, 0.50000000000000000,
0.17453292519943295 },
{ 0.34407576010465207, -0.50000000000000000, 0.50000000000000000,
0.34906585039886590 },
{ 0.50795686560160835, -0.50000000000000000, 0.50000000000000000,
0.52359877559829882 },
{ 0.66442115453330175, -0.50000000000000000, 0.50000000000000000,
0.69813170079773179 },
{ 0.81373829119355345, -0.50000000000000000, 0.50000000000000000,
0.87266462599716477 },
{ 0.95705743313235825, -0.50000000000000000, 0.50000000000000000,
1.0471975511965976 },
{ 1.0959131991362556, -0.50000000000000000, 0.50000000000000000,
1.2217304763960306 },
{ 1.2318900529754597, -0.50000000000000000, 0.50000000000000000,
1.3962634015954636 },
{ 1.3664739530045971, -0.50000000000000000, 0.50000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.50000000000000000, nu=0.50000000000000000.
template
void test046()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data046)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data046[i].k), Tp(data046[i].nu),
Tp(data046[i].phi));
const Tp f0 = data046[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.50000000000000000, nu=0.59999999999999998.
testcase_ellint_3 data047[] = {
{ -0.0000000000000000, -0.50000000000000000, 0.59999999999999998,
0.0000000000000000 },
{ 0.17370597174637581, -0.50000000000000000, 0.59999999999999998,
0.17453292519943295 },
{ 0.34278139158591414, -0.50000000000000000, 0.59999999999999998,
0.34906585039886590 },
{ 0.50401419439302719, -0.50000000000000000, 0.59999999999999998,
0.52359877559829882 },
{ 0.65618938076167221, -0.50000000000000000, 0.59999999999999998,
0.69813170079773179 },
{ 0.79977959248855424, -0.50000000000000000, 0.59999999999999998,
0.87266462599716477 },
{ 0.93625925190753545, -0.50000000000000000, 0.59999999999999998,
1.0471975511965976 },
{ 1.0674905658379710, -0.50000000000000000, 0.59999999999999998,
1.2217304763960306 },
{ 1.1953481298023048, -0.50000000000000000, 0.59999999999999998,
1.3962634015954636 },
{ 1.3215740290190876, -0.50000000000000000, 0.59999999999999998,
1.5707963267948966 },
};
// Test function for k=-0.50000000000000000, nu=0.59999999999999998.
template
void test047()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data047)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data047[i].k), Tp(data047[i].nu),
Tp(data047[i].phi));
const Tp f0 = data047[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.50000000000000000, nu=0.69999999999999996.
testcase_ellint_3 data048[] = {
{ -0.0000000000000000, -0.50000000000000000, 0.69999999999999996,
0.0000000000000000 },
{ 0.17353350383131641, -0.50000000000000000, 0.69999999999999996,
0.17453292519943295 },
{ 0.34150410405436771, -0.50000000000000000, 0.69999999999999996,
0.34906585039886590 },
{ 0.50017589696443487, -0.50000000000000000, 0.69999999999999996,
0.52359877559829882 },
{ 0.64829398188419962, -0.50000000000000000, 0.69999999999999996,
0.69813170079773179 },
{ 0.78658270782402073, -0.50000000000000000, 0.69999999999999996,
0.87266462599716477 },
{ 0.91684738336675053, -0.50000000000000000, 0.69999999999999996,
1.0471975511965976 },
{ 1.0412486789555937, -0.50000000000000000, 0.69999999999999996,
1.2217304763960306 },
{ 1.1619021847612001, -0.50000000000000000, 0.69999999999999996,
1.3962634015954636 },
{ 1.2807475181182502, -0.50000000000000000, 0.69999999999999996,
1.5707963267948966 },
};
// Test function for k=-0.50000000000000000, nu=0.69999999999999996.
template
void test048()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data048)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data048[i].k), Tp(data048[i].nu),
Tp(data048[i].phi));
const Tp f0 = data048[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.50000000000000000, nu=0.80000000000000004.
testcase_ellint_3 data049[] = {
{ -0.0000000000000000, -0.50000000000000000, 0.80000000000000004,
0.0000000000000000 },
{ 0.17336164805979126, -0.50000000000000000, 0.80000000000000004,
0.17453292519943295 },
{ 0.34024350132086773, -0.50000000000000000, 0.80000000000000004,
0.34906585039886590 },
{ 0.49643719555734084, -0.50000000000000000, 0.80000000000000004,
0.52359877559829882 },
{ 0.64071162456976150, -0.50000000000000000, 0.80000000000000004,
0.69813170079773179 },
{ 0.77407836177211908, -0.50000000000000000, 0.80000000000000004,
0.87266462599716477 },
{ 0.89867058251905652, -0.50000000000000000, 0.80000000000000004,
1.0471975511965976 },
{ 1.0169181822134912, -0.50000000000000000, 0.80000000000000004,
1.2217304763960306 },
{ 1.1311363312779448, -0.50000000000000000, 0.80000000000000004,
1.3962634015954636 },
{ 1.2434165408189539, -0.50000000000000000, 0.80000000000000004,
1.5707963267948966 },
};
// Test function for k=-0.50000000000000000, nu=0.80000000000000004.
template
void test049()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data049)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data049[i].k), Tp(data049[i].nu),
Tp(data049[i].phi));
const Tp f0 = data049[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.50000000000000000, nu=0.90000000000000002.
testcase_ellint_3 data050[] = {
{ -0.0000000000000000, -0.50000000000000000, 0.90000000000000002,
0.0000000000000000 },
{ 0.17319040056865681, -0.50000000000000000, 0.90000000000000002,
0.17453292519943295 },
{ 0.33899920036578557, -0.50000000000000000, 0.90000000000000002,
0.34906585039886590 },
{ 0.49279362182695186, -0.50000000000000000, 0.90000000000000002,
0.52359877559829882 },
{ 0.63342123379746151, -0.50000000000000000, 0.90000000000000002,
0.69813170079773179 },
{ 0.76220595179550321, -0.50000000000000000, 0.90000000000000002,
0.87266462599716477 },
{ 0.88160004743532294, -0.50000000000000000, 0.90000000000000002,
1.0471975511965976 },
{ 0.99427448642310134, -0.50000000000000000, 0.90000000000000002,
1.2217304763960306 },
{ 1.1027091512470093, -0.50000000000000000, 0.90000000000000002,
1.3962634015954636 },
{ 1.2091116095504744, -0.50000000000000000, 0.90000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.50000000000000000, nu=0.90000000000000002.
template
void test050()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data050)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data050[i].k), Tp(data050[i].nu),
Tp(data050[i].phi));
const Tp f0 = data050[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.40000000000000002, nu=0.0000000000000000.
testcase_ellint_3 data051[] = {
{ -0.0000000000000000, -0.40000000000000002, 0.0000000000000000,
0.0000000000000000 },
{ 0.17467414669441531, -0.40000000000000002, 0.0000000000000000,
0.17453292519943295 },
{ 0.35018222772483443, -0.40000000000000002, 0.0000000000000000,
0.34906585039886590 },
{ 0.52729015917508748, -0.40000000000000002, 0.0000000000000000,
0.52359877559829882 },
{ 0.70662374407341255, -0.40000000000000002, 0.0000000000000000,
0.69813170079773179 },
{ 0.88859210497602170, -0.40000000000000002, 0.0000000000000000,
0.87266462599716477 },
{ 1.0733136290471379, -0.40000000000000002, 0.0000000000000000,
1.0471975511965976 },
{ 1.2605612170157061, -0.40000000000000002, 0.0000000000000000,
1.2217304763960306 },
{ 1.4497513956433437, -0.40000000000000002, 0.0000000000000000,
1.3962634015954636 },
{ 1.6399998658645112, -0.40000000000000002, 0.0000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.40000000000000002, nu=0.0000000000000000.
template
void test051()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data051)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data051[i].k), Tp(data051[i].nu),
Tp(data051[i].phi));
const Tp f0 = data051[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.40000000000000002, nu=0.10000000000000001.
testcase_ellint_3 data052[] = {
{ -0.0000000000000000, -0.40000000000000002, 0.10000000000000001,
0.0000000000000000 },
{ 0.17449806706684673, -0.40000000000000002, 0.10000000000000001,
0.17453292519943295 },
{ 0.34880048623856075, -0.40000000000000002, 0.10000000000000001,
0.34906585039886590 },
{ 0.52277322065757403, -0.40000000000000002, 0.10000000000000001,
0.52359877559829882 },
{ 0.69638072056918376, -0.40000000000000002, 0.10000000000000001,
0.69813170079773179 },
{ 0.86968426619831540, -0.40000000000000002, 0.10000000000000001,
0.87266462599716477 },
{ 1.0428044206578095, -0.40000000000000002, 0.10000000000000001,
1.0471975511965976 },
{ 1.2158651158274378, -0.40000000000000002, 0.10000000000000001,
1.2217304763960306 },
{ 1.3889447129893322, -0.40000000000000002, 0.10000000000000001,
1.3962634015954636 },
{ 1.5620566886683604, -0.40000000000000002, 0.10000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.40000000000000002, nu=0.10000000000000001.
template
void test052()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data052)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data052[i].k), Tp(data052[i].nu),
Tp(data052[i].phi));
const Tp f0 = data052[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.40000000000000002, nu=0.20000000000000001.
testcase_ellint_3 data053[] = {
{ -0.0000000000000000, -0.40000000000000002, 0.20000000000000001,
0.0000000000000000 },
{ 0.17432262290723399, -0.40000000000000002, 0.20000000000000001,
0.17453292519943295 },
{ 0.34743795258968596, -0.40000000000000002, 0.20000000000000001,
0.34906585039886590 },
{ 0.51838919472805123, -0.40000000000000002, 0.20000000000000001,
0.52359877559829882 },
{ 0.68663134739057918, -0.40000000000000002, 0.20000000000000001,
0.69813170079773179 },
{ 0.85206432981833979, -0.40000000000000002, 0.20000000000000001,
0.87266462599716477 },
{ 1.0149595349004430, -0.40000000000000002, 0.20000000000000001,
1.0471975511965976 },
{ 1.1758349405464676, -0.40000000000000002, 0.20000000000000001,
1.2217304763960306 },
{ 1.3353337673882635, -0.40000000000000002, 0.20000000000000001,
1.3962634015954636 },
{ 1.4941414344266770, -0.40000000000000002, 0.20000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.40000000000000002, nu=0.20000000000000001.
template
void test053()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data053)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data053[i].k), Tp(data053[i].nu),
Tp(data053[i].phi));
const Tp f0 = data053[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.40000000000000002, nu=0.29999999999999999.
testcase_ellint_3 data054[] = {
{ -0.0000000000000000, -0.40000000000000002, 0.29999999999999999,
0.0000000000000000 },
{ 0.17414781013591543, -0.40000000000000002, 0.29999999999999999,
0.17453292519943295 },
{ 0.34609415696777285, -0.40000000000000002, 0.29999999999999999,
0.34906585039886590 },
{ 0.51413131295862546, -0.40000000000000002, 0.29999999999999999,
0.52359877559829882 },
{ 0.67733527622935630, -0.40000000000000002, 0.29999999999999999,
0.69813170079773179 },
{ 0.83558675182733266, -0.40000000000000002, 0.29999999999999999,
0.87266462599716477 },
{ 0.98940140808865906, -0.40000000000000002, 0.29999999999999999,
1.0471975511965976 },
{ 1.1396968797728058, -0.40000000000000002, 0.29999999999999999,
1.2217304763960306 },
{ 1.2875920037865087, -0.40000000000000002, 0.29999999999999999,
1.3962634015954636 },
{ 1.4342789859950078, -0.40000000000000002, 0.29999999999999999,
1.5707963267948966 },
};
// Test function for k=-0.40000000000000002, nu=0.29999999999999999.
template
void test054()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data054)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data054[i].k), Tp(data054[i].nu),
Tp(data054[i].phi));
const Tp f0 = data054[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.40000000000000002, nu=0.40000000000000002.
testcase_ellint_3 data055[] = {
{ -0.0000000000000000, -0.40000000000000002, 0.40000000000000002,
0.0000000000000000 },
{ 0.17397362471112710, -0.40000000000000002, 0.40000000000000002,
0.17453292519943295 },
{ 0.34476864603333196, -0.40000000000000002, 0.40000000000000002,
0.34906585039886590 },
{ 0.50999329415379357, -0.40000000000000002, 0.40000000000000002,
0.52359877559829882 },
{ 0.66845674551396017, -0.40000000000000002, 0.40000000000000002,
0.69813170079773179 },
{ 0.82012848346231748, -0.40000000000000002, 0.40000000000000002,
0.87266462599716477 },
{ 0.96582449258349057, -0.40000000000000002, 0.40000000000000002,
1.0471975511965976 },
{ 1.1068473749476286, -0.40000000000000002, 0.40000000000000002,
1.2217304763960306 },
{ 1.2447132729159986, -0.40000000000000002, 0.40000000000000002,
1.3962634015954636 },
{ 1.3809986210732901, -0.40000000000000002, 0.40000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.40000000000000002, nu=0.40000000000000002.
template
void test055()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data055)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data055[i].k), Tp(data055[i].nu),
Tp(data055[i].phi));
const Tp f0 = data055[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.40000000000000002, nu=0.50000000000000000.
testcase_ellint_3 data056[] = {
{ -0.0000000000000000, -0.40000000000000002, 0.50000000000000000,
0.0000000000000000 },
{ 0.17380006262854139, -0.40000000000000002, 0.50000000000000000,
0.17453292519943295 },
{ 0.34346098216756610, -0.40000000000000002, 0.50000000000000000,
0.34906585039886590 },
{ 0.50596929935059420, -0.40000000000000002, 0.50000000000000000,
0.52359877559829882 },
{ 0.65996392089131262, -0.40000000000000002, 0.50000000000000000,
0.69813170079773179 },
{ 0.80558463511364786, -0.40000000000000002, 0.50000000000000000,
0.87266462599716477 },
{ 0.94397834522857704, -0.40000000000000002, 0.50000000000000000,
1.0471975511965976 },
{ 1.0768075114108115, -0.40000000000000002, 0.50000000000000000,
1.2217304763960306 },
{ 1.2059184624251329, -0.40000000000000002, 0.50000000000000000,
1.3962634015954636 },
{ 1.3331797176377398, -0.40000000000000002, 0.50000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.40000000000000002, nu=0.50000000000000000.
template
void test056()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data056)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data056[i].k), Tp(data056[i].nu),
Tp(data056[i].phi));
const Tp f0 = data056[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.40000000000000002, nu=0.59999999999999998.
testcase_ellint_3 data057[] = {
{ -0.0000000000000000, -0.40000000000000002, 0.59999999999999998,
0.0000000000000000 },
{ 0.17362711992081248, -0.40000000000000002, 0.59999999999999998,
0.17453292519943295 },
{ 0.34217074276403953, -0.40000000000000002, 0.59999999999999998,
0.34906585039886590 },
{ 0.50205389185761617, -0.40000000000000002, 0.59999999999999998,
0.52359877559829882 },
{ 0.65182834920372745, -0.40000000000000002, 0.59999999999999998,
0.69813170079773179 },
{ 0.79186512820565136, -0.40000000000000002, 0.59999999999999998,
0.87266462599716477 },
{ 0.92365535916287134, -0.40000000000000002, 0.59999999999999998,
1.0471975511965976 },
{ 1.0491915663957907, -0.40000000000000002, 0.59999999999999998,
1.2217304763960306 },
{ 1.1705934291745104, -0.40000000000000002, 0.59999999999999998,
1.3962634015954636 },
{ 1.2899514672527024, -0.40000000000000002, 0.59999999999999998,
1.5707963267948966 },
};
// Test function for k=-0.40000000000000002, nu=0.59999999999999998.
template
void test057()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data057)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data057[i].k), Tp(data057[i].nu),
Tp(data057[i].phi));
const Tp f0 = data057[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.40000000000000002, nu=0.69999999999999996.
testcase_ellint_3 data058[] = {
{ -0.0000000000000000, -0.40000000000000002, 0.69999999999999996,
0.0000000000000000 },
{ 0.17345479265712871, -0.40000000000000002, 0.69999999999999996,
0.17453292519943295 },
{ 0.34089751955950354, -0.40000000000000002, 0.69999999999999996,
0.34906585039886590 },
{ 0.49824200167361343, -0.40000000000000002, 0.69999999999999996,
0.52359877559829882 },
{ 0.64402450341199413, -0.40000000000000002, 0.69999999999999996,
0.69813170079773179 },
{ 0.77889207804122873, -0.40000000000000002, 0.69999999999999996,
0.87266462599716477 },
{ 0.90468169720957992, -0.40000000000000002, 0.69999999999999996,
1.0471975511965976 },
{ 1.0236847823692916, -0.40000000000000002, 0.69999999999999996,
1.2217304763960306 },
{ 1.1382465247425164, -0.40000000000000002, 0.69999999999999996,
1.3962634015954636 },
{ 1.2506255923253344, -0.40000000000000002, 0.69999999999999996,
1.5707963267948966 },
};
// Test function for k=-0.40000000000000002, nu=0.69999999999999996.
template
void test058()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data058)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data058[i].k), Tp(data058[i].nu),
Tp(data058[i].phi));
const Tp f0 = data058[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.40000000000000002, nu=0.80000000000000004.
testcase_ellint_3 data059[] = {
{ -0.0000000000000000, -0.40000000000000002, 0.80000000000000004,
0.0000000000000000 },
{ 0.17328307694277156, -0.40000000000000002, 0.80000000000000004,
0.17453292519943295 },
{ 0.33964091800132007, -0.40000000000000002, 0.80000000000000004,
0.34906585039886590 },
{ 0.49452889372467451, -0.40000000000000002, 0.80000000000000004,
0.52359877559829882 },
{ 0.63652940095937327, -0.40000000000000002, 0.80000000000000004,
0.69813170079773179 },
{ 0.76659772511159097, -0.40000000000000002, 0.80000000000000004,
0.87266462599716477 },
{ 0.88691047977338111, -0.40000000000000002, 0.80000000000000004,
1.0471975511965976 },
{ 1.0000273200611638, -0.40000000000000002, 0.80000000000000004,
1.2217304763960306 },
{ 1.1084787902188007, -0.40000000000000002, 0.80000000000000004,
1.3962634015954636 },
{ 1.2146499565727209, -0.40000000000000002, 0.80000000000000004,
1.5707963267948966 },
};
// Test function for k=-0.40000000000000002, nu=0.80000000000000004.
template
void test059()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data059)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data059[i].k), Tp(data059[i].nu),
Tp(data059[i].phi));
const Tp f0 = data059[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.40000000000000002, nu=0.90000000000000002.
testcase_ellint_3 data060[] = {
{ -0.0000000000000000, -0.40000000000000002, 0.90000000000000002,
0.0000000000000000 },
{ 0.17311196891868130, -0.40000000000000002, 0.90000000000000002,
0.17453292519943295 },
{ 0.33840055664911906, -0.40000000000000002, 0.90000000000000002,
0.34906585039886590 },
{ 0.49091013944075340, -0.40000000000000002, 0.90000000000000002,
0.52359877559829882 },
{ 0.62932228186809591, -0.40000000000000002, 0.90000000000000002,
0.69813170079773179 },
{ 0.75492278323019801, -0.40000000000000002, 0.90000000000000002,
0.87266462599716477 },
{ 0.87021659043854294, -0.40000000000000002, 0.90000000000000002,
1.0471975511965976 },
{ 0.97800245228239246, -0.40000000000000002, 0.90000000000000002,
1.2217304763960306 },
{ 1.0809625773173694, -0.40000000000000002, 0.90000000000000002,
1.3962634015954636 },
{ 1.1815758115929846, -0.40000000000000002, 0.90000000000000002,
1.5707963267948966 },
};
// Test function for k=-0.40000000000000002, nu=0.90000000000000002.
template
void test060()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data060)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data060[i].k), Tp(data060[i].nu),
Tp(data060[i].phi));
const Tp f0 = data060[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.30000000000000004, nu=0.0000000000000000.
testcase_ellint_3 data061[] = {
{ -0.0000000000000000, -0.30000000000000004, 0.0000000000000000,
0.0000000000000000 },
{ 0.17461228653000102, -0.30000000000000004, 0.0000000000000000,
0.17453292519943295 },
{ 0.34969146102798415, -0.30000000000000004, 0.0000000000000000,
0.34906585039886590 },
{ 0.52565822873726320, -0.30000000000000004, 0.0000000000000000,
0.52359877559829882 },
{ 0.70284226512408532, -0.30000000000000004, 0.0000000000000000,
0.69813170079773179 },
{ 0.88144139195111182, -0.30000000000000004, 0.0000000000000000,
0.87266462599716477 },
{ 1.0614897067260523, -0.30000000000000004, 0.0000000000000000,
1.0471975511965976 },
{ 1.2428416824174218, -0.30000000000000004, 0.0000000000000000,
1.2217304763960306 },
{ 1.4251795877015925, -0.30000000000000004, 0.0000000000000000,
1.3962634015954636 },
{ 1.6080486199305126, -0.30000000000000004, 0.0000000000000000,
1.5707963267948966 },
};
// Test function for k=-0.30000000000000004, nu=0.0000000000000000.
template
void test061()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data061)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data061[i].k), Tp(data061[i].nu),
Tp(data061[i].phi));
const Tp f0 = data061[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.30000000000000004, nu=0.10000000000000001.
testcase_ellint_3 data062[] = {
{ -0.0000000000000000, -0.30000000000000004, 0.10000000000000001,
0.0000000000000000 },
{ 0.17443631884814378, -0.30000000000000004, 0.10000000000000001,
0.17453292519943295 },
{ 0.34831316835124926, -0.30000000000000004, 0.10000000000000001,
0.34906585039886590 },
{ 0.52116586276523857, -0.30000000000000004, 0.10000000000000001,
0.52359877559829882 },
{ 0.69269385837910036, -0.30000000000000004, 0.10000000000000001,
0.69813170079773179 },
{ 0.86279023163070856, -0.30000000000000004, 0.10000000000000001,
0.87266462599716477 },
{ 1.0315321461438265, -0.30000000000000004, 0.10000000000000001,
1.0471975511965976 },
{ 1.1991449111869024, -0.30000000000000004, 0.10000000000000001,
1.2217304763960306 },
{ 1.3659561780923211, -0.30000000000000004, 0.10000000000000001,
1.3962634015954636 },
{ 1.5323534693557526, -0.30000000000000004, 0.10000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.30000000000000004, nu=0.10000000000000001.
template
void test062()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data062)
/ sizeof(testcase_ellint_3);
for (unsigned int i = 0; i < num_datum; ++i)
{
const Tp f = std::tr1::ellint_3(Tp(data062[i].k), Tp(data062[i].nu),
Tp(data062[i].phi));
const Tp f0 = data062[i].f0;
const Tp diff = f - f0;
if (std::abs(diff) > max_abs_diff)
max_abs_diff = std::abs(diff);
if (std::abs(f0) > Tp(10) * eps
&& std::abs(f) > Tp(10) * eps)
{
const Tp frac = diff / f0;
if (std::abs(frac) > max_abs_frac)
max_abs_frac = std::abs(frac);
}
}
VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
}
// Test data for k=-0.30000000000000004, nu=0.20000000000000001.
testcase_ellint_3 data063[] = {
{ -0.0000000000000000, -0.30000000000000004, 0.20000000000000001,
0.0000000000000000 },
{ 0.17426098615372090, -0.30000000000000004, 0.20000000000000001,
0.17453292519943295 },
{ 0.34695402664689923, -0.30000000000000004, 0.20000000000000001,
0.34906585039886590 },
{ 0.51680555567038933, -0.30000000000000004, 0.20000000000000001,
0.52359877559829882 },
{ 0.68303375225260210, -0.30000000000000004, 0.20000000000000001,
0.69813170079773179 },
{ 0.84540662891295026, -0.30000000000000004, 0.20000000000000001,
0.87266462599716477 },
{ 1.0041834051646927, -0.30000000000000004, 0.20000000000000001,
1.0471975511965976 },
{ 1.1599952702345711, -0.30000000000000004, 0.20000000000000001,
1.2217304763960306 },
{ 1.3137179520499163, -0.30000000000000004, 0.20000000000000001,
1.3962634015954636 },
{ 1.4663658145259875, -0.30000000000000004, 0.20000000000000001,
1.5707963267948966 },
};
// Test function for k=-0.30000000000000004, nu=0.20000000000000001.
template
void test063()
{
const Tp eps = std::numeric_limits::epsilon();
Tp max_abs_diff = -Tp(1);
Tp max_abs_frac = -Tp(1);
unsigned int num_datum = sizeof(data063)
/ sizeof(testcase_ellint_3