-

cool-RR · cool-RR · commit 5dbfa727d6d1 · 2014-09-19T23:40:05.000+03:00
diff --git a/source_py3/python_toolbox/combi/perm.py b/source_py3/python_toolbox/combi/perm.py
@@ -203,23 +203,35 @@ def number(self):
                   self.just_dapplied_rapplied_perm_space.n_unused_elements)
             
     
+    is_infinite = caching.CachedProperty(
+        lambda self: self.just_dapplied_rapplied_perm_space.is_infinite
+    )
+    
     @caching.CachedProperty
     @nifty_collections.LazyTuple.factory()
     def _perm_sequence(self):
         assert (0 <= self.number < 
                                  self.just_dapplied_rapplied_perm_space.length)
+        n_digits_pad = 0 if self.is_infinite else self.length
         factoradic_number = math_tools.to_factoradic(
             self.number * math.factorial(
                  self.just_dapplied_rapplied_perm_space.n_unused_elements),
-            n_digits_pad=self.just_dapplied_rapplied_perm_space.sequence_length
+            n_digits_pad=n_digits_pad
         )
         if self.is_partial:
+            assert not self.is_infinite
             factoradic_number = factoradic_number[
                 :-self.just_dapplied_rapplied_perm_space.n_unused_elements
             ]
         unused_numbers = list(self.just_dapplied_rapplied_perm_space.sequence,)
         result = tuple(unused_numbers.pop(factoradic_digit) for
                        factoradic_digit in factoradic_number)
+        if self.is_infinite:
+            from .chain_space import ChainSpace
+            result = ChainSpace((
+                result,
+                sequence_tools.CuteRange(len(result), infinity)
+            ))
         assert len(result) == self.length
         return result
     
diff --git a/source_py3/python_toolbox/combi/perm_space.py b/source_py3/python_toolbox/combi/perm_space.py
@@ -902,6 +902,11 @@ def _coerce_perm(self, perm):
         return Perm(perm, self)
         
         
+    is_infinite = caching.CachedProperty(
+        lambda self: self.sequence_length == infinity
+    )
+    
+
 infinite_pure_perm_space = PermSpace(infinity)
 
 
diff --git a/source_py3/python_toolbox/math_tools/factorials.py b/source_py3/python_toolbox/math_tools/factorials.py
@@ -4,6 +4,7 @@
 import math
 import collections
 import itertools
+import numbers
 
 infinity = float('inf')
 infinities = (infinity, -infinity)
@@ -85,7 +86,7 @@ def from_factoradic(factoradic_number):
     return number
         
 
-def to_factoradic(number, n_digits_pad=None):
+def to_factoradic(number, n_digits_pad=0):
     '''
     Convert a number to factoradic representation (in a tuple.)
     
@@ -106,6 +107,7 @@ def to_factoradic(number, n_digits_pad=None):
     '''
     assert isinstance(number, int)
     assert number >= 0
+    assert isinstance(n_digits_pad, numbers.Integral)
     n_digits = inverse_factorial(number, round_up=False) + 1
     digits = [None] * n_digits
     current_number = number
@@ -114,7 +116,7 @@ def to_factoradic(number, n_digits_pad=None):
         digits[n_digits - i - 1], current_number = \
                                                    divmod(current_number, unit)
     result = tuple(digits)
-    if n_digits_pad and (len(result) < n_digits_pad):
+    if (len(result) < n_digits_pad):
         return ((0,) * (n_digits_pad - len(result))) + result
     else:
         return result
diff --git a/source_py3/python_toolbox/sequence_tools/__init__.py b/source_py3/python_toolbox/sequence_tools/__init__.py
@@ -1,3 +1,4 @@
 
 from .misc import *
-from .cute_range import CuteRange
+from .cute_range import CuteRange
+from .sequence_view import SequenceView
diff --git a/source_py3/python_toolbox/sequence_tools/sequence_view.py b/source_py3/python_toolbox/sequence_tools/sequence_view.py
@@ -0,0 +1,51 @@
+import abc
+import builtins
+import types
+import collections
+import numbers
+
+from python_toolbox import caching
+
+from .misc import CuteSequence
+
+infinity = float('inf')
+infinities = (infinity, -infinity)
+
+
+class SequenceView(CuteSequence):
+    def __init__(self, sequence, indices=None):
+        self.sequence = sequence
+        if indices is not None:
+            self.indices = indices
+
+    indices = caching.CachedProperty(
+                                  lambda self: list(range(len(self.sequence))))
+        
+    def __getitem__(self, index):
+        return self.sequence[self.indices[index]]
+
+    def __iter__(self):
+        yield from map(self.sequence.__getitem__, self.indices)
+
+    __contains__ = lambda self: any(item == value for value in self)
+
+    def __reversed__(self):
+        yield from map(self.sequence.__getitem__, reversed(self.indices))
+
+    # Can't defined `index` which uses the wrapped sequence's `index` because
+    # `index` stops on the first occurrence, and if our first occurrence was
+    # removed, we'd need to search for the next one.
+
+    def _nopity_nope_nope(self, item):
+        raise TypeError("Can't add stuff to a `VirtualPopper`")
+    extend = insert = append = _nopity_nope_nope
+    
+    clear = lambda self: self.sequence.clear()
+    copy = lambda self: type(self)(self.sequence, indices=self.indices)
+    reverse = lambda self: self.indices.reverse()
+    
+    # This are the money methods right here:
+    pop = lambda self, i: self.sequence[self.indices.pop(i)]
+    remove = lambda self, item: self.indices.remove(self.sequence.index(item))
+    
+        
