yade-dev team mailing list archive
-
yade-dev team
-
Mailing list archive
-
Message #10870
[Branch ~yade-pkg/yade/git-trunk] Rev 3975: Remove extra/floating_point_utilities_v3
------------------------------------------------------------
revno: 3975
committer: Anton Gladky <gladky.anton@xxxxxxxxx>
timestamp: Fri 2014-05-23 15:03:49 +0200
message:
Remove extra/floating_point_utilities_v3
This library is shipped in Boost since 1.47.0,
no need to ship an embedded version any more.
removed:
extra/
extra/floating_point_utilities_v3/
extra/floating_point_utilities_v3/README
extra/floating_point_utilities_v3/boost/
extra/floating_point_utilities_v3/boost/math/
extra/floating_point_utilities_v3/boost/math/detail/
extra/floating_point_utilities_v3/boost/math/detail/fp_traits.hpp
extra/floating_point_utilities_v3/boost/math/fpclassify.hpp
extra/floating_point_utilities_v3/boost/math/nonfinite_num_facets.hpp
extra/floating_point_utilities_v3/boost/math/signbit.hpp
modified:
CMakeLists.txt
--
lp:yade
https://code.launchpad.net/~yade-pkg/yade/git-trunk
Your team Yade developers is subscribed to branch lp:yade.
To unsubscribe from this branch go to https://code.launchpad.net/~yade-pkg/yade/git-trunk/+edit-subscription
=== modified file 'CMakeLists.txt'
--- CMakeLists.txt 2014-05-08 07:11:18 +0000
+++ CMakeLists.txt 2014-05-23 13:03:49 +0000
@@ -87,6 +87,9 @@
#===========================================================
# Add possibility to use local boost installation (e.g. -DLocalBoost=1.46.1)
+IF ( NOT LocalBoost )
+ SET(LocalBoost "1.47.0") # Minimal required Boost version
+ENDIF ( NOT LocalBoost )
FIND_PACKAGE(Boost ${LocalBoost} COMPONENTS python thread filesystem iostreams regex serialization system REQUIRED)
INCLUDE_DIRECTORIES (${Boost_INCLUDE_DIRS})
# for checking purpose
@@ -324,7 +327,6 @@
ENDIF(ENABLE_GL2PS)
INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_DIRS})
-INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/extra/floating_point_utilities_v3)
INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR})
#===========================================================
=== removed directory 'extra'
=== removed directory 'extra/floating_point_utilities_v3'
=== removed file 'extra/floating_point_utilities_v3/README'
--- extra/floating_point_utilities_v3/README 2010-04-19 10:18:42 +0000
+++ extra/floating_point_utilities_v3/README 1970-01-01 00:00:00 +0000
@@ -1,7 +0,0 @@
-Graceful handling of nan and inf in iostream
-
-Proposed for boost::math
-
-Downloaded from: http://www.boostpro.com/vault/index.php?action=downloadfile&filename=floating_point_utilities_v3.zip&directory=Math%20-%20Numerics&;
-
-stripped of documentation
=== removed directory 'extra/floating_point_utilities_v3/boost'
=== removed directory 'extra/floating_point_utilities_v3/boost/math'
=== removed directory 'extra/floating_point_utilities_v3/boost/math/detail'
=== removed file 'extra/floating_point_utilities_v3/boost/math/detail/fp_traits.hpp'
--- extra/floating_point_utilities_v3/boost/math/detail/fp_traits.hpp 2010-04-19 10:18:42 +0000
+++ extra/floating_point_utilities_v3/boost/math/detail/fp_traits.hpp 1970-01-01 00:00:00 +0000
@@ -1,576 +0,0 @@
-// fp_traits.hpp
-
-#ifndef BOOST_MATH_FP_TRAITS_HPP
-#define BOOST_MATH_FP_TRAITS_HPP
-
-// Copyright (c) 2006 Johan Rade
-
-// Distributed under 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)
-
-#if defined(__vms) && defined(__DECCXX) && !__IEEE_FLOAT
-# error The VAX floating point mode on VMS is not supported.
-#endif
-
-#include <cstring>
-
-#include <boost/assert.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/detail/endian.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
-
-//------------------------------------------------------------------------------
-
-namespace boost {
-namespace math {
-namespace detail {
-
-//------------------------------------------------------------------------------
-
-/*
-Most processors support three different floating point precisions:
-single precision (32 bits), double precision (64 bits)
-and extended double precision (>64 bits)
-
-Note that the C++ type long double can be implemented
-both as double precision and extended double precision.
-*/
-
-struct single_precision_tag {};
-struct double_precision_tag {};
-struct extended_double_precision_tag {};
-
-//------------------------------------------------------------------------------
-
-/*
-template<class T, class U> struct fp_traits_impl;
-
- This is traits class that describes the binary structure of floating
- point numbers of C++ type T and precision U
-
-Requirements:
-
- T = float, double or long double
- U = single_precision_tag, double_precision_tag
- or extended_double_precision_tag
-
-Typedef members:
-
- bits -- the target type when copying the leading bytes of a floating
- point number. It is a typedef for uint32_t or uint64_t.
-
- coverage -- tells us whether all bytes are copied or not.
- It is a typedef for all_bits or not_all_bits.
-
-Static data members:
-
- sign, exponent, flag, mantissa -- bit masks that give the meaning of the bits
- in the leading bytes.
-
-Static function members:
-
- init() -- initializes the static data members, if needed.
- (Is a no-op in the specialized versions of the template.)
-
- get_bits(), set_bits() -- provide access to the leading bytes.
-*/
-
-struct all_bits {};
-struct not_all_bits {};
-
-// Generic version -------------------------------------------------------------
-
-// The generic version uses run time initialization to determine the floating
-// point format. It is capable of handling most formats,
-// but not the Motorola 68K extended double precision format.
-
-// Currently the generic version is used only for extended double precision
-// on Itanium. In all other cases there are specializations of the template
-// that use compile time initialization.
-
-template<class T> struct uint32_t_coverage
-{
- typedef not_all_bits type;
-};
-
-template<> struct uint32_t_coverage<single_precision_tag>
-{
- typedef all_bits type;
-};
-
-template<class T, class U> struct fp_traits_impl
-{
- typedef uint32_t bits;
- typedef BOOST_DEDUCED_TYPENAME uint32_t_coverage<U>::type coverage;
-
- BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
- static uint32_t exponent;
- static uint32_t flag;
- static uint32_t mantissa;
-
- static void init()
- {
- if(is_init_) return;
- do_init_();
- is_init_ = true;
- }
-
- static void get_bits(T x, uint32_t& a)
- {
- memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
- }
-
- static void set_bits(T& x, uint32_t a)
- {
- memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
- }
-
-private:
- static size_t offset_;
- static bool is_init_;
- static void do_init_();
-};
-
-//..............................................................................
-
-template<class T, class U> uint32_t fp_traits_impl<T,U>::exponent;
-template<class T, class U> uint32_t fp_traits_impl<T,U>::flag;
-template<class T, class U> uint32_t fp_traits_impl<T,U>::mantissa;
-template<class T, class U> size_t fp_traits_impl<T,U>::offset_;
-template<class T, class U> bool fp_traits_impl<T,U>::is_init_;
-
-// In a single-threaded program, do_init will be called exactly once.
-// In a multi-threaded program, do_init may be called simultaneously
-// by more then one thread. That should not be a problem.
-
-//..............................................................................
-
-template<class T, class U> void fp_traits_impl<T,U>::do_init_()
-{
- T x = static_cast<T>(3) / static_cast<T>(4);
- // sign bit = 0
- // exponent: first and last bit = 0, all other bits = 1
- // flag bit (if present) = 1
- // mantissa: first bit = 1, all other bits = 0
-
- uint32_t a;
-
- for(size_t k = 0; k <= sizeof(T) - 4; ++k) {
-
- memcpy(&a, reinterpret_cast<unsigned char*>(&x) + k, 4);
-
- switch(a) {
-
- case 0x3f400000: // IEEE single precision format
-
- offset_ = k;
- exponent = 0x7f800000;
- flag = 0x00000000;
- mantissa = 0x007fffff;
- return;
-
- case 0x3fe80000: // IEEE double precision format
- // and PowerPC extended double precision format
- offset_ = k;
- exponent = 0x7ff00000;
- flag = 0x00000000;
- mantissa = 0x000fffff;
- return;
-
- case 0x3ffe0000: // Motorola extended double precision format
-
- // Must not get here. Must be handled by specialization.
- // To get accurate cutoff between normals and subnormals
- // we must use the flag bit that is in the 5th byte.
- // Otherwise this cutoff will be off by a factor 2.
- // If we do get here, then we have failed to detect the Motorola
- // processor at compile time.
-
- BOOST_ASSERT(false);
- return;
-
- case 0x3ffe8000: // IEEE extended double precision format
- // with 15 exponent bits
- offset_ = k;
- exponent = 0x7fff0000;
- flag = 0x00000000;
- mantissa = 0x0000ffff;
- return;
-
- case 0x3ffec000: // Intel extended double precision format
-
- offset_ = k;
- exponent = 0x7fff0000;
- flag = 0x00008000;
- mantissa = 0x00007fff;
- return;
-
- default:
- continue;
- }
- }
-
- BOOST_ASSERT(false);
-
- // Unknown format.
-}
-
-
-// float (32 bits) -------------------------------------------------------------
-
-template<> struct fp_traits_impl<float, single_precision_tag>
-{
- typedef uint32_t bits;
- typedef all_bits coverage;
-
- BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
- BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7f800000);
- BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000);
- BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x007fffff);
-
- static void init() {}
- static void get_bits(float x, uint32_t& a) { memcpy(&a, &x, 4); }
- static void set_bits(float& x, uint32_t a) { memcpy(&x, &a, 4); }
-};
-
-
-// double (64 bits) ------------------------------------------------------------
-
-#if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
-
-template<> struct fp_traits_impl<double, double_precision_tag>
-{
- typedef uint32_t bits;
- typedef not_all_bits coverage;
-
- BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
- BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
- BOOST_STATIC_CONSTANT(uint32_t, flag = 0);
- BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);
-
- static void init() {}
-
- static void get_bits(double x, uint32_t& a)
- {
- memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
- }
-
- static void set_bits(double& x, uint32_t a)
- {
- memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
- }
-
-private:
-
-#if defined(BOOST_BIG_ENDIAN)
- BOOST_STATIC_CONSTANT(int, offset_ = 0);
-#elif defined(BOOST_LITTLE_ENDIAN)
- BOOST_STATIC_CONSTANT(int, offset_ = 4);
-#else
- BOOST_STATIC_ASSERT(false);
-#endif
-};
-
-//..............................................................................
-
-#else
-
-template<> struct fp_traits_impl<double, double_precision_tag>
-{
- typedef uint64_t bits;
- typedef all_bits coverage;
-
- static const uint64_t sign = (uint64_t)0x80000000 << 32;
- static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
- static const uint64_t flag = 0;
- static const uint64_t mantissa
- = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffff;
-
- static void init() {}
- static void get_bits(double x, uint64_t& a) { memcpy(&a, &x, 8); }
- static void set_bits(double& x, uint64_t a) { memcpy(&x, &a, 8); }
-};
-
-#endif
-
-
-// long double (64 bits) -------------------------------------------------------
-
-#if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
-
-template<> struct fp_traits_impl<long double, double_precision_tag>
-{
- typedef uint32_t bits;
- typedef not_all_bits coverage;
-
- BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
- BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
- BOOST_STATIC_CONSTANT(uint32_t, flag = 0);
- BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);
-
- static void init() {}
-
- static void get_bits(long double x, uint32_t& a)
- {
- memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
- }
-
- static void set_bits(long double& x, uint32_t a)
- {
- memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
- }
-
-private:
-
-#if defined(BOOST_BIG_ENDIAN)
- BOOST_STATIC_CONSTANT(int, offset_ = 0);
-#elif defined(BOOST_LITTLE_ENDIAN)
- BOOST_STATIC_CONSTANT(int, offset_ = 4);
-#else
- BOOST_STATIC_ASSERT(false);
-#endif
-};
-
-//..............................................................................
-
-#else
-
-template<> struct fp_traits_impl<long double, double_precision_tag>
-{
- typedef uint64_t bits;
- typedef all_bits coverage;
-
- static const uint64_t sign = (uint64_t)0x80000000 << 32;
- static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
- static const uint64_t flag = 0;
- static const uint64_t mantissa
- = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffff;
-
- static void init() {}
- static void get_bits(long double x, uint64_t& a) { memcpy(&a, &x, 8); }
- static void set_bits(long double& x, uint64_t a) { memcpy(&x, &a, 8); }
-};
-
-#endif
-
-
-// long double (>64 bits), x86 and x64 -----------------------------------------
-
-#if defined(__i386) || defined(__i386__) || defined(_M_IX86) \
- || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) \
- || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)
-
-// Intel extended double precision format (80 bits)
-
-template<> struct fp_traits_impl<long double, extended_double_precision_tag>
-{
- typedef uint32_t bits;
- typedef not_all_bits coverage;
-
- BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
- BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
- BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00008000);
- BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x00007fff);
-
- static void init() {}
-
- static void get_bits(long double x, uint32_t& a)
- {
- memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + 6, 4);
- }
-
- static void set_bits(long double& x, uint32_t a)
- {
- memcpy(reinterpret_cast<unsigned char*>(&x) + 6, &a, 4);
- }
-};
-
-
-// long double (>64 bits), Itanium ---------------------------------------------
-
-#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
-
-// The floating point format is unknown at compile time
-// No template specialization is provided.
-// The generic definition is used.
-
-// The Itanium supports both
-// the Intel extended double precision format (80 bits) and
-// the IEEE extended double precision format with 15 exponent bits (128 bits).
-
-
-// long double (>64 bits), PowerPC ---------------------------------------------
-
-#elif defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) \
- || defined(__ppc) || defined(__ppc__) || defined(__PPC__)
-
-// PowerPC extended double precision format (128 bits)
-
-template<> struct fp_traits_impl<long double, extended_double_precision_tag>
-{
- typedef uint32_t bits;
- typedef not_all_bits coverage;
-
- BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
- BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
- BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000);
- BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);
-
- static void init() {}
-
- static void get_bits(long double x, uint32_t& a)
- {
- memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
- }
-
- static void set_bits(long double& x, uint32_t a)
- {
- memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
- }
-
-private:
-
-#if defined(BOOST_BIG_ENDIAN)
- BOOST_STATIC_CONSTANT(int, offset_ = 0);
-#elif defined(BOOST_LITTLE_ENDIAN)
- BOOST_STATIC_CONSTANT(int, offset_ = 12);
-#else
- BOOST_STATIC_ASSERT(false);
-#endif
-};
-
-
-// long double (>64 bits), Motorola 68K ----------------------------------------
-
-#elif defined(__m68k) || defined(__m68k__) \
- || defined(__mc68000) || defined(__mc68000__) \
-
-// Motorola extended double precision format (96 bits)
-
-// It is the same format as the Intel extended double precision format,
-// except that 1) it is big-endian, 2) the 3rd and 4th byte are padding, and
-// 3) the flag bit is not set for infinity
-
-template<> struct fp_traits_impl<long double, extended_double_precision_tag>
-{
- typedef uint32_t bits;
- typedef not_all_bits coverage;
-
- BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
- BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
- BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00008000);
- BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x00007fff);
-
- static void init() {}
-
- // copy 1st, 2nd, 5th and 6th byte. 3rd and 4th byte are padding.
-
- static void get_bits(long double x, uint32_t& a)
- {
- memcpy(&a, &x, 2);
- memcpy(reinterpret_cast<unsigned char*>(&a) + 2,
- reinterpret_cast<const unsigned char*>(&x) + 4, 2);
- }
-
- static void set_bits(long double& x, uint32_t a)
- {
- memcpy(&x, &a, 2);
- memcpy(reinterpret_cast<unsigned char*>(&x) + 4,
- reinterpret_cast<const unsigned char*>(&a) + 2, 2);
- }
-};
-
-
-// long double (>64 bits), All other processors --------------------------------
-
-#else
-
-// IEEE extended double precision format with 15 exponent bits (128 bits)
-
-template<> struct fp_traits_impl<long double, extended_double_precision_tag>
-{
- typedef uint32_t bits;
- typedef not_all_bits coverage;
-
- BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
- BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
- BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000);
- BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x0000ffff);
-
- static void init() {}
-
- static void get_bits(long double x, uint32_t& a)
- {
- memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
- }
-
- static void set_bits(long double& x, uint32_t a)
- {
- memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
- }
-
-private:
-
-#if defined(BOOST_BIG_ENDIAN)
- BOOST_STATIC_CONSTANT(int, offset_ = 0);
-#elif defined(BOOST_LITTLE_ENDIAN)
- BOOST_STATIC_CONSTANT(int, offset_ = 12);
-#else
- BOOST_STATIC_ASSERT(false);
-#endif
-};
-
-#endif
-
-
-//------------------------------------------------------------------------------
-
-// size_to_precision is a type switch for converting a C++ floating point type
-// to the corresponding precision type.
-
-template<int n> struct size_to_precision;
-
-template<> struct size_to_precision<4>
-{
- typedef single_precision_tag type;
-};
-
-template<> struct size_to_precision<8>
-{
- typedef double_precision_tag type;
-};
-
-template<> struct size_to_precision<10>
-{
- typedef extended_double_precision_tag type;
-};
-
-template<> struct size_to_precision<12>
-{
- typedef extended_double_precision_tag type;
-};
-
-template<> struct size_to_precision<16>
-{
- typedef extended_double_precision_tag type;
-};
-
-// fp_traits is a type switch that selects the right fp_traits_impl
-
-template<class T> struct fp_traits
-{
- BOOST_STATIC_ASSERT(boost::is_floating_point<T>::value);
- typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T)>::type precision;
- typedef fp_traits_impl<T, precision> type;
-};
-
-
-//------------------------------------------------------------------------------
-
-} // namespace detail
-} // namespace math
-} // namespace boost
-
-#endif
=== removed file 'extra/floating_point_utilities_v3/boost/math/fpclassify.hpp'
--- extra/floating_point_utilities_v3/boost/math/fpclassify.hpp 2010-04-19 10:18:42 +0000
+++ extra/floating_point_utilities_v3/boost/math/fpclassify.hpp 1970-01-01 00:00:00 +0000
@@ -1,229 +0,0 @@
-// fpclassify.hpp
-
-#ifndef BOOST_MATH_FPCLASSIFY_HPP
-#define BOOST_MATH_FPCLASSIFY_HPP
-
-// Copyright (c) 2006 Johan Rade
-
-// Distributed under 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)
-
-/*
-The following algorithm is used:
-
- If all exponent bits, the flag bit (if there is one),
- and all mantissa bits are 0, then the number is zero.
-
- If all exponent bits and the flag bit (if there is one) are 0,
- and at least one mantissa bit is 1, then the number is subnormal.
-
- If all exponent bits are 1 and all mantissa bits are 0,
- then the number is infinity.
-
- If all exponent bits are 1 and at least one mantissa bit is 1,
- then the number is a not-a-number.
-
- Otherwise the number is normal.
-
-(Note that the binary representation of infinity
-has flag bit 0 for Motorola 68K extended double precision,
-and flag bit 1 for Intel extended double precision.)
-
-To get the bits, the four or eight most significant bytes are copied
-into an uint32_t or uint64_t and bit masks are applied.
-This covers all the exponent bits and the flag bit (if there is one),
-but not always all the mantissa bits.
-Some of the functions below have two implementations,
-depending on whether all the mantissa bits are copied or not.
-*/
-
-#include <cmath>
-
-#ifndef FP_INFINITE
-# define FP_INFINITE 0
-# define FP_NAN 1
-# define FP_NORMAL 2
-# define FP_SUBNORMAL 3
-# define FP_ZERO 4
-#endif
-
-#include "detail/fp_traits.hpp"
-
-namespace boost {
-namespace math {
-
-//------------------------------------------------------------------------------
-
-template<class T> bool (isfinite)(T x)
-{
- typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits;
- traits::init();
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
- a &= traits::exponent;
- return a != traits::exponent;
-}
-
-//------------------------------------------------------------------------------
-
-template<class T> bool (isnormal)(T x)
-{
- typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits;
- traits::init();
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
- a &= traits::exponent | traits::flag;
- return (a != 0) && (a < traits::exponent);
-}
-
-//------------------------------------------------------------------------------
-
-namespace detail {
-
- template<class T> bool isinf_impl(T x, all_bits)
- {
- typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
- a &= traits::exponent | traits::mantissa;
- return a == traits::exponent;
- }
-
- template<class T> bool isinf_impl(T x, not_all_bits)
- {
- typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
- a &= traits::exponent | traits::mantissa;
- if(a != traits::exponent)
- return false;
-
- traits::set_bits(x,0);
- return x == 0;
- }
-
-} // namespace detail
-
-template<class T> bool (isinf)(T x)
-{
- typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits;
- traits::init();
- return detail::isinf_impl(x, BOOST_DEDUCED_TYPENAME traits::coverage());
-}
-
-//------------------------------------------------------------------------------
-
-namespace detail {
-
- template<class T> bool isnan_impl(T x, all_bits)
- {
- typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
- traits::init();
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
- a &= traits::exponent | traits::mantissa;
- return a > traits::exponent;
- }
-
- template<class T> bool isnan_impl(T x, not_all_bits)
- {
- typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
- traits::init();
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
-
- a &= traits::exponent | traits::mantissa;
- if(a < traits::exponent)
- return false;
-
- a &= traits::mantissa;
- traits::set_bits(x,a);
- return x != 0;
- }
-
-} // namespace detail
-
-template<class T> bool (isnan)(T x)
-{
- typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits;
- traits::init();
- return detail::isnan_impl(x, BOOST_DEDUCED_TYPENAME traits::coverage());
-}
-
-//------------------------------------------------------------------------------
-
-namespace detail {
-
- template<class T> int fpclassify_impl(T x, all_bits)
- {
- typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
- a &= traits::exponent | traits::flag | traits::mantissa;
-
- if(a <= traits::mantissa) {
- if(a == 0)
- return FP_ZERO;
- else
- return FP_SUBNORMAL;
- }
-
- if(a < traits::exponent)
- return FP_NORMAL;
-
- a &= traits::mantissa;
- if(a == 0)
- return FP_INFINITE;
-
- return FP_NAN;
- }
-
- template<class T> int fpclassify_impl(T x, not_all_bits)
- {
- typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
- a &= traits::exponent | traits::flag | traits::mantissa;
-
- if(a <= traits::mantissa) {
- if(x == 0)
- return FP_ZERO;
- else
- return FP_SUBNORMAL;
- }
-
- if(a < traits::exponent)
- return FP_NORMAL;
-
- a &= traits::mantissa;
- traits::set_bits(x,a);
- if(x == 0)
- return FP_INFINITE;
-
- return FP_NAN;
- }
-
-} // namespace detail
-
-template<class T> int (fpclassify)(T x)
-{
- typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits;
- traits::init();
- return detail::fpclassify_impl(x, BOOST_DEDUCED_TYPENAME traits::coverage());
-}
-
-//------------------------------------------------------------------------------
-
-} // namespace math
-} // namespace boost
-
-#endif
=== removed file 'extra/floating_point_utilities_v3/boost/math/nonfinite_num_facets.hpp'
--- extra/floating_point_utilities_v3/boost/math/nonfinite_num_facets.hpp 2010-04-19 10:18:42 +0000
+++ extra/floating_point_utilities_v3/boost/math/nonfinite_num_facets.hpp 1970-01-01 00:00:00 +0000
@@ -1,475 +0,0 @@
-#ifndef BOOST_MATH_NONFINITE_NUM_FACETS_HPP
-#define BOOST_MATH_NONFINITE_NUM_FACETS_HPP
-
-// Copyright (c) 2006 Johan Rade
-
-// Distributed under 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)
-
-#include <cstring>
-#include <ios>
-#include <limits>
-#include <locale>
-#include "fpclassify.hpp"
-#include "signbit.hpp"
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable : 4127 4511 4512 4706)
-#endif
-
-namespace boost {
-namespace math {
-
-
-// flags -----------------------------------------------------------------------
-
-const int legacy = 0x1;
-const int signed_zero = 0x2;
-const int trap_infinity = 0x4;
-const int trap_nan = 0x8;
-
-
-// class nonfinite_num_put -----------------------------------------------------
-
-template<
- class CharType,
- class OutputIterator = std::ostreambuf_iterator<CharType>
->
-class nonfinite_num_put : public std::num_put<CharType, OutputIterator> {
-public:
- explicit nonfinite_num_put(int flags = 0) : flags_(flags) {}
-
-protected:
- virtual OutputIterator do_put(
- OutputIterator it, std::ios_base& iosb,
- CharType fill, double val) const
- {
- put_and_reset_width(it, iosb, fill, val);
- return it;
- }
-
- virtual OutputIterator do_put(
- OutputIterator it, std::ios_base& iosb,
- CharType fill, long double val) const
- {
- put_and_reset_width(it, iosb, fill, val);
- return it;
- }
-
-private:
- template<class ValType> void put_and_reset_width(
- OutputIterator& it, std::ios_base& iosb,
- CharType fill, ValType val) const
- {
- put_impl(it, iosb, fill, val);
- iosb.width(0);
- }
-
- template<class ValType> void put_impl(
- OutputIterator& it, std::ios_base& iosb,
- CharType fill, ValType val) const
- {
- switch((boost::math::fpclassify)(val)) {
-
- case FP_INFINITE:
- if(flags_ & trap_infinity)
- throw std::ios_base::failure("Infinity");
- else if((boost::math::signbit)(val))
- put_num_and_fill(it, iosb, "-", "inf", fill);
- else if(iosb.flags() & std::ios_base::showpos)
- put_num_and_fill(it, iosb, "+", "inf", fill);
- else
- put_num_and_fill(it, iosb, "", "inf", fill);
- break;
-
- case FP_NAN:
- if(flags_ & trap_nan)
- throw std::ios_base::failure("NaN");
- else if((boost::math::signbit)(val))
- put_num_and_fill(it, iosb, "-", "nan", fill);
- else if(iosb.flags() & std::ios_base::showpos)
- put_num_and_fill(it, iosb, "+", "nan", fill);
- else
- put_num_and_fill(it, iosb, "", "nan", fill);
- break;
-
- case FP_ZERO:
- if(flags_ & signed_zero) {
- if((boost::math::signbit)(val))
- put_num_and_fill(it, iosb, "-", "0", fill);
- else if(iosb.flags() & std::ios_base::showpos)
- put_num_and_fill(it, iosb, "+", "0", fill);
- else
- put_num_and_fill(it, iosb, "", "0", fill);
- }
- else
- put_num_and_fill(it, iosb, "", "0", fill);
- break;
-
- default:
- it = std::num_put<CharType, OutputIterator>::do_put(
- it, iosb, fill, val);
- break;
- }
- }
-
- void put_num_and_fill(
- OutputIterator& it, std::ios_base& iosb, const char* prefix,
- const char* body, CharType fill) const
- {
- int width = (int)strlen(prefix) + (int)strlen(body);
- std::ios_base::fmtflags adjust
- = iosb.flags() & std::ios_base::adjustfield;
- const std::ctype<CharType>& ct
- = std::use_facet<std::ctype<CharType> >(iosb.getloc());
-
- if(adjust != std::ios_base::internal && adjust != std::ios_base::left)
- put_fill(it, iosb, fill, width);
-
- while(*prefix)
- *it = ct.widen(*(prefix++));
-
- if(adjust == std::ios_base::internal)
- put_fill(it, iosb, fill, width);
-
- if(iosb.flags() & std::ios_base::uppercase) {
- while(*body)
- *it = ct.toupper(ct.widen(*(body++)));
- }
- else {
- while(*body)
- *it = ct.widen(*(body++));
- }
-
- if(adjust == std::ios_base::left)
- put_fill(it, iosb, fill, width);
- }
-
- void put_fill(
- OutputIterator& it, std::ios_base& iosb,
- CharType fill, int width) const
- {
- for(int i = iosb.width() - width; i > 0; --i)
- *it = fill;
- }
-
-private:
- const int flags_;
-};
-
-
-// class nonfinite_num_get ------------------------------------------------------
-
-template<
- class CharType,
- class InputIterator = std::istreambuf_iterator<CharType>
->
-class nonfinite_num_get : public std::num_get<CharType, InputIterator> {
-public:
- explicit nonfinite_num_get(int flags = 0) : flags_(flags) {}
-
-protected:
- virtual InputIterator do_get(
- InputIterator it, InputIterator end, std::ios_base& iosb,
- std::ios_base::iostate& state, float& val) const
- {
- get_and_check_eof(it, end, iosb, state, val);
- return it;
- }
-
- virtual InputIterator do_get(
- InputIterator it, InputIterator end, std::ios_base& iosb,
- std::ios_base::iostate& state, double& val) const
- {
- get_and_check_eof(it, end, iosb, state, val);
- return it;
- }
-
- virtual InputIterator do_get(
- InputIterator it, InputIterator end, std::ios_base& iosb,
- std::ios_base::iostate& state, long double& val) const
- {
- get_and_check_eof(it, end, iosb, state, val);
- return it;
- }
-
-//..............................................................................
-
-private:
- template<class ValType> static ValType positive_nan()
- {
- // on some platforms quiet_NaN() is negative
- return (boost::math::copysign)(
- std::numeric_limits<ValType>::quiet_NaN(), 1);
- }
-
- template<class ValType> void get_and_check_eof(
- InputIterator& it, InputIterator end, std::ios_base& iosb,
- std::ios_base::iostate& state, ValType& val) const
- {
- get_signed(it, end, iosb, state, val);
- if(it == end)
- state |= std::ios_base::eofbit;
- }
-
- template<class ValType> void get_signed(
- InputIterator& it, InputIterator end, std::ios_base& iosb,
- std::ios_base::iostate& state, ValType& val) const
- {
- const std::ctype<CharType>& ct
- = std::use_facet<std::ctype<CharType> >(iosb.getloc());
-
- char c = peek_char(it, end, ct);
-
- bool negative = (c == '-');
-
- if(negative || c == '+') {
- ++it;
- c = peek_char(it, end, ct);
- if(c == '-' || c == '+') {
- // without this check, "++5" etc would be accepted
- state |= std::ios_base::failbit;
- return;
- }
- }
-
- get_unsigned(it, end, iosb, ct, state, val);
-
- if(negative)
- val = (boost::math::changesign)(val);
- }
-
- template<class ValType> void get_unsigned(
- InputIterator& it, InputIterator end, std::ios_base& iosb,
- const std::ctype<CharType>& ct,
- std::ios_base::iostate& state, ValType& val) const
- {
- switch(peek_char(it, end, ct)) {
-
- case 'i':
- get_i(it, end, ct, state, val);
- break;
-
- case 'n':
- get_n(it, end, ct, state, val);
- break;
-
- case 'q':
- case 's':
- get_q(it, end, ct, state, val);
- break;
-
- default:
- it = std::num_get<CharType, InputIterator>::do_get(
- it, end, iosb, state, val);
- if((flags_ & legacy) && val == static_cast<ValType>(1)
- && peek_char(it, end, ct) == '#')
- get_one_hash(it, end, ct, state, val);
- break;
- }
- }
-
- //..........................................................................
-
- template<class ValType> void get_i(
- InputIterator& it, InputIterator end, const std::ctype<CharType>& ct,
- std::ios_base::iostate& state, ValType& val) const
- {
- if(!std::numeric_limits<ValType>::has_infinity
- || (flags_ & trap_infinity)) {
- state |= std::ios_base::failbit;
- return;
- }
-
- ++it;
-
- if(!match_string(it, end, ct, "nf")) {
- state |= std::ios_base::failbit;
- return;
- }
-
- if(peek_char(it, end, ct) != 'i') {
- val = std::numeric_limits<ValType>::infinity(); // "inf"
- return;
- }
-
- ++it;
-
- if(!match_string(it, end, ct, "nity")) {
- state |= std::ios_base::failbit;
- return;
- }
-
- val = std::numeric_limits<ValType>::infinity(); // "infinity"
- }
-
- template<class ValType> void get_n(
- InputIterator& it, InputIterator end, const std::ctype<CharType>& ct,
- std::ios_base::iostate& state, ValType& val) const
- {
- if(!std::numeric_limits<ValType>::has_quiet_NaN
- || (flags_ & trap_nan)) {
- state |= std::ios_base::failbit;
- return;
- }
-
- ++it;
-
- if(!match_string(it, end, ct, "an")) {
- state |= std::ios_base::failbit;
- return;
- }
-
- switch(peek_char(it, end, ct)) {
- case 'q':
- case 's':
- if(flags_ && legacy)
- ++it;
- break; // "nanq", "nans"
-
- case '(':
- {
- ++it;
- char c;
- while((c = peek_char(it, end, ct))
- && c != ')' && c != ' ' && c != '\n' && c != '\t')
- ++it;
- if(c != ')') {
- state |= std::ios_base::failbit;
- return;
- }
- ++it;
- break; // "nan(...)"
- }
-
- default:
- break; // "nan"
- }
-
- val = positive_nan<ValType>();
- }
-
- template<class ValType> void get_q(
- InputIterator& it, InputIterator end, const std::ctype<CharType>& ct,
- std::ios_base::iostate& state, ValType& val) const
- {
- if(!std::numeric_limits<ValType>::has_quiet_NaN
- || (flags_ & trap_nan) || !(flags_ & legacy)) {
- state |= std::ios_base::failbit;
- return;
- }
-
- ++it;
-
- if(!match_string(it, end, ct, "nan")) {
- state |= std::ios_base::failbit;
- return;
- }
-
- val = positive_nan<ValType>(); // qnan, snan
- }
-
- template<class ValType> void get_one_hash(
- InputIterator& it, InputIterator end, const std::ctype<CharType>& ct,
- std::ios_base::iostate& state, ValType& val) const
- {
- ++it;
-
- switch(peek_char(it, end, ct)) {
- case 'i':
- get_one_hash_i(it, end, ct, state, val);
- return;
-
- case 'q':
- case 's':
- if(std::numeric_limits<ValType>::has_quiet_NaN
- && !(flags_ & trap_nan)) {
- ++it;
- if(match_string(it, end, ct, "nan")) {
- // "1.#QNAN", "1.#SNAN"
- ++it;
- val = positive_nan<ValType>();
- return;
- }
- }
- break;
-
- default:
- break;
- }
-
- state |= std::ios_base::failbit;
- }
-
- template<class ValType> void get_one_hash_i(
- InputIterator& it, InputIterator end, const std::ctype<CharType>& ct,
- std::ios_base::iostate& state, ValType& val) const
- {
- ++it;
-
- if(peek_char(it, end, ct) == 'n') {
- ++it;
- switch(peek_char(it, end, ct)) {
- case 'f': // "1.#INF"
- if(std::numeric_limits<ValType>::has_infinity
- && !(flags_ & trap_infinity)) {
- ++it;
- val = std::numeric_limits<ValType>::infinity();
- return;
- }
- break;
-
- case 'd': // 1.#IND"
- if(std::numeric_limits<ValType>::has_quiet_NaN
- && !(flags_ & trap_nan)) {
- ++it;
- val = positive_nan<ValType>();
- return;
- }
- break;
-
- default:
- break;
- }
- }
-
- state |= std::ios_base::failbit;
- }
-
- //..........................................................................
-
- char peek_char(
- InputIterator& it, InputIterator end,
- const std::ctype<CharType>& ct) const
- {
- if(it == end) return 0;
- return ct.narrow(ct.tolower(*it), 0);
- }
-
- bool match_string(
- InputIterator& it, InputIterator end,
- const std::ctype<CharType>& ct, const char* s) const
- {
- while(it != end && *s && *s == ct.narrow(ct.tolower(*it), 0)) {
- ++s;
- ++it;
- }
- return !*s;
- }
-
-private:
- const int flags_;
-};
-
-//------------------------------------------------------------------------------
-
-} // namespace serialization
-} // namespace boost
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif
=== removed file 'extra/floating_point_utilities_v3/boost/math/signbit.hpp'
--- extra/floating_point_utilities_v3/boost/math/signbit.hpp 2010-04-19 10:18:42 +0000
+++ extra/floating_point_utilities_v3/boost/math/signbit.hpp 1970-01-01 00:00:00 +0000
@@ -1,86 +0,0 @@
-// signbit.hpp
-
-#ifndef BOOST_MATH_SIGNBIT_HPP
-#define BOOST_MATH_SIGNBIT_HPP
-
-// Copyright (c) 2006 Johan Rade
-
-// Distributed under 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)
-
-#include "detail/fp_traits.hpp"
-
-namespace boost {
-namespace math {
-
-//------------------------------------------------------------------------------
-
-template<class T> bool (signbit)(T x)
-{
- typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits;
- traits::init();
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
- a &= traits::sign;
- return a != 0;
-}
-
-//------------------------------------------------------------------------------
-
-namespace detail {
-
- template<class T> T copysign_impl(T x, T y)
- {
- typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
- traits::init();
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
- a &= ~traits::sign;
-
- BOOST_DEDUCED_TYPENAME traits::bits b;
- traits::get_bits(y,b);
- b &= traits::sign;
-
- traits::set_bits(x,a|b);
- return x;
- }
-}
-
-inline float (copysign)(float x, float y) // magnitude of x and sign of y
-{
- return detail::copysign_impl(x,y);
-}
-
-inline double (copysign)(double x, double y)
-{
- return detail::copysign_impl(x,y);
-}
-
-inline long double (copysign)(long double x, long double y)
-{
- return detail::copysign_impl(x,y);
-}
-
-//------------------------------------------------------------------------------
-
-template<class T> T (changesign)(T x)
-{
- typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits;
- traits::init();
-
- BOOST_DEDUCED_TYPENAME traits::bits a;
- traits::get_bits(x,a);
- a ^= traits::sign;
- traits::set_bits(x,a);
- return x;
-}
-
-//------------------------------------------------------------------------------
-
-} // namespace math
-} // namespace boost
-
-#endif
