-

cool-RR · cool-RR · commit 79e5b8e2cacb · 2014-09-20T13:28:11.000+03:00
diff --git a/source_py3/python_toolbox/combi/perm.py b/source_py3/python_toolbox/combi/perm.py
@@ -58,7 +58,8 @@ class Perm(sequence_tools.CuteSequenceMixin, collections.Sequence,
     
     @classmethod
     def coerce(cls, item, perm_space=None):
-        if isinstance(item, Perm) and (item.just_dapplied_rapplied_perm_space
+        if isinstance(item, Perm) and (perm_space is not None) and \
+           (item.just_dapplied_rapplied_perm_space
                               == perm_space.just_dapplied_rapplied_perm_space):
             return item
         else:
diff --git a/source_py3/python_toolbox/nifty_collections/__init__.py b/source_py3/python_toolbox/nifty_collections/__init__.py
@@ -5,11 +5,13 @@
 
 from .ordered_dict import OrderedDict
 from .ordered_set import OrderedSet
+from .sorted_set import SortedSet
 from .weak_key_default_dict import WeakKeyDefaultDict
 from .weak_key_identity_dict import WeakKeyIdentityDict
 from .lazy_tuple import LazyTuple
 from .frozen_dict import FrozenDict
 from .frozen_counter import FrozenCounter
+from .integer_set import IntegerSet
 
 from .emitting_ordered_set import EmittingOrderedSet
 from .emitting_weak_key_default_dict import EmittingWeakKeyDefaultDict
diff --git a/source_py3/python_toolbox/nifty_collections/integer_set.py b/source_py3/python_toolbox/nifty_collections/integer_set.py
@@ -0,0 +1,18 @@
+# Copyright 2009-2014 Ram Rachum.
+# This program is distributed under the MIT license.
+
+import threading
+import collections
+import itertools
+
+from python_toolbox import decorator_tools
+from python_toolbox import comparison_tools
+
+infinity = float('inf')
+
+
+@comparison_tools.total_ordering    
+class IntegerSet(collections.Set):
+    def __init__(self, iterable):
+        self.integers = 
+        
diff --git a/source_py3/python_toolbox/nifty_collections/sorted_set.py b/source_py3/python_toolbox/nifty_collections/sorted_set.py
@@ -0,0 +1,31 @@
+# Copyright 2009-2014 Ram Rachum.
+# This program is distributed under the MIT license.
+
+import collections
+
+from python_toolbox import comparison_tools
+from python_toolbox import misc_tools
+
+from .ordered_set import OrderedSet, KEY, PREV, NEXT
+
+
+class SortedSet(OrderedSet):
+    
+    def __init__(self, iterable=None, key=None, reverse=False):
+        super().__init__(iterable=iterable)
+        self._key = key if (key is not None) else misc_tools.identity_function
+        self._reverse = reverse
+        
+
+    _sort = lambda self: self.sort(key=self._key, reverse=self._reverse)
+
+    def add(self, key):
+        """
+        Add an element to a set.
+    
+        This has no effect if the element is already present.
+        """
+        super().add(key)
+        self._sort()
+        
+        
diff --git a/source_py3/test_python_toolbox/test_combi/test_perm_space.py b/source_py3/test_python_toolbox/test_combi/test_perm_space.py
@@ -32,6 +32,8 @@ def test_perm_spaces():
     assert not pure_0a.is_dapplied
     assert not pure_0a.is_fixed
     assert not pure_0a.is_sliced
+    assert not pure_0a.is_infinite
+    
     
     first_perm = pure_0a[0]
     some_perm = pure_0a[7]
@@ -51,6 +53,14 @@ def test_perm_spaces():
     assert set(some_perm) == set(range(4))
     assert tuple(first_perm) == (0, 1, 2, 3)
     assert tuple(last_perm) == (3, 2, 1, 0)
+    assert Perm.coerce(first_perm) == first_perm
+    assert Perm.coerce(tuple(first_perm)) == first_perm
+    assert Perm.coerce(list(first_perm)) == first_perm
+    assert Perm.coerce(tuple(first_perm), pure_0a) == first_perm
+    assert Perm.coerce(list(first_perm), pure_0b) == first_perm
+    assert Perm.coerce(tuple(first_perm), PermSpace(5, n_elements=4)) != \
+                                                                     first_perm
+    
     
     assert isinstance(first_perm.items, combi.perm.PermItems)
     assert first_perm.items[2] == (2, 2)
@@ -467,11 +477,13 @@ def test_neighbors():
     
 
 def test_infinite_perm_space():
-    perm_space = PermSpace(sequence_tools.CuteRange(infinity))
-    assert perm_space.length == infinity
-    assert perm_space == infinite_pure_perm_space
-    assert perm_space[100].length == infinity
-    assert perm_space.index(perm_space[100]) == 100
+    assert infinite_pure_perm_space == \
+                                  PermSpace(sequence_tools.CuteRange(infinity))
+    assert infinite_pure_perm_space.length == infinity
+    assert infinite_pure_perm_space.is_infinite
+    assert infinite_pure_perm_space[100].length == infinity
+    assert infinite_pure_perm_space.index(infinite_pure_perm_space[100]) == 100
+    assert Perm(100) == infinite_pure_perm_space[100]
     
     
 
