std::string FloatFormat::intervalToHex (const Interval& interval) const
{
if (interval.empty())
return interval.hasNaN() ? "{ NaN }" : "{}";
else if (interval.lo() == interval.hi())
return (std::string(interval.hasNaN() ? "{ NaN, " : "{ ") +
floatToHex(interval.lo()) + " }");
else if (interval == Interval::unbounded(true))
return "<any>";
return (std::string(interval.hasNaN() ? "{ NaN } | " : "") +
"[" + floatToHex(interval.lo()) + ", " + floatToHex(interval.hi()) + "]");
}
//! Return the range of numbers that might be used with this format to
//! represent a number within `x`.
Interval FloatFormat::convert (const Interval& x) const
{
Interval ret;
Interval tmp = x;
if (x.hasNaN())
{
// If NaN might be supported, NaN is a legal return value
if (m_hasNaN != NO)
ret |= TCU_NAN;
// If NaN might not be supported, any (non-NaN) value is legal,
// _subject_ to clamping. Hence we modify tmp, not ret.
if (m_hasNaN != YES)
tmp = Interval::unbounded();
}
// Round both bounds _inwards_ to closest representable values.
if (!tmp.empty())
ret |= clampValue(round(tmp.lo(), true)) | clampValue(round(tmp.hi(), false));
// If this format's precision is not exact, the (possibly out-of-bounds)
// original value is also a possible result.
if (!m_exactPrecision)
ret |= x;
return ret;
}
//! Round output of an operation.
//! \param roundUnderOverflow Can +/-inf rounded to min/max representable;
//! should be false if any of operands was inf, true otherwise.
Interval FloatFormat::roundOut (const Interval& x, bool roundUnderOverflow) const
{
Interval ret = x.nan();
if (!x.empty())
ret |= Interval(roundOut(x.lo(), false, roundUnderOverflow),
roundOut(x.hi(), true, roundUnderOverflow));
return ret;
}