🚸 Support for adding tests to NALAC

include/mqt-core/na/NAComputation.hpp

@@ -57,7 +57,6 @@ class NAComputation {
   }
   auto clear(const bool clearInitialPositions = true) -> void {
     operations.clear();
-    initialPositions.clear();
     if (clearInitialPositions) {
       initialPositions.clear();
     }

include/mqt-core/na/NADefinitions.hpp

@@ -123,3 +123,12 @@ template <> struct std::hash<na::FullOpType> {
     return qc::combineHash(h1, h2);
   }
 };
+
+/// Hash function for Point, e.g., for use in unordered_map
+template <> struct std::hash<na::Point> {
+  std::size_t operator()(const na::Point& p) const noexcept {
+    const std::size_t h1 = std::hash<decltype(p.x)>{}(p.x);
+    const std::size_t h2 = std::hash<decltype(p.y)>{}(p.y);
+    return qc::combineHash(h1, h2);
+  }
+};

include/mqt-core/na/operations/NAGlobalOperation.hpp

@@ -28,6 +28,7 @@ class NAGlobalOperation : public NAOperation {
   [[nodiscard]] auto getParams() const -> const std::vector<qc::fp>& {
     return params;
   }
+  [[nodiscard]] auto getType() const -> FullOpType { return type; }
   [[nodiscard]] auto isGlobalOperation() const -> bool override { return true; }
   [[nodiscard]] auto toString() const -> std::string override;
   [[nodiscard]] auto clone() const -> std::unique_ptr<NAOperation> override {

include/mqt-core/operations/CompoundOperation.hpp

@@ -62,7 +62,10 @@
 
   std::vector<std::unique_ptr<Operation>>& getOps() { return ops; }
 
-  [[nodiscard]] std::set<Qubit> getUsedQubits() const override;
+  [[nodiscard]] std::set<Qubit>
+  getUsedQubits(const std::function<Qubit(Qubit)>& perm = [](Qubit q) {
+    return q;
+  }) const override;
 
   [[nodiscard]] auto commutesAtQubit(const Operation& other,
                                      const Qubit& qubit) const -> bool override;

include/mqt-core/operations/NonUnitaryOperation.hpp

@@ -47,9 +47,16 @@
   std::vector<Bit>& getClassics() { return classics; }
   [[nodiscard]] std::size_t getNclassics() const { return classics.size(); }
 
-  [[nodiscard]] std::set<Qubit> getUsedQubits() const override {
+  [[nodiscard]] std::set<Qubit>
+  getUsedQubits(const std::function<Qubit(Qubit)>& perm = [](Qubit q) {
+    return q;
+  }) const override {
     const auto& opTargets = getTargets();
-    return {opTargets.begin(), opTargets.end()};
+    std::set<Qubit> usedQubits;
+    for (const auto& target : opTargets) {
+      usedQubits.emplace(perm(target));
+    }
+    return usedQubits;
   }
 
   [[nodiscard]] const Controls& getControls() const override {

include/mqt-core/operations/Operation.hpp

@@ -68,12 +68,18 @@
   [[nodiscard]] const std::string& getName() const { return name; }
   [[nodiscard]] virtual OpType getType() const { return type; }
 
-  [[nodiscard]] virtual std::set<Qubit> getUsedQubits() const {
+  [[nodiscard]] virtual auto
+  getUsedQubits(const std::function<Qubit(Qubit)>& perm = [](Qubit q) {
+    return q;
+  }) const -> std::set<Qubit> {
     const auto& opTargets = getTargets();
     const auto& opControls = getControls();
-    std::set<Qubit> usedQubits = {opTargets.begin(), opTargets.end()};
+    std::set<Qubit> usedQubits;
+    for (const auto& target : opTargets) {
+      usedQubits.emplace(perm(target));
+    }
     for (const auto& control : opControls) {
-      usedQubits.insert(control.qubit);
+      usedQubits.emplace(perm(control.qubit));
     }
     return usedQubits;
   }

src/na/NAComputation.cpp

@@ -9,13 +9,16 @@ auto NAComputation::toString() const -> std::string {
   std::stringstream ss;
   ss << "init at ";
   for (const auto& p : initialPositions) {
-    ss << "(" << p->x << ", " << p->y << ")"
-       << ", ";
+    ss << *p << ", ";
+  }
+  if (ss.tellp() == 8) {
+    ss.seekp(-1, std::ios_base::end);
+  } else {
+    ss.seekp(-2, std::ios_base::end);
   }
-  ss.seekp(-2, std::ios_base::end);
   ss << ";\n";
   for (const auto& op : operations) {
-    ss << op->toString();
+    ss << *op;
   }
   return ss.str();
 }

src/na/operations/NALocalOperation.cpp

@@ -17,10 +17,14 @@ auto NALocalOperation::toString() const -> std::string {
     ss << ")";
   }
   ss << " at ";
-  for (const auto& p : positions) {
-    ss << *p << ", ";
+  if (positions.empty()) {
+    ss.seekp(-1, std::ios_base::end);
+  } else {
+    for (const auto& p : positions) {
+      ss << *p << ", ";
+    }
+    ss.seekp(-2, std::ios_base::end);
   }
-  ss.seekp(-2, std::ios_base::end);
   ss << ";\n";
   return ss.str();
 }

src/operations/CompoundOperation.cpp

@@ -160,10 +160,11 @@
   }
 }
 
-std::set<Qubit> CompoundOperation::getUsedQubits() const {
+std::set<Qubit> CompoundOperation::getUsedQubits(
+    const std::function<Qubit(Qubit)>& perm) const {
   std::set<Qubit> usedQubits{};
   for (const auto& op : ops) {
-    usedQubits.merge(op->getUsedQubits());
+    usedQubits.merge(op->getUsedQubits(perm));
   }
   return usedQubits;
 }
@@ -194,14 +195,14 @@
     assert(!thisUsedQubits.empty());
     const auto thisMaxQubit =
         *std::max_element(thisUsedQubits.cbegin(), thisUsedQubits.cend());
     QuantumComputation thisQc(thisMaxQubit + 1);
     std::for_each(cbegin(), cend(),
                   [&](const auto& op) { thisQc.emplace_back(op->clone()); });
     const auto& otherUsedQubits = co.getUsedQubits();
     assert(!otherUsedQubits.empty());
     const auto otherMaxQubit =
         *std::max_element(otherUsedQubits.cbegin(), otherUsedQubits.cend());
     QuantumComputation otherQc(otherMaxQubit + 1);
     std::for_each(co.cbegin(), co.cend(),
                   [&](const auto& op) { otherQc.emplace_back(op->clone()); });
     CircuitOptimizer::reorderOperations(thisQc);

src/operations/Operation.cpp

@@ -121,6 +121,46 @@
     return false;
   }
 
+  if (isDiagonalGate()) {
+    // check pos. controls and targets together
+    std::set<Qubit> usedQubits1 =
+        perm1.empty()
+            ? getUsedQubits()
+            : getUsedQubits([&perm1](const auto& q) { return perm1.at(q); });
+
+    std::set<Qubit> usedQubits2 =
+        perm2.empty()
+            ? getUsedQubits()
+            : getUsedQubits([&perm2](const auto& q) { return perm2.at(q); });
+
+    if (usedQubits1 != usedQubits2) {
+      return false;
+    }
+
+    std::set<Qubit> negControls1{};
+    for (const auto& control : getControls()) {
+      if (control.type == Control::Type::Neg) {
+        if (perm1.empty()) {
+          negControls1.emplace(control.qubit);
+        } else {
+          negControls1.emplace(perm1.at(control.qubit));
+        }
+      }
+    }
+
+    std::set<Qubit> negControls2{};
+    for (const auto& control : op.getControls()) {
+      if (control.type == Control::Type::Neg) {
+        if (perm2.empty()) {
+          negControls2.emplace(control.qubit);
+        } else {
+          negControls2.emplace(perm2.at(control.qubit));
+        }
+      }
+    }
+
+    return negControls1 == negControls2;
+  }
   // check controls
   if (nc1 != 0U) {
     Controls controls1{};

test/na/test_nacomputation.cpp

@@ -46,4 +46,11 @@ TEST(NAComputation, General) {
                       "move (0, 1), (1, 1) to (4, 1), (5, 1);\n"
                       "store (4, 1), (5, 1) to (4, 0), (5, 0);\n");
 }
+
+TEST(NAComputation, EmptyPrint) {
+  const NAComputation qc;
+  std::stringstream ss;
+  ss << qc;
+  EXPECT_EQ(ss.str(), "init at;\n");
+}
 } // namespace na

test/na/test_naoperation.cpp

@@ -7,6 +7,7 @@
 
 #include <gtest/gtest.h>
 #include <memory>
+#include <sstream>
 #include <vector>
 
 namespace na {
@@ -49,4 +50,12 @@ TEST(NAOperation, LocalOperation) {
   EXPECT_ANY_THROW(
       NALocalOperation(FullOpType{qc::RY, 1}, std::make_shared<Point>(0, 0)));
 }
+
+TEST(NAOperation, EmptyPrint) {
+  const NALocalOperation op(FullOpType{qc::RY, 0}, std::vector{qc::PI_2},
+                            std::vector<std::shared_ptr<Point>>{});
+  std::stringstream ss;
+  ss << op;
+  EXPECT_EQ(ss.str(), "ry(1.5708) at;\n");
+}
 } // namespace na

test/test_operation.cpp

@@ -1,4 +1,5 @@
 #include "Definitions.hpp"
+#include "Permutation.hpp"
 #include "operations/AodOperation.hpp"
 #include "operations/CompoundOperation.hpp"
 #include "operations/Expression.hpp"
@@ -139,6 +140,24 @@ TEST(Operation, IsDiagonalGate) {
   EXPECT_TRUE(op2.isDiagonalGate());
 }
 
+TEST(Operation, Equality) {
+  const qc::StandardOperation op1(0, qc::Z);
+  const qc::StandardOperation op2(1, 0, qc::Z);
+  const qc::StandardOperation op3(0, 1, qc::Z);
+  const qc::StandardOperation op4({0, qc::Control::Type::Neg}, 1, qc::Z);
+  EXPECT_FALSE(op1 == op2);
+  EXPECT_TRUE(op2 == op3);
+  EXPECT_TRUE(op3 == op2);
+  EXPECT_FALSE(op2 == op4);
+
+  EXPECT_TRUE(op2.equals(op3, qc::Permutation{{{0, 0}, {1, 2}}},
+                         qc::Permutation{{{0, 2}, {1, 0}}}));
+  EXPECT_FALSE(
+      op2.equals(op3, qc::Permutation{{{0, 0}, {1, 2}}}, qc::Permutation{}));
+  EXPECT_FALSE(op2.equals(op4, qc::Permutation{{{0, 0}, {1, 2}}},
+                          qc::Permutation{{{0, 2}, {1, 0}}}));
+}
+
 TEST(StandardOperation, Move) {
   const qc::StandardOperation moveOp({0, 1}, qc::OpType::Move);
   EXPECT_EQ(moveOp.getTargets().size(), 2);