🎨 Refactor NAComputation with concrete base classes for every operation and ouput new .naviz format

include/mqt-core/na/NAComputation.hpp

@@ -9,94 +9,102 @@
 
 #pragma once
 
-#include "NADefinitions.hpp"
-#include "operations/NAOperation.hpp"
+#include "na/entities/Atom.hpp"
+#include "na/entities/Location.hpp"
+#include "na/entities/Zone.hpp"
+#include "na/operations/Op.hpp"
 
-#include <algorithm>
 #include <cstddef>
-#include <iterator>
 #include <memory>
 #include <ostream>
 #include <string>
+#include <unordered_map>
+#include <utility>
 #include <vector>
 
 namespace na {
-class NAComputation {
+class NAComputation final : protected std::vector<std::unique_ptr<Op>> {
 protected:
-  std::vector<std::shared_ptr<Point>> initialPositions;
-  std::vector<std::unique_ptr<NAOperation>> operations;
+  std::vector<std::unique_ptr<Atom>> atoms;
+  std::vector<std::unique_ptr<Zone>> zones;
+  std::unordered_map<const Atom*, Location> initialLocations;
 
 public:
+  using std::vector<std::unique_ptr<Op>>::begin;
+  using std::vector<std::unique_ptr<Op>>::clear;
+  using std::vector<std::unique_ptr<Op>>::end;
+  using std::vector<std::unique_ptr<Op>>::size;
+  using std::vector<std::unique_ptr<Op>>::operator[];
   NAComputation() = default;
   NAComputation(NAComputation&& qc) noexcept = default;
   NAComputation& operator=(NAComputation&& qc) noexcept = default;
-  NAComputation(const NAComputation& qc)
-      : initialPositions(qc.initialPositions) {
-    operations.reserve(qc.operations.size());
-    std::transform(qc.operations.cbegin(), qc.operations.cend(),
-                   std::back_inserter(operations),
-                   [](const auto& op) { return op->clone(); });
+  [[nodiscard]] auto getAtomsSize() const -> std::size_t {
+    return atoms.size();
   }
-  NAComputation& operator=(const NAComputation& qc) {
-    if (this != &qc) {
-      initialPositions = qc.initialPositions;
-      operations.clear();
-      operations.reserve(qc.operations.size());
-      std::transform(qc.operations.cbegin(), qc.operations.cend(),
-                     std::back_inserter(operations),
-                     [](const auto& op) { return op->clone(); });
-    }
-    return *this;
+  [[nodiscard]] auto getAtoms() const -> const decltype(atoms)& {
+    return atoms;
   }
-  virtual ~NAComputation() = default;
-  template <class T> auto emplaceBack(std::unique_ptr<T>&& op) -> void {
-    static_assert(std::is_base_of_v<NAOperation, T>,
-                  "T must be a subclass of NAOperation.");
-    operations.emplace_back(std::move(op));
+  [[nodiscard]] auto getZones() const -> const decltype(zones)& {
+    return zones;
   }
-  template <class T> auto emplaceBack(const std::unique_ptr<T>& op) -> void {
-    static_assert(std::is_base_of_v<NAOperation, T>,
-                  "T must be a subclass of NAOperation.");
-    operations.emplace_back(std::move(op));
+  [[nodiscard]] auto getInitialLocations() const -> const
+      decltype(initialLocations)& {
+    return initialLocations;
   }
-  template <class T, class... Args> auto emplaceBack(Args&&... args) -> void {
-    static_assert(std::is_base_of_v<NAOperation, T>,
-                  "T must be a subclass of NAOperation.");
-    operations.emplace_back(std::make_unique<T>(std::forward<Args>(args)...));
+  [[nodiscard]] auto
+  getLocationOfAtomAfterOperation(const std::unique_ptr<Atom>& atom,
+                                  const std::unique_ptr<Op>& op) const
+      -> Location {
+    return getLocationOfAtomAfterOperation(atom.get(), op.get());
   }
-  auto clear(const bool clearInitialPositions = true) -> void {
-    operations.clear();
-    if (clearInitialPositions) {
-      initialPositions.clear();
-    }
+  [[nodiscard]] auto
+  getLocationOfAtomAfterOperation(const std::unique_ptr<Atom>& atom,
+                                  const Op* op) const -> Location {
+    return getLocationOfAtomAfterOperation(atom.get(), op);
   }
-  [[nodiscard]] auto size() const -> std::size_t { return operations.size(); }
-  [[nodiscard]] auto getInitialPositions() const
-      -> const std::vector<std::shared_ptr<Point>>& {
-    return initialPositions;
+  [[nodiscard]] auto getLocationOfAtomAfterOperation(
+      const Atom* atom, const std::unique_ptr<Op>& op) const -> Location {
+    return getLocationOfAtomAfterOperation(atom, op.get());
   }
-  auto emplaceInitialPosition(std::shared_ptr<Point> p) -> void {
-    initialPositions.emplace_back(std::move(p));
+  [[nodiscard]] auto getLocationOfAtomAfterOperation(const Atom* atom,
+                                                     const Op* op) const
+      -> Location;
+  auto emplaceBackAtom(std::string name) -> const Atom* {
+    return atoms.emplace_back(std::make_unique<Atom>(std::move(name))).get();
+  }
+  auto emplaceBackZone(std::string name) -> const Zone* {
+    return zones.emplace_back(std::make_unique<Zone>(std::move(name))).get();
+  }
+  auto emplaceInitialLocation(const Atom* atom, const Location& loc) -> void {
+    initialLocations.emplace(atom, loc);
+  }
+  template <typename... Args>
+  auto emplaceInitialLocation(const Atom* atom, Args&&... loc) -> void {
+    initialLocations.emplace(atom, Location{std::forward<Args>(loc)...});
+  }
+  template <class T> auto emplaceBack(T&& op) -> const Op* {
+    return std::vector<std::unique_ptr<Op>>::emplace_back(
+               std::make_unique<T>(std::forward<T>(op)))
+        .get();
+  }
+  template <class T, typename... Args>
+  auto emplaceBack(Args&&... args) -> const Op* {
+    return std::vector<std::unique_ptr<Op>>::emplace_back(
+               std::make_unique<T>(std::forward<Args>(args)...))
+        .get();
   }
   [[nodiscard]] auto toString() const -> std::string;
   friend auto operator<<(std::ostream& os, const NAComputation& qc)
       -> std::ostream& {
     return os << qc.toString();
   }
-  // Iterators (pass-through)
-  auto begin() noexcept { return operations.begin(); }
-  [[nodiscard]] auto begin() const noexcept { return operations.begin(); }
-  [[nodiscard]] auto cbegin() const noexcept { return operations.cbegin(); }
-  auto end() noexcept { return operations.end(); }
-  [[nodiscard]] auto end() const noexcept { return operations.end(); }
-  [[nodiscard]] auto cend() const noexcept { return operations.cend(); }
-  auto rbegin() noexcept { return operations.rbegin(); }
-  [[nodiscard]] auto rbegin() const noexcept { return operations.rbegin(); }
-  [[nodiscard]] auto crbegin() const noexcept { return operations.crbegin(); }
-  auto rend() noexcept { return operations.rend(); }
-  [[nodiscard]] auto rend() const noexcept { return operations.rend(); }
-  [[nodiscard]] auto crend() const noexcept { return operations.crend(); }
-
-  [[nodiscard]] auto validateAODConstraints() const -> bool;
+  /// Validates the NAComputation and checks whether all AOD constraints are
+  /// fulfilled.
+  /// I.e.,
+  /// - each atom is loaded before it is moved
+  /// - the relative order of loaded atoms is preserved
+  /// - each atom is loaded before it is stored
+  /// - each atom is stored before it is loaded (again)
+  [[nodiscard]] auto validate() const -> bool;
 };
 } // namespace na

include/mqt-core/na/NAUtils.hpp

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2025 Chair for Design Automation, TUM
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include "Definitions.hpp"
+#include "ir/operations/CompoundOperation.hpp"
+#include "ir/operations/OpType.hpp"
+#include "ir/operations/Operation.hpp"
+
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <utility>
+
+namespace na {
+/**
+ * @brief Checks whether a gate is global.
+ * @details A StandardOperation is global if it acts on all qubits.
+ * A CompoundOperation is global if all its sub-operations are
+ * StandardOperations of the same type with the same parameters acting on all
+ * qubits. The latter is what a QASM line like `ry(π) q;` is translated to in
+ * MQT-core. All other operations are not global.
+ */
+[[nodiscard]] inline auto isGlobal(const qc::Operation& op,
+                                   const std::size_t nQubits) -> bool {
+  if (op.isStandardOperation()) {
+    return op.getUsedQubits().size() == nQubits;
+  }
+  if (op.isCompoundOperation()) {
+    const auto ops = dynamic_cast<const qc::CompoundOperation&>(op);
+    const auto& params = ops.at(0)->getParameter();
+    const auto& type = ops.at(0)->getType();
+    return op.getUsedQubits().size() == nQubits &&
+           std::all_of(ops.cbegin(), ops.cend(), [&](const auto& operation) {
+             return operation->isStandardOperation() &&
+                    operation->getNcontrols() == 0 &&
+                    operation->getType() == type &&
+                    operation->getParameter() == params;
+           });
+  }
+  return false;
+}
+} // namespace na
+
+template <> struct std::hash<std::pair<qc::OpType, std::size_t>> {
+  std::size_t
+  operator()(const std::pair<qc::OpType, std::size_t>& t) const noexcept {
+    const std::size_t h1 = std::hash<qc::OpType>{}(t.first);
+    const std::size_t h2 = std::hash<std::size_t>{}(t.second);
+    return qc::combineHash(h1, h2);
+  }
+};
+
+template <> struct std::hash<std::pair<std::size_t, std::size_t>> {
+  std::size_t
+  operator()(const std::pair<std::size_t, std::size_t>& p) const noexcept {
+    const std::size_t h1 = std::hash<std::size_t>{}(p.first);
+    const std::size_t h2 = std::hash<std::size_t>{}(p.second);
+    return qc::combineHash(h1, h2);
+  }
+};