...one of the most highly
regarded and expertly designed C++ library projects in the
world.

— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards

This is the documentation for a snapshot of the master branch, built from commit 2b7c83edd2.

## Safe Numerics |

A closed arithmetic interval represented by a pair of elements of
type R. In principle, one should be able to use Boost.Interval library for
this. But the functions in this library are not `constexpr`

.
Also, this Boost.Interval is more complex and does not support certain
operations such bit operations. Perhaps some time in the future,
Boost.Interval will be used instead of this `interval<R>`

type.

R must model the type requirements of Numeric. Note this in principle
includes any numeric type including floating point numbers and instances
of `checked_result<R>`

.

Symbol | Description |
---|---|

`I` |
An interval type |

`i, j` |
An instance of interval type |

`R` |
Numeric types which can be used to make an interval |

`r` |
An instance of type R |

`p` |
An instance of std::pair<R, R> |

`l, u` |
Lowermost and uppermost values in an interval |

`os` |
std::basic_ostream<class CharT, class Traits = std::char_traits<CharT>> |

`checked_result` |
holds either the result of an operation or information as to why it failed |

Note that all expressions are constexpr.

Expression | Return Type | Semantics |
---|---|---|

`interval<R>(l, u)` |
`interval<R>` |
construct a new interval from a pair of limits |

`interval<R>(p)` |
`interval<R>` |
construct a new interval from a pair of limits |

`interval<R>(i)` |
`interval<R>` |
copy constructor |

`make_interval<R>()` |
`interval<R>` |
return new interval with std::numric_limits<R>::min() and std::numric_limits<R>::max() |

```
make_interval<R>(const R
&r)
``` |
`interval<R>` |
return new interval with std::numric_limits<R>::min() and std::numric_limits<R>::max() |

`i.l` |
`R` |
lowermost value in the interval i |

`i.u` |
`R` |
uppermost value in the interval i |

`i.includes(j)` |
`boost::logic::tribool` |
return true if interval i includes interval j |

`i.excludes(j)` |
`boost::logic::tribool` |
return true if interval i includes interval j |

`i.includes(t)` |
`bool` |
return true if interval i includes value t |

`i.excludes(t)` |
`bool` |
return true if interval i includes value t |

`i + j` |
`interval<R>` |
add two intervals and return the result |

`i - j` |
`interval<R>` |
subtract two intervals and return the result |

`i * j` |
`interval<R>` |
multiply two intervals and return the result |

`i / j` |
`interval<R>` |
divide one interval by another and return the result |

`i % j` |
`interval<R>` |
calculate modulus of one interval by another and return the result |

`i << j` |
`interval<R>` |
calculate the range that would result from shifting one interval by another |

`i >> j` |
`interval<R>` |
calculate the range that would result from shifting one interval by another |

`i | j` |
`interval<R>` |
range of values which can result from applying | to any pair of operands from I and j |

`i & j` |
`interval<R>` |
range of values which can result from applying & to any pair of operands from I and j |

`i ^ j` |
`interval<R>` |
range of values which can result from applying ^ to any pair of operands from I and j |

`t < u` |
`boost::logic::tribool` |
true if every element in t is less than every element in u |

`t > u` |
`boost::logic::tribool` |
true if every element in t is greater than every element in u |

`t <= u` |
`boost::logic::tribool` |
true if every element in t is less than or equal to every element in u |

`t >= u` |
`boost::logic::tribool` |
true if every element in t is greater than or equal to every element in u |

`t == u` |
`bool` |
true if limits are equal |

`t != u` |
`bool` |
true if limits are not equal |

`os << i` |
`os &` |
print interval to output stream |

#include <iostream> #include <cstdint> #include <cassert> #include <boost/numeric/safe_numerics/interval.hpp> int main(){ std::cout << "test1" << std::endl; interval<std::int16_t> x = {-64, 63}; std::cout << "x = " << x << std::endl; interval<std::int16_t> y(-128, 126); std::cout << "y = " << y << std::endl; assert(static_cast<interval<std::int16_t>>(add<std::int16_t>(x,x)) == y); std::cout << "x + x =" << add<std::int16_t>(x, x) << std::endl; std::cout << "x - x = " << subtract<std::int16_t>(x, x) << std::endl; return 0; }