Debian Codegraph @

third-party/boost-math/include/boost/math/special_functions/nonfinite_num_facets.hpp

raw
1 #ifndef BOOST_MATH_NONFINITE_NUM_FACETS_HPP
2 #define BOOST_MATH_NONFINITE_NUM_FACETS_HPP
3
4 // Copyright 2006 Johan Rade
5 // Copyright 2012 K R Walker
6 // Copyright 2011, 2012 Paul A. Bristow
7
8 // Distributed under the Boost Software License, Version 1.0.
9 // (See accompanying file LICENSE_1_0.txt
10 // or copy at http://www.boost.org/LICENSE_1_0.txt)
11
12 /*
13 \file
14
15 \brief non_finite_num facets for C99 standard output of infinity and NaN.
16
17 \details See fuller documentation at Boost.Math Facets
18 for Floating-Point Infinities and NaNs.
19 */
20
21 #include <cstring>
22 #include <ios>
23 #include <limits>
24 #include <locale>
25 #include <boost/math/tools/throw_exception.hpp>
26 #include <boost/math/special_functions/fpclassify.hpp>
27 #include <boost/math/special_functions/sign.hpp>
28
29 #ifdef _MSC_VER
30 # pragma warning(push)
31 # pragma warning(disable : 4127) // conditional expression is constant.
32 # pragma warning(disable : 4706) // assignment within conditional expression.
33 #endif
34
35 namespace boost {
36 namespace math {
37
38 // flags (enums can be ORed together) -----------------------------------
39
40 const int legacy = 0x1; //!< get facet will recognize most string representations of infinity and NaN.
41 const int signed_zero = 0x2; //!< put facet will distinguish between positive and negative zero.
42 const int trap_infinity = 0x4; /*!< put facet will throw an exception of type std::ios_base::failure
43 when an attempt is made to format positive or negative infinity.
44 get will set the fail bit of the stream when an attempt is made
45 to parse a string that represents positive or negative sign infinity.
46 */
47 const int trap_nan = 0x8; /*!< put facet will throw an exception of type std::ios_base::failure
48 when an attempt is made to format positive or negative NaN.
49 get will set the fail bit of the stream when an attempt is made
50 to parse a string that represents positive or negative sign infinity.
51 */
52
53 // class nonfinite_num_put -----------------------------------------------------
54
55 template<
56 class CharType,
57 class OutputIterator = std::ostreambuf_iterator<CharType>
58 >
59 class nonfinite_num_put : public std::num_put<CharType, OutputIterator>
60 {
61 public:
62 explicit nonfinite_num_put(int flags = 0) : flags_(flags) {}
63
64 protected:
65 virtual OutputIterator do_put(
66 OutputIterator it, std::ios_base& iosb, CharType fill, double val) const
67 {
68 put_and_reset_width(it, iosb, fill, val);
69 return it;
70 }
71
72 virtual OutputIterator do_put(
73 OutputIterator it, std::ios_base& iosb, CharType fill, long double val) const
74 {
75 put_and_reset_width(it, iosb, fill, val);
76 return it;
77 }
78
79 private:
80 template<class ValType> void put_and_reset_width(
81 OutputIterator& it, std::ios_base& iosb,
82 CharType fill, ValType val) const
83 {
84 put_impl(it, iosb, fill, val);
85 iosb.width(0);
86 }
87
88 template<class ValType> void put_impl(
89 OutputIterator& it, std::ios_base& iosb,
90 CharType fill, ValType val) const
91 {
92 static const CharType prefix_plus[2] = { '+', '\0' };
93 static const CharType prefix_minus[2] = { '-', '\0' };
94 static const CharType body_inf[4] = { 'i', 'n', 'f', '\0' };
95 static const CharType body_nan[4] = { 'n', 'a', 'n', '\0' };
96 static const CharType* null_string = 0;
97
98 switch((boost::math::fpclassify)(val))
99 {
100
101 case FP_INFINITE:
102 if(flags_ & trap_infinity)
103 {
104 BOOST_MATH_THROW_EXCEPTION(std::ios_base::failure("Infinity"));
105 }
106 else if((boost::math::signbit)(val))
107 { // negative infinity.
108 put_num_and_fill(it, iosb, prefix_minus, body_inf, fill, val);
109 }
110 else if(iosb.flags() & std::ios_base::showpos)
111 { // Explicit "+inf" wanted.
112 put_num_and_fill(it, iosb, prefix_plus, body_inf, fill, val);
113 }
114 else
115 { // just "inf" wanted.
116 put_num_and_fill(it, iosb, null_string, body_inf, fill, val);
117 }
118 break;
119
120 case FP_NAN:
121 if(flags_ & trap_nan)
122 {
123 BOOST_MATH_THROW_EXCEPTION(std::ios_base::failure("NaN"));
124 }
125 else if((boost::math::signbit)(val))
126 { // negative so "-nan".
127 put_num_and_fill(it, iosb, prefix_minus, body_nan, fill, val);
128 }
129 else if(iosb.flags() & std::ios_base::showpos)
130 { // explicit "+nan" wanted.
131 put_num_and_fill(it, iosb, prefix_plus, body_nan, fill, val);
132 }
133 else
134 { // Just "nan".
135 put_num_and_fill(it, iosb, null_string, body_nan, fill, val);
136 }
137 break;
138
139 case FP_ZERO:
140 if((flags_ & signed_zero) && ((boost::math::signbit)(val)))
141 { // Flag set to distinguish between positive and negative zero.
142 // But string "0" should have stuff after decimal point if setprecision and/or exp format.
143
144 std::basic_ostringstream<CharType> zeros; // Needs to be CharType version.
145
146 // Copy flags, fill, width and precision.
147 zeros.flags(iosb.flags());
148 zeros.unsetf(std::ios::showpos); // Ignore showpos because must be negative.
149 zeros.precision(iosb.precision());
150 //zeros.width is set by put_num_and_fill
151 zeros.fill(static_cast<char>(fill));
152 zeros << ValType(0);
153 put_num_and_fill(it, iosb, prefix_minus, zeros.str().c_str(), fill, val);
154 }
155 else
156 { // Output the platform default for positive and negative zero.
157 put_num_and_fill(it, iosb, null_string, null_string, fill, val);
158 }
159 break;
160
161 default: // Normal non-zero finite value.
162 it = std::num_put<CharType, OutputIterator>::do_put(it, iosb, fill, val);
163 break;
164 }
165 }
166
167 template<class ValType>
168 void put_num_and_fill(
169 OutputIterator& it, std::ios_base& iosb, const CharType* prefix,
170 const CharType* body, CharType fill, ValType val) const
171 {
172 int prefix_length = prefix ? (int)std::char_traits<CharType>::length(prefix) : 0;
173 int body_length = body ? (int)std::char_traits<CharType>::length(body) : 0;
174 int width = prefix_length + body_length;
175 std::ios_base::fmtflags adjust = iosb.flags() & std::ios_base::adjustfield;
176 const std::ctype<CharType>& ct
177 = std::use_facet<std::ctype<CharType> >(iosb.getloc());
178
179 if(body || prefix)
180 { // adjust == std::ios_base::right, so leading fill needed.
181 if(adjust != std::ios_base::internal && adjust != std::ios_base::left)
182 put_fill(it, iosb, fill, width);
183 }
184
185 if(prefix)
186 { // Adjust width for prefix.
187 while(*prefix)
188 *it = *(prefix++);
189 iosb.width( iosb.width() - prefix_length );
190 width -= prefix_length;
191 }
192
193 if(body)
194 { //
195 if(adjust == std::ios_base::internal)
196 { // Put fill between sign and digits.
197 put_fill(it, iosb, fill, width);
198 }
199 if(iosb.flags() & std::ios_base::uppercase)
200 {
201 while(*body)
202 *it = ct.toupper(*(body++));
203 }
204 else
205 {
206 while(*body)
207 *it = *(body++);
208 }
209
210 if(adjust == std::ios_base::left)
211 put_fill(it, iosb, fill, width);
212 }
213 else
214 {
215 it = std::num_put<CharType, OutputIterator>::do_put(it, iosb, fill, val);
216 }
217 }
218
219 void put_fill(
220 OutputIterator& it, std::ios_base& iosb, CharType fill, int width) const
221 { // Insert fill chars.
222 for(std::streamsize i = iosb.width() - static_cast<std::streamsize>(width); i > 0; --i)
223 *it = fill;
224 }
225
226 const int flags_;
227 };
228
229
230 // class nonfinite_num_get ------------------------------------------------------
231
232 template<
233 class CharType,
234 class InputIterator = std::istreambuf_iterator<CharType>
235 >
236 class nonfinite_num_get : public std::num_get<CharType, InputIterator>
237 {
238
239 public:
240 explicit nonfinite_num_get(int flags = 0) : flags_(flags)
241 {}
242
243 protected: // float, double and long double versions of do_get.
244 virtual InputIterator do_get(
245 InputIterator it, InputIterator end, std::ios_base& iosb,
246 std::ios_base::iostate& state, float& val) const
247 {
248 get_and_check_eof(it, end, iosb, state, val);
249 return it;
250 }
251
252 virtual InputIterator do_get(
253 InputIterator it, InputIterator end, std::ios_base& iosb,
254 std::ios_base::iostate& state, double& val) const
255 {
256 get_and_check_eof(it, end, iosb, state, val);
257 return it;
258 }
259
260 virtual InputIterator do_get(
261 InputIterator it, InputIterator end, std::ios_base& iosb,
262 std::ios_base::iostate& state, long double& val) const
263 {
264 get_and_check_eof(it, end, iosb, state, val);
265 return it;
266 }
267
268 //..............................................................................
269
270 private:
271 template<class ValType> static ValType positive_nan()
272 {
273 // On some platforms quiet_NaN() may be negative.
274 return (boost::math::copysign)(
275 std::numeric_limits<ValType>::quiet_NaN(), static_cast<ValType>(1)
276 );
277 // static_cast<ValType>(1) added Paul A. Bristow 5 Apr 11
278 }
279
280 template<class ValType> void get_and_check_eof
281 (
282 InputIterator& it, InputIterator end, std::ios_base& iosb,
283 std::ios_base::iostate& state, ValType& val
284 ) const
285 {
286 get_signed(it, end, iosb, state, val);
287 if(it == end)
288 state |= std::ios_base::eofbit;
289 }
290
291 template<class ValType> void get_signed
292 (
293 InputIterator& it, InputIterator end, std::ios_base& iosb,
294 std::ios_base::iostate& state, ValType& val
295 ) const
296 {
297 const std::ctype<CharType>& ct
298 = std::use_facet<std::ctype<CharType> >(iosb.getloc());
299
300 char c = peek_char(it, end, ct);
301
302 bool negative = (c == '-');
303
304 if(negative || c == '+')
305 {
306 ++it;
307 c = peek_char(it, end, ct);
308 if(c == '-' || c == '+')
309 { // Without this check, "++5" etc would be accepted.
310 state |= std::ios_base::failbit;
311 return;
312 }
313 }
314
315 get_unsigned(it, end, iosb, ct, state, val);
316
317 if(negative)
318 {
319 val = (boost::math::changesign)(val);
320 }
321 } // void get_signed
322
323 template<class ValType> void get_unsigned
324 ( //! Get an unsigned floating-point value into val,
325 //! but checking for letters indicating non-finites.
326 InputIterator& it, InputIterator end, std::ios_base& iosb,
327 const std::ctype<CharType>& ct,
328 std::ios_base::iostate& state, ValType& val
329 ) const
330 {
331 switch(peek_char(it, end, ct))
332 {
333 case 'i':
334 get_i(it, end, ct, state, val);
335 break;
336
337 case 'n':
338 get_n(it, end, ct, state, val);
339 break;
340
341 case 'q':
342 case 's':
343 get_q(it, end, ct, state, val);
344 break;
345
346 default: // Got a normal floating-point value into val.
347 it = std::num_get<CharType, InputIterator>::do_get(
348 it, end, iosb, state, val);
349 if((flags_ & legacy) && val == static_cast<ValType>(1)
350 && peek_char(it, end, ct) == '#')
351 get_one_hash(it, end, ct, state, val);
352 break;
353 }
354 } // get_unsigned
355
356 //..........................................................................
357
358 template<class ValType> void get_i
359 ( // Get the rest of all strings starting with 'i', expect "inf", "infinity".
360 InputIterator& it, InputIterator end, const std::ctype<CharType>& ct,
361 std::ios_base::iostate& state, ValType& val
362 ) const
363 {
364 if(!std::numeric_limits<ValType>::has_infinity
365 || (flags_ & trap_infinity))
366 {
367 state |= std::ios_base::failbit;
368 return;
369 }
370
371 ++it;
372 if(!match_string(it, end, ct, "nf"))
373 {
374 state |= std::ios_base::failbit;
375 return;
376 }
377
378 if(peek_char(it, end, ct) != 'i')
379 {
380 val = std::numeric_limits<ValType>::infinity(); // "inf"
381 return;
382 }
383
384 ++it;
385 if(!match_string(it, end, ct, "nity"))
386 { // Expected "infinity"
387 state |= std::ios_base::failbit;
388 return;
389 }
390
391 val = std::numeric_limits<ValType>::infinity(); // "infinity"
392 } // void get_i
393
394 template<class ValType> void get_n
395 ( // Get expected strings after 'n', "nan", "nanq", "nans", "nan(...)"
396 InputIterator& it, InputIterator end, const std::ctype<CharType>& ct,
397 std::ios_base::iostate& state, ValType& val
398 ) const
399 {
400 if(!std::numeric_limits<ValType>::has_quiet_NaN
401 || (flags_ & trap_nan)) {
402 state |= std::ios_base::failbit;
403 return;
404 }
405
406 ++it;
407 if(!match_string(it, end, ct, "an"))
408 {
409 state |= std::ios_base::failbit;
410 return;
411 }
412
413 switch(peek_char(it, end, ct)) {
414 case 'q':
415 case 's':
416 if(flags_ & legacy)
417 ++it;
418 break; // "nanq", "nans"
419
420 case '(': // Optional payload field in (...) follows.
421 {
422 ++it;
423 char c;
424 while((c = peek_char(it, end, ct))
425 && c != ')' && c != ' ' && c != '\n' && c != '\t')
426 ++it;
427 if(c != ')')
428 { // Optional payload field terminator missing!
429 state |= std::ios_base::failbit;
430 return;
431 }
432 ++it;
433 break; // "nan(...)"
434 }
435
436 default:
437 break; // "nan"
438 }
439
440 val = positive_nan<ValType>();
441 } // void get_n
442
443 template<class ValType> void get_q
444 ( // Get expected rest of string starting with 'q': "qnan".
445 InputIterator& it, InputIterator end, const std::ctype<CharType>& ct,
446 std::ios_base::iostate& state, ValType& val
447 ) const
448 {
449 if(!std::numeric_limits<ValType>::has_quiet_NaN
450 || (flags_ & trap_nan) || !(flags_ & legacy))
451 {
452 state |= std::ios_base::failbit;
453 return;
454 }
455
456 ++it;
457 if(!match_string(it, end, ct, "nan"))
458 {
459 state |= std::ios_base::failbit;
460 return;
461 }
462
463 val = positive_nan<ValType>(); // "QNAN"
464 } // void get_q
465
466 template<class ValType> void get_one_hash
467 ( // Get expected string after having read "1.#": "1.#IND", "1.#QNAN", "1.#SNAN".
468 InputIterator& it, InputIterator end, const std::ctype<CharType>& ct,
469 std::ios_base::iostate& state, ValType& val
470 ) const
471 {
472
473 ++it;
474 switch(peek_char(it, end, ct))
475 {
476 case 'i': // from IND (indeterminate), considered same a QNAN.
477 get_one_hash_i(it, end, ct, state, val); // "1.#IND"
478 return;
479
480 case 'q': // from QNAN
481 case 's': // from SNAN - treated the same as QNAN.
482 if(std::numeric_limits<ValType>::has_quiet_NaN
483 && !(flags_ & trap_nan))
484 {
485 ++it;
486 if(match_string(it, end, ct, "nan"))
487 { // "1.#QNAN", "1.#SNAN"
488 // ++it; // removed as caused assert() cannot increment iterator).
489 // (match_string consumes string, so not needed?).
490 // https://svn.boost.org/trac/boost/ticket/5467
491 // Change in nonfinite_num_facet.hpp Paul A. Bristow 11 Apr 11 makes legacy_test.cpp work OK.
492 val = positive_nan<ValType>(); // "1.#QNAN"
493 return;
494 }
495 }
496 break; // LCOV_EXCL_LINE simple fallthrough not registered as covered.
497
498 default:
499 break; // LCOV_EXCL_LINE simple fallthrough not registered as covered.
500 }
501
502 state |= std::ios_base::failbit;
503 } // void get_one_hash
504
505 template<class ValType> void get_one_hash_i
506 ( // Get expected strings after 'i', "1.#INF", 1.#IND".
507 InputIterator& it, InputIterator end, const std::ctype<CharType>& ct,
508 std::ios_base::iostate& state, ValType& val
509 ) const
510 {
511 ++it;
512
513 if(peek_char(it, end, ct) == 'n')
514 {
515 ++it;
516 switch(peek_char(it, end, ct))
517 {
518 case 'f': // "1.#INF"
519 if(std::numeric_limits<ValType>::has_infinity
520 && !(flags_ & trap_infinity))
521 {
522 ++it;
523 val = std::numeric_limits<ValType>::infinity();
524 return;
525 }
526 break; // LCOV_EXCL_LINE simple fallthrough not registered as covered.
527
528 case 'd': // 1.#IND"
529 if(std::numeric_limits<ValType>::has_quiet_NaN
530 && !(flags_ & trap_nan))
531 {
532 ++it;
533 val = positive_nan<ValType>();
534 return;
535 }
536 break; // LCOV_EXCL_LINE simple fallthrough not registered as covered.
537
538 default: // LCOV_EXCL_LINE simple fallthrough not registered as covered.
539 break; // LCOV_EXCL_LINE simple fallthrough not registered as covered.
540 }
541 }
542
543 state |= std::ios_base::failbit;
544 } // void get_one_hash_i
545
546 //..........................................................................
547
548 char peek_char
549 ( //! \return next char in the input buffer, ensuring lowercase (but do not 'consume' char).
550 InputIterator& it, InputIterator end,
551 const std::ctype<CharType>& ct
552 ) const
553 {
554 if(it == end) return 0;
555 return ct.narrow(ct.tolower(*it), 0); // Always tolower to ensure case insensitive.
556 }
557
558 bool match_string
559 ( //! Match remaining chars to expected string (case insensitive),
560 //! consuming chars that match OK.
561 //! \return true if matched expected string, else false.
562 InputIterator& it, InputIterator end,
563 const std::ctype<CharType>& ct,
564 const char* s
565 ) const
566 {
567 while(it != end && *s && *s == ct.narrow(ct.tolower(*it), 0))
568 {
569 ++s;
570 ++it; //
571 }
572 return !*s;
573 } // bool match_string
574
575 const int flags_;
576 }; //
577
578 //------------------------------------------------------------------------------
579
580 } // namespace math
581 } // namespace boost
582
583 #ifdef _MSC_VER
584 # pragma warning(pop)
585 #endif
586
587 #endif // BOOST_MATH_NONFINITE_NUM_FACETS_HPP
588