# Gradient Computation and Optimization

**Gradient computation** enables efficient parameter optimization for variational algorithms. CUDA-Q supports parameter shift rule and automatic differentiation.

```cpp
#include "cudaq.h"
#include "cudaq/gradients.h"
#include "cudaq/optimizer.h"
#include <cmath>

struct ParameterizedAnsatz {
  void operator()(std::vector<double> params) __qpu__ {
    cudaq::qvector q(2);
    ry(params[0], q[0]);
    ry(params[1], q[1]);
    cx(q[0], q[1]);
    rz(params[2], q[0]);
    mz(q);
  }
};

int main() {
  // Define observable (Hamiltonian for VQE)
  cudaq::spin_op H = cudaq::spin::z(0) + cudaq::spin::z(1);
  
  // Initial parameters
  std::vector<double> params = {0.1, 0.2, 0.3};
  
  // Compute gradient via parameter shift rule
  cudaq::gradient grad;
  auto gradient_vec = grad.compute<ParameterizedAnsatz>(params, H);
  
  printf("Gradient at initial params:\n");
  for (size_t i = 0; i < gradient_vec.size(); i++) {
    printf("  dE/d(param_%lu) = %.6f\n", i, gradient_vec[i]);
  }
  
  // Optimization loop with gradients
  cudaq::optimizers::COBYLA optimizer;
  
  auto objective = [&](std::vector<double> p) {
    return cudaq::observe<ParameterizedAnsatz>(p, H);
  };
  
  auto [opt_params, opt_cost] = optimizer.optimize(params, objective);
  
  printf("Optimized energy: %.6f\n", opt_cost);
  printf("Optimized params: ");
  for (auto p : opt_params) {
    printf("%.3f ", p);
  }
  printf("\n");
  
  return 0;
}
```

Gradients accelerate convergence dramatically. Parameter shift rule is hardware-agnostic; automatic differentiation uses GPU operations for efficiency.