def test_rfloordiv_ibm(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
assume(not ibm_b.is_zero())
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
assert ieee_a // ibm_b == ieee_a // ieee_b
def test_rfloordiv_ibm(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
assume(not ibm_b.is_zero())
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
assert ieee_a // ibm_b == ieee_a // ieee_b
def test_rfloordiv_ibm_division_by_zero_raises_zero_division_error(
self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(0.0)
ieee_a = float(ibm_a)
with raises(ZeroDivisionError):
_ = ieee_a // ibm_b
def test_sub(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ibm_c = ibm_a - ibm_b
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
ieee_c = ieee_a - ieee_b
self.assertTrue(almost_equal(ieee_c, ibm_c, epsilon=EPSILON_IBM_FLOAT))
def test_sub(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ibm_c = ibm_a - ibm_b
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
ieee_c = ieee_a - ieee_b
self.assertTrue(almost_equal(ieee_c, ibm_c, epsilon=EPSILON_IBM_FLOAT))
def test_mul_ibm(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
try:
ibm_c = ibm_a * ibm_b
except OverflowError:
raise UnsatisfiedAssumption
ieee_c = ieee_a * ieee_b
assert almost_equal(ibm_c, ieee_c, epsilon=EPSILON_IBM_FLOAT)
def test_mul_ibm(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
try:
ibm_c = ibm_a * ibm_b
except OverflowError:
raise UnsatisfiedAssumption
ieee_c = ieee_a * ieee_b
assert almost_equal(ibm_c, ieee_c, epsilon=EPSILON_IBM_FLOAT)
def test_rpow_ibm_ieee_results(self, a, b):
assume(a != 0.0)
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
try:
ieee_c1 = ieee_a**ibm_b
except OverflowError:
raise UnsatisfiedAssumption
ieee_c2 = ieee_a**ieee_b
assert almost_equal(ieee_c1, ieee_c2, epsilon=EPSILON_IBM_FLOAT)
def test_rmod_ibm(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
assume(not ibm_b.is_zero())
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
try:
ieee_c1 = ieee_a % ibm_b
except OverflowError:
raise UnsatisfiedAssumption
ieee_c2 = ieee_a % ieee_b
assert almost_equal(ieee_c1, ieee_c2, epsilon=EPSILON_IBM_FLOAT)
def test_rpow_ibm_ieee_results(self, a, b):
assume(a != 0.0)
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
try:
ieee_c1 = ieee_a ** ibm_b
except OverflowError:
raise UnsatisfiedAssumption
ieee_c2 = ieee_a ** ieee_b
assert almost_equal(ieee_c1, ieee_c2, epsilon=EPSILON_IBM_FLOAT)
def test_rmod_ibm(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
assume(not ibm_b.is_zero())
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
try:
ieee_c1 = ieee_a % ibm_b
except OverflowError:
raise UnsatisfiedAssumption
ieee_c2 = ieee_a % ieee_b
assert almost_equal(ieee_c1, ieee_c2, epsilon=EPSILON_IBM_FLOAT)
def test_sub(self, a, b):
try:
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ibm_c = ibm_a - ibm_b
except FloatingPointError:
raise UnsatisfiedAssumption
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
ieee_c = ieee_a - ieee_b
self.assertTrue(almost_equal(ieee_c, ibm_c, epsilon=EPSILON_IBM_FLOAT))
def test_pow_ibm_complex_result(self, a, b):
assume(a != 0.0)
assume(b != 0.0 and b != 1.0)
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
try:
ibm_c = ibm_a ** ibm_b
except OverflowError:
raise UnsatisfiedAssumption
ieee_c = ieee_a ** ieee_b
assert almost_equal(ibm_c, ieee_c, epsilon=EPSILON_IBM_FLOAT)
def test_add(self, f, p):
a = f * p
b = f - a
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ibm_c = ibm_a + ibm_b
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
ieee_c = ieee_a + ieee_b
self.assertTrue(almost_equal(ieee_c, ibm_c, epsilon=EPSILON_IBM_FLOAT * 4))
def test_sub(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
try:
ibm_c = ibm_a - ibm_b
except FloatingPointError:
raise UnsatisfiedAssumption
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
ieee_c = ieee_a - ieee_b
assert almost_equal(ieee_c, ibm_c, epsilon=EPSILON_IBM_FLOAT)
def test_pow_ibm_complex_result(self, a, b):
assume(a != 0.0)
assume(b != 0.0 and b != 1.0)
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
try:
ibm_c = ibm_a**ibm_b
except OverflowError:
raise UnsatisfiedAssumption
ieee_c = ieee_a**ieee_b
assert almost_equal(ibm_c, ieee_c, epsilon=EPSILON_IBM_FLOAT)
def test_add(self, f, p):
a = f * p
b = f - a
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ibm_c = ibm_a + ibm_b
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
ieee_c = ieee_a + ieee_b
self.assertTrue(
almost_equal(ieee_c, ibm_c, epsilon=EPSILON_IBM_FLOAT * 4))
def test_add(self, f, p):
a = f * p
b = f - a
try:
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ibm_c = ibm_a + ibm_b
except FloatingPointError:
raise UnsatisfiedAssumption
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
ieee_c = ieee_a + ieee_b
assert almost_equal(ieee_c, ibm_c, epsilon=EPSILON_IBM_FLOAT * 4)
def test_add(self, f, p):
a = f * p
b = f - a
try:
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ibm_c = ibm_a + ibm_b
except FloatingPointError:
raise UnsatisfiedAssumption
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
ieee_c = ieee_a + ieee_b
self.assertTrue(almost_equal(ieee_c, ibm_c, epsilon=EPSILON_IBM_FLOAT * 4))
def test_nan(self):
with self.assertRaises(ValueError):
IBMFloat.from_float(float('nan'))
def test_equality_with_non_comparable_type_is_false(self):
p = IBMFloat.from_float(1234.0)
q = None
assert p != q
def test_equality_with_int_positive(self):
p = IBMFloat.from_float(1234.0)
q = 1234
assert p == q
def test_equality_with_infinite_float_negative(self):
p = IBMFloat.from_float(+1.5)
q = float("+inf")
assert p != q
def test_equality_with_finite_float_positive(self):
p = IBMFloat.from_float(+1.5)
q = +1.5
assert p == q
def test_subnormals_rhs_are_not_equal_to_one(self):
p = IBMFloat.from_float(1.0)
q = IBMFloat(bytes((0x00, 0x00, 0x00, 0x01)))
assert p != q
def test_le_ibm(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
assert (ibm_a <= ibm_b) == (ieee_a <= ieee_b)
def test_floor(self, i, f):
assume(f != 1.0)
ieee = i + f
ibm = IBMFloat.from_float(ieee)
self.assertEqual(math.floor(ibm), i)
def test_trunc_below_zero(self, i, f):
assume(f != 1.0)
ieee = i - f
ibm = IBMFloat.from_float(ieee)
self.assertEqual(trunc(ibm), i)
def test_floats_roundtrip(self, f):
ibm = IBMFloat.from_float(f)
self.assertTrue(almost_equal(f, float(ibm), epsilon=EPSILON_IBM_FLOAT))
def test_bool(self, f):
self.assertEqual(bool(IBMFloat.from_float(f)), bool(f))
def test_too_small(self):
with self.assertRaises(OverflowError):
IBMFloat.from_float(MIN_IBM_FLOAT * 10)
def test_too_large(self):
with self.assertRaises(OverflowError):
IBMFloat.from_float(MAX_IBM_FLOAT * 10)
def test_inf(self):
with self.assertRaises(ValueError):
IBMFloat.from_float(float('inf'))
def test_subnormal(self):
ibm = IBMFloat.from_float(1.6472184286297693e-83)
self.assertTrue(ibm.is_subnormal())
def test_mod_ibm_division_by_zero_raises_zero_division_error(self, a):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(0.0)
with raises(ZeroDivisionError):
_ = ibm_a % ibm_b
def test_normalise_subnormal_expect_failure(self):
# This float has an base-16 exponent of -64 (the minimum) and cannot be normalised
ibm = IBMFloat.from_float(1.6472184286297693e-83)
assert ibm.is_subnormal()
with self.assertRaises(FloatingPointError):
ibm.normalize()
def test_zero_from_float(self):
zero = IBMFloat.from_float(0.0)
self.assertTrue(zero.is_zero())
def test_negate_zero(self):
zero = IBMFloat.from_float(0.0)
negated = -zero
self.assertTrue(negated.is_zero())
def test_equality_different_signs(self):
p = IBMFloat.from_float(+1.0)
q = IBMFloat.from_float(-1.0)
assert p != q
def test_signbit(self, f):
ltz = f < 0
ibm = IBMFloat.from_float(f)
self.assertEqual(ltz, ibm.signbit)
def test_equality_with_finite_float_negative(self):
p = IBMFloat.from_float(+1.5)
q = +1.6
assert p != q
def test_round(self, f):
ibm = IBMFloat.from_float(f)
g = float(ibm)
assert round(ibm) == round(g)
def test_equality_with_nan_negative(self):
p = IBMFloat.from_float(+1.5)
q = float("nan")
assert p != q
def test_smallest_subnormal(self):
ibm = IBMFloat.from_float(5.147557589468029e-85)
self.assertEqual(bytes(ibm), bytes((0x00, 0x00, 0x00, 0x01)))
def test_equality_with_int_negative(self):
p = IBMFloat.from_float(1234.0)
q = 4321
assert p != q
def test_conversion_to_int(self, f):
ibm = IBMFloat.from_float(f)
assert int(ibm) == int(f)
def test_ceil(self, i, f):
ieee = i + f
ibm = IBMFloat.from_float(ieee)
self.assertEqual(math.ceil(ibm), i + 1)
def test_too_small_subnormal(self):
with self.assertRaises(FloatingPointError):
IBMFloat.from_float(1e-86)
def test_repr(self, f):
ibm = IBMFloat.from_float(f)
r = repr(ibm)
assert check_balanced(r)
def test_floor(self, i, f):
ieee = i + f
ibm = IBMFloat.from_float(ieee)
assert math.floor(ibm) == i
def test_round(self, f):
ibm = IBMFloat.from_float(f)
g = float(ibm)
assert round(ibm) == round(g)
def test_normalise_subnormal_expect_failure(self):
# This float has an base-16 exponent of -64 (the minimum) and cannot be normalised
ibm = IBMFloat.from_float(1.6472184286297693e-83)
assert ibm.is_subnormal()
with pytest.raises(FloatingPointError):
ibm.normalize()
def test_le_ibm(self, a, b):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(b)
ieee_a = float(ibm_a)
ieee_b = float(ibm_b)
assert (ibm_a <= ibm_b) == (ieee_a <= ieee_b)
def test_negate_zero(self):
zero = IBMFloat.from_float(0.0)
negated = -zero
assert negated.is_zero()
def test_rmod_ibm_division_by_zero_raises_zero_division_error(self, a):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(0.0)
ieee_a = float(ibm_a)
with raises(ZeroDivisionError):
_ = ieee_a % ibm_b
def test_signbit(self, f):
ltz = f < 0
ibm = IBMFloat.from_float(f)
assert ltz == ibm.signbit
def test_truediv_ibm_by_zero_raises_zero_division_error(self, a):
ibm_a = IBMFloat.from_float(a)
ibm_b = IBMFloat.from_float(0.0)
with raises(ZeroDivisionError):
_ = ibm_a / ibm_b
def test_str(self, f):
ibm = IBMFloat.from_float(f)
g = float(ibm)
assert str(g) == str(ibm)
def test_conversion_to_int(self, f):
ibm = IBMFloat.from_float(f)
assert int(ibm) == int(f)
def test_pos(self, f):
ibm = IBMFloat.from_float(f)
assert ibm == +ibm