...one of the most highly
regarded and expertly designed C++ library projects in the
world.

— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards

#include <boost/math/special_functions/jacobi_zeta.hpp>

namespace boost { namespace math { template <class T1, class T2>calculated-result-typejacobi_zeta(T1 k, T2 phi); template <class T1, class T2, class Policy>calculated-result-typejacobi_zeta(T1 k, T2 phi, const Policy&); }} // namespaces

This function evaluates the Jacobi Zeta Function *Z(φ, k)*

The return type of this function is computed using the *result
type calculation rules* when the arguments are of different
types: when they are the same type then the result is the same type as the
arguments.

Requires *-1 <= k <= 1*, otherwise returns the result
of domain_error
(outside this range the result would be complex).

The final Policy argument is optional and can be used to control the behaviour of the function: how it handles errors, what level of precision to use etc. Refer to the policy documentation for more details.

Note that there is no complete analogue of this function (where φ = π / 2) as
this takes the value 0 for all *k*.

These functions are trivially computed in terms of other elliptic integrals and generally have very low error rates (a few epsilon) unless parameter φ is very large, in which case the usual trigonometric function argument-reduction issues apply.

The tests use a mixture of spot test values calculated using values calculated at wolframalpha.com, and random test data generated using MPFR at 1000-bit precision and a deliberately naive implementation in terms of the Legendre integrals.

The implementation for Z(φ, k) first makes the argument φ positive using:

*Z(-φ, k) = -Z(φ, k)*

The function is then implemented in terms of Carlson's integral R_{J}
using the
relation:

There is one special case where the above relation fails: when *k
= 1*, in that case the function simplifies to

*Z(φ, 1) = sign(cos(φ)) sin(φ)*