Symaptic: os/ossrv/ossrv_pub/boost_apis/boost/numeric/interval/constants.hpp@260cb5ec6c19

     1 /* Boost interval/constants.hpp template implementation file

     2  *

     3  * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion

     4  *

     5  * Distributed under the Boost Software License, Version 1.0.

     6  * (See accompanying file LICENSE_1_0.txt or

     7  * copy at http://www.boost.org/LICENSE_1_0.txt)

     8  */

    10 #ifndef BOOST_NUMERIC_INTERVAL_CONSTANTS_HPP

    11 #define BOOST_NUMERIC_INTERVAL_CONSTANTS_HPP

    13 namespace boost {

    14 namespace numeric {

    15 namespace interval_lib {

    16 namespace constants {

    18 // These constants should be exactly computed.

    19 // Decimal representations wouldn't do it since the standard doesn't

    20 // specify the rounding (even nearest) that should be used.

    22 static const float pi_f_l = 13176794.0f/(1<<22);

    23 static const float pi_f_u = 13176795.0f/(1<<22);

    24 static const double pi_d_l = (3373259426.0 + 273688.0 / (1<<21)) / (1<<30);

    25 static const double pi_d_u = (3373259426.0 + 273689.0 / (1<<21)) / (1<<30);

    27 template<class T> inline T pi_lower() { return 3; }

    28 template<class T> inline T pi_upper() { return 4; }

    29 template<class T> inline T pi_half_lower() { return 1; }

    30 template<class T> inline T pi_half_upper() { return 2; }

    31 template<class T> inline T pi_twice_lower() { return 6; }

    32 template<class T> inline T pi_twice_upper() { return 7; }

    34 template<> inline float pi_lower<float>() { return pi_f_l; }

    35 template<> inline float pi_upper<float>() { return pi_f_u; }

    36 template<> inline float pi_half_lower<float>() { return pi_f_l / 2; }

    37 template<> inline float pi_half_upper<float>() { return pi_f_u / 2; }

    38 template<> inline float pi_twice_lower<float>() { return pi_f_l * 2; }

    39 template<> inline float pi_twice_upper<float>() { return pi_f_u * 2; }

    41 template<> inline double pi_lower<double>() { return pi_d_l; }

    42 template<> inline double pi_upper<double>() { return pi_d_u; }

    43 template<> inline double pi_half_lower<double>() { return pi_d_l / 2; }

    44 template<> inline double pi_half_upper<double>() { return pi_d_u / 2; }

    45 template<> inline double pi_twice_lower<double>() { return pi_d_l * 2; }

    46 template<> inline double pi_twice_upper<double>() { return pi_d_u * 2; }

    48 template<> inline long double pi_lower<long double>() { return pi_d_l; }

    49 template<> inline long double pi_upper<long double>() { return pi_d_u; }

    50 template<> inline long double pi_half_lower<long double>() { return pi_d_l / 2; }

    51 template<> inline long double pi_half_upper<long double>() { return pi_d_u / 2; }

    52 template<> inline long double pi_twice_lower<long double>() { return pi_d_l * 2; }

    53 template<> inline long double pi_twice_upper<long double>() { return pi_d_u * 2; }

    55 } // namespace constants

    57 template<class I> inline

    58 I pi()

    59 {

    60   typedef typename I::base_type T;

    61   return I(constants::pi_lower<T>(),

    62            constants::pi_upper<T>(), true);

    63 }

    65 template<class I> inline

    66 I pi_half()

    67 {

    68   typedef typename I::base_type T;

    69   return I(constants::pi_half_lower<T>(),

    70            constants::pi_half_upper<T>(), true);

    71 }

    73 template<class I> inline

    74 I pi_twice()

    75 {

    76   typedef typename I::base_type T;

    77   return I(constants::pi_twice_lower<T>(),

    78            constants::pi_twice_upper<T>(), true);

    79 }

    81 } // namespace interval_lib

    82 } // namespace numeric

    83 } // namespace boost

    85 #endif // BOOST_NUMERIC_INTERVAL_CONSTANTS_HPP

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--