0.0.4 --> 0.1.0

Revert function previously split into 3 parts into single `factor()`

Author: bellert

README.rst

@@ -3,7 +3,7 @@ Demo of Factoring
 
 Integer factoring is the decomposition of an integer into factors that, when multiplied together, give the original
 number. For example, the factors of 15 are 3 and 5.
- 
+
 D-Wave quantum computers allow us to factor numbers in an entirely new way, by turning a multiplication circuit into a
 constraint satisfaction problem that allows the quantum computer to compute inputs from a predefined output.
 Essentially, this means running the multiplication circuit in reverse!
@@ -38,13 +38,13 @@ appropriate location for the given OS and virtual environment configuration. Thi
   >>> from penaltymodel_cache import cache_file
   >>> cache_file()
   '/home/bellert/git_root/factoring-demo/env/data/dwave-penaltymodel-cache/penaltymodel_cache_v0.2.0.db'
-  
+
 A minimal working example using the main interface function can be seen by running:
 
 .. code-block:: bash
 
   python demo.py
-  
+
 The user is prompted to enter a six-bit integer: P, which represents a product to be factored.
 
 .. code-block::
@@ -53,12 +53,12 @@ The user is prompted to enter a six-bit integer: P, which represents a product t
 
 The algorithm returns possible A and B values, which are the inputs the circuit multiplies to calculate the product, P.
 
-By default, the function that sends the problem to the QPU uses a saved embedding. This can be overriden and the code to
-calculate a new embedding can be called by using:
+By default, the main interface function uses a saved embedding. This can be overriden and the code to calculate a new
+embedding can be called by using:
 
 .. code-block:: python
 
-  submit_factor_bqm(bqm, use_saved_embedding=False)
+  factor(P, use_saved_embedding=False)
 
 License
 -------

demo.py

@@ -2,7 +2,7 @@
 
 from pprint import pprint
 
-from factoring.interfaces import get_factor_bqm, submit_factor_bqm, postprocess_factor_response
+from factoring.interfaces import factor
 
 _PY2 = sys.version_info.major == 2
 if _PY2:
@@ -33,12 +33,10 @@ def sanitised_input(description, variable, range_):
     # get input from user
     print("Enter a number to be factored:")
     P = sanitised_input("product", "P", range(2 ** 6))
-    bqm = get_factor_bqm(P)
 
     # send problem to QPU
     print("Running on QPU")
-    response = submit_factor_bqm(bqm)
+    output = factor(P)
 
     # output results
-    output = postprocess_factor_response(response, P)
     pprint(output)

factoring/interfaces.py

@@ -26,7 +26,7 @@ def validate_input(ui, range_):
         raise ValueError("Input must be between {} and {}".format(start, stop))
 
 
-def get_factor_bqm(P):
+def factor(P, use_saved_embedding=True):
     validate_input(P, range(2 ** 6))
 
     # get circuit
@@ -43,10 +43,6 @@ def get_factor_bqm(P):
         bqm.fix_variable(var, value)
     log.debug('bqm construction time: %s', time.time() - construction_start_time)
 
-    return bqm
-
-
-def submit_factor_bqm(bqm, use_saved_embedding=True):
     # find embedding and put on system
     sampler = DWaveSampler()
 
@@ -82,10 +78,6 @@ def submit_factor_bqm(bqm, use_saved_embedding=True):
     response = dimod.unembed_response(response, embedding, source_bqm=bqm)
     logging.debug('embedding and sampling time: %s', time.time() - sample_time)
 
-    return response
-
-
-def postprocess_factor_response(response, P):
     output = {"results": [],
                 #    {
                 #        "a": Number,

factoring/package_info.py

@@ -1,4 +1,4 @@
-__version__ = '0.0.4'
+__version__ = '0.1.0'
 __author__ = 'D-Wave Systems Inc.'
 __authoremail__ = '[email protected]'
 __description__ = 'Demo of factoring a 6-bit integer by embedding a 3-bit multiplier on the D-Wave QPU'

tests/test_interfaces.py

@@ -1,16 +1,14 @@
 import unittest
 from random import randint
 
-from factoring.interfaces import get_factor_bqm, submit_factor_bqm, postprocess_factor_response
+from factoring.interfaces import factor
 
 
 class TestInterfaces(unittest.TestCase):
 
     def test_factor_output(self):
         P = randint(0, 2**6-1)
-        bqm = get_factor_bqm(P)
-        response = submit_factor_bqm(bqm)
-        output = postprocess_factor_response(response, P)
+        output = factor(P)
 
         self.assertSetEqual(set(output), {'results', 'numberOfReads'})
         for result in output['results']:
@@ -24,13 +22,11 @@ def test_factor_output(self):
 
     def test_factor_invalid(self):
         for P in [-1, 64, 'a']:
-            self.assertRaises(ValueError, get_factor_bqm, P)
+            self.assertRaises(ValueError, factor, P)
 
     @unittest.skip("not robust enough yet")
     def test_factor_validity(self):
         for P in {a*b for a in range(2**3) for b in range(2**3)}:
-            bqm = get_factor_bqm(P)
-            response = submit_factor_bqm(bqm)
-            output = postprocess_factor_response(response, P)
+            output = factor(P)
 
             self.assertTrue(output['results'][0]['valid'])