1 // 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net>
2 //
3 // Copyright (C) 2007-2014 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 //
16 // You should have received a copy of the GNU General Public License along
17 // with this library; see the file COPYING3. If not see
18 // <http://www.gnu.org/licenses/>.
19
20 // conf_hyperg
21
22
23 // Compare against values generated by the GNU Scientific Library.
24 // The GSL can be found on the web: http://www.gnu.org/software/gsl/
25
26 #include <tr1/cmath>
27 #if defined(__TEST_DEBUG)
28 #include <iostream>
29 #define VERIFY(A) \
30 if (!(A)) \
31 { \
32 std::cout << "line " << __LINE__ \
33 << " max_abs_frac = " << max_abs_frac \
34 << std::endl; \
35 }
36 #else
37 #include <testsuite_hooks.h>
38 #endif
39 #include "../testcase.h"
40
41
42 // Test data for 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,
65 0.0000000000000000 },
66 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
67 1.0000000000000000 },
68 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
69 2.0000000000000000 },
70 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
71 3.0000000000000000 },
72 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
73 4.0000000000000000 },
74 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
75 5.0000000000000000 },
76 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
77 6.0000000000000000 },
78 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
79 7.0000000000000000 },
80 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
81 8.0000000000000000 },
82 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
83 9.0000000000000000 },
84 { 1.0000000000000000, 0.0000000000000000, 1.0000000000000000,
85 10.000000000000000 },
86 };
87
88 // Test function for a=0.0000000000000000, c=1.0000000000000000.
89 template <typename Tp>
test001()90 void test001()
91 {
92 const Tp eps = std::numeric_limits<Tp>::epsilon();
93 Tp max_abs_diff = -Tp(1);
94 Tp max_abs_frac = -Tp(1);
95 unsigned int num_datum = sizeof(data001)
96 / sizeof(testcase_conf_hyperg<double>);
97 for (unsigned int i = 0; i < num_datum; ++i)
98 {
99 const Tp f = std::tr1::conf_hyperg(Tp(data001[i].a), Tp(data001[i].c),
100 Tp(data001[i].x));
101 const Tp f0 = data001[i].f0;
102 const Tp diff = f - f0;
103 if (std::abs(diff) > max_abs_diff)
104 max_abs_diff = std::abs(diff);
105 if (std::abs(f0) > Tp(10) * eps
106 && std::abs(f) > Tp(10) * eps)
107 {
108 const Tp frac = diff / f0;
109 if (std::abs(frac) > max_abs_frac)
110 max_abs_frac = std::abs(frac);
111 }
112 }
113 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
114 }
115
116 // Test data for 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 },
160 };
161
162 // Test function for a=0.0000000000000000, c=2.0000000000000000.
163 template <typename Tp>
test002()164 void test002()
165 {
166 const Tp eps = std::numeric_limits<Tp>::epsilon();
167 Tp max_abs_diff = -Tp(1);
168 Tp max_abs_frac = -Tp(1);
169 unsigned int num_datum = sizeof(data002)
170 / sizeof(testcase_conf_hyperg<double>);
171 for (unsigned int i = 0; i < num_datum; ++i)
172 {
173 const Tp f = std::tr1::conf_hyperg(Tp(data002[i].a), Tp(data002[i].c),
174 Tp(data002[i].x));
175 const Tp f0 = data002[i].f0;
176 const Tp diff = f - f0;
177 if (std::abs(diff) > max_abs_diff)
178 max_abs_diff = std::abs(diff);
179 if (std::abs(f0) > Tp(10) * eps
180 && std::abs(f) > Tp(10) * eps)
181 {
182 const Tp frac = diff / f0;
183 if (std::abs(frac) > max_abs_frac)
184 max_abs_frac = std::abs(frac);
185 }
186 }
187 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
188 }
189
190 // Test data for 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 },
234 };
235
236 // Test function for a=0.0000000000000000, c=3.0000000000000000.
237 template <typename Tp>
test003()238 void test003()
239 {
240 const Tp eps = std::numeric_limits<Tp>::epsilon();
241 Tp max_abs_diff = -Tp(1);
242 Tp max_abs_frac = -Tp(1);
243 unsigned int num_datum = sizeof(data003)
244 / sizeof(testcase_conf_hyperg<double>);
245 for (unsigned int i = 0; i < num_datum; ++i)
246 {
247 const Tp f = std::tr1::conf_hyperg(Tp(data003[i].a), Tp(data003[i].c),
248 Tp(data003[i].x));
249 const Tp f0 = data003[i].f0;
250 const Tp diff = f - f0;
251 if (std::abs(diff) > max_abs_diff)
252 max_abs_diff = std::abs(diff);
253 if (std::abs(f0) > Tp(10) * eps
254 && std::abs(f) > Tp(10) * eps)
255 {
256 const Tp frac = diff / f0;
257 if (std::abs(frac) > max_abs_frac)
258 max_abs_frac = std::abs(frac);
259 }
260 }
261 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
262 }
263
264 // Test data for 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 },
308 };
309
310 // Test function for a=0.0000000000000000, c=4.0000000000000000.
311 template <typename Tp>
test004()312 void test004()
313 {
314 const Tp eps = std::numeric_limits<Tp>::epsilon();
315 Tp max_abs_diff = -Tp(1);
316 Tp max_abs_frac = -Tp(1);
317 unsigned int num_datum = sizeof(data004)
318 / sizeof(testcase_conf_hyperg<double>);
319 for (unsigned int i = 0; i < num_datum; ++i)
320 {
321 const Tp f = std::tr1::conf_hyperg(Tp(data004[i].a), Tp(data004[i].c),
322 Tp(data004[i].x));
323 const Tp f0 = data004[i].f0;
324 const Tp diff = f - f0;
325 if (std::abs(diff) > max_abs_diff)
326 max_abs_diff = std::abs(diff);
327 if (std::abs(f0) > Tp(10) * eps
328 && std::abs(f) > Tp(10) * eps)
329 {
330 const Tp frac = diff / f0;
331 if (std::abs(frac) > max_abs_frac)
332 max_abs_frac = std::abs(frac);
333 }
334 }
335 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
336 }
337
338 // Test data for 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 },
382 };
383
384 // Test function for a=0.0000000000000000, c=5.0000000000000000.
385 template <typename Tp>
test005()386 void test005()
387 {
388 const Tp eps = std::numeric_limits<Tp>::epsilon();
389 Tp max_abs_diff = -Tp(1);
390 Tp max_abs_frac = -Tp(1);
391 unsigned int num_datum = sizeof(data005)
392 / sizeof(testcase_conf_hyperg<double>);
393 for (unsigned int i = 0; i < num_datum; ++i)
394 {
395 const Tp f = std::tr1::conf_hyperg(Tp(data005[i].a), Tp(data005[i].c),
396 Tp(data005[i].x));
397 const Tp f0 = data005[i].f0;
398 const Tp diff = f - f0;
399 if (std::abs(diff) > max_abs_diff)
400 max_abs_diff = std::abs(diff);
401 if (std::abs(f0) > Tp(10) * eps
402 && std::abs(f) > Tp(10) * eps)
403 {
404 const Tp frac = diff / f0;
405 if (std::abs(frac) > max_abs_frac)
406 max_abs_frac = std::abs(frac);
407 }
408 }
409 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
410 }
411
412 // Test data for 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 },
456 };
457
458 // Test function for a=0.0000000000000000, c=6.0000000000000000.
459 template <typename Tp>
test006()460 void test006()
461 {
462 const Tp eps = std::numeric_limits<Tp>::epsilon();
463 Tp max_abs_diff = -Tp(1);
464 Tp max_abs_frac = -Tp(1);
465 unsigned int num_datum = sizeof(data006)
466 / sizeof(testcase_conf_hyperg<double>);
467 for (unsigned int i = 0; i < num_datum; ++i)
468 {
469 const Tp f = std::tr1::conf_hyperg(Tp(data006[i].a), Tp(data006[i].c),
470 Tp(data006[i].x));
471 const Tp f0 = data006[i].f0;
472 const Tp diff = f - f0;
473 if (std::abs(diff) > max_abs_diff)
474 max_abs_diff = std::abs(diff);
475 if (std::abs(f0) > Tp(10) * eps
476 && std::abs(f) > Tp(10) * eps)
477 {
478 const Tp frac = diff / f0;
479 if (std::abs(frac) > max_abs_frac)
480 max_abs_frac = std::abs(frac);
481 }
482 }
483 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
484 }
485
486 // Test data for 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 },
530 };
531
532 // Test function for a=0.0000000000000000, c=7.0000000000000000.
533 template <typename Tp>
test007()534 void test007()
535 {
536 const Tp eps = std::numeric_limits<Tp>::epsilon();
537 Tp max_abs_diff = -Tp(1);
538 Tp max_abs_frac = -Tp(1);
539 unsigned int num_datum = sizeof(data007)
540 / sizeof(testcase_conf_hyperg<double>);
541 for (unsigned int i = 0; i < num_datum; ++i)
542 {
543 const Tp f = std::tr1::conf_hyperg(Tp(data007[i].a), Tp(data007[i].c),
544 Tp(data007[i].x));
545 const Tp f0 = data007[i].f0;
546 const Tp diff = f - f0;
547 if (std::abs(diff) > max_abs_diff)
548 max_abs_diff = std::abs(diff);
549 if (std::abs(f0) > Tp(10) * eps
550 && std::abs(f) > Tp(10) * eps)
551 {
552 const Tp frac = diff / f0;
553 if (std::abs(frac) > max_abs_frac)
554 max_abs_frac = std::abs(frac);
555 }
556 }
557 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
558 }
559
560 // Test data for 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 },
604 };
605
606 // Test function for a=0.0000000000000000, c=8.0000000000000000.
607 template <typename Tp>
test008()608 void test008()
609 {
610 const Tp eps = std::numeric_limits<Tp>::epsilon();
611 Tp max_abs_diff = -Tp(1);
612 Tp max_abs_frac = -Tp(1);
613 unsigned int num_datum = sizeof(data008)
614 / sizeof(testcase_conf_hyperg<double>);
615 for (unsigned int i = 0; i < num_datum; ++i)
616 {
617 const Tp f = std::tr1::conf_hyperg(Tp(data008[i].a), Tp(data008[i].c),
618 Tp(data008[i].x));
619 const Tp f0 = data008[i].f0;
620 const Tp diff = f - f0;
621 if (std::abs(diff) > max_abs_diff)
622 max_abs_diff = std::abs(diff);
623 if (std::abs(f0) > Tp(10) * eps
624 && std::abs(f) > Tp(10) * eps)
625 {
626 const Tp frac = diff / f0;
627 if (std::abs(frac) > max_abs_frac)
628 max_abs_frac = std::abs(frac);
629 }
630 }
631 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
632 }
633
634 // Test data for 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 },
678 };
679
680 // Test function for a=0.0000000000000000, c=9.0000000000000000.
681 template <typename Tp>
test009()682 void test009()
683 {
684 const Tp eps = std::numeric_limits<Tp>::epsilon();
685 Tp max_abs_diff = -Tp(1);
686 Tp max_abs_frac = -Tp(1);
687 unsigned int num_datum = sizeof(data009)
688 / sizeof(testcase_conf_hyperg<double>);
689 for (unsigned int i = 0; i < num_datum; ++i)
690 {
691 const Tp f = std::tr1::conf_hyperg(Tp(data009[i].a), Tp(data009[i].c),
692 Tp(data009[i].x));
693 const Tp f0 = data009[i].f0;
694 const Tp diff = f - f0;
695 if (std::abs(diff) > max_abs_diff)
696 max_abs_diff = std::abs(diff);
697 if (std::abs(f0) > Tp(10) * eps
698 && std::abs(f) > Tp(10) * eps)
699 {
700 const Tp frac = diff / f0;
701 if (std::abs(frac) > max_abs_frac)
702 max_abs_frac = std::abs(frac);
703 }
704 }
705 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
706 }
707
708 // Test data for 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 },
752 };
753
754 // Test function for a=0.0000000000000000, c=10.000000000000000.
755 template <typename Tp>
test010()756 void test010()
757 {
758 const Tp eps = std::numeric_limits<Tp>::epsilon();
759 Tp max_abs_diff = -Tp(1);
760 Tp max_abs_frac = -Tp(1);
761 unsigned int num_datum = sizeof(data010)
762 / sizeof(testcase_conf_hyperg<double>);
763 for (unsigned int i = 0; i < num_datum; ++i)
764 {
765 const Tp f = std::tr1::conf_hyperg(Tp(data010[i].a), Tp(data010[i].c),
766 Tp(data010[i].x));
767 const Tp f0 = data010[i].f0;
768 const Tp diff = f - f0;
769 if (std::abs(diff) > max_abs_diff)
770 max_abs_diff = std::abs(diff);
771 if (std::abs(f0) > Tp(10) * eps
772 && std::abs(f) > Tp(10) * eps)
773 {
774 const Tp frac = diff / f0;
775 if (std::abs(frac) > max_abs_frac)
776 max_abs_frac = std::abs(frac);
777 }
778 }
779 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
780 }
781
782 // Test data for 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 },
826 };
827
828 // Test function for a=0.50000000000000000, c=1.0000000000000000.
829 template <typename Tp>
test011()830 void test011()
831 {
832 const Tp eps = std::numeric_limits<Tp>::epsilon();
833 Tp max_abs_diff = -Tp(1);
834 Tp max_abs_frac = -Tp(1);
835 unsigned int num_datum = sizeof(data011)
836 / sizeof(testcase_conf_hyperg<double>);
837 for (unsigned int i = 0; i < num_datum; ++i)
838 {
839 const Tp f = std::tr1::conf_hyperg(Tp(data011[i].a), Tp(data011[i].c),
840 Tp(data011[i].x));
841 const Tp f0 = data011[i].f0;
842 const Tp diff = f - f0;
843 if (std::abs(diff) > max_abs_diff)
844 max_abs_diff = std::abs(diff);
845 if (std::abs(f0) > Tp(10) * eps
846 && std::abs(f) > Tp(10) * eps)
847 {
848 const Tp frac = diff / f0;
849 if (std::abs(frac) > max_abs_frac)
850 max_abs_frac = std::abs(frac);
851 }
852 }
853 VERIFY(max_abs_frac < Tp(1.0000000000000006e-11));
854 }
855
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 },
900 };
901
902 // Test function for a=0.50000000000000000, c=2.0000000000000000.
903 template <typename Tp>
test012()904 void test012()
905 {
906 const Tp eps = std::numeric_limits<Tp>::epsilon();
907 Tp max_abs_diff = -Tp(1);
908 Tp max_abs_frac = -Tp(1);
909 unsigned int num_datum = sizeof(data012)
910 / sizeof(testcase_conf_hyperg<double>);
911 for (unsigned int i = 0; i < num_datum; ++i)
912 {
913 const Tp f = std::tr1::conf_hyperg(Tp(data012[i].a), Tp(data012[i].c),
914 Tp(data012[i].x));
915 const Tp f0 = data012[i].f0;
916 const Tp diff = f - f0;
917 if (std::abs(diff) > max_abs_diff)
918 max_abs_diff = std::abs(diff);
919 if (std::abs(f0) > Tp(10) * eps
920 && std::abs(f) > Tp(10) * eps)
921 {
922 const Tp frac = diff / f0;
923 if (std::abs(frac) > max_abs_frac)
924 max_abs_frac = std::abs(frac);
925 }
926 }
927 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
928 }
929
930 // Test data for 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 },
974 };
975
976 // Test function for a=0.50000000000000000, c=3.0000000000000000.
977 template <typename Tp>
test013()978 void test013()
979 {
980 const Tp eps = std::numeric_limits<Tp>::epsilon();
981 Tp max_abs_diff = -Tp(1);
982 Tp max_abs_frac = -Tp(1);
983 unsigned int num_datum = sizeof(data013)
984 / sizeof(testcase_conf_hyperg<double>);
985 for (unsigned int i = 0; i < num_datum; ++i)
986 {
987 const Tp f = std::tr1::conf_hyperg(Tp(data013[i].a), Tp(data013[i].c),
988 Tp(data013[i].x));
989 const Tp f0 = data013[i].f0;
990 const Tp diff = f - f0;
991 if (std::abs(diff) > max_abs_diff)
992 max_abs_diff = std::abs(diff);
993 if (std::abs(f0) > Tp(10) * eps
994 && std::abs(f) > Tp(10) * eps)
995 {
996 const Tp frac = diff / f0;
997 if (std::abs(frac) > max_abs_frac)
998 max_abs_frac = std::abs(frac);
999 }
1000 }
1001 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1002 }
1003
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 },
1048 };
1049
1050 // Test function for a=0.50000000000000000, c=4.0000000000000000.
1051 template <typename Tp>
test014()1052 void test014()
1053 {
1054 const Tp eps = std::numeric_limits<Tp>::epsilon();
1055 Tp max_abs_diff = -Tp(1);
1056 Tp max_abs_frac = -Tp(1);
1057 unsigned int num_datum = sizeof(data014)
1058 / sizeof(testcase_conf_hyperg<double>);
1059 for (unsigned int i = 0; i < num_datum; ++i)
1060 {
1061 const Tp f = std::tr1::conf_hyperg(Tp(data014[i].a), Tp(data014[i].c),
1062 Tp(data014[i].x));
1063 const Tp f0 = data014[i].f0;
1064 const Tp diff = f - f0;
1065 if (std::abs(diff) > max_abs_diff)
1066 max_abs_diff = std::abs(diff);
1067 if (std::abs(f0) > Tp(10) * eps
1068 && std::abs(f) > Tp(10) * eps)
1069 {
1070 const Tp frac = diff / f0;
1071 if (std::abs(frac) > max_abs_frac)
1072 max_abs_frac = std::abs(frac);
1073 }
1074 }
1075 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1076 }
1077
1078 // Test data for 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 },
1122 };
1123
1124 // Test function for a=0.50000000000000000, c=5.0000000000000000.
1125 template <typename Tp>
test015()1126 void test015()
1127 {
1128 const Tp eps = std::numeric_limits<Tp>::epsilon();
1129 Tp max_abs_diff = -Tp(1);
1130 Tp max_abs_frac = -Tp(1);
1131 unsigned int num_datum = sizeof(data015)
1132 / sizeof(testcase_conf_hyperg<double>);
1133 for (unsigned int i = 0; i < num_datum; ++i)
1134 {
1135 const Tp f = std::tr1::conf_hyperg(Tp(data015[i].a), Tp(data015[i].c),
1136 Tp(data015[i].x));
1137 const Tp f0 = data015[i].f0;
1138 const Tp diff = f - f0;
1139 if (std::abs(diff) > max_abs_diff)
1140 max_abs_diff = std::abs(diff);
1141 if (std::abs(f0) > Tp(10) * eps
1142 && std::abs(f) > Tp(10) * eps)
1143 {
1144 const Tp frac = diff / f0;
1145 if (std::abs(frac) > max_abs_frac)
1146 max_abs_frac = std::abs(frac);
1147 }
1148 }
1149 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1150 }
1151
1152 // Test data for 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 },
1196 };
1197
1198 // Test function for a=0.50000000000000000, c=6.0000000000000000.
1199 template <typename Tp>
test016()1200 void test016()
1201 {
1202 const Tp eps = std::numeric_limits<Tp>::epsilon();
1203 Tp max_abs_diff = -Tp(1);
1204 Tp max_abs_frac = -Tp(1);
1205 unsigned int num_datum = sizeof(data016)
1206 / sizeof(testcase_conf_hyperg<double>);
1207 for (unsigned int i = 0; i < num_datum; ++i)
1208 {
1209 const Tp f = std::tr1::conf_hyperg(Tp(data016[i].a), Tp(data016[i].c),
1210 Tp(data016[i].x));
1211 const Tp f0 = data016[i].f0;
1212 const Tp diff = f - f0;
1213 if (std::abs(diff) > max_abs_diff)
1214 max_abs_diff = std::abs(diff);
1215 if (std::abs(f0) > Tp(10) * eps
1216 && std::abs(f) > Tp(10) * eps)
1217 {
1218 const Tp frac = diff / f0;
1219 if (std::abs(frac) > max_abs_frac)
1220 max_abs_frac = std::abs(frac);
1221 }
1222 }
1223 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1224 }
1225
1226 // Test data for 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 },
1270 };
1271
1272 // Test function for a=0.50000000000000000, c=7.0000000000000000.
1273 template <typename Tp>
test017()1274 void test017()
1275 {
1276 const Tp eps = std::numeric_limits<Tp>::epsilon();
1277 Tp max_abs_diff = -Tp(1);
1278 Tp max_abs_frac = -Tp(1);
1279 unsigned int num_datum = sizeof(data017)
1280 / sizeof(testcase_conf_hyperg<double>);
1281 for (unsigned int i = 0; i < num_datum; ++i)
1282 {
1283 const Tp f = std::tr1::conf_hyperg(Tp(data017[i].a), Tp(data017[i].c),
1284 Tp(data017[i].x));
1285 const Tp f0 = data017[i].f0;
1286 const Tp diff = f - f0;
1287 if (std::abs(diff) > max_abs_diff)
1288 max_abs_diff = std::abs(diff);
1289 if (std::abs(f0) > Tp(10) * eps
1290 && std::abs(f) > Tp(10) * eps)
1291 {
1292 const Tp frac = diff / f0;
1293 if (std::abs(frac) > max_abs_frac)
1294 max_abs_frac = std::abs(frac);
1295 }
1296 }
1297 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1298 }
1299
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 },
1344 };
1345
1346 // Test function for a=0.50000000000000000, c=8.0000000000000000.
1347 template <typename Tp>
test018()1348 void test018()
1349 {
1350 const Tp eps = std::numeric_limits<Tp>::epsilon();
1351 Tp max_abs_diff = -Tp(1);
1352 Tp max_abs_frac = -Tp(1);
1353 unsigned int num_datum = sizeof(data018)
1354 / sizeof(testcase_conf_hyperg<double>);
1355 for (unsigned int i = 0; i < num_datum; ++i)
1356 {
1357 const Tp f = std::tr1::conf_hyperg(Tp(data018[i].a), Tp(data018[i].c),
1358 Tp(data018[i].x));
1359 const Tp f0 = data018[i].f0;
1360 const Tp diff = f - f0;
1361 if (std::abs(diff) > max_abs_diff)
1362 max_abs_diff = std::abs(diff);
1363 if (std::abs(f0) > Tp(10) * eps
1364 && std::abs(f) > Tp(10) * eps)
1365 {
1366 const Tp frac = diff / f0;
1367 if (std::abs(frac) > max_abs_frac)
1368 max_abs_frac = std::abs(frac);
1369 }
1370 }
1371 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1372 }
1373
1374 // Test data for 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 },
1418 };
1419
1420 // Test function for a=0.50000000000000000, c=9.0000000000000000.
1421 template <typename Tp>
test019()1422 void test019()
1423 {
1424 const Tp eps = std::numeric_limits<Tp>::epsilon();
1425 Tp max_abs_diff = -Tp(1);
1426 Tp max_abs_frac = -Tp(1);
1427 unsigned int num_datum = sizeof(data019)
1428 / sizeof(testcase_conf_hyperg<double>);
1429 for (unsigned int i = 0; i < num_datum; ++i)
1430 {
1431 const Tp f = std::tr1::conf_hyperg(Tp(data019[i].a), Tp(data019[i].c),
1432 Tp(data019[i].x));
1433 const Tp f0 = data019[i].f0;
1434 const Tp diff = f - f0;
1435 if (std::abs(diff) > max_abs_diff)
1436 max_abs_diff = std::abs(diff);
1437 if (std::abs(f0) > Tp(10) * eps
1438 && std::abs(f) > Tp(10) * eps)
1439 {
1440 const Tp frac = diff / f0;
1441 if (std::abs(frac) > max_abs_frac)
1442 max_abs_frac = std::abs(frac);
1443 }
1444 }
1445 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1446 }
1447
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 },
1492 };
1493
1494 // Test function for a=0.50000000000000000, c=10.000000000000000.
1495 template <typename Tp>
test020()1496 void test020()
1497 {
1498 const Tp eps = std::numeric_limits<Tp>::epsilon();
1499 Tp max_abs_diff = -Tp(1);
1500 Tp max_abs_frac = -Tp(1);
1501 unsigned int num_datum = sizeof(data020)
1502 / sizeof(testcase_conf_hyperg<double>);
1503 for (unsigned int i = 0; i < num_datum; ++i)
1504 {
1505 const Tp f = std::tr1::conf_hyperg(Tp(data020[i].a), Tp(data020[i].c),
1506 Tp(data020[i].x));
1507 const Tp f0 = data020[i].f0;
1508 const Tp diff = f - f0;
1509 if (std::abs(diff) > max_abs_diff)
1510 max_abs_diff = std::abs(diff);
1511 if (std::abs(f0) > Tp(10) * eps
1512 && std::abs(f) > Tp(10) * eps)
1513 {
1514 const Tp frac = diff / f0;
1515 if (std::abs(frac) > max_abs_frac)
1516 max_abs_frac = std::abs(frac);
1517 }
1518 }
1519 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1520 }
1521
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 },
1566 };
1567
1568 // Test function for a=1.0000000000000000, c=1.0000000000000000.
1569 template <typename Tp>
test021()1570 void test021()
1571 {
1572 const Tp eps = std::numeric_limits<Tp>::epsilon();
1573 Tp max_abs_diff = -Tp(1);
1574 Tp max_abs_frac = -Tp(1);
1575 unsigned int num_datum = sizeof(data021)
1576 / sizeof(testcase_conf_hyperg<double>);
1577 for (unsigned int i = 0; i < num_datum; ++i)
1578 {
1579 const Tp f = std::tr1::conf_hyperg(Tp(data021[i].a), Tp(data021[i].c),
1580 Tp(data021[i].x));
1581 const Tp f0 = data021[i].f0;
1582 const Tp diff = f - f0;
1583 if (std::abs(diff) > max_abs_diff)
1584 max_abs_diff = std::abs(diff);
1585 if (std::abs(f0) > Tp(10) * eps
1586 && std::abs(f) > Tp(10) * eps)
1587 {
1588 const Tp frac = diff / f0;
1589 if (std::abs(frac) > max_abs_frac)
1590 max_abs_frac = std::abs(frac);
1591 }
1592 }
1593 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1594 }
1595
1596 // Test data for 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 },
1640 };
1641
1642 // Test function for a=1.0000000000000000, c=2.0000000000000000.
1643 template <typename Tp>
test022()1644 void test022()
1645 {
1646 const Tp eps = std::numeric_limits<Tp>::epsilon();
1647 Tp max_abs_diff = -Tp(1);
1648 Tp max_abs_frac = -Tp(1);
1649 unsigned int num_datum = sizeof(data022)
1650 / sizeof(testcase_conf_hyperg<double>);
1651 for (unsigned int i = 0; i < num_datum; ++i)
1652 {
1653 const Tp f = std::tr1::conf_hyperg(Tp(data022[i].a), Tp(data022[i].c),
1654 Tp(data022[i].x));
1655 const Tp f0 = data022[i].f0;
1656 const Tp diff = f - f0;
1657 if (std::abs(diff) > max_abs_diff)
1658 max_abs_diff = std::abs(diff);
1659 if (std::abs(f0) > Tp(10) * eps
1660 && std::abs(f) > Tp(10) * eps)
1661 {
1662 const Tp frac = diff / f0;
1663 if (std::abs(frac) > max_abs_frac)
1664 max_abs_frac = std::abs(frac);
1665 }
1666 }
1667 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1668 }
1669
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 },
1714 };
1715
1716 // Test function for a=1.0000000000000000, c=3.0000000000000000.
1717 template <typename Tp>
test023()1718 void test023()
1719 {
1720 const Tp eps = std::numeric_limits<Tp>::epsilon();
1721 Tp max_abs_diff = -Tp(1);
1722 Tp max_abs_frac = -Tp(1);
1723 unsigned int num_datum = sizeof(data023)
1724 / sizeof(testcase_conf_hyperg<double>);
1725 for (unsigned int i = 0; i < num_datum; ++i)
1726 {
1727 const Tp f = std::tr1::conf_hyperg(Tp(data023[i].a), Tp(data023[i].c),
1728 Tp(data023[i].x));
1729 const Tp f0 = data023[i].f0;
1730 const Tp diff = f - f0;
1731 if (std::abs(diff) > max_abs_diff)
1732 max_abs_diff = std::abs(diff);
1733 if (std::abs(f0) > Tp(10) * eps
1734 && std::abs(f) > Tp(10) * eps)
1735 {
1736 const Tp frac = diff / f0;
1737 if (std::abs(frac) > max_abs_frac)
1738 max_abs_frac = std::abs(frac);
1739 }
1740 }
1741 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1742 }
1743
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 },
1788 };
1789
1790 // Test function for a=1.0000000000000000, c=4.0000000000000000.
1791 template <typename Tp>
test024()1792 void test024()
1793 {
1794 const Tp eps = std::numeric_limits<Tp>::epsilon();
1795 Tp max_abs_diff = -Tp(1);
1796 Tp max_abs_frac = -Tp(1);
1797 unsigned int num_datum = sizeof(data024)
1798 / sizeof(testcase_conf_hyperg<double>);
1799 for (unsigned int i = 0; i < num_datum; ++i)
1800 {
1801 const Tp f = std::tr1::conf_hyperg(Tp(data024[i].a), Tp(data024[i].c),
1802 Tp(data024[i].x));
1803 const Tp f0 = data024[i].f0;
1804 const Tp diff = f - f0;
1805 if (std::abs(diff) > max_abs_diff)
1806 max_abs_diff = std::abs(diff);
1807 if (std::abs(f0) > Tp(10) * eps
1808 && std::abs(f) > Tp(10) * eps)
1809 {
1810 const Tp frac = diff / f0;
1811 if (std::abs(frac) > max_abs_frac)
1812 max_abs_frac = std::abs(frac);
1813 }
1814 }
1815 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1816 }
1817
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 },
1862 };
1863
1864 // Test function for a=1.0000000000000000, c=5.0000000000000000.
1865 template <typename Tp>
test025()1866 void test025()
1867 {
1868 const Tp eps = std::numeric_limits<Tp>::epsilon();
1869 Tp max_abs_diff = -Tp(1);
1870 Tp max_abs_frac = -Tp(1);
1871 unsigned int num_datum = sizeof(data025)
1872 / sizeof(testcase_conf_hyperg<double>);
1873 for (unsigned int i = 0; i < num_datum; ++i)
1874 {
1875 const Tp f = std::tr1::conf_hyperg(Tp(data025[i].a), Tp(data025[i].c),
1876 Tp(data025[i].x));
1877 const Tp f0 = data025[i].f0;
1878 const Tp diff = f - f0;
1879 if (std::abs(diff) > max_abs_diff)
1880 max_abs_diff = std::abs(diff);
1881 if (std::abs(f0) > Tp(10) * eps
1882 && std::abs(f) > Tp(10) * eps)
1883 {
1884 const Tp frac = diff / f0;
1885 if (std::abs(frac) > max_abs_frac)
1886 max_abs_frac = std::abs(frac);
1887 }
1888 }
1889 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1890 }
1891
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 },
1936 };
1937
1938 // Test function for a=1.0000000000000000, c=6.0000000000000000.
1939 template <typename Tp>
test026()1940 void test026()
1941 {
1942 const Tp eps = std::numeric_limits<Tp>::epsilon();
1943 Tp max_abs_diff = -Tp(1);
1944 Tp max_abs_frac = -Tp(1);
1945 unsigned int num_datum = sizeof(data026)
1946 / sizeof(testcase_conf_hyperg<double>);
1947 for (unsigned int i = 0; i < num_datum; ++i)
1948 {
1949 const Tp f = std::tr1::conf_hyperg(Tp(data026[i].a), Tp(data026[i].c),
1950 Tp(data026[i].x));
1951 const Tp f0 = data026[i].f0;
1952 const Tp diff = f - f0;
1953 if (std::abs(diff) > max_abs_diff)
1954 max_abs_diff = std::abs(diff);
1955 if (std::abs(f0) > Tp(10) * eps
1956 && std::abs(f) > Tp(10) * eps)
1957 {
1958 const Tp frac = diff / f0;
1959 if (std::abs(frac) > max_abs_frac)
1960 max_abs_frac = std::abs(frac);
1961 }
1962 }
1963 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
1964 }
1965
1966 // Test data for 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 },
2010 };
2011
2012 // Test function for a=1.0000000000000000, c=7.0000000000000000.
2013 template <typename Tp>
test027()2014 void test027()
2015 {
2016 const Tp eps = std::numeric_limits<Tp>::epsilon();
2017 Tp max_abs_diff = -Tp(1);
2018 Tp max_abs_frac = -Tp(1);
2019 unsigned int num_datum = sizeof(data027)
2020 / sizeof(testcase_conf_hyperg<double>);
2021 for (unsigned int i = 0; i < num_datum; ++i)
2022 {
2023 const Tp f = std::tr1::conf_hyperg(Tp(data027[i].a), Tp(data027[i].c),
2024 Tp(data027[i].x));
2025 const Tp f0 = data027[i].f0;
2026 const Tp diff = f - f0;
2027 if (std::abs(diff) > max_abs_diff)
2028 max_abs_diff = std::abs(diff);
2029 if (std::abs(f0) > Tp(10) * eps
2030 && std::abs(f) > Tp(10) * eps)
2031 {
2032 const Tp frac = diff / f0;
2033 if (std::abs(frac) > max_abs_frac)
2034 max_abs_frac = std::abs(frac);
2035 }
2036 }
2037 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2038 }
2039
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 },
2084 };
2085
2086 // Test function for a=1.0000000000000000, c=8.0000000000000000.
2087 template <typename Tp>
test028()2088 void test028()
2089 {
2090 const Tp eps = std::numeric_limits<Tp>::epsilon();
2091 Tp max_abs_diff = -Tp(1);
2092 Tp max_abs_frac = -Tp(1);
2093 unsigned int num_datum = sizeof(data028)
2094 / sizeof(testcase_conf_hyperg<double>);
2095 for (unsigned int i = 0; i < num_datum; ++i)
2096 {
2097 const Tp f = std::tr1::conf_hyperg(Tp(data028[i].a), Tp(data028[i].c),
2098 Tp(data028[i].x));
2099 const Tp f0 = data028[i].f0;
2100 const Tp diff = f - f0;
2101 if (std::abs(diff) > max_abs_diff)
2102 max_abs_diff = std::abs(diff);
2103 if (std::abs(f0) > Tp(10) * eps
2104 && std::abs(f) > Tp(10) * eps)
2105 {
2106 const Tp frac = diff / f0;
2107 if (std::abs(frac) > max_abs_frac)
2108 max_abs_frac = std::abs(frac);
2109 }
2110 }
2111 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2112 }
2113
2114 // Test data for 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 },
2158 };
2159
2160 // Test function for a=1.0000000000000000, c=9.0000000000000000.
2161 template <typename Tp>
test029()2162 void test029()
2163 {
2164 const Tp eps = std::numeric_limits<Tp>::epsilon();
2165 Tp max_abs_diff = -Tp(1);
2166 Tp max_abs_frac = -Tp(1);
2167 unsigned int num_datum = sizeof(data029)
2168 / sizeof(testcase_conf_hyperg<double>);
2169 for (unsigned int i = 0; i < num_datum; ++i)
2170 {
2171 const Tp f = std::tr1::conf_hyperg(Tp(data029[i].a), Tp(data029[i].c),
2172 Tp(data029[i].x));
2173 const Tp f0 = data029[i].f0;
2174 const Tp diff = f - f0;
2175 if (std::abs(diff) > max_abs_diff)
2176 max_abs_diff = std::abs(diff);
2177 if (std::abs(f0) > Tp(10) * eps
2178 && std::abs(f) > Tp(10) * eps)
2179 {
2180 const Tp frac = diff / f0;
2181 if (std::abs(frac) > max_abs_frac)
2182 max_abs_frac = std::abs(frac);
2183 }
2184 }
2185 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2186 }
2187
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 },
2232 };
2233
2234 // Test function for a=1.0000000000000000, c=10.000000000000000.
2235 template <typename Tp>
test030()2236 void test030()
2237 {
2238 const Tp eps = std::numeric_limits<Tp>::epsilon();
2239 Tp max_abs_diff = -Tp(1);
2240 Tp max_abs_frac = -Tp(1);
2241 unsigned int num_datum = sizeof(data030)
2242 / sizeof(testcase_conf_hyperg<double>);
2243 for (unsigned int i = 0; i < num_datum; ++i)
2244 {
2245 const Tp f = std::tr1::conf_hyperg(Tp(data030[i].a), Tp(data030[i].c),
2246 Tp(data030[i].x));
2247 const Tp f0 = data030[i].f0;
2248 const Tp diff = f - f0;
2249 if (std::abs(diff) > max_abs_diff)
2250 max_abs_diff = std::abs(diff);
2251 if (std::abs(f0) > Tp(10) * eps
2252 && std::abs(f) > Tp(10) * eps)
2253 {
2254 const Tp frac = diff / f0;
2255 if (std::abs(frac) > max_abs_frac)
2256 max_abs_frac = std::abs(frac);
2257 }
2258 }
2259 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2260 }
2261
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 },
2304 };
2305
2306 // Test function for a=2.0000000000000000, c=1.0000000000000000.
2307 template <typename Tp>
test031()2308 void test031()
2309 {
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)
2316 {
2317 const Tp f = std::tr1::conf_hyperg(Tp(data031[i].a), Tp(data031[i].c),
2318 Tp(data031[i].x));
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)
2325 {
2326 const Tp frac = diff / f0;
2327 if (std::abs(frac) > max_abs_frac)
2328 max_abs_frac = std::abs(frac);
2329 }
2330 }
2331 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
2332 }
2333
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 },
2378 };
2379
2380 // Test function for a=2.0000000000000000, c=2.0000000000000000.
2381 template <typename Tp>
test032()2382 void test032()
2383 {
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)
2390 {
2391 const Tp f = std::tr1::conf_hyperg(Tp(data032[i].a), Tp(data032[i].c),
2392 Tp(data032[i].x));
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)
2399 {
2400 const Tp frac = diff / f0;
2401 if (std::abs(frac) > max_abs_frac)
2402 max_abs_frac = std::abs(frac);
2403 }
2404 }
2405 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2406 }
2407
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 },
2452 };
2453
2454 // Test function for a=2.0000000000000000, c=3.0000000000000000.
2455 template <typename Tp>
test033()2456 void test033()
2457 {
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)
2464 {
2465 const Tp f = std::tr1::conf_hyperg(Tp(data033[i].a), Tp(data033[i].c),
2466 Tp(data033[i].x));
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)
2473 {
2474 const Tp frac = diff / f0;
2475 if (std::abs(frac) > max_abs_frac)
2476 max_abs_frac = std::abs(frac);
2477 }
2478 }
2479 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2480 }
2481
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 },
2526 };
2527
2528 // Test function for a=2.0000000000000000, c=4.0000000000000000.
2529 template <typename Tp>
test034()2530 void test034()
2531 {
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)
2538 {
2539 const Tp f = std::tr1::conf_hyperg(Tp(data034[i].a), Tp(data034[i].c),
2540 Tp(data034[i].x));
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)
2547 {
2548 const Tp frac = diff / f0;
2549 if (std::abs(frac) > max_abs_frac)
2550 max_abs_frac = std::abs(frac);
2551 }
2552 }
2553 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2554 }
2555
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 },
2600 };
2601
2602 // Test function for a=2.0000000000000000, c=5.0000000000000000.
2603 template <typename Tp>
test035()2604 void test035()
2605 {
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)
2612 {
2613 const Tp f = std::tr1::conf_hyperg(Tp(data035[i].a), Tp(data035[i].c),
2614 Tp(data035[i].x));
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)
2621 {
2622 const Tp frac = diff / f0;
2623 if (std::abs(frac) > max_abs_frac)
2624 max_abs_frac = std::abs(frac);
2625 }
2626 }
2627 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2628 }
2629
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 },
2674 };
2675
2676 // Test function for a=2.0000000000000000, c=6.0000000000000000.
2677 template <typename Tp>
test036()2678 void test036()
2679 {
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)
2686 {
2687 const Tp f = std::tr1::conf_hyperg(Tp(data036[i].a), Tp(data036[i].c),
2688 Tp(data036[i].x));
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)
2695 {
2696 const Tp frac = diff / f0;
2697 if (std::abs(frac) > max_abs_frac)
2698 max_abs_frac = std::abs(frac);
2699 }
2700 }
2701 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2702 }
2703
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 },
2748 };
2749
2750 // Test function for a=2.0000000000000000, c=7.0000000000000000.
2751 template <typename Tp>
test037()2752 void test037()
2753 {
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)
2760 {
2761 const Tp f = std::tr1::conf_hyperg(Tp(data037[i].a), Tp(data037[i].c),
2762 Tp(data037[i].x));
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)
2769 {
2770 const Tp frac = diff / f0;
2771 if (std::abs(frac) > max_abs_frac)
2772 max_abs_frac = std::abs(frac);
2773 }
2774 }
2775 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2776 }
2777
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 },
2822 };
2823
2824 // Test function for a=2.0000000000000000, c=8.0000000000000000.
2825 template <typename Tp>
test038()2826 void test038()
2827 {
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)
2834 {
2835 const Tp f = std::tr1::conf_hyperg(Tp(data038[i].a), Tp(data038[i].c),
2836 Tp(data038[i].x));
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)
2843 {
2844 const Tp frac = diff / f0;
2845 if (std::abs(frac) > max_abs_frac)
2846 max_abs_frac = std::abs(frac);
2847 }
2848 }
2849 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2850 }
2851
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 },
2896 };
2897
2898 // Test function for a=2.0000000000000000, c=9.0000000000000000.
2899 template <typename Tp>
test039()2900 void test039()
2901 {
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)
2908 {
2909 const Tp f = std::tr1::conf_hyperg(Tp(data039[i].a), Tp(data039[i].c),
2910 Tp(data039[i].x));
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)
2917 {
2918 const Tp frac = diff / f0;
2919 if (std::abs(frac) > max_abs_frac)
2920 max_abs_frac = std::abs(frac);
2921 }
2922 }
2923 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2924 }
2925
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 },
2970 };
2971
2972 // Test function for a=2.0000000000000000, c=10.000000000000000.
2973 template <typename Tp>
test040()2974 void test040()
2975 {
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)
2982 {
2983 const Tp f = std::tr1::conf_hyperg(Tp(data040[i].a), Tp(data040[i].c),
2984 Tp(data040[i].x));
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)
2991 {
2992 const Tp frac = diff / f0;
2993 if (std::abs(frac) > max_abs_frac)
2994 max_abs_frac = std::abs(frac);
2995 }
2996 }
2997 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
2998 }
2999
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 },
3044 };
3045
3046 // Test function for a=5.0000000000000000, c=1.0000000000000000.
3047 template <typename Tp>
test041()3048 void test041()
3049 {
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)
3056 {
3057 const Tp f = std::tr1::conf_hyperg(Tp(data041[i].a), Tp(data041[i].c),
3058 Tp(data041[i].x));
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)
3065 {
3066 const Tp frac = diff / f0;
3067 if (std::abs(frac) > max_abs_frac)
3068 max_abs_frac = std::abs(frac);
3069 }
3070 }
3071 VERIFY(max_abs_frac < Tp(5.0000000000000034e-10));
3072 }
3073
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 },
3118 };
3119
3120 // Test function for a=5.0000000000000000, c=2.0000000000000000.
3121 template <typename Tp>
test042()3122 void test042()
3123 {
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)
3130 {
3131 const Tp f = std::tr1::conf_hyperg(Tp(data042[i].a), Tp(data042[i].c),
3132 Tp(data042[i].x));
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)
3139 {
3140 const Tp frac = diff / f0;
3141 if (std::abs(frac) > max_abs_frac)
3142 max_abs_frac = std::abs(frac);
3143 }
3144 }
3145 VERIFY(max_abs_frac < Tp(1.0000000000000006e-10));
3146 }
3147
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 },
3192 };
3193
3194 // Test function for a=5.0000000000000000, c=3.0000000000000000.
3195 template <typename Tp>
test043()3196 void test043()
3197 {
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)
3204 {
3205 const Tp f = std::tr1::conf_hyperg(Tp(data043[i].a), Tp(data043[i].c),
3206 Tp(data043[i].x));
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)
3213 {
3214 const Tp frac = diff / f0;
3215 if (std::abs(frac) > max_abs_frac)
3216 max_abs_frac = std::abs(frac);
3217 }
3218 }
3219 VERIFY(max_abs_frac < Tp(5.0000000000000028e-11));
3220 }
3221
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 },
3266 };
3267
3268 // Test function for a=5.0000000000000000, c=4.0000000000000000.
3269 template <typename Tp>
test044()3270 void test044()
3271 {
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)
3278 {
3279 const Tp f = std::tr1::conf_hyperg(Tp(data044[i].a), Tp(data044[i].c),
3280 Tp(data044[i].x));
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)
3287 {
3288 const Tp frac = diff / f0;
3289 if (std::abs(frac) > max_abs_frac)
3290 max_abs_frac = std::abs(frac);
3291 }
3292 }
3293 VERIFY(max_abs_frac < Tp(2.5000000000000014e-11));
3294 }
3295
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 },
3340 };
3341
3342 // Test function for a=5.0000000000000000, c=5.0000000000000000.
3343 template <typename Tp>
test045()3344 void test045()
3345 {
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)
3352 {
3353 const Tp f = std::tr1::conf_hyperg(Tp(data045[i].a), Tp(data045[i].c),
3354 Tp(data045[i].x));
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)
3361 {
3362 const Tp frac = diff / f0;
3363 if (std::abs(frac) > max_abs_frac)
3364 max_abs_frac = std::abs(frac);
3365 }
3366 }
3367 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
3368 }
3369
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 },
3414 };
3415
3416 // Test function for a=5.0000000000000000, c=6.0000000000000000.
3417 template <typename Tp>
test046()3418 void test046()
3419 {
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)
3426 {
3427 const Tp f = std::tr1::conf_hyperg(Tp(data046[i].a), Tp(data046[i].c),
3428 Tp(data046[i].x));
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)
3435 {
3436 const Tp frac = diff / f0;
3437 if (std::abs(frac) > max_abs_frac)
3438 max_abs_frac = std::abs(frac);
3439 }
3440 }
3441 VERIFY(max_abs_frac < Tp(1.0000000000000006e-11));
3442 }
3443
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 },
3488 };
3489
3490 // Test function for a=5.0000000000000000, c=7.0000000000000000.
3491 template <typename Tp>
test047()3492 void test047()
3493 {
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)
3500 {
3501 const Tp f = std::tr1::conf_hyperg(Tp(data047[i].a), Tp(data047[i].c),
3502 Tp(data047[i].x));
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)
3509 {
3510 const Tp frac = diff / f0;
3511 if (std::abs(frac) > max_abs_frac)
3512 max_abs_frac = std::abs(frac);
3513 }
3514 }
3515 VERIFY(max_abs_frac < Tp(5.0000000000000029e-12));
3516 }
3517
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 },
3562 };
3563
3564 // Test function for a=5.0000000000000000, c=8.0000000000000000.
3565 template <typename Tp>
test048()3566 void test048()
3567 {
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)
3574 {
3575 const Tp f = std::tr1::conf_hyperg(Tp(data048[i].a), Tp(data048[i].c),
3576 Tp(data048[i].x));
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)
3583 {
3584 const Tp frac = diff / f0;
3585 if (std::abs(frac) > max_abs_frac)
3586 max_abs_frac = std::abs(frac);
3587 }
3588 }
3589 VERIFY(max_abs_frac < Tp(2.5000000000000015e-12));
3590 }
3591
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 },
3636 };
3637
3638 // Test function for a=5.0000000000000000, c=9.0000000000000000.
3639 template <typename Tp>
test049()3640 void test049()
3641 {
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)
3648 {
3649 const Tp f = std::tr1::conf_hyperg(Tp(data049[i].a), Tp(data049[i].c),
3650 Tp(data049[i].x));
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)
3657 {
3658 const Tp frac = diff / f0;
3659 if (std::abs(frac) > max_abs_frac)
3660 max_abs_frac = std::abs(frac);
3661 }
3662 }
3663 VERIFY(max_abs_frac < Tp(1.0000000000000008e-12));
3664 }
3665
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 },
3710 };
3711
3712 // Test function for a=5.0000000000000000, c=10.000000000000000.
3713 template <typename Tp>
test050()3714 void test050()
3715 {
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)
3722 {
3723 const Tp f = std::tr1::conf_hyperg(Tp(data050[i].a), Tp(data050[i].c),
3724 Tp(data050[i].x));
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)
3731 {
3732 const Tp frac = diff / f0;
3733 if (std::abs(frac) > max_abs_frac)
3734 max_abs_frac = std::abs(frac);
3735 }
3736 }
3737 VERIFY(max_abs_frac < Tp(5.0000000000000039e-13));
3738 }
3739
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 },
3784 };
3785
3786 // Test function for a=10.000000000000000, c=1.0000000000000000.
3787 template <typename Tp>
test051()3788 void test051()
3789 {
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)
3796 {
3797 const Tp f = std::tr1::conf_hyperg(Tp(data051[i].a), Tp(data051[i].c),
3798 Tp(data051[i].x));
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)
3805 {
3806 const Tp frac = diff / f0;
3807 if (std::abs(frac) > max_abs_frac)
3808 max_abs_frac = std::abs(frac);
3809 }
3810 }
3811 VERIFY(max_abs_frac < Tp(5.0000000000000029e-12));
3812 }
3813
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 },
3858 };
3859
3860 // Test function for a=10.000000000000000, c=2.0000000000000000.
3861 template <typename Tp>
test052()3862 void test052()
3863 {
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)
3870 {
3871 const Tp f = std::tr1::conf_hyperg(Tp(data052[i].a), Tp(data052[i].c),
3872 Tp(data052[i].x));
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)
3879 {
3880 const Tp frac = diff / f0;
3881 if (std::abs(frac) > max_abs_frac)
3882 max_abs_frac = std::abs(frac);
3883 }
3884 }
3885 VERIFY(max_abs_frac < Tp(2.5000000000000017e-10));
3886 }
3887
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 },
3932 };
3933
3934 // Test function for a=10.000000000000000, c=3.0000000000000000.
3935 template <typename Tp>
test053()3936 void test053()
3937 {
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)
3944 {
3945 const Tp f = std::tr1::conf_hyperg(Tp(data053[i].a), Tp(data053[i].c),
3946 Tp(data053[i].x));
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)
3953 {
3954 const Tp frac = diff / f0;
3955 if (std::abs(frac) > max_abs_frac)
3956 max_abs_frac = std::abs(frac);
3957 }
3958 }
3959 VERIFY(max_abs_frac < Tp(2.5000000000000013e-09));
3960 }
3961
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 },
4006 };
4007
4008 // Test function for a=10.000000000000000, c=4.0000000000000000.
4009 template <typename Tp>
test054()4010 void test054()
4011 {
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)
4018 {
4019 const Tp f = std::tr1::conf_hyperg(Tp(data054[i].a), Tp(data054[i].c),
4020 Tp(data054[i].x));
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)
4027 {
4028 const Tp frac = diff / f0;
4029 if (std::abs(frac) > max_abs_frac)
4030 max_abs_frac = std::abs(frac);
4031 }
4032 }
4033 VERIFY(max_abs_frac < Tp(5.0000000000000026e-09));
4034 }
4035
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 },
4080 };
4081
4082 // Test function for a=10.000000000000000, c=5.0000000000000000.
4083 template <typename Tp>
test055()4084 void test055()
4085 {
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)
4092 {
4093 const Tp f = std::tr1::conf_hyperg(Tp(data055[i].a), Tp(data055[i].c),
4094 Tp(data055[i].x));
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)
4101 {
4102 const Tp frac = diff / f0;
4103 if (std::abs(frac) > max_abs_frac)
4104 max_abs_frac = std::abs(frac);
4105 }
4106 }
4107 VERIFY(max_abs_frac < Tp(2.5000000000000013e-09));
4108 }
4109
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 },
4154 };
4155
4156 // Test function for a=10.000000000000000, c=6.0000000000000000.
4157 template <typename Tp>
test056()4158 void test056()
4159 {
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)
4166 {
4167 const Tp f = std::tr1::conf_hyperg(Tp(data056[i].a), Tp(data056[i].c),
4168 Tp(data056[i].x));
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)
4175 {
4176 const Tp frac = diff / f0;
4177 if (std::abs(frac) > max_abs_frac)
4178 max_abs_frac = std::abs(frac);
4179 }
4180 }
4181 VERIFY(max_abs_frac < Tp(2.5000000000000012e-08));
4182 }
4183
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 },
4228 };
4229
4230 // Test function for a=10.000000000000000, c=7.0000000000000000.
4231 template <typename Tp>
test057()4232 void test057()
4233 {
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)
4240 {
4241 const Tp f = std::tr1::conf_hyperg(Tp(data057[i].a), Tp(data057[i].c),
4242 Tp(data057[i].x));
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)
4249 {
4250 const Tp frac = diff / f0;
4251 if (std::abs(frac) > max_abs_frac)
4252 max_abs_frac = std::abs(frac);
4253 }
4254 }
4255 VERIFY(max_abs_frac < Tp(1.0000000000000004e-06));
4256 }
4257
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 },
4302 };
4303
4304 // Test function for a=10.000000000000000, c=8.0000000000000000.
4305 template <typename Tp>
test058()4306 void test058()
4307 {
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)
4314 {
4315 const Tp f = std::tr1::conf_hyperg(Tp(data058[i].a), Tp(data058[i].c),
4316 Tp(data058[i].x));
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)
4323 {
4324 const Tp frac = diff / f0;
4325 if (std::abs(frac) > max_abs_frac)
4326 max_abs_frac = std::abs(frac);
4327 }
4328 }
4329 VERIFY(max_abs_frac < Tp(2.5000000000000013e-09));
4330 }
4331
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 },
4376 };
4377
4378 // Test function for a=10.000000000000000, c=9.0000000000000000.
4379 template <typename Tp>
test059()4380 void test059()
4381 {
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)
4388 {
4389 const Tp f = std::tr1::conf_hyperg(Tp(data059[i].a), Tp(data059[i].c),
4390 Tp(data059[i].x));
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)
4397 {
4398 const Tp frac = diff / f0;
4399 if (std::abs(frac) > max_abs_frac)
4400 max_abs_frac = std::abs(frac);
4401 }
4402 }
4403 VERIFY(max_abs_frac < Tp(2.5000000000000013e-09));
4404 }
4405
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 },
4450 };
4451
4452 // Test function for a=10.000000000000000, c=10.000000000000000.
4453 template <typename Tp>
test060()4454 void test060()
4455 {
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)
4462 {
4463 const Tp f = std::tr1::conf_hyperg(Tp(data060[i].a), Tp(data060[i].c),
4464 Tp(data060[i].x));
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)
4471 {
4472 const Tp frac = diff / f0;
4473 if (std::abs(frac) > max_abs_frac)
4474 max_abs_frac = std::abs(frac);
4475 }
4476 }
4477 VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
4478 }
4479
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 },
4524 };
4525
4526 // Test function for a=20.000000000000000, c=1.0000000000000000.
4527 template <typename Tp>
test061()4528 void test061()
4529 {
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)
4536 {
4537 const Tp f = std::tr1::conf_hyperg(Tp(data061[i].a), Tp(data061[i].c),
4538 Tp(data061[i].x));
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)
4545 {
4546 const Tp frac = diff / f0;
4547 if (std::abs(frac) > max_abs_frac)
4548 max_abs_frac = std::abs(frac);
4549 }
4550 }
4551 VERIFY(max_abs_frac < Tp(2.5000000000000015e-12));
4552 }
4553
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 },
4598 };
4599
4600 // Test function for a=20.000000000000000, c=2.0000000000000000.
4601 template <typename Tp>
test062()4602 void test062()
4603 {
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)
4610 {
4611 const Tp f = std::tr1::conf_hyperg(Tp(data062[i].a), Tp(data062[i].c),
4612 Tp(data062[i].x));
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)
4619 {
4620 const Tp frac = diff / f0;
4621 if (std::abs(frac) > max_abs_frac)
4622 max_abs_frac = std::abs(frac);
4623 }
4624 }
4625 VERIFY(max_abs_frac < Tp(2.5000000000000017e-10));
4626 }
4627
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 },
4672 };
4673
4674 // Test function for a=20.000000000000000, c=3.0000000000000000.
4675 template <typename Tp>
test063()4676 void test063()
4677 {
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)
4684 {
4685 const Tp f = std::tr1::conf_hyperg(Tp(data063[i].a), Tp(data063[i].c),
4686 Tp(data063[i].x));
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)
4693 {
4694 const Tp frac = diff / f0;
4695 if (std::abs(frac) > max_abs_frac)
4696 max_abs_frac = std::abs(frac);
4697 }
4698 }
4699 VERIFY(max_abs_frac < Tp(1.0000000000000007e-09));
4700 }
4701
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 },
4746 };
4747
4748 // Test function for a=20.000000000000000, c=4.0000000000000000.
4749 template <typename Tp>
test064()4750 void test064()
4751 {
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)
4758 {
4759 const Tp f = std::tr1::conf_hyperg(Tp(data064[i].a), Tp(data064[i].c),
4760 Tp(data064[i].x));
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)
4767 {
4768 const Tp frac = diff / f0;
4769 if (std::abs(frac) > max_abs_frac)
4770 max_abs_frac = std::abs(frac);
4771 }
4772 }
4773 VERIFY(max_abs_frac < Tp(1.0000000000000007e-09));
4774 }
4775
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 },
4820 };
4821
4822 // Test function for a=20.000000000000000, c=5.0000000000000000.
4823 template <typename Tp>
test065()4824 void test065()
4825 {
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)
4832 {
4833 const Tp f = std::tr1::conf_hyperg(Tp(data065[i].a), Tp(data065[i].c),
4834 Tp(data065[i].x));
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)
4841 {
4842 const Tp frac = diff / f0;
4843 if (std::abs(frac) > max_abs_frac)
4844 max_abs_frac = std::abs(frac);
4845 }
4846 }
4847 VERIFY(max_abs_frac < Tp(1.0000000000000005e-07));
4848 }
4849
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 },
4894 };
4895
4896 // Test function for a=20.000000000000000, c=6.0000000000000000.
4897 template <typename Tp>
test066()4898 void test066()
4899 {
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)
4906 {
4907 const Tp f = std::tr1::conf_hyperg(Tp(data066[i].a), Tp(data066[i].c),
4908 Tp(data066[i].x));
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)
4915 {
4916 const Tp frac = diff / f0;
4917 if (std::abs(frac) > max_abs_frac)
4918 max_abs_frac = std::abs(frac);
4919 }
4920 }
4921 VERIFY(max_abs_frac < Tp(5.0000000000000019e-07));
4922 }
4923
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 },
4968 };
4969
4970 // Test function for a=20.000000000000000, c=7.0000000000000000.
4971 template <typename Tp>
test067()4972 void test067()
4973 {
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)
4980 {
4981 const Tp f = std::tr1::conf_hyperg(Tp(data067[i].a), Tp(data067[i].c),
4982 Tp(data067[i].x));
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)
4989 {
4990 const Tp frac = diff / f0;
4991 if (std::abs(frac) > max_abs_frac)
4992 max_abs_frac = std::abs(frac);
4993 }
4994 }
4995 VERIFY(max_abs_frac < Tp(2.5000000000000009e-07));
4996 }
4997
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 },
5042 };
5043
5044 // Test function for a=20.000000000000000, c=8.0000000000000000.
5045 template <typename Tp>
test068()5046 void test068()
5047 {
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)
5054 {
5055 const Tp f = std::tr1::conf_hyperg(Tp(data068[i].a), Tp(data068[i].c),
5056 Tp(data068[i].x));
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)
5063 {
5064 const Tp frac = diff / f0;
5065 if (std::abs(frac) > max_abs_frac)
5066 max_abs_frac = std::abs(frac);
5067 }
5068 }
5069 VERIFY(max_abs_frac < Tp(1.0000000000000005e-07));
5070 }
5071
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 },
5116 };
5117
5118 // Test function for a=20.000000000000000, c=9.0000000000000000.
5119 template <typename Tp>
test069()5120 void test069()
5121 {
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)
5128 {
5129 const Tp f = std::tr1::conf_hyperg(Tp(data069[i].a), Tp(data069[i].c),
5130 Tp(data069[i].x));
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)
5137 {
5138 const Tp frac = diff / f0;
5139 if (std::abs(frac) > max_abs_frac)
5140 max_abs_frac = std::abs(frac);
5141 }
5142 }
5143 VERIFY(max_abs_frac < Tp(1.0000000000000004e-06));
5144 }
5145
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 },
5190 };
5191
5192 // Test function for a=20.000000000000000, c=10.000000000000000.
5193 template <typename Tp>
test070()5194 void test070()
5195 {
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)
5202 {
5203 const Tp f = std::tr1::conf_hyperg(Tp(data070[i].a), Tp(data070[i].c),
5204 Tp(data070[i].x));
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)
5211 {
5212 const Tp frac = diff / f0;
5213 if (std::abs(frac) > max_abs_frac)
5214 max_abs_frac = std::abs(frac);
5215 }
5216 }
5217 VERIFY(max_abs_frac < Tp(2.5000000000000009e-07));
5218 }
5219
main(int,char **)5220 int main(int, char**)
5221 {
5222 test001<double>();
5223 test002<double>();
5224 test003<double>();
5225 test004<double>();
5226 test005<double>();
5227 test006<double>();
5228 test007<double>();
5229 test008<double>();
5230 test009<double>();
5231 test010<double>();
5232 test011<double>();
5233 test012<double>();
5234 test013<double>();
5235 test014<double>();
5236 test015<double>();
5237 test016<double>();
5238 test017<double>();
5239 test018<double>();
5240 test019<double>();
5241 test020<double>();
5242 test021<double>();
5243 test022<double>();
5244 test023<double>();
5245 test024<double>();
5246 test025<double>();
5247 test026<double>();
5248 test027<double>();
5249 test028<double>();
5250 test029<double>();
5251 test030<double>();
5252 test031<double>();
5253 test032<double>();
5254 test033<double>();
5255 test034<double>();
5256 test035<double>();
5257 test036<double>();
5258 test037<double>();
5259 test038<double>();
5260 test039<double>();
5261 test040<double>();
5262 test041<double>();
5263 test042<double>();
5264 test043<double>();
5265 test044<double>();
5266 test045<double>();
5267 test046<double>();
5268 test047<double>();
5269 test048<double>();
5270 test049<double>();
5271 test050<double>();
5272 test051<double>();
5273 test052<double>();
5274 test053<double>();
5275 test054<double>();
5276 test055<double>();
5277 test056<double>();
5278 test057<double>();
5279 test058<double>();
5280 test059<double>();
5281 test060<double>();
5282 test061<double>();
5283 test062<double>();
5284 test063<double>();
5285 test064<double>();
5286 test065<double>();
5287 test066<double>();
5288 test067<double>();
5289 test068<double>();
5290 test069<double>();
5291 test070<double>();
5292 return 0;
5293 }
5294