EIC code displayed by LXR master/​include/​boost/​math/​special_functions/​nonfinite_num_facets.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-30 09:46:08

 #ifndef BOOST_MATH_NONFINITE_NUM_FACETS_HPP
 #define BOOST_MATH_NONFINITE_NUM_FACETS_HPP
 
 // Copyright 2006 Johan Rade
 // Copyright 2012 K R Walker
 // Copyright 2011, 2012 Paul A. Bristow 
 
 // 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)
 
 /*
 \file
 
 \brief non_finite_num facets for C99 standard output of infinity and NaN.
 
 \details See fuller documentation at Boost.Math Facets
   for Floating-Point Infinities and NaNs.
 */
 
 #include <cstring>
 #include <ios>
 #include <limits>
 #include <locale>
 #include <boost/math/tools/throw_exception.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
 #include <boost/math/special_functions/sign.hpp>
 
 #ifdef _MSC_VER
 #  pragma warning(push)
 #  pragma warning(disable : 4127) // conditional expression is constant.
 #  pragma warning(disable : 4706) // assignment within conditional expression.
 #endif
 
 namespace boost {
   namespace math {
 
     // flags (enums can be ORed together)       -----------------------------------
 
     const int legacy = 0x1; //!< get facet will recognize most string representations of infinity and NaN.
     const int signed_zero = 0x2; //!< put facet will distinguish between positive and negative zero.
     const int trap_infinity = 0x4; /*!< put facet will throw an exception of type std::ios_base::failure
        when an attempt is made to format positive or negative infinity.
        get will set the fail bit of the stream when an attempt is made
        to parse a string that represents positive or negative sign infinity.
     */
     const int trap_nan = 0x8; /*!< put facet will throw an exception of type std::ios_base::failure
        when an attempt is made to format positive or negative NaN.
        get will set the fail bit of the stream when an attempt is made
        to parse a string that represents positive or negative sign infinity.
        */
 
     // 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
       {
         static const CharType prefix_plus[2] = { '+', '\0' };
         static const CharType prefix_minus[2] = { '-', '\0' };
         static const CharType body_inf[4] = { 'i', 'n', 'f', '\0' };
         static const CharType body_nan[4] = { 'n', 'a', 'n', '\0' };
         static const CharType* null_string = 0;
 
         switch((boost::math::fpclassify)(val))
         {
 
         case FP_INFINITE:
           if(flags_ & trap_infinity)
           {
             BOOST_MATH_THROW_EXCEPTION(std::ios_base::failure("Infinity"));
           }
           else if((boost::math::signbit)(val))
           { // negative infinity.
             put_num_and_fill(it, iosb, prefix_minus, body_inf, fill, val);
           }
           else if(iosb.flags() & std::ios_base::showpos)
           { // Explicit "+inf" wanted.
             put_num_and_fill(it, iosb, prefix_plus, body_inf, fill, val);
           }
           else
           { // just "inf" wanted.
             put_num_and_fill(it, iosb, null_string, body_inf, fill, val);
           }
           break;
 
         case FP_NAN:
           if(flags_ & trap_nan)
           {
             BOOST_MATH_THROW_EXCEPTION(std::ios_base::failure("NaN"));
           }
           else if((boost::math::signbit)(val))
           { // negative so "-nan".
             put_num_and_fill(it, iosb, prefix_minus, body_nan, fill, val);
           }
           else if(iosb.flags() & std::ios_base::showpos)
           { // explicit "+nan" wanted.
             put_num_and_fill(it, iosb, prefix_plus, body_nan, fill, val);
           }
           else
           { // Just "nan".
             put_num_and_fill(it, iosb, null_string, body_nan, fill, val);
           }
           break;
 
         case FP_ZERO:
           if((flags_ & signed_zero) && ((boost::math::signbit)(val)))
           { // Flag set to distinguish between positive and negative zero.
             // But string "0" should have stuff after decimal point if setprecision and/or exp format. 
 
             std::basic_ostringstream<CharType> zeros; // Needs to be CharType version.
 
             // Copy flags, fill, width and precision.
             zeros.flags(iosb.flags());
             zeros.unsetf(std::ios::showpos); // Ignore showpos because must be negative.
             zeros.precision(iosb.precision());
             //zeros.width is set by put_num_and_fill
             zeros.fill(static_cast<char>(fill));
             zeros << ValType(0);
             put_num_and_fill(it, iosb, prefix_minus, zeros.str().c_str(), fill, val);
           }
           else
           { // Output the platform default for positive and negative zero.
             put_num_and_fill(it, iosb, null_string, null_string, fill, val);
           }
           break;
 
         default:  // Normal non-zero finite value.
           it = std::num_put<CharType, OutputIterator>::do_put(it, iosb, fill, val);
           break;
         }
       }
 
       template<class ValType>
       void put_num_and_fill(
         OutputIterator& it, std::ios_base& iosb, const CharType* prefix,
           const CharType* body, CharType fill, ValType val) const
       {
         int prefix_length = prefix ? (int)std::char_traits<CharType>::length(prefix) : 0;
         int body_length = body ? (int)std::char_traits<CharType>::length(body) : 0;
         int width = prefix_length + body_length;
         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(body || prefix)
         { // adjust == std::ios_base::right, so leading fill needed.
           if(adjust != std::ios_base::internal && adjust != std::ios_base::left)
             put_fill(it, iosb, fill, width);
         }
 
         if(prefix)
         { // Adjust width for prefix.
           while(*prefix)
             *it = *(prefix++);
           iosb.width( iosb.width() - prefix_length );
           width -= prefix_length;
         }
 
         if(body)
         { // 
           if(adjust == std::ios_base::internal)
           { // Put fill between sign and digits.
             put_fill(it, iosb, fill, width);
           }
           if(iosb.flags() & std::ios_base::uppercase)
           {
               while(*body)
                 *it = ct.toupper(*(body++));
           }
           else
           {
             while(*body)
               *it = *(body++);
           }
 
           if(adjust == std::ios_base::left)
             put_fill(it, iosb, fill, width);
         }
         else
         {
           it = std::num_put<CharType, OutputIterator>::do_put(it, iosb, fill, val);
         }
       }
 
       void put_fill(
         OutputIterator& it, std::ios_base& iosb, CharType fill, int width) const
       { // Insert fill chars.
         for(std::streamsize i = iosb.width() - static_cast<std::streamsize>(width); i > 0; --i)
           *it = fill;
       }
 
       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:  // float, double and long double versions of do_get.
       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() may be negative.
         return (boost::math::copysign)(
           std::numeric_limits<ValType>::quiet_NaN(), static_cast<ValType>(1)
           );
         // static_cast<ValType>(1) added Paul A. Bristow 5 Apr 11
       }
 
       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);
         }
       } // void get_signed
 
       template<class ValType> void get_unsigned
       ( //! Get an unsigned floating-point value into val,
         //! but checking for letters indicating non-finites.
         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: // Got a normal floating-point value into val.
           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;
         }
       } //  get_unsigned
 
       //..........................................................................
 
       template<class ValType> void get_i
       ( // Get the rest of all strings starting with 'i', expect "inf", "infinity".
         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"))
         { // Expected "infinity"
           state |= std::ios_base::failbit;
           return;
         }
 
         val = std::numeric_limits<ValType>::infinity(); // "infinity"
       } // void get_i
 
       template<class ValType> void get_n
       ( // Get expected strings after 'n', "nan", "nanq", "nans", "nan(...)"
         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 '(':   // Optional payload field in (...) follows.
          {
             ++it;
             char c;
             while((c = peek_char(it, end, ct))
               && c != ')' && c != ' ' && c != '\n' && c != '\t')
               ++it;
             if(c != ')')
             { // Optional payload field terminator missing!
               state |= std::ios_base::failbit;
               return;
             }
             ++it;
             break;  // "nan(...)"
           }
 
         default:
           break;  // "nan"
         }
 
         val = positive_nan<ValType>();
       } // void get_n
 
       template<class ValType> void get_q
       ( // Get expected rest of string starting with 'q': "qnan".
         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"
       } //  void get_q
 
       template<class ValType> void get_one_hash
       ( // Get expected string after having read "1.#": "1.#IND", "1.#QNAN", "1.#SNAN".
         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': // from IND (indeterminate), considered same a QNAN.
           get_one_hash_i(it, end, ct, state, val); // "1.#IND"
           return;
 
         case 'q': // from QNAN
         case 's': // from SNAN - treated the same as QNAN.
           if(std::numeric_limits<ValType>::has_quiet_NaN
             && !(flags_ & trap_nan))
           {
             ++it;
             if(match_string(it, end, ct, "nan"))
             { // "1.#QNAN", "1.#SNAN"
  //             ++it; // removed as caused assert() cannot increment iterator).
 // (match_string consumes string, so not needed?).
 // https://svn.boost.org/trac/boost/ticket/5467
 // Change in nonfinite_num_facet.hpp Paul A. Bristow 11 Apr 11 makes legacy_test.cpp work OK.
               val = positive_nan<ValType>(); // "1.#QNAN"
               return;
             }
           }
           break;
 
         default:
           break;
         }
 
         state |= std::ios_base::failbit;
       } //  void get_one_hash
 
       template<class ValType> void get_one_hash_i
       ( // Get expected strings after 'i', "1.#INF", 1.#IND".
         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;
       } //  void get_one_hash_i
 
       //..........................................................................
 
       char peek_char
       ( //! \return next char in the input buffer, ensuring lowercase (but do not 'consume' char).
         InputIterator& it, InputIterator end,
         const std::ctype<CharType>& ct
       ) const
       {
         if(it == end) return 0;
         return ct.narrow(ct.tolower(*it), 0); // Always tolower to ensure case insensitive.
       }
 
       bool match_string
       ( //! Match remaining chars to expected string (case insensitive),
         //! consuming chars that match OK.
         //! \return true if matched expected string, else false.
         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;
       } // bool match_string
 
       const int flags_;
     }; //
 
     //------------------------------------------------------------------------------
 
   }   // namespace math
 }   // namespace boost
 
 #ifdef _MSC_VER
 #   pragma warning(pop)
 #endif
 
 #endif // BOOST_MATH_NONFINITE_NUM_FACETS_HPP
 

This page was automatically generated by the 2.3.7 LXR engine. The LXR team