]>
git.ipfire.org Git - thirdparty/gcc.git/blob - libstdc++-v3/testsuite/tr1/5_numerical_facilities/special_functions/07_conf_hyperg/check_value.cc
1 // 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net>
3 // Copyright (C) 2007-2016 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 a=0.0000000000000000, c=1.0000000000000000.
43 testcase_conf_hyperg
<double> data001
[] = {
44 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
45 -10.000000000000000 },
46 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
47 -9.0000000000000000 },
48 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
49 -8.0000000000000000 },
50 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
51 -7.0000000000000000 },
52 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
53 -6.0000000000000000 },
54 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
55 -5.0000000000000000 },
56 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
57 -4.0000000000000000 },
58 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
59 -3.0000000000000000 },
60 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
61 -2.0000000000000000 },
62 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
63 -1.0000000000000000 },
64 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
66 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
68 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
70 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
72 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
74 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
76 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
78 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
80 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
82 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
84 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
88 // Test function for a=0.0000000000000000, c=1.0000000000000000.
89 template <typename Tp
>
92 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
93 Tp max_abs_diff
= -Tp(1);
94 Tp max_abs_frac
= -Tp(1);
95 unsigned int num_datum
= sizeof(data001
)
96 / sizeof(testcase_conf_hyperg
<double>);
97 for (unsigned int i
= 0; i
< num_datum
; ++i
)
99 const Tp f
= std::tr1::conf_hyperg(Tp(data001
[i
].a
), Tp(data001
[i
].c
),
101 const Tp f0
= data001
[i
].f0
;
102 const Tp diff
= f
- f0
;
103 if (std::abs(diff
) > max_abs_diff
)
104 max_abs_diff
= std::abs(diff
);
105 if (std::abs(f0
) > Tp(10) * eps
106 && std::abs(f
) > Tp(10) * eps
)
108 const Tp frac
= diff
/ f0
;
109 if (std::abs(frac
) > max_abs_frac
)
110 max_abs_frac
= std::abs(frac
);
113 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
116 // Test data for a=0.0000000000000000, c=2.0000000000000000.
117 testcase_conf_hyperg
<double> data002
[] = {
118 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
119 -10.000000000000000 },
120 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
121 -9.0000000000000000 },
122 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
123 -8.0000000000000000 },
124 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
125 -7.0000000000000000 },
126 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
127 -6.0000000000000000 },
128 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
129 -5.0000000000000000 },
130 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
131 -4.0000000000000000 },
132 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
133 -3.0000000000000000 },
134 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
135 -2.0000000000000000 },
136 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
137 -1.0000000000000000 },
138 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
139 0.0000000000000000 },
140 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
141 1.0000000000000000 },
142 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
143 2.0000000000000000 },
144 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
145 3.0000000000000000 },
146 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
147 4.0000000000000000 },
148 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
149 5.0000000000000000 },
150 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
151 6.0000000000000000 },
152 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
153 7.0000000000000000 },
154 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
155 8.0000000000000000 },
156 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
157 9.0000000000000000 },
158 { 1.0000000000000000, 0.0000000000000000, 2.0000000000000000,
159 10.000000000000000 },
162 // Test function for a=0.0000000000000000, c=2.0000000000000000.
163 template <typename Tp
>
166 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
167 Tp max_abs_diff
= -Tp(1);
168 Tp max_abs_frac
= -Tp(1);
169 unsigned int num_datum
= sizeof(data002
)
170 / sizeof(testcase_conf_hyperg
<double>);
171 for (unsigned int i
= 0; i
< num_datum
; ++i
)
173 const Tp f
= std::tr1::conf_hyperg(Tp(data002
[i
].a
), Tp(data002
[i
].c
),
175 const Tp f0
= data002
[i
].f0
;
176 const Tp diff
= f
- f0
;
177 if (std::abs(diff
) > max_abs_diff
)
178 max_abs_diff
= std::abs(diff
);
179 if (std::abs(f0
) > Tp(10) * eps
180 && std::abs(f
) > Tp(10) * eps
)
182 const Tp frac
= diff
/ f0
;
183 if (std::abs(frac
) > max_abs_frac
)
184 max_abs_frac
= std::abs(frac
);
187 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
190 // Test data for a=0.0000000000000000, c=3.0000000000000000.
191 testcase_conf_hyperg
<double> data003
[] = {
192 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
193 -10.000000000000000 },
194 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
195 -9.0000000000000000 },
196 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
197 -8.0000000000000000 },
198 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
199 -7.0000000000000000 },
200 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
201 -6.0000000000000000 },
202 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
203 -5.0000000000000000 },
204 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
205 -4.0000000000000000 },
206 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
207 -3.0000000000000000 },
208 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
209 -2.0000000000000000 },
210 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
211 -1.0000000000000000 },
212 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
213 0.0000000000000000 },
214 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
215 1.0000000000000000 },
216 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
217 2.0000000000000000 },
218 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
219 3.0000000000000000 },
220 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
221 4.0000000000000000 },
222 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
223 5.0000000000000000 },
224 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
225 6.0000000000000000 },
226 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
227 7.0000000000000000 },
228 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
229 8.0000000000000000 },
230 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
231 9.0000000000000000 },
232 { 1.0000000000000000, 0.0000000000000000, 3.0000000000000000,
233 10.000000000000000 },
236 // Test function for a=0.0000000000000000, c=3.0000000000000000.
237 template <typename Tp
>
240 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
241 Tp max_abs_diff
= -Tp(1);
242 Tp max_abs_frac
= -Tp(1);
243 unsigned int num_datum
= sizeof(data003
)
244 / sizeof(testcase_conf_hyperg
<double>);
245 for (unsigned int i
= 0; i
< num_datum
; ++i
)
247 const Tp f
= std::tr1::conf_hyperg(Tp(data003
[i
].a
), Tp(data003
[i
].c
),
249 const Tp f0
= data003
[i
].f0
;
250 const Tp diff
= f
- f0
;
251 if (std::abs(diff
) > max_abs_diff
)
252 max_abs_diff
= std::abs(diff
);
253 if (std::abs(f0
) > Tp(10) * eps
254 && std::abs(f
) > Tp(10) * eps
)
256 const Tp frac
= diff
/ f0
;
257 if (std::abs(frac
) > max_abs_frac
)
258 max_abs_frac
= std::abs(frac
);
261 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
264 // Test data for a=0.0000000000000000, c=4.0000000000000000.
265 testcase_conf_hyperg
<double> data004
[] = {
266 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
267 -10.000000000000000 },
268 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
269 -9.0000000000000000 },
270 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
271 -8.0000000000000000 },
272 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
273 -7.0000000000000000 },
274 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
275 -6.0000000000000000 },
276 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
277 -5.0000000000000000 },
278 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
279 -4.0000000000000000 },
280 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
281 -3.0000000000000000 },
282 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
283 -2.0000000000000000 },
284 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
285 -1.0000000000000000 },
286 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
287 0.0000000000000000 },
288 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
289 1.0000000000000000 },
290 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
291 2.0000000000000000 },
292 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
293 3.0000000000000000 },
294 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
295 4.0000000000000000 },
296 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
297 5.0000000000000000 },
298 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
299 6.0000000000000000 },
300 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
301 7.0000000000000000 },
302 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
303 8.0000000000000000 },
304 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
305 9.0000000000000000 },
306 { 1.0000000000000000, 0.0000000000000000, 4.0000000000000000,
307 10.000000000000000 },
310 // Test function for a=0.0000000000000000, c=4.0000000000000000.
311 template <typename Tp
>
314 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
315 Tp max_abs_diff
= -Tp(1);
316 Tp max_abs_frac
= -Tp(1);
317 unsigned int num_datum
= sizeof(data004
)
318 / sizeof(testcase_conf_hyperg
<double>);
319 for (unsigned int i
= 0; i
< num_datum
; ++i
)
321 const Tp f
= std::tr1::conf_hyperg(Tp(data004
[i
].a
), Tp(data004
[i
].c
),
323 const Tp f0
= data004
[i
].f0
;
324 const Tp diff
= f
- f0
;
325 if (std::abs(diff
) > max_abs_diff
)
326 max_abs_diff
= std::abs(diff
);
327 if (std::abs(f0
) > Tp(10) * eps
328 && std::abs(f
) > Tp(10) * eps
)
330 const Tp frac
= diff
/ f0
;
331 if (std::abs(frac
) > max_abs_frac
)
332 max_abs_frac
= std::abs(frac
);
335 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
338 // Test data for a=0.0000000000000000, c=5.0000000000000000.
339 testcase_conf_hyperg
<double> data005
[] = {
340 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
341 -10.000000000000000 },
342 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
343 -9.0000000000000000 },
344 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
345 -8.0000000000000000 },
346 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
347 -7.0000000000000000 },
348 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
349 -6.0000000000000000 },
350 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
351 -5.0000000000000000 },
352 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
353 -4.0000000000000000 },
354 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
355 -3.0000000000000000 },
356 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
357 -2.0000000000000000 },
358 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
359 -1.0000000000000000 },
360 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
361 0.0000000000000000 },
362 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
363 1.0000000000000000 },
364 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
365 2.0000000000000000 },
366 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
367 3.0000000000000000 },
368 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
369 4.0000000000000000 },
370 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
371 5.0000000000000000 },
372 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
373 6.0000000000000000 },
374 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
375 7.0000000000000000 },
376 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
377 8.0000000000000000 },
378 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
379 9.0000000000000000 },
380 { 1.0000000000000000, 0.0000000000000000, 5.0000000000000000,
381 10.000000000000000 },
384 // Test function for a=0.0000000000000000, c=5.0000000000000000.
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(data005
)
392 / sizeof(testcase_conf_hyperg
<double>);
393 for (unsigned int i
= 0; i
< num_datum
; ++i
)
395 const Tp f
= std::tr1::conf_hyperg(Tp(data005
[i
].a
), Tp(data005
[i
].c
),
397 const Tp f0
= data005
[i
].f0
;
398 const Tp diff
= f
- f0
;
399 if (std::abs(diff
) > max_abs_diff
)
400 max_abs_diff
= std::abs(diff
);
401 if (std::abs(f0
) > Tp(10) * eps
402 && std::abs(f
) > Tp(10) * eps
)
404 const Tp frac
= diff
/ f0
;
405 if (std::abs(frac
) > max_abs_frac
)
406 max_abs_frac
= std::abs(frac
);
409 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
412 // Test data for a=0.0000000000000000, c=6.0000000000000000.
413 testcase_conf_hyperg
<double> data006
[] = {
414 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
415 -10.000000000000000 },
416 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
417 -9.0000000000000000 },
418 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
419 -8.0000000000000000 },
420 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
421 -7.0000000000000000 },
422 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
423 -6.0000000000000000 },
424 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
425 -5.0000000000000000 },
426 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
427 -4.0000000000000000 },
428 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
429 -3.0000000000000000 },
430 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
431 -2.0000000000000000 },
432 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
433 -1.0000000000000000 },
434 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
435 0.0000000000000000 },
436 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
437 1.0000000000000000 },
438 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
439 2.0000000000000000 },
440 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
441 3.0000000000000000 },
442 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
443 4.0000000000000000 },
444 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
445 5.0000000000000000 },
446 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
447 6.0000000000000000 },
448 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
449 7.0000000000000000 },
450 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
451 8.0000000000000000 },
452 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
453 9.0000000000000000 },
454 { 1.0000000000000000, 0.0000000000000000, 6.0000000000000000,
455 10.000000000000000 },
458 // Test function for a=0.0000000000000000, c=6.0000000000000000.
459 template <typename Tp
>
462 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
463 Tp max_abs_diff
= -Tp(1);
464 Tp max_abs_frac
= -Tp(1);
465 unsigned int num_datum
= sizeof(data006
)
466 / sizeof(testcase_conf_hyperg
<double>);
467 for (unsigned int i
= 0; i
< num_datum
; ++i
)
469 const Tp f
= std::tr1::conf_hyperg(Tp(data006
[i
].a
), Tp(data006
[i
].c
),
471 const Tp f0
= data006
[i
].f0
;
472 const Tp diff
= f
- f0
;
473 if (std::abs(diff
) > max_abs_diff
)
474 max_abs_diff
= std::abs(diff
);
475 if (std::abs(f0
) > Tp(10) * eps
476 && std::abs(f
) > Tp(10) * eps
)
478 const Tp frac
= diff
/ f0
;
479 if (std::abs(frac
) > max_abs_frac
)
480 max_abs_frac
= std::abs(frac
);
483 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
486 // Test data for a=0.0000000000000000, c=7.0000000000000000.
487 testcase_conf_hyperg
<double> data007
[] = {
488 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
489 -10.000000000000000 },
490 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
491 -9.0000000000000000 },
492 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
493 -8.0000000000000000 },
494 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
495 -7.0000000000000000 },
496 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
497 -6.0000000000000000 },
498 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
499 -5.0000000000000000 },
500 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
501 -4.0000000000000000 },
502 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
503 -3.0000000000000000 },
504 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
505 -2.0000000000000000 },
506 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
507 -1.0000000000000000 },
508 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
509 0.0000000000000000 },
510 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
511 1.0000000000000000 },
512 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
513 2.0000000000000000 },
514 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
515 3.0000000000000000 },
516 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
517 4.0000000000000000 },
518 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
519 5.0000000000000000 },
520 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
521 6.0000000000000000 },
522 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
523 7.0000000000000000 },
524 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
525 8.0000000000000000 },
526 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
527 9.0000000000000000 },
528 { 1.0000000000000000, 0.0000000000000000, 7.0000000000000000,
529 10.000000000000000 },
532 // Test function for a=0.0000000000000000, c=7.0000000000000000.
533 template <typename Tp
>
536 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
537 Tp max_abs_diff
= -Tp(1);
538 Tp max_abs_frac
= -Tp(1);
539 unsigned int num_datum
= sizeof(data007
)
540 / sizeof(testcase_conf_hyperg
<double>);
541 for (unsigned int i
= 0; i
< num_datum
; ++i
)
543 const Tp f
= std::tr1::conf_hyperg(Tp(data007
[i
].a
), Tp(data007
[i
].c
),
545 const Tp f0
= data007
[i
].f0
;
546 const Tp diff
= f
- f0
;
547 if (std::abs(diff
) > max_abs_diff
)
548 max_abs_diff
= std::abs(diff
);
549 if (std::abs(f0
) > Tp(10) * eps
550 && std::abs(f
) > Tp(10) * eps
)
552 const Tp frac
= diff
/ f0
;
553 if (std::abs(frac
) > max_abs_frac
)
554 max_abs_frac
= std::abs(frac
);
557 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
560 // Test data for a=0.0000000000000000, c=8.0000000000000000.
561 testcase_conf_hyperg
<double> data008
[] = {
562 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
563 -10.000000000000000 },
564 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
565 -9.0000000000000000 },
566 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
567 -8.0000000000000000 },
568 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
569 -7.0000000000000000 },
570 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
571 -6.0000000000000000 },
572 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
573 -5.0000000000000000 },
574 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
575 -4.0000000000000000 },
576 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
577 -3.0000000000000000 },
578 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
579 -2.0000000000000000 },
580 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
581 -1.0000000000000000 },
582 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
583 0.0000000000000000 },
584 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
585 1.0000000000000000 },
586 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
587 2.0000000000000000 },
588 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
589 3.0000000000000000 },
590 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
591 4.0000000000000000 },
592 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
593 5.0000000000000000 },
594 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
595 6.0000000000000000 },
596 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
597 7.0000000000000000 },
598 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
599 8.0000000000000000 },
600 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
601 9.0000000000000000 },
602 { 1.0000000000000000, 0.0000000000000000, 8.0000000000000000,
603 10.000000000000000 },
606 // Test function for a=0.0000000000000000, c=8.0000000000000000.
607 template <typename Tp
>
610 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
611 Tp max_abs_diff
= -Tp(1);
612 Tp max_abs_frac
= -Tp(1);
613 unsigned int num_datum
= sizeof(data008
)
614 / sizeof(testcase_conf_hyperg
<double>);
615 for (unsigned int i
= 0; i
< num_datum
; ++i
)
617 const Tp f
= std::tr1::conf_hyperg(Tp(data008
[i
].a
), Tp(data008
[i
].c
),
619 const Tp f0
= data008
[i
].f0
;
620 const Tp diff
= f
- f0
;
621 if (std::abs(diff
) > max_abs_diff
)
622 max_abs_diff
= std::abs(diff
);
623 if (std::abs(f0
) > Tp(10) * eps
624 && std::abs(f
) > Tp(10) * eps
)
626 const Tp frac
= diff
/ f0
;
627 if (std::abs(frac
) > max_abs_frac
)
628 max_abs_frac
= std::abs(frac
);
631 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
634 // Test data for a=0.0000000000000000, c=9.0000000000000000.
635 testcase_conf_hyperg
<double> data009
[] = {
636 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
637 -10.000000000000000 },
638 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
639 -9.0000000000000000 },
640 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
641 -8.0000000000000000 },
642 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
643 -7.0000000000000000 },
644 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
645 -6.0000000000000000 },
646 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
647 -5.0000000000000000 },
648 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
649 -4.0000000000000000 },
650 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
651 -3.0000000000000000 },
652 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
653 -2.0000000000000000 },
654 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
655 -1.0000000000000000 },
656 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
657 0.0000000000000000 },
658 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
659 1.0000000000000000 },
660 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
661 2.0000000000000000 },
662 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
663 3.0000000000000000 },
664 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
665 4.0000000000000000 },
666 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
667 5.0000000000000000 },
668 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
669 6.0000000000000000 },
670 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
671 7.0000000000000000 },
672 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
673 8.0000000000000000 },
674 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
675 9.0000000000000000 },
676 { 1.0000000000000000, 0.0000000000000000, 9.0000000000000000,
677 10.000000000000000 },
680 // Test function for a=0.0000000000000000, c=9.0000000000000000.
681 template <typename Tp
>
684 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
685 Tp max_abs_diff
= -Tp(1);
686 Tp max_abs_frac
= -Tp(1);
687 unsigned int num_datum
= sizeof(data009
)
688 / sizeof(testcase_conf_hyperg
<double>);
689 for (unsigned int i
= 0; i
< num_datum
; ++i
)
691 const Tp f
= std::tr1::conf_hyperg(Tp(data009
[i
].a
), Tp(data009
[i
].c
),
693 const Tp f0
= data009
[i
].f0
;
694 const Tp diff
= f
- f0
;
695 if (std::abs(diff
) > max_abs_diff
)
696 max_abs_diff
= std::abs(diff
);
697 if (std::abs(f0
) > Tp(10) * eps
698 && std::abs(f
) > Tp(10) * eps
)
700 const Tp frac
= diff
/ f0
;
701 if (std::abs(frac
) > max_abs_frac
)
702 max_abs_frac
= std::abs(frac
);
705 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
708 // Test data for a=0.0000000000000000, c=10.000000000000000.
709 testcase_conf_hyperg
<double> data010
[] = {
710 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
711 -10.000000000000000 },
712 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
713 -9.0000000000000000 },
714 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
715 -8.0000000000000000 },
716 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
717 -7.0000000000000000 },
718 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
719 -6.0000000000000000 },
720 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
721 -5.0000000000000000 },
722 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
723 -4.0000000000000000 },
724 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
725 -3.0000000000000000 },
726 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
727 -2.0000000000000000 },
728 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
729 -1.0000000000000000 },
730 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
731 0.0000000000000000 },
732 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
733 1.0000000000000000 },
734 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
735 2.0000000000000000 },
736 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
737 3.0000000000000000 },
738 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
739 4.0000000000000000 },
740 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
741 5.0000000000000000 },
742 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
743 6.0000000000000000 },
744 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
745 7.0000000000000000 },
746 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
747 8.0000000000000000 },
748 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
749 9.0000000000000000 },
750 { 1.0000000000000000, 0.0000000000000000, 10.000000000000000,
751 10.000000000000000 },
754 // Test function for a=0.0000000000000000, c=10.000000000000000.
755 template <typename Tp
>
758 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
759 Tp max_abs_diff
= -Tp(1);
760 Tp max_abs_frac
= -Tp(1);
761 unsigned int num_datum
= sizeof(data010
)
762 / sizeof(testcase_conf_hyperg
<double>);
763 for (unsigned int i
= 0; i
< num_datum
; ++i
)
765 const Tp f
= std::tr1::conf_hyperg(Tp(data010
[i
].a
), Tp(data010
[i
].c
),
767 const Tp f0
= data010
[i
].f0
;
768 const Tp diff
= f
- f0
;
769 if (std::abs(diff
) > max_abs_diff
)
770 max_abs_diff
= std::abs(diff
);
771 if (std::abs(f0
) > Tp(10) * eps
772 && std::abs(f
) > Tp(10) * eps
)
774 const Tp frac
= diff
/ f0
;
775 if (std::abs(frac
) > max_abs_frac
)
776 max_abs_frac
= std::abs(frac
);
779 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
782 // Test data for a=0.50000000000000000, c=1.0000000000000000.
783 testcase_conf_hyperg
<double> data011
[] = {
784 { 0.18354081260932853, 0.50000000000000000, 1.0000000000000000,
785 -10.000000000000000 },
786 { 0.19419827762834704, 0.50000000000000000, 1.0000000000000000,
787 -9.0000000000000000 },
788 { 0.20700192122398287, 0.50000000000000000, 1.0000000000000000,
789 -8.0000000000000000 },
790 { 0.22280243801078498, 0.50000000000000000, 1.0000000000000000,
791 -7.0000000000000000 },
792 { 0.24300035416182644, 0.50000000000000000, 1.0000000000000000,
793 -6.0000000000000000 },
794 { 0.27004644161220326, 0.50000000000000000, 1.0000000000000000,
795 -5.0000000000000000 },
796 { 0.30850832255367100, 0.50000000000000000, 1.0000000000000000,
797 -4.0000000000000000 },
798 { 0.36743360905415834, 0.50000000000000000, 1.0000000000000000,
799 -3.0000000000000000 },
800 { 0.46575960759364043, 0.50000000000000000, 1.0000000000000000,
801 -2.0000000000000000 },
802 { 0.64503527044915010, 0.50000000000000000, 1.0000000000000000,
803 -1.0000000000000000 },
804 { 1.0000000000000000, 0.50000000000000000, 1.0000000000000000,
805 0.0000000000000000 },
806 { 1.7533876543770910, 0.50000000000000000, 1.0000000000000000,
807 1.0000000000000000 },
808 { 3.4415238691253336, 0.50000000000000000, 1.0000000000000000,
809 2.0000000000000000 },
810 { 7.3801013214774045, 0.50000000000000000, 1.0000000000000000,
811 3.0000000000000000 },
812 { 16.843983681258987, 0.50000000000000000, 1.0000000000000000,
813 4.0000000000000000 },
814 { 40.078445504076413, 0.50000000000000000, 1.0000000000000000,
815 5.0000000000000000 },
816 { 98.033339697812551, 0.50000000000000000, 1.0000000000000000,
817 6.0000000000000000 },
818 { 244.33254130132133, 0.50000000000000000, 1.0000000000000000,
819 7.0000000000000000 },
820 { 617.06403040562418, 0.50000000000000000, 1.0000000000000000,
821 8.0000000000000000 },
822 { 1573.6049422133683, 0.50000000000000000, 1.0000000000000000,
823 9.0000000000000000 },
824 { 4042.7554308904046, 0.50000000000000000, 1.0000000000000000,
825 10.000000000000000 },
828 // Test function for a=0.50000000000000000, c=1.0000000000000000.
829 template <typename Tp
>
832 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
833 Tp max_abs_diff
= -Tp(1);
834 Tp max_abs_frac
= -Tp(1);
835 unsigned int num_datum
= sizeof(data011
)
836 / sizeof(testcase_conf_hyperg
<double>);
837 for (unsigned int i
= 0; i
< num_datum
; ++i
)
839 const Tp f
= std::tr1::conf_hyperg(Tp(data011
[i
].a
), Tp(data011
[i
].c
),
841 const Tp f0
= data011
[i
].f0
;
842 const Tp diff
= f
- f0
;
843 if (std::abs(diff
) > max_abs_diff
)
844 max_abs_diff
= std::abs(diff
);
845 if (std::abs(f0
) > Tp(10) * eps
846 && std::abs(f
) > Tp(10) * eps
)
848 const Tp frac
= diff
/ f0
;
849 if (std::abs(frac
) > max_abs_frac
)
850 max_abs_frac
= std::abs(frac
);
853 VERIFY(max_abs_frac
< Tp(1.0000000000000006e-11));
856 // Test data for a=0.50000000000000000, c=2.0000000000000000.
857 testcase_conf_hyperg
<double> data012
[] = {
858 { 0.34751307955387079, 0.50000000000000000, 2.0000000000000000,
859 -10.000000000000000 },
860 { 0.36515709992587503, 0.50000000000000000, 2.0000000000000000,
861 -9.0000000000000000 },
862 { 0.38575276072642301, 0.50000000000000000, 2.0000000000000000,
863 -8.0000000000000000 },
864 { 0.41020241461382889, 0.50000000000000000, 2.0000000000000000,
865 -7.0000000000000000 },
866 { 0.43982706745912625, 0.50000000000000000, 2.0000000000000000,
867 -6.0000000000000000 },
868 { 0.47663109114346930, 0.50000000000000000, 2.0000000000000000,
869 -5.0000000000000000 },
870 { 0.52377761180260862, 0.50000000000000000, 2.0000000000000000,
871 -4.0000000000000000 },
872 { 0.58647299647508400, 0.50000000000000000, 2.0000000000000000,
873 -3.0000000000000000 },
874 { 0.67367002294334866, 0.50000000000000000, 2.0000000000000000,
875 -2.0000000000000000 },
876 { 0.80145607363402172, 0.50000000000000000, 2.0000000000000000,
877 -1.0000000000000000 },
878 { 1.0000000000000000, 0.50000000000000000, 2.0000000000000000,
879 0.0000000000000000 },
880 { 1.3281918274866849, 0.50000000000000000, 2.0000000000000000,
881 1.0000000000000000 },
882 { 1.9052621465543667, 0.50000000000000000, 2.0000000000000000,
883 2.0000000000000000 },
884 { 2.9805776178019903, 0.50000000000000000, 2.0000000000000000,
885 3.0000000000000000 },
886 { 5.0906787293171654, 0.50000000000000000, 2.0000000000000000,
887 4.0000000000000000 },
888 { 9.4185650450425964, 0.50000000000000000, 2.0000000000000000,
889 5.0000000000000000 },
890 { 18.627776225141986, 0.50000000000000000, 2.0000000000000000,
891 6.0000000000000000 },
892 { 38.823513069699615, 0.50000000000000000, 2.0000000000000000,
893 7.0000000000000000 },
894 { 84.215287700426927, 0.50000000000000000, 2.0000000000000000,
895 8.0000000000000000 },
896 { 188.31125697734240, 0.50000000000000000, 2.0000000000000000,
897 9.0000000000000000 },
898 { 431.02590173952245, 0.50000000000000000, 2.0000000000000000,
899 10.000000000000000 },
902 // Test function for a=0.50000000000000000, c=2.0000000000000000.
903 template <typename Tp
>
906 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
907 Tp max_abs_diff
= -Tp(1);
908 Tp max_abs_frac
= -Tp(1);
909 unsigned int num_datum
= sizeof(data012
)
910 / sizeof(testcase_conf_hyperg
<double>);
911 for (unsigned int i
= 0; i
< num_datum
; ++i
)
913 const Tp f
= std::tr1::conf_hyperg(Tp(data012
[i
].a
), Tp(data012
[i
].c
),
915 const Tp f0
= data012
[i
].f0
;
916 const Tp diff
= f
- f0
;
917 if (std::abs(diff
) > max_abs_diff
)
918 max_abs_diff
= std::abs(diff
);
919 if (std::abs(f0
) > Tp(10) * eps
920 && std::abs(f
) > Tp(10) * eps
)
922 const Tp frac
= diff
/ f0
;
923 if (std::abs(frac
) > max_abs_frac
)
924 max_abs_frac
= std::abs(frac
);
927 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
930 // Test data for a=0.50000000000000000, c=3.0000000000000000.
931 testcase_conf_hyperg
<double> data013
[] = {
932 { 0.44148780381255515, 0.50000000000000000, 3.0000000000000000,
933 -10.000000000000000 },
934 { 0.46154890030153722, 0.50000000000000000, 3.0000000000000000,
935 -9.0000000000000000 },
936 { 0.48454520771815751, 0.50000000000000000, 3.0000000000000000,
937 -8.0000000000000000 },
938 { 0.51124131917976301, 0.50000000000000000, 3.0000000000000000,
939 -7.0000000000000000 },
940 { 0.54269682032387934, 0.50000000000000000, 3.0000000000000000,
941 -6.0000000000000000 },
942 { 0.58041888164962119, 0.50000000000000000, 3.0000000000000000,
943 -5.0000000000000000 },
944 { 0.62661371932049892, 0.50000000000000000, 3.0000000000000000,
945 -4.0000000000000000 },
946 { 0.68461315644636744, 0.50000000000000000, 3.0000000000000000,
947 -3.0000000000000000 },
948 { 0.75961975369132639, 0.50000000000000000, 3.0000000000000000,
949 -2.0000000000000000 },
950 { 0.86004702726553350, 0.50000000000000000, 3.0000000000000000,
951 -1.0000000000000000 },
952 { 1.0000000000000000, 0.50000000000000000, 3.0000000000000000,
953 0.0000000000000000 },
954 { 1.2039946674617061, 0.50000000000000000, 3.0000000000000000,
955 1.0000000000000000 },
956 { 1.5161750470251780, 0.50000000000000000, 3.0000000000000000,
957 2.0000000000000000 },
958 { 2.0187596221024697, 0.50000000000000000, 3.0000000000000000,
959 3.0000000000000000 },
960 { 2.8698033217756134, 0.50000000000000000, 3.0000000000000000,
961 4.0000000000000000 },
962 { 4.3821186043144440, 0.50000000000000000, 3.0000000000000000,
963 5.0000000000000000 },
964 { 7.1913541951514128, 0.50000000000000000, 3.0000000000000000,
965 6.0000000000000000 },
966 { 12.620107286909638, 0.50000000000000000, 3.0000000000000000,
967 7.0000000000000000 },
968 { 23.478926483036350, 0.50000000000000000, 3.0000000000000000,
969 8.0000000000000000 },
970 { 45.852981860749004, 0.50000000000000000, 3.0000000000000000,
971 9.0000000000000000 },
972 { 93.137265099245667, 0.50000000000000000, 3.0000000000000000,
973 10.000000000000000 },
976 // Test function for a=0.50000000000000000, c=3.0000000000000000.
977 template <typename Tp
>
980 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
981 Tp max_abs_diff
= -Tp(1);
982 Tp max_abs_frac
= -Tp(1);
983 unsigned int num_datum
= sizeof(data013
)
984 / sizeof(testcase_conf_hyperg
<double>);
985 for (unsigned int i
= 0; i
< num_datum
; ++i
)
987 const Tp f
= std::tr1::conf_hyperg(Tp(data013
[i
].a
), Tp(data013
[i
].c
),
989 const Tp f0
= data013
[i
].f0
;
990 const Tp diff
= f
- f0
;
991 if (std::abs(diff
) > max_abs_diff
)
992 max_abs_diff
= std::abs(diff
);
993 if (std::abs(f0
) > Tp(10) * eps
994 && std::abs(f
) > Tp(10) * eps
)
996 const Tp frac
= diff
/ f0
;
997 if (std::abs(frac
) > max_abs_frac
)
998 max_abs_frac
= std::abs(frac
);
1001 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1004 // Test data for a=0.50000000000000000, c=4.0000000000000000.
1005 testcase_conf_hyperg
<double> data014
[] = {
1006 { 0.50723143075298227, 0.50000000000000000, 4.0000000000000000,
1007 -10.000000000000000 },
1008 { 0.52815420026166782, 0.50000000000000000, 4.0000000000000000,
1009 -9.0000000000000000 },
1010 { 0.55181651516426766, 0.50000000000000000, 4.0000000000000000,
1011 -8.0000000000000000 },
1012 { 0.57884767287882366, 0.50000000000000000, 4.0000000000000000,
1013 -7.0000000000000000 },
1014 { 0.61008828324275399, 0.50000000000000000, 4.0000000000000000,
1015 -6.0000000000000000 },
1016 { 0.64668451853659259, 0.50000000000000000, 4.0000000000000000,
1017 -5.0000000000000000 },
1018 { 0.69023479867386495, 0.50000000000000000, 4.0000000000000000,
1019 -4.0000000000000000 },
1020 { 0.74302365975861406, 0.50000000000000000, 4.0000000000000000,
1021 -3.0000000000000000 },
1022 { 0.80840402753201868, 0.50000000000000000, 4.0000000000000000,
1023 -2.0000000000000000 },
1024 { 0.89143814400301236, 0.50000000000000000, 4.0000000000000000,
1025 -1.0000000000000000 },
1026 { 1.0000000000000000, 0.50000000000000000, 4.0000000000000000,
1027 0.0000000000000000 },
1028 { 1.1467204168940972, 0.50000000000000000, 4.0000000000000000,
1029 1.0000000000000000 },
1030 { 1.3525055369951857, 0.50000000000000000, 4.0000000000000000,
1031 2.0000000000000000 },
1032 { 1.6530571499633475, 0.50000000000000000, 4.0000000000000000,
1033 3.0000000000000000 },
1034 { 2.1112387416058045, 0.50000000000000000, 4.0000000000000000,
1035 4.0000000000000000 },
1036 { 2.8410480336278194, 0.50000000000000000, 4.0000000000000000,
1037 5.0000000000000000 },
1038 { 4.0550562221854669, 0.50000000000000000, 4.0000000000000000,
1039 6.0000000000000000 },
1040 { 6.1601039044778592, 0.50000000000000000, 4.0000000000000000,
1041 7.0000000000000000 },
1042 { 9.9538034144264458, 0.50000000000000000, 4.0000000000000000,
1043 8.0000000000000000 },
1044 { 17.034704868473899, 0.50000000000000000, 4.0000000000000000,
1045 9.0000000000000000 },
1046 { 30.671445325428369, 0.50000000000000000, 4.0000000000000000,
1047 10.000000000000000 },
1050 // Test function for a=0.50000000000000000, c=4.0000000000000000.
1051 template <typename Tp
>
1054 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1055 Tp max_abs_diff
= -Tp(1);
1056 Tp max_abs_frac
= -Tp(1);
1057 unsigned int num_datum
= sizeof(data014
)
1058 / sizeof(testcase_conf_hyperg
<double>);
1059 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1061 const Tp f
= std::tr1::conf_hyperg(Tp(data014
[i
].a
), Tp(data014
[i
].c
),
1063 const Tp f0
= data014
[i
].f0
;
1064 const Tp diff
= f
- f0
;
1065 if (std::abs(diff
) > max_abs_diff
)
1066 max_abs_diff
= std::abs(diff
);
1067 if (std::abs(f0
) > Tp(10) * eps
1068 && std::abs(f
) > Tp(10) * eps
)
1070 const Tp frac
= diff
/ f0
;
1071 if (std::abs(frac
) > max_abs_frac
)
1072 max_abs_frac
= std::abs(frac
);
1075 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1078 // Test data for a=0.50000000000000000, c=5.0000000000000000.
1079 testcase_conf_hyperg
<double> data015
[] = {
1080 { 0.55715239162383312, 0.50000000000000000, 5.0000000000000000,
1081 -10.000000000000000 },
1082 { 0.57823135269518977, 0.50000000000000000, 5.0000000000000000,
1083 -9.0000000000000000 },
1084 { 0.60181688556797253, 0.50000000000000000, 5.0000000000000000,
1085 -8.0000000000000000 },
1086 { 0.62842688147829928, 0.50000000000000000, 5.0000000000000000,
1087 -7.0000000000000000 },
1088 { 0.65873434489521876, 0.50000000000000000, 5.0000000000000000,
1089 -6.0000000000000000 },
1090 { 0.69362872731932568, 0.50000000000000000, 5.0000000000000000,
1091 -5.0000000000000000 },
1092 { 0.73430741618153195, 0.50000000000000000, 5.0000000000000000,
1093 -4.0000000000000000 },
1094 { 0.78241503593870543, 0.50000000000000000, 5.0000000000000000,
1095 -3.0000000000000000 },
1096 { 0.84026013345254857, 0.50000000000000000, 5.0000000000000000,
1097 -2.0000000000000000 },
1098 { 0.91115976433208690, 0.50000000000000000, 5.0000000000000000,
1099 -1.0000000000000000 },
1100 { 1.0000000000000000, 0.50000000000000000, 5.0000000000000000,
1101 0.0000000000000000 },
1102 { 1.1141687602185972, 0.50000000000000000, 5.0000000000000000,
1103 1.0000000000000000 },
1104 { 1.2651443108002267, 0.50000000000000000, 5.0000000000000000,
1105 2.0000000000000000 },
1106 { 1.4712624889419719, 0.50000000000000000, 5.0000000000000000,
1107 3.0000000000000000 },
1108 { 1.7626460645467978, 0.50000000000000000, 5.0000000000000000,
1109 4.0000000000000000 },
1110 { 2.1901779328181084, 0.50000000000000000, 5.0000000000000000,
1111 5.0000000000000000 },
1112 { 2.8421796979457072, 0.50000000000000000, 5.0000000000000000,
1113 6.0000000000000000 },
1114 { 3.8760354586203549, 0.50000000000000000, 5.0000000000000000,
1115 7.0000000000000000 },
1116 { 5.5792940156545505, 0.50000000000000000, 5.0000000000000000,
1117 8.0000000000000000 },
1118 { 8.4898429002463196, 0.50000000000000000, 5.0000000000000000,
1119 9.0000000000000000 },
1120 { 13.636227878037923, 0.50000000000000000, 5.0000000000000000,
1121 10.000000000000000 },
1124 // Test function for a=0.50000000000000000, c=5.0000000000000000.
1125 template <typename Tp
>
1128 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1129 Tp max_abs_diff
= -Tp(1);
1130 Tp max_abs_frac
= -Tp(1);
1131 unsigned int num_datum
= sizeof(data015
)
1132 / sizeof(testcase_conf_hyperg
<double>);
1133 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1135 const Tp f
= std::tr1::conf_hyperg(Tp(data015
[i
].a
), Tp(data015
[i
].c
),
1137 const Tp f0
= data015
[i
].f0
;
1138 const Tp diff
= f
- f0
;
1139 if (std::abs(diff
) > max_abs_diff
)
1140 max_abs_diff
= std::abs(diff
);
1141 if (std::abs(f0
) > Tp(10) * eps
1142 && std::abs(f
) > Tp(10) * eps
)
1144 const Tp frac
= diff
/ f0
;
1145 if (std::abs(frac
) > max_abs_frac
)
1146 max_abs_frac
= std::abs(frac
);
1149 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1152 // Test data for a=0.50000000000000000, c=6.0000000000000000.
1153 testcase_conf_hyperg
<double> data016
[] = {
1154 { 0.59687111919499192, 0.50000000000000000, 6.0000000000000000,
1155 -10.000000000000000 },
1156 { 0.61774982278057033, 0.50000000000000000, 6.0000000000000000,
1157 -9.0000000000000000 },
1158 { 0.64090744485124451, 0.50000000000000000, 6.0000000000000000,
1159 -8.0000000000000000 },
1160 { 0.66677322792860194, 0.50000000000000000, 6.0000000000000000,
1161 -7.0000000000000000 },
1162 { 0.69589293014100995, 0.50000000000000000, 6.0000000000000000,
1163 -6.0000000000000000 },
1164 { 0.72897040032571048, 0.50000000000000000, 6.0000000000000000,
1165 -5.0000000000000000 },
1166 { 0.76692755408207181, 0.50000000000000000, 6.0000000000000000,
1167 -4.0000000000000000 },
1168 { 0.81099244559101891, 0.50000000000000000, 6.0000000000000000,
1169 -3.0000000000000000 },
1170 { 0.86283102401276535, 0.50000000000000000, 6.0000000000000000,
1171 -2.0000000000000000 },
1172 { 0.92474809223976406, 0.50000000000000000, 6.0000000000000000,
1173 -1.0000000000000000 },
1174 { 1.0000000000000000, 0.50000000000000000, 6.0000000000000000,
1175 0.0000000000000000 },
1176 { 1.0932912594628821, 0.50000000000000000, 6.0000000000000000,
1177 1.0000000000000000 },
1178 { 1.2115798426781204, 0.50000000000000000, 6.0000000000000000,
1179 2.0000000000000000 },
1180 { 1.3654106750890422, 0.50000000000000000, 6.0000000000000000,
1181 3.0000000000000000 },
1182 { 1.5711704305419896, 0.50000000000000000, 6.0000000000000000,
1183 4.0000000000000000 },
1184 { 1.8549798357448213, 0.50000000000000000, 6.0000000000000000,
1185 5.0000000000000000 },
1186 { 2.2595503871694818, 0.50000000000000000, 6.0000000000000000,
1187 6.0000000000000000 },
1188 { 2.8565038772876936, 0.50000000000000000, 6.0000000000000000,
1189 7.0000000000000000 },
1190 { 3.7689325736317811, 0.50000000000000000, 6.0000000000000000,
1191 8.0000000000000000 },
1192 { 5.2134738554699460, 0.50000000000000000, 6.0000000000000000,
1193 9.0000000000000000 },
1194 { 7.5801565545352725, 0.50000000000000000, 6.0000000000000000,
1195 10.000000000000000 },
1198 // Test function for a=0.50000000000000000, c=6.0000000000000000.
1199 template <typename Tp
>
1202 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1203 Tp max_abs_diff
= -Tp(1);
1204 Tp max_abs_frac
= -Tp(1);
1205 unsigned int num_datum
= sizeof(data016
)
1206 / sizeof(testcase_conf_hyperg
<double>);
1207 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1209 const Tp f
= std::tr1::conf_hyperg(Tp(data016
[i
].a
), Tp(data016
[i
].c
),
1211 const Tp f0
= data016
[i
].f0
;
1212 const Tp diff
= f
- f0
;
1213 if (std::abs(diff
) > max_abs_diff
)
1214 max_abs_diff
= std::abs(diff
);
1215 if (std::abs(f0
) > Tp(10) * eps
1216 && std::abs(f
) > Tp(10) * eps
)
1218 const Tp frac
= diff
/ f0
;
1219 if (std::abs(frac
) > max_abs_frac
)
1220 max_abs_frac
= std::abs(frac
);
1223 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1226 // Test data for a=0.50000000000000000, c=7.0000000000000000.
1227 testcase_conf_hyperg
<double> data017
[] = {
1228 { 0.62946736953754090, 0.50000000000000000, 7.0000000000000000,
1229 -10.000000000000000 },
1230 { 0.64995830964827050, 0.50000000000000000, 7.0000000000000000,
1231 -9.0000000000000000 },
1232 { 0.67251910396276349, 0.50000000000000000, 7.0000000000000000,
1233 -8.0000000000000000 },
1234 { 0.69750870596083636, 0.50000000000000000, 7.0000000000000000,
1235 -7.0000000000000000 },
1236 { 0.72537539174856436, 0.50000000000000000, 7.0000000000000000,
1237 -6.0000000000000000 },
1238 { 0.75668588434835504, 0.50000000000000000, 7.0000000000000000,
1239 -5.0000000000000000 },
1240 { 0.79216623458879654, 0.50000000000000000, 7.0000000000000000,
1241 -4.0000000000000000 },
1242 { 0.83276010491326891, 0.50000000000000000, 7.0000000000000000,
1243 -3.0000000000000000 },
1244 { 0.87971323375878940, 0.50000000000000000, 7.0000000000000000,
1245 -2.0000000000000000 },
1246 { 0.93469794840150233, 0.50000000000000000, 7.0000000000000000,
1247 -1.0000000000000000 },
1248 { 1.0000000000000000, 0.50000000000000000, 7.0000000000000000,
1249 0.0000000000000000 },
1250 { 1.0788040971101556, 0.50000000000000000, 7.0000000000000000,
1251 1.0000000000000000 },
1252 { 1.1756385516794761, 0.50000000000000000, 7.0000000000000000,
1253 2.0000000000000000 },
1254 { 1.2970810749099917, 0.50000000000000000, 7.0000000000000000,
1255 3.0000000000000000 },
1256 { 1.4529009687665237, 0.50000000000000000, 7.0000000000000000,
1257 4.0000000000000000 },
1258 { 1.6579437149144023, 0.50000000000000000, 7.0000000000000000,
1259 5.0000000000000000 },
1260 { 1.9353010489337750, 0.50000000000000000, 7.0000000000000000,
1261 6.0000000000000000 },
1262 { 2.3217458547039813, 0.50000000000000000, 7.0000000000000000,
1263 7.0000000000000000 },
1264 { 2.8772254607646004, 0.50000000000000000, 7.0000000000000000,
1265 8.0000000000000000 },
1266 { 3.7017478151936545, 0.50000000000000000, 7.0000000000000000,
1267 9.0000000000000000 },
1268 { 4.9659500648552148, 0.50000000000000000, 7.0000000000000000,
1269 10.000000000000000 },
1272 // Test function for a=0.50000000000000000, c=7.0000000000000000.
1273 template <typename Tp
>
1276 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1277 Tp max_abs_diff
= -Tp(1);
1278 Tp max_abs_frac
= -Tp(1);
1279 unsigned int num_datum
= sizeof(data017
)
1280 / sizeof(testcase_conf_hyperg
<double>);
1281 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1283 const Tp f
= std::tr1::conf_hyperg(Tp(data017
[i
].a
), Tp(data017
[i
].c
),
1285 const Tp f0
= data017
[i
].f0
;
1286 const Tp diff
= f
- f0
;
1287 if (std::abs(diff
) > max_abs_diff
)
1288 max_abs_diff
= std::abs(diff
);
1289 if (std::abs(f0
) > Tp(10) * eps
1290 && std::abs(f
) > Tp(10) * eps
)
1292 const Tp frac
= diff
/ f0
;
1293 if (std::abs(frac
) > max_abs_frac
)
1294 max_abs_frac
= std::abs(frac
);
1297 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1300 // Test data for a=0.50000000000000000, c=8.0000000000000000.
1301 testcase_conf_hyperg
<double> data018
[] = {
1302 { 0.65682574389601245, 0.50000000000000000, 8.0000000000000000,
1303 -10.000000000000000 },
1304 { 0.67683106084440448, 0.50000000000000000, 8.0000000000000000,
1305 -9.0000000000000000 },
1306 { 0.69871884883136481, 0.50000000000000000, 8.0000000000000000,
1307 -8.0000000000000000 },
1308 { 0.72279201131268422, 0.50000000000000000, 8.0000000000000000,
1309 -7.0000000000000000 },
1310 { 0.74942315553647221, 0.50000000000000000, 8.0000000000000000,
1311 -6.0000000000000000 },
1312 { 0.77907555763819503, 0.50000000000000000, 8.0000000000000000,
1313 -5.0000000000000000 },
1314 { 0.81233192258476394, 0.50000000000000000, 8.0000000000000000,
1315 -4.0000000000000000 },
1316 { 0.84993438521252052, 0.50000000000000000, 8.0000000000000000,
1317 -3.0000000000000000 },
1318 { 0.89284095871461888, 0.50000000000000000, 8.0000000000000000,
1319 -2.0000000000000000 },
1320 { 0.94230641231038748, 0.50000000000000000, 8.0000000000000000,
1321 -1.0000000000000000 },
1322 { 1.0000000000000000, 0.50000000000000000, 8.0000000000000000,
1323 0.0000000000000000 },
1324 { 1.0681796709163929, 0.50000000000000000, 8.0000000000000000,
1325 1.0000000000000000 },
1326 { 1.1499542693515108, 0.50000000000000000, 8.0000000000000000,
1327 2.0000000000000000 },
1328 { 1.2496850956712680, 0.50000000000000000, 8.0000000000000000,
1329 3.0000000000000000 },
1330 { 1.3736119127266571, 0.50000000000000000, 8.0000000000000000,
1331 4.0000000000000000 },
1332 { 1.5308465522192733, 0.50000000000000000, 8.0000000000000000,
1333 5.0000000000000000 },
1334 { 1.7349787653671500, 0.50000000000000000, 8.0000000000000000,
1335 6.0000000000000000 },
1336 { 2.0067188996039378, 0.50000000000000000, 8.0000000000000000,
1337 7.0000000000000000 },
1338 { 2.3783255204306930, 0.50000000000000000, 8.0000000000000000,
1339 8.0000000000000000 },
1340 { 2.9011558746255721, 0.50000000000000000, 8.0000000000000000,
1341 9.0000000000000000 },
1342 { 3.6587666457431167, 0.50000000000000000, 8.0000000000000000,
1343 10.000000000000000 },
1346 // Test function for a=0.50000000000000000, c=8.0000000000000000.
1347 template <typename Tp
>
1350 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1351 Tp max_abs_diff
= -Tp(1);
1352 Tp max_abs_frac
= -Tp(1);
1353 unsigned int num_datum
= sizeof(data018
)
1354 / sizeof(testcase_conf_hyperg
<double>);
1355 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1357 const Tp f
= std::tr1::conf_hyperg(Tp(data018
[i
].a
), Tp(data018
[i
].c
),
1359 const Tp f0
= data018
[i
].f0
;
1360 const Tp diff
= f
- f0
;
1361 if (std::abs(diff
) > max_abs_diff
)
1362 max_abs_diff
= std::abs(diff
);
1363 if (std::abs(f0
) > Tp(10) * eps
1364 && std::abs(f
) > Tp(10) * eps
)
1366 const Tp frac
= diff
/ f0
;
1367 if (std::abs(frac
) > max_abs_frac
)
1368 max_abs_frac
= std::abs(frac
);
1371 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1374 // Test data for a=0.50000000000000000, c=9.0000000000000000.
1375 testcase_conf_hyperg
<double> data019
[] = {
1376 { 0.68018654063475448, 0.50000000000000000, 9.0000000000000000,
1377 -10.000000000000000 },
1378 { 0.69965870094538662, 0.50000000000000000, 9.0000000000000000,
1379 -9.0000000000000000 },
1380 { 0.72084701020942776, 0.50000000000000000, 9.0000000000000000,
1381 -8.0000000000000000 },
1382 { 0.74400928635822572, 0.50000000000000000, 9.0000000000000000,
1383 -7.0000000000000000 },
1384 { 0.76945859319172982, 0.50000000000000000, 9.0000000000000000,
1385 -6.0000000000000000 },
1386 { 0.79757868270124699, 0.50000000000000000, 9.0000000000000000,
1387 -5.0000000000000000 },
1388 { 0.82884476649794248, 0.50000000000000000, 9.0000000000000000,
1389 -4.0000000000000000 },
1390 { 0.86385180214855140, 0.50000000000000000, 9.0000000000000000,
1391 -3.0000000000000000 },
1392 { 0.90335351612716308, 0.50000000000000000, 9.0000000000000000,
1393 -2.0000000000000000 },
1394 { 0.94831697594473685, 0.50000000000000000, 9.0000000000000000,
1395 -1.0000000000000000 },
1396 { 1.0000000000000000, 0.50000000000000000, 9.0000000000000000,
1397 0.0000000000000000 },
1398 { 1.0600626000640645, 0.50000000000000000, 9.0000000000000000,
1399 1.0000000000000000 },
1400 { 1.1307298999505393, 0.50000000000000000, 9.0000000000000000,
1401 2.0000000000000000 },
1402 { 1.2150341092774180, 0.50000000000000000, 9.0000000000000000,
1403 3.0000000000000000 },
1404 { 1.3171798023006840, 0.50000000000000000, 9.0000000000000000,
1405 4.0000000000000000 },
1406 { 1.4431045594091672, 0.50000000000000000, 9.0000000000000000,
1407 5.0000000000000000 },
1408 { 1.6013540635087158, 0.50000000000000000, 9.0000000000000000,
1409 6.0000000000000000 },
1410 { 1.8044714074708206, 0.50000000000000000, 9.0000000000000000,
1411 7.0000000000000000 },
1412 { 2.0712406108144252, 0.50000000000000000, 9.0000000000000000,
1413 8.0000000000000000 },
1414 { 2.4303714711293125, 0.50000000000000000, 9.0000000000000000,
1415 9.0000000000000000 },
1416 { 2.9266541358556246, 0.50000000000000000, 9.0000000000000000,
1417 10.000000000000000 },
1420 // Test function for a=0.50000000000000000, c=9.0000000000000000.
1421 template <typename Tp
>
1424 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1425 Tp max_abs_diff
= -Tp(1);
1426 Tp max_abs_frac
= -Tp(1);
1427 unsigned int num_datum
= sizeof(data019
)
1428 / sizeof(testcase_conf_hyperg
<double>);
1429 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1431 const Tp f
= std::tr1::conf_hyperg(Tp(data019
[i
].a
), Tp(data019
[i
].c
),
1433 const Tp f0
= data019
[i
].f0
;
1434 const Tp diff
= f
- f0
;
1435 if (std::abs(diff
) > max_abs_diff
)
1436 max_abs_diff
= std::abs(diff
);
1437 if (std::abs(f0
) > Tp(10) * eps
1438 && std::abs(f
) > Tp(10) * eps
)
1440 const Tp frac
= diff
/ f0
;
1441 if (std::abs(frac
) > max_abs_frac
)
1442 max_abs_frac
= std::abs(frac
);
1445 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1448 // Test data for a=0.50000000000000000, c=10.000000000000000.
1449 testcase_conf_hyperg
<double> data020
[] = {
1450 { 0.70040954461104077, 0.50000000000000000, 10.000000000000000,
1451 -10.000000000000000 },
1452 { 0.71933025737654377, 0.50000000000000000, 10.000000000000000,
1453 -9.0000000000000000 },
1454 { 0.73981995758615049, 0.50000000000000000, 10.000000000000000,
1455 -8.0000000000000000 },
1456 { 0.76209985272755054, 0.50000000000000000, 10.000000000000000,
1457 -7.0000000000000000 },
1458 { 0.78643553963087975, 0.50000000000000000, 10.000000000000000,
1459 -6.0000000000000000 },
1460 { 0.81314860510626796, 0.50000000000000000, 10.000000000000000,
1461 -5.0000000000000000 },
1462 { 0.84263196565226672, 0.50000000000000000, 10.000000000000000,
1463 -4.0000000000000000 },
1464 { 0.87537037798496642, 0.50000000000000000, 10.000000000000000,
1465 -3.0000000000000000 },
1466 { 0.91196818568151450, 0.50000000000000000, 10.000000000000000,
1467 -2.0000000000000000 },
1468 { 0.95318731786229316, 0.50000000000000000, 10.000000000000000,
1469 -1.0000000000000000 },
1470 { 1.0000000000000000, 0.50000000000000000, 10.000000000000000,
1471 0.0000000000000000 },
1472 { 1.0536628587304602, 0.50000000000000000, 10.000000000000000,
1473 1.0000000000000000 },
1474 { 1.1158225648376323, 0.50000000000000000, 10.000000000000000,
1475 2.0000000000000000 },
1476 { 1.1886686247111011, 0.50000000000000000, 10.000000000000000,
1477 3.0000000000000000 },
1478 { 1.2751576744751334, 0.50000000000000000, 10.000000000000000,
1479 4.0000000000000000 },
1480 { 1.3793478044961116, 0.50000000000000000, 10.000000000000000,
1481 5.0000000000000000 },
1482 { 1.5069047234443802, 0.50000000000000000, 10.000000000000000,
1483 6.0000000000000000 },
1484 { 1.6658803233122232, 0.50000000000000000, 10.000000000000000,
1485 7.0000000000000000 },
1486 { 1.8679295659745196, 0.50000000000000000, 10.000000000000000,
1487 8.0000000000000000 },
1488 { 2.1302432955522042, 0.50000000000000000, 10.000000000000000,
1489 9.0000000000000000 },
1490 { 2.4786679001777268, 0.50000000000000000, 10.000000000000000,
1491 10.000000000000000 },
1494 // Test function for a=0.50000000000000000, c=10.000000000000000.
1495 template <typename Tp
>
1498 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1499 Tp max_abs_diff
= -Tp(1);
1500 Tp max_abs_frac
= -Tp(1);
1501 unsigned int num_datum
= sizeof(data020
)
1502 / sizeof(testcase_conf_hyperg
<double>);
1503 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1505 const Tp f
= std::tr1::conf_hyperg(Tp(data020
[i
].a
), Tp(data020
[i
].c
),
1507 const Tp f0
= data020
[i
].f0
;
1508 const Tp diff
= f
- f0
;
1509 if (std::abs(diff
) > max_abs_diff
)
1510 max_abs_diff
= std::abs(diff
);
1511 if (std::abs(f0
) > Tp(10) * eps
1512 && std::abs(f
) > Tp(10) * eps
)
1514 const Tp frac
= diff
/ f0
;
1515 if (std::abs(frac
) > max_abs_frac
)
1516 max_abs_frac
= std::abs(frac
);
1519 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1522 // Test data for a=1.0000000000000000, c=1.0000000000000000.
1523 testcase_conf_hyperg
<double> data021
[] = {
1524 { 4.5399929762484854e-05, 1.0000000000000000, 1.0000000000000000,
1525 -10.000000000000000 },
1526 { 0.00012340980408667956, 1.0000000000000000, 1.0000000000000000,
1527 -9.0000000000000000 },
1528 { 0.00033546262790251185, 1.0000000000000000, 1.0000000000000000,
1529 -8.0000000000000000 },
1530 { 0.00091188196555451624, 1.0000000000000000, 1.0000000000000000,
1531 -7.0000000000000000 },
1532 { 0.0024787521766663585, 1.0000000000000000, 1.0000000000000000,
1533 -6.0000000000000000 },
1534 { 0.0067379469990854670, 1.0000000000000000, 1.0000000000000000,
1535 -5.0000000000000000 },
1536 { 0.018315638888734179, 1.0000000000000000, 1.0000000000000000,
1537 -4.0000000000000000 },
1538 { 0.049787068367863944, 1.0000000000000000, 1.0000000000000000,
1539 -3.0000000000000000 },
1540 { 0.13533528323661270, 1.0000000000000000, 1.0000000000000000,
1541 -2.0000000000000000 },
1542 { 0.36787944117144233, 1.0000000000000000, 1.0000000000000000,
1543 -1.0000000000000000 },
1544 { 1.0000000000000000, 1.0000000000000000, 1.0000000000000000,
1545 0.0000000000000000 },
1546 { 2.7182818284590451, 1.0000000000000000, 1.0000000000000000,
1547 1.0000000000000000 },
1548 { 7.3890560989306504, 1.0000000000000000, 1.0000000000000000,
1549 2.0000000000000000 },
1550 { 20.085536923187668, 1.0000000000000000, 1.0000000000000000,
1551 3.0000000000000000 },
1552 { 54.598150033144236, 1.0000000000000000, 1.0000000000000000,
1553 4.0000000000000000 },
1554 { 148.41315910257660, 1.0000000000000000, 1.0000000000000000,
1555 5.0000000000000000 },
1556 { 403.42879349273511, 1.0000000000000000, 1.0000000000000000,
1557 6.0000000000000000 },
1558 { 1096.6331584284585, 1.0000000000000000, 1.0000000000000000,
1559 7.0000000000000000 },
1560 { 2980.9579870417283, 1.0000000000000000, 1.0000000000000000,
1561 8.0000000000000000 },
1562 { 8103.0839275753842, 1.0000000000000000, 1.0000000000000000,
1563 9.0000000000000000 },
1564 { 22026.465794806718, 1.0000000000000000, 1.0000000000000000,
1565 10.000000000000000 },
1568 // Test function for a=1.0000000000000000, c=1.0000000000000000.
1569 template <typename Tp
>
1572 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1573 Tp max_abs_diff
= -Tp(1);
1574 Tp max_abs_frac
= -Tp(1);
1575 unsigned int num_datum
= sizeof(data021
)
1576 / sizeof(testcase_conf_hyperg
<double>);
1577 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1579 const Tp f
= std::tr1::conf_hyperg(Tp(data021
[i
].a
), Tp(data021
[i
].c
),
1581 const Tp f0
= data021
[i
].f0
;
1582 const Tp diff
= f
- f0
;
1583 if (std::abs(diff
) > max_abs_diff
)
1584 max_abs_diff
= std::abs(diff
);
1585 if (std::abs(f0
) > Tp(10) * eps
1586 && std::abs(f
) > Tp(10) * eps
)
1588 const Tp frac
= diff
/ f0
;
1589 if (std::abs(frac
) > max_abs_frac
)
1590 max_abs_frac
= std::abs(frac
);
1593 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1596 // Test data for a=1.0000000000000000, c=2.0000000000000000.
1597 testcase_conf_hyperg
<double> data022
[] = {
1598 { 0.099995460007023751, 1.0000000000000000, 2.0000000000000000,
1599 -10.000000000000000 },
1600 { 0.11109739891065704, 1.0000000000000000, 2.0000000000000000,
1601 -9.0000000000000000 },
1602 { 0.12495806717151219, 1.0000000000000000, 2.0000000000000000,
1603 -8.0000000000000000 },
1604 { 0.14272687400492079, 1.0000000000000000, 2.0000000000000000,
1605 -7.0000000000000000 },
1606 { 0.16625354130388895, 1.0000000000000000, 2.0000000000000000,
1607 -6.0000000000000000 },
1608 { 0.19865241060018290, 1.0000000000000000, 2.0000000000000000,
1609 -5.0000000000000000 },
1610 { 0.24542109027781644, 1.0000000000000000, 2.0000000000000000,
1611 -4.0000000000000000 },
1612 { 0.31673764387737868, 1.0000000000000000, 2.0000000000000000,
1613 -3.0000000000000000 },
1614 { 0.43233235838169365, 1.0000000000000000, 2.0000000000000000,
1615 -2.0000000000000000 },
1616 { 0.63212055882855767, 1.0000000000000000, 2.0000000000000000,
1617 -1.0000000000000000 },
1618 { 1.0000000000000000, 1.0000000000000000, 2.0000000000000000,
1619 0.0000000000000000 },
1620 { 1.7182818284590451, 1.0000000000000000, 2.0000000000000000,
1621 1.0000000000000000 },
1622 { 3.1945280494653252, 1.0000000000000000, 2.0000000000000000,
1623 2.0000000000000000 },
1624 { 6.3618456410625557, 1.0000000000000000, 2.0000000000000000,
1625 3.0000000000000000 },
1626 { 13.399537508286059, 1.0000000000000000, 2.0000000000000000,
1627 4.0000000000000000 },
1628 { 29.482631820515319, 1.0000000000000000, 2.0000000000000000,
1629 5.0000000000000000 },
1630 { 67.071465582122514, 1.0000000000000000, 2.0000000000000000,
1631 6.0000000000000000 },
1632 { 156.51902263263693, 1.0000000000000000, 2.0000000000000000,
1633 7.0000000000000000 },
1634 { 372.49474838021604, 1.0000000000000000, 2.0000000000000000,
1635 8.0000000000000000 },
1636 { 900.23154750837602, 1.0000000000000000, 2.0000000000000000,
1637 9.0000000000000000 },
1638 { 2202.5465794806719, 1.0000000000000000, 2.0000000000000000,
1639 10.000000000000000 },
1642 // Test function for a=1.0000000000000000, c=2.0000000000000000.
1643 template <typename Tp
>
1646 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1647 Tp max_abs_diff
= -Tp(1);
1648 Tp max_abs_frac
= -Tp(1);
1649 unsigned int num_datum
= sizeof(data022
)
1650 / sizeof(testcase_conf_hyperg
<double>);
1651 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1653 const Tp f
= std::tr1::conf_hyperg(Tp(data022
[i
].a
), Tp(data022
[i
].c
),
1655 const Tp f0
= data022
[i
].f0
;
1656 const Tp diff
= f
- f0
;
1657 if (std::abs(diff
) > max_abs_diff
)
1658 max_abs_diff
= std::abs(diff
);
1659 if (std::abs(f0
) > Tp(10) * eps
1660 && std::abs(f
) > Tp(10) * eps
)
1662 const Tp frac
= diff
/ f0
;
1663 if (std::abs(frac
) > max_abs_frac
)
1664 max_abs_frac
= std::abs(frac
);
1667 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1670 // Test data for a=1.0000000000000000, c=3.0000000000000000.
1671 testcase_conf_hyperg
<double> data023
[] = {
1672 { 0.18000090799859525, 1.0000000000000000, 3.0000000000000000,
1673 -10.000000000000000 },
1674 { 0.19753391135318732, 1.0000000000000000, 3.0000000000000000,
1675 -9.0000000000000000 },
1676 { 0.21876048320712196, 1.0000000000000000, 3.0000000000000000,
1677 -8.0000000000000000 },
1678 { 0.24493517885573690, 1.0000000000000000, 3.0000000000000000,
1679 -7.0000000000000000 },
1680 { 0.27791548623203705, 1.0000000000000000, 3.0000000000000000,
1681 -6.0000000000000000 },
1682 { 0.32053903575992687, 1.0000000000000000, 3.0000000000000000,
1683 -5.0000000000000000 },
1684 { 0.37728945486109178, 1.0000000000000000, 3.0000000000000000,
1685 -4.0000000000000000 },
1686 { 0.45550823741508090, 1.0000000000000000, 3.0000000000000000,
1687 -3.0000000000000000 },
1688 { 0.56766764161830641, 1.0000000000000000, 3.0000000000000000,
1689 -2.0000000000000000 },
1690 { 0.73575888234288467, 1.0000000000000000, 3.0000000000000000,
1691 -1.0000000000000000 },
1692 { 1.0000000000000000, 1.0000000000000000, 3.0000000000000000,
1693 0.0000000000000000 },
1694 { 1.4365636569180902, 1.0000000000000000, 3.0000000000000000,
1695 1.0000000000000000 },
1696 { 2.1945280494653252, 1.0000000000000000, 3.0000000000000000,
1697 2.0000000000000000 },
1698 { 3.5745637607083705, 1.0000000000000000, 3.0000000000000000,
1699 3.0000000000000000 },
1700 { 6.1997687541430295, 1.0000000000000000, 3.0000000000000000,
1701 4.0000000000000000 },
1702 { 11.393052728206127, 1.0000000000000000, 3.0000000000000000,
1703 5.0000000000000000 },
1704 { 22.023821860707507, 1.0000000000000000, 3.0000000000000000,
1705 6.0000000000000000 },
1706 { 44.434006466467693, 1.0000000000000000, 3.0000000000000000,
1707 7.0000000000000000 },
1708 { 92.873687095054009, 1.0000000000000000, 3.0000000000000000,
1709 8.0000000000000000 },
1710 { 199.82923277963911, 1.0000000000000000, 3.0000000000000000,
1711 9.0000000000000000 },
1712 { 440.30931589613436, 1.0000000000000000, 3.0000000000000000,
1713 10.000000000000000 },
1716 // Test function for a=1.0000000000000000, c=3.0000000000000000.
1717 template <typename Tp
>
1720 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1721 Tp max_abs_diff
= -Tp(1);
1722 Tp max_abs_frac
= -Tp(1);
1723 unsigned int num_datum
= sizeof(data023
)
1724 / sizeof(testcase_conf_hyperg
<double>);
1725 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1727 const Tp f
= std::tr1::conf_hyperg(Tp(data023
[i
].a
), Tp(data023
[i
].c
),
1729 const Tp f0
= data023
[i
].f0
;
1730 const Tp diff
= f
- f0
;
1731 if (std::abs(diff
) > max_abs_diff
)
1732 max_abs_diff
= std::abs(diff
);
1733 if (std::abs(f0
) > Tp(10) * eps
1734 && std::abs(f
) > Tp(10) * eps
)
1736 const Tp frac
= diff
/ f0
;
1737 if (std::abs(frac
) > max_abs_frac
)
1738 max_abs_frac
= std::abs(frac
);
1741 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1744 // Test data for a=1.0000000000000000, c=4.0000000000000000.
1745 testcase_conf_hyperg
<double> data024
[] = {
1746 { 0.24599972760042146, 1.0000000000000000, 4.0000000000000000,
1747 -10.000000000000000 },
1748 { 0.26748869621560417, 1.0000000000000000, 4.0000000000000000,
1749 -9.0000000000000000 },
1750 { 0.29296481879732927, 1.0000000000000000, 4.0000000000000000,
1751 -8.0000000000000000 },
1752 { 0.32359920906182704, 1.0000000000000000, 4.0000000000000000,
1753 -7.0000000000000000 },
1754 { 0.36104225688398150, 1.0000000000000000, 4.0000000000000000,
1755 -6.0000000000000000 },
1756 { 0.40767657854404399, 1.0000000000000000, 4.0000000000000000,
1757 -5.0000000000000000 },
1758 { 0.46703290885418114, 1.0000000000000000, 4.0000000000000000,
1759 -4.0000000000000000 },
1760 { 0.54449176258491927, 1.0000000000000000, 4.0000000000000000,
1761 -3.0000000000000000 },
1762 { 0.64849853757254050, 1.0000000000000000, 4.0000000000000000,
1763 -2.0000000000000000 },
1764 { 0.79272335297134611, 1.0000000000000000, 4.0000000000000000,
1765 -1.0000000000000000 },
1766 { 1.0000000000000000, 1.0000000000000000, 4.0000000000000000,
1767 0.0000000000000000 },
1768 { 1.3096909707542714, 1.0000000000000000, 4.0000000000000000,
1769 1.0000000000000000 },
1770 { 1.7917920741979876, 1.0000000000000000, 4.0000000000000000,
1771 2.0000000000000000 },
1772 { 2.5745637607083709, 1.0000000000000000, 4.0000000000000000,
1773 3.0000000000000000 },
1774 { 3.8998265656072717, 1.0000000000000000, 4.0000000000000000,
1775 4.0000000000000000 },
1776 { 6.2358316369236775, 1.0000000000000000, 4.0000000000000000,
1777 5.0000000000000000 },
1778 { 10.511910930353745, 1.0000000000000000, 4.0000000000000000,
1779 6.0000000000000000 },
1780 { 18.614574199914728, 1.0000000000000000, 4.0000000000000000,
1781 7.0000000000000000 },
1782 { 34.452632660645271, 1.0000000000000000, 4.0000000000000000,
1783 8.0000000000000000 },
1784 { 66.276410926546333, 1.0000000000000000, 4.0000000000000000,
1785 9.0000000000000000 },
1786 { 131.79279476884014, 1.0000000000000000, 4.0000000000000000,
1787 10.000000000000000 },
1790 // Test function for a=1.0000000000000000, c=4.0000000000000000.
1791 template <typename Tp
>
1794 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1795 Tp max_abs_diff
= -Tp(1);
1796 Tp max_abs_frac
= -Tp(1);
1797 unsigned int num_datum
= sizeof(data024
)
1798 / sizeof(testcase_conf_hyperg
<double>);
1799 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1801 const Tp f
= std::tr1::conf_hyperg(Tp(data024
[i
].a
), Tp(data024
[i
].c
),
1803 const Tp f0
= data024
[i
].f0
;
1804 const Tp diff
= f
- f0
;
1805 if (std::abs(diff
) > max_abs_diff
)
1806 max_abs_diff
= std::abs(diff
);
1807 if (std::abs(f0
) > Tp(10) * eps
1808 && std::abs(f
) > Tp(10) * eps
)
1810 const Tp frac
= diff
/ f0
;
1811 if (std::abs(frac
) > max_abs_frac
)
1812 max_abs_frac
= std::abs(frac
);
1815 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1818 // Test data for a=1.0000000000000000, c=5.0000000000000000.
1819 testcase_conf_hyperg
<double> data025
[] = {
1820 { 0.30160010895983153, 1.0000000000000000, 5.0000000000000000,
1821 -10.000000000000000 },
1822 { 0.32556057945973144, 1.0000000000000000, 5.0000000000000000,
1823 -9.0000000000000000 },
1824 { 0.35351759060133547, 1.0000000000000000, 5.0000000000000000,
1825 -8.0000000000000000 },
1826 { 0.38651473767895589, 1.0000000000000000, 5.0000000000000000,
1827 -7.0000000000000000 },
1828 { 0.42597182874401224, 1.0000000000000000, 5.0000000000000000,
1829 -6.0000000000000000 },
1830 { 0.47385873716476495, 1.0000000000000000, 5.0000000000000000,
1831 -5.0000000000000000 },
1832 { 0.53296709114581886, 1.0000000000000000, 5.0000000000000000,
1833 -4.0000000000000000 },
1834 { 0.60734431655344123, 1.0000000000000000, 5.0000000000000000,
1835 -3.0000000000000000 },
1836 { 0.70300292485491900, 1.0000000000000000, 5.0000000000000000,
1837 -2.0000000000000000 },
1838 { 0.82910658811461568, 1.0000000000000000, 5.0000000000000000,
1839 -1.0000000000000000 },
1840 { 1.0000000000000000, 1.0000000000000000, 5.0000000000000000,
1841 0.0000000000000000 },
1842 { 1.2387638830170857, 1.0000000000000000, 5.0000000000000000,
1843 1.0000000000000000 },
1844 { 1.5835841483959754, 1.0000000000000000, 5.0000000000000000,
1845 2.0000000000000000 },
1846 { 2.0994183476111612, 1.0000000000000000, 5.0000000000000000,
1847 3.0000000000000000 },
1848 { 2.8998265656072721, 1.0000000000000000, 5.0000000000000000,
1849 4.0000000000000000 },
1850 { 4.1886653095389432, 1.0000000000000000, 5.0000000000000000,
1851 5.0000000000000000 },
1852 { 6.3412739535691678, 1.0000000000000000, 5.0000000000000000,
1853 6.0000000000000000 },
1854 { 10.065470971379844, 1.0000000000000000, 5.0000000000000000,
1855 7.0000000000000000 },
1856 { 16.726316330322632, 1.0000000000000000, 5.0000000000000000,
1857 8.0000000000000000 },
1858 { 29.011738189576135, 1.0000000000000000, 5.0000000000000000,
1859 9.0000000000000000 },
1860 { 52.317117907536058, 1.0000000000000000, 5.0000000000000000,
1861 10.000000000000000 },
1864 // Test function for a=1.0000000000000000, c=5.0000000000000000.
1865 template <typename Tp
>
1868 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1869 Tp max_abs_diff
= -Tp(1);
1870 Tp max_abs_frac
= -Tp(1);
1871 unsigned int num_datum
= sizeof(data025
)
1872 / sizeof(testcase_conf_hyperg
<double>);
1873 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1875 const Tp f
= std::tr1::conf_hyperg(Tp(data025
[i
].a
), Tp(data025
[i
].c
),
1877 const Tp f0
= data025
[i
].f0
;
1878 const Tp diff
= f
- f0
;
1879 if (std::abs(diff
) > max_abs_diff
)
1880 max_abs_diff
= std::abs(diff
);
1881 if (std::abs(f0
) > Tp(10) * eps
1882 && std::abs(f
) > Tp(10) * eps
)
1884 const Tp frac
= diff
/ f0
;
1885 if (std::abs(frac
) > max_abs_frac
)
1886 max_abs_frac
= std::abs(frac
);
1889 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1892 // Test data for a=1.0000000000000000, c=6.0000000000000000.
1893 testcase_conf_hyperg
<double> data026
[] = {
1894 { 0.34919994552008432, 1.0000000000000000, 6.0000000000000000,
1895 -10.000000000000000 },
1896 { 0.37468856696681579, 1.0000000000000000, 6.0000000000000000,
1897 -9.0000000000000000 },
1898 { 0.40405150587416544, 1.0000000000000000, 6.0000000000000000,
1899 -8.0000000000000000 },
1900 { 0.43820375880074558, 1.0000000000000000, 6.0000000000000000,
1901 -7.0000000000000000 },
1902 { 0.47835680937998976, 1.0000000000000000, 6.0000000000000000,
1903 -6.0000000000000000 },
1904 { 0.52614126283523510, 1.0000000000000000, 6.0000000000000000,
1905 -5.0000000000000000 },
1906 { 0.58379113606772637, 1.0000000000000000, 6.0000000000000000,
1907 -4.0000000000000000 },
1908 { 0.65442613907759817, 1.0000000000000000, 6.0000000000000000,
1909 -3.0000000000000000 },
1910 { 0.74249268786270239, 1.0000000000000000, 6.0000000000000000,
1911 -2.0000000000000000 },
1912 { 0.85446705942692136, 1.0000000000000000, 6.0000000000000000,
1913 -1.0000000000000000 },
1914 { 1.0000000000000000, 1.0000000000000000, 6.0000000000000000,
1915 0.0000000000000000 },
1916 { 1.1938194150854282, 1.0000000000000000, 6.0000000000000000,
1917 1.0000000000000000 },
1918 { 1.4589603709899384, 1.0000000000000000, 6.0000000000000000,
1919 2.0000000000000000 },
1920 { 1.8323639126852680, 1.0000000000000000, 6.0000000000000000,
1921 3.0000000000000000 },
1922 { 2.3747832070090902, 1.0000000000000000, 6.0000000000000000,
1923 4.0000000000000000 },
1924 { 3.1886653095389415, 1.0000000000000000, 6.0000000000000000,
1925 5.0000000000000000 },
1926 { 4.4510616279743056, 1.0000000000000000, 6.0000000000000000,
1927 6.0000000000000000 },
1928 { 6.4753364081284595, 1.0000000000000000, 6.0000000000000000,
1929 7.0000000000000000 },
1930 { 9.8289477064516344, 1.0000000000000000, 6.0000000000000000,
1931 8.0000000000000000 },
1932 { 15.562076771986721, 1.0000000000000000, 6.0000000000000000,
1933 9.0000000000000000 },
1934 { 25.658558953767979, 1.0000000000000000, 6.0000000000000000,
1935 10.000000000000000 },
1938 // Test function for a=1.0000000000000000, c=6.0000000000000000.
1939 template <typename Tp
>
1942 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
1943 Tp max_abs_diff
= -Tp(1);
1944 Tp max_abs_frac
= -Tp(1);
1945 unsigned int num_datum
= sizeof(data026
)
1946 / sizeof(testcase_conf_hyperg
<double>);
1947 for (unsigned int i
= 0; i
< num_datum
; ++i
)
1949 const Tp f
= std::tr1::conf_hyperg(Tp(data026
[i
].a
), Tp(data026
[i
].c
),
1951 const Tp f0
= data026
[i
].f0
;
1952 const Tp diff
= f
- f0
;
1953 if (std::abs(diff
) > max_abs_diff
)
1954 max_abs_diff
= std::abs(diff
);
1955 if (std::abs(f0
) > Tp(10) * eps
1956 && std::abs(f
) > Tp(10) * eps
)
1958 const Tp frac
= diff
/ f0
;
1959 if (std::abs(frac
) > max_abs_frac
)
1960 max_abs_frac
= std::abs(frac
);
1963 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
1966 // Test data for a=1.0000000000000000, c=7.0000000000000000.
1967 testcase_conf_hyperg
<double> data027
[] = {
1968 { 0.39048003268794951, 1.0000000000000000, 7.0000000000000000,
1969 -10.000000000000000 },
1970 { 0.41687428868878945, 1.0000000000000000, 7.0000000000000000,
1971 -9.0000000000000000 },
1972 { 0.44696137059437596, 1.0000000000000000, 7.0000000000000000,
1973 -8.0000000000000000 },
1974 { 0.48153963531364646, 1.0000000000000000, 7.0000000000000000,
1975 -7.0000000000000000 },
1976 { 0.52164319062001030, 1.0000000000000000, 7.0000000000000000,
1977 -6.0000000000000000 },
1978 { 0.56863048459771781, 1.0000000000000000, 7.0000000000000000,
1979 -5.0000000000000000 },
1980 { 0.62431329589841034, 1.0000000000000000, 7.0000000000000000,
1981 -4.0000000000000000 },
1982 { 0.69114772184480400, 1.0000000000000000, 7.0000000000000000,
1983 -3.0000000000000000 },
1984 { 0.77252193641189282, 1.0000000000000000, 7.0000000000000000,
1985 -2.0000000000000000 },
1986 { 0.87319764343847150, 1.0000000000000000, 7.0000000000000000,
1987 -1.0000000000000000 },
1988 { 1.0000000000000000, 1.0000000000000000, 7.0000000000000000,
1989 0.0000000000000000 },
1990 { 1.1629164905125695, 1.0000000000000000, 7.0000000000000000,
1991 1.0000000000000000 },
1992 { 1.3768811129698151, 1.0000000000000000, 7.0000000000000000,
1993 2.0000000000000000 },
1994 { 1.6647278253705360, 1.0000000000000000, 7.0000000000000000,
1995 3.0000000000000000 },
1996 { 2.0621748105136359, 1.0000000000000000, 7.0000000000000000,
1997 4.0000000000000000 },
1998 { 2.6263983714467298, 1.0000000000000000, 7.0000000000000000,
1999 5.0000000000000000 },
2000 { 3.4510616279743078, 1.0000000000000000, 7.0000000000000000,
2001 6.0000000000000000 },
2002 { 4.6931454926815448, 1.0000000000000000, 7.0000000000000000,
2003 7.0000000000000000 },
2004 { 6.6217107798387476, 1.0000000000000000, 7.0000000000000000,
2005 8.0000000000000000 },
2006 { 9.7080511813245050, 1.0000000000000000, 7.0000000000000000,
2007 9.0000000000000000 },
2008 { 14.795135372260793, 1.0000000000000000, 7.0000000000000000,
2009 10.000000000000000 },
2012 // Test function for a=1.0000000000000000, c=7.0000000000000000.
2013 template <typename Tp
>
2016 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2017 Tp max_abs_diff
= -Tp(1);
2018 Tp max_abs_frac
= -Tp(1);
2019 unsigned int num_datum
= sizeof(data027
)
2020 / sizeof(testcase_conf_hyperg
<double>);
2021 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2023 const Tp f
= std::tr1::conf_hyperg(Tp(data027
[i
].a
), Tp(data027
[i
].c
),
2025 const Tp f0
= data027
[i
].f0
;
2026 const Tp diff
= f
- f0
;
2027 if (std::abs(diff
) > max_abs_diff
)
2028 max_abs_diff
= std::abs(diff
);
2029 if (std::abs(f0
) > Tp(10) * eps
2030 && std::abs(f
) > Tp(10) * eps
)
2032 const Tp frac
= diff
/ f0
;
2033 if (std::abs(frac
) > max_abs_frac
)
2034 max_abs_frac
= std::abs(frac
);
2037 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2040 // Test data for a=1.0000000000000000, c=8.0000000000000000.
2041 testcase_conf_hyperg
<double> data028
[] = {
2042 { 0.42666397711843540, 1.0000000000000000, 8.0000000000000000,
2043 -10.000000000000000 },
2044 { 0.45354221990871918, 1.0000000000000000, 8.0000000000000000,
2045 -9.0000000000000000 },
2046 { 0.48390880072992104, 1.0000000000000000, 8.0000000000000000,
2047 -8.0000000000000000 },
2048 { 0.51846036468635348, 1.0000000000000000, 8.0000000000000000,
2049 -7.0000000000000000 },
2050 { 0.55808294427665472, 1.0000000000000000, 8.0000000000000000,
2051 -6.0000000000000000 },
2052 { 0.60391732156319489, 1.0000000000000000, 8.0000000000000000,
2053 -5.0000000000000000 },
2054 { 0.65745173217778197, 1.0000000000000000, 8.0000000000000000,
2055 -4.0000000000000000 },
2056 { 0.72065531569545760, 1.0000000000000000, 8.0000000000000000,
2057 -3.0000000000000000 },
2058 { 0.79617322255837530, 1.0000000000000000, 8.0000000000000000,
2059 -2.0000000000000000 },
2060 { 0.88761649593069913, 1.0000000000000000, 8.0000000000000000,
2061 -1.0000000000000000 },
2062 { 1.0000000000000000, 1.0000000000000000, 8.0000000000000000,
2063 0.0000000000000000 },
2064 { 1.1404154335879861, 1.0000000000000000, 8.0000000000000000,
2065 1.0000000000000000 },
2066 { 1.3190838953943527, 1.0000000000000000, 8.0000000000000000,
2067 2.0000000000000000 },
2068 { 1.5510315925312508, 1.0000000000000000, 8.0000000000000000,
2069 3.0000000000000000 },
2070 { 1.8588059183988628, 1.0000000000000000, 8.0000000000000000,
2071 4.0000000000000000 },
2072 { 2.2769577200254218, 1.0000000000000000, 8.0000000000000000,
2073 5.0000000000000000 },
2074 { 2.8595718993033583, 1.0000000000000000, 8.0000000000000000,
2075 6.0000000000000000 },
2076 { 3.6931454926815368, 1.0000000000000000, 8.0000000000000000,
2077 7.0000000000000000 },
2078 { 4.9189969323589020, 1.0000000000000000, 8.0000000000000000,
2079 8.0000000000000000 },
2080 { 6.7729286965857218, 1.0000000000000000, 8.0000000000000000,
2081 9.0000000000000000 },
2082 { 9.6565947605825802, 1.0000000000000000, 8.0000000000000000,
2083 10.000000000000000 },
2086 // Test function for a=1.0000000000000000, c=8.0000000000000000.
2087 template <typename Tp
>
2090 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2091 Tp max_abs_diff
= -Tp(1);
2092 Tp max_abs_frac
= -Tp(1);
2093 unsigned int num_datum
= sizeof(data028
)
2094 / sizeof(testcase_conf_hyperg
<double>);
2095 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2097 const Tp f
= std::tr1::conf_hyperg(Tp(data028
[i
].a
), Tp(data028
[i
].c
),
2099 const Tp f0
= data028
[i
].f0
;
2100 const Tp diff
= f
- f0
;
2101 if (std::abs(diff
) > max_abs_diff
)
2102 max_abs_diff
= std::abs(diff
);
2103 if (std::abs(f0
) > Tp(10) * eps
2104 && std::abs(f
) > Tp(10) * eps
)
2106 const Tp frac
= diff
/ f0
;
2107 if (std::abs(frac
) > max_abs_frac
)
2108 max_abs_frac
= std::abs(frac
);
2111 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2114 // Test data for a=1.0000000000000000, c=9.0000000000000000.
2115 testcase_conf_hyperg
<double> data029
[] = {
2116 { 0.45866881830525175, 1.0000000000000000, 9.0000000000000000,
2117 -10.000000000000000 },
2118 { 0.48574024897002721, 1.0000000000000000, 9.0000000000000000,
2119 -9.0000000000000000 },
2120 { 0.51609119927007907, 1.0000000000000000, 9.0000000000000000,
2121 -8.0000000000000000 },
2122 { 0.55033101178702437, 1.0000000000000000, 9.0000000000000000,
2123 -7.0000000000000000 },
2124 { 0.58922274096446048, 1.0000000000000000, 9.0000000000000000,
2125 -6.0000000000000000 },
2126 { 0.63373228549888783, 1.0000000000000000, 9.0000000000000000,
2127 -5.0000000000000000 },
2128 { 0.68509653564443607, 1.0000000000000000, 9.0000000000000000,
2129 -4.0000000000000000 },
2130 { 0.74491915814544640, 1.0000000000000000, 9.0000000000000000,
2131 -3.0000000000000000 },
2132 { 0.81530710976649901, 1.0000000000000000, 9.0000000000000000,
2133 -2.0000000000000000 },
2134 { 0.89906803255440670, 1.0000000000000000, 9.0000000000000000,
2135 -1.0000000000000000 },
2136 { 1.0000000000000000, 1.0000000000000000, 9.0000000000000000,
2137 0.0000000000000000 },
2138 { 1.1233234687038898, 1.0000000000000000, 9.0000000000000000,
2139 1.0000000000000000 },
2140 { 1.2763355815774109, 1.0000000000000000, 9.0000000000000000,
2141 2.0000000000000000 },
2142 { 1.4694175800833353, 1.0000000000000000, 9.0000000000000000,
2143 3.0000000000000000 },
2144 { 1.7176118367977251, 1.0000000000000000, 9.0000000000000000,
2145 4.0000000000000000 },
2146 { 2.0431323520406752, 1.0000000000000000, 9.0000000000000000,
2147 5.0000000000000000 },
2148 { 2.4794291990711450, 1.0000000000000000, 9.0000000000000000,
2149 6.0000000000000000 },
2150 { 3.0778805630646140, 1.0000000000000000, 9.0000000000000000,
2151 7.0000000000000000 },
2152 { 3.9189969323588896, 1.0000000000000000, 9.0000000000000000,
2153 8.0000000000000000 },
2154 { 5.1314921747428537, 1.0000000000000000, 9.0000000000000000,
2155 9.0000000000000000 },
2156 { 6.9252758084660462, 1.0000000000000000, 9.0000000000000000,
2157 10.000000000000000 },
2160 // Test function for a=1.0000000000000000, c=9.0000000000000000.
2161 template <typename Tp
>
2164 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2165 Tp max_abs_diff
= -Tp(1);
2166 Tp max_abs_frac
= -Tp(1);
2167 unsigned int num_datum
= sizeof(data029
)
2168 / sizeof(testcase_conf_hyperg
<double>);
2169 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2171 const Tp f
= std::tr1::conf_hyperg(Tp(data029
[i
].a
), Tp(data029
[i
].c
),
2173 const Tp f0
= data029
[i
].f0
;
2174 const Tp diff
= f
- f0
;
2175 if (std::abs(diff
) > max_abs_diff
)
2176 max_abs_diff
= std::abs(diff
);
2177 if (std::abs(f0
) > Tp(10) * eps
2178 && std::abs(f
) > Tp(10) * eps
)
2180 const Tp frac
= diff
/ f0
;
2181 if (std::abs(frac
) > max_abs_frac
)
2182 max_abs_frac
= std::abs(frac
);
2185 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2188 // Test data for a=1.0000000000000000, c=10.000000000000000.
2189 testcase_conf_hyperg
<double> data030
[] = {
2190 { 0.48719806352527339, 1.0000000000000000, 10.000000000000000,
2191 -10.000000000000000 },
2192 { 0.51425975102997279, 1.0000000000000000, 10.000000000000000,
2193 -9.0000000000000000 },
2194 { 0.54439740082116117, 1.0000000000000000, 10.000000000000000,
2195 -8.0000000000000000 },
2196 { 0.57814584198811125, 1.0000000000000000, 10.000000000000000,
2197 -7.0000000000000000 },
2198 { 0.61616588855330923, 1.0000000000000000, 10.000000000000000,
2199 -6.0000000000000000 },
2200 { 0.65928188610200156, 1.0000000000000000, 10.000000000000000,
2201 -5.0000000000000000 },
2202 { 0.70853279480001885, 1.0000000000000000, 10.000000000000000,
2203 -4.0000000000000000 },
2204 { 0.76524252556366068, 1.0000000000000000, 10.000000000000000,
2205 -3.0000000000000000 },
2206 { 0.83111800605075459, 1.0000000000000000, 10.000000000000000,
2207 -2.0000000000000000 },
2208 { 0.90838770701033944, 1.0000000000000000, 10.000000000000000,
2209 -1.0000000000000000 },
2210 { 1.0000000000000000, 1.0000000000000000, 10.000000000000000,
2211 0.0000000000000000 },
2212 { 1.1099112183350075, 1.0000000000000000, 10.000000000000000,
2213 1.0000000000000000 },
2214 { 1.2435101170983485, 1.0000000000000000, 10.000000000000000,
2215 2.0000000000000000 },
2216 { 1.4082527402500060, 1.0000000000000000, 10.000000000000000,
2217 3.0000000000000000 },
2218 { 1.6146266327948817, 1.0000000000000000, 10.000000000000000,
2219 4.0000000000000000 },
2220 { 1.8776382336732149, 1.0000000000000000, 10.000000000000000,
2221 5.0000000000000000 },
2222 { 2.2191437986067171, 1.0000000000000000, 10.000000000000000,
2223 6.0000000000000000 },
2224 { 2.6715607239402184, 1.0000000000000000, 10.000000000000000,
2225 7.0000000000000000 },
2226 { 3.2838715489037504, 1.0000000000000000, 10.000000000000000,
2227 8.0000000000000000 },
2228 { 4.1314921747428679, 1.0000000000000000, 10.000000000000000,
2229 9.0000000000000000 },
2230 { 5.3327482276194447, 1.0000000000000000, 10.000000000000000,
2231 10.000000000000000 },
2234 // Test function for a=1.0000000000000000, c=10.000000000000000.
2235 template <typename Tp
>
2238 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2239 Tp max_abs_diff
= -Tp(1);
2240 Tp max_abs_frac
= -Tp(1);
2241 unsigned int num_datum
= sizeof(data030
)
2242 / sizeof(testcase_conf_hyperg
<double>);
2243 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2245 const Tp f
= std::tr1::conf_hyperg(Tp(data030
[i
].a
), Tp(data030
[i
].c
),
2247 const Tp f0
= data030
[i
].f0
;
2248 const Tp diff
= f
- f0
;
2249 if (std::abs(diff
) > max_abs_diff
)
2250 max_abs_diff
= std::abs(diff
);
2251 if (std::abs(f0
) > Tp(10) * eps
2252 && std::abs(f
) > Tp(10) * eps
)
2254 const Tp frac
= diff
/ f0
;
2255 if (std::abs(frac
) > max_abs_frac
)
2256 max_abs_frac
= std::abs(frac
);
2259 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2262 // Test data for a=2.0000000000000000, c=1.0000000000000000.
2263 testcase_conf_hyperg
<double> data031
[] = {
2264 { -0.00040859936786236367, 2.0000000000000000, 1.0000000000000000,
2265 -10.000000000000000 },
2266 { -0.00098727843269343649, 2.0000000000000000, 1.0000000000000000,
2267 -9.0000000000000000 },
2268 { -0.0023482383953175828, 2.0000000000000000, 1.0000000000000000,
2269 -8.0000000000000000 },
2270 { -0.0054712917933270972, 2.0000000000000000, 1.0000000000000000,
2271 -7.0000000000000000 },
2272 { -0.012393760883331793, 2.0000000000000000, 1.0000000000000000,
2273 -6.0000000000000000 },
2274 { -0.026951787996341868, 2.0000000000000000, 1.0000000000000000,
2275 -5.0000000000000000 },
2276 { -0.054946916666202536, 2.0000000000000000, 1.0000000000000000,
2277 -4.0000000000000000 },
2278 { -0.099574136735727889, 2.0000000000000000, 1.0000000000000000,
2279 -3.0000000000000000 },
2280 { -0.13533528323661270, 2.0000000000000000, 1.0000000000000000,
2281 -2.0000000000000000 },
2282 { 1.0000000000000000, 2.0000000000000000, 1.0000000000000000,
2283 0.0000000000000000 },
2284 { 5.4365636569180902, 2.0000000000000000, 1.0000000000000000,
2285 1.0000000000000000 },
2286 { 22.167168296791949, 2.0000000000000000, 1.0000000000000000,
2287 2.0000000000000000 },
2288 { 80.342147692750672, 2.0000000000000000, 1.0000000000000000,
2289 3.0000000000000000 },
2290 { 272.99075016572118, 2.0000000000000000, 1.0000000000000000,
2291 4.0000000000000000 },
2292 { 890.47895461545954, 2.0000000000000000, 1.0000000000000000,
2293 5.0000000000000000 },
2294 { 2824.0015544491457, 2.0000000000000000, 1.0000000000000000,
2295 6.0000000000000000 },
2296 { 8773.0652674276680, 2.0000000000000000, 1.0000000000000000,
2297 7.0000000000000000 },
2298 { 26828.621883375556, 2.0000000000000000, 1.0000000000000000,
2299 8.0000000000000000 },
2300 { 81030.839275753839, 2.0000000000000000, 1.0000000000000000,
2301 9.0000000000000000 },
2302 { 242291.12374287390, 2.0000000000000000, 1.0000000000000000,
2303 10.000000000000000 },
2306 // Test function for a=2.0000000000000000, c=1.0000000000000000.
2307 template <typename Tp
>
2310 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2311 Tp max_abs_diff
= -Tp(1);
2312 Tp max_abs_frac
= -Tp(1);
2313 unsigned int num_datum
= sizeof(data031
)
2314 / sizeof(testcase_conf_hyperg
<double>);
2315 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2317 const Tp f
= std::tr1::conf_hyperg(Tp(data031
[i
].a
), Tp(data031
[i
].c
),
2319 const Tp f0
= data031
[i
].f0
;
2320 const Tp diff
= f
- f0
;
2321 if (std::abs(diff
) > max_abs_diff
)
2322 max_abs_diff
= std::abs(diff
);
2323 if (std::abs(f0
) > Tp(10) * eps
2324 && std::abs(f
) > Tp(10) * eps
)
2326 const Tp frac
= diff
/ f0
;
2327 if (std::abs(frac
) > max_abs_frac
)
2328 max_abs_frac
= std::abs(frac
);
2331 VERIFY(max_abs_frac
< Tp(1.0000000000000008e-12));
2334 // Test data for a=2.0000000000000000, c=2.0000000000000000.
2335 testcase_conf_hyperg
<double> data032
[] = {
2336 { 4.5399929762484854e-05, 2.0000000000000000, 2.0000000000000000,
2337 -10.000000000000000 },
2338 { 0.00012340980408667956, 2.0000000000000000, 2.0000000000000000,
2339 -9.0000000000000000 },
2340 { 0.00033546262790251185, 2.0000000000000000, 2.0000000000000000,
2341 -8.0000000000000000 },
2342 { 0.00091188196555451624, 2.0000000000000000, 2.0000000000000000,
2343 -7.0000000000000000 },
2344 { 0.0024787521766663585, 2.0000000000000000, 2.0000000000000000,
2345 -6.0000000000000000 },
2346 { 0.0067379469990854670, 2.0000000000000000, 2.0000000000000000,
2347 -5.0000000000000000 },
2348 { 0.018315638888734179, 2.0000000000000000, 2.0000000000000000,
2349 -4.0000000000000000 },
2350 { 0.049787068367863944, 2.0000000000000000, 2.0000000000000000,
2351 -3.0000000000000000 },
2352 { 0.13533528323661270, 2.0000000000000000, 2.0000000000000000,
2353 -2.0000000000000000 },
2354 { 0.36787944117144233, 2.0000000000000000, 2.0000000000000000,
2355 -1.0000000000000000 },
2356 { 1.0000000000000000, 2.0000000000000000, 2.0000000000000000,
2357 0.0000000000000000 },
2358 { 2.7182818284590451, 2.0000000000000000, 2.0000000000000000,
2359 1.0000000000000000 },
2360 { 7.3890560989306504, 2.0000000000000000, 2.0000000000000000,
2361 2.0000000000000000 },
2362 { 20.085536923187668, 2.0000000000000000, 2.0000000000000000,
2363 3.0000000000000000 },
2364 { 54.598150033144236, 2.0000000000000000, 2.0000000000000000,
2365 4.0000000000000000 },
2366 { 148.41315910257660, 2.0000000000000000, 2.0000000000000000,
2367 5.0000000000000000 },
2368 { 403.42879349273511, 2.0000000000000000, 2.0000000000000000,
2369 6.0000000000000000 },
2370 { 1096.6331584284585, 2.0000000000000000, 2.0000000000000000,
2371 7.0000000000000000 },
2372 { 2980.9579870417283, 2.0000000000000000, 2.0000000000000000,
2373 8.0000000000000000 },
2374 { 8103.0839275753842, 2.0000000000000000, 2.0000000000000000,
2375 9.0000000000000000 },
2376 { 22026.465794806718, 2.0000000000000000, 2.0000000000000000,
2377 10.000000000000000 },
2380 // Test function for a=2.0000000000000000, c=2.0000000000000000.
2381 template <typename Tp
>
2384 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2385 Tp max_abs_diff
= -Tp(1);
2386 Tp max_abs_frac
= -Tp(1);
2387 unsigned int num_datum
= sizeof(data032
)
2388 / sizeof(testcase_conf_hyperg
<double>);
2389 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2391 const Tp f
= std::tr1::conf_hyperg(Tp(data032
[i
].a
), Tp(data032
[i
].c
),
2393 const Tp f0
= data032
[i
].f0
;
2394 const Tp diff
= f
- f0
;
2395 if (std::abs(diff
) > max_abs_diff
)
2396 max_abs_diff
= std::abs(diff
);
2397 if (std::abs(f0
) > Tp(10) * eps
2398 && std::abs(f
) > Tp(10) * eps
)
2400 const Tp frac
= diff
/ f0
;
2401 if (std::abs(frac
) > max_abs_frac
)
2402 max_abs_frac
= std::abs(frac
);
2405 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2408 // Test data for a=2.0000000000000000, c=3.0000000000000000.
2409 testcase_conf_hyperg
<double> data033
[] = {
2410 { 0.019990012015452256, 2.0000000000000000, 3.0000000000000000,
2411 -10.000000000000000 },
2412 { 0.024660886468126749, 2.0000000000000000, 3.0000000000000000,
2413 -9.0000000000000000 },
2414 { 0.031155651135902421, 2.0000000000000000, 3.0000000000000000,
2415 -8.0000000000000000 },
2416 { 0.040518569154104643, 2.0000000000000000, 3.0000000000000000,
2417 -7.0000000000000000 },
2418 { 0.054591596375740861, 2.0000000000000000, 3.0000000000000000,
2419 -6.0000000000000000 },
2420 { 0.076765785440438966, 2.0000000000000000, 3.0000000000000000,
2421 -5.0000000000000000 },
2422 { 0.11355272569454113, 2.0000000000000000, 3.0000000000000000,
2423 -4.0000000000000000 },
2424 { 0.17796705033967650, 2.0000000000000000, 3.0000000000000000,
2425 -3.0000000000000000 },
2426 { 0.29699707514508100, 2.0000000000000000, 3.0000000000000000,
2427 -2.0000000000000000 },
2428 { 0.52848223531423066, 2.0000000000000000, 3.0000000000000000,
2429 -1.0000000000000000 },
2430 { 1.0000000000000000, 2.0000000000000000, 3.0000000000000000,
2431 0.0000000000000000 },
2432 { 2.0000000000000000, 2.0000000000000000, 3.0000000000000000,
2433 1.0000000000000000 },
2434 { 4.1945280494653261, 2.0000000000000000, 3.0000000000000000,
2435 2.0000000000000000 },
2436 { 9.1491275214167409, 2.0000000000000000, 3.0000000000000000,
2437 3.0000000000000000 },
2438 { 20.599306262429089, 2.0000000000000000, 3.0000000000000000,
2439 4.0000000000000000 },
2440 { 47.572210912824517, 2.0000000000000000, 3.0000000000000000,
2441 5.0000000000000000 },
2442 { 112.11910930353754, 2.0000000000000000, 3.0000000000000000,
2443 6.0000000000000000 },
2444 { 268.60403879880613, 2.0000000000000000, 3.0000000000000000,
2445 7.0000000000000000 },
2446 { 652.11580966537815, 2.0000000000000000, 3.0000000000000000,
2447 8.0000000000000000 },
2448 { 1600.6338622371129, 2.0000000000000000, 3.0000000000000000,
2449 9.0000000000000000 },
2450 { 3964.7838430652091, 2.0000000000000000, 3.0000000000000000,
2451 10.000000000000000 },
2454 // Test function for a=2.0000000000000000, c=3.0000000000000000.
2455 template <typename Tp
>
2458 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2459 Tp max_abs_diff
= -Tp(1);
2460 Tp max_abs_frac
= -Tp(1);
2461 unsigned int num_datum
= sizeof(data033
)
2462 / sizeof(testcase_conf_hyperg
<double>);
2463 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2465 const Tp f
= std::tr1::conf_hyperg(Tp(data033
[i
].a
), Tp(data033
[i
].c
),
2467 const Tp f0
= data033
[i
].f0
;
2468 const Tp diff
= f
- f0
;
2469 if (std::abs(diff
) > max_abs_diff
)
2470 max_abs_diff
= std::abs(diff
);
2471 if (std::abs(f0
) > Tp(10) * eps
2472 && std::abs(f
) > Tp(10) * eps
)
2474 const Tp frac
= diff
/ f0
;
2475 if (std::abs(frac
) > max_abs_frac
)
2476 max_abs_frac
= std::abs(frac
);
2479 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2482 // Test data for a=2.0000000000000000, c=4.0000000000000000.
2483 testcase_conf_hyperg
<double> data034
[] = {
2484 { 0.048003268794942940, 2.0000000000000000, 4.0000000000000000,
2485 -10.000000000000000 },
2486 { 0.057624341628353531, 2.0000000000000000, 4.0000000000000000,
2487 -9.0000000000000000 },
2488 { 0.070351812026707330, 2.0000000000000000, 4.0000000000000000,
2489 -8.0000000000000000 },
2490 { 0.087607118443556703, 2.0000000000000000, 4.0000000000000000,
2491 -7.0000000000000000 },
2492 { 0.11166194492814813, 2.0000000000000000, 4.0000000000000000,
2493 -6.0000000000000000 },
2494 { 0.14626395019169278, 2.0000000000000000, 4.0000000000000000,
2495 -5.0000000000000000 },
2496 { 0.19780254687491294, 2.0000000000000000, 4.0000000000000000,
2497 -4.0000000000000000 },
2498 { 0.27754118707540443, 2.0000000000000000, 4.0000000000000000,
2499 -3.0000000000000000 },
2500 { 0.40600584970983811, 2.0000000000000000, 4.0000000000000000,
2501 -2.0000000000000000 },
2502 { 0.62182994108596168, 2.0000000000000000, 4.0000000000000000,
2503 -1.0000000000000000 },
2504 { 1.0000000000000000, 2.0000000000000000, 4.0000000000000000,
2505 0.0000000000000000 },
2506 { 1.6903090292457283, 2.0000000000000000, 4.0000000000000000,
2507 1.0000000000000000 },
2508 { 3.0000000000000000, 2.0000000000000000, 4.0000000000000000,
2509 2.0000000000000000 },
2510 { 5.5745637607083705, 2.0000000000000000, 4.0000000000000000,
2511 3.0000000000000000 },
2512 { 10.799653131214550, 2.0000000000000000, 4.0000000000000000,
2513 4.0000000000000000 },
2514 { 21.707494910771043, 2.0000000000000000, 4.0000000000000000,
2515 5.0000000000000000 },
2516 { 45.047643721415056, 2.0000000000000000, 4.0000000000000000,
2517 6.0000000000000000 },
2518 { 96.072870999573695, 2.0000000000000000, 4.0000000000000000,
2519 7.0000000000000000 },
2520 { 209.71579596387159, 2.0000000000000000, 4.0000000000000000,
2521 8.0000000000000000 },
2522 { 466.93487648582493, 2.0000000000000000, 4.0000000000000000,
2523 9.0000000000000000 },
2524 { 1057.3423581507243, 2.0000000000000000, 4.0000000000000000,
2525 10.000000000000000 },
2528 // Test function for a=2.0000000000000000, c=4.0000000000000000.
2529 template <typename Tp
>
2532 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2533 Tp max_abs_diff
= -Tp(1);
2534 Tp max_abs_frac
= -Tp(1);
2535 unsigned int num_datum
= sizeof(data034
)
2536 / sizeof(testcase_conf_hyperg
<double>);
2537 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2539 const Tp f
= std::tr1::conf_hyperg(Tp(data034
[i
].a
), Tp(data034
[i
].c
),
2541 const Tp f0
= data034
[i
].f0
;
2542 const Tp diff
= f
- f0
;
2543 if (std::abs(diff
) > max_abs_diff
)
2544 max_abs_diff
= std::abs(diff
);
2545 if (std::abs(f0
) > Tp(10) * eps
2546 && std::abs(f
) > Tp(10) * eps
)
2548 const Tp frac
= diff
/ f0
;
2549 if (std::abs(frac
) > max_abs_frac
)
2550 max_abs_frac
= std::abs(frac
);
2553 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2556 // Test data for a=2.0000000000000000, c=5.0000000000000000.
2557 testcase_conf_hyperg
<double> data035
[] = {
2558 { 0.079198583522191404, 2.0000000000000000, 5.0000000000000000,
2559 -10.000000000000000 },
2560 { 0.093273046483222530, 2.0000000000000000, 5.0000000000000000,
2561 -9.0000000000000000 },
2562 { 0.11130650338531098, 2.0000000000000000, 5.0000000000000000,
2563 -8.0000000000000000 },
2564 { 0.13485262321044020, 2.0000000000000000, 5.0000000000000000,
2565 -7.0000000000000000 },
2566 { 0.16625354130388895, 2.0000000000000000, 5.0000000000000000,
2567 -6.0000000000000000 },
2568 { 0.20913010268188095, 2.0000000000000000, 5.0000000000000000,
2569 -5.0000000000000000 },
2570 { 0.26923036197926808, 2.0000000000000000, 5.0000000000000000,
2571 -4.0000000000000000 },
2572 { 0.35593410067935288, 2.0000000000000000, 5.0000000000000000,
2573 -3.0000000000000000 },
2574 { 0.48498537572540468, 2.0000000000000000, 5.0000000000000000,
2575 -2.0000000000000000 },
2576 { 0.68357364754153715, 2.0000000000000000, 5.0000000000000000,
2577 -1.0000000000000000 },
2578 { 1.0000000000000000, 2.0000000000000000, 5.0000000000000000,
2579 0.0000000000000000 },
2580 { 1.5224722339658285, 2.0000000000000000, 5.0000000000000000,
2581 1.0000000000000000 },
2582 { 2.4164158516040235, 2.0000000000000000, 5.0000000000000000,
2583 2.0000000000000000 },
2584 { 4.0000000000000009, 2.0000000000000000, 5.0000000000000000,
2585 3.0000000000000000 },
2586 { 6.8998265656072721, 2.0000000000000000, 5.0000000000000000,
2587 4.0000000000000000 },
2588 { 12.377330619077886, 2.0000000000000000, 5.0000000000000000,
2589 5.0000000000000000 },
2590 { 23.023821860707503, 2.0000000000000000, 5.0000000000000000,
2591 6.0000000000000000 },
2592 { 44.261883885519374, 2.0000000000000000, 5.0000000000000000,
2593 7.0000000000000000 },
2594 { 87.631581651613160, 2.0000000000000000, 5.0000000000000000,
2595 8.0000000000000000 },
2596 { 178.07042913745681, 2.0000000000000000, 5.0000000000000000,
2597 9.0000000000000000 },
2598 { 370.21982535275242, 2.0000000000000000, 5.0000000000000000,
2599 10.000000000000000 },
2602 // Test function for a=2.0000000000000000, c=5.0000000000000000.
2603 template <typename Tp
>
2606 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2607 Tp max_abs_diff
= -Tp(1);
2608 Tp max_abs_frac
= -Tp(1);
2609 unsigned int num_datum
= sizeof(data035
)
2610 / sizeof(testcase_conf_hyperg
<double>);
2611 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2613 const Tp f
= std::tr1::conf_hyperg(Tp(data035
[i
].a
), Tp(data035
[i
].c
),
2615 const Tp f0
= data035
[i
].f0
;
2616 const Tp diff
= f
- f0
;
2617 if (std::abs(diff
) > max_abs_diff
)
2618 max_abs_diff
= std::abs(diff
);
2619 if (std::abs(f0
) > Tp(10) * eps
2620 && std::abs(f
) > Tp(10) * eps
)
2622 const Tp frac
= diff
/ f0
;
2623 if (std::abs(frac
) > max_abs_frac
)
2624 max_abs_frac
= std::abs(frac
);
2627 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2630 // Test data for a=2.0000000000000000, c=6.0000000000000000.
2631 testcase_conf_hyperg
<double> data036
[] = {
2632 { 0.11120076271882003, 2.0000000000000000, 6.0000000000000000,
2633 -10.000000000000000 },
2634 { 0.12904862943139384, 2.0000000000000000, 6.0000000000000000,
2635 -9.0000000000000000 },
2636 { 0.15138192951001525, 2.0000000000000000, 6.0000000000000000,
2637 -8.0000000000000000 },
2638 { 0.17975865319179699, 2.0000000000000000, 6.0000000000000000,
2639 -7.0000000000000000 },
2640 { 0.21643190620010283, 2.0000000000000000, 6.0000000000000000,
2641 -6.0000000000000000 },
2642 { 0.26472863448288397, 2.0000000000000000, 6.0000000000000000,
2643 -5.0000000000000000 },
2644 { 0.32967091145818839, 2.0000000000000000, 6.0000000000000000,
2645 -4.0000000000000000 },
2646 { 0.41901702645681349, 2.0000000000000000, 6.0000000000000000,
2647 -3.0000000000000000 },
2648 { 0.54504387282378575, 2.0000000000000000, 6.0000000000000000,
2649 -2.0000000000000000 },
2650 { 0.72766470286539298, 2.0000000000000000, 6.0000000000000000,
2651 -1.0000000000000000 },
2652 { 1.0000000000000000, 2.0000000000000000, 6.0000000000000000,
2653 0.0000000000000000 },
2654 { 1.4185417547437151, 2.0000000000000000, 6.0000000000000000,
2655 1.0000000000000000 },
2656 { 2.0820792580201224, 2.0000000000000000, 6.0000000000000000,
2657 2.0000000000000000 },
2658 { 3.1676360873147318, 2.0000000000000000, 6.0000000000000000,
2659 3.0000000000000000 },
2660 { 4.9999999999999982, 2.0000000000000000, 6.0000000000000000,
2661 4.0000000000000000 },
2662 { 8.1886653095389406, 2.0000000000000000, 6.0000000000000000,
2663 5.0000000000000000 },
2664 { 13.902123255948611, 2.0000000000000000, 6.0000000000000000,
2665 6.0000000000000000 },
2666 { 24.426009224385378, 2.0000000000000000, 6.0000000000000000,
2667 7.0000000000000000 },
2668 { 44.315790825806538, 2.0000000000000000, 6.0000000000000000,
2669 8.0000000000000000 },
2670 { 82.810383859933609, 2.0000000000000000, 6.0000000000000000,
2671 9.0000000000000000 },
2672 { 158.95135372260788, 2.0000000000000000, 6.0000000000000000,
2673 10.000000000000000 },
2676 // Test function for a=2.0000000000000000, c=6.0000000000000000.
2677 template <typename Tp
>
2680 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2681 Tp max_abs_diff
= -Tp(1);
2682 Tp max_abs_frac
= -Tp(1);
2683 unsigned int num_datum
= sizeof(data036
)
2684 / sizeof(testcase_conf_hyperg
<double>);
2685 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2687 const Tp f
= std::tr1::conf_hyperg(Tp(data036
[i
].a
), Tp(data036
[i
].c
),
2689 const Tp f0
= data036
[i
].f0
;
2690 const Tp diff
= f
- f0
;
2691 if (std::abs(diff
) > max_abs_diff
)
2692 max_abs_diff
= std::abs(diff
);
2693 if (std::abs(f0
) > Tp(10) * eps
2694 && std::abs(f
) > Tp(10) * eps
)
2696 const Tp frac
= diff
/ f0
;
2697 if (std::abs(frac
) > max_abs_frac
)
2698 max_abs_frac
= std::abs(frac
);
2701 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2704 // Test data for a=2.0000000000000000, c=7.0000000000000000.
2705 testcase_conf_hyperg
<double> data037
[] = {
2706 { 0.14279950968075858, 2.0000000000000000, 7.0000000000000000,
2707 -10.000000000000000 },
2708 { 0.16375995835694801, 2.0000000000000000, 7.0000000000000000,
2709 -9.0000000000000000 },
2710 { 0.18950218227311263, 2.0000000000000000, 7.0000000000000000,
2711 -8.0000000000000000 },
2712 { 0.22152437623624174, 2.0000000000000000, 7.0000000000000000,
2713 -7.0000000000000000 },
2714 { 0.26192490317988687, 2.0000000000000000, 7.0000000000000000,
2715 -6.0000000000000000 },
2716 { 0.31369515402282139, 2.0000000000000000, 7.0000000000000000,
2717 -5.0000000000000000 },
2718 { 0.38118033691430731, 2.0000000000000000, 7.0000000000000000,
2719 -4.0000000000000000 },
2720 { 0.47081822524156886, 2.0000000000000000, 7.0000000000000000,
2721 -3.0000000000000000 },
2722 { 0.59234644511675072, 2.0000000000000000, 7.0000000000000000,
2723 -2.0000000000000000 },
2724 { 0.76081413936917086, 2.0000000000000000, 7.0000000000000000,
2725 -1.0000000000000000 },
2726 { 1.0000000000000000, 2.0000000000000000, 7.0000000000000000,
2727 0.0000000000000000 },
2728 { 1.3483340379497220, 2.0000000000000000, 7.0000000000000000,
2729 1.0000000000000000 },
2730 { 1.8693566610905543, 2.0000000000000000, 7.0000000000000000,
2731 2.0000000000000000 },
2732 { 2.6705443492589280, 2.0000000000000000, 7.0000000000000000,
2733 3.0000000000000000 },
2734 { 3.9378251894863650, 2.0000000000000000, 7.0000000000000000,
2735 4.0000000000000000 },
2736 { 6.0000000000000018, 2.0000000000000000, 7.0000000000000000,
2737 5.0000000000000000 },
2738 { 9.4510616279743118, 2.0000000000000000, 7.0000000000000000,
2739 6.0000000000000000 },
2740 { 15.386290985363090, 2.0000000000000000, 7.0000000000000000,
2741 7.0000000000000000 },
2742 { 25.865132339516244, 2.0000000000000000, 7.0000000000000000,
2743 8.0000000000000000 },
2744 { 44.832204725298020, 2.0000000000000000, 7.0000000000000000,
2745 9.0000000000000000 },
2746 { 79.975676861303967, 2.0000000000000000, 7.0000000000000000,
2747 10.000000000000000 },
2750 // Test function for a=2.0000000000000000, c=7.0000000000000000.
2751 template <typename Tp
>
2754 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2755 Tp max_abs_diff
= -Tp(1);
2756 Tp max_abs_frac
= -Tp(1);
2757 unsigned int num_datum
= sizeof(data037
)
2758 / sizeof(testcase_conf_hyperg
<double>);
2759 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2761 const Tp f
= std::tr1::conf_hyperg(Tp(data037
[i
].a
), Tp(data037
[i
].c
),
2763 const Tp f0
= data037
[i
].f0
;
2764 const Tp diff
= f
- f0
;
2765 if (std::abs(diff
) > max_abs_diff
)
2766 max_abs_diff
= std::abs(diff
);
2767 if (std::abs(f0
) > Tp(10) * eps
2768 && std::abs(f
) > Tp(10) * eps
)
2770 const Tp frac
= diff
/ f0
;
2771 if (std::abs(frac
) > max_abs_frac
)
2772 max_abs_frac
= std::abs(frac
);
2775 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2778 // Test data for a=2.0000000000000000, c=8.0000000000000000.
2779 testcase_conf_hyperg
<double> data038
[] = {
2780 { 0.17337636610503362, 2.0000000000000000, 8.0000000000000000,
2781 -10.000000000000000 },
2782 { 0.19686670136921000, 2.0000000000000000, 8.0000000000000000,
2783 -9.0000000000000000 },
2784 { 0.22527678978110538, 2.0000000000000000, 8.0000000000000000,
2785 -8.0000000000000000 },
2786 { 0.26001525907740475, 2.0000000000000000, 8.0000000000000000,
2787 -7.0000000000000000 },
2788 { 0.30300466868014397, 2.0000000000000000, 8.0000000000000000,
2789 -6.0000000000000000 },
2790 { 0.35690946280485503, 2.0000000000000000, 8.0000000000000000,
2791 -5.0000000000000000 },
2792 { 0.42548267822218039, 2.0000000000000000, 8.0000000000000000,
2793 -4.0000000000000000 },
2794 { 0.51410215874088183, 2.0000000000000000, 8.0000000000000000,
2795 -3.0000000000000000 },
2796 { 0.63061421953299790, 2.0000000000000000, 8.0000000000000000,
2797 -2.0000000000000000 },
2798 { 0.78668452848510595, 2.0000000000000000, 8.0000000000000000,
2799 -1.0000000000000000 },
2800 { 1.0000000000000000, 2.0000000000000000, 8.0000000000000000,
2801 0.0000000000000000 },
2802 { 1.2979228320600693, 2.0000000000000000, 8.0000000000000000,
2803 1.0000000000000000 },
2804 { 1.7236644184225898, 2.0000000000000000, 8.0000000000000000,
2805 2.0000000000000000 },
2806 { 2.3469052224062485, 2.0000000000000000, 8.0000000000000000,
2807 3.0000000000000000 },
2808 { 3.2823881632022749, 2.0000000000000000, 8.0000000000000000,
2809 4.0000000000000000 },
2810 { 4.7230422799745782, 2.0000000000000000, 8.0000000000000000,
2811 5.0000000000000000 },
2812 { 7.0000000000000009, 2.0000000000000000, 8.0000000000000000,
2813 6.0000000000000000 },
2814 { 10.693145492681536, 2.0000000000000000, 8.0000000000000000,
2815 7.0000000000000000 },
2816 { 16.837993864717802, 2.0000000000000000, 8.0000000000000000,
2817 8.0000000000000000 },
2818 { 27.318786089757165, 2.0000000000000000, 8.0000000000000000,
2819 9.0000000000000000 },
2820 { 45.626379042330321, 2.0000000000000000, 8.0000000000000000,
2821 10.000000000000000 },
2824 // Test function for a=2.0000000000000000, c=8.0000000000000000.
2825 template <typename Tp
>
2828 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2829 Tp max_abs_diff
= -Tp(1);
2830 Tp max_abs_frac
= -Tp(1);
2831 unsigned int num_datum
= sizeof(data038
)
2832 / sizeof(testcase_conf_hyperg
<double>);
2833 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2835 const Tp f
= std::tr1::conf_hyperg(Tp(data038
[i
].a
), Tp(data038
[i
].c
),
2837 const Tp f0
= data038
[i
].f0
;
2838 const Tp diff
= f
- f0
;
2839 if (std::abs(diff
) > max_abs_diff
)
2840 max_abs_diff
= std::abs(diff
);
2841 if (std::abs(f0
) > Tp(10) * eps
2842 && std::abs(f
) > Tp(10) * eps
)
2844 const Tp frac
= diff
/ f0
;
2845 if (std::abs(frac
) > max_abs_frac
)
2846 max_abs_frac
= std::abs(frac
);
2849 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2852 // Test data for a=2.0000000000000000, c=9.0000000000000000.
2853 testcase_conf_hyperg
<double> data039
[] = {
2854 { 0.20263008881072142, 2.0000000000000000, 9.0000000000000000,
2855 -10.000000000000000 },
2856 { 0.22815601647956382, 2.0000000000000000, 9.0000000000000000,
2857 -9.0000000000000000 },
2858 { 0.25863201094881560, 2.0000000000000000, 9.0000000000000000,
2859 -8.0000000000000000 },
2860 { 0.29536583498165569, 2.0000000000000000, 9.0000000000000000,
2861 -7.0000000000000000 },
2862 { 0.34010436746201422, 2.0000000000000000, 9.0000000000000000,
2863 -6.0000000000000000 },
2864 { 0.39521257401334392, 2.0000000000000000, 9.0000000000000000,
2865 -5.0000000000000000 },
2866 { 0.46393810791120338, 2.0000000000000000, 9.0000000000000000,
2867 -4.0000000000000000 },
2868 { 0.55080841854553553, 2.0000000000000000, 9.0000000000000000,
2869 -3.0000000000000000 },
2870 { 0.66223601210150940, 2.0000000000000000, 9.0000000000000000,
2871 -2.0000000000000000 },
2872 { 0.80745573956474603, 2.0000000000000000, 9.0000000000000000,
2873 -1.0000000000000000 },
2874 { 1.0000000000000000, 2.0000000000000000, 9.0000000000000000,
2875 0.0000000000000000 },
2876 { 1.2600591877766618, 2.0000000000000000, 9.0000000000000000,
2877 1.0000000000000000 },
2878 { 1.6183220921129462, 2.0000000000000000, 9.0000000000000000,
2879 2.0000000000000000 },
2880 { 2.1223296796666578, 2.0000000000000000, 9.0000000000000000,
2881 3.0000000000000000 },
2882 { 2.8471644896068233, 2.0000000000000000, 9.0000000000000000,
2883 4.0000000000000000 },
2884 { 3.9137352959186495, 2.0000000000000000, 9.0000000000000000,
2885 5.0000000000000000 },
2886 { 5.5205708009288541, 2.0000000000000000, 9.0000000000000000,
2887 6.0000000000000000 },
2888 { 7.9999999999999982, 2.0000000000000000, 9.0000000000000000,
2889 7.0000000000000000 },
2890 { 11.918996932358892, 2.0000000000000000, 9.0000000000000000,
2891 8.0000000000000000 },
2892 { 18.262984349485706, 2.0000000000000000, 9.0000000000000000,
2893 9.0000000000000000 },
2894 { 28.775827425398138, 2.0000000000000000, 9.0000000000000000,
2895 10.000000000000000 },
2898 // Test function for a=2.0000000000000000, c=9.0000000000000000.
2899 template <typename Tp
>
2902 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2903 Tp max_abs_diff
= -Tp(1);
2904 Tp max_abs_frac
= -Tp(1);
2905 unsigned int num_datum
= sizeof(data039
)
2906 / sizeof(testcase_conf_hyperg
<double>);
2907 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2909 const Tp f
= std::tr1::conf_hyperg(Tp(data039
[i
].a
), Tp(data039
[i
].c
),
2911 const Tp f0
= data039
[i
].f0
;
2912 const Tp diff
= f
- f0
;
2913 if (std::abs(diff
) > max_abs_diff
)
2914 max_abs_diff
= std::abs(diff
);
2915 if (std::abs(f0
) > Tp(10) * eps
2916 && std::abs(f
) > Tp(10) * eps
)
2918 const Tp frac
= diff
/ f0
;
2919 if (std::abs(frac
) > max_abs_frac
)
2920 max_abs_frac
= std::abs(frac
);
2923 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
2926 // Test data for a=2.0000000000000000, c=10.000000000000000.
2927 testcase_conf_hyperg
<double> data040
[] = {
2928 { 0.23043485654507717, 2.0000000000000000, 10.000000000000000,
2929 -10.000000000000000 },
2930 { 0.25758423249046342, 2.0000000000000000, 10.000000000000000,
2931 -9.0000000000000000 },
2932 { 0.28964158686142122, 2.0000000000000000, 10.000000000000000,
2933 -8.0000000000000000 },
2934 { 0.32781237017833142, 2.0000000000000000, 10.000000000000000,
2935 -7.0000000000000000 },
2936 { 0.37367756025366927, 2.0000000000000000, 10.000000000000000,
2937 -6.0000000000000000 },
2938 { 0.42933548067397925, 2.0000000000000000, 10.000000000000000,
2939 -5.0000000000000000 },
2940 { 0.49760646239977369, 2.0000000000000000, 10.000000000000000,
2941 -4.0000000000000000 },
2942 { 0.58233221879973318, 2.0000000000000000, 10.000000000000000,
2943 -3.0000000000000000 },
2944 { 0.68881993949245379, 2.0000000000000000, 10.000000000000000,
2945 -2.0000000000000000 },
2946 { 0.82451063690694526, 2.0000000000000000, 10.000000000000000,
2947 -1.0000000000000000 },
2948 { 1.0000000000000000, 2.0000000000000000, 10.000000000000000,
2949 0.0000000000000000 },
2950 { 1.2306214716549471, 2.0000000000000000, 10.000000000000000,
2951 1.0000000000000000 },
2952 { 1.5389392974099088, 2.0000000000000000, 10.000000000000000,
2953 2.0000000000000000 },
2954 { 1.9587362987499699, 2.0000000000000000, 10.000000000000000,
2955 3.0000000000000000 },
2956 { 2.5414934688204727, 2.0000000000000000, 10.000000000000000,
2957 4.0000000000000000 },
2958 { 3.3670852989803555, 2.0000000000000000, 10.000000000000000,
2959 5.0000000000000000 },
2960 { 4.5617124027865650, 2.0000000000000000, 10.000000000000000,
2961 6.0000000000000000 },
2962 { 6.3284392760597825, 2.0000000000000000, 10.000000000000000,
2963 7.0000000000000000 },
2964 { 9.0000000000000036, 2.0000000000000000, 10.000000000000000,
2965 8.0000000000000000 },
2966 { 13.131492174742865, 2.0000000000000000, 10.000000000000000,
2967 9.0000000000000000 },
2968 { 19.665496455238888, 2.0000000000000000, 10.000000000000000,
2969 10.000000000000000 },
2972 // Test function for a=2.0000000000000000, c=10.000000000000000.
2973 template <typename Tp
>
2976 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
2977 Tp max_abs_diff
= -Tp(1);
2978 Tp max_abs_frac
= -Tp(1);
2979 unsigned int num_datum
= sizeof(data040
)
2980 / sizeof(testcase_conf_hyperg
<double>);
2981 for (unsigned int i
= 0; i
< num_datum
; ++i
)
2983 const Tp f
= std::tr1::conf_hyperg(Tp(data040
[i
].a
), Tp(data040
[i
].c
),
2985 const Tp f0
= data040
[i
].f0
;
2986 const Tp diff
= f
- f0
;
2987 if (std::abs(diff
) > max_abs_diff
)
2988 max_abs_diff
= std::abs(diff
);
2989 if (std::abs(f0
) > Tp(10) * eps
2990 && std::abs(f
) > Tp(10) * eps
)
2992 const Tp frac
= diff
/ f0
;
2993 if (std::abs(frac
) > max_abs_frac
)
2994 max_abs_frac
= std::abs(frac
);
2997 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
3000 // Test data for a=5.0000000000000000, c=1.0000000000000000.
3001 testcase_conf_hyperg
<double> data041
[] = {
3002 { 0.00049939922738733355, 5.0000000000000000, 1.0000000000000000,
3003 -10.000000000000000 },
3004 { -0.00057077034390089253, 5.0000000000000000, 1.0000000000000000,
3005 -9.0000000000000000 },
3006 { -0.0032428054030576147, 5.0000000000000000, 1.0000000000000000,
3007 -8.0000000000000000 },
3008 { -0.0078649819529077025, 5.0000000000000000, 1.0000000000000000,
3009 -7.0000000000000000 },
3010 { -0.012393760883331793, 5.0000000000000000, 1.0000000000000000,
3011 -6.0000000000000000 },
3012 { -0.0087031815404853934, 5.0000000000000000, 1.0000000000000000,
3013 -5.0000000000000000 },
3014 { 0.018315638888832021, 5.0000000000000000, 1.0000000000000000,
3015 -4.0000000000000000 },
3016 { 0.068457219005814696, 5.0000000000000000, 1.0000000000000000,
3017 -3.0000000000000000 },
3018 { 0.045111761078875295, 5.0000000000000000, 1.0000000000000000,
3019 -2.0000000000000000 },
3020 { -0.22992465073215118, 5.0000000000000000, 1.0000000000000000,
3021 -1.0000000000000000 },
3022 { 1.0000000000000000, 5.0000000000000000, 1.0000000000000000,
3023 0.0000000000000000 },
3024 { 23.671704256164183, 5.0000000000000000, 1.0000000000000000,
3025 1.0000000000000000 },
3026 { 199.50451467112745, 5.0000000000000000, 1.0000000000000000,
3027 2.0000000000000000 },
3028 { 1232.7498286606428, 5.0000000000000000, 1.0000000000000000,
3029 3.0000000000000000 },
3030 { 6460.7810872554019, 5.0000000000000000, 1.0000000000000000,
3031 4.0000000000000000 },
3032 { 30480.352550691667, 5.0000000000000000, 1.0000000000000000,
3033 5.0000000000000000 },
3034 { 133534.93064609534, 5.0000000000000000, 1.0000000000000000,
3035 6.0000000000000000 },
3036 { 553479.89366849652, 5.0000000000000000, 1.0000000000000000,
3037 7.0000000000000000 },
3038 { 2196966.0364497532, 5.0000000000000000, 1.0000000000000000,
3039 8.0000000000000000 },
3040 { 8422142.8572236635, 5.0000000000000000, 1.0000000000000000,
3041 9.0000000000000000 },
3042 { 31373029.447069697, 5.0000000000000000, 1.0000000000000000,
3043 10.000000000000000 },
3046 // Test function for a=5.0000000000000000, c=1.0000000000000000.
3047 template <typename Tp
>
3050 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3051 Tp max_abs_diff
= -Tp(1);
3052 Tp max_abs_frac
= -Tp(1);
3053 unsigned int num_datum
= sizeof(data041
)
3054 / sizeof(testcase_conf_hyperg
<double>);
3055 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3057 const Tp f
= std::tr1::conf_hyperg(Tp(data041
[i
].a
), Tp(data041
[i
].c
),
3059 const Tp f0
= data041
[i
].f0
;
3060 const Tp diff
= f
- f0
;
3061 if (std::abs(diff
) > max_abs_diff
)
3062 max_abs_diff
= std::abs(diff
);
3063 if (std::abs(f0
) > Tp(10) * eps
3064 && std::abs(f
) > Tp(10) * eps
)
3066 const Tp frac
= diff
/ f0
;
3067 if (std::abs(frac
) > max_abs_frac
)
3068 max_abs_frac
= std::abs(frac
);
3071 VERIFY(max_abs_frac
< Tp(5.0000000000000034e-10));
3074 // Test data for a=5.0000000000000000, c=2.0000000000000000.
3075 testcase_conf_hyperg
<double> data042
[] = {
3076 { -0.00025726626865408083, 5.0000000000000000, 2.0000000000000000,
3077 -10.000000000000000 },
3078 { -0.00029309828470586396, 5.0000000000000000, 2.0000000000000000,
3079 -9.0000000000000000 },
3080 { -0.00011182087596750395, 5.0000000000000000, 2.0000000000000000,
3081 -8.0000000000000000 },
3082 { 0.00064591639226778245, 5.0000000000000000, 2.0000000000000000,
3083 -7.0000000000000000 },
3084 { 0.0024787521766663585, 5.0000000000000000, 2.0000000000000000,
3085 -6.0000000000000000 },
3086 { 0.0053342080409426616, 5.0000000000000000, 2.0000000000000000,
3087 -5.0000000000000000 },
3088 { 0.0061052129629022966, 5.0000000000000000, 2.0000000000000000,
3089 -4.0000000000000000 },
3090 { -0.0062233835459823200, 5.0000000000000000, 2.0000000000000000,
3091 -3.0000000000000000 },
3092 { -0.045111761078871798, 5.0000000000000000, 2.0000000000000000,
3093 -2.0000000000000000 },
3094 { -0.015328310048810216, 5.0000000000000000, 2.0000000000000000,
3095 -1.0000000000000000 },
3096 { 1.0000000000000000, 5.0000000000000000, 2.0000000000000000,
3097 0.0000000000000000 },
3098 { 8.2681072282295975, 5.0000000000000000, 2.0000000000000000,
3099 1.0000000000000000 },
3100 { 46.797355293227440, 5.0000000000000000, 2.0000000000000000,
3101 2.0000000000000000 },
3102 { 223.45159827046285, 5.0000000000000000, 2.0000000000000000,
3103 3.0000000000000000 },
3104 { 964.56731725221459, 5.0000000000000000, 2.0000000000000000,
3105 4.0000000000000000 },
3106 { 3889.6615448133625, 5.0000000000000000, 2.0000000000000000,
3107 5.0000000000000000 },
3108 { 14926.865359231202, 5.0000000000000000, 2.0000000000000000,
3109 6.0000000000000000 },
3110 { 55151.509259297891, 5.0000000000000000, 2.0000000000000000,
3111 7.0000000000000000 },
3112 { 197736.87980710136, 5.0000000000000000, 2.0000000000000000,
3113 8.0000000000000000 },
3114 { 691800.79031674843, 5.0000000000000000, 2.0000000000000000,
3115 9.0000000000000000 },
3116 { 2371516.1505741901, 5.0000000000000000, 2.0000000000000000,
3117 10.000000000000000 },
3120 // Test function for a=5.0000000000000000, c=2.0000000000000000.
3121 template <typename Tp
>
3124 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3125 Tp max_abs_diff
= -Tp(1);
3126 Tp max_abs_frac
= -Tp(1);
3127 unsigned int num_datum
= sizeof(data042
)
3128 / sizeof(testcase_conf_hyperg
<double>);
3129 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3131 const Tp f
= std::tr1::conf_hyperg(Tp(data042
[i
].a
), Tp(data042
[i
].c
),
3133 const Tp f0
= data042
[i
].f0
;
3134 const Tp diff
= f
- f0
;
3135 if (std::abs(diff
) > max_abs_diff
)
3136 max_abs_diff
= std::abs(diff
);
3137 if (std::abs(f0
) > Tp(10) * eps
3138 && std::abs(f
) > Tp(10) * eps
)
3140 const Tp frac
= diff
/ f0
;
3141 if (std::abs(frac
) > max_abs_frac
)
3142 max_abs_frac
= std::abs(frac
);
3145 VERIFY(max_abs_frac
< Tp(1.0000000000000006e-10));
3148 // Test data for a=5.0000000000000000, c=3.0000000000000000.
3149 testcase_conf_hyperg
<double> data043
[] = {
3150 { 0.00012106647936662629, 5.0000000000000000, 3.0000000000000000,
3151 -10.000000000000000 },
3152 { 0.00021596715715168925, 5.0000000000000000, 3.0000000000000000,
3153 -9.0000000000000000 },
3154 { 0.00033546262790251185, 5.0000000000000000, 3.0000000000000000,
3155 -8.0000000000000000 },
3156 { 0.00037995081898104839, 5.0000000000000000, 3.0000000000000000,
3157 -7.0000000000000000 },
3158 { 0.0000000000000000, 5.0000000000000000, 3.0000000000000000,
3159 -6.0000000000000000 },
3160 { -0.0016844867497713672, 5.0000000000000000, 3.0000000000000000,
3161 -5.0000000000000000 },
3162 { -0.0061052129629113917, 5.0000000000000000, 3.0000000000000000,
3163 -4.0000000000000000 },
3164 { -0.012446767091965986, 5.0000000000000000, 3.0000000000000000,
3165 -3.0000000000000000 },
3166 { 7.5126173746727200e-18, 5.0000000000000000, 3.0000000000000000,
3167 -2.0000000000000000 },
3168 { 0.15328310048810098, 5.0000000000000000, 3.0000000000000000,
3169 -1.0000000000000000 },
3170 { 1.0000000000000000, 5.0000000000000000, 3.0000000000000000,
3171 0.0000000000000000 },
3172 { 4.7569931998033290, 5.0000000000000000, 3.0000000000000000,
3173 1.0000000000000000 },
3174 { 19.704149597148401, 5.0000000000000000, 3.0000000000000000,
3175 2.0000000000000000 },
3176 { 75.320763461953760, 5.0000000000000000, 3.0000000000000000,
3177 3.0000000000000000 },
3178 { 272.99075016572118, 5.0000000000000000, 3.0000000000000000,
3179 4.0000000000000000 },
3180 { 952.31777090819992, 5.0000000000000000, 3.0000000000000000,
3181 5.0000000000000000 },
3182 { 3227.4303479418809, 5.0000000000000000, 3.0000000000000000,
3183 6.0000000000000000 },
3184 { 10692.173294677470, 5.0000000000000000, 3.0000000000000000,
3185 7.0000000000000000 },
3186 { 34777.843182153498, 5.0000000000000000, 3.0000000000000000,
3187 8.0000000000000000 },
3188 { 111417.40400416154, 5.0000000000000000, 3.0000000000000000,
3189 9.0000000000000000 },
3190 { 352423.45271690749, 5.0000000000000000, 3.0000000000000000,
3191 10.000000000000000 },
3194 // Test function for a=5.0000000000000000, c=3.0000000000000000.
3195 template <typename Tp
>
3198 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3199 Tp max_abs_diff
= -Tp(1);
3200 Tp max_abs_frac
= -Tp(1);
3201 unsigned int num_datum
= sizeof(data043
)
3202 / sizeof(testcase_conf_hyperg
<double>);
3203 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3205 const Tp f
= std::tr1::conf_hyperg(Tp(data043
[i
].a
), Tp(data043
[i
].c
),
3207 const Tp f0
= data043
[i
].f0
;
3208 const Tp diff
= f
- f0
;
3209 if (std::abs(diff
) > max_abs_diff
)
3210 max_abs_diff
= std::abs(diff
);
3211 if (std::abs(f0
) > Tp(10) * eps
3212 && std::abs(f
) > Tp(10) * eps
)
3214 const Tp frac
= diff
/ f0
;
3215 if (std::abs(frac
) > max_abs_frac
)
3216 max_abs_frac
= std::abs(frac
);
3219 VERIFY(max_abs_frac
< Tp(5.0000000000000028e-11));
3222 // Test data for a=5.0000000000000000, c=4.0000000000000000.
3223 testcase_conf_hyperg
<double> data044
[] = {
3224 { -6.8099894643727278e-05, 5.0000000000000000, 4.0000000000000000,
3225 -10.000000000000000 },
3226 { -0.00015426225510834944, 5.0000000000000000, 4.0000000000000000,
3227 -9.0000000000000000 },
3228 { -0.00033546262790251185, 5.0000000000000000, 4.0000000000000000,
3229 -8.0000000000000000 },
3230 { -0.00068391147416588716, 5.0000000000000000, 4.0000000000000000,
3231 -7.0000000000000000 },
3232 { -0.0012393760883331792, 5.0000000000000000, 4.0000000000000000,
3233 -6.0000000000000000 },
3234 { -0.0016844867497713668, 5.0000000000000000, 4.0000000000000000,
3235 -5.0000000000000000 },
3236 { 0.0000000000000000, 5.0000000000000000, 4.0000000000000000,
3237 -4.0000000000000000 },
3238 { 0.012446767091965986, 5.0000000000000000, 4.0000000000000000,
3239 -3.0000000000000000 },
3240 { 0.067667641618306351, 5.0000000000000000, 4.0000000000000000,
3241 -2.0000000000000000 },
3242 { 0.27590958087858175, 5.0000000000000000, 4.0000000000000000,
3243 -1.0000000000000000 },
3244 { 1.0000000000000000, 5.0000000000000000, 4.0000000000000000,
3245 0.0000000000000000 },
3246 { 3.3978522855738063, 5.0000000000000000, 4.0000000000000000,
3247 1.0000000000000000 },
3248 { 11.083584148395975, 5.0000000000000000, 4.0000000000000000,
3249 2.0000000000000000 },
3250 { 35.149689615578417, 5.0000000000000000, 4.0000000000000000,
3251 3.0000000000000000 },
3252 { 109.19630006628847, 5.0000000000000000, 4.0000000000000000,
3253 4.0000000000000000 },
3254 { 333.92960798079736, 5.0000000000000000, 4.0000000000000000,
3255 5.0000000000000000 },
3256 { 1008.5719837318378, 5.0000000000000000, 4.0000000000000000,
3257 6.0000000000000000 },
3258 { 3015.7411856782610, 5.0000000000000000, 4.0000000000000000,
3259 7.0000000000000000 },
3260 { 8942.8739611251840, 5.0000000000000000, 4.0000000000000000,
3261 8.0000000000000000 },
3262 { 26335.022764620000, 5.0000000000000000, 4.0000000000000000,
3263 9.0000000000000000 },
3264 { 77092.630281823513, 5.0000000000000000, 4.0000000000000000,
3265 10.000000000000000 },
3268 // Test function for a=5.0000000000000000, c=4.0000000000000000.
3269 template <typename Tp
>
3272 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3273 Tp max_abs_diff
= -Tp(1);
3274 Tp max_abs_frac
= -Tp(1);
3275 unsigned int num_datum
= sizeof(data044
)
3276 / sizeof(testcase_conf_hyperg
<double>);
3277 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3279 const Tp f
= std::tr1::conf_hyperg(Tp(data044
[i
].a
), Tp(data044
[i
].c
),
3281 const Tp f0
= data044
[i
].f0
;
3282 const Tp diff
= f
- f0
;
3283 if (std::abs(diff
) > max_abs_diff
)
3284 max_abs_diff
= std::abs(diff
);
3285 if (std::abs(f0
) > Tp(10) * eps
3286 && std::abs(f
) > Tp(10) * eps
)
3288 const Tp frac
= diff
/ f0
;
3289 if (std::abs(frac
) > max_abs_frac
)
3290 max_abs_frac
= std::abs(frac
);
3293 VERIFY(max_abs_frac
< Tp(2.5000000000000014e-11));
3296 // Test data for a=5.0000000000000000, c=5.0000000000000000.
3297 testcase_conf_hyperg
<double> data045
[] = {
3298 { 4.5399929762484854e-05, 5.0000000000000000, 5.0000000000000000,
3299 -10.000000000000000 },
3300 { 0.00012340980408667956, 5.0000000000000000, 5.0000000000000000,
3301 -9.0000000000000000 },
3302 { 0.00033546262790251185, 5.0000000000000000, 5.0000000000000000,
3303 -8.0000000000000000 },
3304 { 0.00091188196555451624, 5.0000000000000000, 5.0000000000000000,
3305 -7.0000000000000000 },
3306 { 0.0024787521766663585, 5.0000000000000000, 5.0000000000000000,
3307 -6.0000000000000000 },
3308 { 0.0067379469990854670, 5.0000000000000000, 5.0000000000000000,
3309 -5.0000000000000000 },
3310 { 0.018315638888734179, 5.0000000000000000, 5.0000000000000000,
3311 -4.0000000000000000 },
3312 { 0.049787068367863944, 5.0000000000000000, 5.0000000000000000,
3313 -3.0000000000000000 },
3314 { 0.13533528323661270, 5.0000000000000000, 5.0000000000000000,
3315 -2.0000000000000000 },
3316 { 0.36787944117144233, 5.0000000000000000, 5.0000000000000000,
3317 -1.0000000000000000 },
3318 { 1.0000000000000000, 5.0000000000000000, 5.0000000000000000,
3319 0.0000000000000000 },
3320 { 2.7182818284590451, 5.0000000000000000, 5.0000000000000000,
3321 1.0000000000000000 },
3322 { 7.3890560989306504, 5.0000000000000000, 5.0000000000000000,
3323 2.0000000000000000 },
3324 { 20.085536923187668, 5.0000000000000000, 5.0000000000000000,
3325 3.0000000000000000 },
3326 { 54.598150033144236, 5.0000000000000000, 5.0000000000000000,
3327 4.0000000000000000 },
3328 { 148.41315910257660, 5.0000000000000000, 5.0000000000000000,
3329 5.0000000000000000 },
3330 { 403.42879349273511, 5.0000000000000000, 5.0000000000000000,
3331 6.0000000000000000 },
3332 { 1096.6331584284585, 5.0000000000000000, 5.0000000000000000,
3333 7.0000000000000000 },
3334 { 2980.9579870417283, 5.0000000000000000, 5.0000000000000000,
3335 8.0000000000000000 },
3336 { 8103.0839275753842, 5.0000000000000000, 5.0000000000000000,
3337 9.0000000000000000 },
3338 { 22026.465794806718, 5.0000000000000000, 5.0000000000000000,
3339 10.000000000000000 },
3342 // Test function for a=5.0000000000000000, c=5.0000000000000000.
3343 template <typename Tp
>
3346 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3347 Tp max_abs_diff
= -Tp(1);
3348 Tp max_abs_frac
= -Tp(1);
3349 unsigned int num_datum
= sizeof(data045
)
3350 / sizeof(testcase_conf_hyperg
<double>);
3351 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3353 const Tp f
= std::tr1::conf_hyperg(Tp(data045
[i
].a
), Tp(data045
[i
].c
),
3355 const Tp f0
= data045
[i
].f0
;
3356 const Tp diff
= f
- f0
;
3357 if (std::abs(diff
) > max_abs_diff
)
3358 max_abs_diff
= std::abs(diff
);
3359 if (std::abs(f0
) > Tp(10) * eps
3360 && std::abs(f
) > Tp(10) * eps
)
3362 const Tp frac
= diff
/ f0
;
3363 if (std::abs(frac
) > max_abs_frac
)
3364 max_abs_frac
= std::abs(frac
);
3367 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
3370 // Test data for a=5.0000000000000000, c=6.0000000000000000.
3371 testcase_conf_hyperg
<double> data046
[] = {
3372 { 0.0011648967743076431, 5.0000000000000000, 6.0000000000000000,
3373 -10.000000000000000 },
3374 { 0.0019205128456127479, 5.0000000000000000, 6.0000000000000000,
3375 -9.0000000000000000 },
3376 { 0.0032972446271226320, 5.0000000000000000, 6.0000000000000000,
3377 -8.0000000000000000 },
3378 { 0.0059047424914709006, 5.0000000000000000, 6.0000000000000000,
3379 -7.0000000000000000 },
3380 { 0.011033078698817415, 5.0000000000000000, 6.0000000000000000,
3381 -6.0000000000000000 },
3382 { 0.021485057853495842, 5.0000000000000000, 6.0000000000000000,
3383 -5.0000000000000000 },
3384 { 0.043495671658608563, 5.0000000000000000, 6.0000000000000000,
3385 -4.0000000000000000 },
3386 { 0.091228027395668113, 5.0000000000000000, 6.0000000000000000,
3387 -3.0000000000000000 },
3388 { 0.19744881503891684, 5.0000000000000000, 6.0000000000000000,
3389 -2.0000000000000000 },
3390 { 0.43918161928124549, 5.0000000000000000, 6.0000000000000000,
3391 -1.0000000000000000 },
3392 { 1.0000000000000000, 5.0000000000000000, 6.0000000000000000,
3393 0.0000000000000000 },
3394 { 2.3226822806570353, 5.0000000000000000, 6.0000000000000000,
3395 1.0000000000000000 },
3396 { 5.4863201236633126, 5.0000000000000000, 6.0000000000000000,
3397 2.0000000000000000 },
3398 { 13.144500379942246, 5.0000000000000000, 6.0000000000000000,
3399 3.0000000000000000 },
3400 { 31.873916035045447, 5.0000000000000000, 6.0000000000000000,
3401 4.0000000000000000 },
3402 { 78.086286951596321, 5.0000000000000000, 6.0000000000000000,
3403 5.0000000000000000 },
3404 { 192.98291046720354, 5.0000000000000000, 6.0000000000000000,
3405 6.0000000000000000 },
3406 { 480.54877204888402, 5.0000000000000000, 6.0000000000000000,
3407 7.0000000000000000 },
3408 { 1204.4605636118313, 5.0000000000000000, 6.0000000000000000,
3409 8.0000000000000000 },
3410 { 3036.1329048350581, 5.0000000000000000, 6.0000000000000000,
3411 9.0000000000000000 },
3412 { 7691.6406555465064, 5.0000000000000000, 6.0000000000000000,
3413 10.000000000000000 },
3416 // Test function for a=5.0000000000000000, c=6.0000000000000000.
3417 template <typename Tp
>
3420 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3421 Tp max_abs_diff
= -Tp(1);
3422 Tp max_abs_frac
= -Tp(1);
3423 unsigned int num_datum
= sizeof(data046
)
3424 / sizeof(testcase_conf_hyperg
<double>);
3425 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3427 const Tp f
= std::tr1::conf_hyperg(Tp(data046
[i
].a
), Tp(data046
[i
].c
),
3429 const Tp f0
= data046
[i
].f0
;
3430 const Tp diff
= f
- f0
;
3431 if (std::abs(diff
) > max_abs_diff
)
3432 max_abs_diff
= std::abs(diff
);
3433 if (std::abs(f0
) > Tp(10) * eps
3434 && std::abs(f
) > Tp(10) * eps
)
3436 const Tp frac
= diff
/ f0
;
3437 if (std::abs(frac
) > max_abs_frac
)
3438 max_abs_frac
= std::abs(frac
);
3441 VERIFY(max_abs_frac
< Tp(1.0000000000000006e-11));
3444 // Test data for a=5.0000000000000000, c=7.0000000000000000.
3445 testcase_conf_hyperg
<double> data047
[] = {
3446 { 0.0036308901122103932, 5.0000000000000000, 7.0000000000000000,
3447 -10.000000000000000 },
3448 { 0.0055327336019229401, 5.0000000000000000, 7.0000000000000000,
3449 -9.0000000000000000 },
3450 { 0.0086767852656603455, 5.0000000000000000, 7.0000000000000000,
3451 -8.0000000000000000 },
3452 { 0.014030481266326614, 5.0000000000000000, 7.0000000000000000,
3453 -7.0000000000000000 },
3454 { 0.023426839582149212, 5.0000000000000000, 7.0000000000000000,
3455 -6.0000000000000000 },
3456 { 0.040427681994512799, 5.0000000000000000, 7.0000000000000000,
3457 -5.0000000000000000 },
3458 { 0.072123784177593755, 5.0000000000000000, 7.0000000000000000,
3459 -4.0000000000000000 },
3460 { 0.13295857409596740, 5.0000000000000000, 7.0000000000000000,
3461 -3.0000000000000000 },
3462 { 0.25298991319893882, 5.0000000000000000, 7.0000000000000000,
3463 -2.0000000000000000 },
3464 { 0.49602437239337821, 5.0000000000000000, 7.0000000000000000,
3465 -1.0000000000000000 },
3466 { 1.0000000000000000, 5.0000000000000000, 7.0000000000000000,
3467 0.0000000000000000 },
3468 { 2.0681072498819240, 5.0000000000000000, 7.0000000000000000,
3469 1.0000000000000000 },
3470 { 4.3768811129698140, 5.0000000000000000, 7.0000000000000000,
3471 2.0000000000000000 },
3472 { 9.4566368471992224, 5.0000000000000000, 7.0000000000000000,
3473 3.0000000000000000 },
3474 { 20.811741224531826, 5.0000000000000000, 7.0000000000000000,
3475 4.0000000000000000 },
3476 { 46.556488803696276, 5.0000000000000000, 7.0000000000000000,
3477 5.0000000000000000 },
3478 { 105.66804767556316, 5.0000000000000000, 7.0000000000000000,
3479 6.0000000000000000 },
3480 { 242.93097638084427, 5.0000000000000000, 7.0000000000000000,
3481 7.0000000000000000 },
3482 { 564.89804380887358, 5.0000000000000000, 7.0000000000000000,
3483 8.0000000000000000 },
3484 { 1326.9606865425994, 5.0000000000000000, 7.0000000000000000,
3485 9.0000000000000000 },
3486 { 3145.3685154983909, 5.0000000000000000, 7.0000000000000000,
3487 10.000000000000000 },
3490 // Test function for a=5.0000000000000000, c=7.0000000000000000.
3491 template <typename Tp
>
3494 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3495 Tp max_abs_diff
= -Tp(1);
3496 Tp max_abs_frac
= -Tp(1);
3497 unsigned int num_datum
= sizeof(data047
)
3498 / sizeof(testcase_conf_hyperg
<double>);
3499 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3501 const Tp f
= std::tr1::conf_hyperg(Tp(data047
[i
].a
), Tp(data047
[i
].c
),
3503 const Tp f0
= data047
[i
].f0
;
3504 const Tp diff
= f
- f0
;
3505 if (std::abs(diff
) > max_abs_diff
)
3506 max_abs_diff
= std::abs(diff
);
3507 if (std::abs(f0
) > Tp(10) * eps
3508 && std::abs(f
) > Tp(10) * eps
)
3510 const Tp frac
= diff
/ f0
;
3511 if (std::abs(frac
) > max_abs_frac
)
3512 max_abs_frac
= std::abs(frac
);
3515 VERIFY(max_abs_frac
< Tp(5.0000000000000029e-12));
3518 // Test data for a=5.0000000000000000, c=8.0000000000000000.
3519 testcase_conf_hyperg
<double> data048
[] = {
3520 { 0.0075295293831406122, 5.0000000000000000, 8.0000000000000000,
3521 -10.000000000000000 },
3522 { 0.010936052508673187, 5.0000000000000000, 8.0000000000000000,
3523 -9.0000000000000000 },
3524 { 0.016247454253649721, 5.0000000000000000, 8.0000000000000000,
3525 -8.0000000000000000 },
3526 { 0.024729468107576008, 5.0000000000000000, 8.0000000000000000,
3527 -7.0000000000000000 },
3528 { 0.038615775445860964, 5.0000000000000000, 8.0000000000000000,
3529 -6.0000000000000000 },
3530 { 0.061937865588523586, 5.0000000000000000, 8.0000000000000000,
3531 -5.0000000000000000 },
3532 { 0.10213565389690644, 5.0000000000000000, 8.0000000000000000,
3533 -4.0000000000000000 },
3534 { 0.17324118243379236, 5.0000000000000000, 8.0000000000000000,
3535 -3.0000000000000000 },
3536 { 0.30228316551605494, 5.0000000000000000, 8.0000000000000000,
3537 -2.0000000000000000 },
3538 { 0.54238748802203829, 5.0000000000000000, 8.0000000000000000,
3539 -1.0000000000000000 },
3540 { 1.0000000000000000, 5.0000000000000000, 8.0000000000000000,
3541 0.0000000000000000 },
3542 { 1.8922997283093959, 5.0000000000000000, 8.0000000000000000,
3543 1.0000000000000000 },
3544 { 3.6699742831126270, 5.0000000000000000, 8.0000000000000000,
3545 2.0000000000000000 },
3546 { 7.2831842359960941, 5.0000000000000000, 8.0000000000000000,
3547 3.0000000000000000 },
3548 { 14.764676530664770, 5.0000000000000000, 8.0000000000000000,
3549 4.0000000000000000 },
3550 { 30.522558591756702, 5.0000000000000000, 8.0000000000000000,
3551 5.0000000000000000 },
3552 { 64.236147093730224, 5.0000000000000000, 8.0000000000000000,
3553 6.0000000000000000 },
3554 { 137.40503032883328, 5.0000000000000000, 8.0000000000000000,
3555 7.0000000000000000 },
3556 { 298.29153884828759, 5.0000000000000000, 8.0000000000000000,
3557 8.0000000000000000 },
3558 { 656.29389355002741, 5.0000000000000000, 8.0000000000000000,
3559 9.0000000000000000 },
3560 { 1461.6183101433730, 5.0000000000000000, 8.0000000000000000,
3561 10.000000000000000 },
3564 // Test function for a=5.0000000000000000, c=8.0000000000000000.
3565 template <typename Tp
>
3568 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3569 Tp max_abs_diff
= -Tp(1);
3570 Tp max_abs_frac
= -Tp(1);
3571 unsigned int num_datum
= sizeof(data048
)
3572 / sizeof(testcase_conf_hyperg
<double>);
3573 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3575 const Tp f
= std::tr1::conf_hyperg(Tp(data048
[i
].a
), Tp(data048
[i
].c
),
3577 const Tp f0
= data048
[i
].f0
;
3578 const Tp diff
= f
- f0
;
3579 if (std::abs(diff
) > max_abs_diff
)
3580 max_abs_diff
= std::abs(diff
);
3581 if (std::abs(f0
) > Tp(10) * eps
3582 && std::abs(f
) > Tp(10) * eps
)
3584 const Tp frac
= diff
/ f0
;
3585 if (std::abs(frac
) > max_abs_frac
)
3586 max_abs_frac
= std::abs(frac
);
3589 VERIFY(max_abs_frac
< Tp(2.5000000000000015e-12));
3592 // Test data for a=5.0000000000000000, c=9.0000000000000000.
3593 testcase_conf_hyperg
<double> data049
[] = {
3594 { 0.012801285049305222, 5.0000000000000000, 9.0000000000000000,
3595 -10.000000000000000 },
3596 { 0.017955923031350202, 5.0000000000000000, 9.0000000000000000,
3597 -9.0000000000000000 },
3598 { 0.025661650371090718, 5.0000000000000000, 9.0000000000000000,
3599 -8.0000000000000000 },
3600 { 0.037414616710204310, 5.0000000000000000, 9.0000000000000000,
3601 -7.0000000000000000 },
3602 { 0.055720934057414885, 5.0000000000000000, 9.0000000000000000,
3603 -6.0000000000000000 },
3604 { 0.084862956151755986, 5.0000000000000000, 9.0000000000000000,
3605 -5.0000000000000000 },
3606 { 0.13230635170162319, 5.0000000000000000, 9.0000000000000000,
3607 -4.0000000000000000 },
3608 { 0.21132914572142125, 5.0000000000000000, 9.0000000000000000,
3609 -3.0000000000000000 },
3610 { 0.34601808641639625, 5.0000000000000000, 9.0000000000000000,
3611 -2.0000000000000000 },
3612 { 0.58092180965710882, 5.0000000000000000, 9.0000000000000000,
3613 -1.0000000000000000 },
3614 { 1.0000000000000000, 5.0000000000000000, 9.0000000000000000,
3615 0.0000000000000000 },
3616 { 1.7643922061378634, 5.0000000000000000, 9.0000000000000000,
3617 1.0000000000000000 },
3618 { 3.1888010096332451, 5.0000000000000000, 9.0000000000000000,
3619 2.0000000000000000 },
3620 { 5.8981194929479273, 5.0000000000000000, 9.0000000000000000,
3621 3.0000000000000000 },
3622 { 11.152835510393174, 5.0000000000000000, 9.0000000000000000,
3623 4.0000000000000000 },
3624 { 21.533483453443495, 5.0000000000000000, 9.0000000000000000,
3625 5.0000000000000000 },
3626 { 42.397145995355721, 5.0000000000000000, 9.0000000000000000,
3627 6.0000000000000000 },
3628 { 85.010891404859976, 5.0000000000000000, 9.0000000000000000,
3629 7.0000000000000000 },
3630 { 173.36225868739959, 5.0000000000000000, 9.0000000000000000,
3631 8.0000000000000000 },
3632 { 359.10444177844266, 5.0000000000000000, 9.0000000000000000,
3633 9.0000000000000000 },
3634 { 754.64844371961385, 5.0000000000000000, 9.0000000000000000,
3635 10.000000000000000 },
3638 // Test function for a=5.0000000000000000, c=9.0000000000000000.
3639 template <typename Tp
>
3642 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3643 Tp max_abs_diff
= -Tp(1);
3644 Tp max_abs_frac
= -Tp(1);
3645 unsigned int num_datum
= sizeof(data049
)
3646 / sizeof(testcase_conf_hyperg
<double>);
3647 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3649 const Tp f
= std::tr1::conf_hyperg(Tp(data049
[i
].a
), Tp(data049
[i
].c
),
3651 const Tp f0
= data049
[i
].f0
;
3652 const Tp diff
= f
- f0
;
3653 if (std::abs(diff
) > max_abs_diff
)
3654 max_abs_diff
= std::abs(diff
);
3655 if (std::abs(f0
) > Tp(10) * eps
3656 && std::abs(f
) > Tp(10) * eps
)
3658 const Tp frac
= diff
/ f0
;
3659 if (std::abs(frac
) > max_abs_frac
)
3660 max_abs_frac
= std::abs(frac
);
3663 VERIFY(max_abs_frac
< Tp(1.0000000000000008e-12));
3666 // Test data for a=5.0000000000000000, c=10.000000000000000.
3667 testcase_conf_hyperg
<double> data050
[] = {
3668 { 0.019313731161840469, 5.0000000000000000, 10.000000000000000,
3669 -10.000000000000000 },
3670 { 0.026361085775183927, 5.0000000000000000, 10.000000000000000,
3671 -9.0000000000000000 },
3672 { 0.036556772070711910, 5.0000000000000000, 10.000000000000000,
3673 -8.0000000000000000 },
3674 { 0.051563934048344140, 5.0000000000000000, 10.000000000000000,
3675 -7.0000000000000000 },
3676 { 0.074056625794521824, 5.0000000000000000, 10.000000000000000,
3677 -6.0000000000000000 },
3678 { 0.10841132531381445, 5.0000000000000000, 10.000000000000000,
3679 -5.0000000000000000 },
3680 { 0.16192115120742598, 5.0000000000000000, 10.000000000000000,
3681 -4.0000000000000000 },
3682 { 0.24696279814742436, 5.0000000000000000, 10.000000000000000,
3683 -3.0000000000000000 },
3684 { 0.38492640633381947, 5.0000000000000000, 10.000000000000000,
3685 -2.0000000000000000 },
3686 { 0.61345628229723270, 5.0000000000000000, 10.000000000000000,
3687 -1.0000000000000000 },
3688 { 1.0000000000000000, 5.0000000000000000, 10.000000000000000,
3689 0.0000000000000000 },
3690 { 1.6675470647226096, 5.0000000000000000, 10.000000000000000,
3691 1.0000000000000000 },
3692 { 2.8442428103603667, 5.0000000000000000, 10.000000000000000,
3693 2.0000000000000000 },
3694 { 4.9603804008438397, 5.0000000000000000, 10.000000000000000,
3695 3.0000000000000000 },
3696 { 8.8405953071624790, 5.0000000000000000, 10.000000000000000,
3697 4.0000000000000000 },
3698 { 16.089667272320334, 5.0000000000000000, 10.000000000000000,
3699 5.0000000000000000 },
3700 { 29.876575194426895, 5.0000000000000000, 10.000000000000000,
3701 6.0000000000000000 },
3702 { 56.546719856432318, 5.0000000000000000, 10.000000000000000,
3703 7.0000000000000000 },
3704 { 108.97420168465270, 5.0000000000000000, 10.000000000000000,
3705 8.0000000000000000 },
3706 { 213.60609045832913, 5.0000000000000000, 10.000000000000000,
3707 9.0000000000000000 },
3708 { 425.41323880637168, 5.0000000000000000, 10.000000000000000,
3709 10.000000000000000 },
3712 // Test function for a=5.0000000000000000, c=10.000000000000000.
3713 template <typename Tp
>
3716 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3717 Tp max_abs_diff
= -Tp(1);
3718 Tp max_abs_frac
= -Tp(1);
3719 unsigned int num_datum
= sizeof(data050
)
3720 / sizeof(testcase_conf_hyperg
<double>);
3721 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3723 const Tp f
= std::tr1::conf_hyperg(Tp(data050
[i
].a
), Tp(data050
[i
].c
),
3725 const Tp f0
= data050
[i
].f0
;
3726 const Tp diff
= f
- f0
;
3727 if (std::abs(diff
) > max_abs_diff
)
3728 max_abs_diff
= std::abs(diff
);
3729 if (std::abs(f0
) > Tp(10) * eps
3730 && std::abs(f
) > Tp(10) * eps
)
3732 const Tp frac
= diff
/ f0
;
3733 if (std::abs(frac
) > max_abs_frac
)
3734 max_abs_frac
= std::abs(frac
);
3737 VERIFY(max_abs_frac
< Tp(5.0000000000000039e-13));
3740 // Test data for a=10.000000000000000, c=1.0000000000000000.
3741 testcase_conf_hyperg
<double> data051
[] = {
3742 { 0.00067155063653961283, 10.000000000000000, 1.0000000000000000,
3743 -10.000000000000000 },
3744 { -0.00071555648905258641, 10.000000000000000, 1.0000000000000000,
3745 -9.0000000000000000 },
3746 { -0.0035372078786207375, 10.000000000000000, 1.0000000000000000,
3747 -8.0000000000000000 },
3748 { -0.0047884005574714370, 10.000000000000000, 1.0000000000000000,
3749 -7.0000000000000000 },
3750 { 0.0024787521766663585, 10.000000000000000, 1.0000000000000000,
3751 -6.0000000000000000 },
3752 { 0.018136827242522878, 10.000000000000000, 1.0000000000000000,
3753 -5.0000000000000000 },
3754 { 0.0099686175680129968, 10.000000000000000, 1.0000000000000000,
3755 -4.0000000000000000 },
3756 { -0.052832081031434205, 10.000000000000000, 1.0000000000000000,
3757 -3.0000000000000000 },
3758 { 0.0010979582061524211, 10.000000000000000, 1.0000000000000000,
3759 -2.0000000000000000 },
3760 { 0.11394854824644544, 10.000000000000000, 1.0000000000000000,
3761 -1.0000000000000000 },
3762 { 1.0000000000000000, 10.000000000000000, 1.0000000000000000,
3763 0.0000000000000000 },
3764 { 131.63017574352625, 10.000000000000000, 1.0000000000000000,
3765 1.0000000000000000 },
3766 { 2431.2913698755492, 10.000000000000000, 1.0000000000000000,
3767 2.0000000000000000 },
3768 { 27127.328899791049, 10.000000000000000, 1.0000000000000000,
3769 3.0000000000000000 },
3770 { 232066.49977835573, 10.000000000000000, 1.0000000000000000,
3771 4.0000000000000000 },
3772 { 1674401.3794931532, 10.000000000000000, 1.0000000000000000,
3773 5.0000000000000000 },
3774 { 10707495.820386337, 10.000000000000000, 1.0000000000000000,
3775 6.0000000000000000 },
3776 { 62515499.242815509, 10.000000000000000, 1.0000000000000000,
3777 7.0000000000000000 },
3778 { 339773485.00937450, 10.000000000000000, 1.0000000000000000,
3779 8.0000000000000000 },
3780 { 1742442474.2135217, 10.000000000000000, 1.0000000000000000,
3781 9.0000000000000000 },
3782 { 8514625476.5462780, 10.000000000000000, 1.0000000000000000,
3783 10.000000000000000 },
3786 // Test function for a=10.000000000000000, c=1.0000000000000000.
3787 template <typename Tp
>
3790 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3791 Tp max_abs_diff
= -Tp(1);
3792 Tp max_abs_frac
= -Tp(1);
3793 unsigned int num_datum
= sizeof(data051
)
3794 / sizeof(testcase_conf_hyperg
<double>);
3795 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3797 const Tp f
= std::tr1::conf_hyperg(Tp(data051
[i
].a
), Tp(data051
[i
].c
),
3799 const Tp f0
= data051
[i
].f0
;
3800 const Tp diff
= f
- f0
;
3801 if (std::abs(diff
) > max_abs_diff
)
3802 max_abs_diff
= std::abs(diff
);
3803 if (std::abs(f0
) > Tp(10) * eps
3804 && std::abs(f
) > Tp(10) * eps
)
3806 const Tp frac
= diff
/ f0
;
3807 if (std::abs(frac
) > max_abs_frac
)
3808 max_abs_frac
= std::abs(frac
);
3811 VERIFY(max_abs_frac
< Tp(5.0000000000000029e-12));
3814 // Test data for a=10.000000000000000, c=2.0000000000000000.
3815 testcase_conf_hyperg
<double> data052
[] = {
3816 { -0.00014116415550486912, 10.000000000000000, 2.0000000000000000,
3817 -10.000000000000000 },
3818 { -0.00016988130843806985, 10.000000000000000, 2.0000000000000000,
3819 -9.0000000000000000 },
3820 { 6.6619209703391391e-05, 10.000000000000000, 2.0000000000000000,
3821 -8.0000000000000000 },
3822 { 0.00072582919646365740, 10.000000000000000, 2.0000000000000000,
3823 -7.0000000000000000 },
3824 { 0.0012039653429522313, 10.000000000000000, 2.0000000000000000,
3825 -6.0000000000000000 },
3826 { -0.00061450715370021350, 10.000000000000000, 2.0000000000000000,
3827 -5.0000000000000000 },
3828 { -0.0053557899960354968, 10.000000000000000, 2.0000000000000000,
3829 -4.0000000000000000 },
3830 { -0.00078903612815141419, 10.000000000000000, 2.0000000000000000,
3831 -3.0000000000000000 },
3832 { 0.023725444715554326, 10.000000000000000, 2.0000000000000000,
3833 -2.0000000000000000 },
3834 { -0.057297669024384767, 10.000000000000000, 2.0000000000000000,
3835 -1.0000000000000000 },
3836 { 1.0000000000000000, 10.000000000000000, 2.0000000000000000,
3837 0.0000000000000000 },
3838 { 34.432116659636534, 10.000000000000000, 2.0000000000000000,
3839 1.0000000000000000 },
3840 { 432.53475371634494, 10.000000000000000, 2.0000000000000000,
3841 2.0000000000000000 },
3842 { 3789.1768909683515, 10.000000000000000, 2.0000000000000000,
3843 3.0000000000000000 },
3844 { 27089.676185774806, 10.000000000000000, 2.0000000000000000,
3845 4.0000000000000000 },
3846 { 169243.72183073507, 10.000000000000000, 2.0000000000000000,
3847 5.0000000000000000 },
3848 { 959019.40135397331, 10.000000000000000, 2.0000000000000000,
3849 6.0000000000000000 },
3850 { 5043073.3458297960, 10.000000000000000, 2.0000000000000000,
3851 7.0000000000000000 },
3852 { 24989309.819281481, 10.000000000000000, 2.0000000000000000,
3853 8.0000000000000000 },
3854 { 117948708.50540228, 10.000000000000000, 2.0000000000000000,
3855 9.0000000000000000 },
3856 { 534524325.69810420, 10.000000000000000, 2.0000000000000000,
3857 10.000000000000000 },
3860 // Test function for a=10.000000000000000, c=2.0000000000000000.
3861 template <typename Tp
>
3864 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3865 Tp max_abs_diff
= -Tp(1);
3866 Tp max_abs_frac
= -Tp(1);
3867 unsigned int num_datum
= sizeof(data052
)
3868 / sizeof(testcase_conf_hyperg
<double>);
3869 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3871 const Tp f
= std::tr1::conf_hyperg(Tp(data052
[i
].a
), Tp(data052
[i
].c
),
3873 const Tp f0
= data052
[i
].f0
;
3874 const Tp diff
= f
- f0
;
3875 if (std::abs(diff
) > max_abs_diff
)
3876 max_abs_diff
= std::abs(diff
);
3877 if (std::abs(f0
) > Tp(10) * eps
3878 && std::abs(f
) > Tp(10) * eps
)
3880 const Tp frac
= diff
/ f0
;
3881 if (std::abs(frac
) > max_abs_frac
)
3882 max_abs_frac
= std::abs(frac
);
3885 VERIFY(max_abs_frac
< Tp(2.5000000000000017e-10));
3888 // Test data for a=10.000000000000000, c=3.0000000000000000.
3889 testcase_conf_hyperg
<double> data053
[] = {
3890 { 1.4973169075105230e-05, 10.000000000000000, 3.0000000000000000,
3891 -10.000000000000000 },
3892 { 5.7627971015476259e-05, 10.000000000000000, 3.0000000000000000,
3893 -9.0000000000000000 },
3894 { 9.5964794084281178e-05, 10.000000000000000, 3.0000000000000000,
3895 -8.0000000000000000 },
3896 { 1.5479477810339013e-05, 10.000000000000000, 3.0000000000000000,
3897 -7.0000000000000000 },
3898 { -0.00035410745380947978, 10.000000000000000, 3.0000000000000000,
3899 -6.0000000000000000 },
3900 { -0.00078393993138610115, 10.000000000000000, 3.0000000000000000,
3901 -5.0000000000000000 },
3902 { 0.00038117202625584341, 10.000000000000000, 3.0000000000000000,
3903 -4.0000000000000000 },
3904 { 0.0045341794406447526, 10.000000000000000, 3.0000000000000000,
3905 -3.0000000000000000 },
3906 { -0.0031029253652133434, 10.000000000000000, 3.0000000000000000,
3907 -2.0000000000000000 },
3908 { -0.028487137061611361, 10.000000000000000, 3.0000000000000000,
3909 -1.0000000000000000 },
3910 { 1.0000000000000000, 10.000000000000000, 3.0000000000000000,
3911 0.0000000000000000 },
3912 { 15.691485606063281, 10.000000000000000, 3.0000000000000000,
3913 1.0000000000000000 },
3914 { 141.71088859081422, 10.000000000000000, 3.0000000000000000,
3915 2.0000000000000000 },
3916 { 997.55177799313742, 10.000000000000000, 3.0000000000000000,
3917 3.0000000000000000 },
3918 { 6038.6324280926056, 10.000000000000000, 3.0000000000000000,
3919 4.0000000000000000 },
3920 { 32946.952425437157, 10.000000000000000, 3.0000000000000000,
3921 5.0000000000000000 },
3922 { 166431.66712118863, 10.000000000000000, 3.0000000000000000,
3923 6.0000000000000000 },
3924 { 791818.30272061308, 10.000000000000000, 3.0000000000000000,
3925 7.0000000000000000 },
3926 { 3589678.0198700386, 10.000000000000000, 3.0000000000000000,
3927 8.0000000000000000 },
3928 { 15637649.698874988, 10.000000000000000, 3.0000000000000000,
3929 9.0000000000000000 },
3930 { 65871447.346678361, 10.000000000000000, 3.0000000000000000,
3931 10.000000000000000 },
3934 // Test function for a=10.000000000000000, c=3.0000000000000000.
3935 template <typename Tp
>
3938 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
3939 Tp max_abs_diff
= -Tp(1);
3940 Tp max_abs_frac
= -Tp(1);
3941 unsigned int num_datum
= sizeof(data053
)
3942 / sizeof(testcase_conf_hyperg
<double>);
3943 for (unsigned int i
= 0; i
< num_datum
; ++i
)
3945 const Tp f
= std::tr1::conf_hyperg(Tp(data053
[i
].a
), Tp(data053
[i
].c
),
3947 const Tp f0
= data053
[i
].f0
;
3948 const Tp diff
= f
- f0
;
3949 if (std::abs(diff
) > max_abs_diff
)
3950 max_abs_diff
= std::abs(diff
);
3951 if (std::abs(f0
) > Tp(10) * eps
3952 && std::abs(f
) > Tp(10) * eps
)
3954 const Tp frac
= diff
/ f0
;
3955 if (std::abs(frac
) > max_abs_frac
)
3956 max_abs_frac
= std::abs(frac
);
3959 VERIFY(max_abs_frac
< Tp(2.5000000000000013e-09));
3962 // Test data for a=10.000000000000000, c=4.0000000000000000.
3963 testcase_conf_hyperg
<double> data054
[] = {
3964 { 6.9661267889527031e-06, 10.000000000000000, 4.0000000000000000,
3965 -10.000000000000000 },
3966 { -3.0301514396282926e-06, 10.000000000000000, 4.0000000000000000,
3967 -9.0000000000000000 },
3968 { -3.7983599138168025e-05, 10.000000000000000, 4.0000000000000000,
3969 -8.0000000000000000 },
3970 { -9.3615660121163871e-05, 10.000000000000000, 4.0000000000000000,
3971 -7.0000000000000000 },
3972 { -7.0821490761895943e-05, 10.000000000000000, 4.0000000000000000,
3973 -6.0000000000000000 },
3974 { 0.00030692863727646260, 10.000000000000000, 4.0000000000000000,
3975 -5.0000000000000000 },
3976 { 0.0010659895649527829, 10.000000000000000, 4.0000000000000000,
3977 -4.0000000000000000 },
3978 { -0.00042230102633456065, 10.000000000000000, 4.0000000000000000,
3979 -3.0000000000000000 },
3980 { -0.010168047735237568, 10.000000000000000, 4.0000000000000000,
3981 -2.0000000000000000 },
3982 { 0.036903514708782073, 10.000000000000000, 4.0000000000000000,
3983 -1.0000000000000000 },
3984 { 1.0000000000000000, 10.000000000000000, 4.0000000000000000,
3985 0.0000000000000000 },
3986 { 9.3384756433214022, 10.000000000000000, 4.0000000000000000,
3987 1.0000000000000000 },
3988 { 63.905561372021388, 10.000000000000000, 4.0000000000000000,
3989 2.0000000000000000 },
3990 { 370.08498456728779, 10.000000000000000, 4.0000000000000000,
3991 3.0000000000000000 },
3992 { 1922.9526217493540, 10.000000000000000, 4.0000000000000000,
3993 4.0000000000000000 },
3994 { 9245.0380014351485, 10.000000000000000, 4.0000000000000000,
3995 5.0000000000000000 },
3996 { 41898.961838459785, 10.000000000000000, 4.0000000000000000,
3997 6.0000000000000000 },
3998 { 181211.14084739226, 10.000000000000000, 4.0000000000000000,
3999 7.0000000000000000 },
4000 { 754384.25570692297, 10.000000000000000, 4.0000000000000000,
4001 8.0000000000000000 },
4002 { 3042060.4915799876, 10.000000000000000, 4.0000000000000000,
4003 9.0000000000000000 },
4004 { 11939626.424402930, 10.000000000000000, 4.0000000000000000,
4005 10.000000000000000 },
4008 // Test function for a=10.000000000000000, c=4.0000000000000000.
4009 template <typename Tp
>
4012 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4013 Tp max_abs_diff
= -Tp(1);
4014 Tp max_abs_frac
= -Tp(1);
4015 unsigned int num_datum
= sizeof(data054
)
4016 / sizeof(testcase_conf_hyperg
<double>);
4017 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4019 const Tp f
= std::tr1::conf_hyperg(Tp(data054
[i
].a
), Tp(data054
[i
].c
),
4021 const Tp f0
= data054
[i
].f0
;
4022 const Tp diff
= f
- f0
;
4023 if (std::abs(diff
) > max_abs_diff
)
4024 max_abs_diff
= std::abs(diff
);
4025 if (std::abs(f0
) > Tp(10) * eps
4026 && std::abs(f
) > Tp(10) * eps
)
4028 const Tp frac
= diff
/ f0
;
4029 if (std::abs(frac
) > max_abs_frac
)
4030 max_abs_frac
= std::abs(frac
);
4033 VERIFY(max_abs_frac
< Tp(5.0000000000000026e-09));
4036 // Test data for a=10.000000000000000, c=5.0000000000000000.
4037 testcase_conf_hyperg
<double> data055
[] = {
4038 { -6.2454929831989742e-06, 10.000000000000000, 5.0000000000000000,
4039 -10.000000000000000 },
4040 { -1.1459481808048817e-05, 10.000000000000000, 5.0000000000000000,
4041 -9.0000000000000000 },
4042 { -8.1646988801669512e-06, 10.000000000000000, 5.0000000000000000,
4043 -8.0000000000000000 },
4044 { 3.1240400671775088e-05, 10.000000000000000, 5.0000000000000000,
4045 -7.0000000000000000 },
4046 { 0.00014164298152379191, 10.000000000000000, 5.0000000000000000,
4047 -6.0000000000000000 },
4048 { 0.00023172833594738379, 10.000000000000000, 5.0000000000000000,
4049 -5.0000000000000000 },
4050 { -0.00036825094062005220, 10.000000000000000, 5.0000000000000000,
4051 -4.0000000000000000 },
4052 { -0.0030227862937631683, 10.000000000000000, 5.0000000000000000,
4053 -3.0000000000000000 },
4054 { -0.00028642387986584615, 10.000000000000000, 5.0000000000000000,
4055 -2.0000000000000000 },
4056 { 0.10617896040159881, 10.000000000000000, 5.0000000000000000,
4057 -1.0000000000000000 },
4058 { 1.0000000000000000, 10.000000000000000, 5.0000000000000000,
4059 0.0000000000000000 },
4060 { 6.4803694966028260, 10.000000000000000, 5.0000000000000000,
4061 1.0000000000000000 },
4062 { 35.201619637445276, 10.000000000000000, 5.0000000000000000,
4063 2.0000000000000000 },
4064 { 171.58787257237464, 10.000000000000000, 5.0000000000000000,
4065 3.0000000000000000 },
4066 { 775.87148867205678, 10.000000000000000, 5.0000000000000000,
4067 4.0000000000000000 },
4068 { 3317.4071019773678, 10.000000000000000, 5.0000000000000000,
4069 5.0000000000000000 },
4070 { 13578.260535269774, 10.000000000000000, 5.0000000000000000,
4071 6.0000000000000000 },
4072 { 53651.761875039716, 10.000000000000000, 5.0000000000000000,
4073 7.0000000000000000 },
4074 { 205900.60390283042, 10.000000000000000, 5.0000000000000000,
4075 8.0000000000000000 },
4076 { 770979.49612334219, 10.000000000000000, 5.0000000000000000,
4077 9.0000000000000000 },
4078 { 2826613.2348531331, 10.000000000000000, 5.0000000000000000,
4079 10.000000000000000 },
4082 // Test function for a=10.000000000000000, c=5.0000000000000000.
4083 template <typename Tp
>
4086 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4087 Tp max_abs_diff
= -Tp(1);
4088 Tp max_abs_frac
= -Tp(1);
4089 unsigned int num_datum
= sizeof(data055
)
4090 / sizeof(testcase_conf_hyperg
<double>);
4091 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4093 const Tp f
= std::tr1::conf_hyperg(Tp(data055
[i
].a
), Tp(data055
[i
].c
),
4095 const Tp f0
= data055
[i
].f0
;
4096 const Tp diff
= f
- f0
;
4097 if (std::abs(diff
) > max_abs_diff
)
4098 max_abs_diff
= std::abs(diff
);
4099 if (std::abs(f0
) > Tp(10) * eps
4100 && std::abs(f
) > Tp(10) * eps
)
4102 const Tp frac
= diff
/ f0
;
4103 if (std::abs(frac
) > max_abs_frac
)
4104 max_abs_frac
= std::abs(frac
);
4107 VERIFY(max_abs_frac
< Tp(2.5000000000000013e-09));
4110 // Test data for a=10.000000000000000, c=6.0000000000000000.
4111 testcase_conf_hyperg
<double> data056
[] = {
4112 { 9.6084507433830306e-07, 10.000000000000000, 6.0000000000000000,
4113 -10.000000000000000 },
4114 { 7.7131127554174726e-06, 10.000000000000000, 6.0000000000000000,
4115 -9.0000000000000000 },
4116 { 2.3074149009167486e-05, 10.000000000000000, 6.0000000000000000,
4117 -8.0000000000000000 },
4118 { 4.0105919781332888e-05, 10.000000000000000, 6.0000000000000000,
4119 -7.0000000000000000 },
4120 { -7.7443012320393170e-21, 10.000000000000000, 6.0000000000000000,
4121 -6.0000000000000000 },
4122 { -0.00029188857701064686, 10.000000000000000, 6.0000000000000000,
4123 -5.0000000000000000 },
4124 { -0.0010659895649527829, 10.000000000000000, 6.0000000000000000,
4125 -4.0000000000000000 },
4126 { -0.00044452739614164190, 10.000000000000000, 6.0000000000000000,
4127 -3.0000000000000000 },
4128 { 0.020049671590609292, 10.000000000000000, 6.0000000000000000,
4129 -2.0000000000000000 },
4130 { 0.17092282236966813, 10.000000000000000, 6.0000000000000000,
4131 -1.0000000000000000 },
4132 { 1.0000000000000000, 10.000000000000000, 6.0000000000000000,
4133 0.0000000000000000 },
4134 { 4.9520550902714540, 10.000000000000000, 6.0000000000000000,
4135 1.0000000000000000 },
4136 { 22.206263831706924, 10.000000000000000, 6.0000000000000000,
4137 2.0000000000000000 },
4138 { 93.074943420842843, 10.000000000000000, 6.0000000000000000,
4139 3.0000000000000000 },
4140 { 371.20964440523989, 10.000000000000000, 6.0000000000000000,
4141 4.0000000000000000 },
4142 { 1424.6976175888544, 10.000000000000000, 6.0000000000000000,
4143 5.0000000000000000 },
4144 { 5302.2070001902330, 10.000000000000000, 6.0000000000000000,
4145 6.0000000000000000 },
4146 { 19239.311823447424, 10.000000000000000, 6.0000000000000000,
4147 7.0000000000000000 },
4148 { 68341.221999215923, 10.000000000000000, 6.0000000000000000,
4149 8.0000000000000000 },
4150 { 238389.83519072225, 10.000000000000000, 6.0000000000000000,
4151 9.0000000000000000 },
4152 { 818592.04096678516, 10.000000000000000, 6.0000000000000000,
4153 10.000000000000000 },
4156 // Test function for a=10.000000000000000, c=6.0000000000000000.
4157 template <typename Tp
>
4160 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4161 Tp max_abs_diff
= -Tp(1);
4162 Tp max_abs_frac
= -Tp(1);
4163 unsigned int num_datum
= sizeof(data056
)
4164 / sizeof(testcase_conf_hyperg
<double>);
4165 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4167 const Tp f
= std::tr1::conf_hyperg(Tp(data056
[i
].a
), Tp(data056
[i
].c
),
4169 const Tp f0
= data056
[i
].f0
;
4170 const Tp diff
= f
- f0
;
4171 if (std::abs(diff
) > max_abs_diff
)
4172 max_abs_diff
= std::abs(diff
);
4173 if (std::abs(f0
) > Tp(10) * eps
4174 && std::abs(f
) > Tp(10) * eps
)
4176 const Tp frac
= diff
/ f0
;
4177 if (std::abs(frac
) > max_abs_frac
)
4178 max_abs_frac
= std::abs(frac
);
4181 VERIFY(max_abs_frac
< Tp(2.5000000000000012e-08));
4184 // Test data for a=10.000000000000000, c=7.0000000000000000.
4185 testcase_conf_hyperg
<double> data057
[] = {
4186 { 3.9634859316455036e-06, 10.000000000000000, 7.0000000000000000,
4187 -10.000000000000000 },
4188 { 4.4074930030956985e-06, 10.000000000000000, 7.0000000000000000,
4189 -9.0000000000000000 },
4190 { -5.3248036175001926e-06, 10.000000000000000, 7.0000000000000000,
4191 -8.0000000000000000 },
4192 { -5.0660109197473119e-05, 10.000000000000000, 7.0000000000000000,
4193 -7.0000000000000000 },
4194 { -0.00017705372690473989, 10.000000000000000, 7.0000000000000000,
4195 -6.0000000000000000 },
4196 { -0.00034759250392107569, 10.000000000000000, 7.0000000000000000,
4197 -5.0000000000000000 },
4198 { 0.00029072442680530428, 10.000000000000000, 7.0000000000000000,
4199 -4.0000000000000000 },
4200 { 0.0071124383382662791, 10.000000000000000, 7.0000000000000000,
4201 -3.0000000000000000 },
4202 { 0.046185850628367831, 10.000000000000000, 7.0000000000000000,
4203 -2.0000000000000000 },
4204 { 0.22919473120601763, 10.000000000000000, 7.0000000000000000,
4205 -1.0000000000000000 },
4206 { 1.0000000000000000, 10.000000000000000, 7.0000000000000000,
4207 0.0000000000000000 },
4208 { 4.0342754120781059, 10.000000000000000, 7.0000000000000000,
4209 1.0000000000000000 },
4210 { 15.423188523958421, 10.000000000000000, 7.0000000000000000,
4211 2.0000000000000000 },
4212 { 56.669907747565212, 10.000000000000000, 7.0000000000000000,
4213 3.0000000000000000 },
4214 { 201.92649139242229, 10.000000000000000, 7.0000000000000000,
4215 4.0000000000000000 },
4216 { 702.01780019948944, 10.000000000000000, 7.0000000000000000,
4217 5.0000000000000000 },
4218 { 2391.7564185640722, 10.000000000000000, 7.0000000000000000,
4219 6.0000000000000000 },
4220 { 8011.5144629634615, 10.000000000000000, 7.0000000000000000,
4221 7.0000000000000000 },
4222 { 26450.087535814702, 10.000000000000000, 7.0000000000000000,
4223 8.0000000000000000 },
4224 { 86239.964657766584, 10.000000000000000, 7.0000000000000000,
4225 9.0000000000000000 },
4226 { 278127.83396458323, 10.000000000000000, 7.0000000000000000,
4227 10.000000000000000 },
4230 // Test function for a=10.000000000000000, c=7.0000000000000000.
4231 template <typename Tp
>
4234 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4235 Tp max_abs_diff
= -Tp(1);
4236 Tp max_abs_frac
= -Tp(1);
4237 unsigned int num_datum
= sizeof(data057
)
4238 / sizeof(testcase_conf_hyperg
<double>);
4239 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4241 const Tp f
= std::tr1::conf_hyperg(Tp(data057
[i
].a
), Tp(data057
[i
].c
),
4243 const Tp f0
= data057
[i
].f0
;
4244 const Tp diff
= f
- f0
;
4245 if (std::abs(diff
) > max_abs_diff
)
4246 max_abs_diff
= std::abs(diff
);
4247 if (std::abs(f0
) > Tp(10) * eps
4248 && std::abs(f
) > Tp(10) * eps
)
4250 const Tp frac
= diff
/ f0
;
4251 if (std::abs(frac
) > max_abs_frac
)
4252 max_abs_frac
= std::abs(frac
);
4255 VERIFY(max_abs_frac
< Tp(1.0000000000000004e-06));
4258 // Test data for a=10.000000000000000, c=8.0000000000000000.
4259 testcase_conf_hyperg
<double> data058
[] = {
4260 { -5.0444366402760924e-06, 10.000000000000000, 8.0000000000000000,
4261 -10.000000000000000 },
4262 { -1.5426225510834945e-05, 10.000000000000000, 8.0000000000000000,
4263 -9.0000000000000000 },
4264 { -3.7273625322501334e-05, 10.000000000000000, 8.0000000000000000,
4265 -8.0000000000000000 },
4266 { -6.3325136496841480e-05, 10.000000000000000, 8.0000000000000000,
4267 -7.0000000000000000 },
4268 { -2.7519677388747149e-19, 10.000000000000000, 8.0000000000000000,
4269 -6.0000000000000000 },
4270 { 0.00065507818046664273, 10.000000000000000, 8.0000000000000000,
4271 -5.0000000000000000 },
4272 { 0.0040701419752742617, 10.000000000000000, 8.0000000000000000,
4273 -4.0000000000000000 },
4274 { 0.018670150637948978, 10.000000000000000, 8.0000000000000000,
4275 -3.0000000000000000 },
4276 { 0.075186268464784836, 10.000000000000000, 8.0000000000000000,
4277 -2.0000000000000000 },
4278 { 0.28101901756151842, 10.000000000000000, 8.0000000000000000,
4279 -1.0000000000000000 },
4280 { 1.0000000000000000, 10.000000000000000, 8.0000000000000000,
4281 0.0000000000000000 },
4282 { 3.4356061998579595, 10.000000000000000, 8.0000000000000000,
4283 1.0000000000000000 },
4284 { 11.494087265003234, 10.000000000000000, 8.0000000000000000,
4285 2.0000000000000000 },
4286 { 37.660381730976880, 10.000000000000000, 8.0000000000000000,
4287 3.0000000000000000 },
4288 { 121.32922229587608, 10.000000000000000, 8.0000000000000000,
4289 4.0000000000000000 },
4290 { 385.46195489141422, 10.000000000000000, 8.0000000000000000,
4291 5.0000000000000000 },
4292 { 1210.2863804782053, 10.000000000000000, 8.0000000000000000,
4293 6.0000000000000000 },
4294 { 3762.0609740531836, 10.000000000000000, 8.0000000000000000,
4295 7.0000000000000000 },
4296 { 11592.614394051165, 10.000000000000000, 8.0000000000000000,
4297 8.0000000000000000 },
4298 { 35450.992183142305, 10.000000000000000, 8.0000000000000000,
4299 9.0000000000000000 },
4300 { 107684.94388572175, 10.000000000000000, 8.0000000000000000,
4301 10.000000000000000 },
4304 // Test function for a=10.000000000000000, c=8.0000000000000000.
4305 template <typename Tp
>
4308 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4309 Tp max_abs_diff
= -Tp(1);
4310 Tp max_abs_frac
= -Tp(1);
4311 unsigned int num_datum
= sizeof(data058
)
4312 / sizeof(testcase_conf_hyperg
<double>);
4313 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4315 const Tp f
= std::tr1::conf_hyperg(Tp(data058
[i
].a
), Tp(data058
[i
].c
),
4317 const Tp f0
= data058
[i
].f0
;
4318 const Tp diff
= f
- f0
;
4319 if (std::abs(diff
) > max_abs_diff
)
4320 max_abs_diff
= std::abs(diff
);
4321 if (std::abs(f0
) > Tp(10) * eps
4322 && std::abs(f
) > Tp(10) * eps
)
4324 const Tp frac
= diff
/ f0
;
4325 if (std::abs(frac
) > max_abs_frac
)
4326 max_abs_frac
= std::abs(frac
);
4329 VERIFY(max_abs_frac
< Tp(2.5000000000000013e-09));
4332 // Test data for a=10.000000000000000, c=9.0000000000000000.
4333 testcase_conf_hyperg
<double> data059
[] = {
4334 { -5.0444366402760974e-06, 10.000000000000000, 9.0000000000000000,
4335 -10.000000000000000 },
4336 { 0.0000000000000000, 10.000000000000000, 9.0000000000000000,
4337 -9.0000000000000000 },
4338 { 3.7273625322501334e-05, 10.000000000000000, 9.0000000000000000,
4339 -8.0000000000000000 },
4340 { 0.00020264043678989247, 10.000000000000000, 9.0000000000000000,
4341 -7.0000000000000000 },
4342 { 0.00082625072555545290, 10.000000000000000, 9.0000000000000000,
4343 -6.0000000000000000 },
4344 { 0.0029946431107046520, 10.000000000000000, 9.0000000000000000,
4345 -5.0000000000000000 },
4346 { 0.010175354938185655, 10.000000000000000, 9.0000000000000000,
4347 -4.0000000000000000 },
4348 { 0.033191378911909299, 10.000000000000000, 9.0000000000000000,
4349 -3.0000000000000000 },
4350 { 0.10526077585069878, 10.000000000000000, 9.0000000000000000,
4351 -2.0000000000000000 },
4352 { 0.32700394770794872, 10.000000000000000, 9.0000000000000000,
4353 -1.0000000000000000 },
4354 { 1.0000000000000000, 10.000000000000000, 9.0000000000000000,
4355 0.0000000000000000 },
4356 { 3.0203131427322725, 10.000000000000000, 9.0000000000000000,
4357 1.0000000000000000 },
4358 { 9.0310685653596838, 10.000000000000000, 9.0000000000000000,
4359 2.0000000000000000 },
4360 { 26.780715897583555, 10.000000000000000, 9.0000000000000000,
4361 3.0000000000000000 },
4362 { 78.863994492319449, 10.000000000000000, 9.0000000000000000,
4363 4.0000000000000000 },
4364 { 230.86491415956360, 10.000000000000000, 9.0000000000000000,
4365 5.0000000000000000 },
4366 { 672.38132248789179, 10.000000000000000, 9.0000000000000000,
4367 6.0000000000000000 },
4368 { 1949.5700594283705, 10.000000000000000, 9.0000000000000000,
4369 7.0000000000000000 },
4370 { 5630.6984199677090, 10.000000000000000, 9.0000000000000000,
4371 8.0000000000000000 },
4372 { 16206.167855150768, 10.000000000000000, 9.0000000000000000,
4373 9.0000000000000000 },
4374 { 46500.316677925293, 10.000000000000000, 9.0000000000000000,
4375 10.000000000000000 },
4378 // Test function for a=10.000000000000000, c=9.0000000000000000.
4379 template <typename Tp
>
4382 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4383 Tp max_abs_diff
= -Tp(1);
4384 Tp max_abs_frac
= -Tp(1);
4385 unsigned int num_datum
= sizeof(data059
)
4386 / sizeof(testcase_conf_hyperg
<double>);
4387 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4389 const Tp f
= std::tr1::conf_hyperg(Tp(data059
[i
].a
), Tp(data059
[i
].c
),
4391 const Tp f0
= data059
[i
].f0
;
4392 const Tp diff
= f
- f0
;
4393 if (std::abs(diff
) > max_abs_diff
)
4394 max_abs_diff
= std::abs(diff
);
4395 if (std::abs(f0
) > Tp(10) * eps
4396 && std::abs(f
) > Tp(10) * eps
)
4398 const Tp frac
= diff
/ f0
;
4399 if (std::abs(frac
) > max_abs_frac
)
4400 max_abs_frac
= std::abs(frac
);
4403 VERIFY(max_abs_frac
< Tp(2.5000000000000013e-09));
4406 // Test data for a=10.000000000000000, c=10.000000000000000.
4407 testcase_conf_hyperg
<double> data060
[] = {
4408 { 4.5399929762484854e-05, 10.000000000000000, 10.000000000000000,
4409 -10.000000000000000 },
4410 { 0.00012340980408667956, 10.000000000000000, 10.000000000000000,
4411 -9.0000000000000000 },
4412 { 0.00033546262790251185, 10.000000000000000, 10.000000000000000,
4413 -8.0000000000000000 },
4414 { 0.00091188196555451624, 10.000000000000000, 10.000000000000000,
4415 -7.0000000000000000 },
4416 { 0.0024787521766663585, 10.000000000000000, 10.000000000000000,
4417 -6.0000000000000000 },
4418 { 0.0067379469990854670, 10.000000000000000, 10.000000000000000,
4419 -5.0000000000000000 },
4420 { 0.018315638888734179, 10.000000000000000, 10.000000000000000,
4421 -4.0000000000000000 },
4422 { 0.049787068367863944, 10.000000000000000, 10.000000000000000,
4423 -3.0000000000000000 },
4424 { 0.13533528323661270, 10.000000000000000, 10.000000000000000,
4425 -2.0000000000000000 },
4426 { 0.36787944117144233, 10.000000000000000, 10.000000000000000,
4427 -1.0000000000000000 },
4428 { 1.0000000000000000, 10.000000000000000, 10.000000000000000,
4429 0.0000000000000000 },
4430 { 2.7182818284590451, 10.000000000000000, 10.000000000000000,
4431 1.0000000000000000 },
4432 { 7.3890560989306504, 10.000000000000000, 10.000000000000000,
4433 2.0000000000000000 },
4434 { 20.085536923187668, 10.000000000000000, 10.000000000000000,
4435 3.0000000000000000 },
4436 { 54.598150033144236, 10.000000000000000, 10.000000000000000,
4437 4.0000000000000000 },
4438 { 148.41315910257660, 10.000000000000000, 10.000000000000000,
4439 5.0000000000000000 },
4440 { 403.42879349273511, 10.000000000000000, 10.000000000000000,
4441 6.0000000000000000 },
4442 { 1096.6331584284585, 10.000000000000000, 10.000000000000000,
4443 7.0000000000000000 },
4444 { 2980.9579870417283, 10.000000000000000, 10.000000000000000,
4445 8.0000000000000000 },
4446 { 8103.0839275753842, 10.000000000000000, 10.000000000000000,
4447 9.0000000000000000 },
4448 { 22026.465794806718, 10.000000000000000, 10.000000000000000,
4449 10.000000000000000 },
4452 // Test function for a=10.000000000000000, c=10.000000000000000.
4453 template <typename Tp
>
4456 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4457 Tp max_abs_diff
= -Tp(1);
4458 Tp max_abs_frac
= -Tp(1);
4459 unsigned int num_datum
= sizeof(data060
)
4460 / sizeof(testcase_conf_hyperg
<double>);
4461 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4463 const Tp f
= std::tr1::conf_hyperg(Tp(data060
[i
].a
), Tp(data060
[i
].c
),
4465 const Tp f0
= data060
[i
].f0
;
4466 const Tp diff
= f
- f0
;
4467 if (std::abs(diff
) > max_abs_diff
)
4468 max_abs_diff
= std::abs(diff
);
4469 if (std::abs(f0
) > Tp(10) * eps
4470 && std::abs(f
) > Tp(10) * eps
)
4472 const Tp frac
= diff
/ f0
;
4473 if (std::abs(frac
) > max_abs_frac
)
4474 max_abs_frac
= std::abs(frac
);
4477 VERIFY(max_abs_frac
< Tp(2.5000000000000020e-13));
4480 // Test data for a=20.000000000000000, c=1.0000000000000000.
4481 testcase_conf_hyperg
<double> data061
[] = {
4482 { 0.00018021852293239465, 20.000000000000000, 1.0000000000000000,
4483 -10.000000000000000 },
4484 { 0.0017726368057851861, 20.000000000000000, 1.0000000000000000,
4485 -9.0000000000000000 },
4486 { 0.00058280040382329248, 20.000000000000000, 1.0000000000000000,
4487 -8.0000000000000000 },
4488 { -0.0049657717020590141, 20.000000000000000, 1.0000000000000000,
4489 -7.0000000000000000 },
4490 { -0.0012360336087128597, 20.000000000000000, 1.0000000000000000,
4491 -6.0000000000000000 },
4492 { 0.014898894139255305, 20.000000000000000, 1.0000000000000000,
4493 -5.0000000000000000 },
4494 { -0.013800784612552089, 20.000000000000000, 1.0000000000000000,
4495 -4.0000000000000000 },
4496 { -0.012192213426039619, 20.000000000000000, 1.0000000000000000,
4497 -3.0000000000000000 },
4498 { 0.050311246773136239, 20.000000000000000, 1.0000000000000000,
4499 -2.0000000000000000 },
4500 { -0.025985814502838461, 20.000000000000000, 1.0000000000000000,
4501 -1.0000000000000000 },
4502 { 1.0000000000000000, 20.000000000000000, 1.0000000000000000,
4503 0.0000000000000000 },
4504 { 1563.6577385252015, 20.000000000000000, 1.0000000000000000,
4505 1.0000000000000000 },
4506 { 86377.091910766278, 20.000000000000000, 1.0000000000000000,
4507 2.0000000000000000 },
4508 { 2216718.8789979252, 20.000000000000000, 1.0000000000000000,
4509 3.0000000000000000 },
4510 { 38045018.520647161, 20.000000000000000, 1.0000000000000000,
4511 4.0000000000000000 },
4512 { 504376263.68346798, 20.000000000000000, 1.0000000000000000,
4513 5.0000000000000000 },
4514 { 5565635666.7972031, 20.000000000000000, 1.0000000000000000,
4515 6.0000000000000000 },
4516 { 53451562646.544518, 20.000000000000000, 1.0000000000000000,
4517 7.0000000000000000 },
4518 { 460009135340.33868, 20.000000000000000, 1.0000000000000000,
4519 8.0000000000000000 },
4520 { 3620401937301.4907, 20.000000000000000, 1.0000000000000000,
4521 9.0000000000000000 },
4522 { 26446266822604.152, 20.000000000000000, 1.0000000000000000,
4523 10.000000000000000 },
4526 // Test function for a=20.000000000000000, c=1.0000000000000000.
4527 template <typename Tp
>
4530 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4531 Tp max_abs_diff
= -Tp(1);
4532 Tp max_abs_frac
= -Tp(1);
4533 unsigned int num_datum
= sizeof(data061
)
4534 / sizeof(testcase_conf_hyperg
<double>);
4535 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4537 const Tp f
= std::tr1::conf_hyperg(Tp(data061
[i
].a
), Tp(data061
[i
].c
),
4539 const Tp f0
= data061
[i
].f0
;
4540 const Tp diff
= f
- f0
;
4541 if (std::abs(diff
) > max_abs_diff
)
4542 max_abs_diff
= std::abs(diff
);
4543 if (std::abs(f0
) > Tp(10) * eps
4544 && std::abs(f
) > Tp(10) * eps
)
4546 const Tp frac
= diff
/ f0
;
4547 if (std::abs(frac
) > max_abs_frac
)
4548 max_abs_frac
= std::abs(frac
);
4551 VERIFY(max_abs_frac
< Tp(2.5000000000000015e-12));
4554 // Test data for a=20.000000000000000, c=2.0000000000000000.
4555 testcase_conf_hyperg
<double> data062
[] = {
4556 { 6.6647681992684102e-05, 20.000000000000000, 2.0000000000000000,
4557 -10.000000000000000 },
4558 { -3.7248253270227178e-05, 20.000000000000000, 2.0000000000000000,
4559 -9.0000000000000000 },
4560 { -0.00024392611307344028, 20.000000000000000, 2.0000000000000000,
4561 -8.0000000000000000 },
4562 { 2.4034559592246216e-05, 20.000000000000000, 2.0000000000000000,
4563 -7.0000000000000000 },
4564 { 0.00081645960584843073, 20.000000000000000, 2.0000000000000000,
4565 -6.0000000000000000 },
4566 { -0.00051326387116462115, 20.000000000000000, 2.0000000000000000,
4567 -5.0000000000000000 },
4568 { -0.0021786279856333920, 20.000000000000000, 2.0000000000000000,
4569 -4.0000000000000000 },
4570 { 0.0061029380625179973, 20.000000000000000, 2.0000000000000000,
4571 -3.0000000000000000 },
4572 { -0.011834301617155171, 20.000000000000000, 2.0000000000000000,
4573 -2.0000000000000000 },
4574 { 0.037622016973681095, 20.000000000000000, 2.0000000000000000,
4575 -1.0000000000000000 },
4576 { 1.0000000000000000, 20.000000000000000, 2.0000000000000000,
4577 0.0000000000000000 },
4578 { 303.10954080179744, 20.000000000000000, 2.0000000000000000,
4579 1.0000000000000000 },
4580 { 11508.923130556599, 20.000000000000000, 2.0000000000000000,
4581 2.0000000000000000 },
4582 { 234541.86023461280, 20.000000000000000, 2.0000000000000000,
4583 3.0000000000000000 },
4584 { 3398931.2897027107, 20.000000000000000, 2.0000000000000000,
4585 4.0000000000000000 },
4586 { 39382712.287920594, 20.000000000000000, 2.0000000000000000,
4587 5.0000000000000000 },
4588 { 388350500.37087941, 20.000000000000000, 2.0000000000000000,
4589 6.0000000000000000 },
4590 { 3385284070.5527201, 20.000000000000000, 2.0000000000000000,
4591 7.0000000000000000 },
4592 { 26751585258.405773, 20.000000000000000, 2.0000000000000000,
4593 8.0000000000000000 },
4594 { 195061928138.27673, 20.000000000000000, 2.0000000000000000,
4595 9.0000000000000000 },
4596 { 1329571695324.3132, 20.000000000000000, 2.0000000000000000,
4597 10.000000000000000 },
4600 // Test function for a=20.000000000000000, c=2.0000000000000000.
4601 template <typename Tp
>
4604 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4605 Tp max_abs_diff
= -Tp(1);
4606 Tp max_abs_frac
= -Tp(1);
4607 unsigned int num_datum
= sizeof(data062
)
4608 / sizeof(testcase_conf_hyperg
<double>);
4609 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4611 const Tp f
= std::tr1::conf_hyperg(Tp(data062
[i
].a
), Tp(data062
[i
].c
),
4613 const Tp f0
= data062
[i
].f0
;
4614 const Tp diff
= f
- f0
;
4615 if (std::abs(diff
) > max_abs_diff
)
4616 max_abs_diff
= std::abs(diff
);
4617 if (std::abs(f0
) > Tp(10) * eps
4618 && std::abs(f
) > Tp(10) * eps
)
4620 const Tp frac
= diff
/ f0
;
4621 if (std::abs(frac
) > max_abs_frac
)
4622 max_abs_frac
= std::abs(frac
);
4625 VERIFY(max_abs_frac
< Tp(2.5000000000000017e-10));
4628 // Test data for a=20.000000000000000, c=3.0000000000000000.
4629 testcase_conf_hyperg
<double> data063
[] = {
4630 { -8.6671962318505729e-06, 20.000000000000000, 3.0000000000000000,
4631 -10.000000000000000 },
4632 { -1.8205565180535418e-05, 20.000000000000000, 3.0000000000000000,
4633 -9.0000000000000000 },
4634 { 1.5620588717927631e-05, 20.000000000000000, 3.0000000000000000,
4635 -8.0000000000000000 },
4636 { 7.6532767373103759e-05, 20.000000000000000, 3.0000000000000000,
4637 -7.0000000000000000 },
4638 { -5.2708600380172109e-05, 20.000000000000000, 3.0000000000000000,
4639 -6.0000000000000000 },
4640 { -0.00028546308121326264, 20.000000000000000, 3.0000000000000000,
4641 -5.0000000000000000 },
4642 { 0.00056490746026256289, 20.000000000000000, 3.0000000000000000,
4643 -4.0000000000000000 },
4644 { -5.0602588875468348e-07, 20.000000000000000, 3.0000000000000000,
4645 -3.0000000000000000 },
4646 { -0.0021376080642211705, 20.000000000000000, 3.0000000000000000,
4647 -2.0000000000000000 },
4648 { 0.0028873127225376070, 20.000000000000000, 3.0000000000000000,
4649 -1.0000000000000000 },
4650 { 1.0000000000000000, 20.000000000000000, 3.0000000000000000,
4651 0.0000000000000000 },
4652 { 106.38207299128953, 20.000000000000000, 3.0000000000000000,
4653 1.0000000000000000 },
4654 { 2880.5734732831320, 20.000000000000000, 3.0000000000000000,
4655 2.0000000000000000 },
4656 { 47353.756965165747, 20.000000000000000, 3.0000000000000000,
4657 3.0000000000000000 },
4658 { 584732.27978148917, 20.000000000000000, 3.0000000000000000,
4659 4.0000000000000000 },
4660 { 5957333.1101321029, 20.000000000000000, 3.0000000000000000,
4661 5.0000000000000000 },
4662 { 52725595.633352734, 20.000000000000000, 3.0000000000000000,
4663 6.0000000000000000 },
4664 { 418560160.03369552, 20.000000000000000, 3.0000000000000000,
4665 7.0000000000000000 },
4666 { 3045067611.3150902, 20.000000000000000, 3.0000000000000000,
4667 8.0000000000000000 },
4668 { 20614600690.354652, 20.000000000000000, 3.0000000000000000,
4669 9.0000000000000000 },
4670 { 131344201933.74118, 20.000000000000000, 3.0000000000000000,
4671 10.000000000000000 },
4674 // Test function for a=20.000000000000000, c=3.0000000000000000.
4675 template <typename Tp
>
4678 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4679 Tp max_abs_diff
= -Tp(1);
4680 Tp max_abs_frac
= -Tp(1);
4681 unsigned int num_datum
= sizeof(data063
)
4682 / sizeof(testcase_conf_hyperg
<double>);
4683 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4685 const Tp f
= std::tr1::conf_hyperg(Tp(data063
[i
].a
), Tp(data063
[i
].c
),
4687 const Tp f0
= data063
[i
].f0
;
4688 const Tp diff
= f
- f0
;
4689 if (std::abs(diff
) > max_abs_diff
)
4690 max_abs_diff
= std::abs(diff
);
4691 if (std::abs(f0
) > Tp(10) * eps
4692 && std::abs(f
) > Tp(10) * eps
)
4694 const Tp frac
= diff
/ f0
;
4695 if (std::abs(frac
) > max_abs_frac
)
4696 max_abs_frac
= std::abs(frac
);
4699 VERIFY(max_abs_frac
< Tp(1.0000000000000007e-09));
4702 // Test data for a=20.000000000000000, c=4.0000000000000000.
4703 testcase_conf_hyperg
<double> data064
[] = {
4704 { -1.1286669552452404e-06, 20.000000000000000, 4.0000000000000000,
4705 -10.000000000000000 },
4706 { 3.9595188785137704e-06, 20.000000000000000, 4.0000000000000000,
4707 -9.0000000000000000 },
4708 { 8.6940153052790034e-06, 20.000000000000000, 4.0000000000000000,
4709 -8.0000000000000000 },
4710 { -1.0858814018067509e-05, 20.000000000000000, 4.0000000000000000,
4711 -7.0000000000000000 },
4712 { -4.1826023828710966e-05, 20.000000000000000, 4.0000000000000000,
4713 -6.0000000000000000 },
4714 { 6.6455893622436357e-05, 20.000000000000000, 4.0000000000000000,
4715 -5.0000000000000000 },
4716 { 0.00014238710517977903, 20.000000000000000, 4.0000000000000000,
4717 -4.0000000000000000 },
4718 { -0.00071796294700866132, 20.000000000000000, 4.0000000000000000,
4719 -3.0000000000000000 },
4720 { 0.0020884061677332653, 20.000000000000000, 4.0000000000000000,
4721 -2.0000000000000000 },
4722 { -0.012768833157321986, 20.000000000000000, 4.0000000000000000,
4723 -1.0000000000000000 },
4724 { 1.0000000000000000, 20.000000000000000, 4.0000000000000000,
4725 0.0000000000000000 },
4726 { 50.659916934657751, 20.000000000000000, 4.0000000000000000,
4727 1.0000000000000000 },
4728 { 1014.3134442335910, 20.000000000000000, 4.0000000000000000,
4729 2.0000000000000000 },
4730 { 13665.584449611581, 20.000000000000000, 4.0000000000000000,
4731 3.0000000000000000 },
4732 { 145123.62797278629, 20.000000000000000, 4.0000000000000000,
4733 4.0000000000000000 },
4734 { 1308144.4519382305, 20.000000000000000, 4.0000000000000000,
4735 5.0000000000000000 },
4736 { 10438124.578674613, 20.000000000000000, 4.0000000000000000,
4737 6.0000000000000000 },
4738 { 75719160.524424642, 20.000000000000000, 4.0000000000000000,
4739 7.0000000000000000 },
4740 { 508510905.96310234, 20.000000000000000, 4.0000000000000000,
4741 8.0000000000000000 },
4742 { 3203200954.5618095, 20.000000000000000, 4.0000000000000000,
4743 9.0000000000000000 },
4744 { 19111993543.124691, 20.000000000000000, 4.0000000000000000,
4745 10.000000000000000 },
4748 // Test function for a=20.000000000000000, c=4.0000000000000000.
4749 template <typename Tp
>
4752 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4753 Tp max_abs_diff
= -Tp(1);
4754 Tp max_abs_frac
= -Tp(1);
4755 unsigned int num_datum
= sizeof(data064
)
4756 / sizeof(testcase_conf_hyperg
<double>);
4757 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4759 const Tp f
= std::tr1::conf_hyperg(Tp(data064
[i
].a
), Tp(data064
[i
].c
),
4761 const Tp f0
= data064
[i
].f0
;
4762 const Tp diff
= f
- f0
;
4763 if (std::abs(diff
) > max_abs_diff
)
4764 max_abs_diff
= std::abs(diff
);
4765 if (std::abs(f0
) > Tp(10) * eps
4766 && std::abs(f
) > Tp(10) * eps
)
4768 const Tp frac
= diff
/ f0
;
4769 if (std::abs(frac
) > max_abs_frac
)
4770 max_abs_frac
= std::abs(frac
);
4773 VERIFY(max_abs_frac
< Tp(1.0000000000000007e-09));
4776 // Test data for a=20.000000000000000, c=5.0000000000000000.
4777 testcase_conf_hyperg
<double> data065
[] = {
4778 { 8.4755643455670995e-07, 20.000000000000000, 5.0000000000000000,
4779 -10.000000000000000 },
4780 { 8.5721061862565634e-07, 20.000000000000000, 5.0000000000000000,
4781 -9.0000000000000000 },
4782 { -2.8228700837555599e-06, 20.000000000000000, 5.0000000000000000,
4783 -8.0000000000000000 },
4784 { -6.6486802159657585e-06, 20.000000000000000, 5.0000000000000000,
4785 -7.0000000000000000 },
4786 { 1.1816828026110384e-05, 20.000000000000000, 5.0000000000000000,
4787 -6.0000000000000000 },
4788 { 3.6173872819745767e-05, 20.000000000000000, 5.0000000000000000,
4789 -5.0000000000000000 },
4790 { -0.00011481934287296673, 20.000000000000000, 5.0000000000000000,
4791 -4.0000000000000000 },
4792 { 1.2650647218867087e-07, 20.000000000000000, 5.0000000000000000,
4793 -3.0000000000000000 },
4794 { 0.0010626537950495971, 20.000000000000000, 5.0000000000000000,
4795 -2.0000000000000000 },
4796 { -0.0085499011205641979, 20.000000000000000, 5.0000000000000000,
4797 -1.0000000000000000 },
4798 { 1.0000000000000000, 20.000000000000000, 5.0000000000000000,
4799 0.0000000000000000 },
4800 { 29.126637808809363, 20.000000000000000, 5.0000000000000000,
4801 1.0000000000000000 },
4802 { 446.26914983518060, 20.000000000000000, 5.0000000000000000,
4803 2.0000000000000000 },
4804 { 5005.6470164856382, 20.000000000000000, 5.0000000000000000,
4805 3.0000000000000000 },
4806 { 46145.715220935213, 20.000000000000000, 5.0000000000000000,
4807 4.0000000000000000 },
4808 { 370342.18574452243, 20.000000000000000, 5.0000000000000000,
4809 5.0000000000000000 },
4810 { 2676402.7371661114, 20.000000000000000, 5.0000000000000000,
4811 6.0000000000000000 },
4812 { 17803174.102029990, 20.000000000000000, 5.0000000000000000,
4813 7.0000000000000000 },
4814 { 110674464.63597310, 20.000000000000000, 5.0000000000000000,
4815 8.0000000000000000 },
4816 { 650149739.34228516, 20.000000000000000, 5.0000000000000000,
4817 9.0000000000000000 },
4818 { 3639417243.5150661, 20.000000000000000, 5.0000000000000000,
4819 10.000000000000000 },
4822 // Test function for a=20.000000000000000, c=5.0000000000000000.
4823 template <typename Tp
>
4826 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4827 Tp max_abs_diff
= -Tp(1);
4828 Tp max_abs_frac
= -Tp(1);
4829 unsigned int num_datum
= sizeof(data065
)
4830 / sizeof(testcase_conf_hyperg
<double>);
4831 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4833 const Tp f
= std::tr1::conf_hyperg(Tp(data065
[i
].a
), Tp(data065
[i
].c
),
4835 const Tp f0
= data065
[i
].f0
;
4836 const Tp diff
= f
- f0
;
4837 if (std::abs(diff
) > max_abs_diff
)
4838 max_abs_diff
= std::abs(diff
);
4839 if (std::abs(f0
) > Tp(10) * eps
4840 && std::abs(f
) > Tp(10) * eps
)
4842 const Tp frac
= diff
/ f0
;
4843 if (std::abs(frac
) > max_abs_frac
)
4844 max_abs_frac
= std::abs(frac
);
4847 VERIFY(max_abs_frac
< Tp(1.0000000000000005e-07));
4850 // Test data for a=20.000000000000000, c=6.0000000000000000.
4851 testcase_conf_hyperg
<double> data066
[] = {
4852 { -1.9022359545309947e-08, 20.000000000000000, 6.0000000000000000,
4853 -10.000000000000000 },
4854 { -7.4533809656234677e-07, 20.000000000000000, 6.0000000000000000,
4855 -9.0000000000000000 },
4856 { -9.7852420358724059e-07, 20.000000000000000, 6.0000000000000000,
4857 -8.0000000000000000 },
4858 { 3.0181569866746340e-06, 20.000000000000000, 6.0000000000000000,
4859 -7.0000000000000000 },
4860 { 7.9816910701457280e-06, 20.000000000000000, 6.0000000000000000,
4861 -6.0000000000000000 },
4862 { -2.0133163153966078e-05, 20.000000000000000, 6.0000000000000000,
4863 -5.0000000000000000 },
4864 { -4.7462368393259678e-05, 20.000000000000000, 6.0000000000000000,
4865 -4.0000000000000000 },
4866 { 0.00031910869938964821, 20.000000000000000, 6.0000000000000000,
4867 -3.0000000000000000 },
4868 { -0.0010380528468056445, 20.000000000000000, 6.0000000000000000,
4869 -2.0000000000000000 },
4870 { 0.0084752097558651162, 20.000000000000000, 6.0000000000000000,
4871 -1.0000000000000000 },
4872 { 1.0000000000000000, 20.000000000000000, 6.0000000000000000,
4873 0.0000000000000000 },
4874 { 19.002159564861387, 20.000000000000000, 6.0000000000000000,
4875 1.0000000000000000 },
4876 { 229.93981298721295, 20.000000000000000, 6.0000000000000000,
4877 2.0000000000000000 },
4878 { 2180.3120758940981, 20.000000000000000, 6.0000000000000000,
4879 3.0000000000000000 },
4880 { 17610.732510305290, 20.000000000000000, 6.0000000000000000,
4881 4.0000000000000000 },
4882 { 126633.20907014773, 20.000000000000000, 6.0000000000000000,
4883 5.0000000000000000 },
4884 { 832692.83016874129, 20.000000000000000, 6.0000000000000000,
4885 6.0000000000000000 },
4886 { 5097225.0940651651, 20.000000000000000, 6.0000000000000000,
4887 7.0000000000000000 },
4888 { 29414585.342530537, 20.000000000000000, 6.0000000000000000,
4889 8.0000000000000000 },
4890 { 161513229.88138971, 20.000000000000000, 6.0000000000000000,
4891 9.0000000000000000 },
4892 { 849871092.10959554, 20.000000000000000, 6.0000000000000000,
4893 10.000000000000000 },
4896 // Test function for a=20.000000000000000, c=6.0000000000000000.
4897 template <typename Tp
>
4900 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4901 Tp max_abs_diff
= -Tp(1);
4902 Tp max_abs_frac
= -Tp(1);
4903 unsigned int num_datum
= sizeof(data066
)
4904 / sizeof(testcase_conf_hyperg
<double>);
4905 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4907 const Tp f
= std::tr1::conf_hyperg(Tp(data066
[i
].a
), Tp(data066
[i
].c
),
4909 const Tp f0
= data066
[i
].f0
;
4910 const Tp diff
= f
- f0
;
4911 if (std::abs(diff
) > max_abs_diff
)
4912 max_abs_diff
= std::abs(diff
);
4913 if (std::abs(f0
) > Tp(10) * eps
4914 && std::abs(f
) > Tp(10) * eps
)
4916 const Tp frac
= diff
/ f0
;
4917 if (std::abs(frac
) > max_abs_frac
)
4918 max_abs_frac
= std::abs(frac
);
4921 VERIFY(max_abs_frac
< Tp(5.0000000000000019e-07));
4924 // Test data for a=20.000000000000000, c=7.0000000000000000.
4925 testcase_conf_hyperg
<double> data067
[] = {
4926 { -1.7754301607387143e-07, 20.000000000000000, 7.0000000000000000,
4927 -10.000000000000000 },
4928 { -6.2128605089471174e-08, 20.000000000000000, 7.0000000000000000,
4929 -9.0000000000000000 },
4930 { 9.1338873372533148e-07, 20.000000000000000, 7.0000000000000000,
4931 -8.0000000000000000 },
4932 { 1.6657400269273180e-06, 20.000000000000000, 7.0000000000000000,
4933 -7.0000000000000000 },
4934 { -4.7904165143355465e-06, 20.000000000000000, 7.0000000000000000,
4935 -6.0000000000000000 },
4936 { -1.5503088351319615e-05, 20.000000000000000, 7.0000000000000000,
4937 -5.0000000000000000 },
4938 { 5.6425108496954350e-05, 20.000000000000000, 7.0000000000000000,
4939 -4.0000000000000000 },
4940 { 9.1083552345479015e-05, 20.000000000000000, 7.0000000000000000,
4941 -3.0000000000000000 },
4942 { -0.0018058773247853399, 20.000000000000000, 7.0000000000000000,
4943 -2.0000000000000000 },
4944 { 0.032850147696977763, 20.000000000000000, 7.0000000000000000,
4945 -1.0000000000000000 },
4946 { 1.0000000000000000, 20.000000000000000, 7.0000000000000000,
4947 0.0000000000000000 },
4948 { 13.551527852090816, 20.000000000000000, 7.0000000000000000,
4949 1.0000000000000000 },
4950 { 133.23579819973102, 20.000000000000000, 7.0000000000000000,
4951 2.0000000000000000 },
4952 { 1083.6769250393436, 20.000000000000000, 7.0000000000000000,
4953 3.0000000000000000 },
4954 { 7739.1410905637622, 20.000000000000000, 7.0000000000000000,
4955 4.0000000000000000 },
4956 { 50175.328973240226, 20.000000000000000, 7.0000000000000000,
4957 5.0000000000000000 },
4958 { 301599.46814102860, 20.000000000000000, 7.0000000000000000,
4959 6.0000000000000000 },
4960 { 1705051.1866143674, 20.000000000000000, 7.0000000000000000,
4961 7.0000000000000000 },
4962 { 9159788.2353733126, 20.000000000000000, 7.0000000000000000,
4963 8.0000000000000000 },
4964 { 47122070.398665302, 20.000000000000000, 7.0000000000000000,
4965 9.0000000000000000 },
4966 { 233529421.53991729, 20.000000000000000, 7.0000000000000000,
4967 10.000000000000000 },
4970 // Test function for a=20.000000000000000, c=7.0000000000000000.
4971 template <typename Tp
>
4974 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
4975 Tp max_abs_diff
= -Tp(1);
4976 Tp max_abs_frac
= -Tp(1);
4977 unsigned int num_datum
= sizeof(data067
)
4978 / sizeof(testcase_conf_hyperg
<double>);
4979 for (unsigned int i
= 0; i
< num_datum
; ++i
)
4981 const Tp f
= std::tr1::conf_hyperg(Tp(data067
[i
].a
), Tp(data067
[i
].c
),
4983 const Tp f0
= data067
[i
].f0
;
4984 const Tp diff
= f
- f0
;
4985 if (std::abs(diff
) > max_abs_diff
)
4986 max_abs_diff
= std::abs(diff
);
4987 if (std::abs(f0
) > Tp(10) * eps
4988 && std::abs(f
) > Tp(10) * eps
)
4990 const Tp frac
= diff
/ f0
;
4991 if (std::abs(frac
) > max_abs_frac
)
4992 max_abs_frac
= std::abs(frac
);
4995 VERIFY(max_abs_frac
< Tp(2.5000000000000009e-07));
4998 // Test data for a=20.000000000000000, c=8.0000000000000000.
4999 testcase_conf_hyperg
<double> data068
[] = {
5000 { 4.4385719622857060e-08, 20.000000000000000, 8.0000000000000000,
5001 -10.000000000000000 },
5002 { 2.7870855352561929e-07, 20.000000000000000, 8.0000000000000000,
5003 -9.0000000000000000 },
5004 { 2.7221706037028333e-07, 20.000000000000000, 8.0000000000000000,
5005 -8.0000000000000000 },
5006 { -1.5211293805365477e-06, 20.000000000000000, 8.0000000000000000,
5007 -7.0000000000000000 },
5008 { -4.2978336531553922e-06, 20.000000000000000, 8.0000000000000000,
5009 -6.0000000000000000 },
5010 { 1.1339557446266738e-05, 20.000000000000000, 8.0000000000000000,
5011 -5.0000000000000000 },
5012 { 5.3526365220658982e-05, 20.000000000000000, 8.0000000000000000,
5013 -4.0000000000000000 },
5014 { -0.00029461053269513242, 20.000000000000000, 8.0000000000000000,
5015 -3.0000000000000000 },
5016 { -0.00026793636646740187, 20.000000000000000, 8.0000000000000000,
5017 -2.0000000000000000 },
5018 { 0.061061258434452835, 20.000000000000000, 8.0000000000000000,
5019 -1.0000000000000000 },
5020 { 1.0000000000000000, 20.000000000000000, 8.0000000000000000,
5021 0.0000000000000000 },
5022 { 10.312756690132913, 20.000000000000000, 8.0000000000000000,
5023 1.0000000000000000 },
5024 { 84.471824856846425, 20.000000000000000, 8.0000000000000000,
5025 2.0000000000000000 },
5026 { 597.47335666854985, 20.000000000000000, 8.0000000000000000,
5027 3.0000000000000000 },
5028 { 3805.9786364107408, 20.000000000000000, 8.0000000000000000,
5029 4.0000000000000000 },
5030 { 22386.068461641658, 20.000000000000000, 8.0000000000000000,
5031 5.0000000000000000 },
5032 { 123573.63516975302, 20.000000000000000, 8.0000000000000000,
5033 6.0000000000000000 },
5034 { 647514.24141570868, 20.000000000000000, 8.0000000000000000,
5035 7.0000000000000000 },
5036 { 3247628.2434586394, 20.000000000000000, 8.0000000000000000,
5037 8.0000000000000000 },
5038 { 15690070.625286423, 20.000000000000000, 8.0000000000000000,
5039 9.0000000000000000 },
5040 { 73379158.893325061, 20.000000000000000, 8.0000000000000000,
5041 10.000000000000000 },
5044 // Test function for a=20.000000000000000, c=8.0000000000000000.
5045 template <typename Tp
>
5048 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
5049 Tp max_abs_diff
= -Tp(1);
5050 Tp max_abs_frac
= -Tp(1);
5051 unsigned int num_datum
= sizeof(data068
)
5052 / sizeof(testcase_conf_hyperg
<double>);
5053 for (unsigned int i
= 0; i
< num_datum
; ++i
)
5055 const Tp f
= std::tr1::conf_hyperg(Tp(data068
[i
].a
), Tp(data068
[i
].c
),
5057 const Tp f0
= data068
[i
].f0
;
5058 const Tp diff
= f
- f0
;
5059 if (std::abs(diff
) > max_abs_diff
)
5060 max_abs_diff
= std::abs(diff
);
5061 if (std::abs(f0
) > Tp(10) * eps
5062 && std::abs(f
) > Tp(10) * eps
)
5064 const Tp frac
= diff
/ f0
;
5065 if (std::abs(frac
) > max_abs_frac
)
5066 max_abs_frac
= std::abs(frac
);
5069 VERIFY(max_abs_frac
< Tp(1.0000000000000005e-07));
5072 // Test data for a=20.000000000000000, c=9.0000000000000000.
5073 testcase_conf_hyperg
<double> data069
[] = {
5074 { 7.3976263576568592e-08, 20.000000000000000, 9.0000000000000000,
5075 -10.000000000000000 },
5076 { -9.0753238092548416e-09, 20.000000000000000, 9.0000000000000000,
5077 -9.0000000000000000 },
5078 { -5.5549484970396693e-07, 20.000000000000000, 9.0000000000000000,
5079 -8.0000000000000000 },
5080 { -1.1104933512848787e-06, 20.000000000000000, 9.0000000000000000,
5081 -7.0000000000000000 },
5082 { 3.2483424385770483e-06, 20.000000000000000, 9.0000000000000000,
5083 -6.0000000000000000 },
5084 { 1.7493431113569438e-05, 20.000000000000000, 9.0000000000000000,
5085 -5.0000000000000000 },
5086 { -3.9066110636117253e-05, 20.000000000000000, 9.0000000000000000,
5087 -4.0000000000000000 },
5088 { -0.00040356155493308509, 20.000000000000000, 9.0000000000000000,
5089 -3.0000000000000000 },
5090 { 0.0037671531470534567, 20.000000000000000, 9.0000000000000000,
5091 -2.0000000000000000 },
5092 { 0.090944344485248449, 20.000000000000000, 9.0000000000000000,
5093 -1.0000000000000000 },
5094 { 1.0000000000000000, 20.000000000000000, 9.0000000000000000,
5095 0.0000000000000000 },
5096 { 8.2390942957149722, 20.000000000000000, 9.0000000000000000,
5097 1.0000000000000000 },
5098 { 57.468054562166706, 20.000000000000000, 9.0000000000000000,
5099 2.0000000000000000 },
5100 { 358.00109079775746, 20.000000000000000, 9.0000000000000000,
5101 3.0000000000000000 },
5102 { 2051.3704389046998, 20.000000000000000, 9.0000000000000000,
5103 4.0000000000000000 },
5104 { 11012.597503064211, 20.000000000000000, 9.0000000000000000,
5105 5.0000000000000000 },
5106 { 56082.113308934473, 20.000000000000000, 9.0000000000000000,
5107 6.0000000000000000 },
5108 { 273348.46918863337, 20.000000000000000, 9.0000000000000000,
5109 7.0000000000000000 },
5110 { 1283674.4996444662, 20.000000000000000, 9.0000000000000000,
5111 8.0000000000000000 },
5112 { 5838026.8730425332, 20.000000000000000, 9.0000000000000000,
5113 9.0000000000000000 },
5114 { 25817349.972859707, 20.000000000000000, 9.0000000000000000,
5115 10.000000000000000 },
5118 // Test function for a=20.000000000000000, c=9.0000000000000000.
5119 template <typename Tp
>
5122 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
5123 Tp max_abs_diff
= -Tp(1);
5124 Tp max_abs_frac
= -Tp(1);
5125 unsigned int num_datum
= sizeof(data069
)
5126 / sizeof(testcase_conf_hyperg
<double>);
5127 for (unsigned int i
= 0; i
< num_datum
; ++i
)
5129 const Tp f
= std::tr1::conf_hyperg(Tp(data069
[i
].a
), Tp(data069
[i
].c
),
5131 const Tp f0
= data069
[i
].f0
;
5132 const Tp diff
= f
- f0
;
5133 if (std::abs(diff
) > max_abs_diff
)
5134 max_abs_diff
= std::abs(diff
);
5135 if (std::abs(f0
) > Tp(10) * eps
5136 && std::abs(f
) > Tp(10) * eps
)
5138 const Tp frac
= diff
/ f0
;
5139 if (std::abs(frac
) > max_abs_frac
)
5140 max_abs_frac
= std::abs(frac
);
5143 VERIFY(max_abs_frac
< Tp(1.0000000000000004e-06));
5146 // Test data for a=20.000000000000000, c=10.000000000000000.
5147 testcase_conf_hyperg
<double> data070
[] = {
5148 { -4.1157677792944940e-08, 20.000000000000000, 10.000000000000000,
5149 -10.000000000000000 },
5150 { -2.0187210039960906e-07, 20.000000000000000, 10.000000000000000,
5151 -9.0000000000000000 },
5152 { -2.2272304939386817e-07, 20.000000000000000, 10.000000000000000,
5153 -8.0000000000000000 },
5154 { 1.2925568212606171e-06, 20.000000000000000, 10.000000000000000,
5155 -7.0000000000000000 },
5156 { 5.5744573775996227e-06, 20.000000000000000, 10.000000000000000,
5157 -6.0000000000000000 },
5158 { -6.2568272011787340e-06, 20.000000000000000, 10.000000000000000,
5159 -5.0000000000000000 },
5160 { -0.00011955177906335608, 20.000000000000000, 10.000000000000000,
5161 -4.0000000000000000 },
5162 { 9.2475405516991078e-05, 20.000000000000000, 10.000000000000000,
5163 -3.0000000000000000 },
5164 { 0.010123531287569982, 20.000000000000000, 10.000000000000000,
5165 -2.0000000000000000 },
5166 { 0.12118937229909535, 20.000000000000000, 10.000000000000000,
5167 -1.0000000000000000 },
5168 { 1.0000000000000000, 20.000000000000000, 10.000000000000000,
5169 0.0000000000000000 },
5170 { 6.8319857942415494, 20.000000000000000, 10.000000000000000,
5171 1.0000000000000000 },
5172 { 41.356658140815220, 20.000000000000000, 10.000000000000000,
5173 2.0000000000000000 },
5174 { 229.57496033810907, 20.000000000000000, 10.000000000000000,
5175 3.0000000000000000 },
5176 { 1192.7830549969506, 20.000000000000000, 10.000000000000000,
5177 4.0000000000000000 },
5178 { 5878.6003887215920, 20.000000000000000, 10.000000000000000,
5179 5.0000000000000000 },
5180 { 27741.749322673899, 20.000000000000000, 10.000000000000000,
5181 6.0000000000000000 },
5182 { 126220.54599305884, 20.000000000000000, 10.000000000000000,
5183 7.0000000000000000 },
5184 { 556592.10886612453, 20.000000000000000, 10.000000000000000,
5185 8.0000000000000000 },
5186 { 2388555.2873243922, 20.000000000000000, 10.000000000000000,
5187 9.0000000000000000 },
5188 { 10008079.497419352, 20.000000000000000, 10.000000000000000,
5189 10.000000000000000 },
5192 // Test function for a=20.000000000000000, c=10.000000000000000.
5193 template <typename Tp
>
5196 const Tp eps
= std::numeric_limits
<Tp
>::epsilon();
5197 Tp max_abs_diff
= -Tp(1);
5198 Tp max_abs_frac
= -Tp(1);
5199 unsigned int num_datum
= sizeof(data070
)
5200 / sizeof(testcase_conf_hyperg
<double>);
5201 for (unsigned int i
= 0; i
< num_datum
; ++i
)
5203 const Tp f
= std::tr1::conf_hyperg(Tp(data070
[i
].a
), Tp(data070
[i
].c
),
5205 const Tp f0
= data070
[i
].f0
;
5206 const Tp diff
= f
- f0
;
5207 if (std::abs(diff
) > max_abs_diff
)
5208 max_abs_diff
= std::abs(diff
);
5209 if (std::abs(f0
) > Tp(10) * eps
5210 && std::abs(f
) > Tp(10) * eps
)
5212 const Tp frac
= diff
/ f0
;
5213 if (std::abs(frac
) > max_abs_frac
)
5214 max_abs_frac
= std::abs(frac
);
5217 VERIFY(max_abs_frac
< Tp(2.5000000000000009e-07));
5220 int main(int, char**)