🚸 Support for adding tests to NALAC

include/mqt-core/Permutation.hpp

@@ -30,6 +30,13 @@ class Permutation : public std::map<Qubit, Qubit> {
     }
     return t;
   }
+
+  [[nodiscard]] auto apply(const Qubit qubit) const -> Qubit {
+    if (empty()) {
+      return qubit;
+    }
+    return at(qubit);
+  }
 };
 } // namespace qc
 

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,8 @@ class CompoundOperation final : public Operation {
 
   std::vector<std::unique_ptr<Operation>>& getOps() { return ops; }
 
-  [[nodiscard]] std::set<Qubit> getUsedQubits() const override;
+  [[nodiscard]] auto getUsedQubitsPermuted(const Permutation& perm) const
+      -> std::set<Qubit> override;
 
   [[nodiscard]] auto commutesAtQubit(const Operation& other,
                                      const Qubit& qubit) const -> bool override;

include/mqt-core/operations/NonUnitaryOperation.hpp

@@ -47,19 +47,6 @@ class NonUnitaryOperation final : public Operation {
   std::vector<Bit>& getClassics() { return classics; }
   [[nodiscard]] std::size_t getNclassics() const { return classics.size(); }
 
-  [[nodiscard]] std::set<Qubit> getUsedQubits() const override {
-    const auto& opTargets = getTargets();
-    return {opTargets.begin(), opTargets.end()};
-  }
-
-  [[nodiscard]] const Controls& getControls() const override {
-    throw QFRException("Cannot get controls from non-unitary operation.");
-  }
-
-  [[nodiscard]] Controls& getControls() override {
-    throw QFRException("Cannot get controls from non-unitary operation.");
-  }
-
   void addDepthContribution(std::vector<std::size_t>& depths) const override;
 
   void addControl(const Control /*c*/) override {

include/mqt-core/operations/Operation.hpp

@@ -68,15 +68,10 @@ class Operation {
   [[nodiscard]] const std::string& getName() const { return name; }
   [[nodiscard]] virtual OpType getType() const { return type; }
 
-  [[nodiscard]] virtual std::set<Qubit> getUsedQubits() const {
-    const auto& opTargets = getTargets();
-    const auto& opControls = getControls();
-    std::set<Qubit> usedQubits = {opTargets.begin(), opTargets.end()};
-    for (const auto& control : opControls) {
-      usedQubits.insert(control.qubit);
-    }
-    return usedQubits;
-  }
+  [[nodiscard]] virtual auto
+  getUsedQubitsPermuted(const Permutation& perm) const -> std::set<Qubit>;
+
+  [[nodiscard]] auto getUsedQubits() const -> std::set<Qubit>;
 
   [[nodiscard]] std::unique_ptr<Operation> getInverted() const {
     auto op = clone();

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 @@ void CompoundOperation::dumpOpenQASM(std::ostream& of,
   }
 }
 
-std::set<Qubit> CompoundOperation::getUsedQubits() const {
+auto CompoundOperation::getUsedQubitsPermuted(const Permutation& perm) const
+    -> std::set<Qubit> {
   std::set<Qubit> usedQubits{};
   for (const auto& op : ops) {
-    usedQubits.merge(op->getUsedQubits());
+    usedQubits.merge(op->getUsedQubitsPermuted(perm));
   }
   return usedQubits;
 }

src/operations/Operation.cpp

@@ -121,51 +121,35 @@ bool Operation::equals(const Operation& op, const Permutation& perm1,
     return false;
   }
 
-  // check controls
-  if (nc1 != 0U) {
-    Controls controls1{};
-    if (perm1.empty()) {
-      controls1 = getControls();
-    } else {
-      for (const auto& control : getControls()) {
-        controls1.emplace(perm1.at(control.qubit), control.type);
-      }
+  if (isDiagonalGate()) {
+    // check pos. controls and targets together
+    const auto& usedQubits1 = getUsedQubitsPermuted(perm1);
+    const auto& usedQubits2 = op.getUsedQubitsPermuted(perm2);
+    if (usedQubits1 != usedQubits2) {
+      return false;
     }
 
-    Controls controls2{};
-    if (perm2.empty()) {
-      controls2 = op.getControls();
-    } else {
-      for (const auto& control : op.getControls()) {
-        controls2.emplace(perm2.at(control.qubit), control.type);
+    std::set<Qubit> negControls1{};
+    for (const auto& control : getControls()) {
+      if (control.type == Control::Type::Neg) {
+        negControls1.emplace(perm1.apply(control.qubit));
       }
     }
-
-    if (controls1 != controls2) {
-      return false;
-    }
-  }
-
-  // check targets
-  std::set<Qubit> targets1{};
-  if (perm1.empty()) {
-    targets1 = {getTargets().begin(), getTargets().end()};
-  } else {
-    for (const auto& target : getTargets()) {
-      targets1.emplace(perm1.at(target));
+    std::set<Qubit> negControls2{};
+    for (const auto& control : op.getControls()) {
+      if (control.type == Control::Type::Neg) {
+        negControls2.emplace(perm2.apply(control.qubit));
+      }
     }
+    return negControls1 == negControls2;
   }
-
-  std::set<Qubit> targets2{};
-  if (perm2.empty()) {
-    targets2 = {op.getTargets().begin(), op.getTargets().end()};
-  } else {
-    for (const auto& target : op.getTargets()) {
-      targets2.emplace(perm2.at(target));
-    }
+  // check controls
+  if (nc1 != 0U &&
+      perm1.apply(getControls()) != perm2.apply(op.getControls())) {
+    return false;
   }
 
-  return targets1 == targets2;
+  return perm1.apply(getTargets()) == perm2.apply(op.getTargets());
 }
 
 void Operation::addDepthContribution(std::vector<std::size_t>& depths) const {
@@ -198,4 +182,19 @@ auto Operation::isInverseOf(const Operation& other) const -> bool {
   return operator==(*other.getInverted());
 }
 
+auto Operation::getUsedQubitsPermuted(const qc::Permutation& perm) const
+    -> std::set<Qubit> {
+  std::set<Qubit> usedQubits;
+  for (const auto& target : getTargets()) {
+    usedQubits.emplace(perm.apply(target));
+  }
+  for (const auto& control : getControls()) {
+    usedQubits.emplace(perm.apply(control.qubit));
+  }
+  return usedQubits;
+}
+
+auto Operation::getUsedQubits() const -> std::set<Qubit> {
+  return getUsedQubitsPermuted({});
+}
 } // namespace qc

test/datastructures/test_layer.cpp

@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <gtest/gtest.h>
 #include <memory>
+#include <stdexcept>
 #include <tuple>
 #include <vector>
 
@@ -39,7 +40,7 @@ TEST(Layer, ExecutableSet1) {
   EXPECT_EQ(layer.getExecutableSet().size(), 1); // layer (1)
   std::shared_ptr<Layer::DAGVertex> v = *(layer.getExecutableSet()).begin();
   v->execute();
-  EXPECT_ANY_THROW(v->execute());
+  EXPECT_THROW(v->execute(), std::logic_error);
   EXPECT_EQ(layer.getExecutableSet().size(), 3); // layer (2)
   v = *(layer.getExecutableSet()).begin();
   v->execute();

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);

test/unittests/test_qfr_functionality.cpp

@@ -1706,7 +1706,6 @@ TEST_F(QFRFunctionality, addControlClassicControlledOperation) {
 TEST_F(QFRFunctionality, addControlNonUnitaryOperation) {
   auto op = NonUnitaryOperation(0U, Measure);
 
-  EXPECT_THROW(static_cast<void>(op.getControls()), QFRException);
   EXPECT_THROW(op.addControl(1), QFRException);
   EXPECT_THROW(op.removeControl(1), QFRException);
   EXPECT_THROW(op.clearControls(), QFRException);