mqt-core 3.1.0__cp313-cp313t-win_arm64.whl

mqt/core/include/mqt-core/ir/operations/SymbolicOperation.hpp

@@ -0,0 +1,144 @@
+/*
+ * 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
+ */
+
+#pragma once
+
+#include "ir/Definitions.hpp"
+#include "ir/Permutation.hpp"
+#include "ir/Register.hpp"
+#include "ir/operations/Control.hpp"
+#include "ir/operations/Expression.hpp"
+#include "ir/operations/OpType.hpp"
+#include "ir/operations/Operation.hpp"
+#include "ir/operations/StandardOperation.hpp"
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <variant>
+#include <vector>
+
+namespace qc {
+
+class SymbolicOperation final : public StandardOperation {
+public:
+  SymbolicOperation() = default;
+
+  [[nodiscard]] SymbolOrNumber getParameter(std::size_t i) const;
+
+  [[nodiscard]] std::vector<SymbolOrNumber> getParameters() const;
+
+  void setSymbolicParameter(const Symbolic& par, const std::size_t i) {
+    symbolicParameter.at(i) = par;
+  }
+
+  // Standard Constructors
+  SymbolicOperation(Qubit target, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+  SymbolicOperation(const Targets& targ, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+
+  SymbolicOperation(Control control, Qubit target, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+  SymbolicOperation(Control control, const Targets& targ, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+
+  SymbolicOperation(const Controls& c, Qubit target, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+  SymbolicOperation(const Controls& c, const Targets& targ, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+
+  // MCF (cSWAP), Peres, parameterized two target Constructor
+  SymbolicOperation(const Controls& c, Qubit target0, Qubit target1, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+
+  [[nodiscard]] std::unique_ptr<Operation> clone() const override;
+
+  [[nodiscard]] bool isSymbolicOperation() const override;
+
+  [[nodiscard]] bool isStandardOperation() const override;
+
+  [[nodiscard]] bool equals(const Operation& op, const Permutation& perm1,
+                            const Permutation& perm2) const override;
+  [[nodiscard]] bool equals(const Operation& op) const override {
+    return equals(op, {}, {});
+  }
+
+  [[noreturn]] void dumpOpenQASM(std::ostream& of,
+                                 const QubitIndexToRegisterMap& qubitMap,
+                                 const BitIndexToRegisterMap& bitMap,
+                                 std::size_t indent,
+                                 bool openQASM3) const override;
+
+  [[nodiscard]] StandardOperation
+  getInstantiatedOperation(const VariableAssignment& assignment) const;
+
+  // Instantiates this Operation
+  // Afterwards casting to StandardOperation can be done if assignment is total
+  void instantiate(const VariableAssignment& assignment);
+
+  void invert() override;
+
+protected:
+  std::vector<std::optional<Symbolic>> symbolicParameter;
+
+  static OpType parseU3(const Symbolic& theta, fp& phi, fp& lambda);
+  static OpType parseU3(fp& theta, const Symbolic& phi, fp& lambda);
+  static OpType parseU3(fp& theta, fp& phi, const Symbolic& lambda);
+  static OpType parseU3(const Symbolic& theta, const Symbolic& phi, fp& lambda);
+  static OpType parseU3(const Symbolic& theta, fp& phi, const Symbolic& lambda);
+  static OpType parseU3(fp& theta, const Symbolic& phi, const Symbolic& lambda);
+
+  static OpType parseU2(const Symbolic& phi, const Symbolic& lambda);
+  static OpType parseU2(const Symbolic& phi, fp& lambda);
+  static OpType parseU2(fp& phi, const Symbolic& lambda);
+
+  static OpType parseU1(const Symbolic& lambda);
+
+  void checkSymbolicUgate();
+
+  void storeSymbolOrNumber(const SymbolOrNumber& param, std::size_t i);
+
+  [[nodiscard]] bool isSymbolicParameter(std::size_t i) const;
+
+  static bool isSymbol(const SymbolOrNumber& param);
+
+  static Symbolic& getSymbol(SymbolOrNumber& param);
+
+  static fp& getNumber(SymbolOrNumber& param);
+
+  void setup(const std::vector<SymbolOrNumber>& params);
+
+  [[nodiscard]] static fp
+  getInstantiation(const SymbolOrNumber& symOrNum,
+                   const VariableAssignment& assignment);
+
+  void negateSymbolicParameter(std::size_t index);
+
+  void addToSymbolicParameter(std::size_t index, fp value);
+};
+} // namespace qc
+
+template <> struct std::hash<qc::SymbolicOperation> {
+  std::size_t operator()(qc::SymbolicOperation const& op) const noexcept {
+    std::size_t seed = 0U;
+    qc::hashCombine(seed, std::hash<qc::Operation>{}(op));
+    for (const auto& param : op.getParameters()) {
+      if (std::holds_alternative<qc::fp>(param)) {
+        qc::hashCombine(seed, hash<qc::fp>{}(get<qc::fp>(param)));
+      } else {
+        qc::hashCombine(seed, hash<qc::Symbolic>{}(get<qc::Symbolic>(param)));
+      }
+    }
+    return seed;
+  }
+};

mqt/core/include/mqt-core/na/NAComputation.hpp

@@ -0,0 +1,185 @@
+/*
+ * 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 neutral atom computations.
+ */
+
+#pragma once
+
+#include "na/entities/Atom.hpp"
+#include "na/entities/Location.hpp"
+#include "na/entities/Zone.hpp"
+#include "na/operations/Op.hpp"
+
+#include <cstddef>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a neutral atom computation.
+class NAComputation final {
+protected:
+  /// The operations in the NA computation.
+  std::vector<std::unique_ptr<Op>> operations_;
+  /// The atoms used in the NA computation.
+  std::vector<std::unique_ptr<Atom>> atoms_;
+  /// The zones used in the NA computation.
+  std::vector<std::unique_ptr<Zone>> zones_;
+  /// The initial locations of the atoms.
+  std::unordered_map<const Atom*, Location> initialLocations_;
+
+public:
+  /// Returns an iterator to the beginning of the operations.
+  [[nodiscard]] auto begin() -> auto { return operations_.begin(); }
+
+  /// Returns an iterator to the beginning of the operations.
+  [[nodiscard]] auto begin() const -> auto { return operations_.begin(); }
+
+  /// Returns an iterator to the end of the operations.
+  [[nodiscard]] auto end() -> auto { return operations_.end(); }
+
+  /// Returns an iterator to the end of the operations.
+  [[nodiscard]] auto end() const -> auto { return operations_.end(); }
+
+  /// Returns the number of operations in the NAComputation.
+  [[nodiscard]] auto size() const -> std::size_t { return operations_.size(); }
+
+  /// Returns a reference to the operation at the given index.
+  /// @param i The index of the operation.
+  /// @return A reference to the operation at the given index.
+  [[nodiscard]] auto operator[](const std::size_t i) -> Op& {
+    return *operations_[i];
+  }
+
+  /// Returns a const reference to the operation at the given index.
+  /// @param i The index of the operation.
+  /// @return A const reference to the operation at the given index.
+  [[nodiscard]] auto operator[](const std::size_t i) const -> const Op& {
+    return *operations_[i];
+  }
+
+  /// Clears the operations in the NAComputation.
+  auto clear() -> void { operations_.clear(); }
+
+  /// Returns the number of atoms used in the NAComputation.
+  [[nodiscard]] auto getAtomsSize() const -> std::size_t {
+    return atoms_.size();
+  }
+
+  /// Returns the atoms used in the NAComputation.
+  [[nodiscard]] auto getAtoms() const -> auto& { return atoms_; }
+
+  /// Returns the zones used in global operations within the NAComputation.
+  [[nodiscard]] auto getZones() const -> auto& { return zones_; }
+
+  /// Returns the initial locations of the atoms.
+  [[nodiscard]] auto getInitialLocations() const -> auto& {
+    return initialLocations_;
+  }
+
+  /// Returns the location of the given atom after the given operation.
+  /// @param atom The atom to get the location for.
+  /// @param op The operation to get the location after.
+  /// @return The location of the atom after the operation.
+  [[nodiscard]] auto getLocationOfAtomAfterOperation(const Atom& atom,
+                                                     const Op& op) const
+      -> Location;
+
+  /// Emplaces a new atom with the given name and returns a reference to the
+  /// newly created atom.
+  /// @param name The name of the atom.
+  /// @return A reference to the newly created atom.
+  auto emplaceBackAtom(std::string name) -> const Atom& {
+    return *atoms_.emplace_back(std::make_unique<Atom>(std::move(name)));
+  }
+
+  /// Emplaces a new zone with the given name and returns a reference to the
+  /// newly created zone.
+  /// @param args The name of the zone and, optionally, the extent of the zone.
+  /// @return A reference to the newly created zone.
+  template <typename... Args>
+  auto emplaceBackZone(Args&&... args) -> const Zone& {
+    return *zones_.emplace_back(
+        std::make_unique<Zone>(std::forward<Args>(args)...));
+  }
+
+  /// Emplaces a new initial location for the given atom with the given location
+  /// and returns a reference to the newly created location.
+  /// @param atom The atom to set the initial location for.
+  /// @param loc The location of the atom.
+  /// @return A reference to the newly created location.
+  auto emplaceInitialLocation(const Atom& atom, const Location& loc)
+      -> const Location& {
+    return initialLocations_.emplace(&atom, loc).first->second;
+  }
+
+  /// Emplaces a new initial location for the given atom with the given
+  /// arguments and returns a reference to the newly created location.
+  /// @param atom The atom to set the initial location for.
+  /// @param loc The parameters for the location of the atom.
+  /// @return A reference to the newly created location.
+  template <typename... Args>
+  auto emplaceInitialLocation(const Atom& atom, Args&&... loc)
+      -> const Location& {
+    return initialLocations_
+        .emplace(&atom,
+                 Location{static_cast<double>(std::forward<Args>(loc))...})
+        .first->second;
+  }
+
+  /// Emplaces a new operation of type T with the given operation and returns a
+  /// reference to the newly created operation.
+  /// @tparam T The concrete type of the operation.
+  /// @param op The operation to emplace.
+  /// @return A reference to the newly created operation.
+  template <class T> auto emplaceBack(T&& op) -> const Op& {
+    return *operations_.emplace_back(std::make_unique<T>(std::forward<T>(op)));
+  }
+
+  /// Emplaces a new operation of type T with the given arguments and returns a
+  /// reference to the newly created operation.
+  /// @tparam T The concrete type of the operation.
+  /// @param args The arguments for the operation.
+  /// @return A reference to the newly created operation.
+  template <class T, typename... Args>
+  auto emplaceBack(Args&&... args) -> const Op& {
+    return *operations_.emplace_back(
+        std::make_unique<T>(std::forward<Args>(args)...));
+  }
+
+  /// Returns a string representation of the NAComputation.
+  [[nodiscard]] auto toString() const -> std::string;
+  /// Outputs the NAComputation to the given output stream, i.e., the string
+  /// returned by toString().
+  /// @param os The output stream to print the NAComputation to.
+  /// @param qc The NAComputation to print.
+  /// @return The output stream after printing the NAComputation.
+  friend auto operator<<(std::ostream& os, const NAComputation& qc)
+      -> std::ostream& {
+    return os << qc.toString();
+  }
+
+  /// Validates the NAComputation and checks whether all AOD constraints are
+  /// fulfilled.
+  /// Specifically,
+  /// - 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)
+  /// @returns a pair of a Boolean indicating whether the NAComputation is valid
+  /// and a string containing the error message if the NAComputation is invalid.
+  [[nodiscard]] auto validate() const -> std::pair<bool, std::string>;
+};
+} // namespace na

mqt/core/include/mqt-core/na/entities/Atom.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 a type for representing individual atoms.
+ */
+
+#pragma once
+
+#include <ostream>
+#include <string>
+#include <utility>
+
+namespace na {
+/// Represents an atom in the NAComputation.
+/// @details The name of the atom is used for printing the NAComputation.
+/// To maintain the uniqueness of atoms, the name of the atom should be unique.
+class Atom final {
+  /// The identifier of the atom.
+  std::string name_;
+
+public:
+  /// Creates a new atom with the given name.
+  /// @param name The name of the atom.
+  explicit Atom(std::string name) : name_(std::move(name)) {}
+
+  /// Returns the name of the atom.
+  [[nodiscard]] auto getName() const -> std::string { return name_; }
+
+  /// Prints the atom to the given output stream.
+  /// @param os The output stream to print the atom to.
+  /// @param obj The atom to print.
+  /// @return The output stream after printing the atom.
+  friend auto operator<<(std::ostream& os, const Atom& obj) -> std::ostream& {
+    return os << obj.getName();
+  }
+
+  /// Compares two atoms for equality.
+  /// @param other The atom to compare with.
+  /// @return True if the atoms are equal, false otherwise.
+  [[nodiscard]] auto operator==(const Atom& other) const -> bool {
+    if (this == &other) {
+      return true;
+    }
+    return name_ == other.name_;
+  }
+
+  /// Compares two atoms for inequality.
+  /// @param other The atom to compare with.
+  /// @return True if the atoms are not equal, false otherwise.
+  [[nodiscard]] auto operator!=(const Atom& other) const -> bool {
+    return !(*this == other);
+  }
+};
+} // namespace na

mqt/core/include/mqt-core/na/entities/Location.hpp

@@ -0,0 +1,154 @@
+/*
+ * 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 type for representing two-dimensional locations.
+ */
+
+#pragma once
+
+#include "ir/Definitions.hpp"
+
+#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <iomanip>
+#include <ios>
+#include <ostream>
+#include <sstream>
+#include <string>
+
+namespace na {
+/// Class to store two-dimensional coordinates of type double.
+struct Location final {
+  /// The x-coordinate of the location.
+  double x = 0;
+  /// The y-coordinate of the location.
+  double y = 0;
+
+  /// Subtracts the coordinates of the given location from this location.
+  /// @param loc The location to subtract.
+  /// @return The location resulting from the subtraction.
+  Location operator-(const Location& loc) const {
+    return {x - loc.x, y - loc.y};
+  }
+
+  /// Adds the coordinates of the given location to this location.
+  /// @param loc The location to add.
+  /// @return The location resulting from the addition.
+  Location operator+(const Location& loc) const {
+    return {x + loc.x, y + loc.y};
+  }
+
+  /// Returns the length of the vector from the origin to this location.
+  [[nodiscard]] auto length() const -> double { return std::hypot(x, y); }
+
+  /// Returns the distance between two locations.
+  [[nodiscard]] static auto distance(const Location& loc1, const Location& loc2)
+      -> double {
+    return (loc1 - loc2).length();
+  }
+
+  /// Returns a string representation of the location in the format "(x, y)".
+  [[nodiscard]] auto toString() const -> std::string {
+    std::stringstream ss;
+    ss << std::setprecision(3) << std::fixed;
+    ss << "(" << x << ", " << y << ")";
+    return ss.str();
+  }
+
+  /// Prints the location to the given output stream.
+  /// @param os The output stream to print the location to.
+  /// @param obj The location to print.
+  /// @return The output stream after printing the location.
+  friend auto operator<<(std::ostream& os, const Location& obj)
+      -> std::ostream& {
+    return os << obj.toString();
+  }
+
+  /// Compares two locations for equality.
+  /// @param other The location to compare with.
+  /// @return True if the locations are equal, false otherwise.
+  [[nodiscard]] auto operator==(const Location& other) const -> bool {
+    return x == other.x && y == other.y;
+  }
+
+  /// Compares two locations for inequality.
+  /// @param other The location to compare with.
+  /// @return True if the locations are not equal, false otherwise.
+  [[nodiscard]] auto operator!=(const Location& other) const -> bool {
+    return !(*this == other);
+  }
+
+  /// Compares two locations for less than.
+  /// @param other The location to compare with.
+  /// @return True if this location is less than the other location, false
+  [[nodiscard]] auto operator<(const Location& other) const -> bool {
+    return x < other.x || (x == other.x && y < other.y);
+  }
+
+  /// Compares two locations for greater than.
+  /// @param other The location to compare with.
+  /// @return True if this location is greater than the other location, false
+  [[nodiscard]] auto operator>(const Location& other) const -> bool {
+    return other < *this;
+  }
+
+  /// Compares two locations for greater than or equal.
+  /// @param other The location to compare with.
+  /// @return True if this location is greater than or equal to the other
+  [[nodiscard]] auto operator>=(const Location& other) const -> bool {
+    return !(other < *this);
+  }
+
+  /// Compares two locations for less than or equal.
+  /// @param other The location to compare with.
+  /// @return True if this location is less than or equal to the other location,
+  [[nodiscard]] auto operator<=(const Location& other) const -> bool {
+    return *this >= other;
+  }
+
+  /// Computes the Euclidean distance between this location and the given
+  /// location.
+  /// @param loc The location to compute the distance to.
+  /// @return The Euclidean distance between the two locations.
+  [[nodiscard]] auto getEuclideanDistance(const Location& loc) const -> double {
+    return (*this - loc).length();
+  }
+
+  /// Computes the horizontal distance between this location and the given
+  /// location.
+  /// @param loc The location to compute the distance to.
+  /// @return The horizontal distance between the two locations.
+  [[nodiscard]] auto getManhattanDistanceX(const Location& loc) const
+      -> double {
+    return std::abs(x - loc.x);
+  }
+
+  /// Computes the vertical distance between this location and the given
+  /// location.
+  /// @param loc The location to compute the distance to.
+  /// @return The vertical distance between the two locations.
+  [[nodiscard]] auto getManhattanDistanceY(const Location& loc) const
+      -> double {
+    return std::abs(y - loc.y);
+  }
+};
+} // namespace na
+
+/// @brief Specialization of std::hash for na::Location.
+template <> struct std::hash<na::Location> {
+  /// @brief Hashes a pair of qc::OpType and size_t values.
+  auto operator()(const na::Location& loc) const noexcept -> size_t {
+    const size_t h1 = std::hash<double>{}(loc.x);
+    const size_t h2 = std::hash<double>{}(loc.y);
+    return qc::combineHash(h1, h2);
+  }
+};

mqt/core/include/mqt-core/na/entities/Zone.hpp

@@ -0,0 +1,95 @@
+/*
+ * 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 type for representing zones in NA architectures.
+ */
+
+#pragma once
+
+#include <optional>
+#include <ostream>
+#include <string>
+#include <utility>
+
+namespace na {
+
+struct Location;
+
+/// Represents a zone in the NAComputation.
+/// @details The name of the zone is used for printing the NAComputation.
+/// To maintain the uniqueness of zones, the name of the zone should be unique
+/// for this zone.
+class Zone final {
+public:
+  /// A simple struct to represent the extent of a zone.
+  struct Extent {
+    double minX = 0.0;
+    double minY = 0.0;
+    double maxX = 0.0;
+    double maxY = 0.0;
+  };
+
+private:
+  /// The identifier of the zone.
+  std::string name_;
+  /// The extent of the zone.
+  std::optional<Extent> extent_;
+
+public:
+  /// Creates a new zone with the given name.
+  /// @param name The name of the zone.
+  explicit Zone(std::string name) : name_(std::move(name)) {}
+
+  /// Creates a new zone with the given name.
+  /// @param name The name of the zone.
+  /// @param extent The extent of the zone.
+  Zone(std::string name, const Extent& extent)
+      : name_(std::move(name)), extent_(extent) {}
+
+  /// Returns the name of the zone.
+  [[nodiscard]] auto getName() const -> std::string { return name_; }
+
+  /// Returns the extent of the zone.
+  [[nodiscard]] const std::optional<Extent>& getExtent() const {
+    return extent_;
+  }
+
+  /// Sets the extent of the zone.
+  void setExtent(const Extent& extent) { extent_ = extent; }
+
+  [[nodiscard]] auto contains(const Location& location) const -> bool;
+
+  /// Prints the zone to the given output stream.
+  /// @param os The output stream to print the zone to.
+  /// @param obj The zone to print.
+  /// @return The output stream after printing the zone.
+  friend auto operator<<(std::ostream& os, const Zone& obj) -> std::ostream& {
+    return os << obj.getName();
+  }
+
+  /// Compares two zones for equality.
+  /// @param other The zone to compare with.
+  /// @return True if the zones are equal, false otherwise.
+  [[nodiscard]] auto operator==(const Zone& other) const -> bool {
+    if (this == &other) {
+      return true;
+    }
+    return name_ == other.name_;
+  }
+
+  /// Compares two zones for inequality.
+  /// @param other The zone to compare with.
+  /// @return True if the zones are not equal, false otherwise.
+  [[nodiscard]] auto operator!=(const Zone& other) const -> bool {
+    return !(*this == other);
+  }
+};
+} // namespace na

mqt/core/include/mqt-core/na/mqt_core_na_export.h

@@ -0,0 +1,43 @@
+
+#ifndef MQT_CORE_NA_EXPORT_H
+#define MQT_CORE_NA_EXPORT_H
+
+#ifdef MQT_CORE_NA_STATIC_DEFINE
+#  define MQT_CORE_NA_EXPORT
+#  define MQT_CORE_NA_NO_EXPORT
+#else
+#  ifndef MQT_CORE_NA_EXPORT
+#    ifdef mqt_core_na_EXPORTS
+        /* We are building this library */
+#      define MQT_CORE_NA_EXPORT __declspec(dllexport)
+#    else
+        /* We are using this library */
+#      define MQT_CORE_NA_EXPORT __declspec(dllimport)
+#    endif
+#  endif
+
+#  ifndef MQT_CORE_NA_NO_EXPORT
+#    define MQT_CORE_NA_NO_EXPORT 
+#  endif
+#endif
+
+#ifndef MQT_CORE_NA_DEPRECATED
+#  define MQT_CORE_NA_DEPRECATED __declspec(deprecated)
+#endif
+
+#ifndef MQT_CORE_NA_DEPRECATED_EXPORT
+#  define MQT_CORE_NA_DEPRECATED_EXPORT MQT_CORE_NA_EXPORT MQT_CORE_NA_DEPRECATED
+#endif
+
+#ifndef MQT_CORE_NA_DEPRECATED_NO_EXPORT
+#  define MQT_CORE_NA_DEPRECATED_NO_EXPORT MQT_CORE_NA_NO_EXPORT MQT_CORE_NA_DEPRECATED
+#endif
+
+/* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef MQT_CORE_NA_NO_DEPRECATED
+#    define MQT_CORE_NA_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* MQT_CORE_NA_EXPORT_H */