123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247 |
- [/
- Copyright (c) 2006 Xiaogang Zhang
- Copyright (c) 2006 John Maddock
- 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)
- ]
- [section:ellint_carlson Elliptic Integrals - Carlson Form]
- [heading Synopsis]
- ``
- #include <boost/math/special_functions/ellint_rf.hpp>
- ``
- namespace boost { namespace math {
- template <class T1, class T2, class T3>
- ``__sf_result`` ellint_rf(T1 x, T2 y, T3 z)
- template <class T1, class T2, class T3, class ``__Policy``>
- ``__sf_result`` ellint_rf(T1 x, T2 y, T3 z, const ``__Policy``&)
- }} // namespaces
- ``
- #include <boost/math/special_functions/ellint_rd.hpp>
- ``
- namespace boost { namespace math {
- template <class T1, class T2, class T3>
- ``__sf_result`` ellint_rd(T1 x, T2 y, T3 z)
- template <class T1, class T2, class T3, class ``__Policy``>
- ``__sf_result`` ellint_rd(T1 x, T2 y, T3 z, const ``__Policy``&)
- }} // namespaces
- ``
- #include <boost/math/special_functions/ellint_rj.hpp>
- ``
- namespace boost { namespace math {
- template <class T1, class T2, class T3, class T4>
- ``__sf_result`` ellint_rj(T1 x, T2 y, T3 z, T4 p)
- template <class T1, class T2, class T3, class T4, class ``__Policy``>
- ``__sf_result`` ellint_rj(T1 x, T2 y, T3 z, T4 p, const ``__Policy``&)
- }} // namespaces
- ``
- #include <boost/math/special_functions/ellint_rc.hpp>
- ``
- namespace boost { namespace math {
- template <class T1, class T2>
- ``__sf_result`` ellint_rc(T1 x, T2 y)
- template <class T1, class T2, class ``__Policy``>
- ``__sf_result`` ellint_rc(T1 x, T2 y, const ``__Policy``&)
- }} // namespaces
- ``
- #include <boost/math/special_functions/ellint_rg.hpp>
- ``
- namespace boost { namespace math {
- template <class T1, class T2, class T3>
- ``__sf_result`` ellint_rg(T1 x, T2 y, T3 z)
- template <class T1, class T2, class T3, class ``__Policy``>
- ``__sf_result`` ellint_rg(T1 x, T2 y, T3 z, const ``__Policy``&)
- }} // namespaces
- [heading Description]
- These functions return Carlson's symmetrical elliptic integrals, the functions
- have complicated behavior over all their possible domains, but the following
- graph gives an idea of their behavior:
- [graph ellint_carlson]
- The return type of these functions is computed using the __arg_promotion_rules
- when the arguments are of different types: otherwise the return is the same type
- as the arguments.
- template <class T1, class T2, class T3>
- ``__sf_result`` ellint_rf(T1 x, T2 y, T3 z)
-
- template <class T1, class T2, class T3, class ``__Policy``>
- ``__sf_result`` ellint_rf(T1 x, T2 y, T3 z, const ``__Policy``&)
-
- Returns Carlson's Elliptic Integral ['R[sub F]]:
- [equation ellint9]
- Requires that all of the arguments are non-negative, and at most
- one may be zero. Otherwise returns the result of __domain_error.
- [optional_policy]
- template <class T1, class T2, class T3>
- ``__sf_result`` ellint_rd(T1 x, T2 y, T3 z)
-
- template <class T1, class T2, class T3, class ``__Policy``>
- ``__sf_result`` ellint_rd(T1 x, T2 y, T3 z, const ``__Policy``&)
-
- Returns Carlson's elliptic integral R[sub D]:
- [equation ellint10]
- Requires that x and y are non-negative, with at most one of them
- zero, and that z >= 0. Otherwise returns the result of __domain_error.
- [optional_policy]
- template <class T1, class T2, class T3, class T4>
- ``__sf_result`` ellint_rj(T1 x, T2 y, T3 z, T4 p)
- template <class T1, class T2, class T3, class T4, class ``__Policy``>
- ``__sf_result`` ellint_rj(T1 x, T2 y, T3 z, T4 p, const ``__Policy``&)
- Returns Carlson's elliptic integral R[sub J]:
-
- [equation ellint11]
- Requires that x, y and z are non-negative, with at most one of them
- zero, and that ['p != 0]. Otherwise returns the result of __domain_error.
- [optional_policy]
- When ['p < 0] the function returns the
- [@http://en.wikipedia.org/wiki/Cauchy_principal_value Cauchy principal value]
- using the relation:
- [equation ellint17]
- template <class T1, class T2>
- ``__sf_result`` ellint_rc(T1 x, T2 y)
- template <class T1, class T2, class ``__Policy``>
- ``__sf_result`` ellint_rc(T1 x, T2 y, const ``__Policy``&)
- Returns Carlson's elliptic integral R[sub C]:
-
- [equation ellint12]
- Requires that ['x > 0] and that ['y != 0].
- Otherwise returns the result of __domain_error.
- [optional_policy]
- When ['y < 0] the function returns the
- [@http://mathworld.wolfram.com/CauchyPrincipalValue.html Cauchy principal value]
- using the relation:
- [equation ellint18]
- template <class T1, class T2, class T3>
- ``__sf_result`` ellint_rg(T1 x, T2 y, T3 z)
-
- template <class T1, class T2, class T3, class ``__Policy``>
- ``__sf_result`` ellint_rg(T1 x, T2 y, T3 z, const ``__Policy``&)
-
- Returns Carlson's elliptic integral ['R[sub G]:]
- [equation ellint27]
- Requires that x and y are non-negative, otherwise returns the result of __domain_error.
- [optional_policy]
- [heading Testing]
- There are two sets of tests.
- Spot tests compare selected values with test data given in:
- [:B. C. Carlson, ['[@http://arxiv.org/abs/math.CA/9409227
- Numerical computation of real or complex elliptic integrals]]. Numerical Algorithms,
- Volume 10, Number 1 / March, 1995, pp 13-26.]
- Random test data generated using NTL::RR at 1000-bit precision and our
- implementation checks for rounding-errors and/or regressions.
- There are also sanity checks that use the inter-relations between the integrals
- to verify their correctness: see the above Carlson paper for details.
- [heading Accuracy]
- These functions are computed using only basic arithmetic operations, so
- there isn't much variation in accuracy over differing platforms.
- Note that only results for the widest floating-point type on the
- system are given as narrower types have __zero_error. All values
- are relative errors in units of epsilon.
- [table_ellint_rc]
- [table_ellint_rd]
- [table_ellint_rg]
- [table_ellint_rf]
- [table_ellint_rj]
- [heading Implementation]
- The key of Carlson's algorithm [[link ellint_ref_carlson79 Carlson79]] is the
- duplication theorem:
- [equation ellint13]
- By applying it repeatedly, ['x], ['y], ['z] get
- closer and closer. When they are nearly equal, the special case equation
- [equation ellint16]
- is used. More specifically, ['[R F]] is evaluated from a Taylor series
- expansion to the fifth order. The calculations of the other three integrals
- are analogous, except for R[sub C] which can be computed from elementary functions.
- For ['p < 0] in ['R[sub J](x, y, z, p)] and ['y < 0] in ['R[sub C](x, y)],
- the integrals are singular and their
- [@http://mathworld.wolfram.com/CauchyPrincipalValue.html Cauchy principal values]
- are returned via the relations:
- [equation ellint17]
- [equation ellint18]
- [endsect] [/section:ellint_carlson Elliptic Integrals - Carlson Form]
|