// (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_SPHERICAL_HARMONIC_HPP | |
#define BOOST_MATH_SPECIAL_SPHERICAL_HARMONIC_HPP | |
#ifdef _MSC_VER | |
#pragma once | |
#endif | |
#include <boost/math/special_functions/legendre.hpp> | |
#include <boost/math/tools/workaround.hpp> | |
#include <complex> | |
namespace boost{ | |
namespace math{ | |
namespace detail{ | |
// | |
// Calculates the prefix term that's common to the real | |
// and imaginary parts. Does *not* fix up the sign of the result | |
// though. | |
// | |
template <class T, class Policy> | |
inline T spherical_harmonic_prefix(unsigned n, unsigned m, T theta, const Policy& pol) | |
{ | |
BOOST_MATH_STD_USING | |
if(m > n) | |
return 0; | |
T sin_theta = sin(theta); | |
T x = cos(theta); | |
T leg = detail::legendre_p_imp(n, m, x, pow(fabs(sin_theta), T(m)), pol); | |
T prefix = boost::math::tgamma_delta_ratio(static_cast<T>(n - m + 1), static_cast<T>(2 * m), pol); | |
prefix *= (2 * n + 1) / (4 * constants::pi<T>()); | |
prefix = sqrt(prefix); | |
return prefix * leg; | |
} | |
// | |
// Real Part: | |
// | |
template <class T, class Policy> | |
T spherical_harmonic_r(unsigned n, int m, T theta, T phi, const Policy& pol) | |
{ | |
BOOST_MATH_STD_USING // ADL of std functions | |
bool sign = false; | |
if(m < 0) | |
{ | |
// Reflect and adjust sign if m < 0: | |
sign = m&1; | |
m = abs(m); | |
} | |
if(m&1) | |
{ | |
// Check phase if theta is outside [0, PI]: | |
T mod = boost::math::tools::fmod_workaround(theta, T(2 * constants::pi<T>())); | |
if(mod < 0) | |
mod += 2 * constants::pi<T>(); | |
if(mod > constants::pi<T>()) | |
sign = !sign; | |
} | |
// Get the value and adjust sign as required: | |
T prefix = spherical_harmonic_prefix(n, m, theta, pol); | |
prefix *= cos(m * phi); | |
return sign ? T(-prefix) : prefix; | |
} | |
template <class T, class Policy> | |
T spherical_harmonic_i(unsigned n, int m, T theta, T phi, const Policy& pol) | |
{ | |
BOOST_MATH_STD_USING // ADL of std functions | |
bool sign = false; | |
if(m < 0) | |
{ | |
// Reflect and adjust sign if m < 0: | |
sign = !(m&1); | |
m = abs(m); | |
} | |
if(m&1) | |
{ | |
// Check phase if theta is outside [0, PI]: | |
T mod = boost::math::tools::fmod_workaround(theta, T(2 * constants::pi<T>())); | |
if(mod < 0) | |
mod += 2 * constants::pi<T>(); | |
if(mod > constants::pi<T>()) | |
sign = !sign; | |
} | |
// Get the value and adjust sign as required: | |
T prefix = spherical_harmonic_prefix(n, m, theta, pol); | |
prefix *= sin(m * phi); | |
return sign ? T(-prefix) : prefix; | |
} | |
template <class T, class U, class Policy> | |
std::complex<T> spherical_harmonic(unsigned n, int m, U theta, U phi, const Policy& pol) | |
{ | |
BOOST_MATH_STD_USING | |
// | |
// Sort out the signs: | |
// | |
bool r_sign = false; | |
bool i_sign = false; | |
if(m < 0) | |
{ | |
// Reflect and adjust sign if m < 0: | |
r_sign = m&1; | |
i_sign = !(m&1); | |
m = abs(m); | |
} | |
if(m&1) | |
{ | |
// Check phase if theta is outside [0, PI]: | |
U mod = boost::math::tools::fmod_workaround(theta, 2 * constants::pi<U>()); | |
if(mod < 0) | |
mod += 2 * constants::pi<U>(); | |
if(mod > constants::pi<U>()) | |
{ | |
r_sign = !r_sign; | |
i_sign = !i_sign; | |
} | |
} | |
// | |
// Calculate the value: | |
// | |
U prefix = spherical_harmonic_prefix(n, m, theta, pol); | |
U r = prefix * cos(m * phi); | |
U i = prefix * sin(m * phi); | |
// | |
// Add in the signs: | |
// | |
if(r_sign) | |
r = -r; | |
if(i_sign) | |
i = -i; | |
static const char* function = "boost::math::spherical_harmonic<%1%>(int, int, %1%, %1%)"; | |
return std::complex<T>(policies::checked_narrowing_cast<T, Policy>(r, function), policies::checked_narrowing_cast<T, Policy>(i, function)); | |
} | |
} // namespace detail | |
template <class T1, class T2, class Policy> | |
inline std::complex<typename tools::promote_args<T1, T2>::type> | |
spherical_harmonic(unsigned n, int m, T1 theta, T2 phi, const Policy& pol) | |
{ | |
typedef typename tools::promote_args<T1, T2>::type result_type; | |
typedef typename policies::evaluation<result_type, Policy>::type value_type; | |
return detail::spherical_harmonic<result_type, value_type>(n, m, static_cast<value_type>(theta), static_cast<value_type>(phi), pol); | |
} | |
template <class T1, class T2> | |
inline std::complex<typename tools::promote_args<T1, T2>::type> | |
spherical_harmonic(unsigned n, int m, T1 theta, T2 phi) | |
{ | |
return boost::math::spherical_harmonic(n, m, theta, phi, policies::policy<>()); | |
} | |
template <class T1, class T2, class Policy> | |
inline typename tools::promote_args<T1, T2>::type | |
spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi, const Policy& pol) | |
{ | |
typedef typename tools::promote_args<T1, T2>::type result_type; | |
typedef typename policies::evaluation<result_type, Policy>::type value_type; | |
return policies::checked_narrowing_cast<result_type, Policy>(detail::spherical_harmonic_r(n, m, static_cast<value_type>(theta), static_cast<value_type>(phi), pol), "bost::math::spherical_harmonic_r<%1%>(unsigned, int, %1%, %1%)"); | |
} | |
template <class T1, class T2> | |
inline typename tools::promote_args<T1, T2>::type | |
spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi) | |
{ | |
return boost::math::spherical_harmonic_r(n, m, theta, phi, policies::policy<>()); | |
} | |
template <class T1, class T2, class Policy> | |
inline typename tools::promote_args<T1, T2>::type | |
spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol) | |
{ | |
typedef typename tools::promote_args<T1, T2>::type result_type; | |
typedef typename policies::evaluation<result_type, Policy>::type value_type; | |
return policies::checked_narrowing_cast<result_type, Policy>(detail::spherical_harmonic_i(n, m, static_cast<value_type>(theta), static_cast<value_type>(phi), pol), "boost::math::spherical_harmonic_i<%1%>(unsigned, int, %1%, %1%)"); | |
} | |
template <class T1, class T2> | |
inline typename tools::promote_args<T1, T2>::type | |
spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi) | |
{ | |
return boost::math::spherical_harmonic_i(n, m, theta, phi, policies::policy<>()); | |
} | |
} // namespace math | |
} // namespace boost | |
#endif // BOOST_MATH_SPECIAL_SPHERICAL_HARMONIC_HPP | |