-

cool-RR · cool-RR · commit 93c9595feb9e · 2014-10-01T18:34:03.000+03:00
diff --git a/source_py3/python_toolbox/combi/perm_space.py b/source_py3/python_toolbox/combi/perm_space.py
@@ -565,8 +565,8 @@ def __getitem__(self, i):
             return self.perm_type((wip_perm_sequence_dict[k] for k in
                                    self.domain), self)
         elif self.is_recurrent:
-            assert not self.is_degreed
-            assert not self.is_sliced
+            assert not self.is_dapplied and not self.is_degreed and \
+                                                             not self.is_sliced
             available_values = list(self.sequence)
             reserved_values = list(self.fixed_map.values())
             wip_perm_sequence_dict = dict(self.fixed_map)
@@ -592,17 +592,20 @@ def __getitem__(self, i):
                     head = []
                     fixed_map_to_use = dict(wip_perm_sequence_dict)
                     n_elements_to_use = self.n_elements
-                    for i in sequence_tools.CuteRange(infinity):
+                    for k in sequence_tools.CuteRange(infinity):
                         try:
-                            head.append(wip_perm_sequence_dict[i])
+                            head.append(wip_perm_sequence_dict[k])
                         except KeyError:
                             break
                         else:
-                            del wip_perm_sequence_dict[i]
+                            del fixed_map_to_use[k]
                             n_elements_to_use -= 1
                     sequence_to_use = list(self.sequence)
                     for item in head:
                         sequence_to_use.remove(item)
+                        
+                    fixed_map_to_use = {key - len(head): value for key, value
+                                        in fixed_map_to_use.items()}
                     
                     candidate_sub_perm_space = PermSpace(
                         sequence_to_use,
diff --git a/source_py3/python_toolbox/sequence_tools/cute_range.py b/source_py3/python_toolbox/sequence_tools/cute_range.py
@@ -192,20 +192,23 @@ def __len__(self):
         # Sadly Python doesn't allow infinity or floats here.
         return self.length if isinstance(self.length, numbers.Integral) else 0
         
-    def index(self, i):
+    def index(self, i, start=-infinity, stop=infinity):
         from python_toolbox import math_tools
         if not isinstance(i, numbers.Number):
             raise ValueError
         else:
             distance = i - self.start
             if distance == 0 and self:
-                return 0
+                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):
-                return index
+                if start <= index < stop: return index
+                else: raise ValueError("Found but not within range.")
+
             else:
                 raise ValueError
             
diff --git a/source_py3/test_python_toolbox/test_combi/test_exhaustive.py b/source_py3/test_python_toolbox/test_combi/test_exhaustive.py
@@ -58,9 +58,13 @@ def _iter(self):
             if any(candidate[self.domain.index(key)] != value for
                                          key, value in self.fixed_map.items()):
                 continue
-            if self.is_combination and not cute_iter_tools.is_sorted(
-                                           candidate, key=self.sequence.index):
-                continue
+            if self.is_combination:
+                i = -1
+                for item in candidate:
+                    try:
+                        i = self.sequence.index(item, start=i+1)
+                    except ValueError:
+                        continue
             if self.is_degreed:
                 unvisited_items = \
                             set(sequence_tools.CuteRange(self.sequence_length))
