From 67408fbb0d70318ba203c55d5d0e49596cd4ba5d Mon Sep 17 00:00:00 2001 From: Beman Dawes Date: Sat, 1 Mar 2003 18:10:27 +0000 Subject: [PATCH] replace cr with nl [SVN r17689] --- .../boost/math/special_functions/atanh.hpp | 1 + octonion/octonion_test.cpp | 718 ++++++++++++++++++ quaternion/HSO3.hpp | 1 + quaternion/HSO3SO4.cpp | 1 + quaternion/HSO4.hpp | 1 + quaternion/quaternion_mi1.cpp | 2 +- quaternion/quaternion_mi1.h | 2 +- quaternion/quaternion_mi2.cpp | 2 +- quaternion/quaternion_mi2.h | 2 +- quaternion/quaternion_mult_incl_test.cpp | 1 + quaternion/quaternion_test.cpp | 1 + special_functions/acosh_test.hpp | 1 + special_functions/asinh_test.hpp | 1 + special_functions/atanh_test.hpp | 1 + special_functions/sinc_test.hpp | 1 + special_functions/sinhc_test.hpp | 1 + special_functions/special_functions_test.cpp | 1 + 17 files changed, 734 insertions(+), 4 deletions(-) diff --git a/include/boost/math/special_functions/atanh.hpp b/include/boost/math/special_functions/atanh.hpp index 38c4daea7..af3cb42aa 100644 --- a/include/boost/math/special_functions/atanh.hpp +++ b/include/boost/math/special_functions/atanh.hpp @@ -264,3 +264,4 @@ namespace boost } #endif /* BOOST_ATANH_HPP */ + diff --git a/octonion/octonion_test.cpp b/octonion/octonion_test.cpp index d2a859445..fe0e88159 100644 --- a/octonion/octonion_test.cpp +++ b/octonion/octonion_test.cpp @@ -1,718 +1,1436 @@ // test file for octonion.hpp + + // (C) Copyright Hubert Holin 2001. Permission to copy, use, modify, sell and + // distribute this software is granted provided this copyright notice appears + // in all copies. This software is provided "as is" without express or implied + // warranty, and with no claim as to its suitability for any purpose. + + + #include + #include + #include + #include + + + #include + #include + + + #include + #include + + + #include + + + #ifdef BOOST_NO_STDC_NAMESPACE + using ::sqrt; + using ::atan; + using ::log; + using ::exp; + using ::cos; + using ::sin; + using ::tan; + using ::cosh; + using ::sinh; + using ::tanh; + #endif /* BOOST_NO_STDC_NAMESPACE */ + + #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP + using ::boost::math::real; + using ::boost::math::unreal; + using ::boost::math::sup; + using ::boost::math::l1; + using ::boost::math::abs; + using ::boost::math::norm; + using ::boost::math::conj; + using ::boost::math::exp; + using ::boost::math::pow; + using ::boost::math::cos; + using ::boost::math::sin; + using ::boost::math::tan; + using ::boost::math::cosh; + using ::boost::math::sinh; + using ::boost::math::tanh; + using ::boost::math::sinc_pi; + using ::boost::math::sinhc_pi; + #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ + + // Provide standard floating point abs() overloads for MSVC + #ifdef BOOST_MSVC + #if (BOOST_MSVC < 1300) || defined(_MSC_EXTENSIONS) + inline float abs(float v) + { + return(fabs(v)); + } + + inline double abs(double v) + { + return(fabs(v)); + } + + inline long double abs(long double v) + { + return(fabs(v)); + } + #endif /* (BOOST_MSVC < 1300) || defined(_MSC_EXTENSIONS) */ + #endif /* BOOST_MSVC */ + + + // explicit (if ludicrous) instanciation + #ifndef __GNUC__ + template class ::boost::math::octonion; + #else + // gcc doesn't like the absolutely-qualified namespace + template class boost::math::octonion; + #endif + + + namespace + { + template + ::boost::math::octonion index_i_element(int idx) + { + return( + ::boost::math::octonion( + (idx == 0) ? + static_cast(1) : + static_cast(0), + (idx == 1) ? + static_cast(1) : + static_cast(0), + (idx == 2) ? + static_cast(1) : + static_cast(0), + (idx == 3) ? + static_cast(1) : + static_cast(0), + (idx == 4) ? + static_cast(1) : + static_cast(0), + (idx == 5) ? + static_cast(1) : + static_cast(0), + (idx == 6) ? + static_cast(1) : + static_cast(0), + (idx == 7) ? + static_cast(1) : + static_cast(0) + )); + } + } + + + + void octonion_manual_test() + { + // tests for evaluation by humans + + + // using default constructor + ::boost::math::octonion o0; + + ::boost::math::octonion oa[2]; + + // using constructor "O seen as R^8" + ::boost::math::octonion o1(1,2,3,4,5,6,7,8); + + ::std::complex c0(9,10); + + // using constructor "O seen as C^4" + ::boost::math::octonion o2(c0); + + ::boost::math::quaternion q0(11,12,13,14); + + // using constructor "O seen as H^2" + ::boost::math::octonion o3(q0); + + // using UNtemplated copy constructor + ::boost::math::octonion o4(o1); + + // using templated copy constructor + ::boost::math::octonion o5(o2); + + // using UNtemplated assignment operator + o5 = o3; + oa[0] = o0; + + // using templated assignment operator + o5 = o2; + oa[1] = o5; + + float f0(15); + + // using converting assignment operator + o0 = f0; + + // using converting assignment operator + o2 = c0; + + // using converting assignment operator + o5 = q0; + + // using += (const T &) + o4 += f0; + + // using += (const ::std::complex &) + o2 += c0; + + // using += (const ::boost::math::quaternion &) + o3 += q0; + + // using += (const quaternion &) + o5 += o4; + + // using -= (const T &) + o1 -= f0; + + // using -= (const ::std::complex &) + o2 -= c0; + + // using -= (const ::boost::math::quaternion &) + o5 -= q0; + + // using -= (const octonion &) + o3 -= o4; + + double d0(16); + ::std::complex c1(17,18); + ::boost::math::quaternion q1(19,20,21,22); + + // using *= (const T &) + o2 *= d0; + + // using *= (const ::std::complex &) + o2 *= c1; + + // using *= (const ::boost::math::quaternion &) + o2 *= q1; + + // using *= (const octonion &) + o2 *= o4; + + long double l0(23); + ::std::complex c2(24,25); + + // using /= (const T &) + o5 /= l0; + + // using /= (const ::std::complex &) + o5 /= c2; + + // using /= (const quaternion &) + o5 /= q0; + + // using /= (const octonion &) + o5 /= o5; + + // using + (const T &, const octonion &) + ::boost::math::octonion o6 = f0+o0; + + // using + (const octonion &, const T &) + ::boost::math::octonion o7 = o0+f0; + + // using + (const ::std::complex &, const quaternion &) + ::boost::math::octonion o8 = c0+o2; + + // using + (const octonion &, const ::std::complex &) + ::boost::math::octonion o9 = o2+c0; + + // using + (const ::boost::math::quaternion, const octonion &) + ::boost::math::octonion o10 = q0+o3; + + // using + (const octonion &, const ::boost::math::quaternion &) + ::boost::math::octonion o11 = o3+q0; + + // using + (const quaternion &,const quaternion &) + ::boost::math::octonion o12 = o0+o4; + + // using - (const T &, const octonion &) + o6 = f0-o0; + + // using - (const octonion &, const T &) + o7 = o0-f0; + + // using - (const ::std::complex &, const octonion &) + o8 = c0-o2; + + // using - (const octonion &, const ::std::complex &) + o9 = o2-c0; + + // using - (const quaternion &,const octonion &) + o10 = q0-o3; + + // using - (const octonion &,const quaternion &) + o11 = o3-q0; + + // using - (const octonion &,const octonion &) + o12 = o0-o4; + + // using * (const T &, const octonion &) + o6 = f0*o0; + + // using * (const octonion &, const T &) + o7 = o0*f0; + + // using * (const ::std::complex &, const octonion &) + o8 = c0*o2; + + // using * (const octonion &, const ::std::complex &) + o9 = o2*c0; + + // using * (const quaternion &,const octonion &) + o10 = q0*o3; + + // using * (const octonion &,const quaternion &) + o11 = o3*q0; + + // using * (const octonion &,const octonion &) + o12 = o0*o4; + + // using / (const T &, const octonion &) + o6 = f0/o0; + + // using / (const octonion &, const T &) + o7 = o0/f0; + + // using / (const ::std::complex &, const octonion &) + o8 = c0/o2; + + // using / (const octonion &, const ::std::complex &) + o9 = o2/c0; + + // using / (const ::boost::math::quaternion &, const octonion &) + o10 = q0/o3; + + // using / (const octonion &, const ::boost::math::quaternion &) + o11 = o3/q0; + + // using / (const octonion &,const octonion &) + o12 = o0/o4; + + // using + (const octonion &) + o4 = +o0; + + // using - (const octonion &) + o0 = -o4; + + // using == (const T &, const octonion &) + f0 == o0; + + // using == (const octonion &, const T &) + o0 == f0; + + // using == (const ::std::complex &, const octonion &) + c0 == o2; + + // using == (const octonion &, const ::std::complex &) + o2 == c0; + + // using == (const ::boost::math::quaternion &, const octonion &) + q0 == o3; + + // using == (const octonion &, const ::boost::math::quaternion &) + o3 == q0; + + // using == (const octonion &,const octonion &) + o0 == o4; + + // using != (const T &, const octonion &) + f0 != o0; + + // using != (const octonion &, const T &) + o0 != f0; + + // using != (const ::std::complex &, const octonion &) + c0 != o2; + + // using != (const octonion &, const ::std::complex &) + o2 != c0; + + // using != (const ::boost::math::quaternion &, const octonion &) + q0 != o3; + + // using != (const octonion &, const ::boost::math::quaternion &) + o3 != q0; + + // using != (const octonion &,const octonion &) + o0 != o4; + + BOOST_MESSAGE("Please input an octonion..."); + + #ifdef BOOST_INTERACTIVE_TEST_INPUT_ITERATOR + ::std::cin >> o0; + + if (::std::cin.fail()) + { + BOOST_MESSAGE("You have entered nonsense!"); + } + else + { + BOOST_MESSAGE("You have entered the octonion " << o0 << " ."); + } + #else + ::std::istringstream bogus("(1,2,3,4,5,6,7,8)"); + + bogus >> o0; + + BOOST_MESSAGE("You have entered the octonion " << o0 << " ."); + #endif + + BOOST_MESSAGE("For this octonion:"); + + BOOST_MESSAGE( "the value of the real part is " + << real(o0)); + + BOOST_MESSAGE( "the value of the unreal part is " + << unreal(o0)); + + BOOST_MESSAGE( "the value of the sup norm is " + << sup(o0)); + + BOOST_MESSAGE( "the value of the l1 norm is " + << l1(o0)); + + BOOST_MESSAGE( "the value of the magnitude (euclidian norm) is " + << abs(o0)); + + BOOST_MESSAGE( "the value of the (Cayley) norm is " + << norm(o0)); + + BOOST_MESSAGE( "the value of the conjugate is " + << conj(o0)); + + BOOST_MESSAGE( "the value of the exponential is " + << exp(o0)); + + BOOST_MESSAGE( "the value of the cube is " + << pow(o0,3)); + + BOOST_MESSAGE( "the value of the cosinus is " + << cos(o0)); + + BOOST_MESSAGE( "the value of the sinus is " + << sin(o0)); + + BOOST_MESSAGE( "the value of the tangent is " + << tan(o0)); + + BOOST_MESSAGE( "the value of the hyperbolic cosinus is " + << cosh(o0)); + + BOOST_MESSAGE( "the value of the hyperbolic sinus is " + << sinh(o0)); + + BOOST_MESSAGE( "the value of the hyperbolic tangent is " + << tanh(o0)); + + #ifdef BOOST_NO_TEMPLATE_TEMPLATES + BOOST_MESSAGE( "no template templates, can't compute cardinal functions"); + #else /* BOOST_NO_TEMPLATE_TEMPLATES */ + BOOST_MESSAGE( "the value of the Sinus Cardinal (of index pi) is " + << sinc_pi(o0)); + + BOOST_MESSAGE( "the value of " + << "the Hyperbolic Sinus Cardinal (of index pi) is " + << sinhc_pi(o0)); + #endif /* BOOST_NO_TEMPLATE_TEMPLATES */ + + BOOST_MESSAGE(" "); + + float rho = ::std::sqrt(4096.0f); + float theta = ::std::atan(1.0f); + float phi1 = ::std::atan(1.0f); + float phi2 = ::std::atan(1.0f); + float phi3 = ::std::atan(1.0f); + float phi4 = ::std::atan(1.0f); + float phi5 = ::std::atan(1.0f); + float phi6 = ::std::atan(1.0f); + + BOOST_MESSAGE( "The value of the octonion represented " + << "in spherical form by " + << "rho = " << rho << " , theta = " << theta + << " , phi1 = " << phi1 << " , phi2 = " << phi2 + << " , phi3 = " << phi3 << " , phi4 = " << phi4 + << " , phi5 = " << phi5 << " , phi6 = " << phi6 + << " is " + << ::boost::math::spherical(rho, theta, + phi1, phi2, phi3, phi4, phi5, phi6)); + + float rho1 = 1; + float rho2 = 2; + float rho3 = ::std::sqrt(2.0f); + float rho4 = ::std::sqrt(8.0f); + float theta1 = 0; + float theta2 = ::std::atan(1.0f)*2; + float theta3 = ::std::atan(1.0f); + float theta4 = ::std::atan(::std::sqrt(3.0f)); + + BOOST_MESSAGE( "The value of the octonion represented " + << "in multipolar form by " + << "rho1 = " << rho1 << " , theta1 = " << theta1 + << " , rho2 = " << rho2 << " , theta2 = " << theta2 + << "rho3 = " << rho3 << " , theta3 = " << theta3 + << " , rho4 = " << rho4 << " , theta4 = " << theta4 + << " is " + << ::boost::math::multipolar(rho1, theta1, rho2, theta2, + rho3, theta3, rho4, theta4)); + + float r = ::std::sqrt(2.0f); + float angle = ::std::atan(1.0f); + float h1 = 3; + float h2 = 4; + float h3 = 5; + float h4 = 6; + float h5 = 7; + float h6 = 8; + + BOOST_MESSAGE( "The value of the octonion represented " + << "in cylindrical form by " + << "r = " << r << " , angle = " << angle + << " , h1 = " << h1 << " , h2 = " << h2 + << " , h3 = " << h3 << " , h4 = " << h4 + << " , h5 = " << h5 << " , h6 = " << h6 + << " is " << ::boost::math::cylindrical(r, angle, + h1, h2, h3, h4, h5, h6)); + + double real_1(1); + ::std::complex complex_1(1); + ::std::complex complex_i(0,1); + ::boost::math::quaternion quaternion_1(1); + ::boost::math::quaternion quaternion_i(0,1); + ::boost::math::quaternion quaternion_j(0,0,1); + ::boost::math::quaternion quaternion_k(0,0,0,1); + ::boost::math::octonion octonion_1(1); + ::boost::math::octonion octonion_i(0,1); + ::boost::math::octonion octonion_j(0,0,1); + ::boost::math::octonion octonion_k(0,0,0,1); + ::boost::math::octonion octonion_e_prime(0,0,0,0,1); + ::boost::math::octonion octonion_i_prime(0,0,0,0,0,1); + ::boost::math::octonion octonion_j_prime(0,0,0,0,0,0,1); + ::boost::math::octonion octonion_k_prime(0,0,0,0,0,0,0,1); + + + BOOST_MESSAGE(" "); + + BOOST_MESSAGE( "Real 1: " << real_1 + << " ; Complex 1: " << complex_1 + << " ; Quaternion 1: " << quaternion_1 + << " ; Octonion 1: " << octonion_1 << " ."); + + BOOST_MESSAGE( "Complex i: " << complex_i + << " ; Quaternion i: " << quaternion_i + << " ; Octonion i : " << octonion_i << " ."); + + BOOST_MESSAGE( "Quaternion j: " << quaternion_j + << " ; Octonion j: " << octonion_j << " ."); + + BOOST_MESSAGE( "Quaternion k: " << quaternion_k + << " ; Octonion k: " << octonion_k << " ."); + + BOOST_MESSAGE( "Quaternion e\': " << octonion_e_prime << " ."); + + BOOST_MESSAGE( "Quaternion i\': " << octonion_i_prime << " ."); + + BOOST_MESSAGE( "Quaternion j\': " << octonion_j_prime << " ."); + + BOOST_MESSAGE( "Quaternion k\': " << octonion_k_prime << " ."); + + BOOST_MESSAGE(" "); + + BOOST_MESSAGE( octonion_1*octonion_1 << " ; " + << octonion_1*octonion_i << " ; " + << octonion_1*octonion_j << " ; " + << octonion_1*octonion_k << " ; " + << octonion_1*octonion_e_prime << " ; " + << octonion_1*octonion_i_prime << " ; " + << octonion_1*octonion_j_prime << " ; " + << octonion_1*octonion_k_prime << " ; "); + + BOOST_MESSAGE( octonion_i*octonion_1 << " ; " + << octonion_i*octonion_i << " ; " + << octonion_i*octonion_j << " ; " + << octonion_i*octonion_k << " ; " + << octonion_i*octonion_e_prime << " ; " + << octonion_i*octonion_i_prime << " ; " + << octonion_i*octonion_j_prime << " ; " + << octonion_i*octonion_k_prime << " ; "); + + BOOST_MESSAGE( octonion_j*octonion_1 << " ; " + << octonion_j*octonion_i << " ; " + << octonion_j*octonion_j << " ; " + << octonion_j*octonion_k << " ; " + << octonion_j*octonion_e_prime << " ; " + << octonion_j*octonion_i_prime << " ; " + << octonion_j*octonion_j_prime << " ; " + << octonion_j*octonion_k_prime << " ; "); + + BOOST_MESSAGE( octonion_k*octonion_1 << " ; " + << octonion_k*octonion_i << " ; " + << octonion_k*octonion_j << " ; " + << octonion_k*octonion_k << " ; " + << octonion_k*octonion_e_prime << " ; " + << octonion_k*octonion_i_prime << " ; " + << octonion_k*octonion_j_prime << " ; " + << octonion_k*octonion_k_prime << " ; "); + + BOOST_MESSAGE( octonion_e_prime*octonion_1 << " ; " + << octonion_e_prime*octonion_i << " ; " + << octonion_e_prime*octonion_j << " ; " + << octonion_e_prime*octonion_k << " ; " + << octonion_e_prime*octonion_e_prime << " ; " + << octonion_e_prime*octonion_i_prime << " ; " + << octonion_e_prime*octonion_j_prime << " ; " + << octonion_e_prime*octonion_k_prime << " ; "); + + BOOST_MESSAGE( octonion_i_prime*octonion_1 << " ; " + << octonion_i_prime*octonion_i << " ; " + << octonion_i_prime*octonion_j << " ; " + << octonion_i_prime*octonion_k << " ; " + << octonion_i_prime*octonion_e_prime << " ; " + << octonion_i_prime*octonion_i_prime << " ; " + << octonion_i_prime*octonion_j_prime << " ; " + << octonion_i_prime*octonion_k_prime << " ; "); + + BOOST_MESSAGE( octonion_j_prime*octonion_1 << " ; " + << octonion_j_prime*octonion_i << " ; " + << octonion_j_prime*octonion_j << " ; " + << octonion_j_prime*octonion_k << " ; " + << octonion_j_prime*octonion_e_prime << " ; " + << octonion_j_prime*octonion_i_prime << " ; " + << octonion_j_prime*octonion_j_prime << " ; " + << octonion_j_prime*octonion_k_prime << " ; "); + + BOOST_MESSAGE( octonion_k_prime*octonion_1 << " ; " + << octonion_k_prime*octonion_i << " ; " + << octonion_k_prime*octonion_j << " ; " + << octonion_k_prime*octonion_k << " ; " + << octonion_k_prime*octonion_e_prime << " ; " + << octonion_k_prime*octonion_i_prime << " ; " + << octonion_k_prime*octonion_j_prime << " ; " + << octonion_k_prime*octonion_k_prime << " ; "); + + BOOST_MESSAGE(" "); + + BOOST_MESSAGE("i\'*(e\'*j) : " + << octonion_i_prime*(octonion_e_prime*octonion_j) << " ;"); + + BOOST_MESSAGE("(i\'*e\')*j : " + << (octonion_i_prime*octonion_e_prime)*octonion_j << " ;"); + + BOOST_MESSAGE(" "); + } + + + template + void multiplication_test(const char * more_blurb) + { + using ::std::numeric_limits; + + using ::boost::math::abs; + + + BOOST_MESSAGE("Testing multiplication for " << more_blurb << "."); + + BOOST_REQUIRE_PREDICATE(::std::less_equal(), 2, + ( + abs(::boost::math::octonion(1,0,0,0,0,0,0,0)* + ::boost::math::octonion(1,0,0,0,0,0,0,0)- + static_cast(1)), + numeric_limits::epsilon() + )); + + for (int idx = 1; idx < 8; ++idx) + { + ::boost::math::octonion toto = index_i_element(idx); + + BOOST_REQUIRE_PREDICATE(::std::less_equal(), 2, + ( + abs(toto*toto+static_cast(1)), + numeric_limits::epsilon() + )); + } + } + + + template + void exp_test(const char * more_blurb) + { + using ::std::numeric_limits; + + using ::std::atan; + + using ::boost::math::abs; + + + BOOST_MESSAGE("Testing exp for " << more_blurb << "."); + + for (int idx = 1; idx < 8; ++idx) + { + ::boost::math::octonion toto = + static_cast(4)*atan(static_cast(1))*index_i_element(idx); + + BOOST_CHECK_PREDICATE(::std::less_equal(), 2, + ( + abs(exp(toto)+static_cast(1)), + 2*numeric_limits::epsilon() + )); + } + } + + + boost::unit_test_framework::test_suite * init_unit_test_suite(int, char *[]) + { + //::boost::unit_test_framework::unit_test_log::instance(). + // set_log_threshold_level_by_name("messages"); + + boost::unit_test_framework::test_suite * test = + BOOST_TEST_SUITE("octonion_test"); + + #define BOOST_OCTONION_COMMON_GENERATOR(fct,type) \ + test->add(BOOST_TEST_CASE(::boost::bind(static_cast \ + < void (*) (const char *) >(&fct##_test), #type))); + + + #define BOOST_OCTONION_TEST(type) \ + BOOST_OCTONION_COMMON_GENERATOR(multiplication,type) \ + BOOST_OCTONION_COMMON_GENERATOR(exp,type) + + + BOOST_OCTONION_TEST(float) + BOOST_OCTONION_TEST(double) + BOOST_OCTONION_TEST(long double) + + + #undef BOOST_OCTONION_TEST + + #undef BOOST_OCTONION_COMMON_GENERATOR + + + #ifdef BOOST_OCTONION_TEST_VERBOSE + + octonion_manual_test(); + + #endif /* BOOST_OCTONION_TEST_VERBOSE */ + + return(test); + } + diff --git a/quaternion/HSO3.hpp b/quaternion/HSO3.hpp index 4a5ea6c96..a65a6a481 100644 --- a/quaternion/HSO3.hpp +++ b/quaternion/HSO3.hpp @@ -508,3 +508,4 @@ template } #endif /* TEST_HSO3_HPP */ + diff --git a/quaternion/HSO3SO4.cpp b/quaternion/HSO3SO4.cpp index f68e3907c..105346a5c 100644 --- a/quaternion/HSO3SO4.cpp +++ b/quaternion/HSO3SO4.cpp @@ -442,3 +442,4 @@ void test_SO4() test_SO4_spherical(); } + diff --git a/quaternion/HSO4.hpp b/quaternion/HSO4.hpp index 3a5f04950..0f0333446 100644 --- a/quaternion/HSO4.hpp +++ b/quaternion/HSO4.hpp @@ -180,3 +180,4 @@ template } #endif /* TEST_HSO4_HPP */ + diff --git a/quaternion/quaternion_mi1.cpp b/quaternion/quaternion_mi1.cpp index 7650dbb5f..7a551ef89 100644 --- a/quaternion/quaternion_mi1.cpp +++ b/quaternion/quaternion_mi1.cpp @@ -15,4 +15,4 @@ void quaternion_mi1() ::boost::math::quaternion q0; q0 *= q0; -} \ No newline at end of file +} diff --git a/quaternion/quaternion_mi1.h b/quaternion/quaternion_mi1.h index d13134975..14a407084 100644 --- a/quaternion/quaternion_mi1.h +++ b/quaternion/quaternion_mi1.h @@ -10,4 +10,4 @@ void quaternion_mi1(); -#endif /* BOOST_QUATERNION_MULTIPLE_INCLUDE_TEST_1 */ \ No newline at end of file +#endif /* BOOST_QUATERNION_MULTIPLE_INCLUDE_TEST_1 */ diff --git a/quaternion/quaternion_mi2.cpp b/quaternion/quaternion_mi2.cpp index 916e639d6..c1832c591 100644 --- a/quaternion/quaternion_mi2.cpp +++ b/quaternion/quaternion_mi2.cpp @@ -15,4 +15,4 @@ void quaternion_mi2() ::boost::math::quaternion q0; q0 *= q0; -} \ No newline at end of file +} diff --git a/quaternion/quaternion_mi2.h b/quaternion/quaternion_mi2.h index 4da9f2474..5d8dbe4a6 100644 --- a/quaternion/quaternion_mi2.h +++ b/quaternion/quaternion_mi2.h @@ -10,4 +10,4 @@ void quaternion_mi2(); -#endif /* BOOST_QUATERNION_MULTIPLE_INCLUDE_TEST_2 */ \ No newline at end of file +#endif /* BOOST_QUATERNION_MULTIPLE_INCLUDE_TEST_2 */ diff --git a/quaternion/quaternion_mult_incl_test.cpp b/quaternion/quaternion_mult_incl_test.cpp index e15666fad..83ace5eb3 100644 --- a/quaternion/quaternion_mult_incl_test.cpp +++ b/quaternion/quaternion_mult_incl_test.cpp @@ -26,3 +26,4 @@ boost::unit_test_framework::test_suite * init_unit_test_suite(int, char *[]) return(test); } + diff --git a/quaternion/quaternion_test.cpp b/quaternion/quaternion_test.cpp index c53b819b3..ddf4d8c45 100644 --- a/quaternion/quaternion_test.cpp +++ b/quaternion/quaternion_test.cpp @@ -756,3 +756,4 @@ boost::unit_test_framework::test_suite * init_unit_test_suite(int, char *[]) return(test); } + diff --git a/special_functions/acosh_test.hpp b/special_functions/acosh_test.hpp index 0d5c6fbdb..5f454d0b1 100644 --- a/special_functions/acosh_test.hpp +++ b/special_functions/acosh_test.hpp @@ -82,3 +82,4 @@ void acosh_manual_check() BOOST_MESSAGE(" "); } + diff --git a/special_functions/asinh_test.hpp b/special_functions/asinh_test.hpp index a7523f490..8250ac8c6 100644 --- a/special_functions/asinh_test.hpp +++ b/special_functions/asinh_test.hpp @@ -82,3 +82,4 @@ void asinh_manual_check() BOOST_MESSAGE(" "); } + diff --git a/special_functions/atanh_test.hpp b/special_functions/atanh_test.hpp index 9c0308732..d8b57e6bc 100644 --- a/special_functions/atanh_test.hpp +++ b/special_functions/atanh_test.hpp @@ -162,3 +162,4 @@ void atanh_manual_check() BOOST_MESSAGE(" "); } + diff --git a/special_functions/sinc_test.hpp b/special_functions/sinc_test.hpp index a1a169e0f..ae70944db 100644 --- a/special_functions/sinc_test.hpp +++ b/special_functions/sinc_test.hpp @@ -85,3 +85,4 @@ void sinc_pi_manual_check() BOOST_MESSAGE(" "); } + diff --git a/special_functions/sinhc_test.hpp b/special_functions/sinhc_test.hpp index 607bceb46..ce981165b 100644 --- a/special_functions/sinhc_test.hpp +++ b/special_functions/sinhc_test.hpp @@ -85,3 +85,4 @@ void sinhc_pi_manual_check() BOOST_MESSAGE(" "); } + diff --git a/special_functions/special_functions_test.cpp b/special_functions/special_functions_test.cpp index 710bfa664..e6eb59f45 100644 --- a/special_functions/special_functions_test.cpp +++ b/special_functions/special_functions_test.cpp @@ -103,3 +103,4 @@ boost::unit_test_framework::test_suite * init_unit_test_suite(int, char *[]) return(test); } +