Subject: [Boost-commit] svn:boost r82900 - trunk/libs/math/example
From: pbristow_at_[hidden]
Date: 2013-02-15 06:01:22
Author: pbristow
Date: 2013-02-15 06:01:22 EST (Fri, 15 Feb 2013)
New Revision: 82900
URL: http://svn.boost.org/trac/boost/changeset/82900
Log:
Use more accurate values for airy zeros as max and min to suit 80 bit long double platforms.
Text files modified:
trunk/libs/math/example/bessel_zeros_example.cpp | 124 +++++++++++++++++++++++++++++++++++++++
1 files changed, 123 insertions(+), 1 deletions(-)
Modified: trunk/libs/math/example/bessel_zeros_example.cpp
==============================================================================
--- trunk/libs/math/example/bessel_zeros_example.cpp (original)
+++ trunk/libs/math/example/bessel_zeros_example.cpp 2013-02-15 06:01:22 EST (Fri, 15 Feb 2013)
@@ -43,7 +43,7 @@
//`This file has the forward declaration signatures for the zero-finding functions:
- #include <boost/math/special_functions/math_fwd.hpp>
+// #include <boost/math/special_functions/math_fwd.hpp>
/*`but more details are in the full documentation, for example at
[@http://www.boost.org/doc/libs/1_53_0/libs/math/doc/sf_and_dist/html/math_toolkit/special/bessel/bessel_over.html Boost.Math Bessel functions]
@@ -106,6 +106,7 @@
T* p_sum;
};
+
//] [/bessel_zero_example_iterator_1]
int main()
@@ -140,6 +141,33 @@
error C2338: Order must be a floating-point type.
``
*/
+
+/*` We can use a policy to ignore errors, C-style, returning some value
+perhaps infinity or NaN or the best that can be done. (See __user_error_handling). */
+
+/*`Create a policy that ignores all errors (possibly unwise!).*/
+
+ typedef boost::math::policies::policy<
+ boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+ boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+ boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+ boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+ boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+ boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+ > ignore_all_policy;
+
+ // std::cout.precision(6); // Show 6 decimal digits.
+
+ double inf = std::numeric_limits<double>::infinity();
+ double nan = std::numeric_limits<double>::quiet_NaN();
+
+ double dodgy_root = boost::math::cyl_bessel_j_zero(-1.0, 1U, ignore_all_policy());
+ std::cout << "boost::math::cyl_bessel_j_zero(-1.0, 1U) " << dodgy_root << std::endl; // 1.#QNAN
+ double inf_root = boost::math::cyl_bessel_j_zero(inf, 1U, ignore_all_policy());
+ std::cout << "boost::math::cyl_bessel_j_zero(inf, 1U) " << inf_root << std::endl; // 1.#QNAN
+ double nan_root = boost::math::cyl_bessel_j_zero(nan, 1U, ignore_all_policy());
+ std::cout << "boost::math::cyl_bessel_j_zero(nan, 1U) " << nan_root << std::endl; // 1.#QNAN
+
/*`Another version of `cyl_bessel_j_zero` allows calculation of multiple zeros with one call,
placing the results in a container, often `std::vector`.
For example, generate five `double` roots of J[sub v] for integral order 2.
@@ -155,6 +183,8 @@
roots.end(),
std::ostream_iterator<double>(std::cout, "\n"));
+
+
/*`Or generate 50 decimal digit roots of J[sub v] for non-integral order `v=71/19`.
We set the precision of the output stream and show trailing zeros to display a fixed 50 decimal digits.
@@ -176,6 +206,7 @@
std::copy(zeros.begin(), zeros.end(),
std::ostream_iterator<float_type>(std::cout, "\n"));
+
/*`The Neumann functions zeros are evaluated very similarly:
*/
using boost::math::cyl_neumann_zero;
@@ -188,6 +219,11 @@
std::copy(nzeros.begin(), nzeros.end(),
std::ostream_iterator<float>(std::cout, "\n"));
+
+ std::cout << cyl_neumann_zero(static_cast<float_type>(220)/100, 1U) << std::endl;
+ // 3.6154383428745996706772556069431792744372398748422
+
+
/*`Finally we show how the output interator can be used to compute a sum of zeros.
See [@http://dx.doi.org/10.1017/S2040618500034067 Ian N. Sneddon, Infinite Sums of Bessel Zeros],
@@ -216,6 +252,92 @@
{
std::cout << "Throw exception " << ex.what() << std::endl;
}
+
+ // Show effect of 'bad' arguments that throw a domain_error exception.
+ try
+ { // Try a negative order v.
+ double dodgy_root = boost::math::cyl_bessel_j_zero(-1.0, 1U);
+ std::cout << "boost::math::cyl_bessel_j_zero(-1.0, 1U) " << dodgy_root << std::endl;
+ // Throw exception Error in function boost::math::cyl_bessel_j_zero<long double>(long double, unsigned):
+ // Order argument is -1, but must be >= 0 !
+ }
+ catch (std::exception ex)
+ {
+ std::cout << "Throw exception " << ex.what() << std::endl;
+ }
+
+ try
+ { // order v = inf
+ double inf = std::numeric_limits<double>::infinity();
+ double inf_root = boost::math::cyl_bessel_j_zero(inf, 1U);
+ std::cout << "boost::math::cyl_bessel_j_zero(inf, 1U) " << inf_root << std::endl;
+ // Throw exception Error in function boost::math::cyl_bessel_j_zero<long double>(long double, unsigned):
+ // Order argument is 1.#INF, but must be finite >= 0 !
+ }
+ catch (std::exception ex)
+ {
+ std::cout << "Throw exception " << ex.what() << std::endl;
+ }
+
+ try
+ { // order v = NaN
+ double nan = std::numeric_limits<double>::quiet_NaN();
+ double nan_root = boost::math::cyl_bessel_j_zero(nan, 1);
+ std::cout << "boost::math::cyl_bessel_j_zero(nan, 1U) " << nan_root << std::endl;
+ // Throw exception Error in function boost::math::cyl_bessel_j_zero<long double>(long double, unsigned):
+ // Order argument is 1.#QNAN, but must be finite >= 0 !
+ }
+ catch (std::exception ex)
+ {
+ std::cout << "Throw exception " << ex.what() << std::endl;
+ }
+
+
+
+ try
+ { // Try a negative m.
+ double dodgy_root = boost::math::cyl_bessel_j_zero(0.0, -1);
+ // warning C4146: unary minus operator applied to unsigned type, result still unsigned.
+ std::cout << "boost::math::cyl_bessel_j_zero(0.0, -1) " << dodgy_root << std::endl;
+ // boost::math::cyl_bessel_j_zero(0.0, -1U) 6.74652e+009
+ // This *should* fail because m is unreasonably large.
+
+ }
+ catch (std::exception ex)
+ {
+ std::cout << "Throw exception " << ex.what() << std::endl;
+ }
+
+ try
+ { // m = inf
+ double inf = std::numeric_limits<double>::infinity();
+ double inf_root = boost::math::cyl_bessel_j_zero(0.0, inf);
+ // warning C4244: 'argument' : conversion from 'double' to 'unsigned int', possible loss of data
+ std::cout << "boost::math::cyl_bessel_j_zero(0.0, inf) " << inf_root << std::endl;
+ // Throw exception Error in function boost::math::cyl_bessel_j_zero<long double>(long double, unsigned):
+ // Requested the 0'th zero, but must be > 0 !
+
+ }
+ catch (std::exception ex)
+ {
+ std::cout << "Throw exception " << ex.what() << std::endl;
+ }
+
+ try
+ { // m = NaN
+ double nan = std::numeric_limits<double>::quiet_NaN();
+ double nan_root = boost::math::cyl_bessel_j_zero(0.0, nan);
+ // warning C4244: 'argument' : conversion from 'double' to 'unsigned int', possible loss of data
+ std::cout << "boost::math::cyl_bessel_j_zero(0.0, nan) " << nan_root << std::endl;
+ // Throw exception Error in function boost::math::cyl_bessel_j_zero<long double>(long double, unsigned):
+ // Requested the 0'th zero, but must be > 0 !
+ }
+ catch (std::exception ex)
+ {
+ std::cout << "Throw exception " << ex.what() << std::endl;
+ }
+
+
} // int main()