Add primitive arg that recurses all the way down

thoppe · thoppe · commit b8a3be7741f9 · 2016-02-07T18:33:28.000-05:00
diff --git a/README.md b/README.md
@@ -1,7 +1,8 @@
 # Hyperoperators
 
 [![Build Status](https://travis-ci.org/thoppe/python-hyperoperators.svg?branch=master)](https://travis-ci.org/thoppe/python-hyperoperators)
-
+[![Coverage Status](https://coveralls.io/repos/github/thoppe/python-hyperoperators/badge.svg?branch=master)](https://coveralls.io/github/thoppe/python-hyperoperators?branch=master)
+  
 `hyperop` is a small library for representing really, really, ridiculously large numbers in pure python. It does so using [hyperoperations](https://en.wikipedia.org/wiki/Hyperoperation).
 
 + Hyperoperation 0, `H0` is the [successor function](https://en.wikipedia.org/wiki/Successor_function), `H0(None, 4) = 5`
diff --git a/hyperop/hyperop.py b/hyperop/hyperop.py
@@ -22,20 +22,27 @@ def __call__(self,a,b):
 
 class hyperop(object):
     
-    def __new__(cls,n):
+    def __new__(cls,n,primitive=False):
         if n<0 or int(n) != n:
             raise ValueError(_errmsg_invalid_hyperop_n.format(n))
         
         if n==0:  return base_hyperop0()
-        if n==1:  return base_hyperop1()
-        if n==2:  return base_hyperop2()
-        if n==3:  return base_hyperop3()
+
+        if not primitive:
+            if n==1:  return base_hyperop1()
+            if n==2:  return base_hyperop2()
+            if n==3:  return base_hyperop3()
+            
         return object.__new__(cls)
     
-    def __init__(self, n):
+    def __init__(self, n, primitive=False):
         '''
         Create a hyperoperator of order n. 
+
         n must be a non-negative integer.
+        If primitive is True, evaluate everything from the successor 
+        function, otherwise hardcode in base cases all 
+        the way to exponentiation.
 
         Hyperoperation 0, H0 is the successor function, H0(None, 4) = 5
         H1 is addition, H1(2,4) = 2 + (1+1+1+1) = 6
@@ -61,7 +68,6 @@ def _repeat(self,a,b):
 
         # For successor to work properly the base case
         # needs to be incremented by one
-        
         if self.n == 1:
             yield a
 
diff --git a/tests/hyperop_test.py b/tests/hyperop_test.py
@@ -1,7 +1,29 @@
 import unittest, itertools, math
 from hyperop import hyperop
 
-testing_values = range(1,20)
+testing_values = range(1,15)
+
+#def generic_evaulation(fA, fB):
+#    for x,y in itertools.product(testing_values,repeat=2):
+#        assert( fA(x,y) == fB(x,y) )
+
+class PrimitiveSmallValues(unittest.TestCase):
+
+    def test_primitive_H1(self):
+        H = hyperop(1,primitive=True)
+        
+        for a,b in itertools.product(testing_values,repeat=2):
+            assert( H(a,b) == a+b )
+
+    def test_primitive_H2(self):
+        H = hyperop(2,primitive=True)
+        for a,b in itertools.product(testing_values,repeat=2):
+            assert( H(a,b) == a*b )
+
+    def test_primitive_H3(self):
+        H = hyperop(3,primitive=True)
+        for a,b in itertools.product(testing_values,repeat=2):
+            assert( H(a,b) == a**b )
 
 class SmallValues(unittest.TestCase):
 
