Merge remote-tracking branch 'origin/development' into development

cool-RR · cool-RR · commit 20ad363e0980 · 2016-04-22T15:18:07.000+03:00
diff --git a/source_py3/python_toolbox/cute_enum.py b/source_py3/python_toolbox/cute_enum.py
diff --git a/source_py3/python_toolbox/math_tools/misc.py b/source_py3/python_toolbox/math_tools/misc.py
@@ -3,6 +3,9 @@
 
 import numbers
 import math
+import random
+
+import python_toolbox.cute_enum
 
 
 infinity = float('inf')
@@ -153,31 +156,69 @@ def is_integer(x):
     return inted_x == x
     
     
-def cute_round(x, step=1, up=False):
+class RoundMode(python_toolbox.cute_enum.CuteEnum):
+    CLOSEST_OR_DOWN = 0
+    CLOSEST_OR_UP = 1
+    ALWAYS_DOWN = 2
+    ALWAYS_UP = 3
+    PROBABILISTIC = 4
+
+def cute_round(x, round_mode=RoundMode.CLOSEST_OR_DOWN, *, step=1):
     '''
-    Round with a chosen step.
-    
-    Examples:
+    Round a number, with lots of different options for rounding.
     
+    Basic usage:
+
         >>> cute_round(7.456)
         7
-        >>> cute_round(7.456, up=True)
-        8
-        >>> cute_round(7.456, step=0.1)
-        7.4
-        >>> cute_round(7.456, step=0.1, up=True)
-        7.5
-        >>> cute_round(7.456, step=0.2)
-        7.4
-        >>> cute_round(7.456, step=0.2, up=True)
-        7.6
-        >>> cute_round(7.456, step=0.01)
-        7.45
-        >>> cute_round(7.456, step=0.01, up=True)
-        7.46
+    
+    The optional `step=1` argument can be changed to change the definition of a
+    round number. e.g., if you set `step=100`, then 1234 will be rounded to
+    1200. `step` doesn't have to be an integer.
+        
+    There are different rounding modes:
+
+        RoundMode.CLOSEST_OR_DOWN
+        
+            Default mode: Round to the closest round number. If we're smack in
+            the middle, like 4.5, round down to 4.
+            
+        RoundMode.CLOSEST_OR_UP
+        
+            Round to the closest round number. If we're smack in the middle,
+            like 4.5, round up to 5.
+
+        RoundMode.ALWAYS_DOWN
+        
+            Always round down. Even 4.99 gets rounded down to 4.
+
+        RoundMode.ALWAYS_UP
+        
+            Always round up. Even 4.01 gets rounded up to 5.
+        
+        RoundMode.PROBABILISTIC
+        
+            Probabilistic round, giving a random result depending on how close
+            the number is to each of the two surrounding round numbers. For
+            example, if you round 4.5 with this mode, you'll get either 4 or 5
+            with an equal probability. If you'll round 4.1 with this mode,
+            there's a 90% chance you'll get 4, and a 10% chance you'll get 5.
+            
         
     '''
+    assert step > 0
     div, mod = divmod(x, step)
-    return (div + bool(mod and up)) * step
+    if round_mode == RoundMode.CLOSEST_OR_DOWN:
+        round_up = (mod > 0.5 * step)
+    elif round_mode == RoundMode.CLOSEST_OR_UP:
+        round_up = (mod >= 0.5 * step)
+    elif round_mode == RoundMode.ALWAYS_DOWN:
+        round_up = False
+    elif round_mode == RoundMode.ALWAYS_UP:
+        round_up = True
+    else:
+        assert round_mode == RoundMode.PROBABILISTIC
+        round_up = random.random() < mod / step
+    return (div + round_up) * step
     
     
diff --git a/source_py3/python_toolbox/math_tools/statistics.py b/source_py3/python_toolbox/math_tools/statistics.py
@@ -29,4 +29,4 @@ def get_mean(iterable):
         sum_ += value
     return sum_ / (i + 1)
 
-        
+        
diff --git a/source_py3/python_toolbox/nifty_collections/__init__.py b/source_py3/python_toolbox/nifty_collections/__init__.py
@@ -11,7 +11,7 @@
 from .various_frozen_dicts import FrozenDict, FrozenOrderedDict
 from .bagging import Bag, OrderedBag, FrozenBag, FrozenOrderedBag
 from .frozen_bag_bag import FrozenBagBag
-from .cute_enum import CuteEnum
+from ..cute_enum import CuteEnum
 
 from .emitting_weak_key_default_dict import EmittingWeakKeyDefaultDict
 
diff --git a/source_py3/python_toolbox/sequence_tools/misc.py b/source_py3/python_toolbox/sequence_tools/misc.py
@@ -320,4 +320,43 @@ def divide_to_slices(sequence, n_slices):
     return [sequence[x:y] for x, y in
                      cute_iter_tools.iterate_overlapping_subsequences(indices)]
 
+    
+def is_subsequence(big_sequence, small_sequence):
+    '''
+    Check whether `small_sequence` is a subsequence of `big_sequence`.
+    
+    For example:
+    
+        >>> is_subsequence([1, 2, 3, 4], [2, 3])
+        True
+        >>> is_subsequence([1, 2, 3, 4], [4, 5])
+        False
+        
+    This can be used on any kind of sequence, including tuples, lists and
+    strings.
+    '''
+    from python_toolbox import nifty_collections
+    big_sequence = ensure_iterable_is_sequence(big_sequence,
+                                               allow_unordered=False)
+    small_sequence = ensure_iterable_is_sequence(small_sequence,
+                                                 allow_unordered=False)
+    small_sequence_length = len(small_sequence)
+    last_index_that_subsequence_can_start = \
+                                    len(big_sequence) - len(small_sequence) + 1
+    matches = {}
+    for i, item in enumerate(big_sequence):
+        if matches:
+            new_matches = {}
+            for match_position, match_length in matches.items():
+                if small_sequence[match_length] == item:
+                    new_matches[match_position] = match_length + 1
+            matches = new_matches
+        if (item == small_sequence[0]) and \
+                                   (i < last_index_that_subsequence_can_start):
+            matches[i] = 1
+        for match_position, match_length in matches.items():
+            if match_length == small_sequence_length:
+                return True
+        
+        
     
diff --git a/source_py3/test_python_toolbox/test_math_tools/test_cute_round.py b/source_py3/test_python_toolbox/test_math_tools/test_cute_round.py
@@ -1,18 +1,107 @@
 # Copyright 2009-2015 Ram Rachum.
 # This program is distributed under the MIT license.
 
-from python_toolbox.math_tools import cute_round
+import inspect
+
+from python_toolbox import nifty_collections
+
+from python_toolbox.math_tools import cute_round, RoundMode
 
 def almost_equals(x, y):
     return (abs(1-(x / y)) < (10 ** -10))
     
 
-def test_cute_round():
-    assert almost_equals(cute_round(7.456), 7)
-    assert almost_equals(cute_round(7.456, up=True), 8)
-    assert almost_equals(cute_round(7.456, step=0.1), 7.4)
-    assert almost_equals(cute_round(7.456, step=0.1, up=True), 7.5)
-    assert almost_equals(cute_round(7.456, step=0.2), 7.4)
-    assert almost_equals(cute_round(7.456, step=0.2, up=True), 7.6)
-    assert almost_equals(cute_round(7.456, step=0.01), 7.45)
-    assert almost_equals(cute_round(7.456, step=0.01, up=True), 7.46)
+class CuteRoundTestCase:
+    def test_closest_or_down(self):
+        full_arg_spec = inspect.getfullargspec(cute_round)
+        assert RoundMode.CLOSEST_OR_DOWN in full_arg_spec.defaults
+                                                          
+        assert almost_equals(cute_round(7.456), 7)
+        assert almost_equals(cute_round(7.654), 8)
+        assert almost_equals(cute_round(7.5), 7)
+        assert almost_equals(cute_round(7.456, step=0.1), 7.5)
+        assert almost_equals(cute_round(7.456, step=0.2), 7.4)
+        assert almost_equals(cute_round(7.456, step=0.01), 7.46)
+        
+    def test_closest_or_up(self):
+        assert almost_equals(
+            cute_round(7.456, RoundMode.CLOSEST_OR_UP), 7
+        )
+        assert almost_equals(
+            cute_round(7.654, RoundMode.CLOSEST_OR_UP), 8
+        )
+        assert almost_equals(
+            cute_round(7.5, RoundMode.CLOSEST_OR_UP), 8
+        )
+        assert almost_equals(
+            cute_round(7.456, RoundMode.CLOSEST_OR_UP, step=0.1), 7.5
+        )
+        assert almost_equals(
+            cute_round(7.456, RoundMode.CLOSEST_OR_UP, step=0.2), 7.4
+        )
+        assert almost_equals(
+            cute_round(7.456, RoundMode.CLOSEST_OR_UP, step=0.01), 7.46
+        )
+        
+    def test_always_up(self):
+        assert almost_equals(
+            cute_round(7.456, RoundMode.ALWAYS_UP), 8
+        )
+        assert almost_equals(
+            cute_round(7.654, RoundMode.ALWAYS_UP), 8
+        )
+        assert almost_equals(
+            cute_round(7.5, RoundMode.ALWAYS_UP), 8
+        )
+        assert almost_equals(
+            cute_round(7.456, RoundMode.ALWAYS_UP, step=0.1), 7.5
+        )
+        assert almost_equals(
+            cute_round(7.456, RoundMode.ALWAYS_UP, step=0.2), 7.6
+        )
+        assert almost_equals(
+            cute_round(7.456, RoundMode.ALWAYS_UP, step=0.01), 7.46
+        )
+        
+    def test_always_down(self):
+        assert almost_equals(
+            cute_round(7.456, RoundMode.ALWAYS_DOWN), 7
+        )
+        assert almost_equals(
+            cute_round(7.654, RoundMode.ALWAYS_DOWN), 7
+        )
+        assert almost_equals(
+            cute_round(7.5, RoundMode.ALWAYS_DOWN), 7
+        )
+        assert almost_equals(
+            cute_round(7.456, RoundMode.ALWAYS_DOWN, step=0.1), 7.4
+        )
+        assert almost_equals(
+            cute_round(7.456, RoundMode.ALWAYS_DOWN, step=0.2), 7.4
+        )
+        assert almost_equals(
+            cute_round(7.456, RoundMode.ALWAYS_DOWN, step=0.01), 7.45
+        )
+        
+    def test_probabilistic(self):
+        def get_bag(*args, **kwargs):
+            kwargs.update({'round_mode': RoundMode.PROBABILISTIC,})
+            return nifty_collections.Bag(
+                cute_round(*args, **kwargs) for i in range(1000)
+            )
+            
+        bag = get_bag(5, step=5)
+        assert bag[5] == 1000
+        
+        bag = get_bag(6, step=5)
+        assert 300 <= bag[5] <= 908
+        assert 2 <= bag[10] <= 600
+        
+        bag = get_bag(7.5, step=5)
+        assert 100 <= bag[5] <= 900
+        assert 100 <= bag[10] <= 900
+        
+        bag = get_bag(10, step=5)
+        assert bag[10] == 1000
+                
+            
diff --git a/source_py3/test_python_toolbox/test_sequence_tools/test_is_subsequence.py b/source_py3/test_python_toolbox/test_sequence_tools/test_is_subsequence.py
@@ -0,0 +1,40 @@
+# Copyright 2009-2015 Ram Rachum.
+# This program is distributed under the MIT license.
+
+from python_toolbox import cute_testing
+from python_toolbox import sequence_tools
+from python_toolbox.sequence_tools import is_subsequence
+
+
+
+def test():
+    true_pairs = (
+        ([1, 2, 3, 4], [2, 3]),
+        ([1, 2, 3, 4], (2, 3)),
+        ([1, 2, 'meow', 3, 4], (2, 'meow', 3)),
+        ('abracadabra', 'cad'),
+        ('abracadabra', 'dab'),
+        ('abracadabra', 'a'),
+        ('abracadabra', 'ab'),
+        ('abracadabra', 'bra'),
+        (range(10000), (range(7, 14))),
+        (range(10000), [99]),
+    )
+    false_pairs = (
+        ([1, 2, 3, 4], [2, 4]),
+        ([1, 2, 3, 4], (2, 4)),
+        ([1, 2, 'meow', 3, 4], (2, 3)),
+        ('abracadabra', 'cab'),
+        ('abracadabra', 'darb'),
+        ('abracadabra', 'z'),
+        ('abracadabra', 'bab'),
+        ('abracadabra', 'arb'),
+        (range(10000), (range(14, 7, -1))),
+        (range(100), [100]),
+        (range(100), [109]),
+    )
+    
+    for true_pair in true_pairs:
+        assert is_subsequence(*true_pair)
+    for false_pair in false_pairs:
+        assert not is_subsequence(*false_pair)
