]>
git.ipfire.org Git - thirdparty/gcc.git/blob - libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/06_comp_ellint_3/check_value.cc
1 // 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net>
3 // Copyright (C) 2007, 2009 Free Software Foundation, Inc.
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // You should have received a copy of the GNU General Public License along
17 // with this library; see the file COPYING3. If not see
18 // <http://www.gnu.org/licenses/>.
23 // Compare against values generated by the GNU Scientific Library.
24 // The GSL can be found on the web: http://www.gnu.org/software/gsl/
27 #if defined(__TEST_DEBUG)
32 std::cout << "line " << __LINE__ \
33 << " max_abs_frac = " << max_abs_frac \
37 #include <testsuite_hooks.h>
39 #include "../testcase.h"
42 // Test data for k=-0.90000000000000002.
43 testcase_comp_ellint_3
<double> data001
[] = {
44 { 2.2805491384227703, -0.90000000000000002, 0.0000000000000000 },
45 { 2.1537868513875287, -0.90000000000000002, 0.10000000000000001 },
46 { 2.0443194576468890, -0.90000000000000002, 0.20000000000000001 },
47 { 1.9486280260314426, -0.90000000000000002, 0.29999999999999999 },
48 { 1.8641114227238349, -0.90000000000000002, 0.40000000000000002 },
49 { 1.7888013241937861, -0.90000000000000002, 0.50000000000000000 },
50 { 1.7211781128919523, -0.90000000000000002, 0.59999999999999998 },
51 { 1.6600480747670938, -0.90000000000000002, 0.69999999999999996 },
52 { 1.6044591960982204, -0.90000000000000002, 0.80000000000000004 },
53 { 1.5536420236310946, -0.90000000000000002, 0.90000000000000002 },
56 // Test function for k=-0.90000000000000002.
57 template <typename Tp
>
60 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
61 Tp max_abs_diff
= -Tp(1);
62 Tp max_abs_frac
= -Tp(1);
63 unsigned int num_datum
= sizeof(data001
)
64 / sizeof(testcase_comp_ellint_3
<double>);
65 for (unsigned int i
= 0; i
< num_datum
; ++i
)
67 const Tp f
= std::tr1::comp_ellint_3(Tp(data001
[i
].k
), Tp(data001
[i
].nu
));
68 const Tp f0
= data001
[i
].f0
;
69 const Tp diff
= f
- f0
;
70 if (std::abs(diff
) > max_abs_diff
)
71 max_abs_diff
= std::abs(diff
);
72 if (std::abs(f0
) > Tp(10) * eps
73 && std::abs(f
) > Tp(10) * eps
)
75 const Tp frac
= diff
/ f0
;
76 if (std::abs(frac
) > max_abs_frac
)
77 max_abs_frac
= std::abs(frac
);
80 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
83 // Test data for k=-0.80000000000000004.
84 testcase_comp_ellint_3
<double> data002
[] = {
85 { 1.9953027776647296, -0.80000000000000004, 0.0000000000000000 },
86 { 1.8910755418379521, -0.80000000000000004, 0.10000000000000001 },
87 { 1.8007226661734588, -0.80000000000000004, 0.20000000000000001 },
88 { 1.7214611048717301, -0.80000000000000004, 0.29999999999999999 },
89 { 1.6512267838651289, -0.80000000000000004, 0.40000000000000002 },
90 { 1.5884528947755532, -0.80000000000000004, 0.50000000000000000 },
91 { 1.5319262547427865, -0.80000000000000004, 0.59999999999999998 },
92 { 1.4806912324625332, -0.80000000000000004, 0.69999999999999996 },
93 { 1.4339837018309474, -0.80000000000000004, 0.80000000000000004 },
94 { 1.3911845406776222, -0.80000000000000004, 0.90000000000000002 },
97 // Test function for k=-0.80000000000000004.
98 template <typename Tp
>
101 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
102 Tp max_abs_diff
= -Tp(1);
103 Tp max_abs_frac
= -Tp(1);
104 unsigned int num_datum
= sizeof(data002
)
105 / sizeof(testcase_comp_ellint_3
<double>);
106 for (unsigned int i
= 0; i
< num_datum
; ++i
)
108 const Tp f
= std::tr1::comp_ellint_3(Tp(data002
[i
].k
), Tp(data002
[i
].nu
));
109 const Tp f0
= data002
[i
].f0
;
110 const Tp diff
= f
- f0
;
111 if (std::abs(diff
) > max_abs_diff
)
112 max_abs_diff
= std::abs(diff
);
113 if (std::abs(f0
) > Tp(10) * eps
114 && std::abs(f
) > Tp(10) * eps
)
116 const Tp frac
= diff
/ f0
;
117 if (std::abs(frac
) > max_abs_frac
)
118 max_abs_frac
= std::abs(frac
);
121 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
124 // Test data for k=-0.69999999999999996.
125 testcase_comp_ellint_3
<double> data003
[] = {
126 { 1.8456939983747236, -0.69999999999999996, 0.0000000000000000 },
127 { 1.7528050171757608, -0.69999999999999996, 0.10000000000000001 },
128 { 1.6721098780092147, -0.69999999999999996, 0.20000000000000001 },
129 { 1.6011813647733213, -0.69999999999999996, 0.29999999999999999 },
130 { 1.5382162002954762, -0.69999999999999996, 0.40000000000000002 },
131 { 1.4818433192178544, -0.69999999999999996, 0.50000000000000000 },
132 { 1.4309994736080540, -0.69999999999999996, 0.59999999999999998 },
133 { 1.3848459188329196, -0.69999999999999996, 0.69999999999999996 },
134 { 1.3427110650397533, -0.69999999999999996, 0.80000000000000004 },
135 { 1.3040500499695911, -0.69999999999999996, 0.90000000000000002 },
138 // Test function for k=-0.69999999999999996.
139 template <typename Tp
>
142 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
143 Tp max_abs_diff
= -Tp(1);
144 Tp max_abs_frac
= -Tp(1);
145 unsigned int num_datum
= sizeof(data003
)
146 / sizeof(testcase_comp_ellint_3
<double>);
147 for (unsigned int i
= 0; i
< num_datum
; ++i
)
149 const Tp f
= std::tr1::comp_ellint_3(Tp(data003
[i
].k
), Tp(data003
[i
].nu
));
150 const Tp f0
= data003
[i
].f0
;
151 const Tp diff
= f
- f0
;
152 if (std::abs(diff
) > max_abs_diff
)
153 max_abs_diff
= std::abs(diff
);
154 if (std::abs(f0
) > Tp(10) * eps
155 && std::abs(f
) > Tp(10) * eps
)
157 const Tp frac
= diff
/ f0
;
158 if (std::abs(frac
) > max_abs_frac
)
159 max_abs_frac
= std::abs(frac
);
162 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
165 // Test data for k=-0.59999999999999998.
166 testcase_comp_ellint_3
<double> data004
[] = {
167 { 1.7507538029157526, -0.59999999999999998, 0.0000000000000000 },
168 { 1.6648615773343014, -0.59999999999999998, 0.10000000000000001 },
169 { 1.5901418016279374, -0.59999999999999998, 0.20000000000000001 },
170 { 1.5243814243493585, -0.59999999999999998, 0.29999999999999999 },
171 { 1.4659345278069984, -0.59999999999999998, 0.40000000000000002 },
172 { 1.4135484285693078, -0.59999999999999998, 0.50000000000000000 },
173 { 1.3662507535812816, -0.59999999999999998, 0.59999999999999998 },
174 { 1.3232737468822811, -0.59999999999999998, 0.69999999999999996 },
175 { 1.2840021261752192, -0.59999999999999998, 0.80000000000000004 },
176 { 1.2479362973851875, -0.59999999999999998, 0.90000000000000002 },
179 // Test function for k=-0.59999999999999998.
180 template <typename Tp
>
183 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
184 Tp max_abs_diff
= -Tp(1);
185 Tp max_abs_frac
= -Tp(1);
186 unsigned int num_datum
= sizeof(data004
)
187 / sizeof(testcase_comp_ellint_3
<double>);
188 for (unsigned int i
= 0; i
< num_datum
; ++i
)
190 const Tp f
= std::tr1::comp_ellint_3(Tp(data004
[i
].k
), Tp(data004
[i
].nu
));
191 const Tp f0
= data004
[i
].f0
;
192 const Tp diff
= f
- f0
;
193 if (std::abs(diff
) > max_abs_diff
)
194 max_abs_diff
= std::abs(diff
);
195 if (std::abs(f0
) > Tp(10) * eps
196 && std::abs(f
) > Tp(10) * eps
)
198 const Tp frac
= diff
/ f0
;
199 if (std::abs(frac
) > max_abs_frac
)
200 max_abs_frac
= std::abs(frac
);
203 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
206 // Test data for k=-0.50000000000000000.
207 testcase_comp_ellint_3
<double> data005
[] = {
208 { 1.6857503548125963, -0.50000000000000000, 0.0000000000000000 },
209 { 1.6045524936084892, -0.50000000000000000, 0.10000000000000001 },
210 { 1.5338490483665983, -0.50000000000000000, 0.20000000000000001 },
211 { 1.4715681939859637, -0.50000000000000000, 0.29999999999999999 },
212 { 1.4161679518465340, -0.50000000000000000, 0.40000000000000002 },
213 { 1.3664739530045971, -0.50000000000000000, 0.50000000000000000 },
214 { 1.3215740290190876, -0.50000000000000000, 0.59999999999999998 },
215 { 1.2807475181182502, -0.50000000000000000, 0.69999999999999996 },
216 { 1.2434165408189539, -0.50000000000000000, 0.80000000000000004 },
217 { 1.2091116095504744, -0.50000000000000000, 0.90000000000000002 },
220 // Test function for k=-0.50000000000000000.
221 template <typename Tp
>
224 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
225 Tp max_abs_diff
= -Tp(1);
226 Tp max_abs_frac
= -Tp(1);
227 unsigned int num_datum
= sizeof(data005
)
228 / sizeof(testcase_comp_ellint_3
<double>);
229 for (unsigned int i
= 0; i
< num_datum
; ++i
)
231 const Tp f
= std::tr1::comp_ellint_3(Tp(data005
[i
].k
), Tp(data005
[i
].nu
));
232 const Tp f0
= data005
[i
].f0
;
233 const Tp diff
= f
- f0
;
234 if (std::abs(diff
) > max_abs_diff
)
235 max_abs_diff
= std::abs(diff
);
236 if (std::abs(f0
) > Tp(10) * eps
237 && std::abs(f
) > Tp(10) * eps
)
239 const Tp frac
= diff
/ f0
;
240 if (std::abs(frac
) > max_abs_frac
)
241 max_abs_frac
= std::abs(frac
);
244 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
247 // Test data for k=-0.40000000000000002.
248 testcase_comp_ellint_3
<double> data006
[] = {
249 { 1.6399998658645112, -0.40000000000000002, 0.0000000000000000 },
250 { 1.5620566886683604, -0.40000000000000002, 0.10000000000000001 },
251 { 1.4941414344266770, -0.40000000000000002, 0.20000000000000001 },
252 { 1.4342789859950078, -0.40000000000000002, 0.29999999999999999 },
253 { 1.3809986210732901, -0.40000000000000002, 0.40000000000000002 },
254 { 1.3331797176377398, -0.40000000000000002, 0.50000000000000000 },
255 { 1.2899514672527024, -0.40000000000000002, 0.59999999999999998 },
256 { 1.2506255923253344, -0.40000000000000002, 0.69999999999999996 },
257 { 1.2146499565727209, -0.40000000000000002, 0.80000000000000004 },
258 { 1.1815758115929846, -0.40000000000000002, 0.90000000000000002 },
261 // Test function for k=-0.40000000000000002.
262 template <typename Tp
>
265 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
266 Tp max_abs_diff
= -Tp(1);
267 Tp max_abs_frac
= -Tp(1);
268 unsigned int num_datum
= sizeof(data006
)
269 / sizeof(testcase_comp_ellint_3
<double>);
270 for (unsigned int i
= 0; i
< num_datum
; ++i
)
272 const Tp f
= std::tr1::comp_ellint_3(Tp(data006
[i
].k
), Tp(data006
[i
].nu
));
273 const Tp f0
= data006
[i
].f0
;
274 const Tp diff
= f
- f0
;
275 if (std::abs(diff
) > max_abs_diff
)
276 max_abs_diff
= std::abs(diff
);
277 if (std::abs(f0
) > Tp(10) * eps
278 && std::abs(f
) > Tp(10) * eps
)
280 const Tp frac
= diff
/ f0
;
281 if (std::abs(frac
) > max_abs_frac
)
282 max_abs_frac
= std::abs(frac
);
285 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
288 // Test data for k=-0.30000000000000004.
289 testcase_comp_ellint_3
<double> data007
[] = {
290 { 1.6080486199305126, -0.30000000000000004, 0.0000000000000000 },
291 { 1.5323534693557526, -0.30000000000000004, 0.10000000000000001 },
292 { 1.4663658145259875, -0.30000000000000004, 0.20000000000000001 },
293 { 1.4081767433479089, -0.30000000000000004, 0.29999999999999999 },
294 { 1.3563643538969761, -0.30000000000000004, 0.40000000000000002 },
295 { 1.3098448759814960, -0.30000000000000004, 0.50000000000000000 },
296 { 1.2677758800420666, -0.30000000000000004, 0.59999999999999998 },
297 { 1.2294913236274980, -0.30000000000000004, 0.69999999999999996 },
298 { 1.1944567571590046, -0.30000000000000004, 0.80000000000000004 },
299 { 1.1622376896064912, -0.30000000000000004, 0.90000000000000002 },
302 // Test function for k=-0.30000000000000004.
303 template <typename Tp
>
306 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
307 Tp max_abs_diff
= -Tp(1);
308 Tp max_abs_frac
= -Tp(1);
309 unsigned int num_datum
= sizeof(data007
)
310 / sizeof(testcase_comp_ellint_3
<double>);
311 for (unsigned int i
= 0; i
< num_datum
; ++i
)
313 const Tp f
= std::tr1::comp_ellint_3(Tp(data007
[i
].k
), Tp(data007
[i
].nu
));
314 const Tp f0
= data007
[i
].f0
;
315 const Tp diff
= f
- f0
;
316 if (std::abs(diff
) > max_abs_diff
)
317 max_abs_diff
= std::abs(diff
);
318 if (std::abs(f0
) > Tp(10) * eps
319 && std::abs(f
) > Tp(10) * eps
)
321 const Tp frac
= diff
/ f0
;
322 if (std::abs(frac
) > max_abs_frac
)
323 max_abs_frac
= std::abs(frac
);
326 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
329 // Test data for k=-0.19999999999999996.
330 testcase_comp_ellint_3
<double> data008
[] = {
331 { 1.5868678474541664, -0.19999999999999996, 0.0000000000000000 },
332 { 1.5126513474261092, -0.19999999999999996, 0.10000000000000001 },
333 { 1.4479323932249568, -0.19999999999999996, 0.20000000000000001 },
334 { 1.3908453514752481, -0.19999999999999996, 0.29999999999999999 },
335 { 1.3400002519661010, -0.19999999999999996, 0.40000000000000002 },
336 { 1.2943374404397376, -0.19999999999999996, 0.50000000000000000 },
337 { 1.2530330675914561, -0.19999999999999996, 0.59999999999999998 },
338 { 1.2154356555075867, -0.19999999999999996, 0.69999999999999996 },
339 { 1.1810223448909913, -0.19999999999999996, 0.80000000000000004 },
340 { 1.1493679916141863, -0.19999999999999996, 0.90000000000000002 },
343 // Test function for k=-0.19999999999999996.
344 template <typename Tp
>
347 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
348 Tp max_abs_diff
= -Tp(1);
349 Tp max_abs_frac
= -Tp(1);
350 unsigned int num_datum
= sizeof(data008
)
351 / sizeof(testcase_comp_ellint_3
<double>);
352 for (unsigned int i
= 0; i
< num_datum
; ++i
)
354 const Tp f
= std::tr1::comp_ellint_3(Tp(data008
[i
].k
), Tp(data008
[i
].nu
));
355 const Tp f0
= data008
[i
].f0
;
356 const Tp diff
= f
- f0
;
357 if (std::abs(diff
) > max_abs_diff
)
358 max_abs_diff
= std::abs(diff
);
359 if (std::abs(f0
) > Tp(10) * eps
360 && std::abs(f
) > Tp(10) * eps
)
362 const Tp frac
= diff
/ f0
;
363 if (std::abs(frac
) > max_abs_frac
)
364 max_abs_frac
= std::abs(frac
);
367 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
370 // Test data for k=-0.099999999999999978.
371 testcase_comp_ellint_3
<double> data009
[] = {
372 { 1.5747455615173562, -0.099999999999999978, 0.0000000000000000 },
373 { 1.5013711111199950, -0.099999999999999978, 0.10000000000000001 },
374 { 1.4373749386463430, -0.099999999999999978, 0.20000000000000001 },
375 { 1.3809159606704959, -0.099999999999999978, 0.29999999999999999 },
376 { 1.3306223265207477, -0.099999999999999978, 0.40000000000000002 },
377 { 1.2854480708580160, -0.099999999999999978, 0.50000000000000000 },
378 { 1.2445798942989255, -0.099999999999999978, 0.59999999999999998 },
379 { 1.2073745911083187, -0.099999999999999978, 0.69999999999999996 },
380 { 1.1733158866987732, -0.099999999999999978, 0.80000000000000004 },
381 { 1.1419839485283374, -0.099999999999999978, 0.90000000000000002 },
384 // Test function for k=-0.099999999999999978.
385 template <typename Tp
>
388 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
389 Tp max_abs_diff
= -Tp(1);
390 Tp max_abs_frac
= -Tp(1);
391 unsigned int num_datum
= sizeof(data009
)
392 / sizeof(testcase_comp_ellint_3
<double>);
393 for (unsigned int i
= 0; i
< num_datum
; ++i
)
395 const Tp f
= std::tr1::comp_ellint_3(Tp(data009
[i
].k
), Tp(data009
[i
].nu
));
396 const Tp f0
= data009
[i
].f0
;
397 const Tp diff
= f
- f0
;
398 if (std::abs(diff
) > max_abs_diff
)
399 max_abs_diff
= std::abs(diff
);
400 if (std::abs(f0
) > Tp(10) * eps
401 && std::abs(f
) > Tp(10) * eps
)
403 const Tp frac
= diff
/ f0
;
404 if (std::abs(frac
) > max_abs_frac
)
405 max_abs_frac
= std::abs(frac
);
408 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
411 // Test data for k=0.0000000000000000.
412 testcase_comp_ellint_3
<double> data010
[] = {
413 { 1.5707963267948966, 0.0000000000000000, 0.0000000000000000 },
414 { 1.4976955329233277, 0.0000000000000000, 0.10000000000000001 },
415 { 1.4339343023863691, 0.0000000000000000, 0.20000000000000001 },
416 { 1.3776795151134889, 0.0000000000000000, 0.29999999999999999 },
417 { 1.3275651989026322, 0.0000000000000000, 0.40000000000000002 },
418 { 1.2825498301618641, 0.0000000000000000, 0.50000000000000000 },
419 { 1.2418235332245127, 0.0000000000000000, 0.59999999999999998 },
420 { 1.2047457872617382, 0.0000000000000000, 0.69999999999999996 },
421 { 1.1708024551734544, 0.0000000000000000, 0.80000000000000004 },
422 { 1.1395754288497419, 0.0000000000000000, 0.90000000000000002 },
425 // Test function for k=0.0000000000000000.
426 template <typename Tp
>
429 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
430 Tp max_abs_diff
= -Tp(1);
431 Tp max_abs_frac
= -Tp(1);
432 unsigned int num_datum
= sizeof(data010
)
433 / sizeof(testcase_comp_ellint_3
<double>);
434 for (unsigned int i
= 0; i
< num_datum
; ++i
)
436 const Tp f
= std::tr1::comp_ellint_3(Tp(data010
[i
].k
), Tp(data010
[i
].nu
));
437 const Tp f0
= data010
[i
].f0
;
438 const Tp diff
= f
- f0
;
439 if (std::abs(diff
) > max_abs_diff
)
440 max_abs_diff
= std::abs(diff
);
441 if (std::abs(f0
) > Tp(10) * eps
442 && std::abs(f
) > Tp(10) * eps
)
444 const Tp frac
= diff
/ f0
;
445 if (std::abs(frac
) > max_abs_frac
)
446 max_abs_frac
= std::abs(frac
);
449 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
452 // Test data for k=0.10000000000000009.
453 testcase_comp_ellint_3
<double> data011
[] = {
454 { 1.5747455615173562, 0.10000000000000009, 0.0000000000000000 },
455 { 1.5013711111199950, 0.10000000000000009, 0.10000000000000001 },
456 { 1.4373749386463430, 0.10000000000000009, 0.20000000000000001 },
457 { 1.3809159606704959, 0.10000000000000009, 0.29999999999999999 },
458 { 1.3306223265207477, 0.10000000000000009, 0.40000000000000002 },
459 { 1.2854480708580160, 0.10000000000000009, 0.50000000000000000 },
460 { 1.2445798942989255, 0.10000000000000009, 0.59999999999999998 },
461 { 1.2073745911083187, 0.10000000000000009, 0.69999999999999996 },
462 { 1.1733158866987732, 0.10000000000000009, 0.80000000000000004 },
463 { 1.1419839485283374, 0.10000000000000009, 0.90000000000000002 },
466 // Test function for k=0.10000000000000009.
467 template <typename Tp
>
470 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
471 Tp max_abs_diff
= -Tp(1);
472 Tp max_abs_frac
= -Tp(1);
473 unsigned int num_datum
= sizeof(data011
)
474 / sizeof(testcase_comp_ellint_3
<double>);
475 for (unsigned int i
= 0; i
< num_datum
; ++i
)
477 const Tp f
= std::tr1::comp_ellint_3(Tp(data011
[i
].k
), Tp(data011
[i
].nu
));
478 const Tp f0
= data011
[i
].f0
;
479 const Tp diff
= f
- f0
;
480 if (std::abs(diff
) > max_abs_diff
)
481 max_abs_diff
= std::abs(diff
);
482 if (std::abs(f0
) > Tp(10) * eps
483 && std::abs(f
) > Tp(10) * eps
)
485 const Tp frac
= diff
/ f0
;
486 if (std::abs(frac
) > max_abs_frac
)
487 max_abs_frac
= std::abs(frac
);
490 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
493 // Test data for k=0.19999999999999996.
494 testcase_comp_ellint_3
<double> data012
[] = {
495 { 1.5868678474541664, 0.19999999999999996, 0.0000000000000000 },
496 { 1.5126513474261092, 0.19999999999999996, 0.10000000000000001 },
497 { 1.4479323932249568, 0.19999999999999996, 0.20000000000000001 },
498 { 1.3908453514752481, 0.19999999999999996, 0.29999999999999999 },
499 { 1.3400002519661010, 0.19999999999999996, 0.40000000000000002 },
500 { 1.2943374404397376, 0.19999999999999996, 0.50000000000000000 },
501 { 1.2530330675914561, 0.19999999999999996, 0.59999999999999998 },
502 { 1.2154356555075867, 0.19999999999999996, 0.69999999999999996 },
503 { 1.1810223448909913, 0.19999999999999996, 0.80000000000000004 },
504 { 1.1493679916141863, 0.19999999999999996, 0.90000000000000002 },
507 // Test function for k=0.19999999999999996.
508 template <typename Tp
>
511 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
512 Tp max_abs_diff
= -Tp(1);
513 Tp max_abs_frac
= -Tp(1);
514 unsigned int num_datum
= sizeof(data012
)
515 / sizeof(testcase_comp_ellint_3
<double>);
516 for (unsigned int i
= 0; i
< num_datum
; ++i
)
518 const Tp f
= std::tr1::comp_ellint_3(Tp(data012
[i
].k
), Tp(data012
[i
].nu
));
519 const Tp f0
= data012
[i
].f0
;
520 const Tp diff
= f
- f0
;
521 if (std::abs(diff
) > max_abs_diff
)
522 max_abs_diff
= std::abs(diff
);
523 if (std::abs(f0
) > Tp(10) * eps
524 && std::abs(f
) > Tp(10) * eps
)
526 const Tp frac
= diff
/ f0
;
527 if (std::abs(frac
) > max_abs_frac
)
528 max_abs_frac
= std::abs(frac
);
531 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
534 // Test data for k=0.30000000000000004.
535 testcase_comp_ellint_3
<double> data013
[] = {
536 { 1.6080486199305126, 0.30000000000000004, 0.0000000000000000 },
537 { 1.5323534693557526, 0.30000000000000004, 0.10000000000000001 },
538 { 1.4663658145259875, 0.30000000000000004, 0.20000000000000001 },
539 { 1.4081767433479089, 0.30000000000000004, 0.29999999999999999 },
540 { 1.3563643538969761, 0.30000000000000004, 0.40000000000000002 },
541 { 1.3098448759814960, 0.30000000000000004, 0.50000000000000000 },
542 { 1.2677758800420666, 0.30000000000000004, 0.59999999999999998 },
543 { 1.2294913236274980, 0.30000000000000004, 0.69999999999999996 },
544 { 1.1944567571590046, 0.30000000000000004, 0.80000000000000004 },
545 { 1.1622376896064912, 0.30000000000000004, 0.90000000000000002 },
548 // Test function for k=0.30000000000000004.
549 template <typename Tp
>
552 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
553 Tp max_abs_diff
= -Tp(1);
554 Tp max_abs_frac
= -Tp(1);
555 unsigned int num_datum
= sizeof(data013
)
556 / sizeof(testcase_comp_ellint_3
<double>);
557 for (unsigned int i
= 0; i
< num_datum
; ++i
)
559 const Tp f
= std::tr1::comp_ellint_3(Tp(data013
[i
].k
), Tp(data013
[i
].nu
));
560 const Tp f0
= data013
[i
].f0
;
561 const Tp diff
= f
- f0
;
562 if (std::abs(diff
) > max_abs_diff
)
563 max_abs_diff
= std::abs(diff
);
564 if (std::abs(f0
) > Tp(10) * eps
565 && std::abs(f
) > Tp(10) * eps
)
567 const Tp frac
= diff
/ f0
;
568 if (std::abs(frac
) > max_abs_frac
)
569 max_abs_frac
= std::abs(frac
);
572 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
575 // Test data for k=0.39999999999999991.
576 testcase_comp_ellint_3
<double> data014
[] = {
577 { 1.6399998658645112, 0.39999999999999991, 0.0000000000000000 },
578 { 1.5620566886683604, 0.39999999999999991, 0.10000000000000001 },
579 { 1.4941414344266770, 0.39999999999999991, 0.20000000000000001 },
580 { 1.4342789859950078, 0.39999999999999991, 0.29999999999999999 },
581 { 1.3809986210732901, 0.39999999999999991, 0.40000000000000002 },
582 { 1.3331797176377398, 0.39999999999999991, 0.50000000000000000 },
583 { 1.2899514672527024, 0.39999999999999991, 0.59999999999999998 },
584 { 1.2506255923253344, 0.39999999999999991, 0.69999999999999996 },
585 { 1.2146499565727209, 0.39999999999999991, 0.80000000000000004 },
586 { 1.1815758115929846, 0.39999999999999991, 0.90000000000000002 },
589 // Test function for k=0.39999999999999991.
590 template <typename Tp
>
593 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
594 Tp max_abs_diff
= -Tp(1);
595 Tp max_abs_frac
= -Tp(1);
596 unsigned int num_datum
= sizeof(data014
)
597 / sizeof(testcase_comp_ellint_3
<double>);
598 for (unsigned int i
= 0; i
< num_datum
; ++i
)
600 const Tp f
= std::tr1::comp_ellint_3(Tp(data014
[i
].k
), Tp(data014
[i
].nu
));
601 const Tp f0
= data014
[i
].f0
;
602 const Tp diff
= f
- f0
;
603 if (std::abs(diff
) > max_abs_diff
)
604 max_abs_diff
= std::abs(diff
);
605 if (std::abs(f0
) > Tp(10) * eps
606 && std::abs(f
) > Tp(10) * eps
)
608 const Tp frac
= diff
/ f0
;
609 if (std::abs(frac
) > max_abs_frac
)
610 max_abs_frac
= std::abs(frac
);
613 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
616 // Test data for k=0.50000000000000000.
617 testcase_comp_ellint_3
<double> data015
[] = {
618 { 1.6857503548125963, 0.50000000000000000, 0.0000000000000000 },
619 { 1.6045524936084892, 0.50000000000000000, 0.10000000000000001 },
620 { 1.5338490483665983, 0.50000000000000000, 0.20000000000000001 },
621 { 1.4715681939859637, 0.50000000000000000, 0.29999999999999999 },
622 { 1.4161679518465340, 0.50000000000000000, 0.40000000000000002 },
623 { 1.3664739530045971, 0.50000000000000000, 0.50000000000000000 },
624 { 1.3215740290190876, 0.50000000000000000, 0.59999999999999998 },
625 { 1.2807475181182502, 0.50000000000000000, 0.69999999999999996 },
626 { 1.2434165408189539, 0.50000000000000000, 0.80000000000000004 },
627 { 1.2091116095504744, 0.50000000000000000, 0.90000000000000002 },
630 // Test function for k=0.50000000000000000.
631 template <typename Tp
>
634 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
635 Tp max_abs_diff
= -Tp(1);
636 Tp max_abs_frac
= -Tp(1);
637 unsigned int num_datum
= sizeof(data015
)
638 / sizeof(testcase_comp_ellint_3
<double>);
639 for (unsigned int i
= 0; i
< num_datum
; ++i
)
641 const Tp f
= std::tr1::comp_ellint_3(Tp(data015
[i
].k
), Tp(data015
[i
].nu
));
642 const Tp f0
= data015
[i
].f0
;
643 const Tp diff
= f
- f0
;
644 if (std::abs(diff
) > max_abs_diff
)
645 max_abs_diff
= std::abs(diff
);
646 if (std::abs(f0
) > Tp(10) * eps
647 && std::abs(f
) > Tp(10) * eps
)
649 const Tp frac
= diff
/ f0
;
650 if (std::abs(frac
) > max_abs_frac
)
651 max_abs_frac
= std::abs(frac
);
654 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
657 // Test data for k=0.60000000000000009.
658 testcase_comp_ellint_3
<double> data016
[] = {
659 { 1.7507538029157526, 0.60000000000000009, 0.0000000000000000 },
660 { 1.6648615773343014, 0.60000000000000009, 0.10000000000000001 },
661 { 1.5901418016279374, 0.60000000000000009, 0.20000000000000001 },
662 { 1.5243814243493585, 0.60000000000000009, 0.29999999999999999 },
663 { 1.4659345278069984, 0.60000000000000009, 0.40000000000000002 },
664 { 1.4135484285693078, 0.60000000000000009, 0.50000000000000000 },
665 { 1.3662507535812816, 0.60000000000000009, 0.59999999999999998 },
666 { 1.3232737468822811, 0.60000000000000009, 0.69999999999999996 },
667 { 1.2840021261752192, 0.60000000000000009, 0.80000000000000004 },
668 { 1.2479362973851875, 0.60000000000000009, 0.90000000000000002 },
671 // Test function for k=0.60000000000000009.
672 template <typename Tp
>
675 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
676 Tp max_abs_diff
= -Tp(1);
677 Tp max_abs_frac
= -Tp(1);
678 unsigned int num_datum
= sizeof(data016
)
679 / sizeof(testcase_comp_ellint_3
<double>);
680 for (unsigned int i
= 0; i
< num_datum
; ++i
)
682 const Tp f
= std::tr1::comp_ellint_3(Tp(data016
[i
].k
), Tp(data016
[i
].nu
));
683 const Tp f0
= data016
[i
].f0
;
684 const Tp diff
= f
- f0
;
685 if (std::abs(diff
) > max_abs_diff
)
686 max_abs_diff
= std::abs(diff
);
687 if (std::abs(f0
) > Tp(10) * eps
688 && std::abs(f
) > Tp(10) * eps
)
690 const Tp frac
= diff
/ f0
;
691 if (std::abs(frac
) > max_abs_frac
)
692 max_abs_frac
= std::abs(frac
);
695 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
698 // Test data for k=0.69999999999999996.
699 testcase_comp_ellint_3
<double> data017
[] = {
700 { 1.8456939983747236, 0.69999999999999996, 0.0000000000000000 },
701 { 1.7528050171757608, 0.69999999999999996, 0.10000000000000001 },
702 { 1.6721098780092147, 0.69999999999999996, 0.20000000000000001 },
703 { 1.6011813647733213, 0.69999999999999996, 0.29999999999999999 },
704 { 1.5382162002954762, 0.69999999999999996, 0.40000000000000002 },
705 { 1.4818433192178544, 0.69999999999999996, 0.50000000000000000 },
706 { 1.4309994736080540, 0.69999999999999996, 0.59999999999999998 },
707 { 1.3848459188329196, 0.69999999999999996, 0.69999999999999996 },
708 { 1.3427110650397533, 0.69999999999999996, 0.80000000000000004 },
709 { 1.3040500499695911, 0.69999999999999996, 0.90000000000000002 },
712 // Test function for k=0.69999999999999996.
713 template <typename Tp
>
716 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
717 Tp max_abs_diff
= -Tp(1);
718 Tp max_abs_frac
= -Tp(1);
719 unsigned int num_datum
= sizeof(data017
)
720 / sizeof(testcase_comp_ellint_3
<double>);
721 for (unsigned int i
= 0; i
< num_datum
; ++i
)
723 const Tp f
= std::tr1::comp_ellint_3(Tp(data017
[i
].k
), Tp(data017
[i
].nu
));
724 const Tp f0
= data017
[i
].f0
;
725 const Tp diff
= f
- f0
;
726 if (std::abs(diff
) > max_abs_diff
)
727 max_abs_diff
= std::abs(diff
);
728 if (std::abs(f0
) > Tp(10) * eps
729 && std::abs(f
) > Tp(10) * eps
)
731 const Tp frac
= diff
/ f0
;
732 if (std::abs(frac
) > max_abs_frac
)
733 max_abs_frac
= std::abs(frac
);
736 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
739 // Test data for k=0.80000000000000004.
740 testcase_comp_ellint_3
<double> data018
[] = {
741 { 1.9953027776647296, 0.80000000000000004, 0.0000000000000000 },
742 { 1.8910755418379521, 0.80000000000000004, 0.10000000000000001 },
743 { 1.8007226661734588, 0.80000000000000004, 0.20000000000000001 },
744 { 1.7214611048717301, 0.80000000000000004, 0.29999999999999999 },
745 { 1.6512267838651289, 0.80000000000000004, 0.40000000000000002 },
746 { 1.5884528947755532, 0.80000000000000004, 0.50000000000000000 },
747 { 1.5319262547427865, 0.80000000000000004, 0.59999999999999998 },
748 { 1.4806912324625332, 0.80000000000000004, 0.69999999999999996 },
749 { 1.4339837018309474, 0.80000000000000004, 0.80000000000000004 },
750 { 1.3911845406776222, 0.80000000000000004, 0.90000000000000002 },
753 // Test function for k=0.80000000000000004.
754 template <typename Tp
>
757 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
758 Tp max_abs_diff
= -Tp(1);
759 Tp max_abs_frac
= -Tp(1);
760 unsigned int num_datum
= sizeof(data018
)
761 / sizeof(testcase_comp_ellint_3
<double>);
762 for (unsigned int i
= 0; i
< num_datum
; ++i
)
764 const Tp f
= std::tr1::comp_ellint_3(Tp(data018
[i
].k
), Tp(data018
[i
].nu
));
765 const Tp f0
= data018
[i
].f0
;
766 const Tp diff
= f
- f0
;
767 if (std::abs(diff
) > max_abs_diff
)
768 max_abs_diff
= std::abs(diff
);
769 if (std::abs(f0
) > Tp(10) * eps
770 && std::abs(f
) > Tp(10) * eps
)
772 const Tp frac
= diff
/ f0
;
773 if (std::abs(frac
) > max_abs_frac
)
774 max_abs_frac
= std::abs(frac
);
777 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
780 // Test data for k=0.89999999999999991.
781 testcase_comp_ellint_3
<double> data019
[] = {
782 { 2.2805491384227699, 0.89999999999999991, 0.0000000000000000 },
783 { 2.1537868513875282, 0.89999999999999991, 0.10000000000000001 },
784 { 2.0443194576468890, 0.89999999999999991, 0.20000000000000001 },
785 { 1.9486280260314424, 0.89999999999999991, 0.29999999999999999 },
786 { 1.8641114227238347, 0.89999999999999991, 0.40000000000000002 },
787 { 1.7888013241937859, 0.89999999999999991, 0.50000000000000000 },
788 { 1.7211781128919521, 0.89999999999999991, 0.59999999999999998 },
789 { 1.6600480747670936, 0.89999999999999991, 0.69999999999999996 },
790 { 1.6044591960982200, 0.89999999999999991, 0.80000000000000004 },
791 { 1.5536420236310944, 0.89999999999999991, 0.90000000000000002 },
794 // Test function for k=0.89999999999999991.
795 template <typename Tp
>
798 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
799 Tp max_abs_diff
= -Tp(1);
800 Tp max_abs_frac
= -Tp(1);
801 unsigned int num_datum
= sizeof(data019
)
802 / sizeof(testcase_comp_ellint_3
<double>);
803 for (unsigned int i
= 0; i
< num_datum
; ++i
)
805 const Tp f
= std::tr1::comp_ellint_3(Tp(data019
[i
].k
), Tp(data019
[i
].nu
));
806 const Tp f0
= data019
[i
].f0
;
807 const Tp diff
= f
- f0
;
808 if (std::abs(diff
) > max_abs_diff
)
809 max_abs_diff
= std::abs(diff
);
810 if (std::abs(f0
) > Tp(10) * eps
811 && std::abs(f
) > Tp(10) * eps
)
813 const Tp frac
= diff
/ f0
;
814 if (std::abs(frac
) > max_abs_frac
)
815 max_abs_frac
= std::abs(frac
);
818 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
821 int main(int, char**)