mqt-core 3.1.0__cp313-cp313t-win_arm64.whl

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines a class for representing global CZ operations.
+ */
+
+#pragma once
+
+#include "na/entities/Zone.hpp"
+#include "na/operations/GlobalOp.hpp"
+
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a global CZ operation in the NAComputation.
+class GlobalCZOp final : public GlobalOp {
+public:
+  /// Creates a new CZ operation in the given zones.
+  /// @param zones The zones the operation is applied to.
+  explicit GlobalCZOp(std::vector<const Zone*> zones)
+      : GlobalOp(std::move(zones), {}) {
+    name_ = "cz";
+  }
+
+  /// Creates a new CZ operation in the given zone.
+  /// @param zone The zone the operation is applied to.
+  explicit GlobalCZOp(const Zone& zone) : GlobalCZOp({&zone}) {}
+};
+} // namespace na

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines a class for representing global operations in the
+ * NAComputation.
+ */
+
+#pragma once
+
+#include "ir/Definitions.hpp"
+#include "na/entities/Zone.hpp"
+#include "na/operations/Op.hpp"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a global operation in the NAComputation.
+/// @details Global operations are applied to entire zones instead of to
+/// individual atoms.
+class GlobalOp : public Op {
+protected:
+  /// The name of the operation.
+  std::string name_;
+  /// The parameters of the operation.
+  std::vector<qc::fp> params_;
+  /// The zones the operation is applied to.
+  std::vector<const Zone*> zones_;
+
+  /// Creates a new global operation in the given zone with the given
+  /// parameters.
+  /// @param zones The zones the operation is applied to.
+  /// @param params The parameters of the operation.
+  GlobalOp(std::vector<const Zone*> zones, std::vector<qc::fp> params)
+      : params_(std::move(params)), zones_(std::move(zones)) {}
+
+public:
+  GlobalOp() = delete;
+
+  /// Returns the parameters of the operation.
+  [[nodiscard]] auto getParams() const -> auto& { return params_; }
+
+  /// Returns the zone the operation is applied to.
+  [[nodiscard]] auto getZones() const -> auto& { return zones_; }
+
+  /// Returns a string representation of the operation.
+  [[nodiscard]] auto toString() const -> std::string override;
+};
+} // namespace na

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines a class for representing global RY operations.
+ */
+
+#pragma once
+
+#include "ir/Definitions.hpp"
+#include "na/entities/Zone.hpp"
+#include "na/operations/GlobalOp.hpp"
+
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a global RY operation in the NAComputation.
+class GlobalRYOp final : public GlobalOp {
+public:
+  /// Creates a new RY operation in the given zones with the given angle.
+  /// @param zones The zones the operation is applied to.
+  /// @param angle The angle of the operation.
+  GlobalRYOp(std::vector<const Zone*> zones, const qc::fp angle)
+      : GlobalOp(std::move(zones), {angle}) {
+    name_ = "ry";
+  }
+
+  /// Creates a new RY operation in the given zone with the given angle.
+  /// @param zone The zone the operation is applied to.
+  /// @param angle The angle of the operation.
+  GlobalRYOp(const Zone& zone, const qc::fp angle)
+      : GlobalRYOp({&zone}, angle) {}
+};
+} // namespace na

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

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines a class for representing load operations.
+ */
+
+#pragma once
+
+#include "na/entities/Atom.hpp"
+#include "na/entities/Location.hpp"
+#include "na/operations/ShuttlingOp.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a load operation in the NAComputation.
+/// @details Before an atom can be moved, it must be loaded, i.e., transferred
+/// from a static SLM to an adjustable AOD trap.
+class LoadOp final : public ShuttlingOp {
+protected:
+  /// The target locations to load the atoms to.
+  std::optional<std::vector<Location>> targetLocations_ = std::nullopt;
+
+public:
+  /// Creates a new load operation with the given atoms and target locations.
+  /// @details The target locations can be set if the loading operation contains
+  /// a certain offset.
+  /// @param atoms The atoms to load.
+  /// @param targetLocations The target locations to load the atoms to.
+  LoadOp(std::vector<const Atom*> atoms, std::vector<Location> targetLocations)
+      : ShuttlingOp(std::move(atoms)),
+        targetLocations_(std::move(targetLocations)) {
+    if (atoms_.size() != targetLocations_->size()) {
+      throw std::invalid_argument(
+          "Number of atoms and target locations must be equal.");
+    }
+  }
+
+  /// Creates a new load operation with the given atoms.
+  /// @details This constructor is used if the target locations are not set,
+  /// i.e., the load operation does not incorporate any offset.
+  /// @param atoms The atoms to load.
+  explicit LoadOp(std::vector<const Atom*> atoms)
+      : ShuttlingOp(std::move(atoms)) {}
+
+  /// Creates a new load operation with the given atom and target location.
+  /// @details The target locations can be set if the loading operation contains
+  /// a certain offset.
+  /// @param atom The atom to load.
+  /// @param targetLocation The target location to load the atom to.
+  LoadOp(const Atom& atom, const Location& targetLocation)
+      : LoadOp({&atom}, {targetLocation}) {}
+
+  /// Creates a new load operation with the given atom.
+  /// @details This constructor is used if the target locations are not set,
+  /// i.e., the load operation does not incorporate any offset.
+  /// @param atom The atom to load.
+  explicit LoadOp(const Atom& atom) : LoadOp({&atom}) {}
+
+  /// Returns whether the load operation has target locations set.
+  [[nodiscard]] auto hasTargetLocations() const -> bool override {
+    return targetLocations_.has_value();
+  }
+
+  /// Returns the target locations of the load operation.
+  [[nodiscard]] auto getTargetLocations() const
+      -> const std::vector<Location>& override {
+    if (!targetLocations_.has_value()) {
+      throw std::logic_error("Operation has no target locations set.");
+    }
+    return *targetLocations_;
+  }
+
+  /// Returns a string representation of the load operation.
+  [[nodiscard]] auto toString() const -> std::string override;
+};
+} // namespace na

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines a class for representing local operations in the
+ * NAComputation.
+ */
+
+#pragma once
+
+#include "ir/Definitions.hpp"
+#include "na/entities/Atom.hpp"
+#include "na/operations/Op.hpp"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a local operation in the NAComputation.
+/// @details A local operation is applied to individual atoms.
+class LocalOp : public Op {
+protected:
+  /// The name of the operation.
+  std::string name_;
+  /// The parameters of the operation.
+  std::vector<qc::fp> params_;
+  /// The atoms the operation is applied to.
+  std::vector<const Atom*> atoms_;
+
+  /// Creates a new local operation with the given atoms and parameters.
+  /// @param atoms The atoms the operation is applied to.
+  /// @param params The parameters of the operation.
+  LocalOp(std::vector<const Atom*> atoms, std::vector<qc::fp> params)
+      : params_(std::move(params)), atoms_(std::move(atoms)) {}
+
+public:
+  LocalOp() = delete;
+
+  /// Returns the atoms the operation is applied to.
+  [[nodiscard]] auto getAtoms() const -> auto& { return atoms_; }
+
+  /// Returns the parameters of the operation.
+  [[nodiscard]] auto getParams() const -> auto& { return params_; }
+
+  /// Returns a string representation of the operation.
+  [[nodiscard]] auto toString() const -> std::string override;
+};
+} // namespace na

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines a class for representing local RZ operations.
+ */
+
+#pragma once
+
+#include "ir/Definitions.hpp"
+#include "na/entities/Atom.hpp"
+#include "na/operations/LocalOp.hpp"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a local RZ operation in the NAComputation.
+class LocalRZOp final : public LocalOp {
+public:
+  /// Creates a new RZ operation with the given atoms and angle.
+  /// @param atoms The atoms the operation is applied to.
+  /// @param angle The angle of the operation.
+  LocalRZOp(std::vector<const Atom*> atoms, const qc::fp angle)
+      : LocalOp(std::move(atoms), {angle}) {
+    name_ = "rz";
+  }
+
+  /// Creates a new RZ operation with the given atom and angle.
+  /// @param atom The atom the operation is applied to.
+  /// @param angle The angle of the operation.
+  LocalRZOp(const Atom& atom, const qc::fp angle) : LocalRZOp({&atom}, angle) {}
+};
+} // namespace na

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines a class for representing local U3 operations.
+ */
+
+#pragma once
+
+#include "ir/Definitions.hpp"
+#include "na/entities/Atom.hpp"
+#include "na/operations/LocalOp.hpp"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a local U3 operation in the NAComputation.
+class LocalUOp final : public LocalOp {
+public:
+  /// Creates a new U3 operation with the given atoms and angles.
+  /// @param atoms The atoms the operation is applied to.
+  /// @param theta The first parameter of the operation.
+  /// @param phi The second parameter of the operation.
+  /// @param lambda The third parameter of the operation.
+  LocalUOp(std::vector<const Atom*> atoms, const qc::fp theta, const qc::fp phi,
+           const qc::fp lambda)
+      : LocalOp(std::move(atoms), {theta, phi, lambda}) {
+    name_ = "u";
+  }
+
+  /// Creates a new U3 operation with the given atom and angle.
+  /// @param atom The atom the operation is applied to.
+  /// @param theta The first parameter of the operation.
+  /// @param phi The second parameter of the operation.
+  /// @param lambda The third parameter of the operation.
+  LocalUOp(const Atom& atom, const qc::fp theta, const qc::fp phi,
+           const qc::fp lambda)
+      : LocalUOp({&atom}, theta, phi, lambda) {}
+};
+} // namespace na

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines a class for representing move operations.
+ */
+
+#pragma once
+
+#include "na/entities/Atom.hpp"
+#include "na/entities/Location.hpp"
+#include "na/operations/ShuttlingOp.hpp"
+
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a move operation in the NAComputation.
+class MoveOp final : public ShuttlingOp {
+protected:
+  /// The target locations to move the atoms to.
+  std::vector<Location> targetLocations_;
+
+public:
+  /// Creates a new move operation with the given atoms and target locations.
+  /// @param atoms The atoms to move.
+  /// @param targetLocations The target locations to move the atoms to.
+  MoveOp(std::vector<const Atom*> atoms, std::vector<Location> targetLocations)
+      : ShuttlingOp(std::move(atoms)),
+        targetLocations_(std::move(targetLocations)) {
+    if (atoms_.size() != targetLocations_.size()) {
+      throw std::invalid_argument(
+          "Number of atoms and target locations must be equal.");
+    }
+  }
+
+  /// Creates a new move operation with the given atom and target location.
+  /// @param atom The atom to move.
+  /// @param targetLocation The target location to move the atom to.
+  MoveOp(const Atom& atom, const Location& targetLocation)
+      : MoveOp({&atom}, {targetLocation}) {}
+
+  /// Returns whether the move operation has target locations set.
+  [[nodiscard]] auto hasTargetLocations() const -> bool override {
+    return true;
+  }
+
+  /// Returns the target locations of the move operation.
+  [[nodiscard]] auto getTargetLocations() const -> const
+      decltype(targetLocations_)& override {
+    return targetLocations_;
+  }
+
+  /// Returns a string representation of the operation.
+  [[nodiscard]] auto toString() const -> std::string override;
+};
+} // namespace na

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

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines the base class for all operations in the NAComputation.
+ */
+
+#pragma once
+
+#include <ostream>
+#include <string>
+
+namespace na {
+/// This is the base class for all operations in the NAComputation.
+class Op {
+public:
+  /// Default constructor.
+  Op() = default;
+
+  /// Virtual destructor.
+  virtual ~Op() = default;
+
+  /// Returns a string representation of the operation.
+  [[nodiscard]] virtual auto toString() const -> std::string = 0;
+
+  /// Prints the operation to the given output stream.
+  /// @param os The output stream to print the operation to.
+  /// @param obj The operation to print.
+  /// @return The output stream after printing the operation.
+  friend auto operator<<(std::ostream& os, const Op& obj) -> std::ostream& {
+    return os << obj.toString(); // Using toString() method
+  }
+
+  /// Checks if the operation is of the given type.
+  /// @tparam T The type to check for.
+  /// @return True if the operation is of the given type, false otherwise.
+  template <class T> [[nodiscard]] auto is() const -> bool {
+    return dynamic_cast<const T*>(this) != nullptr;
+  }
+
+  /// Casts the operation to the given type.
+  /// @tparam T The type to cast to.
+  /// @return A reference to the operation as the given type.
+  template <class T> [[nodiscard]] auto as() -> T& {
+    return dynamic_cast<T&>(*this);
+  }
+
+  /// Casts the operation to the given type.
+  /// @tparam T The type to cast to.
+  /// @return A const reference to the operation as the given type.
+  template <class T> [[nodiscard]] auto as() const -> const T& {
+    return dynamic_cast<const T&>(*this);
+  }
+};
+} // namespace na

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines a base class for representing shuttling operations.
+ */
+
+#pragma once
+
+#include "na/entities/Atom.hpp"
+#include "na/entities/Location.hpp"
+#include "na/operations/Op.hpp"
+
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a shuttling operation in the NAComputation.
+/// @details A shuttling operation is the super class for all shuttling-related
+/// operations, i.e., load, store, and move operations.
+class ShuttlingOp : public Op {
+protected:
+  /// The atoms the operation is applied to.
+  std::vector<const Atom*> atoms_;
+
+  /// Creates a new shuttling operation with the given atoms.
+  /// @param atoms The atoms the operation is applied to.
+  explicit ShuttlingOp(std::vector<const Atom*> atoms)
+      : atoms_(std::move(atoms)) {}
+
+public:
+  ShuttlingOp() = delete;
+
+  /// Returns the atoms the operation is applied to.
+  [[nodiscard]] auto getAtoms() const -> auto& { return atoms_; }
+
+  /// Returns whether the shuttling operation has target locations set.
+  [[nodiscard]] virtual auto hasTargetLocations() const -> bool = 0;
+
+  /// Returns the target locations of the shuttling operation.
+  [[nodiscard]] virtual auto getTargetLocations() const
+      -> const std::vector<Location>& = 0;
+};
+} // namespace na

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

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/** @file
+ * @brief Defines a class for representing store operations.
+ */
+
+#pragma once
+
+#include "na/entities/Atom.hpp"
+#include "na/entities/Location.hpp"
+#include "na/operations/ShuttlingOp.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a store operation in the NAComputation.
+class StoreOp final : public ShuttlingOp {
+protected:
+  /// The target locations to store the atoms to.
+  std::optional<std::vector<Location>> targetLocations_ = std::nullopt;
+
+public:
+  /// Creates a new store operation with the given atoms and target locations.
+  /// @details The target locations can be used if the store operation
+  /// incorporates some offset.
+  /// @param atoms The atoms to store.
+  /// @param targetLocations The target locations to store the atoms to.
+  StoreOp(std::vector<const Atom*> atoms, std::vector<Location> targetLocations)
+      : ShuttlingOp(std::move(atoms)),
+        targetLocations_(std::move(targetLocations)) {
+    if (atoms_.size() != targetLocations_->size()) {
+      throw std::invalid_argument(
+          "Number of atoms and target locations must be equal.");
+    }
+  }
+
+  /// Creates a new store operation with the given atoms and target locations.
+  /// @details Here, the target locations are not used, i.e., this store does
+  /// not contain any offset.
+  /// @param atoms The atoms to store.
+  explicit StoreOp(std::vector<const Atom*> atoms)
+      : ShuttlingOp(std::move(atoms)) {}
+
+  /// Creates a new store operation with the given atom and target location.
+  /// @details The target location can be used if the store operation
+  /// incorporates some offset.
+  /// @param atom The atom to store.
+  /// @param targetLocation The target location to store the atom to.
+  StoreOp(const Atom& atom, const Location& targetLocation)
+      : StoreOp({&atom}, {targetLocation}) {}
+
+  /// Creates a new store operation with the given atom and target locations.
+  /// @details Here, the target locations are not used, i.e., this store does
+  /// not contain any offset.
+  /// @param atom The atom to store.
+  explicit StoreOp(const Atom& atom) : StoreOp({&atom}) {}
+
+  /// Returns whether the store operation has target locations set.
+  [[nodiscard]] auto hasTargetLocations() const -> bool override {
+    return targetLocations_.has_value();
+  }
+
+  /// Returns the target locations of the store operation.
+  [[nodiscard]] auto getTargetLocations() const
+      -> const std::vector<Location>& override {
+    if (!targetLocations_.has_value()) {
+      throw std::logic_error("Operation has no target locations set.");
+    }
+    return *targetLocations_;
+  }
+
+  /// Returns a string representation of the operation.
+  [[nodiscard]] auto toString() const -> std::string override;
+};
+} // namespace na