-

cool-RR · cool-RR · commit 025b1f9ee6db · 2014-10-03T21:35:05.000+03:00
diff --git a/source_py3/python_toolbox/combi/perm_space.py b/source_py3/python_toolbox/combi/perm_space.py
@@ -237,14 +237,6 @@ def __init__(self, iterable_or_length, domain=None, *, n_elements=None,
         #                                                                     #
         ### Finished figuring out whether space is dapplied. ##################
         
-        ### Doing interim calculation of the length: ##########################
-        #                                                                     #
-        # The length calculated here will be true only for perm spaces that
-        # don't have any additional complications.
-        #                                                                     #
-        ### Finished doing interim calculation of the length. #################
-        
-        
         ### Figuring out fixed map: ###########################################
         #                                                                     #
         if fixed_map is None:
@@ -270,20 +262,6 @@ def __init__(self, iterable_or_length, domain=None, *, n_elements=None,
                 
         self.is_fixed = bool(self.fixed_map)
         if self.is_fixed:
-            if self.is_recurrent:
-                self._unsliced_undegreed_length = math_tools.shitfuck(
-                    self.n_elements - len(self.fixed_map),
-                    nifty_collections.FrozenCounterCounter(
-                        collections.Counter(self.free_values).values()
-                    )                    
-                )
-            else:
-                self._unsliced_undegreed_length = math_tools.factorial(
-                    len(self.free_indices),
-                    start=(len(self.free_indices) -
-                                       (self.n_elements - len(self.fixed_map)) + 1)
-                )
-            
             if not (self.is_dapplied or self.is_rapplied or degrees or slice_
                     or (n_elements is not None) or self.is_combination):
                 self._just_fixed = self
@@ -293,20 +271,6 @@ def __init__(self, iterable_or_length, domain=None, *, n_elements=None,
                     fixed_map=self._undapplied_unrapplied_fixed_map,
                 )
         else:
-            
-            if self.is_recurrent:
-                function_to_use = math_tools.catshit if self.is_combination else \
-                                                                math_tools.shitfuck
-                self._unsliced_undegreed_length = \
-                       function_to_use(self.n_elements, self._frozen_counter_counter)
-            else:
-                self._unsliced_undegreed_length = \
-                    math_tools.factorial(
-                        self.sequence_length,
-                        start=(self.sequence_length - self.n_elements + 1)
-                    ) // (math_tools.factorial(self.n_elements) if
-                                                        self.is_combination else 1)
-                # This division is always without a remainder, because math.
                 
             if not (self.is_dapplied or self.is_rapplied or degrees or slice_
                     or (n_elements is not None) or self.is_combination):
@@ -327,7 +291,6 @@ def __init__(self, iterable_or_length, domain=None, *, n_elements=None,
         if (not degrees) or cute_iter_tools.are_equal(degrees, all_degrees):
             self.is_degreed = False
             self.degrees = all_degrees
-            self._unsliced_length = self._unsliced_undegreed_length
         else:
             self.is_degreed = True
             if self.is_combination:
@@ -348,13 +311,6 @@ def __init__(self, iterable_or_length, domain=None, *, n_elements=None,
             self.degrees = tuple(
                 degree for degree in degrees if degree in all_degrees
             )
-            self._unsliced_length = sum(
-                math_tools.abs_stirling(
-                    self.sequence_length - len(self.fixed_map),
-                    self.sequence_length - degree -
-                                    self._n_cycles_in_fixed_items_of_just_fixed
-                ) for degree in self.degrees
-            )
             
         #                                                                     #
         ### Finished figuring out degrees. ####################################
@@ -400,6 +356,60 @@ def __init__(self, iterable_or_length, domain=None, *, n_elements=None,
     __init__.signature = inspect.signature(__init__)
             
             
+    @caching.CachedProperty
+    def _unsliced_length(self):
+        
+        if self.is_degreed:
+            assert not self.is_recurrent and not self.is_partial and \
+                                                        not self.is_combination
+            return sum(
+                math_tools.abs_stirling(
+                    self.sequence_length - len(self.fixed_map),
+                    self.sequence_length - degree -
+                                    self._n_cycles_in_fixed_items_of_just_fixed
+                ) for degree in self.degrees
+            )
+        elif self.is_fixed:
+            assert not self.is_degreed and not self.is_combination
+            if self.is_recurrent:
+                return math_tools.calculate_length_of_recurrent_perm_space(
+                    self.n_elements - len(self.fixed_map),
+                    nifty_collections.FrozenCounterCounter(
+                        collections.Counter(self.free_values).values()
+                    )                    
+                )
+            else:
+                return math_tools.factorial(
+                    len(self.free_indices),
+                    start=(len(self.free_indices) -
+                                   (self.n_elements - len(self.fixed_map)) + 1)
+                )
+            
+        else:
+            assert not self.is_degreed and not self.is_fixed
+            if self.is_recurrent:
+                if self.is_combination:
+                    return math_tools.calculate_length_of_recurrent_comb_space(
+                        self.n_elements,
+                        self._frozen_counter_counter
+                    )
+                else:
+                    return math_tools.calculate_length_of_recurrent_perm_space(
+                        self.n_elements,
+                        self._frozen_counter_counter
+                    )
+                    
+            else:
+                return math_tools.factorial(
+                    self.sequence_length,
+                    start=(self.sequence_length - self.n_elements + 1)
+                ) // (math_tools.factorial(self.n_elements) if
+                          self.is_combination else 1)
+                # This division is always without a remainder, because math.
+            
+            
+        
+            
     is_recurrent = None
     
     @caching.CachedProperty
diff --git a/source_py3/python_toolbox/math_tools/sequences.py b/source_py3/python_toolbox/math_tools/sequences.py
@@ -58,11 +58,12 @@ def abs_stirling(n, k):
     
 ###############################################################################
 
-_shitfuck_cache = {}
+_length_of_recurrent_perm_space_cache = {}
 
-def shitfuck(k, recurrence_counter):
+def calculate_length_of_recurrent_perm_space(k, recurrence_counter):
     from python_toolbox import nifty_collections
     from python_toolbox import cute_iter_tools
+    cache = _length_of_recurrent_perm_space_cache
     if not isinstance(recurrence_counter, nifty_collections.FrozenCounterCounter):
         recurrence_counter = \
                        nifty_collections.FrozenCounterCounter(recurrence_counter)
@@ -74,7 +75,7 @@ def shitfuck(k, recurrence_counter):
         # unlike Python's `Counter`.)
         return recurrence_counter.n_elements
     try:
-        return _shitfuck_cache[(k, recurrence_counter)]
+        return cache[(k, recurrence_counter)]
     except KeyError:
         pass
     
@@ -86,7 +87,7 @@ def shitfuck(k, recurrence_counter):
             {recurrence_counter_: recurrence_counter_.
                                        get_sub_counters_for_one_crate_removed()
              for recurrence_counter_ in current_reccurence_counters
-                          if (k_, recurrence_counter_) not in _shitfuck_cache}
+                          if (k_, recurrence_counter_) not in cache}
         )
         current_reccurence_counters = \
                                      set(itertools.chain(*levels[-1].values()))
@@ -95,30 +96,31 @@ def shitfuck(k, recurrence_counter):
     for k_, level in enumerate(reversed(levels), (k - len(levels) + 1)):
         if k_ == 1:
             for recurrence_counter_, sub_counters_counter in level.items():
-                _shitfuck_cache[(k_, recurrence_counter_)] = \
+                cache[(k_, recurrence_counter_)] = \
                                                  recurrence_counter_.n_elements
         else:
             for recurrence_counter_, sub_counters_counter in level.items():
-                _shitfuck_cache[(k_, recurrence_counter_)] = sum(
-                    (_shitfuck_cache[(k_ - 1, sub_counter)] * factor for
+                cache[(k_, recurrence_counter_)] = sum(
+                    (cache[(k_ - 1, sub_counter)] * factor for
                            sub_counter, factor in sub_counters_counter.items())
                 )
     
-    return _shitfuck_cache[(k, recurrence_counter)]
+    return cache[(k, recurrence_counter)]
         
     
 
 
 ###############################################################################
 
-_catshit_cache = {}
+_length_of_recurrent_comb_space_cache = {}
 
-def catshit(k, recurrence_counter):
+def calculate_length_of_recurrent_comb_space(k, recurrence_counter):
     '''
     blocktodo gotta properly name these two sons of bitches
     '''
     from python_toolbox import nifty_collections
     from python_toolbox import cute_iter_tools
+    cache = _length_of_recurrent_comb_space_cache
     if not isinstance(recurrence_counter, nifty_collections.FrozenCounterCounter):
         recurrence_counter = \
                        nifty_collections.FrozenCounterCounter(recurrence_counter)
@@ -130,7 +132,7 @@ def catshit(k, recurrence_counter):
         # unlike Python's `Counter`.)
         return recurrence_counter.n_elements
     try:
-        return _catshit_cache[(k, recurrence_counter)]
+        return cache[(k, recurrence_counter)]
     except KeyError:
         pass
     
@@ -142,7 +144,7 @@ def catshit(k, recurrence_counter):
             {recurrence_counter_: recurrence_counter_.
                     get_sub_counters_for_one_crate_and_previous_piles_removed()
              for recurrence_counter_ in current_reccurence_counters
-                            if (k_, recurrence_counter_) not in _catshit_cache}
+                            if (k_, recurrence_counter_) not in cache}
         )
         current_reccurence_counters = \
                                      set(itertools.chain(*levels[-1].values()))
@@ -151,15 +153,15 @@ def catshit(k, recurrence_counter):
     for k_, level in enumerate(reversed(levels), (k - len(levels) + 1)):
         if k_ == 1:
             for recurrence_counter_, sub_counters in level.items():
-                _catshit_cache[(k_, recurrence_counter_)] = len(sub_counters)
+                cache[(k_, recurrence_counter_)] = len(sub_counters)
         else:
             for recurrence_counter_, sub_counters in level.items():
-                _catshit_cache[(k_, recurrence_counter_)] = sum(
-                    (_catshit_cache[(k_ - 1, sub_counter)] for
+                cache[(k_, recurrence_counter_)] = sum(
+                    (cache[(k_ - 1, sub_counter)] for
                                                    sub_counter in sub_counters)
                 )
     
-    return _catshit_cache[(k, recurrence_counter)]
+    return cache[(k, recurrence_counter)]
         
     
             
diff --git a/source_py3/test_python_toolbox/test_math_tools/test_sequences.py b/source_py3/test_python_toolbox/test_math_tools/test_sequences.py
@@ -1,6 +1,6 @@
 
 
-from python_toolbox.math_tools import abs_stirling, shitfuck, catshit
+from python_toolbox.math_tools import abs_stirling, calculate_length_of_recurrent_perm_space, calculate_length_of_recurrent_comb_space
 
 
 def test_abs_stirling():
@@ -17,14 +17,14 @@ def test_abs_stirling():
     assert abs_stirling(200, 50) == 525010571470323062300307763288024029929662200077890908912803398279686186838073914722860457474159887042512346530620756231465891831828236378945598188429630326359716300315479010640625526167635598138598969330736141913019490812196987045505021083120744610946447254207252791218757775609887718753072629854788563118348792912143712216969484697600
 
 
-def test_shitfuck():
-    assert shitfuck(3, (3, 1, 1)) == 13
-    assert shitfuck(2, (3, 2, 2, 1)) == 15
-    assert shitfuck(3, (3, 2, 2, 1)) == 52
+def test_recurrent_perm_space_length():
+    assert calculate_length_of_recurrent_perm_space(3, (3, 1, 1)) == 13
+    assert calculate_length_of_recurrent_perm_space(2, (3, 2, 2, 1)) == 15
+    assert calculate_length_of_recurrent_perm_space(3, (3, 2, 2, 1)) == 52
     
 
-def test_catshit():
-    assert catshit(3, (3, 1, 1)) == 4
-    assert catshit(2, (3, 2, 2, 1)) == 9
-    assert catshit(3, (3, 2, 2, 1)) == 14
+def test_recurrent_comb_space_length():
+    assert calculate_length_of_recurrent_comb_space(3, (3, 1, 1)) == 4
+    assert calculate_length_of_recurrent_comb_space(2, (3, 2, 2, 1)) == 9
+    assert calculate_length_of_recurrent_comb_space(3, (3, 2, 2, 1)) == 14
     
