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