Example #1
0
 def remove_expired_entries():
     almost_cutting_point = \
                           binary_search.binary_search_by_index(
         list(cached._cache.keys()),
         _get_now(),
         sorting_key_function,
         rounding=binary_search.LOW
     )
     if almost_cutting_point is not None:
         cutting_point = almost_cutting_point + 1
         for key in cached._cache.keys()[:cutting_point]:
             del cached._cache[key]
Example #2
0
 def remove_expired_entries():
     almost_cutting_point = \
                           binary_search.binary_search_by_index(
         list(cached._cache.keys()),
         sorting_key_function,
         _get_now(), 
         rounding=binary_search.LOW
     )
     if almost_cutting_point is not None:
         cutting_point = almost_cutting_point + 1
         for key in list(cached._cache.keys())[:cutting_point]:
             del cached._cache[key]
Example #3
0
 def __getitem__(self, i):
     if isinstance(i, slice):
         raise NotImplementedError
     assert isinstance(i, int)
     if i <= -1:
         i += self.length
     if i < 0:
         raise IndexError
     if self.accumulated_lengths.is_exhausted and i >= self.length:
         raise IndexError
     # Todo: Can't have a binary search here, it exhausts all the sequences.
     sequence_index = binary_search.binary_search_by_index(
         self.accumulated_lengths, i, rounding=binary_search.LOW_IF_BOTH)
     if sequence_index is None:
         raise IndexError
     sequence_start = self.accumulated_lengths[sequence_index]
     return self.sequences[sequence_index][i - sequence_start]
Example #4
0
 def __getitem__(self, i):
     if isinstance(i, slice):
         raise NotImplementedError
     assert isinstance(i, int)
     if i <= -1:
         i += self.length
     if i < 0:
         raise IndexError
     if self.accumulated_lengths.is_exhausted and i >= self.length:
         raise IndexError
     # Todo: Can't have a binary search here, it exhausts all the sequences.
     sequence_index = binary_search.binary_search_by_index(
         self.accumulated_lengths, i, rounding=binary_search.LOW_IF_BOTH
     )
     if sequence_index is None:
         raise IndexError
     sequence_start = self.accumulated_lengths[sequence_index]
     return self.sequences[sequence_index][i - sequence_start]
Example #5
0
def test():
    '''Test the basic workings of `binary_search`.'''
    my_list = [0, 1, 2, 3, 4]

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       3, binary_search.EXACT) == 3

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       3.2, binary_search.CLOSEST) == 3

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       3.2, binary_search.LOW) == 3

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       3.2, binary_search.HIGH) == 4

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       3.2, binary_search.BOTH) == (3, 4)

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       -5, binary_search.BOTH) == (None, 0)

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       -5, binary_search.LOW) == None

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       -5, binary_search.HIGH) == 0

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       -5,
                                       binary_search.HIGH_OTHERWISE_LOW) == 0

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       -5,
                                       binary_search.LOW_OTHERWISE_HIGH) == 0

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       100, binary_search.BOTH) == (4, None)

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       100, binary_search.LOW) == 4

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       100, binary_search.HIGH) == None

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       100,
                                       binary_search.LOW_OTHERWISE_HIGH) == 4

    assert binary_search.binary_search(my_list, misc_tools.identity_function,
                                       100,
                                       binary_search.HIGH_OTHERWISE_LOW) == 4

    assert binary_search.binary_search_by_index([(number * 10)
                                                 for number in my_list],
                                                misc_tools.identity_function,
                                                32,
                                                binary_search.BOTH) == (3, 4)

    assert binary_search.binary_search([], misc_tools.identity_function, 32,
                                       binary_search.BOTH) == (None, None)

    assert binary_search.binary_search(
        [],
        misc_tools.identity_function,
        32,
    ) == None
Example #6
0
def test():
    '''Test the basic workings of `binary_search`.'''
    my_list = [0, 1, 2, 3, 4]
    
    assert binary_search.binary_search(
        my_list,
        3,
        misc_tools.identity_function,
        binary_search.EXACT
    ) == 3
    
    assert binary_search.binary_search(
        my_list,
        3.2,
        misc_tools.identity_function,
        binary_search.CLOSEST
    ) == 3
    
    assert binary_search.binary_search(
        my_list,
        3.2,
        misc_tools.identity_function,
        binary_search.LOW
    ) == 3
    
    assert binary_search.binary_search(
        my_list,
        3.2,
        misc_tools.identity_function,
        binary_search.HIGH
    ) == 4
    
    assert binary_search.binary_search(
        my_list,
        3.2,
        misc_tools.identity_function,
        binary_search.BOTH
    ) == (3, 4)
    
    assert binary_search.binary_search(
        my_list,
        -5,
        misc_tools.identity_function,
        binary_search.BOTH
    ) == (None, 0)
    
    assert binary_search.binary_search(
        my_list,
        -5,
        misc_tools.identity_function,
        binary_search.LOW
    ) == None
    
    assert binary_search.binary_search(
        my_list,
        -5,
        misc_tools.identity_function,
        binary_search.HIGH
    ) == 0
    
    assert binary_search.binary_search(
        my_list,
        -5,
        misc_tools.identity_function,
        binary_search.HIGH_OTHERWISE_LOW
    ) == 0
    
    assert binary_search.binary_search(
        my_list,
        -5,
        misc_tools.identity_function,
        binary_search.LOW_OTHERWISE_HIGH
    ) == 0
    
    assert binary_search.binary_search(
        my_list,
        100,
        misc_tools.identity_function,
        binary_search.BOTH
    ) == (4, None)
    
    assert binary_search.binary_search(
        my_list,
        100,
        misc_tools.identity_function,
        binary_search.LOW
    ) == 4
    
    assert binary_search.binary_search(
        my_list,
        100,
        misc_tools.identity_function,
        binary_search.HIGH
    ) == None
    
    assert binary_search.binary_search(
        my_list,
        100,
        misc_tools.identity_function,
        binary_search.LOW_OTHERWISE_HIGH
    ) == 4
    
    assert binary_search.binary_search(
        my_list,
        100,
        misc_tools.identity_function,
        binary_search.HIGH_OTHERWISE_LOW
    ) == 4

    assert binary_search.binary_search_by_index(
        [(number * 10) for number in my_list],
        32,
        misc_tools.identity_function,
        binary_search.BOTH
    ) == (3, 4)
    
    assert binary_search.binary_search(
        [], 
        32,
        misc_tools.identity_function,
        binary_search.BOTH
    ) == (None, None)
    
    assert binary_search.binary_search(
        [], 
        32,
        misc_tools.identity_function,
    ) == None