wassname/segpy
1
0
Fork 0
mirror of https://github.com/wassname/segpy.git synced 2026-07-11 20:07:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

Reinstate Python 2 compatibility.

Browse Source
This commit is contained in:
Robert Smallshire
2015-01-31 16:00:14 +01:00
parent 38511e67ba
commit 4862f347df
7 changed files with 71 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/test_float.py
+22 -21
View File
@@ -2,6 +2,7 @@ import unittest
from segpy.ibm_float import (ieee2ibm, ibm2ieee, MAX_IBM_FLOAT, SMALLEST_POSITIVE_NORMAL_IBM_FLOAT,
LARGEST_NEGATIVE_NORMAL_IBM_FLOAT, MIN_IBM_FLOAT)
from segpy.portability import byte_string
class Ibm2Ieee(unittest.TestCase):
@@ -10,44 +11,44 @@ class Ibm2Ieee(unittest.TestCase):
self.assertEqual(ibm2ieee(b'\0\0\0\0'), 0.0)
def test_positive_half(self):
self.assertEqual(ibm2ieee((0b11000000, 0x80, 0x00, 0x00)), -0.5)
self.assertEqual(ibm2ieee(byte_string((0b11000000, 0x80, 0x00, 0x00))), -0.5)
def test_negative_half(self):
self.assertEqual(ibm2ieee((0b01000000, 0x80, 0x00, 0x00)), 0.5)
self.assertEqual(ibm2ieee(byte_string((0b01000000, 0x80, 0x00, 0x00))), 0.5)
def test_one(self):
self.assertEqual(ibm2ieee(b'\x41\x10\x00\x00'), 1.0)
def test_negative_118_625(self):
# Example taken from Wikipedia http://en.wikipedia.org/wiki/IBM_Floating_Point_Architecture
self.assertEqual(ibm2ieee((0b11000010, 0b01110110, 0b10100000, 0b00000000)), -118.625)
self.assertEqual(ibm2ieee(byte_string((0b11000010, 0b01110110, 0b10100000, 0b00000000))), -118.625)
def test_largest_representable_number(self):
self.assertEqual(ibm2ieee((0b01111111, 0b11111111, 0b11111111, 0b11111111)), MAX_IBM_FLOAT)
self.assertEqual(ibm2ieee(byte_string((0b01111111, 0b11111111, 0b11111111, 0b11111111))), MAX_IBM_FLOAT)
def test_smallest_positive_normalised_number(self):
self.assertEqual(ibm2ieee((0b00000000, 0b00010000, 0b00000000, 0b00000000)), SMALLEST_POSITIVE_NORMAL_IBM_FLOAT)
self.assertEqual(ibm2ieee(byte_string((0b00000000, 0b00010000, 0b00000000, 0b00000000))), SMALLEST_POSITIVE_NORMAL_IBM_FLOAT)
def test_largest_negative_normalised_number(self):
self.assertEqual(ibm2ieee((0b10000000, 0b00010000, 0b00000000, 0b00000000)), LARGEST_NEGATIVE_NORMAL_IBM_FLOAT)
self.assertEqual(ibm2ieee(byte_string((0b10000000, 0b00010000, 0b00000000, 0b00000000))), LARGEST_NEGATIVE_NORMAL_IBM_FLOAT)
def test_smallest_representable_number(self):
self.assertEqual(ibm2ieee((0b11111111, 0b11111111, 0b11111111, 0b11111111)), MIN_IBM_FLOAT)
self.assertEqual(ibm2ieee(byte_string((0b11111111, 0b11111111, 0b11111111, 0b11111111))), MIN_IBM_FLOAT)
def test_error_1(self):
self.assertEqual(ibm2ieee((196, 74, 194, 143)), -19138.55859375)
self.assertEqual(ibm2ieee(byte_string((196, 74, 194, 143))), -19138.55859375)
def test_error_2(self):
self.assertEqual(ibm2ieee((191, 128, 0, 0)), -0.03125)
self.assertEqual(ibm2ieee(byte_string((191, 128, 0, 0))), -0.03125)
def test_subnormal(self):
self.assertEqual(ibm2ieee((0x00, 0x00, 0x00, 0x20)), 1.6472184286297693e-83)
self.assertEqual(ibm2ieee(byte_string((0x00, 0x00, 0x00, 0x20))), 1.6472184286297693e-83)
def test_subnormal_is_subnormal(self):
self.assertTrue(0 < ibm2ieee((0x00, 0x00, 0x00, 0x20)) < SMALLEST_POSITIVE_NORMAL_IBM_FLOAT)
self.assertTrue(0 < ibm2ieee(byte_string((0x00, 0x00, 0x00, 0x20))) < SMALLEST_POSITIVE_NORMAL_IBM_FLOAT)
def test_subnormal_smallest_subnormal(self):
self.assertEqual(ibm2ieee((0x00, 0x00, 0x00, 0x01)), 5.147557589468029e-85)
self.assertEqual(ibm2ieee(byte_string((0x00, 0x00, 0x00, 0x01))), 5.147557589468029e-85)
class Ieee2Ibm(unittest.TestCase):
@@ -56,28 +57,28 @@ class Ieee2Ibm(unittest.TestCase):
self.assertEqual(ieee2ibm(0.0), b'\0\0\0\0')
def test_positive_half(self):
self.assertEqual(ieee2ibm(-0.5), bytes((0b11000000, 0x80, 0x00, 0x00)))
self.assertEqual(ieee2ibm(-0.5), byte_string((0b11000000, 0x80, 0x00, 0x00)))
def test_negative_half(self):
self.assertEqual(ieee2ibm(0.5), bytes((0b01000000, 0x80, 0x00, 0x00)))
self.assertEqual(ieee2ibm(0.5), byte_string((0b01000000, 0x80, 0x00, 0x00)))
def test_one(self):
self.assertEqual(ieee2ibm(1.0), b'\x41\x10\x00\x00')
def test_negative_118_625(self):
# Example taken from Wikipedia http://en.wikipedia.org/wiki/IBM_Floating_Point_Architecture
self.assertEqual(ieee2ibm(-118.625), bytes((0b11000010, 0b01110110, 0b10100000, 0b00000000)))
self.assertEqual(ieee2ibm(-118.625), byte_string((0b11000010, 0b01110110, 0b10100000, 0b00000000)))
def test_0_1(self):
# Note, this is different from the Wikipedia example, because the Wikipedia example does
# round to nearest, and our routine does round to zero
self.assertEqual(ieee2ibm(0.1), bytes((0b01000000, 0b00011001, 0b10011001, 0b10011001)))
self.assertEqual(ieee2ibm(0.1), byte_string((0b01000000, 0b00011001, 0b10011001, 0b10011001)))
def test_subnormal(self):
self.assertEqual(ieee2ibm(1.6472184286297693e-83), bytes((0x00, 0x00, 0x00, 0x20)))
self.assertEqual(ieee2ibm(1.6472184286297693e-83), byte_string((0x00, 0x00, 0x00, 0x20)))
def test_smallest_subnormal(self):
self.assertEqual(ieee2ibm(5.147557589468029e-85), bytes((0x00, 0x00, 0x00, 0x01)))
self.assertEqual(ieee2ibm(5.147557589468029e-85), byte_string((0x00, 0x00, 0x00, 0x01)))
def test_too_small_subnormal(self):
with self.assertRaises(FloatingPointError):
@@ -109,13 +110,13 @@ class Ibm2IeeeRoundtrip(unittest.TestCase):
self.assertEqual(ibm_start, ibm_result)
def test_positive_half(self):
ibm_start = bytes((0b11000000, 0x80, 0x00, 0x00))
ibm_start = byte_string((0b11000000, 0x80, 0x00, 0x00))
f = ibm2ieee(ibm_start)
ibm_result = ieee2ibm(f)
self.assertEqual(ibm_start, ibm_result)
def test_negative_half(self):
ibm_start = bytes((0b01000000, 0x80, 0x00, 0x00))
ibm_start = byte_string((0b01000000, 0x80, 0x00, 0x00))
f = ibm2ieee(ibm_start)
ibm_result = ieee2ibm(f)
self.assertEqual(ibm_start, ibm_result)
@@ -127,7 +128,7 @@ class Ibm2IeeeRoundtrip(unittest.TestCase):
self.assertEqual(ibm_start, ibm_result)
def test_subnormal(self):
ibm_start = bytes((0x00, 0x00, 0x00, 0x20))
ibm_start = byte_string((0x00, 0x00, 0x00, 0x20))
f = ibm2ieee(ibm_start)
ibm_result = ieee2ibm(f)
self.assertEqual(ibm_start, ibm_result)