コード例 #1
0
def test_degenerate_cases():
    degenerate_cases = ((4, 5), (-1234, 23), (0, 512), (452.5, 613.451),
                        (234.234, -3453), (-23.3, 4), (infinity, infinity),
                        (infinity, -infinity), (-infinity, infinity),
                        (-infinity, -infinity))
    for degenerate_case in degenerate_cases:
        assert cute_equal(cute_divmod(*degenerate_case),
                          divmod(*degenerate_case))
        assert cute_equal(
            cute_divmod(*degenerate_case)[0], cute_floor_div(*degenerate_case),
            degenerate_case[0] // degenerate_case[1])
コード例 #2
0
def test_degenerate_cases():
    degenerate_cases = (
        (4, 5), (-1234, 23), (0, 512), (452.5, 613.451), (234.234, -3453),
        (-23.3, 4), (infinity, infinity), (infinity, -infinity),
        (-infinity, infinity), (-infinity, -infinity)
    )
    for degenerate_case in degenerate_cases:
        assert cute_equal(cute_divmod(*degenerate_case),
                          divmod(*degenerate_case))
        assert cute_equal(cute_divmod(*degenerate_case)[0],
                          cute_floor_div(*degenerate_case),
                          degenerate_case[0] // degenerate_case[1])
コード例 #3
0
def test_illegal_cases():
    illegal_cases = ((4, 0), (infinity, 0), (-infinity, 0))
    for illegal_case in illegal_cases:
        with cute_testing.RaiseAssertor() as raise_assertor_0:
            cute_divmod(*illegal_case)
        with cute_testing.RaiseAssertor() as raise_assertor_1:
            divmod(*illegal_case)
        with cute_testing.RaiseAssertor() as raise_assertor_2:
            cute_floor_div(*illegal_case)
        assert logic_tools.all_equivalent((
            type(raise_assertor_0.exception),
            type(raise_assertor_1.exception),
            type(raise_assertor_2.exception),
        ))
コード例 #4
0
def test_meaningful_cases():
    meaningful_cases = (
        (infinity, 3),
        (infinity, 300.5),
        (infinity, -3),
        (infinity, -300.5),
        (-infinity, 3),
        (-infinity, 300.5),
        (-infinity, -3),
        (-infinity, -300.5),
        (3, infinity),
        (3, -infinity),
        (-3, infinity),
        (-3, -infinity),
        (300.5, infinity),
        (300.5, -infinity),
        (-300.5, infinity),
        (-300.5, -infinity),
        (0, infinity),
        (0, -infinity),
    )
    for meaningful_numerator, meaningful_denominator in meaningful_cases:
        cute_quotient, cute_remainder = cute_divmod(meaningful_numerator,
                                                    meaningful_denominator)
        assert cute_equal(
            cute_quotient,
            cute_floor_div(meaningful_numerator, meaningful_denominator))
        assert (cute_quotient ==
                          (meaningful_numerator / meaningful_denominator)) or \
        (0 <= ((meaningful_numerator / meaningful_denominator)
                                                          - cute_quotient) < 1)
コード例 #5
0
def test_illegal_cases():
    illegal_cases = (
        (4, 0), (infinity, 0), (-infinity, 0)
    )
    for illegal_case in illegal_cases:
        with cute_testing.RaiseAssertor() as raise_assertor_0:
            cute_divmod(*illegal_case)
        with cute_testing.RaiseAssertor() as raise_assertor_1:
            divmod(*illegal_case)
        with cute_testing.RaiseAssertor() as raise_assertor_2:
            cute_floor_div(*illegal_case)
        assert logic_tools.all_equal((
            type(raise_assertor_0.exception),
            type(raise_assertor_1.exception),
            type(raise_assertor_2.exception),
        ))
コード例 #6
0
def test_meaningful_cases():
    if sys_tools.is_pypy:
        # todo: When version of Pypy with bug 1873 is released, remove this
        # skipping.
        raise nose.SkipTest
    meaningful_cases = (
        (infinity, 3),
        (infinity, 300.5),
        (infinity, -3),
        (infinity, -300.5),
        (-infinity, 3),
        (-infinity, 300.5),
        (-infinity, -3),
        (-infinity, -300.5),
        (3, infinity),
        (3, -infinity),
        (-3, infinity),
        (-3, -infinity),
        (300.5, infinity),
        (300.5, -infinity),
        (-300.5, infinity),
        (-300.5, -infinity),
        (0, infinity),
        (0, -infinity),
    )
    for meaningful_numerator, meaningful_denominator in meaningful_cases:
        cute_quotient, cute_remainder = cute_divmod(meaningful_numerator,
                                                    meaningful_denominator)
        assert cute_equal(
            cute_quotient,
            cute_floor_div(meaningful_numerator, meaningful_denominator))
        assert (cute_quotient ==
                          (meaningful_numerator / meaningful_denominator)) or \
        (0 <= ((meaningful_numerator / meaningful_denominator)
                                                          - cute_quotient) < 1)
コード例 #7
0
ファイル: cute_range.py プロジェクト: vu8/python_toolbox
    def length(self):
        '''
        The length of the `CuteRange`.

        We're using a property `.length` rather than the built-in `__len__`
        because `__len__` can't handle infinite values or floats.
        '''
        from python_toolbox import math_tools

        if math_tools.get_sign(self.distance_to_cover) != \
                                                math_tools.get_sign(self.step):
            return 0
        else:
            raw_length, remainder = math_tools.cute_divmod(
                self.distance_to_cover, self.step)
            raw_length += (remainder != 0)
            return raw_length
コード例 #8
0
ファイル: cute_range.py プロジェクト: cool-RR/python_toolbox
 def length(self):
     '''
     The length of the `CuteRange`.
     
     We're using a property `.length` rather than the built-in `__len__`
     because `__len__` can't handle infinite values or floats.
     '''
     from python_toolbox import math_tools
     
     if math_tools.get_sign(self.distance_to_cover) != \
                                             math_tools.get_sign(self.step):
         return 0
     else:
         raw_length, remainder = math_tools.cute_divmod(
             self.distance_to_cover, self.step
         )
         raw_length += (remainder != 0)
         return raw_length
コード例 #9
0
def test_meaningful_cases():
    meaningful_cases = (
        (infinity, 3), (infinity, 300.5), (infinity, -3), (infinity, -300.5), 
        (-infinity, 3), (-infinity, 300.5), (-infinity, -3), (-infinity, -300.5), 
        (3, infinity), (3, -infinity), (-3, infinity), (-3, -infinity), 
        (300.5, infinity), (300.5, -infinity),
                                       (-300.5, infinity), (-300.5, -infinity),
        (0, infinity), (0, -infinity),
    )
    for meaningful_numerator, meaningful_denominator in meaningful_cases:
        cute_quotient, cute_remainder = cute_divmod(meaningful_numerator,
                                                    meaningful_denominator)
        assert cute_equal(cute_quotient,
                          cute_floor_div(meaningful_numerator,
                                         meaningful_denominator))
        assert (cute_quotient ==
                          (meaningful_numerator / meaningful_denominator)) or \
        (0 <= ((meaningful_numerator / meaningful_denominator)
                                                          - cute_quotient) < 1)
コード例 #10
0
ファイル: cute_range.py プロジェクト: vu8/python_toolbox
    def index(self, i, start=-infinity, stop=infinity):
        '''Get the index number of `i` in this `CuteRange`.'''
        from python_toolbox import math_tools
        if not isinstance(i, numbers.Number):
            raise ValueError
        else:
            distance = i - self.start
            if distance == 0 and self:
                if start <= 0 < stop: return 0
                else: raise ValueError("Found but not within range.")
            if math_tools.get_sign(distance) != math_tools.get_sign(self.step):
                raise ValueError
            index, remainder = math_tools.cute_divmod(distance, self.step)
            if remainder == 0 and (0 <= index < self.length
                                   or index == self.length == infinity):
                if start <= index < stop: return index
                else: raise ValueError("Found but not within range.")

            else:
                raise ValueError
コード例 #11
0
ファイル: cute_range.py プロジェクト: cool-RR/python_toolbox
    def index(self, i, start=-infinity, stop=infinity):
        '''Get the index number of `i` in this `CuteRange`.'''
        from python_toolbox import math_tools
        if not isinstance(i, numbers.Number):
            raise ValueError
        else:
            distance = i - self.start
            if distance == 0 and self:
                if start <= 0 < stop: return 0
                else: raise ValueError("Found but not within range.")
            if math_tools.get_sign(distance) != math_tools.get_sign(self.step):
                raise ValueError
            index, remainder = math_tools.cute_divmod(distance, self.step)
            if remainder == 0 and (0 <= index < self.length or
                                             index == self.length == infinity):
                if start <= index < stop: return index
                else: raise ValueError("Found but not within range.")

            else:
                raise ValueError
コード例 #12
0
def test_meaningful_cases():
    if sys_tools.is_pypy:
        # todo: When version of Pypy with bug 1873 is released, remove this
        # skipping.
        raise nose.SkipTest
    meaningful_cases = (
        (infinity, 3), (infinity, 300.5), (infinity, -3), (infinity, -300.5), 
        (-infinity, 3), (-infinity, 300.5), (-infinity, -3), (-infinity, -300.5), 
        (3, infinity), (3, -infinity), (-3, infinity), (-3, -infinity), 
        (300.5, infinity), (300.5, -infinity),
                                       (-300.5, infinity), (-300.5, -infinity),
        (0, infinity), (0, -infinity),
    )
    for meaningful_numerator, meaningful_denominator in meaningful_cases:
        cute_quotient, cute_remainder = cute_divmod(meaningful_numerator,
                                                    meaningful_denominator)
        assert cute_equal(cute_quotient,
                          cute_floor_div(meaningful_numerator,
                                         meaningful_denominator))
        assert (cute_quotient ==
                          (meaningful_numerator / meaningful_denominator)) or \
        (0 <= ((meaningful_numerator / meaningful_denominator)
                                                          - cute_quotient) < 1)