OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [libstdc++-v3/] [testsuite/] [tr1/] [5_numerical_facilities/] [special_functions/] [07_conf_hyperg/] [check_value.cc] - Blame information for rev 424

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 424 jeremybenn 
// 2007-02-04  Edward Smith-Rowland <3dw4rd@verizon.net>
2 
//
3 
// Copyright (C) 2007, 2009 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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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 
 
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 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.