|
|
Boost-Commit : |
From: pbristow_at_[hidden]
Date: 2007-09-20 07:39:31
Author: pbristow
Date: 2007-09-20 07:39:30 EDT (Thu, 20 Sep 2007)
New Revision: 39403
URL: http://svn.boost.org/trac/boost/changeset/39403
Log:
warning suppression with comment - constant too big for float.
Text files modified:
sandbox/math_toolkit/libs/math/test/test_bessel_k.cpp | 9 ++++++++-
sandbox/math_toolkit/libs/math/test/test_ellint_1.cpp | 38 ++++++++++++++++++++++----------------
sandbox/math_toolkit/libs/math/test/test_ellint_2.cpp | 37 ++++++++++++++++++++++---------------
sandbox/math_toolkit/libs/math/test/test_ellint_3.cpp | 35 ++++++++++++++++++++---------------
sandbox/math_toolkit/libs/math/test/test_hermite.cpp | 9 ++++++++-
sandbox/math_toolkit/libs/math/test/test_roots.cpp | 22 +++++++++++-----------
sandbox/math_toolkit/libs/math/test/test_spherical_harmonic.cpp | 28 ++++++++++++++--------------
7 files changed, 105 insertions(+), 73 deletions(-)
Modified: sandbox/math_toolkit/libs/math/test/test_bessel_k.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_bessel_k.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_bessel_k.cpp 2007-09-20 07:39:30 EDT (Thu, 20 Sep 2007)
@@ -1,8 +1,15 @@
-// (C) Copyright John Maddock 2007.
+// Copyright John Maddock 2006, 2007
+// Copyright Paul A. Bristow 2007
+
// 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)
+#ifdef _MSC_VER
+# pragma warning(disable : 4756) // overflow in constant arithmetic
+// Constants are too big for float case, but this doesn't matter for test.
+#endif
+
#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
#include <boost/math/concepts/real_concept.hpp>
#include <boost/test/included/test_exec_monitor.hpp>
Modified: sandbox/math_toolkit/libs/math/test/test_ellint_1.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_ellint_1.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_ellint_1.cpp 2007-09-20 07:39:30 EDT (Thu, 20 Sep 2007)
@@ -1,10 +1,16 @@
-// Copyright (c) 2006 Xiaogang Zhang
-// Copyright (c) 2006 John Maddock
-//
+// Copyright Xiaogang Zhang 2006
+// Copyright John Maddock 2006, 2007
+// Copyright Paul A. Bristow 2007
+
// 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)
+#ifdef _MSC_VER
+# pragma warning(disable : 4756) // overflow in constant arithmetic
+// Constants are too big for float case, but this doesn't matter for test.
+#endif
+
#include <boost/math/concepts/real_concept.hpp>
#include <boost/test/included/test_exec_monitor.hpp>
#include <boost/test/floating_point_comparison.hpp>
@@ -18,17 +24,17 @@
// DESCRIPTION:
// ~~~~~~~~~~~~
//
-// This file tests the Elliptic Integrals of the first kind.
+// This file tests the Elliptic Integrals of the first kind.
// There are two sets of tests, spot
// tests which compare our results with selected values computed
-// using the online special function calculator at
+// using the online special function calculator at
// functions.wolfram.com, while the bulk of the accuracy tests
// use values generated with NTL::RR at 1000-bit precision
// and our generic versions of these functions.
//
// Note that when this file is first run on a new platform many of
// these tests will fail: the default accuracy is 1 epsilon which
-// is too tight for most platforms. In this situation you will
+// is too tight for most platforms. In this situation you will
// need to cast a human eye over the error rates reported and make
// a judgement as to whether they are acceptable. Either way please
// report the results to the Boost mailing list. Acceptable rates of
@@ -79,7 +85,7 @@
// Finish off by printing out the compiler/stdlib/platform names,
// we do this to make it easier to mark up expected error rates.
//
- std::cout << "Tests run with " << BOOST_COMPILER << ", "
+ std::cout << "Tests run with " << BOOST_COMPILER << ", "
<< BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}
@@ -94,14 +100,14 @@
value_type (*fp2)(value_type, value_type) = boost::math::ellint_1;
boost::math::tools::test_result<value_type> result;
-
+
result = boost::math::tools::test(
- data,
- boost::lambda::bind(fp2,
+ data,
+ boost::lambda::bind(fp2,
boost::lambda::ret<value_type>(boost::lambda::_1[1]),
boost::lambda::ret<value_type>(boost::lambda::_1[0])),
boost::lambda::ret<value_type>(boost::lambda::_1[2]));
- handle_test_result(result, data[result.worst()], result.worst(),
+ handle_test_result(result, data[result.worst()], result.worst(),
type_name, "boost::math::ellint_1", test);
std::cout << std::endl;
@@ -119,11 +125,11 @@
value_type (*fp1)(value_type) = boost::math::ellint_1;
result = boost::math::tools::test(
- data,
- boost::lambda::bind(fp1,
+ data,
+ boost::lambda::bind(fp1,
boost::lambda::ret<value_type>(boost::lambda::_1[0])),
boost::lambda::ret<value_type>(boost::lambda::_1[1]));
- handle_test_result(result, data[result.worst()], result.worst(),
+ handle_test_result(result, data[result.worst()], result.worst(),
type_name, "boost::math::ellint_1", test);
std::cout << std::endl;
@@ -133,7 +139,7 @@
void test_spots(T, const char* type_name)
{
// Function values calculated on http://functions.wolfram.com/
- // Note that Mathematica's EllipticF accepts k^2 as the second parameter.
+ // Note that Mathematica's EllipticF accepts k^2 as the second parameter.
#define SC_(x) static_cast<T>(BOOST_JOIN(x, L))
static const boost::array<boost::array<T, 3>, 19> data1 = {
SC_(0), SC_(0), SC_(0),
@@ -165,7 +171,7 @@
do_test_ellint_f(ellint_f_data, type_name, "Elliptic Integral F: Random Data");
// Function values calculated on http://functions.wolfram.com/
- // Note that Mathematica's EllipticK accepts k^2 as the second parameter.
+ // Note that Mathematica's EllipticK accepts k^2 as the second parameter.
#define SC_(x) static_cast<T>(BOOST_JOIN(x, L))
static const boost::array<boost::array<T, 2>, 9> data2 = {
SC_(0), SC_(1.5707963267948966192313216916397514420985846996876),
Modified: sandbox/math_toolkit/libs/math/test/test_ellint_2.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_ellint_2.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_ellint_2.cpp 2007-09-20 07:39:30 EDT (Thu, 20 Sep 2007)
@@ -1,9 +1,16 @@
-// Copyright (c) 2006 Xiaogang Zhang
-// Copyright (c) 2006 John Maddock
+// Copyright Xiaogang Zhang 2006
+// Copyright John Maddock 2006, 2007
+// Copyright Paul A. Bristow 2007
+
// 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)
+#ifdef _MSC_VER
+# pragma warning(disable : 4756) // overflow in constant arithmetic
+// Constants are too big for float case, but this doesn't matter for test.
+#endif
+
#include <boost/math/concepts/real_concept.hpp>
#include <boost/test/included/test_exec_monitor.hpp>
#include <boost/test/floating_point_comparison.hpp>
@@ -17,17 +24,17 @@
// DESCRIPTION:
// ~~~~~~~~~~~~
//
-// This file tests the Elliptic Integrals of the second kind.
+// This file tests the Elliptic Integrals of the second kind.
// There are two sets of tests, spot
// tests which compare our results with selected values computed
-// using the online special function calculator at
+// using the online special function calculator at
// functions.wolfram.com, while the bulk of the accuracy tests
// use values generated with NTL::RR at 1000-bit precision
// and our generic versions of these functions.
//
// Note that when this file is first run on a new platform many of
// these tests will fail: the default accuracy is 1 epsilon which
-// is too tight for most platforms. In this situation you will
+// is too tight for most platforms. In this situation you will
// need to cast a human eye over the error rates reported and make
// a judgement as to whether they are acceptable. Either way please
// report the results to the Boost mailing list. Acceptable rates of
@@ -78,7 +85,7 @@
// Finish off by printing out the compiler/stdlib/platform names,
// we do this to make it easier to mark up expected error rates.
//
- std::cout << "Tests run with " << BOOST_COMPILER << ", "
+ std::cout << "Tests run with " << BOOST_COMPILER << ", "
<< BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}
@@ -93,14 +100,14 @@
value_type (*fp2)(value_type, value_type) = boost::math::ellint_2;
boost::math::tools::test_result<value_type> result;
-
+
result = boost::math::tools::test(
- data,
- boost::lambda::bind(fp2,
+ data,
+ boost::lambda::bind(fp2,
boost::lambda::ret<value_type>(boost::lambda::_1[1]),
boost::lambda::ret<value_type>(boost::lambda::_1[0])),
boost::lambda::ret<value_type>(boost::lambda::_1[2]));
- handle_test_result(result, data[result.worst()], result.worst(),
+ handle_test_result(result, data[result.worst()], result.worst(),
type_name, "boost::math::ellint_2", test);
std::cout << std::endl;
@@ -117,11 +124,11 @@
value_type (*fp1)(value_type) = boost::math::ellint_2;
result = boost::math::tools::test(
- data,
- boost::lambda::bind(fp1,
+ data,
+ boost::lambda::bind(fp1,
boost::lambda::ret<value_type>(boost::lambda::_1[0])),
boost::lambda::ret<value_type>(boost::lambda::_1[1]));
- handle_test_result(result, data[result.worst()], result.worst(),
+ handle_test_result(result, data[result.worst()], result.worst(),
type_name, "boost::math::ellint_2", test);
std::cout << std::endl;
@@ -131,7 +138,7 @@
void test_spots(T, const char* type_name)
{
// Function values calculated on http://functions.wolfram.com/
- // Note that Mathematica's EllipticE accepts k^2 as the second parameter.
+ // Note that Mathematica's EllipticE accepts k^2 as the second parameter.
#define SC_(x) static_cast<T>(BOOST_JOIN(x, L))
static const boost::array<boost::array<T, 3>, 10> data1 = {
SC_(0), SC_(0), SC_(0),
@@ -154,7 +161,7 @@
do_test_ellint_e2(ellint_e2_data, type_name, "Elliptic Integral E: Random Data");
// Function values calculated on http://functions.wolfram.com/
- // Note that Mathematica's EllipticE accepts k^2 as the second parameter.
+ // Note that Mathematica's EllipticE accepts k^2 as the second parameter.
#define SC_(x) static_cast<T>(BOOST_JOIN(x, L))
static const boost::array<boost::array<T, 2>, 10> data2 = {
SC_(-1), SC_(1),
Modified: sandbox/math_toolkit/libs/math/test/test_ellint_3.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_ellint_3.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_ellint_3.cpp 2007-09-20 07:39:30 EDT (Thu, 20 Sep 2007)
@@ -1,11 +1,16 @@
-// Copyright 2006 Xiaogang Zhang
-// Copyright 2006 John Maddock
-// Copyright Paul A. Bristow 2007.
+// Copyright Xiaogang Zhang 2006
+// Copyright John Maddock 2006, 2007
+// Copyright Paul A. Bristow 2007
// 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)
+#ifdef _MSC_VER
+# pragma warning(disable : 4756) // overflow in constant arithmetic
+// Constants are too big for float case, but this doesn't matter for test.
+#endif
+
#include <boost/math/concepts/real_concept.hpp>
#include <boost/test/included/test_exec_monitor.hpp>
#include <boost/test/floating_point_comparison.hpp>
@@ -19,17 +24,17 @@
// DESCRIPTION:
// ~~~~~~~~~~~~
//
-// This file tests the Elliptic Integrals of the third kind.
+// This file tests the Elliptic Integrals of the third kind.
// There are two sets of tests, spot
// tests which compare our results with selected values computed
-// using the online special function calculator at
+// using the online special function calculator at
// functions.wolfram.com, while the bulk of the accuracy tests
// use values generated with NTL::RR at 1000-bit precision
// and our generic versions of these functions.
//
// Note that when this file is first run on a new platform many of
// these tests will fail: the default accuracy is 1 epsilon which
-// is too tight for most platforms. In this situation you will
+// is too tight for most platforms. In this situation you will
// need to cast a human eye over the error rates reported and make
// a judgement as to whether they are acceptable. Either way please
// report the results to the Boost mailing list. Acceptable rates of
@@ -94,7 +99,7 @@
// Finish off by printing out the compiler/stdlib/platform names,
// we do this to make it easier to mark up expected error rates.
//
- std::cout << "Tests run with " << BOOST_COMPILER << ", "
+ std::cout << "Tests run with " << BOOST_COMPILER << ", "
<< BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}
@@ -108,15 +113,15 @@
value_type (*fp2)(value_type, value_type, value_type) = boost::math::ellint_3;
boost::math::tools::test_result<value_type> result;
-
+
result = boost::math::tools::test(
- data,
- boost::lambda::bind(fp2,
+ data,
+ boost::lambda::bind(fp2,
boost::lambda::ret<value_type>(boost::lambda::_1[2]),
boost::lambda::ret<value_type>(boost::lambda::_1[0]),
boost::lambda::ret<value_type>(boost::lambda::_1[1])),
boost::lambda::ret<value_type>(boost::lambda::_1[3]));
- handle_test_result(result, data[result.worst()], result.worst(),
+ handle_test_result(result, data[result.worst()], result.worst(),
type_name, "boost::math::ellint_3", test);
std::cout << std::endl;
@@ -133,14 +138,14 @@
value_type (*fp2)(value_type, value_type) = boost::math::ellint_3;
boost::math::tools::test_result<value_type> result;
-
+
result = boost::math::tools::test(
- data,
- boost::lambda::bind(fp2,
+ data,
+ boost::lambda::bind(fp2,
boost::lambda::ret<value_type>(boost::lambda::_1[1]),
boost::lambda::ret<value_type>(boost::lambda::_1[0])),
boost::lambda::ret<value_type>(boost::lambda::_1[2]));
- handle_test_result(result, data[result.worst()], result.worst(),
+ handle_test_result(result, data[result.worst()], result.worst(),
type_name, "boost::math::ellint_3", test);
std::cout << std::endl;
Modified: sandbox/math_toolkit/libs/math/test/test_hermite.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_hermite.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_hermite.cpp 2007-09-20 07:39:30 EDT (Thu, 20 Sep 2007)
@@ -1,8 +1,15 @@
-// (C) Copyright John Maddock 2006.
+// Copyright John Maddock 2006, 2007
+// Copyright Paul A. Bristow 2007
+
// 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)
+#ifdef _MSC_VER
+# pragma warning(disable : 4756) // overflow in constant arithmetic
+// Constants are too big for float case, but this doesn't matter for test.
+#endif
+
#include <boost/math/concepts/real_concept.hpp>
#include <boost/test/included/test_exec_monitor.hpp>
#include <boost/test/floating_point_comparison.hpp>
Modified: sandbox/math_toolkit/libs/math/test/test_roots.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_roots.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_roots.cpp 2007-09-20 07:39:30 EDT (Thu, 20 Sep 2007)
@@ -19,7 +19,7 @@
template <class T, class Policy>
struct ibeta_roots_1 // for first order algorithms
{
- ibeta_roots_1(T _a, T _b, T t, bool inv = false)
+ ibeta_roots_1(T _a, T _b, T t, bool inv = false)
: a(_a), b(_b), target(t), invert(inv) {}
T operator()(const T& x)
@@ -34,15 +34,15 @@
template <class T, class Policy>
struct ibeta_roots_2 // for second order algorithms
{
- ibeta_roots_2(T _a, T _b, T t, bool inv = false)
+ ibeta_roots_2(T _a, T _b, T t, bool inv = false)
: a(_a), b(_b), target(t), invert(inv) {}
std::tr1::tuple<T, T> operator()(const T& x)
{
typedef typename boost::math::lanczos::lanczos<T, Policy>::type L;
T f = boost::math::detail::ibeta_imp(a, b, x, Policy(), invert, true) - target;
- T f1 = invert ?
- -boost::math::detail::ibeta_power_terms(b, a, 1 - x, x, L(), true, Policy())
+ T f1 = invert ?
+ -boost::math::detail::ibeta_power_terms(b, a, 1 - x, x, L(), true, Policy())
: boost::math::detail::ibeta_power_terms(a, b, x, 1 - x, L(), true, Policy());
T y = 1 - x;
if(y == 0)
@@ -63,15 +63,15 @@
template <class T, class Policy>
struct ibeta_roots_3 // for third order algorithms
{
- ibeta_roots_3(T _a, T _b, T t, bool inv = false)
+ ibeta_roots_3(T _a, T _b, T t, bool inv = false)
: a(_a), b(_b), target(t), invert(inv) {}
std::tr1::tuple<T, T, T> operator()(const T& x)
{
typedef typename boost::math::lanczos::lanczos<T, Policy>::type L;
T f = boost::math::detail::ibeta_imp(a, b, x, Policy(), invert, true) - target;
- T f1 = invert ?
- -boost::math::detail::ibeta_power_terms(b, a, 1 - x, x, L(), true, Policy())
+ T f1 = invert ?
+ -boost::math::detail::ibeta_power_terms(b, a, 1 - x, x, L(), true, Policy())
: boost::math::detail::ibeta_power_terms(a, b, x, 1 - x, L(), true, Policy());
T y = 1 - x;
if(y == 0)
@@ -232,8 +232,8 @@
for(unsigned i = 0; i < data.size(); ++i)
{
//
- // These inverse tests are thrown off if the output of the
- // incomplete beta is too close to 1: basically there is insuffient
+ // These inverse tests are thrown off if the output of the
+ // incomplete beta is too close to 1: basically there is insuffient
// information left in the value we're using as input to the inverse
// to be able to get back to the original value.
//
@@ -267,14 +267,14 @@
}
template <class T>
-void test_beta(T, const char* name)
+void test_beta(T, const char* /* name */)
{
//
// The actual test data is rather verbose, so it's in a separate file
//
// The contents are as follows, each row of data contains
// five items, input value a, input value b, integration limits x, beta(a, b, x) and ibeta(a, b, x):
- //
+ //
# include "ibeta_small_data.ipp"
test_inverses(ibeta_small_data);
Modified: sandbox/math_toolkit/libs/math/test/test_spherical_harmonic.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_spherical_harmonic.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_spherical_harmonic.cpp 2007-09-20 07:39:30 EDT (Thu, 20 Sep 2007)
@@ -18,17 +18,17 @@
// DESCRIPTION:
// ~~~~~~~~~~~~
//
-// This file tests the Spherical Harmonic Functions.
+// This file tests the Spherical Harmonic Functions.
// There are two sets of tests, spot
// tests which compare our results with selected values computed
-// using the online special function calculator at
+// using the online special function calculator at
// functions.wolfram.com, while the bulk of the accuracy tests
// use values generated with NTL::RR at 1000-bit precision
// and our generic versions of these functions.
//
// Note that when this file is first run on a new platform many of
// these tests will fail: the default accuracy is 1 epsilon which
-// is too tight for most platforms. In this situation you will
+// is too tight for most platforms. In this situation you will
// need to cast a human eye over the error rates reported and make
// a judgement as to whether they are acceptable. Either way please
// report the results to the Boost mailing list. Acceptable rates of
@@ -91,7 +91,7 @@
// Finish off by printing out the compiler/stdlib/platform names,
// we do this to make it easier to mark up expected error rates.
//
- std::cout << "Tests run with " << BOOST_COMPILER << ", "
+ std::cout << "Tests run with " << BOOST_COMPILER << ", "
<< BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}
@@ -115,8 +115,8 @@
// test Spheric Harmonic against data:
//
result = boost::math::tools::test(
- data,
- boost::lambda::bind(funcp,
+ data,
+ boost::lambda::bind(funcp,
boost::lambda::ret<unsigned>(
boost::lambda::bind(
cf,
@@ -126,7 +126,7 @@
cf,
boost::lambda::ret<value_type>(boost::lambda::_1[1]))),
boost::lambda::ret<value_type>(boost::lambda::_1[2]),
- boost::lambda::ret<value_type>(boost::lambda::_1[3])),
+ boost::lambda::ret<value_type>(boost::lambda::_1[3])),
boost::lambda::ret<value_type>(boost::lambda::_1[4]));
handle_test_result(result, data[result.worst()], result.worst(), type_name, "boost::math::spherical_harmonic_r", test_name);
@@ -135,8 +135,8 @@
// test Spheric Harmonic against data:
//
result = boost::math::tools::test(
- data,
- boost::lambda::bind(funcp,
+ data,
+ boost::lambda::bind(funcp,
boost::lambda::ret<unsigned>(
boost::lambda::bind(
cf,
@@ -146,7 +146,7 @@
cf,
boost::lambda::ret<value_type>(boost::lambda::_1[1]))),
boost::lambda::ret<value_type>(boost::lambda::_1[2]),
- boost::lambda::ret<value_type>(boost::lambda::_1[3])),
+ boost::lambda::ret<value_type>(boost::lambda::_1[3])),
boost::lambda::ret<value_type>(boost::lambda::_1[5]));
handle_test_result(result, data[result.worst()], result.worst(), type_name, "boost::math::spherical_harmonic_i", test_name);
@@ -154,7 +154,7 @@
}
template <class T>
-void test_complex_spherical_harmonic(const T& data, const char* name, boost::mpl::true_ const &)
+void test_complex_spherical_harmonic(const T& data, const char* /* name */, boost::mpl::true_ const &)
{
typedef typename T::value_type row_type;
typedef typename row_type::value_type value_type;
@@ -186,7 +186,7 @@
}
template <class T>
-void test_complex_spherical_harmonic(const T& data, const char* name, boost::mpl::false_ const &)
+void test_complex_spherical_harmonic(const T& /* data */, const char* /* name */, boost::mpl::false_ const &)
{
// T is not a built in type, can't use std::complex with it...
}
@@ -199,7 +199,7 @@
//
// The contents are as follows, each row of data contains
// three items, input value a, input value b and erf(a, b):
- //
+ //
# include "spherical_harmonic.ipp"
do_test_spherical_harmonic(spherical_harmonic, name, "Spherical Harmonics");
@@ -218,7 +218,7 @@
BOOST_CHECK_CLOSE_FRACTION(::boost::math::spherical_harmonic_r(3, 2, static_cast<T>(0.5), static_cast<T>(0)), static_cast<T>(0.2061460599687871330692286791802688341213L), tolerance);
BOOST_CHECK_CLOSE_FRACTION(::boost::math::spherical_harmonic_r(20, 10, static_cast<T>(0.75), static_cast<T>(-0.25)), static_cast<T>(0.06197787102219208244041677775577045124092L), tolerance);
BOOST_CHECK_CLOSE_FRACTION(::boost::math::spherical_harmonic_i(20, 10, static_cast<T>(0.75), static_cast<T>(-0.25)), static_cast<T>(0.04629885158895932341185988759669916977920L), tolerance);
-
+
BOOST_CHECK_CLOSE_FRACTION(::boost::math::spherical_harmonic_r(40, 15, static_cast<T>(-0.75), static_cast<T>(2.25)), static_cast<T>(0.2806904825045745687343492963236868973484L), tolerance);
BOOST_CHECK_CLOSE_FRACTION(::boost::math::spherical_harmonic_i(40, 15, static_cast<T>(-0.75), static_cast<T>(2.25)), static_cast<T>(-0.2933918444656603582282372590387544902135L), tolerance);
BOOST_CHECK_CLOSE_FRACTION(::boost::math::spherical_harmonic_r(40, 15, static_cast<T>(-0.75), static_cast<T>(-2.25)), static_cast<T>(0.2806904825045745687343492963236868973484L), tolerance);
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk