Revert "Fix some C++ tests by undoing gradient changes that aren't ne…

…eded"

This reverts commit fc4c9a0.

runtime/cudaq/algorithms/gradient.h

@@ -47,6 +47,12 @@ class gradient {
     return cudaq::observe(ansatz_functor, h, x);
   }
 
+  /// Copy constructor. Derived classes should implement the clone() method.
+  gradient(const gradient &o) {
+    ansatz_functor = o.ansatz_functor;
+    serializedArgs = o.serializedArgs;
+  }
+
 public:
   /// Constructor, takes the quantum kernel with prescribed signature
   gradient(std::function<void(std::vector<double>)> &&kernel)
@@ -141,6 +147,9 @@ class gradient {
           const std::function<double(std::vector<double>)> &func,
           double funcAtX) = 0;
 
+  /// Clone the object. Must be implemented by derived classes.
+  virtual std::unique_ptr<cudaq::gradient> clone() = 0;
+
   virtual ~gradient() = default;
 };
 } // namespace cudaq

runtime/cudaq/algorithms/gradients/central_difference.h

@@ -15,21 +15,34 @@ namespace cudaq::gradients {
 class central_difference : public gradient {
 public:
   using gradient::gradient;
-  double step = 1e-4;
+  static constexpr double default_step = 1e-4;
+  double step = default_step;
+
+  central_difference(double s = default_step) : gradient(), step(s) {}
+
+  virtual std::unique_ptr<cudaq::gradient> clone() override {
+    return std::make_unique<central_difference>(step);
+  }
 
   void compute(const std::vector<double> &x, std::vector<double> &dx,
                const spin_op &h, double exp_h) override {
     auto tmpX = x;
     for (std::size_t i = 0; i < x.size(); i++) {
       // increase value to x_i + dx_i
       tmpX[i] += step;
+      // auto savepx = tmpX[i];
       auto px = getExpectedValue(tmpX, h);
       // decrease the value to x_i - dx_i
       tmpX[i] -= 2 * step;
+      // auto savemx = tmpX[i];
       auto mx = getExpectedValue(tmpX, h);
       // return value back to x_i
       tmpX[i] += step;
       dx[i] = (px - mx) / (2. * step);
+      // printf("compute: tmp[%lu]=%.16f dx[%lu]=%.16f step=%.16f px=%.16f
+      // mx=%.16f "
+      //        "savepx=%.16f savemx=%.16f\n",
+      //        i, tmpX[i], i, dx[i], step, px, mx, savepx, savemx);
     }
   }
 

runtime/cudaq/algorithms/gradients/forward_difference.h

@@ -17,7 +17,14 @@ namespace cudaq::gradients {
 class forward_difference : public gradient {
 public:
   using gradient::gradient;
-  double step = 1e-4;
+  static constexpr double default_step = 1e-4;
+  double step = default_step;
+
+  forward_difference(double s = default_step) : gradient(), step(s) {}
+
+  virtual std::unique_ptr<cudaq::gradient> clone() override {
+    return std::make_unique<forward_difference>(step);
+  }
 
   /// @brief Compute the `forward_difference` gradient
   void compute(const std::vector<double> &x, std::vector<double> &dx,

runtime/cudaq/algorithms/gradients/parameter_shift.h

@@ -14,7 +14,15 @@ namespace cudaq::gradients {
 class parameter_shift : public gradient {
 public:
   using gradient::gradient;
-  double shiftScalar = 0.5;
+  static constexpr double default_shiftScalar = 0.5;
+  double shiftScalar = default_shiftScalar;
+
+  parameter_shift(double s = default_shiftScalar)
+      : gradient(), shiftScalar(s) {}
+
+  virtual std::unique_ptr<cudaq::gradient> clone() override {
+    return std::make_unique<parameter_shift>(shiftScalar);
+  }
 
   void compute(const std::vector<double> &x, std::vector<double> &dx,
                const spin_op &h, double exp_h) override {

runtime/cudaq/algorithms/vqe.h

@@ -241,11 +241,17 @@ optimization_result vqe(QuantumKernel &&kernel, cudaq::gradient &gradient,
   }
 
   auto requires_grad = optimizer.requiresGradients();
+  std::unique_ptr<cudaq::gradient> newGrad;
+  if (requires_grad) {
+    newGrad = gradient.clone();
+    if constexpr (sizeof...(args) > 0)
+      newGrad->setArgs(kernel, args...);
+  }
   return optimizer.optimize(n_params, [&](const std::vector<double> &x,
                                           std::vector<double> &grad_vec) {
     double e = cudaq::observe(kernel, H, x, args...);
     if (requires_grad) {
-      gradient.compute(x, grad_vec, H, e);
+      newGrad->compute(x, grad_vec, H, e);
     }
     return e;
   });