Merge pull request #98 from ampolloreno/DJ-fixes

fixing dj padding of strings and job result handling

examples/DeutschJosza.ipynb

@@ -10,17 +10,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 1,
+   "metadata": {},
    "outputs": [],
    "source": [
     "from collections import defaultdict\n",
+    "from mock import patch, Mock\n",
+    "from itertools import product\n",
+    "\n",
     "from pyquil.api import SyncConnection\n",
+    "from pyquil.job_results import JobResult, wait_for_job\n",
     "import numpy as np\n",
-    "from mock import patch\n",
-    "from itertools import product\n",
     "\n",
     "from grove.deutsch_jozsa.deutsch_jozsa import DeutschJosza"
    ]
@@ -34,7 +34,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -57,10 +57,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 3,
+   "metadata": {},
    "outputs": [],
    "source": [
     "for value in constant_bitmap.values():\n",
@@ -76,16 +74,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 4,
+   "metadata": {},
    "outputs": [],
    "source": [
     "with patch(\"pyquil.api.SyncConnection\") as cxn:\n",
     "    # Need to mock multiple returns as an iterable\n",
-    "    cxn.run_and_measure.side_effect = [\n",
-    "        (np.asarray([0, 0]))]"
+    "    mock_job_result = Mock(spec=JobResult)\n",
+    "    mock_job_result.is_done.return_value = True\n",
+    "    mock_job_result.result = {'result': [[0, 0]]}\n",
+    "    cxn.run_and_measure.return_value = mock_job_result"
    ]
   },
   {
@@ -97,9 +95,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "metadata": {
-    "collapsed": true
+    "scrolled": true
    },
    "outputs": [],
    "source": [
@@ -118,21 +116,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 2",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "python2"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.13"
+   "pygments_lexer": "ipython3",
+   "version": "3.6.3"
   }
  },
  "nbformat": 4,

grove/deutsch_jozsa/deutsch_jozsa.py

@@ -19,6 +19,7 @@
 import numpy as np
 import pyquil.quil as pq
 from pyquil.gates import X, H, CNOT
+from pyquil.job_results import wait_for_job
 
 
 SWAP_MATRIX = np.array([[1, 0, 0, 0],
@@ -53,9 +54,11 @@ def is_constant(self, cxn, bitstring_map):
         :rtype: bool
         """
         self._init_attr(bitstring_map)
-        bitstring = np.array(cxn.run_and_measure(self.deutsch_jozsa_circuit,
-                                                 self.computational_qubits),
-                             dtype=int)
+        job_result = wait_for_job(cxn.run_and_measure(self.deutsch_jozsa_circuit,
+                                                      self.computational_qubits))
+        # We are only running a single shot, so we are only interested in the first element.
+        returned_bitstring = job_result.result['result'][0]
+        bitstring = np.array(returned_bitstring, dtype=int)
         constant = all([bit == 0 for bit in bitstring])
         return constant
 
@@ -143,7 +146,7 @@ def unitary_function(mappings):
             index_lists = [list(range(2 ** (num_qubits - 1))),
                            list(range(2 ** (num_qubits - 1), 2 ** num_qubits))]
             for j in range(2 ** num_qubits):
-                bitstring = bin(j)[2:]
+                bitstring = np.binary_repr(j, num_qubits)
                 value = int(mappings[bitstring])
                 mappings.pop(bitstring)
                 i = index_lists[value].pop()

grove/tests/deutsch_jozsa/test_deutsch_jozsa.py

@@ -1,33 +1,41 @@
-from mock import patch
+from mock import patch, Mock
 import pytest
 
 import numpy as np
 import pyquil.quil as pq
+from pyquil.api import JobResult
 from pyquil.gates import X, H, CNOT
 
 from grove.deutsch_jozsa.deutsch_jozsa import DeutschJosza, ORACLE_GATE_NAME
 
 
+def mock_job_result(result):
+    job_result = Mock(spec=JobResult)
+    job_result.is_done.return_value = True
+    job_result.result = {'result': [result]}
+    return job_result
+
+
 @pytest.mark.parametrize("bitmap, expected_bitstring",
                          [({"0": "0", "1": "0"},
                           np.asarray([0, 0], dtype=int)),
                           ({"0": "1", "1": "1"},
                           np.asarray([0, 0], dtype=int))])
 def test_deutsch_jozsa_one_qubit_exact_zeros(bitmap, expected_bitstring):
     dj = DeutschJosza()
-    with patch("pyquil.api.SyncConnection") as qvm:
-        qvm.run_and_measure.return_value = expected_bitstring
+    with patch("pyquil.api.JobConnection") as qvm:
+        qvm.run_and_measure.return_value = mock_job_result(expected_bitstring)
         is_constant = dj.is_constant(qvm, bitmap)
     assert is_constant
 
 
 def test_deutsch_jozsa_one_qubit_balanced():
     balanced_one_qubit_bitmap = {"0": "0", "1": "1"}
     dj = DeutschJosza()
-    with patch("pyquil.api.SyncConnection") as qvm:
+    with patch("pyquil.api.JobConnection") as qvm:
         # Should just be not the zero vector
         expected_bitstring = np.asarray([0, 1], dtype=int)
-        qvm.run_and_measure.return_value = expected_bitstring
+        qvm.run_and_measure.return_value = mock_job_result(expected_bitstring)
         is_constant = dj.is_constant(qvm, balanced_one_qubit_bitmap)
     assert not is_constant
 
@@ -36,17 +44,17 @@ def test_deutsch_jozsa_two_qubit_neither():
     exact_two_qubit_bitmap = {"00": "0", "01": "0", "10": "1", "11": "00"}
     dj = DeutschJosza()
     with pytest.raises(ValueError):
-        with patch("pyquil.api.SyncConnection") as qvm:
+        with patch("pyquil.api.JobConnection") as qvm:
             _ = dj.is_constant(qvm, exact_two_qubit_bitmap)
 
 
 def test_one_qubit_exact_zeros_circuit():
     exact_one_qubit_bitmap = {"0": "0", "1": "1"}
     dj = DeutschJosza()
-    with patch("pyquil.api.SyncConnection") as qvm:
+    with patch("pyquil.api.JobConnection") as qvm:
         # Should just be not the zero vector
         expected_bitstring = np.asarray([0, 1], dtype=int)
-        qvm.run_and_measure.return_value = expected_bitstring
+        qvm.run_and_measure.return_value = mock_job_result(expected_bitstring)
         _ = dj.is_constant(qvm, exact_one_qubit_bitmap)
     # Ordering doesn't matter, so we pop instructions from a set
     expected_prog = pq.Program()