-

cool-RR · cool-RR · commit 135a4f2a52d2 · 2014-09-19T22:49:54.000+03:00
diff --git a/source_py3/python_toolbox/math_tools/factorials.py b/source_py3/python_toolbox/math_tools/factorials.py
@@ -11,14 +11,23 @@
 
 def factorial(x, start=1):
     '''
+    Calculate a factorial
     
     This differs from the built-in `math.factorial` in that it allows a `start`
-    argument.
+    argument. If one is given, the function returns `(x!)/(start!)`.
     '''
     from python_toolbox import misc_tools
     return misc_tools.general_product(range(start, x+1), start=1)
 
-def reverse_factorial(number, round_up=True):
+
+def inverse_factorial(number, round_up=True):
+    '''
+    Get the integer that the factorial of would be `number`.
+    
+    If `number` isn't a factorial of an integer, the result will be rounded. By
+    default it'll be rounded up, but you can specify `round_up=False` to have
+    it be rounded down.
+    '''
     assert number >= 0
     if number == 0:
         return 0
@@ -37,6 +46,13 @@ def reverse_factorial(number, round_up=True):
         
     
 def from_factoradic(factoradic_number):
+    '''
+    Get the integer that the factorial of would be `number`.
+    
+    If `number` isn't a factorial of an integer, the result will be rounded. By
+    default it'll be rounded up, but you can specify `round_up=False` to have
+    it be rounded down.
+    '''
     from python_toolbox import sequence_tools
     assert isinstance(factoradic_number, collections.Iterable)
     factoradic_number = \
@@ -51,7 +67,7 @@ def from_factoradic(factoradic_number):
 def to_factoradic(number, n_digits_pad=None):
     assert isinstance(number, int)
     assert number >= 0
-    n_digits = reverse_factorial(number, round_up=False) + 1
+    n_digits = inverse_factorial(number, round_up=False) + 1
     digits = [None] * n_digits
     current_number = number
     for i in range(n_digits)[::-1]:
diff --git a/source_py3/test_python_toolbox/test_math_tools/test_factorials.py b/source_py3/test_python_toolbox/test_math_tools/test_factorials.py
@@ -1,26 +1,26 @@
-from python_toolbox.math_tools import (reverse_factorial, from_factoradic,
+from python_toolbox.math_tools import (inverse_factorial, from_factoradic,
                                        to_factoradic)
 
-def test_reverse_factorial():
-    assert reverse_factorial(0, round_up=True) == 0
-    assert reverse_factorial(0, round_up=False) == 0
-    assert reverse_factorial(1, round_up=True) == 1
-    assert reverse_factorial(1, round_up=False) == 1
-    assert reverse_factorial(2, round_up=True) == 2
-    assert reverse_factorial(2, round_up=False) == 2
-    assert reverse_factorial(6, round_up=True) == 3
-    assert reverse_factorial(6, round_up=False) == 3
-    assert reverse_factorial(24, round_up=True) == 4
-    assert reverse_factorial(24, round_up=False) == 4
+def test_inverse_factorial():
+    assert inverse_factorial(0, round_up=True) == 0
+    assert inverse_factorial(0, round_up=False) == 0
+    assert inverse_factorial(1, round_up=True) == 1
+    assert inverse_factorial(1, round_up=False) == 1
+    assert inverse_factorial(2, round_up=True) == 2
+    assert inverse_factorial(2, round_up=False) == 2
+    assert inverse_factorial(6, round_up=True) == 3
+    assert inverse_factorial(6, round_up=False) == 3
+    assert inverse_factorial(24, round_up=True) == 4
+    assert inverse_factorial(24, round_up=False) == 4
     
-    assert reverse_factorial(25, round_up=True) == 5
-    assert reverse_factorial(25, round_up=False) == 4
-    assert reverse_factorial(26, round_up=True) == 5
-    assert reverse_factorial(26, round_up=False) == 4
-    assert reverse_factorial(0.1, round_up=True) == 1
-    assert reverse_factorial(0.1, round_up=False) == 0
-    assert reverse_factorial(1.1, round_up=True) == 2
-    assert reverse_factorial(1.1, round_up=False) == 1
+    assert inverse_factorial(25, round_up=True) == 5
+    assert inverse_factorial(25, round_up=False) == 4
+    assert inverse_factorial(26, round_up=True) == 5
+    assert inverse_factorial(26, round_up=False) == 4
+    assert inverse_factorial(0.1, round_up=True) == 1
+    assert inverse_factorial(0.1, round_up=False) == 0
+    assert inverse_factorial(1.1, round_up=True) == 2
+    assert inverse_factorial(1.1, round_up=False) == 1
 
 
 def test_factoradics():
