-

cool-RR · cool-RR · commit 0b42cb48f79c · 2014-09-24T21:54:06.000+03:00
diff --git a/source_py3/python_toolbox/combi/perm_space.py b/source_py3/python_toolbox/combi/perm_space.py
@@ -28,7 +28,6 @@
 infinity = float('inf')
 
 
-
 class PermSpaceType(abc.ABCMeta):
     '''
     Metaclass for `PermSpace` and `CombSpace`.
@@ -82,55 +81,37 @@ class PermSpace(sequence_tools.CuteSequenceMixin, collections.Sequence,
     of a second as well.
     
     There are several variations that a perm space could have:
-     - Rapplied (Range-applied): having an arbitrary sequence as a range. To
-       make one, pass your sequence as the first argument.
-     - Dapplied (Domain-applied): having an arbitrary sequence as a domain. To make one, pass a sequence into the `domain` argument.
+     - Rapplied (Range-applied): having an arbitrary sequence as a range.
+       To make one, pass your sequence as the first argument.
+     - Dapplied (Domain-applied): having an arbitrary sequence as a domain.
+       To make one, pass a sequence into the `domain` argument.
      - Fixed: Having a specified number of indices always pointing at certain
-       values, making the space smaller. To make one, pass a dict from each key to the value it should be fixed to to argument `fixed_map`
+       values, making the space smaller. To make one, pass a dict from each
+       key to the value it should be fixed to as the argument `fixed_map`.
      - Sliced: A perm space can be sliced like any Python sequence (except you
-       can't change the step.) To make one, use slice notation on an existing perm space.
+       can't change the step.) To make one, use slice notation on an existing
+       perm space, e.g. perm_space[56:100]
      - Degreed: A perm space can be limited to perms of a certain degree. (A
        perm's degree is the number of transformations it takes to make it.)
-     - Partialled: A perm space can be partial, in which case not all elements
+       To make one, pass into the `degrees` argument either a single degree
+       (like `5`) or a tuple of different degrees (like `(1, 3, 7)`)
+     - Partial: A perm space can be partial, in which case not all elements
        are used in perms. E.g. you can have a perm space of a sequence of
-       length 5 but with `n_elements=3`, so every perm will have only 3
+       length 5 but with `n_elements=3`, so every perm will have only 3 items.
+       To make one, pass a number as the argument `n_elements`.
      - Combination: If you pass in `is_combination=True` or use the subclass
        `CombSpace`, then you'll have a space of combinations (combs) instead of
        perms. Combs are like perms except there's no order to the elements.
 
-    
-    Instead of a number, you can also pass a sequence as the first argument,
-    and the `PermSpace` will use that rather than a range. Such a `PermSpace`
-    is called "rapplied", which is short for range-applied. It'll have a
-    property `.unrapplied` which'll give you a non-rapplied version of that
-    perm space. You can also take any perm space and use the `.get_rapplied`
-    method on it to get that space range-applied to a sequence that you
-    provide.
-    
-    You may pass a sequence as the `domain` argument, and it'll be used as the
-    indices for the permutations. (i.e., if the permutations are seen as a
-    function, `domain` is the domain of the function.)
-    
-    You may pass a number as `n_elements` in order to make a partial
-    permutation space. That number must be smaller than the size of the
-    sequence, and every permutation will have only that number of items. This
-    means that permutations will not use all the items in `sequence` but just
-    some of them.
-    
-    You may pass in a `dict` for the argument `fixed_map` that'll map between
-    indices and values that should remain fixed in the permutation space. Only
-    the non-fixed items will be allowed to change between permutations.
-    
-    You may pass in a list of integers as `degrees`, and then only permutations
-    with those degrees will be included in the space. (A degree of a
-    permutation stands for that number of transformations (single switches
-    between items) that are needed to create that permutation. )
-    
-    A permutation space can be sliced by using regular Python slice notation.
-    
     Note: Some of the options are not allowed to be used with each other.
     
-    Some clarification  on terminology <blocktododoc> rapplied, dapplied "just" etc.
+    For each of these variations, there's a function to make a perm space have
+    that variation and get rid of it. For example, if you want to make a normal
+    perm space be degreed, call `.get_degreed()` on it with the desired
+    degrees. If you want to make a degreed perm space non-degreed, access its
+    `.undegreed` property. The same is true for all other variations.
+    
+    A perm space that has none of these variations is called pure.
     '''
     
     @classmethod
