PR #2683 Follow up

.github/workflows/publishing.yml

@@ -839,11 +839,10 @@ jobs:
       - name: Basic validation (GPU backends)
         shell: bash
         run: |
-          # We don't test the 'dynamics' target in these tests
           backends_to_test=`\
               for file in $(ls $CUDA_QUANTUM_PATH/targets/*.yml); \
               do
-                  if [[ "$file" != *"dynamics"* ]] && [ -n "$(cat $file | grep "gpu-requirements")" ]; then \
+                  if [ -n "$(cat $file | grep "gpu-requirements")" ]; then \
                     basename $file | cut -d "." -f 1; \
                   elif [ -n "$(basename $file | grep mqpu)" ]; then \
                     echo remote-mqpu; \

docs/sphinx/examples/cpp/dynamics/cavity_qed.cpp

@@ -108,7 +108,7 @@ int main() {
   auto get_expectation = [](int idx, auto &result) -> std::vector<double> {
     std::vector<double> expectations;
 
-    auto all_exps = result.get_expectation_values().value();
+    auto all_exps = result.expectation_values.value();
     for (auto exp_vals : all_exps) {
       expectations.push_back((double)exp_vals[idx]);
     }

docs/sphinx/examples/cpp/dynamics/cross_resonance.cpp

@@ -119,7 +119,7 @@ int main() {
   auto get_expectation = [](int idx, auto &result) -> std::vector<double> {
     std::vector<double> expectations;
 
-    auto all_exps = result.get_expectation_values().value();
+    auto all_exps = result.expectation_values.value();
     for (auto exp_vals : all_exps) {
       expectations.push_back((double)exp_vals[idx]);
     }

docs/sphinx/examples/cpp/dynamics/heisenberg_model.cpp

@@ -121,7 +121,7 @@ int main() {
     auto get_expectation = [](int idx, auto &result) -> std::vector<double> {
       std::vector<double> expectations;
 
-      auto all_exps = result.get_expectation_values().value();
+      auto all_exps = result.expectation_values.value();
       for (auto exp_vals : all_exps) {
         expectations.push_back((double)exp_vals[idx]);
       }

docs/sphinx/examples/cpp/dynamics/qubit_control.cpp

@@ -46,9 +46,8 @@ int main() {
   // 2. A time-dependent driving term: omega_x * cos(omega_drive * t) * `Sx`_0,
   // which induces rotations about the X-axis. The scalar_operator(mod_`func`)
   // allows the drive term to vary in time according to mod_`func`.
-  auto hamiltonian =
-      0.5 * omega_z * cudaq::spin_operator::z(0) +
-      omega_x * cudaq::scalar_operator(mod_func) * cudaq::spin_operator::x(0);
+  auto hamiltonian = 0.5 * omega_z * cudaq::spin_operator::z(0) +
+                     mod_func * cudaq::spin_operator::x(0) * omega_x;
 
   // A single qubit with dimension 2.
   cudaq::dimension_map dimensions = {{0, 2}};
@@ -100,7 +99,7 @@ int main() {
   auto get_expectation = [](int idx, auto &result) -> std::vector<double> {
     std::vector<double> expectations;
 
-    auto all_exps = result.get_expectation_values().value();
+    auto all_exps = result.expectation_values.value();
     for (auto exp_vals : all_exps) {
       expectations.push_back(exp_vals[idx].expectation());
     }

docs/sphinx/examples/cpp/dynamics/qubit_dynamics.cpp

@@ -54,7 +54,7 @@ int main() {
   auto get_expectation = [](int idx, auto &result) -> std::vector<double> {
     std::vector<double> expectations;
 
-    auto all_exps = result.get_expectation_values().value();
+    auto all_exps = result.expectation_values.value();
     for (auto exp_vals : all_exps) {
       expectations.push_back((double)exp_vals[idx]);
     }

python/runtime/common/py_EvolveResult.cpp

@@ -35,24 +35,22 @@ void bindEvolveResult(py::module &mod) {
       .def(py::init<std::vector<state>, std::vector<std::vector<double>>>())
       .def(
           "final_state",
-          [](evolve_result &self) { return self.get_final_state(); },
+          [](evolve_result &self) { return self.states->back(); },
           "Stores the final state produced by a call to :func:`evolve`. "
           "Represent the state of a quantum system after time evolution under "
           "a set of operators, see the :func:`evolve` documentation for more "
           "detail.\n")
       .def(
           "intermediate_states",
-          [](evolve_result &self) { return self.get_intermediate_states(); },
+          [](evolve_result &self) { return self.states; },
           "Stores all intermediate states, meaning the state after each step "
           "in a defined schedule, produced by a call to :func:`evolve`, "
           "including the final state. This property is only populated if "
           "saving intermediate results was requested in the call to "
           ":func:`evolve`.\n")
       .def(
           "final_expectation_values",
-          [](evolve_result &self) {
-            return self.get_final_expectation_values();
-          },
+          [](evolve_result &self) { return self.expectation_values; },
           "Stores the final expectation values, that is the results produced "
           "by "
           "calls to :func:`observe`, triggered by a call to :func:`evolve`. "
@@ -63,7 +61,7 @@ void bindEvolveResult(py::module &mod) {
           "call.\n")
       .def(
           "expectation_values",
-          [](evolve_result &self) { return self.get_expectation_values(); },
+          [](evolve_result &self) { return self.expectation_values; },
           "Stores the expectation values, that is the results from the calls "
           "to "
           ":func:`observe`, at each step in the schedule produced by a call to "

runtime/common/EvolveResult.h

@@ -20,61 +20,62 @@ namespace cudaq {
 /// and any computed expectation values during and after evolution,
 /// depending on the arguments passed to the call.
 class evolve_result {
-protected:
-  // The final state after the time evolution.
-  state final_state;
-
-  // The state after each step in the evolution, if computed.
-  std::optional<std::vector<state>> intermediate_states = {};
-
-  // The computed expectation values at the end of the evolution.
-  std::optional<std::vector<observe_result>> final_expectation_values = {};
+public:
+  // The state of the system. If only final state is retained, this vector will
+  // have exactly one element.
+  std::optional<std::vector<state>> states = std::nullopt;
 
-  // The computed expectation values for each step of the evolution.
+  // The computed expectation values. If only final expectation values are
+  // retained, this vector will have exactly one element.
   std::optional<std::vector<std::vector<observe_result>>> expectation_values =
-      {};
+      std::nullopt;
 
   // The result of sampling of an analog Hamiltonian simulation on a QPU
-  std::optional<sample_result> sampling_result = {};
+  std::optional<sample_result> sampling_result = std::nullopt;
 
-public:
-  evolve_result(state state) : final_state(state) {}
+  // Construct from single final state.
+  evolve_result(state state) {}
 
-  evolve_result(state state, const std::vector<observe_result> &expectations)
-      : final_state(state),
-        final_expectation_values(
-            std::make_optional<std::vector<observe_result>>(expectations)) {}
+  // Construct from single final observe result.
+  evolve_result(state state, const std::vector<observe_result> &expectations) {
+    if (!expectation_values.has_value()) {
+      expectation_values =
+          std::make_optional<std::vector<std::vector<observe_result>>>();
+    }
 
-  evolve_result(state state, const std::vector<double> &expectations)
-      : final_state(state) {
+    expectation_values->emplace_back(expectations);
+  }
+
+  evolve_result(state state, const std::vector<double> &expectations) {
     std::vector<observe_result> result;
     const spin_op emptyOp(
         std::unordered_map<spin_op::spin_op_term, std::complex<double>>{});
     for (auto e : expectations) {
       result.push_back(observe_result(e, emptyOp));
     }
-    final_expectation_values = result;
+
+    if (!expectation_values.has_value()) {
+      expectation_values =
+          std::make_optional<std::vector<std::vector<observe_result>>>();
+    }
+
+    expectation_values->emplace_back(result);
   }
 
-  evolve_result(const std::vector<state> &states)
-      : final_state(getLastStateIfValid(states)),
-        intermediate_states(std::make_optional<std::vector<state>>(states)) {}
+  // Construct from system states.
+  evolve_result(const std::vector<state> &states) {}
 
+  // Construct from intermediate system states and observe results.
   evolve_result(const std::vector<state> &states,
                 const std::vector<std::vector<observe_result>> &expectations)
-      : final_state(getLastStateIfValid(states)),
-        intermediate_states(std::make_optional<std::vector<state>>(states)),
-        final_expectation_values(
-            std::make_optional<std::vector<observe_result>>(
-                expectations.back())),
+      : states(std::make_optional<std::vector<state>>(states)),
         expectation_values(
             std::make_optional<std::vector<std::vector<observe_result>>>(
                 expectations)) {}
 
   evolve_result(const std::vector<state> &states,
                 const std::vector<std::vector<double>> &expectations)
-      : final_state(getLastStateIfValid(states)),
-        intermediate_states(std::make_optional<std::vector<state>>(states)) {
+      : states(std::make_optional<std::vector<state>>(states)) {
     std::vector<std::vector<observe_result>> result;
     const spin_op emptyOp(
         std::unordered_map<spin_op::spin_op_term, std::complex<double>>{});
@@ -85,45 +86,9 @@ class evolve_result {
       }
       result.push_back(subResult);
     }
-    final_expectation_values = result.back();
     expectation_values = result;
   }
 
-  evolve_result(const sample_result &sr)
-      : final_state(nullptr), sampling_result(sr) {}
-
-  state get_final_state() {
-    /// TODO: Check for valid state
-    // if (final_state){
-    //   throw std::runtime_error("No state available for this result");
-    // }
-    return final_state;
-  }
-
-  const std::optional<std::vector<state>> &get_intermediate_states() {
-    return intermediate_states;
-  }
-
-  const std::optional<std::vector<observe_result>> &
-  get_final_expectation_values() {
-    return final_expectation_values;
-  }
-
-  const std::optional<std::vector<std::vector<observe_result>>> &
-  get_expectation_values() {
-    return expectation_values;
-  }
-
-  const std::optional<sample_result> &get_sampling_result() {
-    return sampling_result;
-  }
-
-private:
-  state getLastStateIfValid(const std::vector<state> &states) {
-    if (states.empty())
-      throw std::runtime_error(
-          "Cannot create evolve_result with an empty list of states.");
-    return states.back();
-  }
+  evolve_result(const sample_result &sr) : sampling_result(sr) {}
 };
 } // namespace cudaq

runtime/cudaq/dynamics/schedule.cpp

@@ -71,9 +71,9 @@ void schedule::reset() {
 
 // Get the current step
 std::optional<std::complex<double>> schedule::current_step() const {
-  if (current_idx >= 0 && current_idx < static_cast<int>(steps.size())) {
+  if (current_idx >= 0 && current_idx < static_cast<int>(steps.size()))
     return steps[current_idx];
-  }
+
   return std::nullopt;
 }
 

runtime/nvqir/cudensitymat/CuDensityMatEvolution.cpp

@@ -59,9 +59,8 @@ evolve_result evolveSingle(
   cudmState->initialize_cudm(handle, dims);
 
   state initial_State = [&]() {
-    if (!collapseOperators.empty() && !cudmState->is_density_matrix()) {
+    if (!collapseOperators.empty() && !cudmState->is_density_matrix())
       return state(new CuDensityMatState(cudmState->to_density_matrix()));
-    }
     return initialState;
   }();
 

runtime/nvqir/cudensitymat/CuDensityMatOpConverter.cpp

@@ -118,9 +118,8 @@ cudaq::product_operator<cudaq::matrix_operator> computeDagger(
   }
   std::reverse(daggerOps.begin(), daggerOps.end());
 
-  if (daggerOps.empty()) {
+  if (daggerOps.empty())
     throw std::runtime_error("Empty product operator");
-  }
   cudaq::product_operator<cudaq::matrix_operator> daggerProduct = daggerOps[0];
   for (std::size_t i = 1; i < daggerOps.size(); ++i) {
     daggerProduct *= daggerOps[i];
@@ -346,9 +345,9 @@ cudaq::dynamics::CuDensityMatOpConverter::createProductOperatorTerm(
       int degree = sub_degrees[j];
       int modality = modalities[j];
 
-      if (sub_degrees[i] < 0) {
+      if (sub_degrees[i] < 0)
         throw std::out_of_range("Degree cannot be negative!");
-      }
+
       allDegrees.emplace_back(degree);
       allModeActionDuality.emplace_back(modality);
     }
@@ -367,9 +366,8 @@ cudaq::dynamics::CuDensityMatOpConverter::convertToCudensitymatOperator(
     const std::unordered_map<std::string, std::complex<double>> &parameters,
     const operator_sum<cudaq::matrix_operator> &op,
     const std::vector<int64_t> &modeExtents) {
-  if (op.get_terms().empty()) {
+  if (op.get_terms().empty())
     throw std::invalid_argument("Operator sum cannot be empty.");
-  }
 
   cudensitymatOperator_t cudmOperator;
   HANDLE_CUDM_ERROR(cudensitymatCreateOperator(