// (C) Copyright John Maddock 2006. // 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) #ifndef BOOST_MATH_SPECIAL_LEGENDRE_HPP #define BOOST_MATH_SPECIAL_LEGENDRE_HPP #ifdef _MSC_VER #pragma once #endif #include #include #include namespace boost{ namespace math{ // Recurrance relation for legendre P and Q polynomials: template inline typename tools::promote_args::type legendre_next(unsigned l, T1 x, T2 Pl, T3 Plm1) { typedef typename tools::promote_args::type result_type; return ((2 * l + 1) * result_type(x) * result_type(Pl) - l * result_type(Plm1)) / (l + 1); } namespace detail{ // Implement Legendre P and Q polynomials via recurrance: template T legendre_imp(unsigned l, T x, const Policy& pol, bool second = false) { static const char* function = "boost::math::legrendre_p<%1%>(unsigned, %1%)"; // Error handling: if((x < -1) || (x > 1)) return policies::raise_domain_error( function, "The Legendre Polynomial is defined for" " -1 <= x <= 1, but got x = %1%.", x, pol); T p0, p1; if(second) { // A solution of the second kind (Q): p0 = (boost::math::log1p(x, pol) - boost::math::log1p(-x, pol)) / 2; p1 = x * p0 - 1; } else { // A solution of the first kind (P): p0 = 1; p1 = x; } if(l == 0) return p0; unsigned n = 1; while(n < l) { std::swap(p0, p1); p1 = boost::math::legendre_next(n, x, p0, p1); ++n; } return p1; } } // namespace detail template inline typename boost::enable_if_c::value, typename tools::promote_args::type>::type legendre_p(int l, T x, const Policy& pol) { typedef typename tools::promote_args::type result_type; typedef typename policies::evaluation::type value_type; static const char* function = "boost::math::legendre_p<%1%>(unsigned, %1%)"; if(l < 0) return policies::checked_narrowing_cast(detail::legendre_imp(-l-1, static_cast(x), pol, false), function); return policies::checked_narrowing_cast(detail::legendre_imp(l, static_cast(x), pol, false), function); } template inline typename tools::promote_args::type legendre_p(int l, T x) { return boost::math::legendre_p(l, x, policies::policy<>()); } template inline typename boost::enable_if_c::value, typename tools::promote_args::type>::type legendre_q(unsigned l, T x, const Policy& pol) { typedef typename tools::promote_args::type result_type; typedef typename policies::evaluation::type value_type; return policies::checked_narrowing_cast(detail::legendre_imp(l, static_cast(x), pol, true), "boost::math::legendre_q<%1%>(unsigned, %1%)"); } template inline typename tools::promote_args::type legendre_q(unsigned l, T x) { return boost::math::legendre_q(l, x, policies::policy<>()); } // Recurrence for associated polynomials: template inline typename tools::promote_args::type legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1) { typedef typename tools::promote_args::type result_type; return ((2 * l + 1) * result_type(x) * result_type(Pl) - (l + m) * result_type(Plm1)) / (l + 1 - m); } namespace detail{ // Legendre P associated polynomial: template T legendre_p_imp(int l, int m, T x, T sin_theta_power, const Policy& pol) { // Error handling: if((x < -1) || (x > 1)) return policies::raise_domain_error( "boost::math::legendre_p<%1%>(int, int, %1%)", "The associated Legendre Polynomial is defined for" " -1 <= x <= 1, but got x = %1%.", x, pol); // Handle negative arguments first: if(l < 0) return legendre_p_imp(-l-1, m, x, sin_theta_power, pol); if(m < 0) { int sign = (m&1) ? -1 : 1; return sign * boost::math::tgamma_ratio(static_cast(l+m+1), static_cast(l+1-m), pol) * legendre_p_imp(l, -m, x, sin_theta_power, pol); } // Special cases: if(m > l) return 0; if(m == 0) return boost::math::legendre_p(l, x, pol); T p0 = boost::math::double_factorial(2 * m - 1, pol) * sin_theta_power; if(m&1) p0 *= -1; if(m == l) return p0; T p1 = x * (2 * m + 1) * p0; int n = m + 1; while(n < l) { std::swap(p0, p1); p1 = boost::math::legendre_next(n, m, x, p0, p1); ++n; } return p1; } template inline T legendre_p_imp(int l, int m, T x, const Policy& pol) { BOOST_MATH_STD_USING // TODO: we really could use that mythical "pow1p" function here: return legendre_p_imp(l, m, x, static_cast(pow(1 - x*x, T(abs(m))/2)), pol); } } template inline typename tools::promote_args::type legendre_p(int l, int m, T x, const Policy& pol) { typedef typename tools::promote_args::type result_type; typedef typename policies::evaluation::type value_type; return policies::checked_narrowing_cast(detail::legendre_p_imp(l, m, static_cast(x), pol), "bost::math::legendre_p<%1%>(int, int, %1%)"); } template inline typename tools::promote_args::type legendre_p(int l, int m, T x) { return boost::math::legendre_p(l, m, x, policies::policy<>()); } } // namespace math } // namespace boost #endif // BOOST_MATH_SPECIAL_LEGENDRE_HPP