quaternion_test.cpp

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

                << sinhc_pi(q0));
#endif    /* BOOST_NO_TEMPLATE_TEMPLATES */
    
    BOOST_MESSAGE(" ");
    
    float                         rho = ::std::sqrt(8.0f);
    float                         theta = ::std::atan(1.0f);
    float                         phi1 = ::std::atan(1.0f);
    float                         phi2 = ::std::atan(1.0f);
    
    BOOST_MESSAGE( "The value of the quaternion represented "
                << "in spherical form by "
                << "rho = " << rho << " , theta = " << theta
                << " , phi1 = " << phi1 << " , phi2 = " << phi2
                << " is "
                << ::boost::math::spherical(rho, theta, phi1, phi2));
    
    float                         alpha = ::std::atan(1.0f);
    
    BOOST_MESSAGE( "The value of the quaternion represented "
                << "in semipolar form by "
                << "rho = " << rho << " , alpha = " << alpha
                << " , phi1 = " << phi1 << " , phi2 = " << phi2
                << " is "
                << ::boost::math::semipolar(rho, alpha, phi1, phi2));
    
    float                         rho1 = 1;
    float                         rho2 = 2;
    float                         theta1 = 0;
    float                         theta2 = ::std::atan(1.0f)*2;
    
    BOOST_MESSAGE( "The value of the quaternion represented "
                << "in multipolar form by "
                << "rho1 = " << rho1 << " , theta1 = " << theta1
                << " , rho2 = " << rho2 << " , theta2 = " << theta2
                << " is "
                << ::boost::math::multipolar(rho1, theta1, rho2, theta2));
    
    float                         t = 5;
    float                         radius = ::std::sqrt(2.0f);
    float                         longitude = ::std::atan(1.0f);
    float                         lattitude = ::std::atan(::std::sqrt(3.0f));
    
    BOOST_MESSAGE( "The value of the quaternion represented "
                << "in cylindrospherical form by "
                << "t = " << t << " , radius = " << radius
                << " , longitude = " << longitude << " , latitude = "
                << lattitude << " is "
                << ::boost::math::cylindrospherical(t, radius,
                        longitude, lattitude));
    
    float                         r = ::std::sqrt(2.0f);
    float                         angle = ::std::atan(1.0f);
    float                         h1 = 3;
    float                         h2 = 4;
    
    BOOST_MESSAGE( "The value of the quaternion represented "
                << "in cylindrical form by "
                << "r = " << r << " , angle = " << angle
                << " , h1 = " << h1 << " , h2 = " << h2
                << " is "
                << ::boost::math::cylindrical(r, angle, h1, h2));
    
    double                                   real_1(1);
    ::std::complex<double>                   complex_1(1);
    ::std::complex<double>                   complex_i(0,1);
    ::boost::math::quaternion<double>        quaternion_1(1);
    ::boost::math::quaternion<double>        quaternion_i(0,1);
    ::boost::math::quaternion<double>        quaternion_j(0,0,1);
    ::boost::math::quaternion<double>        quaternion_k(0,0,0,1);
    
    BOOST_MESSAGE(" ");
    
    BOOST_MESSAGE( "Real 1: " << real_1 << " ; "
                << "Complex 1: " << complex_1 << " ; "
                << "Quaternion 1: " << quaternion_1 << " .");
    
    BOOST_MESSAGE( "Complex i: " << complex_i << " ; "
                << "Quaternion i: " << quaternion_i << " .");
    
    BOOST_MESSAGE( "Quaternion j: " << quaternion_j << " .");
    
    BOOST_MESSAGE( "Quaternion k: " << quaternion_k << " .");
    
    
    BOOST_MESSAGE(" ");
    
    
    BOOST_MESSAGE( "i*i: " << quaternion_i*quaternion_i << " ; "
                << "j*j: " << quaternion_j*quaternion_j << " ; "
                << "k*k: " << quaternion_k*quaternion_k << " .");
    BOOST_MESSAGE( "i*j: " << quaternion_i*quaternion_j << " ; "
                << "j*i: " << quaternion_j*quaternion_i << " .");
    BOOST_MESSAGE( "j*k: " << quaternion_j*quaternion_k << " ; "
                << "k*j: " << quaternion_k*quaternion_j << " .");
    BOOST_MESSAGE( "k*i: " << quaternion_k*quaternion_i << " ; "
                << "i*k: " << quaternion_i*quaternion_k << " .");
    
    BOOST_MESSAGE(" ");
}


BOOST_TEST_CASE_TEMPLATE_FUNCTION(multiplication_test, T)
{
#if     BOOST_WORKAROUND(__GNUC__, < 3)
#else   /* BOOST_WORKAROUND(__GNUC__, < 3) */
    using ::std::numeric_limits;
    
    using ::boost::math::abs;
#endif  /* BOOST_WORKAROUND(__GNUC__, < 3) */
    
    
    BOOST_MESSAGE("Testing multiplication for "
        << string_type_name<T>::_() << ".");
    
    BOOST_REQUIRE_PREDICATE(::std::less_equal<T>(),
        (abs(::boost::math::quaternion<T>(1,0,0,0)*
             ::boost::math::quaternion<T>(1,0,0,0)-static_cast<T>(1)))
        (numeric_limits<T>::epsilon()));
    
    BOOST_REQUIRE_PREDICATE(::std::less_equal<T>(),
        (abs(::boost::math::quaternion<T>(0,1,0,0)*
             ::boost::math::quaternion<T>(0,1,0,0)+static_cast<T>(1)))
        (numeric_limits<T>::epsilon()));
    
    BOOST_REQUIRE_PREDICATE(::std::less_equal<T>(),
        (abs(::boost::math::quaternion<T>(0,0,1,0)*
             ::boost::math::quaternion<T>(0,0,1,0)+static_cast<T>(1)))
        (numeric_limits<T>::epsilon()));
    
    BOOST_REQUIRE_PREDICATE(::std::less_equal<T>(),
        (abs(::boost::math::quaternion<T>(0,0,0,1)*
             ::boost::math::quaternion<T>(0,0,0,1)+static_cast<T>(1)))
        (numeric_limits<T>::epsilon()));
    
    BOOST_REQUIRE_PREDICATE(::std::less_equal<T>(),
        (abs(::boost::math::quaternion<T>(0,1,0,0)*
             ::boost::math::quaternion<T>(0,0,1,0)-
             ::boost::math::quaternion<T>(0,0,0,1)))
        (numeric_limits<T>::epsilon()));
    
    BOOST_REQUIRE_PREDICATE(::std::less_equal<T>(),
        (abs(::boost::math::quaternion<T>(0,0,1,0)*
             ::boost::math::quaternion<T>(0,1,0,0)+
             ::boost::math::quaternion<T>(0,0,0,1)))
        (numeric_limits<T>::epsilon()));
    
    BOOST_REQUIRE_PREDICATE(::std::less_equal<T>(),
        (abs(::boost::math::quaternion<T>(0,0,1,0)*
             ::boost::math::quaternion<T>(0,0,0,1)-
             ::boost::math::quaternion<T>(0,1,0,0)))
        (numeric_limits<T>::epsilon()));
    
    BOOST_REQUIRE_PREDICATE(::std::less_equal<T>(),
        (abs(::boost::math::quaternion<T>(0,0,0,1)*
             ::boost::math::quaternion<T>(0,0,1,0)+
             ::boost::math::quaternion<T>(0,1,0,0)))
        (numeric_limits<T>::epsilon()));
    
    BOOST_REQUIRE_PREDICATE(::std::less_equal<T>(),
        (abs(::boost::math::quaternion<T>(0,0,0,1)*
             ::boost::math::quaternion<T>(0,1,0,0)-
             ::boost::math::quaternion<T>(0,0,1,0)))
        (numeric_limits<T>::epsilon()));
    
    BOOST_REQUIRE_PREDICATE(::std::less_equal<T>(),
        (abs(::boost::math::quaternion<T>(0,1,0,0)*
             ::boost::math::quaternion<T>(0,0,0,1)+
             ::boost::math::quaternion<T>(0,0,1,0)))
        (numeric_limits<T>::epsilon()));
}


BOOST_TEST_CASE_TEMPLATE_FUNCTION(exp_test, T)
{
#if     BOOST_WORKAROUND(__GNUC__, < 3)
#else   /* BOOST_WORKAROUND(__GNUC__, < 3) */
    using ::std::numeric_limits;
    
    using ::std::atan;
    
    using ::boost::math::abs;
#endif  /* BOOST_WORKAROUND(__GNUC__, < 3) */
    
    
    BOOST_MESSAGE("Testing exp for "
        << string_type_name<T>::_() << ".");
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(exp(::boost::math::quaternion<T>
             (0,4*atan(static_cast<T>(1)),0,0))+static_cast<T>(1)))
        (2*numeric_limits<T>::epsilon()));
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(exp(::boost::math::quaternion<T>
             (0,0,4*atan(static_cast<T>(1)),0))+static_cast<T>(1)))
        (2*numeric_limits<T>::epsilon()));
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(exp(::boost::math::quaternion<T>
             (0,0,0,4*atan(static_cast<T>(1))))+static_cast<T>(1)))
        (2*numeric_limits<T>::epsilon()));
}


BOOST_TEST_CASE_TEMPLATE_FUNCTION(cos_test, T)
{
#if     BOOST_WORKAROUND(__GNUC__, < 3)
#else   /* BOOST_WORKAROUND(__GNUC__, < 3) */
    using ::std::numeric_limits;
    
    using ::std::log;
    
    using ::boost::math::abs;
#endif  /* BOOST_WORKAROUND(__GNUC__, < 3) */
    
    
    BOOST_MESSAGE("Testing cos for "
        << string_type_name<T>::_() << ".");
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(static_cast<T>(4)*cos(::boost::math::quaternion<T>
             (0,log(static_cast<T>(2)),0,0))-static_cast<T>(5)))
        (4*numeric_limits<T>::epsilon()));
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(static_cast<T>(4)*cos(::boost::math::quaternion<T>
             (0,0,log(static_cast<T>(2)),0))-static_cast<T>(5)))
        (4*numeric_limits<T>::epsilon()));
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(static_cast<T>(4)*cos(::boost::math::quaternion<T>
             (0,0,0,log(static_cast<T>(2))))-static_cast<T>(5)))
        (4*numeric_limits<T>::epsilon()));
}


BOOST_TEST_CASE_TEMPLATE_FUNCTION(sin_test, T)
{
#if     BOOST_WORKAROUND(__GNUC__, < 3)
#else   /* BOOST_WORKAROUND(__GNUC__, < 3) */
    using ::std::numeric_limits;
    
    using ::std::log;
    
    using ::boost::math::abs;
#endif  /* BOOST_WORKAROUND(__GNUC__, < 3) */
    
    
    BOOST_MESSAGE("Testing sin for "
        << string_type_name<T>::_() << ".");
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(static_cast<T>(4)*sin(::boost::math::quaternion<T>
             (0,log(static_cast<T>(2)),0,0))
             -::boost::math::quaternion<T>(0,3,0,0)))
        (4*numeric_limits<T>::epsilon()));
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(static_cast<T>(4)*sin(::boost::math::quaternion<T>
             (0,0,log(static_cast<T>(2)),0))
             -::boost::math::quaternion<T>(0,0,3,0)))
        (4*numeric_limits<T>::epsilon()));
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(static_cast<T>(4)*sin(::boost::math::quaternion<T>
             (0,0,0,log(static_cast<T>(2))))
             -::boost::math::quaternion<T>(0,0,0,3)))
        (4*numeric_limits<T>::epsilon()));
}


BOOST_TEST_CASE_TEMPLATE_FUNCTION(cosh_test, T)
{
#if     BOOST_WORKAROUND(__GNUC__, < 3)
#else   /* BOOST_WORKAROUND(__GNUC__, < 3) */
    using ::std::numeric_limits;
    
    using ::std::atan;
    
    using ::boost::math::abs;
#endif  /* BOOST_WORKAROUND(__GNUC__, < 3) */
    
    
    BOOST_MESSAGE("Testing cosh for "
        << string_type_name<T>::_() << ".");
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(cosh(::boost::math::quaternion<T>
             (0,4*atan(static_cast<T>(1)),0,0))
             +static_cast<T>(1)))
        (4*numeric_limits<T>::epsilon()));
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(cosh(::boost::math::quaternion<T>
             (0,0,4*atan(static_cast<T>(1)),0))
             +static_cast<T>(1)))
        (4*numeric_limits<T>::epsilon()));
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(cosh(::boost::math::quaternion<T>
             (0,0,0,4*atan(static_cast<T>(1))))
             +static_cast<T>(1)))
        (4*numeric_limits<T>::epsilon()));
}


BOOST_TEST_CASE_TEMPLATE_FUNCTION(sinh_test, T)
{
#if     BOOST_WORKAROUND(__GNUC__, < 3)
#else   /* BOOST_WORKAROUND(__GNUC__, < 3) */
    using ::std::numeric_limits;
    
    using ::std::atan;
    
    using ::boost::math::abs;
#endif  /* BOOST_WORKAROUND(__GNUC__, < 3) */
    
    
    BOOST_MESSAGE("Testing sinh for "
        << string_type_name<T>::_() << ".");
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(sinh(::boost::math::quaternion<T>
             (0,2*atan(static_cast<T>(1)),0,0))
             -::boost::math::quaternion<T>(0,1,0,0)))
        (4*numeric_limits<T>::epsilon()));
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(sinh(::boost::math::quaternion<T>
             (0,0,2*atan(static_cast<T>(1)),0))
             -::boost::math::quaternion<T>(0,0,1,0)))
        (4*numeric_limits<T>::epsilon()));
    
    BOOST_CHECK_PREDICATE(::std::less_equal<T>(),
        (abs(sinh(::boost::math::quaternion<T>
             (0,0,0,2*atan(static_cast<T>(1))))
             -::boost::math::quaternion<T>(0,0,0,1)))
        (4*numeric_limits<T>::epsilon()));
}


boost::unit_test_framework::test_suite *    init_unit_test_suite(int, char *[])
{
    ::boost::unit_test::unit_test_log.
        set_threshold_level(::boost::unit_test::log_messages);
    
    boost::unit_test_framework::test_suite *    test =
        BOOST_TEST_SUITE("quaternion_test");
    
    BOOST_MESSAGE("Results of quaternion test.");
    BOOST_MESSAGE(" ");
    BOOST_MESSAGE("(C) Copyright Hubert Holin 2003-2005.");
    BOOST_MESSAGE("Distributed under the Boost Software License, Version 1.0.");
    BOOST_MESSAGE("(See accompanying file LICENSE_1_0.txt or copy at");
    BOOST_MESSAGE("http://www.boost.org/LICENSE_1_0.txt)");
    BOOST_MESSAGE(" ");
    
#define    BOOST_QUATERNION_COMMON_GENERATOR(fct)   \
    test->add(BOOST_TEST_CASE_TEMPLATE(fct##_test, test_types));

#define    BOOST_QUATERNION_COMMON_GENERATOR_NEAR_EPS(fct)   \
    test->add(BOOST_TEST_CASE_TEMPLATE(fct##_test, near_eps_test_types));
    
    
#define    BOOST_QUATERNION_TEST                      \
    BOOST_QUATERNION_COMMON_GENERATOR(multiplication) \
    BOOST_QUATERNION_COMMON_GENERATOR_NEAR_EPS(exp)            \
    BOOST_QUATERNION_COMMON_GENERATOR_NEAR_EPS(cos)            \
    BOOST_QUATERNION_COMMON_GENERATOR_NEAR_EPS(sin)            \
    BOOST_QUATERNION_COMMON_GENERATOR_NEAR_EPS(cosh)           \
    BOOST_QUATERNION_COMMON_GENERATOR_NEAR_EPS(sinh)
    
    
    BOOST_QUATERNION_TEST
    
    
#undef    BOOST_QUATERNION_TEST
    
#undef    BOOST_QUATERNION_COMMON_GENERATOR
#undef BOOST_QUATERNION_COMMON_GENERATOR_NEAR_EPS
    
#ifdef BOOST_QUATERNION_TEST_VERBOSE
    
    test->add(BOOST_TEST_CASE(quaternion_manual_test));
    
#endif    /* BOOST_QUATERNION_TEST_VERBOSE */
    
    return test;
}

#undef DEFINE_TYPE_NAME