1#ifndef BOOST_NUMERIC_CHECKED_RESULT_OPERATIONS
2#define BOOST_NUMERIC_CHECKED_RESULT_OPERATIONS
3
4// Copyright (c) 2012 Robert Ramey
5//
6// Distributed under the Boost Software License, Version 1.0. (See
7// accompanying file LICENSE_1_0.txt or copy at
8// http://www.boost.org/LICENSE_1_0.txt)
9
10// Implemenation of arithmetic on "extended" integers.
11// Extended integers are defined in terms of C++ primitive integers as
12// a) an interger range
13// b) extra elements +inf, -inf, indeterminate
14//
15// Integer operations are closed on the set of extended integers
16// but operations are not necessarily associative when they result in the
17// extensions +inf, -inf, and indeterminate
18//
19// in this code, the type "checked_result<T>" where T is some
20// integer type is an "extended" integer.
21
22#include <cassert>
23
24#include <boost/logic/tribool.hpp>
25
26#include "checked_result.hpp"
27#include "checked_integer.hpp"
28
29//////////////////////////////////////////////////////////////////////////
30// the following idea of "value_type" is used by several of the operations
31// defined by checked_result arithmetic.
32
33namespace boost {
34namespace safe_numerics {
35
36template<typename T>
37constexpr inline void display(const boost::safe_numerics::checked_result<T> & c){
38 switch(c.m_e){
39 case safe_numerics_error::success:
40 std::terminate();
41 case safe_numerics_error::positive_overflow_error: // result is above representational maximum
42 std::terminate();
43 case safe_numerics_error::negative_overflow_error: // result is below representational minimum
44 std::terminate();
45 case safe_numerics_error::domain_error: // one operand is out of valid range
46 std::terminate();
47 case safe_numerics_error::range_error: // result cannot be produced for this operation
48 std::terminate();
49 case safe_numerics_error::precision_overflow_error: // result lost precision
50 std::terminate();
51 case safe_numerics_error::underflow_error: // result is too small to be represented
52 std::terminate();
53 case safe_numerics_error::negative_value_shift: // negative value in shift operator
54 std::terminate();
55 case safe_numerics_error::negative_shift: // shift a negative value
56 std::terminate();
57 case safe_numerics_error::shift_too_large: // l/r shift exceeds variable size
58 std::terminate();
59 case safe_numerics_error::uninitialized_value: // creating of uninitialized value
60 std::terminate();
61 }
62}
63
64//////////////////////////////////////////////////////////////////////////
65// implement C++ operators for check_result<T>
66
67struct sum_value_type {
68 // characterization of various values
69 const enum flag {
70 known_value = 0,
71 less_than_min,
72 greater_than_max,
73 indeterminate,
74 count
75 } m_flag;
76 template<class T>
77 constexpr flag to_flag(const checked_result<T> & t) const {
78 switch(static_cast<safe_numerics_error>(t)){
79 case safe_numerics_error::success:
80 return known_value;
81 case safe_numerics_error::negative_overflow_error:
82 // result is below representational minimum
83 return less_than_min;
84 case safe_numerics_error::positive_overflow_error:
85 // result is above representational maximum
86 return greater_than_max;
87 default:
88 return indeterminate;
89 }
90 }
91 template<class T>
92 constexpr sum_value_type(const checked_result<T> & t) :
93 m_flag(to_flag(t))
94 {}
95 constexpr operator std::uint8_t () const {
96 return static_cast<std::uint8_t>(m_flag);
97 }
98};
99
100// integers addition
101template<class T>
102typename std::enable_if<
103 std::is_integral<T>::value,
104 checked_result<T>
105>::type
106constexpr inline operator+(
107 const checked_result<T> & t,
108 const checked_result<T> & u
109){
110 using value_type = sum_value_type;
111 const std::uint8_t order = static_cast<std::uint8_t>(value_type::count);
112
113 // note major pain. Clang constexpr multi-dimensional array is fine.
114 // but gcc doesn't permit a multi-dimensional array to be be constexpr.
115 // so we need to some ugly gymnastics to make our system work for all
116 // all systems.
117 const enum safe_numerics_error result[order * order] = {
118 // t == known_value
119 //{
120 // u == ...
121 safe_numerics_error::success, // known_value,
122 safe_numerics_error::negative_overflow_error, // less_than_min,
123 safe_numerics_error::positive_overflow_error, // greater_than_max,
124 safe_numerics_error::range_error, // indeterminate,
125 //},
126 // t == less_than_min,
127 //{
128 // u == ...
129 safe_numerics_error::negative_overflow_error, // known_value,
130 safe_numerics_error::negative_overflow_error, // less_than_min,
131 safe_numerics_error::range_error, // greater_than_max,
132 safe_numerics_error::range_error, // indeterminate,
133 //},
134 // t == greater_than_max,
135 //{
136 // u == ...
137 safe_numerics_error::positive_overflow_error, // known_value,
138 safe_numerics_error::range_error, // less_than_min,
139 safe_numerics_error::positive_overflow_error, // greater_than_max,
140 safe_numerics_error::range_error, // indeterminate,
141 //},
142 // t == indeterminate,
143 //{
144 // u == ...
145 safe_numerics_error::range_error, // known_value,
146 safe_numerics_error::range_error, // less_than_min,
147 safe_numerics_error::range_error, // greater_than_max,
148 safe_numerics_error::range_error, // indeterminate,
149 //},
150 };
151
152 const value_type tx(t);
153 const value_type ux(u);
154
155 const safe_numerics_error e = result[tx * order + ux];
156 if(safe_numerics_error::success == e)
157 return checked::add<T>(t, u);
158 return checked_result<T>(e, "addition result");
159}
160
161// unary +
162template<class T>
163typename std::enable_if<
164 std::is_integral<T>::value,
165 checked_result<T>
166>::type
167constexpr inline operator+(
168 const checked_result<T> & t
169){
170 return t;
171}
172
173// integers subtraction
174template<class T>
175typename std::enable_if<
176 std::is_integral<T>::value,
177 checked_result<T>
178>::type
179constexpr inline operator-(
180 const checked_result<T> & t,
181 const checked_result<T> & u
182){
183 using value_type = sum_value_type;
184 constexpr const std::uint8_t order = static_cast<std::uint8_t>(value_type::count);
185
186 constexpr const enum safe_numerics_error result[order * order] = {
187 // t == known_value
188 //{
189 // u == ...
190 safe_numerics_error::success, // known_value,
191 safe_numerics_error::positive_overflow_error, // less_than_min,
192 safe_numerics_error::negative_overflow_error, // greater_than_max,
193 safe_numerics_error::range_error, // indeterminate,
194 //},
195 // t == less_than_min,
196 //{
197 // u == ...
198 safe_numerics_error::negative_overflow_error, // known_value,
199 safe_numerics_error::range_error, // less_than_min,
200 safe_numerics_error::negative_overflow_error, // greater_than_max,
201 safe_numerics_error::range_error, // indeterminate,
202 //},
203 // t == greater_than_max,
204 //{
205 // u == ...
206 safe_numerics_error::positive_overflow_error, // known_value,
207 safe_numerics_error::positive_overflow_error, // less_than_min,
208 safe_numerics_error::range_error, // greater_than_max,
209 safe_numerics_error::range_error, // indeterminate,
210 //},
211 // t == indeterminate,
212 //{
213 // u == ...
214 safe_numerics_error::range_error, // known_value,
215 safe_numerics_error::range_error, // less_than_min,
216 safe_numerics_error::range_error, // greater_than_max,
217 safe_numerics_error::range_error, // indeterminate,
218 //},
219 };
220
221 const value_type tx(t);
222 const value_type ux(u);
223
224 const safe_numerics_error e = result[tx * order + ux];
225 if(safe_numerics_error::success == e)
226 return checked::subtract<T>(t, u);
227 return checked_result<T>(e, "subtraction result");
228}
229
230// unary -
231template<class T>
232typename std::enable_if<
233 std::is_integral<T>::value,
234 checked_result<T>
235>::type
236constexpr inline operator-(
237 const checked_result<T> & t
238){
239// assert(false);
240 return checked_result<T>(0) - t;
241}
242
243struct product_value_type {
244 // characterization of various values
245 const enum flag {
246 less_than_min = 0,
247 less_than_zero,
248 zero,
249 greater_than_zero,
250 greater_than_max,
251 indeterminate,
252 // count of number of cases for values
253 count,
254 // temporary values for special cases
255 t_value,
256 u_value,
257 z_value
258 } m_flag;
259 template<class T>
260 constexpr flag to_flag(const checked_result<T> & t) const {
261 switch(static_cast<safe_numerics_error>(t)){
262 case safe_numerics_error::success:
263 return (t < checked_result<T>(0))
264 ? less_than_zero
265 : (t > checked_result<T>(0))
266 ? greater_than_zero
267 : zero;
268 case safe_numerics_error::negative_overflow_error:
269 // result is below representational minimum
270 return less_than_min;
271 case safe_numerics_error::positive_overflow_error:
272 // result is above representational maximum
273 return greater_than_max;
274 default:
275 return indeterminate;
276 }
277 }
278 template<class T>
279 constexpr product_value_type(const checked_result<T> & t) :
280 m_flag(to_flag(t))
281 {}
282 constexpr operator std::uint8_t () const {
283 return static_cast<std::uint8_t>(m_flag);
284 }
285};
286
287// integers multiplication
288template<class T>
289typename std::enable_if<
290 std::is_integral<T>::value,
291 checked_result<T>
292>::type
293constexpr inline operator*(
294 const checked_result<T> & t,
295 const checked_result<T> & u
296){
297 using value_type = product_value_type;
298 const std::uint8_t order = static_cast<std::uint8_t>(value_type::count);
299
300 constexpr const enum value_type::flag result[order * order] = {
301 // t == less_than_min
302 //{
303 // u == ...
304 value_type::greater_than_max, // less_than_min,
305 value_type::greater_than_max, // less_than_zero,
306 value_type::zero, // zero,
307 value_type::less_than_min, // greater_than_zero,
308 value_type::less_than_min, // greater than max,
309 value_type::indeterminate, // indeterminate,
310 //},
311 // t == less_than_zero,
312 //{
313 // u == ...
314 value_type::greater_than_max, // less_than_min,
315 value_type::greater_than_zero, // less_than_zero,
316 value_type::zero, // zero,
317 value_type::less_than_zero, // greater_than_zero,
318 value_type::less_than_min, // greater than max,
319 value_type::indeterminate, // indeterminate,
320 //},
321 // t == zero,
322 //{
323 // u == ...
324 value_type::zero, // less_than_min,
325 value_type::zero, // less_than_zero,
326 value_type::zero, // zero,
327 value_type::zero, // greater_than_zero,
328 value_type::zero, // greater than max,
329 value_type::indeterminate, // indeterminate,
330 //},
331 // t == greater_than_zero,
332 //{
333 // u == ...
334 value_type::less_than_min, // less_than_min,
335 value_type::less_than_zero, // less_than_zero,
336 value_type::zero, // zero,
337 value_type::greater_than_zero, // greater_than_zero,
338 value_type::greater_than_max, // greater than max,
339 value_type::indeterminate, // indeterminate,
340 //},
341 // t == greater_than_max
342 //{
343 value_type::less_than_min, // less_than_min,
344 value_type::less_than_min, // less_than_zero,
345 value_type::zero, // zero,
346 value_type::greater_than_max, // greater_than_zero,
347 value_type::greater_than_max, // greater than max,
348 value_type::indeterminate, // indeterminate,
349 //},
350 // t == indeterminate
351 //{
352 value_type::indeterminate, // less_than_min,
353 value_type::indeterminate, // less_than_zero,
354 value_type::indeterminate, // zero,
355 value_type::indeterminate, // greater_than_zero,
356 value_type::indeterminate, // greater than max,
357 value_type::indeterminate, // indeterminate,
358 //}
359 };
360
361 const value_type tx(t);
362 const value_type ux(u);
363
364 switch(result[tx * order + ux]){
365 case value_type::less_than_min:
366 return safe_numerics_error::negative_overflow_error;
367 case value_type::zero:
368 return T(0);
369 case value_type::greater_than_max:
370 return safe_numerics_error::positive_overflow_error;
371 case value_type::less_than_zero:
372 case value_type::greater_than_zero:
373 return checked::multiply<T>(t, u);
374 case value_type::indeterminate:
375 return safe_numerics_error::range_error;
376 default:
377 assert(false);
378 }
379 return checked_result<T>(0); // to suppress msvc warning
380}
381
382// integers division
383template<class T>
384typename std::enable_if<
385 std::is_integral<T>::value,
386 checked_result<T>
387>::type
388constexpr inline operator/(
389 const checked_result<T> & t,
390 const checked_result<T> & u
391){
392 using value_type = product_value_type;
393 const std::uint8_t order = static_cast<std::uint8_t>(value_type::count);
394
395 constexpr const enum value_type::flag result[order * order] = {
396 // t == less_than_min
397 //{
398 // u == ...
399 value_type::indeterminate, // less_than_min,
400 value_type::greater_than_max, // less_than_zero,
401 value_type::less_than_min, // zero,
402 value_type::less_than_min, // greater_than_zero,
403 value_type::less_than_min, // greater than max,
404 value_type::indeterminate, // indeterminate,
405 //},
406 // t == less_than_zero,
407 //{
408 // u == ...
409 value_type::zero, // less_than_min,
410 value_type::greater_than_zero, // less_than_zero,
411 value_type::less_than_min, // zero,
412 value_type::less_than_zero, // greater_than_zero,
413 value_type::zero, // greater than max,
414 value_type::indeterminate, // indeterminate,
415 //},
416 // t == zero,
417 //{
418 // u == ...
419 value_type::zero, // less_than_min,
420 value_type::zero, // less_than_zero,
421 value_type::indeterminate, // zero,
422 value_type::zero, // greater_than_zero,
423 value_type::zero, // greater than max,
424 value_type::indeterminate, // indeterminate,
425 //},
426 // t == greater_than_zero,
427 //{
428 // u == ...
429 value_type::zero, // less_than_min,
430 value_type::less_than_zero, // less_than_zero,
431 value_type::greater_than_max, // zero,
432 value_type::greater_than_zero, // greater_than_zero,
433 value_type::zero, // greater than max,
434 value_type::indeterminate, // indeterminate,
435 //},
436 // t == greater_than_max
437 //{
438 value_type::less_than_min, // less_than_min,
439 value_type::less_than_min, // less_than_zero,
440 value_type::greater_than_max, // zero,
441 value_type::greater_than_max, // greater_than_zero,
442 value_type::indeterminate, // greater than max,
443 value_type::indeterminate, // indeterminate,
444 //},
445 // t == indeterminate
446 //{
447 value_type::indeterminate, // less_than_min,
448 value_type::indeterminate, // less_than_zero,
449 value_type::indeterminate, // zero,
450 value_type::indeterminate, // greater_than_zero,
451 value_type::indeterminate, // greater than max,
452 value_type::indeterminate, // indeterminate,
453 //}
454 };
455
456 const value_type tx(t);
457 const value_type ux(u);
458
459 switch(result[tx * order + ux]){
460 case value_type::less_than_min:
461 return safe_numerics_error::negative_overflow_error;
462 case value_type::zero:
463 return 0;
464 case value_type::greater_than_max:
465 return safe_numerics_error::positive_overflow_error;
466 case value_type::less_than_zero:
467 case value_type::greater_than_zero:
468 return checked::divide<T>(t, u);
469 case value_type::indeterminate:
470 return safe_numerics_error::range_error;
471 default:
472 assert(false);
473 }
474 return checked_result<T>(0); // to suppress msvc warning
475}
476
477// integers modulus
478template<class T>
479typename std::enable_if<
480 std::is_integral<T>::value,
481 checked_result<T>
482>::type
483constexpr inline operator%(
484 const checked_result<T> & t,
485 const checked_result<T> & u
486){
487 using value_type = product_value_type;
488 const std::uint8_t order = static_cast<std::uint8_t>(value_type::count);
489
490 constexpr const enum value_type::flag result[order * order] = {
491 // t == less_than_min
492 //{
493 // u == ...
494 value_type::indeterminate, // less_than_min,
495 value_type::z_value, // less_than_zero,
496 value_type::indeterminate, // zero,
497 value_type::z_value, // greater_than_zero,
498 value_type::indeterminate, // greater than max,
499 value_type::indeterminate, // indeterminate,
500 //},
501 // t == less_than_zero,
502 //{
503 // u == ...
504 value_type::t_value, // less_than_min,
505 value_type::greater_than_zero, // less_than_zero,
506 value_type::indeterminate, // zero,
507 value_type::less_than_zero, // greater_than_zero,
508 value_type::t_value, // greater than max,
509 value_type::indeterminate, // indeterminate,
510 //},
511 // t == zero,
512 //{
513 // u == ...
514 value_type::zero, // less_than_min,
515 value_type::zero, // less_than_zero,
516 value_type::indeterminate, // zero,
517 value_type::zero, // greater_than_zero,
518 value_type::zero, // greater than max,
519 value_type::indeterminate, // indeterminate,
520 //},
521 // t == greater_than_zero,
522 //{
523 // u == ...
524 value_type::t_value, // less_than_min,
525 value_type::less_than_zero, // less_than_zero,
526 value_type::indeterminate, // zero,
527 value_type::greater_than_zero, // greater_than_zero,
528 value_type::t_value, // greater than max,
529 value_type::indeterminate, // indeterminate,
530 //},
531 // t == greater_than_max
532 //{
533 value_type::indeterminate, // less_than_min,
534 value_type::u_value, // less_than_zero,
535 value_type::indeterminate, // zero,
536 value_type::u_value, // greater_than_zero,
537 value_type::indeterminate, // greater than max,
538 value_type::indeterminate, // indeterminate,
539 //},
540 // t == indeterminate
541 //{
542 value_type::indeterminate, // less_than_min,
543 value_type::indeterminate, // less_than_zero,
544 value_type::indeterminate, // zero,
545 value_type::indeterminate, // greater_than_zero,
546 value_type::indeterminate, // greater than max,
547 value_type::indeterminate, // indeterminate,
548 //}
549 };
550
551 const value_type tx(t);
552 const value_type ux(u);
553
554 switch(result[tx * order + ux]){
555 case value_type::zero:
556 return 0;
557 case value_type::less_than_zero:
558 case value_type::greater_than_zero:
559 return checked::modulus<T>(t, u);
560 case value_type::indeterminate:
561 return safe_numerics_error::range_error;
562 case value_type::t_value:
563 return t;
564 case value_type::u_value:
565 return checked::subtract<T>(u, 1);
566 case value_type::z_value:
567 return checked::subtract<T>(1, u);
568 case value_type::greater_than_max:
569 case value_type::less_than_min:
570 default:
571 assert(false);
572 }
573 // suppress msvc warning
574 return checked_result<T>(0);
575}
576
577// comparison operators
578
579template<class T>
580constexpr boost::logic::tribool operator<(
581 const checked_result<T> & t,
582 const checked_result<T> & u
583){
584 using value_type = sum_value_type;
585 constexpr const std::uint8_t order = static_cast<std::uint8_t>(value_type::count);
586
587 // the question arises about how to order values of type greater_than_min.
588 // that is: what should greater_than_min < greater_than_min return.
589 //
590 // a) return indeterminate because we're talking about the "true" values for
591 // which greater_than_min is a placholder.
592 //
593 // b) return false because the two values are "equal"
594 //
595 // for our purposes, a) seems the better interpretation.
596
597 enum class result_type : std::uint8_t {
598 runtime,
599 false_value,
600 true_value,
601 indeterminate,
602 };
603 constexpr const result_type resultx[order * order]{
604 // t == known_value
605 //{
606 // u == ...
607 result_type::runtime, // known_value,
608 result_type::false_value, // less_than_min,
609 result_type::true_value, // greater_than_max,
610 result_type::indeterminate, // indeterminate,
611 //},
612 // t == less_than_min
613 //{
614 // u == ...
615 result_type::true_value, // known_value,
616 result_type::indeterminate, // less_than_min, see above argument
617 result_type::true_value, // greater_than_max,
618 result_type::indeterminate, // indeterminate,
619 //},
620 // t == greater_than_max
621 //{
622 // u == ...
623 result_type::false_value, // known_value,
624 result_type::false_value, // less_than_min,
625 result_type::indeterminate, // greater_than_max, see above argument
626 result_type::indeterminate, // indeterminate,
627 //},
628 // t == indeterminate
629 //{
630 // u == ...
631 result_type::indeterminate, // known_value,
632 result_type::indeterminate, // less_than_min,
633 result_type::indeterminate, // greater_than_max,
634 result_type::indeterminate, // indeterminate,
635 //},
636 };
637
638 const value_type tx(t);
639 const value_type ux(u);
640
641 switch(resultx[tx * order + ux]){
642 case result_type::runtime:
643 return static_cast<const T &>(t) < static_cast<const T &>(u);
644 case result_type::false_value:
645 return false;
646 case result_type::true_value:
647 return true;
648 case result_type::indeterminate:
649 return boost::logic::indeterminate;
650 default:
651 assert(false);
652 }
653 return true;
654}
655
656template<class T>
657constexpr boost::logic::tribool
658operator>=(
659 const checked_result<T> & t,
660 const checked_result<T> & u
661){
662 return !(t < u);
663}
664
665template<class T>
666constexpr boost::logic::tribool
667operator>(
668 const checked_result<T> & t,
669 const checked_result<T> & u
670){
671 return u < t;
672}
673
674template<class T>
675constexpr boost::logic::tribool
676operator<=(
677 const checked_result<T> & t,
678 const checked_result<T> & u
679){
680 return !(u < t);
681}
682
683template<class T>
684constexpr boost::logic::tribool
685operator==(
686 const checked_result<T> & t,
687 const checked_result<T> & u
688){
689 using value_type = sum_value_type;
690 constexpr const std::uint8_t order = static_cast<std::uint8_t>(value_type::count);
691
692 enum class result_type : std::uint8_t {
693 runtime,
694 false_value,
695 true_value,
696 indeterminate,
697 };
698
699 constexpr const result_type result[order * order]{
700 // t == known_value
701 //{
702 // u == ...
703 result_type::runtime, // known_value,
704 result_type::false_value, // less_than_min,
705 result_type::false_value, // greater_than_max,
706 result_type::indeterminate, // indeterminate,
707 //},
708 // t == less_than_min
709 //{
710 // u == ...
711 result_type::false_value, // known_value,
712 result_type::indeterminate, // less_than_min,
713 result_type::false_value, // greater_than_max,
714 result_type::indeterminate, // indeterminate,
715 //},
716 // t == greater_than_max
717 //{
718 // u == ...
719 result_type::false_value, // known_value,
720 result_type::false_value, // less_than_min,
721 result_type::indeterminate, // greater_than_max,
722 result_type::indeterminate, // indeterminate,
723 //},
724 // t == indeterminate
725 //{
726 // u == ...
727 result_type::indeterminate, // known_value,
728 result_type::indeterminate, // less_than_min,
729 result_type::indeterminate, // greater_than_max,
730 result_type::indeterminate, // indeterminate,
731 //},
732 };
733
734 const value_type tx(t);
735 const value_type ux(u);
736
737 switch(result[tx * order + ux]){
738 case result_type::runtime:
739 return static_cast<const T &>(t) == static_cast<const T &>(u);
740 case result_type::false_value:
741 return false;
742 case result_type::true_value:
743 return true;
744 case result_type::indeterminate:
745 return boost::logic::indeterminate;
746 default:
747 assert(false);
748 }
749 // suppress msvc warning - not all control paths return a value
750 return false;
751}
752
753template<class T>
754constexpr boost::logic::tribool
755operator!=(
756 const checked_result<T> & t,
757 const checked_result<T> & u
758){
759 return ! (t == u);
760}
761
762template<class T>
763typename std::enable_if<
764 std::is_integral<T>::value,
765 checked_result<T>
766>::type
767constexpr inline operator>>(
768 const checked_result<T> & t,
769 const checked_result<T> & u
770);
771
772template<class T>
773typename std::enable_if<
774 std::is_integral<T>::value,
775 checked_result<T>
776>::type
777constexpr inline operator~(
778 const checked_result<T> & t
779){
780// assert(false);
781 return ~t.m_r;
782}
783
784template<class T>
785typename std::enable_if<
786 std::is_integral<T>::value,
787 checked_result<T>
788>::type
789constexpr inline operator<<(
790 const checked_result<T> & t,
791 const checked_result<T> & u
792){
793 using value_type = product_value_type;
794 const std::uint8_t order = static_cast<std::uint8_t>(value_type::count);
795
796 constexpr const std::uint8_t result[order * order] = {
797 // t == less_than_min
798 //{
799 // u == ...
800 1, // -1, // less_than_min,
801 2, // safe_numerics_error::negative_overflow_error, // less_than_zero,
802 2, // safe_numerics_error::negative_overflow_error, // zero,
803 2, // safe_numerics_error::negative_overflow_error, // greater_than_zero,
804 2, // safe_numerics_error::negative_overflow_error, // greater than max,
805 1, // safe_numerics_error::range_error, // indeterminate,
806 //},
807 // t == less_than_zero,
808 //{
809 // u == ...
810 3, // -1, // less_than_min,
811 4, // - (-t >> -u), // less_than_zero,
812 5, // safe_numerics_error::negative_overflow_error, // zero,
813 6, // - (-t << u), // greater_than_zero,
814 2, // safe_numerics_error::negative_overflow_error, // greater than max,
815 1, // safe_numerics_error::range_error, // indeterminate,
816 //},
817 // t == zero,
818 //{
819 // u == ...
820 3, // 0 // less_than_min,
821 3, // 0 // less_than_zero,
822 3, // 0, // zero,
823 3, // 0, // greater_than_zero,
824 3, // 0, // greater than max,
825 3, // safe_numerics_error::range_error, // indeterminate,
826 //},
827 // t == greater_than_zero,
828 //{
829 // u == ...
830 3, // 0, // less_than_min,
831 7, // t << -u, // less_than_zero,
832 5, // t, // zero,
833 8, // t << u // greater_than_zero,
834 9, // safe_numerics_error::positive_overflow_error, // greater than max,
835 1, // safe_numerics_error::range_error, // indeterminate,
836 //},
837 // t == greater_than_max
838 //{
839 // u == ...
840 1, // safe_numerics_error::range_error, // less_than_min,
841 9, // safe_numerics_error::positive_overflow_error), // less_than_zero,
842 9, // safe_numerics_error::positive_overflow_error, // zero,
843 9, // safe_numerics_error::positive_overflow_error), // greater_than_zero,
844 9, // safe_numerics_error::positive_overflow_error, // greater than max,
845 1, // safe_numerics_error::range_error, // indeterminate,
846 //},
847 // t == indeterminate
848 //{
849 1, // safe_numerics_error::range_error, // indeterminate,
850 1, // safe_numerics_error::range_error, // indeterminate,
851 1, // safe_numerics_error::range_error, // indeterminate,
852 1, // safe_numerics_error::range_error, // indeterminate,
853 1, // safe_numerics_error::range_error, // indeterminate,
854 1, // safe_numerics_error::range_error, // indeterminate,
855 //}
856 };
857
858 const value_type tx(t);
859 const value_type ux(u);
860 assert(tx * order + ux < order * order);
861
862 // I had a switch(i) statment here - but it results in an ICE
863 // on multiple versions of gcc. So make the equivalent in
864 // nested if statments - should be the same (more or less)
865 // performancewise.
866 const unsigned int i = result[tx * order + ux];
867 assert(i <= 9);
868 if(1 == i){
869 return safe_numerics_error::range_error;
870 }
871 else
872 if(2 == i){
873 return safe_numerics_error::negative_overflow_error;
874 }
875 else
876 if(3 == i){
877 return checked_result<T>(0);
878 // the following gymnastics are to handle the case where
879 // a value is changed from a negative to a positive number.
880 // For example, and 8 bit number t == -128. Then -t also
881 // equals -128 since 128 cannot be held in an 8 bit signed
882 // integer.
883 }
884 else
885 if(4 == i){ // - (-t >> -u)
886 assert(static_cast<bool>(t < checked_result<T>(0)));
887 assert(static_cast<bool>(u < checked_result<T>(0)));
888 return t >> -u;
889 }
890 else
891 if(5 == i){
892 return t;
893 }
894 else
895 if(6 == i){ // - (-t << u)
896 assert(static_cast<bool>(t < checked_result<T>(0)));
897 assert(static_cast<bool>(u > checked_result<T>(0)));
898 const checked_result<T> temp_t = t * checked_result<T>(2);
899 const checked_result<T> temp_u = u - checked_result<T>(1);
900 return - (-temp_t << temp_u);
901 }
902 else
903 if(7 == i){ // t >> -u
904 assert(static_cast<bool>(t > checked_result<T>(0)));
905 assert(static_cast<bool>(u < checked_result<T>(0)));
906 return t >> -u;
907 }
908 else
909 if(8 == i){ // t << u
910 assert(static_cast<bool>(t > checked_result<T>(0)));
911 assert(static_cast<bool>(u > checked_result<T>(0)));
912 checked_result<T> r = checked::left_shift<T>(t, u);
913 return (r.m_e == safe_numerics_error::shift_too_large)
914 ? checked_result<T>(safe_numerics_error::positive_overflow_error)
915 : r;
916 }
917 else
918 if(9 == i){
919 return safe_numerics_error::positive_overflow_error;
920 }
921 else{
922 assert(false);
923 };
924 return checked_result<T>(0); // to suppress msvc warning
925}
926
927template<class T>
928typename std::enable_if<
929 std::is_integral<T>::value,
930 checked_result<T>
931>::type
932constexpr inline operator>>(
933 const checked_result<T> & t,
934 const checked_result<T> & u
935){
936 using value_type = product_value_type;
937 const std::uint8_t order = static_cast<std::uint8_t>(value_type::count);
938
939 const std::uint8_t result[order * order] = {
940 // t == less_than_min
941 //{
942 // u == ...
943 2, // safe_numerics_error::negative_overflow_error, // less_than_min,
944 2, // safe_numerics_error::negative_overflow_error, // less_than_zero,
945 2, // safe_numerics_error::negative_overflow_error, // zero,
946 2, // safe_numerics_error::negative_overflow_error, // greater_than_zero,
947 1, // safe_numerics_error::range_error, // greater than max,
948 1, // safe_numerics_error::range_error, // indeterminate,
949 //},
950 // t == less_than_zero,
951 //{
952 // u == ...
953 2, // safe_numerics_error::negative_overflow_error // less_than_min,
954 4, // - (-t << -u), // less_than_zero,
955 5, // safe_numerics_error::negative_overflow_error. // zero,
956 6, // - (-t >> u), // greater_than_zero,
957 3, // 0, ? or -1 // greater than max,
958 1, // safe_numerics_error::range_error, // indeterminate,
959 //},
960 // t == zero,
961 //{
962 // u == ...
963 3, // 0 // less_than_min,
964 3, // 0 // less_than_zero,
965 3, // 0, // zero,
966 3, // 0, // greater_than_zero,
967 3, // 0, // greater than max,
968 3, // safe_numerics_error::range_error, // indeterminate,
969 //},
970 // t == greater_than_zero,
971 //{
972 // u == ...
973 9, // safe_numerics_error::positive_overflow_error // less_than_min,
974 7, // t << -u, // less_than_zero,
975 5, // t, // zero,
976 8, // t >> u // greater_than_zero,
977 3, // 0, // greater than max,
978 1, // safe_numerics_error::range_error, // indeterminate,
979 //},
980 // t == greater_than_max
981 //{
982 // u == ...
983 9, // safe_numerics_error::positive_overflow_error, // less_than_min,
984 9, // safe_numerics_error::positive_overflow_error, // less_than_zero,
985 9, // safe_numerics_error::positive_overflow_error, // zero,
986 9, // safe_numerics_error::positive_overflow_error, // greater_than_zero,
987 1, // safe_numerics_error::range_error, // greater than max,
988 1, // safe_numerics_error::range_error, // indeterminate,
989 //},
990 // t == indeterminate
991 //{
992 1, // safe_numerics_error::range_error, // indeterminate,
993 1, // safe_numerics_error::range_error, // indeterminate,
994 1, // safe_numerics_error::range_error, // indeterminate,
995 1, // safe_numerics_error::range_error, // indeterminate,
996 1, // safe_numerics_error::range_error, // indeterminate,
997 1, // safe_numerics_error::range_error, // indeterminate,
998 //}
999 };
1000
1001 const value_type tx(t);
1002 const value_type ux(u);
1003 assert(tx * order + ux < order * order);
1004
1005 // I had a switch(i) statment here - but it results in an ICE
1006 // on multiple versions of gcc. So make the equivalent in
1007 // nested if statments - should be the same (more or less)
1008 // performancewise.
1009 const unsigned int i = result[tx * order + ux];
1010 assert(i <= 9);
1011 if(1 == i){
1012 return safe_numerics_error::range_error;
1013 }
1014 else
1015 if(2 == i){
1016 return safe_numerics_error::negative_overflow_error;
1017 }
1018 else
1019 if(3 == i){
1020 return checked_result<T>(0);
1021 }
1022 else
1023 if(4 == i){ // - (-t << -u)
1024 assert(static_cast<bool>(t < checked_result<T>(0)));
1025 assert(static_cast<bool>(u < checked_result<T>(0)));
1026 return t << -u;
1027 }
1028 else
1029 if(5 == i){
1030 return t;
1031 }
1032 else
1033 if(6 == i){ // - (-t >> u)
1034 assert(static_cast<bool>(t < checked_result<T>(0)));
1035 assert(static_cast<bool>(u > checked_result<T>(0)));
1036 const checked_result<T> temp_t = t / checked_result<T>(2);
1037 const checked_result<T> temp_u = u - checked_result<T>(1);
1038 return - (-temp_t >> temp_u);
1039 }
1040 else
1041 if(7 == i){ // t << -u,
1042 assert(static_cast<bool>(t > checked_result<T>(0)));
1043 assert(static_cast<bool>(u < checked_result<T>(0)));
1044 return t << -u;
1045 }
1046 else
1047 if(8 == i){ // t >> u
1048 assert(static_cast<bool>(t > checked_result<T>(0)));
1049 assert(static_cast<bool>(u > checked_result<T>(0)));
1050 checked_result<T> r = checked::right_shift<T>(t, u);
1051 return (r.m_e == safe_numerics_error::shift_too_large)
1052 ? checked_result<T>(0)
1053 : r;
1054 }
1055 else
1056 if(9 == i){
1057 return safe_numerics_error::positive_overflow_error;
1058 }
1059 else{
1060 assert(false);
1061 };
1062 return checked_result<T>(0); // to suppress msvc warning
1063}
1064
1065template<class T>
1066typename std::enable_if<
1067 std::is_integral<T>::value,
1068 checked_result<T>
1069>::type
1070constexpr inline operator|(
1071 const checked_result<T> & t,
1072 const checked_result<T> & u
1073){
1074 return
1075 t.exception() || u.exception()
1076 ? checked_result<T>(safe_numerics_error::range_error)
1077 : checked::bitwise_or<T>(
1078 static_cast<T>(t),
1079 static_cast<T>(u)
1080 );
1081}
1082template<class T>
1083typename std::enable_if<
1084 std::is_integral<T>::value,
1085 checked_result<T>
1086>::type
1087constexpr inline operator^(
1088 const checked_result<T> & t,
1089 const checked_result<T> & u
1090){
1091 return
1092 t.exception() || u.exception()
1093 ? checked_result<T>(safe_numerics_error::range_error)
1094 : checked::bitwise_xor<T>(
1095 static_cast<T>(t),
1096 static_cast<T>(u)
1097 );
1098}
1099
1100template<class T>
1101typename std::enable_if<
1102 std::is_integral<T>::value,
1103 checked_result<T>
1104>::type
1105constexpr inline operator&(
1106 const checked_result<T> & t,
1107 const checked_result<T> & u
1108){
1109 return
1110 t.exception() || u.exception()
1111 ? checked_result<T>(safe_numerics_error::range_error)
1112 : checked::bitwise_and<T>(
1113 static_cast<T>(t),
1114 static_cast<T>(u)
1115 );
1116}
1117
1118} // safe_numerics
1119} // boost
1120
1121#include <iosfwd>
1122
1123namespace std {
1124
1125template<typename CharT, typename Traits, typename R>
1126inline std::basic_ostream<CharT, Traits> & operator<<(
1127 std::basic_ostream<CharT, Traits> & os,
1128 const boost::safe_numerics::checked_result<R> & r
1129){
1130 bool e = r.exception();
1131 os << e;
1132 if(!e)
1133 os << static_cast<R>(r);
1134 else
1135 os << std::error_code(r.m_e).message() << ':' << static_cast<char const *>(r);
1136 return os;
1137}
1138
1139template<typename CharT, typename Traits>
1140inline std::basic_ostream<CharT, Traits> & operator<<(
1141 std::basic_ostream<CharT, Traits> & os,
1142 const boost::safe_numerics::checked_result<signed char> & r
1143){
1144 bool e = r.exception();
1145 os << e;
1146 if(! e)
1147 os << static_cast<std::int16_t>(r);
1148 else
1149 os << std::error_code(r.m_e).message() << ':' << static_cast<char const *>(r);
1150 return os;
1151}
1152
1153template<typename CharT, typename Traits, typename R>
1154inline std::basic_istream<CharT, Traits> & operator>>(
1155 std::basic_istream<CharT, Traits> & is,
1156 boost::safe_numerics::checked_result<R> & r
1157){
1158 bool e;
1159 is >> e;
1160 if(!e)
1161 is >> static_cast<R>(r);
1162 else
1163 is >> std::error_code(r.m_e).message() >> ':' >> static_cast<char const *>(r);
1164 return is;
1165}
1166
1167template<typename CharT, typename Traits>
1168inline std::basic_istream<CharT, Traits> & operator>>(
1169 std::basic_istream<CharT, Traits> & is,
1170 boost::safe_numerics::checked_result<signed char> & r
1171){
1172 bool e;
1173 is >> e;
1174 if(!e){
1175 std::int16_t i;
1176 is >> i;
1177 r.m_contents.m_r = static_cast<signed char>(i);
1178 }
1179 else
1180 is >> std::error_code(r.m_e).message() >> ':' >> static_cast<char const *>(r);
1181 return is;
1182}
1183
1184} // std
1185
1186/////////////////////////////////////////////////////////////////
1187// numeric limits for checked<R>
1188
1189#include <limits>
1190
1191namespace std {
1192
1193template<class R>
1194class numeric_limits<boost::safe_numerics::checked_result<R> >
1195 : public std::numeric_limits<R>
1196{
1197 using this_type = boost::safe_numerics::checked_result<R>;
1198public:
1199 constexpr static this_type min() noexcept {
1200 return this_type(std::numeric_limits<R>::min());
1201 }
1202 constexpr static this_type max() noexcept {
1203 return this_type(std::numeric_limits<R>::max());
1204 }
1205};
1206
1207} // std
1208
1209#endif // BOOST_NUMERIC_CHECKED_RESULT_OPERATIONS
1210

source code of boost/libs/safe_numerics/include/boost/safe_numerics/checked_result_operations.hpp