summaryrefslogtreecommitdiff
path: root/libs/math/test/test_instances/test_instances.hpp
blob: 889e9b2f1bf65ad99ad7c0017ee1a8e3ec3a58e1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
// Copyright John Maddock 2011.
//  Use, modification and distribution are subject to the
//  Boost Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


namespace boost{ namespace math{

   typedef policies::policy<policies::overflow_error<policies::throw_on_error> > overflow_policy;

#ifdef TEST_GROUP_1

   // Beta functions.
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         beta(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b); // Beta function (2 arguments).

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         beta(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, policies::policy<>); // Beta function (3 arguments).
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         beta(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE); // Beta function (3 arguments).

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         beta(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol); // Beta function (3 arguments).

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         betac(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE x);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         betac(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibeta(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE x); // Incomplete beta function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibeta(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol); // Incomplete beta function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibetac(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE x); // Incomplete beta complement function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibetac(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol); // Incomplete beta complement function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type  
         ibeta_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE p, BOOST_MATH_TEST_TYPE* py);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type  
         ibeta_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE p, BOOST_MATH_TEST_TYPE* py, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibeta_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE p); // Incomplete beta inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibeta_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE p, const policies::policy<>&); // Incomplete beta inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibeta_inva(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE p); // Incomplete beta inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibeta_inva(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE p, const policies::policy<>&); // Incomplete beta inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibeta_invb(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE p); // Incomplete beta inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibeta_invb(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE p, const policies::policy<>&); // Incomplete beta inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibetac_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE q, BOOST_MATH_TEST_TYPE* py);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibetac_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE q, BOOST_MATH_TEST_TYPE* py, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibetac_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE q); // Incomplete beta complement inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibetac_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE q, const policies::policy<>&); // Incomplete beta complement inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibetac_inva(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE q); // Incomplete beta complement inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibetac_inva(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE q, const policies::policy<>&); // Incomplete beta complement inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibetac_invb(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE q); // Incomplete beta complement inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibetac_invb(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE q, const policies::policy<>&); // Incomplete beta complement inverse function.

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibeta_derivative(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE x);  // derivative of incomplete beta

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ibeta_derivative(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol);  // derivative of incomplete beta

#endif
#ifdef TEST_GROUP_2
   // erf & erfc error functions.
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type erf(BOOST_MATH_TEST_TYPE z);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type erf(BOOST_MATH_TEST_TYPE z, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type erfc(BOOST_MATH_TEST_TYPE z);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type erfc(BOOST_MATH_TEST_TYPE z, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type erf_inv(BOOST_MATH_TEST_TYPE z);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type erf_inv(BOOST_MATH_TEST_TYPE z, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type erfc_inv(BOOST_MATH_TEST_TYPE z);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type erfc_inv(BOOST_MATH_TEST_TYPE z, const policies::policy<>& pol);
#endif
#ifdef TEST_GROUP_3
   // Polynomials:
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         legendre_next(unsigned l, BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE Pl, BOOST_MATH_TEST_TYPE Plm1);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type 
         legendre_p(int l, BOOST_MATH_TEST_TYPE x);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type 
         legendre_p(int l, BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type 
         legendre_q(unsigned l, BOOST_MATH_TEST_TYPE x);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type 
         legendre_q(unsigned l, BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         legendre_next(unsigned l, unsigned m, BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE Pl, BOOST_MATH_TEST_TYPE Plm1);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type 
         legendre_p(int l, int m, BOOST_MATH_TEST_TYPE x);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type 
         legendre_p(int l, int m, BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type  
         laguerre_next(unsigned n, BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE Ln, BOOST_MATH_TEST_TYPE Lnm1);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type  
      laguerre_next(unsigned n, unsigned l, BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE Pl, BOOST_MATH_TEST_TYPE Plm1);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type 
      laguerre(unsigned n, BOOST_MATH_TEST_TYPE x);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type 
      laguerre(unsigned n, unsigned m, BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol);

   template laguerre_result<int, BOOST_MATH_TEST_TYPE>::type 
      laguerre(unsigned n, int m, BOOST_MATH_TEST_TYPE x);

   template laguerre_result<unsigned, BOOST_MATH_TEST_TYPE>::type 
      laguerre(unsigned n, unsigned m, BOOST_MATH_TEST_TYPE x);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type 
      hermite(unsigned n, BOOST_MATH_TEST_TYPE x);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type 
      hermite(unsigned n, BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
      hermite_next(unsigned n, BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE Hn, BOOST_MATH_TEST_TYPE Hnm1);

   template std::complex<BOOST_MATH_TEST_TYPE> 
         spherical_harmonic(unsigned n, int m, BOOST_MATH_TEST_TYPE theta, BOOST_MATH_TEST_TYPE phi);

   template std::complex<BOOST_MATH_TEST_TYPE> 
      spherical_harmonic(unsigned n, int m, BOOST_MATH_TEST_TYPE theta, BOOST_MATH_TEST_TYPE phi, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         spherical_harmonic_r(unsigned n, int m, BOOST_MATH_TEST_TYPE theta, BOOST_MATH_TEST_TYPE phi);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
      spherical_harmonic_r(unsigned n, int m, BOOST_MATH_TEST_TYPE theta, BOOST_MATH_TEST_TYPE phi, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         spherical_harmonic_i(unsigned n, int m, BOOST_MATH_TEST_TYPE theta, BOOST_MATH_TEST_TYPE phi);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
      spherical_harmonic_i(unsigned n, int m, BOOST_MATH_TEST_TYPE theta, BOOST_MATH_TEST_TYPE phi, const policies::policy<>& pol);
#endif
#ifdef TEST_GROUP_4
    // Elliptic integrals:
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ellint_rf(BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE y, BOOST_MATH_TEST_TYPE z);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ellint_rf(BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE y, BOOST_MATH_TEST_TYPE z, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ellint_rd(BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE y, BOOST_MATH_TEST_TYPE z);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ellint_rd(BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE y, BOOST_MATH_TEST_TYPE z, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ellint_rc(BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE y);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ellint_rc(BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE y, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ellint_rj(BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE y, BOOST_MATH_TEST_TYPE z, BOOST_MATH_TEST_TYPE p);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         ellint_rj(BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE y, BOOST_MATH_TEST_TYPE z, BOOST_MATH_TEST_TYPE p, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type ellint_2(BOOST_MATH_TEST_TYPE k);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type ellint_2(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE phi);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type ellint_2(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE phi, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type ellint_1(BOOST_MATH_TEST_TYPE k);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type ellint_1(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE phi);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type ellint_1(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE phi, const policies::policy<>& pol);

   template detail::ellint_3_result<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type ellint_3(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE phi);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type ellint_3(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE phi, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type ellint_3(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE v);
#endif
#ifdef TEST_GROUP_5
   // Gamma functions.
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type tgamma(BOOST_MATH_TEST_TYPE z);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type tgamma1pm1(BOOST_MATH_TEST_TYPE z);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type tgamma1pm1(BOOST_MATH_TEST_TYPE z, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type tgamma(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE z);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type tgamma(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE z, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type lgamma(BOOST_MATH_TEST_TYPE z, int* sign);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type lgamma(BOOST_MATH_TEST_TYPE z, int* sign, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type lgamma(BOOST_MATH_TEST_TYPE x);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type lgamma(BOOST_MATH_TEST_TYPE x, const policies::policy<>& pol);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type tgamma_lower(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE z);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type tgamma_lower(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE z, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_q(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE z);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_q(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE z, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_p(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE z);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_p(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE z, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type tgamma_delta_ratio(BOOST_MATH_TEST_TYPE z, BOOST_MATH_TEST_TYPE delta);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type tgamma_delta_ratio(BOOST_MATH_TEST_TYPE z, BOOST_MATH_TEST_TYPE delta, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type tgamma_ratio(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type tgamma_ratio(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE b, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_p_derivative(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE x);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_p_derivative(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE x, const policies::policy<>&);

   // gamma inverse.
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_p_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE p);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_p_inva(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE p, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_p_inva(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE p);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_p_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE p, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_q_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE q);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_q_inv(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE q, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_q_inva(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE q);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type gamma_q_inva(BOOST_MATH_TEST_TYPE a, BOOST_MATH_TEST_TYPE q, const policies::policy<>&);

   // digamma:
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type digamma(BOOST_MATH_TEST_TYPE x);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type digamma(BOOST_MATH_TEST_TYPE x, const policies::policy<>&);
#endif
#ifdef TEST_GROUP_6
   // Hypotenuse function sqrt(x ^ 2 + y ^ 2).
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         hypot(BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE y);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         hypot(BOOST_MATH_TEST_TYPE x, BOOST_MATH_TEST_TYPE y, const policies::policy<>&);

   // cbrt - cube root.
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type cbrt(BOOST_MATH_TEST_TYPE z);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type cbrt(BOOST_MATH_TEST_TYPE z, const policies::policy<>&);

   // log1p is log(x + 1)
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type log1p(BOOST_MATH_TEST_TYPE);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type log1p(BOOST_MATH_TEST_TYPE, const policies::policy<>&);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type log1p<BOOST_MATH_TEST_TYPE, overflow_policy>(BOOST_MATH_TEST_TYPE, const overflow_policy&);

   // log1pmx is log(x + 1) - x
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type log1pmx(BOOST_MATH_TEST_TYPE);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type log1pmx(BOOST_MATH_TEST_TYPE, const policies::policy<>&);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type log1pmx(BOOST_MATH_TEST_TYPE, const overflow_policy&);

   // Exp (x) minus 1 functions.
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type expm1(BOOST_MATH_TEST_TYPE);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type expm1(BOOST_MATH_TEST_TYPE, const policies::policy<>&);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type expm1(BOOST_MATH_TEST_TYPE, const overflow_policy&);

   // Power - 1
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         powm1(const BOOST_MATH_TEST_TYPE a, const BOOST_MATH_TEST_TYPE z);

   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type 
         powm1(const BOOST_MATH_TEST_TYPE a, const BOOST_MATH_TEST_TYPE z, const policies::policy<>&);

   // sqrt(1+x) - 1
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type sqrt1pm1(const BOOST_MATH_TEST_TYPE& val);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type sqrt1pm1(const BOOST_MATH_TEST_TYPE& val, const policies::policy<>&);
#endif
#ifdef TEST_GROUP_7
   // Bessel functions:
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_j(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_j_prime(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_j(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_j_prime(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<int, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_j(int v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<int, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_j_prime(int v, BOOST_MATH_TEST_TYPE x);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type sph_bessel(unsigned v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type sph_bessel_prime(unsigned v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type sph_bessel(unsigned v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type sph_bessel_prime(unsigned v, BOOST_MATH_TEST_TYPE x);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_i(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_i_prime(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_i(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_i_prime(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<int, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_i(int v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<int, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_i_prime(int v, BOOST_MATH_TEST_TYPE x);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_k(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_k_prime(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_k(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_k_prime(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<int, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_k(int v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<int, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_bessel_k_prime(int v, BOOST_MATH_TEST_TYPE x);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_neumann(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_neumann_prime(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_neumann(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_neumann_prime(BOOST_MATH_TEST_TYPE v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<int, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_neumann(int v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<int, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type cyl_neumann_prime(int v, BOOST_MATH_TEST_TYPE x);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type sph_neumann(unsigned v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type sph_neumann_prime(unsigned v, BOOST_MATH_TEST_TYPE x, const policies::policy<> & pol);

   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type sph_neumann(unsigned v, BOOST_MATH_TEST_TYPE x);
   template detail::bessel_traits<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE, policies::policy<> >::result_type sph_neumann_prime(unsigned v, BOOST_MATH_TEST_TYPE x);
#endif
#ifdef TEST_GROUP_8
   // Airy Functions:
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type airy_ai(BOOST_MATH_TEST_TYPE x, const policies::policy<>&);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type airy_ai(BOOST_MATH_TEST_TYPE x);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type airy_bi(BOOST_MATH_TEST_TYPE x, const policies::policy<>&);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type airy_bi(BOOST_MATH_TEST_TYPE x);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type airy_ai_prime(BOOST_MATH_TEST_TYPE x, const policies::policy<>&);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type airy_ai_prime(BOOST_MATH_TEST_TYPE x);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type airy_bi_prime(BOOST_MATH_TEST_TYPE x, const policies::policy<>&);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type airy_bi_prime(BOOST_MATH_TEST_TYPE x);
#endif
#ifdef TEST_GROUP_9
   // Exponential Integral
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type expint(unsigned n, BOOST_MATH_TEST_TYPE z, const policies::policy<> &);

   template detail::expint_result<int, BOOST_MATH_TEST_TYPE>::type expint(int const z, BOOST_MATH_TEST_TYPE const u);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type expint(BOOST_MATH_TEST_TYPE z);

   // Zeta:
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type zeta(BOOST_MATH_TEST_TYPE s, const policies::policy<>&);

   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type zeta(BOOST_MATH_TEST_TYPE s);
#endif
#ifdef TEST_GROUP_10
   // Jacobi Functions:
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type jacobi_elliptic(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, BOOST_MATH_TEST_TYPE* pcn, BOOST_MATH_TEST_TYPE* pdn, const policies::policy<>&);
   template tools::promote_args<BOOST_MATH_TEST_TYPE>::type jacobi_elliptic(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, BOOST_MATH_TEST_TYPE* pcn, BOOST_MATH_TEST_TYPE* pdn);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_sn(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_sn(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_cn(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_cn(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_dn(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_dn(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_cd(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_cd(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_dc(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_dc(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_ns(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_ns(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_sd(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_sd(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_ds(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_ds(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_nc(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_nc(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_nd(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_nd(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_sc(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_sc(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_cs(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta, const policies::policy<>& pol);
   template tools::promote_args<BOOST_MATH_TEST_TYPE, BOOST_MATH_TEST_TYPE>::type jacobi_cs(BOOST_MATH_TEST_TYPE k, BOOST_MATH_TEST_TYPE theta);
#endif

}} // namespaces