some clean up/fixes in operators.h

Signed-off-by: Bettina Heim <[email protected]>

Author: bettinaheim

runtime/cudaq/operator/elementary_operator.cpp

@@ -18,20 +18,14 @@ namespace cudaq {
 elementary_operator::elementary_operator(std::string operator_id,
                                          std::vector<int> degrees)
     : id(operator_id), degrees(degrees) {}
-elementary_operator::elementary_operator(const elementary_operator &other)
-    : m_ops(other.m_ops), expected_dimensions(other.expected_dimensions),
-      degrees(other.degrees), id(other.id) {}
-elementary_operator::elementary_operator(elementary_operator &other)
-    : m_ops(other.m_ops), expected_dimensions(other.expected_dimensions),
-      degrees(other.degrees), id(other.id) {}
 
 elementary_operator elementary_operator::identity(int degree) {
   std::string op_id = "identity";
   std::vector<int> degrees = {degree};
   auto op = elementary_operator(op_id, degrees);
   // A dimension of -1 indicates this operator can act on any dimension.
   op.expected_dimensions[degree] = -1;
-  if (op.m_ops.find(op_id) == op.m_ops.end()) {
+  if (elementary_operator::m_ops.find(op_id) == elementary_operator::m_ops.end()) {
     auto func = [&](std::map<int, int> dimensions,
                     std::map<std::string, std::complex<double>> _none) {
       int degree = op.degrees[0];
@@ -57,7 +51,7 @@ elementary_operator elementary_operator::zero(int degree) {
   auto op = elementary_operator(op_id, degrees);
   // A dimension of -1 indicates this operator can act on any dimension.
   op.expected_dimensions[degree] = -1;
-  if (op.m_ops.find(op_id) == op.m_ops.end()) {
+  if (elementary_operator::m_ops.find(op_id) == elementary_operator::m_ops.end()) {
     auto func = [&](std::map<int, int> dimensions,
                     std::map<std::string, std::complex<double>> _none) {
       // Need to set the degree via the op itself because the
@@ -83,7 +77,7 @@ elementary_operator elementary_operator::annihilate(int degree) {
   auto op = elementary_operator(op_id, degrees);
   // A dimension of -1 indicates this operator can act on any dimension.
   op.expected_dimensions[degree] = -1;
-  if (op.m_ops.find(op_id) == op.m_ops.end()) {
+  if (elementary_operator::m_ops.find(op_id) == elementary_operator::m_ops.end()) {
     auto func = [&](std::map<int, int> dimensions,
                     std::map<std::string, std::complex<double>> _none) {
       auto degree = op.degrees[0];
@@ -108,7 +102,7 @@ elementary_operator elementary_operator::create(int degree) {
   auto op = elementary_operator(op_id, degrees);
   // A dimension of -1 indicates this operator can act on any dimension.
   op.expected_dimensions[degree] = -1;
-  if (op.m_ops.find(op_id) == op.m_ops.end()) {
+  if (elementary_operator::m_ops.find(op_id) == elementary_operator::m_ops.end()) {
     auto func = [&](std::map<int, int> dimensions,
                     std::map<std::string, std::complex<double>> _none) {
       auto degree = op.degrees[0];
@@ -133,7 +127,7 @@ elementary_operator elementary_operator::position(int degree) {
   auto op = elementary_operator(op_id, degrees);
   // A dimension of -1 indicates this operator can act on any dimension.
   op.expected_dimensions[degree] = -1;
-  if (op.m_ops.find(op_id) == op.m_ops.end()) {
+  if (elementary_operator::m_ops.find(op_id) == elementary_operator::m_ops.end()) {
     auto func = [&](std::map<int, int> dimensions,
                     std::map<std::string, std::complex<double>> _none) {
       auto degree = op.degrees[0];
@@ -160,7 +154,7 @@ elementary_operator elementary_operator::momentum(int degree) {
   auto op = elementary_operator(op_id, degrees);
   // A dimension of -1 indicates this operator can act on any dimension.
   op.expected_dimensions[degree] = -1;
-  if (op.m_ops.find(op_id) == op.m_ops.end()) {
+  if (elementary_operator::m_ops.find(op_id) == elementary_operator::m_ops.end()) {
     auto func = [&](std::map<int, int> dimensions,
                     std::map<std::string, std::complex<double>> _none) {
       auto degree = op.degrees[0];
@@ -189,7 +183,7 @@ elementary_operator elementary_operator::number(int degree) {
   auto op = elementary_operator(op_id, degrees);
   // A dimension of -1 indicates this operator can act on any dimension.
   op.expected_dimensions[degree] = -1;
-  if (op.m_ops.find(op_id) == op.m_ops.end()) {
+  if (elementary_operator::m_ops.find(op_id) == elementary_operator::m_ops.end()) {
     auto func = [&](std::map<int, int> dimensions,
                     std::map<std::string, std::complex<double>> _none) {
       auto degree = op.degrees[0];
@@ -214,7 +208,7 @@ elementary_operator elementary_operator::parity(int degree) {
   auto op = elementary_operator(op_id, degrees);
   // A dimension of -1 indicates this operator can act on any dimension.
   op.expected_dimensions[degree] = -1;
-  if (op.m_ops.find(op_id) == op.m_ops.end()) {
+  if (elementary_operator::m_ops.find(op_id) == elementary_operator::m_ops.end()) {
     auto func = [&](std::map<int, int> dimensions,
                     std::map<std::string, std::complex<double>> _none) {
       auto degree = op.degrees[0];
@@ -240,7 +234,7 @@ elementary_operator::displace(int degree, std::complex<double> amplitude) {
   auto op = elementary_operator(op_id, degrees);
   // A dimension of -1 indicates this operator can act on any dimension.
   op.expected_dimensions[degree] = -1;
-  if (op.m_ops.find(op_id) == op.m_ops.end()) {
+  if (elementary_operator::m_ops.find(op_id) == elementary_operator::m_ops.end()) {
     auto func = [&](std::map<int, int> dimensions,
                     std::map<std::string, std::complex<double>> _none) {
       auto degree = op.degrees[0];
@@ -277,11 +271,11 @@ elementary_operator::squeeze(int degree, std::complex<double> amplitude) {
 complex_matrix elementary_operator::to_matrix(
     const std::map<int, int> dimensions,
     const std::map<std::string, std::complex<double>> parameters) const {
-  if (m_ops.find(id) == m_ops.end())
+  if (elementary_operator::m_ops.find(id) == elementary_operator::m_ops.end())
     throw std::runtime_error(
         fmt::format("No operator found with this ID '{}'", id));
 
-  return m_ops.at(id).generator(dimensions, parameters);
+  return elementary_operator::m_ops.at(id).generator(dimensions, parameters);
 }
 
 template <typename TEval>

runtime/cudaq/operator/matrix_arithmetics.cpp

@@ -104,11 +104,6 @@ matrix_arithmetics::canonicalize(const cudaq::complex_matrix &op_matrix,
 }
 
 Evaluated matrix_arithmetics::evaluate(const Operator &op) const {
-  // cudaq::complex_matrix matrix = op.to_matrix(dimensions, op.parameters);
-  // // Replace with degrees from operator
-  // std::vector<int> degrees = op.degrees;
-  // return Evaluated(degrees, matrix);
-
   return std::visit(
       [this](auto &&arg) -> Evaluated {
         using T = std::decay_t<decltype(arg)>;
@@ -118,17 +113,11 @@ Evaluated matrix_arithmetics::evaluate(const Operator &op) const {
           std::vector<int> degrees = arg.degrees;
           return Evaluated(degrees, matrix);
         } else if constexpr (std::is_same_v<T, cudaq::scalar_operator>) {
-          // Handle the scalar operator
-          if (arg.has_val()) {
-            // double scalar_value = arg.get_val();
-            int dim = dimensions.at(arg.degrees[0]);
-            cudaq::complex_matrix matrix =
-                cudaq::complex_matrix::identity(dim, dim);
-            return Evaluated(arg.degrees, matrix);
-          } else {
-            throw std::runtime_error(
-                "Dynamic scalar operator evaluation not implemented.");
-          }
+          // FIXME: this is not correct!
+          int dim = dimensions.at(arg.degrees[0]);
+          cudaq::complex_matrix matrix =
+              cudaq::complex_matrix::identity(dim, dim);
+          return Evaluated(arg.degrees, matrix);
         } else {
           throw std::runtime_error(
               "Unknown operator type in CudaqOperatorVariant.");

runtime/cudaq/operator/operator_sum.cpp

@@ -95,26 +95,6 @@ std::vector<int> operator_sum::degrees() const {
   return std::vector<int>(unique_degrees.begin(), unique_degrees.end());
 }
 
-/// Aggregate parameters of all terms.
-/*
-std::map<std::string, std::string> operator_sum::parameters() const {
-  std::map<std::string, std::string> param_map;
-
-  for (const auto &term : m_terms) {
-    for (const auto &op_variant : term.get_terms()) {
-      std::visit(
-          [&param_map](auto &op) {
-            const auto &op_params = op.parameters;
-            param_map.insert(op_params.begin(), op_params.end());
-          },
-          op_variant);
-    }
-  }
-
-  return param_map;
-}
-*/
-
 /// Check if the operator sum acts as a spin operator.
 bool operator_sum::_is_spinop() const {
   return std::all_of(
@@ -209,16 +189,6 @@ operator_sum operator_sum::operator+=(const operator_sum &other) {
 // return operator_sum(product_terms);
 // }
 
-/// FIXME:
-// operator_sum operator_sum::operator/(const operator_sum &other) const {
-//   std::vector<product_operator> divided_terms;
-//   for (const auto &term : m_terms) {
-//     divided_terms.push_back(term / other);
-//   }
-
-//   return operator_sum(divided_terms);
-// }
-
 operator_sum operator_sum::operator+(const scalar_operator &other) const {
   std::vector<product_operator> combined_terms = m_terms;
   combined_terms.push_back(product_operator({other}));