| 1 |
// Copyright John Maddock 2012. |
| 2 |
// Use, modification and distribution are subject to the |
| 3 |
// Boost Software License, Version 1.0. |
| 4 |
// (See accompanying file LICENSE_1_0.txt |
| 5 |
// or copy at http://www.boost.org/LICENSE_1_0.txt) |
| 6 |
|
| 7 |
#ifndef BOOST_MATH_JACOBI_ELLIPTIC_HPP |
| 8 |
#define BOOST_MATH_JACOBI_ELLIPTIC_HPP |
| 9 |
|
| 10 |
#include <boost/math/tools/precision.hpp> |
| 11 |
#include <boost/math/tools/promotion.hpp> |
| 12 |
#include <boost/math/policies/error_handling.hpp> |
| 13 |
#include <boost/math/special_functions/math_fwd.hpp> |
| 14 |
|
| 15 |
namespace boost{ namespace math{ |
| 16 |
|
| 17 |
namespace detail{ |
| 18 |
|
| 19 |
template <class T, class Policy> |
| 20 |
T jacobi_recurse(const T& x, const T& k, T anm1, T bnm1, unsigned N, T* pTn, const Policy& pol) |
| 21 |
{ |
| 22 |
BOOST_MATH_STD_USING |
| 23 |
++N; |
| 24 |
T Tn; |
| 25 |
T cn = (anm1 - bnm1) / 2; |
| 26 |
T an = (anm1 + bnm1) / 2; |
| 27 |
if(cn < policies::get_epsilon<T, Policy>()) |
| 28 |
{ |
| 29 |
Tn = ldexp(T(1), (int)N) * x * an; |
| 30 |
} |
| 31 |
else |
| 32 |
Tn = jacobi_recurse<T>(x, k, an, sqrt(anm1 * bnm1), N, 0, pol); |
| 33 |
if(pTn) |
| 34 |
*pTn = Tn; |
| 35 |
return (Tn + asin((cn / an) * sin(Tn))) / 2; |
| 36 |
} |
| 37 |
|
| 38 |
template <class T, class Policy> |
| 39 |
T jacobi_imp(const T& x, const T& k, T* cn, T* dn, const Policy& pol, const char* function) |
| 40 |
{ |
| 41 |
BOOST_MATH_STD_USING |
| 42 |
if(k < 0) |
| 43 |
{ |
| 44 |
return *dn = *cn = policies::raise_domain_error<T>(function, "Modulus k must be positive but got %1%.", k, pol); |
| 45 |
} |
| 46 |
if(k > 1) |
| 47 |
{ |
| 48 |
T xp = x * k; |
| 49 |
T kp = 1 / k; |
| 50 |
T snp, cnp, dnp; |
| 51 |
snp = jacobi_imp(xp, kp, &cnp, &dnp, pol, function); |
| 52 |
*cn = dnp; |
| 53 |
*dn = cnp; |
| 54 |
return snp * kp; |
| 55 |
} |
| 56 |
// |
| 57 |
// Special cases first: |
| 58 |
// |
| 59 |
if(x == 0) |
| 60 |
{ |
| 61 |
*cn = *dn = 1; |
| 62 |
return 0; |
| 63 |
} |
| 64 |
if(k == 0) |
| 65 |
{ |
| 66 |
*cn = cos(x); |
| 67 |
*dn = 1; |
| 68 |
return sin(x); |
| 69 |
} |
| 70 |
if(k == 1) |
| 71 |
{ |
| 72 |
*cn = *dn = 1 / cosh(x); |
| 73 |
return tanh(x); |
| 74 |
} |
| 75 |
// |
| 76 |
// Asymptotic forms from A&S 16.13: |
| 77 |
// |
| 78 |
if(k < tools::forth_root_epsilon<T>()) |
| 79 |
{ |
| 80 |
T su = sin(x); |
| 81 |
T cu = cos(x); |
| 82 |
T m = k * k; |
| 83 |
*dn = 1 - m * su * su / 2; |
| 84 |
*cn = cu + m * (x - su * cu) * su / 4; |
| 85 |
return su - m * (x - su * cu) * cu / 4; |
| 86 |
} |
| 87 |
/* Can't get this to work to adequate precision - disabled for now... |
| 88 |
// |
| 89 |
// Asymptotic forms from A&S 16.15: |
| 90 |
// |
| 91 |
if(k > 1 - tools::root_epsilon<T>()) |
| 92 |
{ |
| 93 |
T tu = tanh(x); |
| 94 |
T su = sinh(x); |
| 95 |
T cu = cosh(x); |
| 96 |
T sec = 1 / cu; |
| 97 |
T kp = 1 - k; |
| 98 |
T m1 = 2 * kp - kp * kp; |
| 99 |
*dn = sec + m1 * (su * cu + x) * tu * sec / 4; |
| 100 |
*cn = sec - m1 * (su * cu - x) * tu * sec / 4; |
| 101 |
T sn = tu; |
| 102 |
T sn2 = m1 * (x * sec * sec - tu) / 4; |
| 103 |
T sn3 = (72 * x * cu + 4 * (8 * x * x - 5) * su - 19 * sinh(3 * x) + sinh(5 * x)) * sec * sec * sec * m1 * m1 / 512; |
| 104 |
return sn + sn2 - sn3; |
| 105 |
}*/ |
| 106 |
T T1; |
| 107 |
T kc = 1 - k; |
| 108 |
T k_prime = k < T(0.5) ? T(sqrt(1 - k * k)) : T(sqrt(2 * kc - kc * kc)); |
| 109 |
T T0 = jacobi_recurse(x, k, T(1), k_prime, 0, &T1, pol); |
| 110 |
*cn = cos(T0); |
| 111 |
*dn = cos(T0) / cos(T1 - T0); |
| 112 |
return sin(T0); |
| 113 |
} |
| 114 |
|
| 115 |
} // namespace detail |
| 116 |
|
| 117 |
template <class T, class U, class V, class Policy> |
| 118 |
inline typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn, V* pdn, const Policy&) |
| 119 |
{ |
| 120 |
BOOST_FPU_EXCEPTION_GUARD |
| 121 |
typedef typename tools::promote_args<T>::type result_type; |
| 122 |
typedef typename policies::evaluation<result_type, Policy>::type value_type; |
| 123 |
typedef typename policies::normalise< |
| 124 |
Policy, |
| 125 |
policies::promote_float<false>, |
| 126 |
policies::promote_double<false>, |
| 127 |
policies::discrete_quantile<>, |
| 128 |
policies::assert_undefined<> >::type forwarding_policy; |
| 129 |
|
| 130 |
static const char* function = "boost::math::jacobi_elliptic<%1%>(%1%)"; |
| 131 |
|
| 132 |
value_type sn, cn, dn; |
| 133 |
sn = detail::jacobi_imp<value_type>(static_cast<value_type>(theta), static_cast<value_type>(k), &cn, &dn, forwarding_policy(), function); |
| 134 |
if(pcn) |
| 135 |
*pcn = policies::checked_narrowing_cast<result_type, Policy>(cn, function); |
| 136 |
if(pdn) |
| 137 |
*pdn = policies::checked_narrowing_cast<result_type, Policy>(dn, function); |
| 138 |
return policies::checked_narrowing_cast<result_type, Policy>(sn, function); |
| 139 |
} |
| 140 |
|
| 141 |
template <class T, class U, class V> |
| 142 |
inline typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn, V* pdn) |
| 143 |
{ |
| 144 |
return jacobi_elliptic(k, theta, pcn, pdn, policies::policy<>()); |
| 145 |
} |
| 146 |
|
| 147 |
template <class U, class T, class Policy> |
| 148 |
inline typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta, const Policy& pol) |
| 149 |
{ |
| 150 |
typedef typename tools::promote_args<T, U>::type result_type; |
| 151 |
return jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), static_cast<result_type*>(nullptr), static_cast<result_type*>(nullptr), pol); |
| 152 |
} |
| 153 |
|
| 154 |
template <class U, class T> |
| 155 |
inline typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta) |
| 156 |
{ |
| 157 |
return jacobi_sn(k, theta, policies::policy<>()); |
| 158 |
} |
| 159 |
|
| 160 |
template <class T, class U, class Policy> |
| 161 |
inline typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta, const Policy& pol) |
| 162 |
{ |
| 163 |
typedef typename tools::promote_args<T, U>::type result_type; |
| 164 |
result_type cn; |
| 165 |
jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), &cn, static_cast<result_type*>(nullptr), pol); |
| 166 |
return cn; |
| 167 |
} |
| 168 |
|
| 169 |
template <class T, class U> |
| 170 |
inline typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta) |
| 171 |
{ |
| 172 |
return jacobi_cn(k, theta, policies::policy<>()); |
| 173 |
} |
| 174 |
|
| 175 |
template <class T, class U, class Policy> |
| 176 |
inline typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta, const Policy& pol) |
| 177 |
{ |
| 178 |
typedef typename tools::promote_args<T, U>::type result_type; |
| 179 |
result_type dn; |
| 180 |
jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), static_cast<result_type*>(nullptr), &dn, pol); |
| 181 |
return dn; |
| 182 |
} |
| 183 |
|
| 184 |
template <class T, class U> |
| 185 |
inline typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta) |
| 186 |
{ |
| 187 |
return jacobi_dn(k, theta, policies::policy<>()); |
| 188 |
} |
| 189 |
|
| 190 |
template <class T, class U, class Policy> |
| 191 |
inline typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta, const Policy& pol) |
| 192 |
{ |
| 193 |
typedef typename tools::promote_args<T, U>::type result_type; |
| 194 |
result_type cn, dn; |
| 195 |
jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), &cn, &dn, pol); |
| 196 |
return cn / dn; |
| 197 |
} |
| 198 |
|
| 199 |
template <class T, class U> |
| 200 |
inline typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta) |
| 201 |
{ |
| 202 |
return jacobi_cd(k, theta, policies::policy<>()); |
| 203 |
} |
| 204 |
|
| 205 |
template <class T, class U, class Policy> |
| 206 |
inline typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta, const Policy& pol) |
| 207 |
{ |
| 208 |
typedef typename tools::promote_args<T, U>::type result_type; |
| 209 |
result_type cn, dn; |
| 210 |
jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), &cn, &dn, pol); |
| 211 |
return dn / cn; |
| 212 |
} |
| 213 |
|
| 214 |
template <class T, class U> |
| 215 |
inline typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta) |
| 216 |
{ |
| 217 |
return jacobi_dc(k, theta, policies::policy<>()); |
| 218 |
} |
| 219 |
|
| 220 |
template <class T, class U, class Policy> |
| 221 |
inline typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta, const Policy& pol) |
| 222 |
{ |
| 223 |
typedef typename tools::promote_args<T, U>::type result_type; |
| 224 |
return 1 / jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), static_cast<result_type*>(nullptr), static_cast<result_type*>(nullptr), pol); |
| 225 |
} |
| 226 |
|
| 227 |
template <class T, class U> |
| 228 |
inline typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta) |
| 229 |
{ |
| 230 |
return jacobi_ns(k, theta, policies::policy<>()); |
| 231 |
} |
| 232 |
|
| 233 |
template <class T, class U, class Policy> |
| 234 |
inline typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta, const Policy& pol) |
| 235 |
{ |
| 236 |
typedef typename tools::promote_args<T, U>::type result_type; |
| 237 |
result_type sn, dn; |
| 238 |
sn = jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), static_cast<result_type*>(nullptr), &dn, pol); |
| 239 |
return sn / dn; |
| 240 |
} |
| 241 |
|
| 242 |
template <class T, class U> |
| 243 |
inline typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta) |
| 244 |
{ |
| 245 |
return jacobi_sd(k, theta, policies::policy<>()); |
| 246 |
} |
| 247 |
|
| 248 |
template <class T, class U, class Policy> |
| 249 |
inline typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta, const Policy& pol) |
| 250 |
{ |
| 251 |
typedef typename tools::promote_args<T, U>::type result_type; |
| 252 |
result_type sn, dn; |
| 253 |
sn = jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), static_cast<result_type*>(nullptr), &dn, pol); |
| 254 |
return dn / sn; |
| 255 |
} |
| 256 |
|
| 257 |
template <class T, class U> |
| 258 |
inline typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta) |
| 259 |
{ |
| 260 |
return jacobi_ds(k, theta, policies::policy<>()); |
| 261 |
} |
| 262 |
|
| 263 |
template <class T, class U, class Policy> |
| 264 |
inline typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta, const Policy& pol) |
| 265 |
{ |
| 266 |
return 1 / jacobi_cn(k, theta, pol); |
| 267 |
} |
| 268 |
|
| 269 |
template <class T, class U> |
| 270 |
inline typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta) |
| 271 |
{ |
| 272 |
return jacobi_nc(k, theta, policies::policy<>()); |
| 273 |
} |
| 274 |
|
| 275 |
template <class T, class U, class Policy> |
| 276 |
inline typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta, const Policy& pol) |
| 277 |
{ |
| 278 |
return 1 / jacobi_dn(k, theta, pol); |
| 279 |
} |
| 280 |
|
| 281 |
template <class T, class U> |
| 282 |
inline typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta) |
| 283 |
{ |
| 284 |
return jacobi_nd(k, theta, policies::policy<>()); |
| 285 |
} |
| 286 |
|
| 287 |
template <class T, class U, class Policy> |
| 288 |
inline typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta, const Policy& pol) |
| 289 |
{ |
| 290 |
typedef typename tools::promote_args<T, U>::type result_type; |
| 291 |
result_type sn, cn; |
| 292 |
sn = jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), &cn, static_cast<result_type*>(nullptr), pol); |
| 293 |
return sn / cn; |
| 294 |
} |
| 295 |
|
| 296 |
template <class T, class U> |
| 297 |
inline typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta) |
| 298 |
{ |
| 299 |
return jacobi_sc(k, theta, policies::policy<>()); |
| 300 |
} |
| 301 |
|
| 302 |
template <class T, class U, class Policy> |
| 303 |
inline typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta, const Policy& pol) |
| 304 |
{ |
| 305 |
typedef typename tools::promote_args<T, U>::type result_type; |
| 306 |
result_type sn, cn; |
| 307 |
sn = jacobi_elliptic(static_cast<result_type>(k), static_cast<result_type>(theta), &cn, static_cast<result_type*>(nullptr), pol); |
| 308 |
return cn / sn; |
| 309 |
} |
| 310 |
|
| 311 |
template <class T, class U> |
| 312 |
inline typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta) |
| 313 |
{ |
| 314 |
return jacobi_cs(k, theta, policies::policy<>()); |
| 315 |
} |
| 316 |
|
| 317 |
}} // namespaces |
| 318 |
|
| 319 |
#endif // BOOST_MATH_JACOBI_ELLIPTIC_HPP |