def test_roundtrip(self, data):
packed = ibm_float_packer.pack_ibm_floats(data)
unpacked = ibm_float_packer.unpack_ibm_floats(packed, len(data))
for f, u in zip(data, unpacked):
assert almost_equal(
f, float(u),
epsilon=EPSILON_IBM_FLOAT)
def test_ldexp_frexp(self, fraction, exponent):
try:
ibm = IBMFloat.ldexp(fraction, exponent)
except OverflowError:
assume(False)
else:
f, e = ibm.frexp()
self.assertTrue(almost_equal(fraction * 2**exponent, f * 2**e, epsilon=EPSILON_IBM_FLOAT))
def test_ldexp_frexp(self, fraction, exponent):
try:
ibm = IBMFloat.ldexp(fraction, exponent)
except (OverflowError, FloatingPointError):
raise UnsatisfiedAssumption
else:
f, e = ibm.frexp()
self.assertTrue(almost_equal(fraction * 2**exponent, f * 2**e, 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_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_ldexp_frexp(self, fraction, exponent):
try:
ibm = IBMFloat.ldexp(fraction, exponent)
except (OverflowError, FloatingPointError):
raise UnsatisfiedAssumption
else:
f, e = ibm.frexp()
assert almost_equal(fraction * 2**exponent,
f * 2**e,
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_ldexp_frexp(self, fraction, exponent):
try:
ibm = IBMFloat.ldexp(fraction, exponent)
except OverflowError:
assume(False)
else:
f, e = ibm.frexp()
self.assertTrue(
almost_equal(fraction * 2**exponent,
f * 2**e,
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_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_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_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_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_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_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_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_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_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_floats_roundtrip(self, f):
ibm = IBMFloat.from_float(f)
self.assertTrue(almost_equal(f, float(ibm), epsilon=EPSILON_IBM_FLOAT))
def test_floats_roundtrip(self, f):
ibm = IBMFloat.from_float(f)
assert almost_equal(f, float(ibm), epsilon=EPSILON_IBM_FLOAT)
def test_roundtrip(self, data):
packed = ibm_float_packer.pack_ibm_floats(data)
unpacked = ibm_float_packer.unpack_ibm_floats(packed, len(data))
for f, u in zip(data, unpacked):
assert almost_equal(f, float(u), epsilon=EPSILON_IBM_FLOAT)
