Add shot expval in C++ layer

mpitests/test_expval.py

@@ -31,8 +31,6 @@
     def test_identity_expectation(self, theta, phi, tol):
         """Test that identity expectation value (i.e. the trace) is 1"""
         dev = qml.device(device_name, mpi=True, wires=3)
-        if device_name == "lightning.gpu" and dev.R_DTYPE == np.float32:
-            pytest.skip("Skipped FP32 tests for expval in lightning.gpu")
 
         O1 = qml.Identity(wires=[0])
         O2 = qml.Identity(wires=[1])
@@ -49,9 +47,6 @@
         """Test that PauliZ expectation value is correct"""
         dev = qml.device(device_name, mpi=True, wires=3)
 
-        if device_name == "lightning.gpu" and dev.R_DTYPE == np.float32:
-            pytest.skip("Skipped FP32 tests for expval in lightning.gpu")
-
         O1 = qml.PauliZ(wires=[0])
         O2 = qml.PauliZ(wires=[1])
 
@@ -63,13 +58,26 @@
         res = np.array([dev.expval(O1), dev.expval(O2)])
         assert np.allclose(res, np.array([np.cos(theta), np.cos(theta) * np.cos(phi)]), tol)
 
+    def test_pauliz_expectation_shots(self, theta, phi, tol):
+        """Test that PauliZ expectation value is correct"""
+        TOL = 5e-2
+        dev = qml.device(device_name, mpi=True, wires=3, shots=1000)
+
+        O1 = qml.PauliZ(wires=[0])
+        O2 = qml.PauliZ(wires=[1])
+
+        dev.apply(
+            [qml.RX(theta, wires=[0]), qml.RX(phi, wires=[1]), qml.CNOT(wires=[0, 1])],
+            rotations=[*O1.diagonalizing_gates(), *O2.diagonalizing_gates()],
+        )
+
+        res = np.array([dev.expval(O1), dev.expval(O2)])
+        assert np.allclose(res, np.array([np.cos(theta), np.cos(theta) * np.cos(phi)]), atol=TOL)
+
     def test_paulix_expectation(self, theta, phi, tol):
         """Test that PauliX expectation value is correct"""
         dev = qml.device(device_name, mpi=True, wires=3)
 
-        if device_name == "lightning.gpu" and dev.R_DTYPE == np.float32:
-            pytest.skip("Skipped FP32 tests for expval in lightning.gpu")
-
         O1 = qml.PauliX(wires=[0])
         O2 = qml.PauliX(wires=[1])
 
@@ -85,13 +93,46 @@
             tol * 10,
         )
 
+    def test_paulix_expectation_shots(self, theta, phi, tol):
+        """Test that PauliX expectation value is correct"""
+        TOL = 5e-2
+        dev = qml.device(device_name, mpi=True, wires=3, shots=1000)
+
+        O1 = qml.PauliX(wires=[0])
+        O2 = qml.PauliX(wires=[1])
+
+        dev.apply(
+            [qml.RY(theta, wires=[0]), qml.RY(phi, wires=[1]), qml.CNOT(wires=[0, 1])],
+            rotations=[*O1.diagonalizing_gates(), *O2.diagonalizing_gates()],
+        )
+
+        res = np.array([dev.expval(O1), dev.expval(O2)], dtype=dev.C_DTYPE)
+        assert np.allclose(
+            res,
+            np.array([np.sin(theta) * np.sin(phi), np.sin(phi)], dtype=dev.C_DTYPE),
+            atol=TOL,
+        )
+
+    def test_pauliy_expectation_shots(self, theta, phi, tol):
+        """Test that PauliY expectation value is correct"""
+        TOL = 5e-2
+        dev = qml.device(device_name, mpi=True, wires=3, shots=1000)
+
+        O1 = qml.PauliY(wires=[0])
+        O2 = qml.PauliY(wires=[1])
+
+        dev.apply(
+            [qml.RX(theta, wires=[0]), qml.RX(phi, wires=[1]), qml.CNOT(wires=[0, 1])],
+            rotations=[*O1.diagonalizing_gates(), *O2.diagonalizing_gates()],
+        )
+
+        res = np.array([dev.expval(O1), dev.expval(O2)])
+        assert np.allclose(res, np.array([0, -np.cos(theta) * np.sin(phi)]), atol=TOL)
+
     def test_pauliy_expectation(self, theta, phi, tol):
         """Test that PauliY expectation value is correct"""
         dev = qml.device(device_name, mpi=True, wires=3)
 
-        if device_name == "lightning.gpu" and dev.R_DTYPE == np.float32:
-            pytest.skip("Skipped FP32 tests for expval in lightning.gpu")
-
         O1 = qml.PauliY(wires=[0])
         O2 = qml.PauliY(wires=[1])
 
@@ -124,14 +165,35 @@
         ) / np.sqrt(2)
         assert np.allclose(res, expected, tol)
 
+    def test_hadamard_expectation_shots(self, theta, phi, tol):
+        """Test that Hadamard expectation value is correct"""
+        TOL = 5e-2
+        dev = qml.device(device_name, mpi=True, wires=3, shots=1000)
+
+        O1 = qml.Hadamard(wires=[0])
+        O2 = qml.Hadamard(wires=[1])
+
+        dev.apply(
+            [qml.RY(theta, wires=[0]), qml.RY(phi, wires=[1]), qml.CNOT(wires=[0, 1])],
+            rotations=[*O1.diagonalizing_gates(), *O2.diagonalizing_gates()],
+        )
+
+        res = np.array([dev.expval(O1), dev.expval(O2)])
+        expected = np.array(
+            [
+                np.sin(theta) * np.sin(phi) + np.cos(theta),
+                np.cos(theta) * np.cos(phi) + np.sin(phi),
+            ]
+        ) / np.sqrt(2)
+        assert np.allclose(res, expected, atol=TOL)
+
     @pytest.mark.parametrize("n_wires", range(1, 8))
     def test_hermitian_expectation(self, n_wires, theta, phi, tol):
         """Test that Hadamard expectation value is correct"""
         n_qubits = 7
         dev_def = qml.device("default.qubit", wires=n_qubits)
         dev = qml.device(device_name, mpi=True, wires=n_qubits)
-        if device_name == "lightning.gpu" and dev.R_DTYPE == np.float32:
-            pytest.skip("Skipped FP32 tests for expval in lightning.gpu")
+
         comm = MPI.COMM_WORLD
 
         m = 2**n_wires
@@ -285,6 +347,29 @@
         expected = np.sin(theta) * np.sin(phi) * np.sin(varphi)
 
         assert np.allclose(res, expected, atol=tol)
+
+    def test_paulix_pauliy_shots(self, theta, phi, varphi):
+        """Test that a tensor product involving PauliX and PauliY works
+        correctly"""
+        TOL = 5e-2
+        dev = qml.device(device_name, mpi=True, wires=3, shots=1000)
+        obs = qml.PauliX(0) @ qml.PauliY(2)
+
+        dev.apply(
+            [
+                qml.RX(theta, wires=[0]),
+                qml.RX(phi, wires=[1]),
+                qml.RX(varphi, wires=[2]),
+                qml.CNOT(wires=[0, 1]),
+                qml.CNOT(wires=[1, 2]),
+            ],
+            rotations=obs.diagonalizing_gates(),
+        )
+        res = dev.expval(obs)
+
+        expected = np.sin(theta) * np.sin(phi) * np.sin(varphi)
+
+        assert np.allclose(res, expected, atol=TOL)
 
     def test_pauliz_identity(self, theta, phi, varphi, tol):
         """Test that a tensor product involving PauliZ and Identity works
@@ -308,6 +393,30 @@
         expected = np.cos(varphi) * np.cos(phi)
 
         assert np.allclose(res, expected, tol)
+
+    def test_pauliz_identity_shots(self, theta, phi, varphi):
+        """Test that a tensor product involving PauliZ and Identity works
+        correctly"""
+        TOL = 5e-2
+        dev = qml.device(device_name, mpi=True, wires=3, shots=1000)
+        obs = qml.PauliZ(0) @ qml.Identity(1) @ qml.PauliZ(2)
+
+        dev.apply(
+            [
+                qml.RX(theta, wires=[0]),
+                qml.RX(phi, wires=[1]),
+                qml.RX(varphi, wires=[2]),
+                qml.CNOT(wires=[0, 1]),
+                qml.CNOT(wires=[1, 2]),
+            ],
+            rotations=obs.diagonalizing_gates(),
+        )
+
+        res = dev.expval(obs)
+
+        expected = np.cos(varphi) * np.cos(phi)
+
+        assert np.allclose(res, expected, atol=TOL)
 
     def test_pauliz_hadamard_pauliy(self, theta, phi, varphi, tol):
         """Test that a tensor product involving PauliZ and PauliY and Hadamard
@@ -330,3 +439,26 @@
         expected = -(np.cos(varphi) * np.sin(phi) + np.sin(varphi) * np.cos(theta)) / np.sqrt(2)
 
         assert np.allclose(res, expected, tol)
+
+    def test_pauliz_hadamard_pauliy_shots(self, theta, phi, varphi):
+        """Test that a tensor product involving PauliZ and PauliY and Hadamard
+        works correctly"""
+        TOL = 5e-2
+        dev = qml.device(device_name, mpi=True, wires=3, shots=1000)
+        obs = qml.PauliZ(0) @ qml.Hadamard(1) @ qml.PauliY(2)
+
+        dev.apply(
+            [
+                qml.RX(theta, wires=[0]),
+                qml.RX(phi, wires=[1]),
+                qml.RX(varphi, wires=[2]),
+                qml.CNOT(wires=[0, 1]),
+                qml.CNOT(wires=[1, 2]),
+            ],
+            rotations=obs.diagonalizing_gates(),
+        )
+
+        res = dev.expval(obs)
+        expected = -(np.cos(varphi) * np.sin(phi) + np.sin(varphi) * np.cos(theta)) / np.sqrt(2)
+
+        assert np.allclose(res, expected, atol=TOL)

pennylane_lightning/core/_version.py

@@ -16,4 +16,4 @@
    Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.34.0-dev4"
+__version__ = "0.34.0-dev5"

pennylane_lightning/core/src/bindings/Bindings.hpp

@@ -439,6 +439,23 @@ void registerBackendAgnosticMeasurements(PyClass &pyclass) {
                 return M.expval(*ob);
             },
             "Expected value of an observable object.")
+        .def(
+            "expval",
+            [](Measurements<StateVectorT> &M,
+               const std::shared_ptr<Observable<StateVectorT>> &ob,
+               const size_t &num_shots) {
+                const std::vector<size_t> &shot_range = {};
+                return M.expval(*ob, num_shots, shot_range);
+            },
+            "Expected value of an observable object.")
+        .def(
+            "expval",
+            [](Measurements<StateVectorT> &M,
+               const std::shared_ptr<Observable<StateVectorT>> &ob,
+               const size_t &num_shots, const std::vector<size_t> &shot_range) {
+                return M.expval(*ob, num_shots, shot_range);
+            },
+            "Expected value of an observable object.")
         .def(
             "var",
             [](Measurements<StateVectorT> &M,

pennylane_lightning/core/src/bindings/BindingsMPI.hpp

@@ -269,6 +269,23 @@ void registerBackendAgnosticMeasurementsMPI(PyClass &pyclass) {
                 return M.expval(*ob);
             },
             "Expected value of an observable object.")
+        .def(
+            "expval",
+            [](MeasurementsMPI<StateVectorT> &M,
+               const std::shared_ptr<Observable<StateVectorT>> &ob,
+               const size_t &num_shots) {
+                const std::vector<size_t> &shot_range = {};
+                return M.expval(*ob, num_shots, shot_range);
+            },
+            "Expected value of an observable object.")
+        .def(
+            "expval",
+            [](MeasurementsMPI<StateVectorT> &M,
+               const std::shared_ptr<Observable<StateVectorT>> &ob,
+               const size_t &num_shots, const std::vector<size_t> &shot_range) {
+                return M.expval(*ob, num_shots, shot_range);
+            },
+            "Expected value of an observable object.")
         .def(
             "var",
             [](MeasurementsMPI<StateVectorT> &M,