def test_max_overflow_bin_999(self): obj = Round(10, 100, max=150, overflow_bin=999) self.assertEqual(100, obj(100)) self.assertEqual(140, obj(149)) # the last bin self.assertEqual(999, obj(150)) # overflow self.assertEqual(999, obj(500)) # overflow self.assertEqual(999, obj.next(140)) # the next to the last # bin is the overflow # bin self.assertEqual(999, obj.next(999)) # the next to the overflow
def test_max_int_on_a_boundary(overflow_bin): # max is always exactly a boundary max_ = 150 obj = Round(10, 100, max=max_, overflow_bin=overflow_bin) assert 100 == obj(100) if overflow_bin is True: overflow_bin = obj.boundaries[-1] assert max_ == obj.boundaries[-1] assert obj(max_) is overflow_bin assert obj.next(obj.boundaries[-2]) is overflow_bin assert obj.next(overflow_bin) is overflow_bin
def test_next(): obj = Round() assert -0.5 == obj.next( -1.5) assert 0.5 == obj.next( -0.5) assert 1.5 == obj.next( 0.5) assert 2.5 == obj.next( 1.5) obj = Round(0.02, 0.005) assert -0.015 == obj.next( -0.035) assert 0.005 == obj.next( -0.015) assert 0.025 == obj.next( 0.005) assert 0.045 == obj.next( 0.025) assert 0.065 == obj.next( 0.045)
def test_min_underflow_bin(self): obj = Round(10, 100, min=30, underflow_bin=0) self.assertEqual(100, obj(100)) self.assertEqual(30, obj(30)) self.assertEqual(0, obj(29)) self.assertEqual(obj(30), obj.next(0)) # the next to the underflow
def test_max_int(): obj = Round(10, 100, max=150) assert 100 == obj( 100) assert None == obj( 150) assert None == obj( 500) assert None == obj.next(140) # the next to the last bin is
def test_max_int(): obj = Round(10, 100, max=150) assert 100 == obj(100) assert None == obj(150) assert None == obj(500) assert None == obj.next(140) # the next to the last bin is
def test_max(self): obj = Round(10, 100, max=150) self.assertEqual(100, obj(100)) self.assertEqual(None, obj(150)) self.assertEqual(None, obj(500)) self.assertEqual(None, obj.next(140)) # the next to the last bin is
def test_max_float_on_a_boundary(width, max_, overflow_bin): # max_ on a boundary (within rounding of float) obj = Round(width, 1.0, max=max_, overflow_bin=overflow_bin) # example boundaries (depending on the architecture) # when width = 0.1: # boundaries = [ # 1.0, 1.1, 1.2000000000000002, 1.3000000000000003, # 1.4000000000000004, 1.5000000000000004, 1.6000000000000005, # 1.7000000000000006, 1.8000000000000007, 1.9000000000000008, # 2.000000000000001, 2.100000000000001, 2.200000000000001, # 2.300000000000001, 2.4000000000000012] # slightly greater than 1.6 and 2.4 # # when width = 0.2: # boundaries = [ # 1.0, 1.2, 1.4, 1.5999999999999999, 1.7999999999999998, # 1.9999999999999998, 2.1999999999999997, 2.4] # slightly less than 1.6, exactly 2.4! # if overflow_bin is True: overflow_bin = obj.boundaries[-1] assert 1.0 == obj(1.0) # this is always true because 1.0 is the given boundary. # If the max is exactly a boundary, the max is the upper edge of # the last bin and bin(max) is overflow because the upper edge is # open. Otherwise, bin(max) is in the last bin. if max_ == obj.boundaries[-1]: assert obj(max_) == overflow_bin else: assert obj.boundaries[-2] == obj(max_) # The max is either the upper or lower edge of the last bin, but # not necessarily exact. if not max_ == pytest.approx(obj.boundaries[-1]): assert max_ == pytest.approx(obj.boundaries[-2]) # the next to the last bin is the overflow bin assert obj.next(obj.boundaries[-2]) is overflow_bin # the next to the overflow bin is the overflow bin assert obj.next(overflow_bin) is overflow_bin
def test_min_on_a_boundary(width, underflow_bin): # this test is related to # the issue 43 # https://github.com/alphatwirl/alphatwirl/issues/43 min_ = 1.0 # on a boundary (within rounding of float) obj = Round(width, 2.0, min=min_, underflow_bin=underflow_bin) # example boundaries (depending on the architecture) # when width = 0.1: # boundaries = [ # 0.9999999999999992, 1.0999999999999992, # 1.1999999999999993, 1.2999999999999994, 1.3999999999999995, # 1.4999999999999996, 1.5999999999999996, 1.6999999999999997, # 1.7999999999999998, 1.9, 2.0] # min=1.0 is the 1st element. but the precise value is slightly # less than 1.0 # # when width = 0.2: # boundaries = [ # 0.8000000000000003, 1.0000000000000002, # 1.2000000000000002, 1.4000000000000001, 1.6, 1.8, 2.0] # min=1.0 is the 2nd element, slightly greater than 1.0. assert 2.0 == obj(2.0) # this is always true because 2.0 is the given boundary. # min=1.0 is a boundary, but not necessarily exact. if min_ == pytest.approx(obj(min_)): assert obj(1.05) == obj(min_) assert obj(0.95) is underflow_bin else: assert obj(0.95) == obj(min_) assert obj(0.95) is not underflow_bin # the results depend on the architecture. # it is wise to not set min a boundary. assert obj(0.7) is underflow_bin if underflow_bin is None: assert obj.next(underflow_bin) is None else: assert obj(min_) == obj.next(underflow_bin)
def test_next(): obj = Round() assert -0.5 == obj.next(-1.5) assert 0.5 == obj.next(-0.5) assert 1.5 == obj.next(0.5) assert 2.5 == obj.next(1.5) obj = Round(0.02, 0.005) assert -0.015 == obj.next(-0.035) assert 0.005 == obj.next(-0.015) assert 0.025 == obj.next(0.005) assert 0.045 == obj.next(0.025) assert 0.065 == obj.next(0.045)
def test_next(self): obj = Round() self.assertEqual(-0.5, obj.next(-1.5)) self.assertEqual(0.5, obj.next(-0.5)) self.assertEqual(1.5, obj.next(0.5)) self.assertEqual(2.5, obj.next(1.5)) obj = Round(0.02, 0.005) self.assertEqual(-0.015, obj.next(-0.035)) self.assertEqual(0.005, obj.next(-0.015)) self.assertEqual(0.025, obj.next(0.005)) self.assertEqual(0.045, obj.next(0.025)) self.assertEqual(0.065, obj.next(0.045))
def test_inf(self): obj = Round(10, 100) self.assertIsNone(obj(float('inf'))) self.assertIsNone(obj(float('-inf'))) self.assertIsNone(obj.next(float('inf'))) self.assertIsNone(obj.next(float('-inf')))
def test_inf(): obj = Round(10, 100) assert obj(float('inf')) is None assert obj(float('-inf')) is None assert obj.next(float('inf')) is None assert obj.next(float('-inf')) is None