🚑 fix all newly broken pieces

Signed-off-by: Lukas Burgholzer <lukas.burgholzer@jku.at>

Author: burgholzer

include/Mapper.hpp

@@ -184,9 +184,9 @@ class Mapper {
     std::transform(extension.begin(), extension.end(), extension.begin(),
                    [](unsigned char c) { return ::tolower(c); });
     if (extension == "real") {
-      dumpResult(outputFilename, qc::Real);
+      dumpResult(outputFilename, qc::Format::Real);
     } else if (extension == "qasm") {
-      dumpResult(outputFilename, qc::OpenQASM);
+      dumpResult(outputFilename, qc::Format::OpenQASM);
     } else {
       throw QMAPException("[dump] Extension " + extension +
                           " not recognized/supported for dumping.");

include/cliffordsynthesis/CliffordSynthesizer.hpp

@@ -44,7 +44,7 @@ class CliffordSynthesizer {
     std::stringstream ss;
     ss << results.getResultCircuit();
     resultCircuit = std::make_unique<qc::QuantumComputation>();
-    resultCircuit->import(ss, qc::OpenQASM);
+    resultCircuit->import(ss, qc::Format::OpenQASM);
     return *resultCircuit;
   };
   [[nodiscard]] Tableau& getResultTableau() {

mqt/qmap/bindings.cpp

@@ -42,7 +42,8 @@ MappingResults map(const py::object& circ, Architecture& arch,
 
   if (config.useTeleportation) {
     config.teleportationQubits =
-        std::min((arch.getNqubits() - qc.getNqubits()) & ~1, 8);
+        std::min((arch.getNqubits() - qc.getNqubits()) & ~1,
+                 static_cast<std::size_t>(8));
   }
 
   std::unique_ptr<Mapper> mapper;
@@ -69,7 +70,7 @@ MappingResults map(const py::object& circ, Architecture& arch,
   auto& results = mapper->getResults();
 
   std::stringstream qasm{};
-  mapper->dumpResult(qasm, qc::OpenQASM);
+  mapper->dumpResult(qasm, qc::Format::OpenQASM);
   results.mappedCircuit = qasm.str();
 
   return results;

src/Mapper.cpp

@@ -149,31 +149,29 @@ void Mapper::finalizeMappedCircuit() {
   // circuit
   if (architecture.getNqubits() > qcMapped.getNqubits()) {
     for (auto logicalQubit = qcMapped.getNqubits();
-         logicalQubit < static_cast<dd::QubitCount>(architecture.getNqubits());
-         ++logicalQubit) {
-      dd::Qubit physicalQubit = -1;
+         logicalQubit < architecture.getNqubits(); ++logicalQubit) {
+      std::optional<qc::Qubit> physicalQubit = std::nullopt;
 
       // check if the corresponding physical qubit is already in use
-      if (qcMapped.initialLayout.find(static_cast<dd::Qubit>(logicalQubit)) !=
+      if (qcMapped.initialLayout.find(static_cast<qc::Qubit>(logicalQubit)) !=
           qcMapped.initialLayout.end()) {
         // get the next unused physical qubit
-        for (physicalQubit = 0;
-             physicalQubit < static_cast<dd::Qubit>(architecture.getNqubits());
-             ++physicalQubit) {
-          if (qcMapped.initialLayout.find(physicalQubit) ==
+        for (physicalQubit = 0; *physicalQubit < architecture.getNqubits();
+             ++(*physicalQubit)) {
+          if (qcMapped.initialLayout.find(*physicalQubit) ==
               qcMapped.initialLayout.end()) {
             break;
           }
         }
       } else {
-        physicalQubit = static_cast<dd::Qubit>(logicalQubit);
+        physicalQubit = static_cast<qc::Qubit>(logicalQubit);
       }
 
-      assert(physicalQubit != -1);
+      assert(physicalQubit.has_value());
 
       // the added logical qubits are not used in the circuit itself, so they
       // are regarded garbage
-      qcMapped.addAncillaryQubit(physicalQubit, -1);
+      qcMapped.addAncillaryQubit(*physicalQubit, std::nullopt);
     }
   }
   // unify quantum registers
@@ -187,31 +185,30 @@ void Mapper::finalizeMappedCircuit() {
 
 void Mapper::placeRemainingArchitectureQubits() {
   if (qc.getNqubits() < architecture.getNqubits()) {
-    for (auto logical = qc.getNqubits();
-         logical < static_cast<decltype(logical)>(architecture.getNqubits());
+    for (auto logical = qc.getNqubits(); logical < architecture.getNqubits();
          ++logical) {
-      dd::Qubit physical = -1;
+      std::optional<qc::Qubit> physical = std::nullopt;
 
       // check if the corresponding physical qubit is already in use
-      if (qcMapped.initialLayout.find(static_cast<dd::Qubit>(logical)) !=
+      if (qcMapped.initialLayout.find(static_cast<qc::Qubit>(logical)) !=
           qcMapped.initialLayout.end()) {
         // get the next unused physical qubit
-        for (physical = 0;
-             physical < static_cast<dd::Qubit>(architecture.getNqubits());
-             ++physical) {
-          if (qcMapped.initialLayout.find(physical) ==
+        for (physical = 0; *physical < architecture.getNqubits();
+             ++(*physical)) {
+          if (qcMapped.initialLayout.find(*physical) ==
               qcMapped.initialLayout.end()) {
             break;
           }
         }
       } else {
-        physical = static_cast<dd::Qubit>(logical);
+        physical = static_cast<qc::Qubit>(logical);
       }
 
-      qubits.at(physical) = logical;
+      assert(physical.has_value());
+      qubits.at(*physical) = static_cast<short>(logical);
 
       // mark architecture qubit as ancillary and garbage
-      qcMapped.initialLayout[physical] = static_cast<dd::Qubit>(logical);
+      qcMapped.initialLayout[*physical] = static_cast<qc::Qubit>(logical);
       qcMapped.setLogicalQubitAncillary(logical);
       qcMapped.setLogicalQubitGarbage(logical);
     }

src/cliffordsynthesis/encoding/GateEncoder.cpp

@@ -129,7 +129,7 @@ void GateEncoder::extractTwoQubitGatesFromModel(const std::size_t       pos,
         continue;
       }
       const auto control =
-          dd::Control{static_cast<dd::Qubit>(ctrl), dd::Control::Type::pos};
+          qc::Control{static_cast<qc::Qubit>(ctrl), qc::Control::Type::Pos};
       if (model.getBoolValue(twoQubitGates[ctrl][trgt], lb.get())) {
         qc.emplace_back<qc::StandardOperation>(N, control, trgt, qc::OpType::X);
         ++nTwoQubitGates;

src/exact/ExactMapper.cpp

@@ -259,10 +259,10 @@ void ExactMapper::map(const Configuration& settings) {
       for (const auto& [physical, logical] : *swapsIterator) {
         locations.at(logical) = static_cast<short>(physical);
         qubits.at(physical)   = static_cast<short>(logical);
-        qcMapped.initialLayout[static_cast<dd::Qubit>(physical)] =
-            static_cast<dd::Qubit>(logical);
-        qcMapped.outputPermutation[static_cast<dd::Qubit>(physical)] =
-            static_cast<dd::Qubit>(logical);
+        qcMapped.initialLayout[static_cast<qc::Qubit>(physical)] =
+            static_cast<qc::Qubit>(logical);
+        qcMapped.outputPermutation[static_cast<qc::Qubit>(physical)] =
+            static_cast<qc::Qubit>(logical);
       }
 
       // place remaining architecture qubits
@@ -317,7 +317,7 @@ void ExactMapper::map(const Configuration& settings) {
           qcMapped.h(reverse.first);
           qcMapped.h(reverse.second);
           qcMapped.x(reverse.second,
-                     dd::Control{static_cast<dd::Qubit>(reverse.first)});
+                     qc::Control{static_cast<qc::Qubit>(reverse.first)});
           qcMapped.h(reverse.second);
           qcMapped.h(reverse.first);
         } else {
@@ -327,7 +327,7 @@ void ExactMapper::map(const Configuration& settings) {
                       << " " << cnot.second << std::endl;
           }
           qcMapped.x(cnot.second,
-                     dd::Control{static_cast<dd::Qubit>(cnot.first)});
+                     qc::Control{static_cast<qc::Qubit>(cnot.first)});
         }
       }
     }

src/heuristic/HeuristicMapper.cpp

@@ -58,9 +58,9 @@ void HeuristicMapper::map(const Configuration& ms) {
           } else if (swap.op == qc::Teleportation) {
             qcMapped.emplace_back<qc::StandardOperation>(
                 qcMapped.getNqubits(),
-                qc::Targets{static_cast<dd::Qubit>(swap.first),
-                            static_cast<dd::Qubit>(swap.second),
-                            static_cast<dd::Qubit>(swap.middle_ancilla)},
+                qc::Targets{static_cast<qc::Qubit>(swap.first),
+                            static_cast<qc::Qubit>(swap.second),
+                            static_cast<qc::Qubit>(swap.middle_ancilla)},
                 qc::Teleportation);
             results.output.teleportations++;
           }
@@ -107,15 +107,15 @@ void HeuristicMapper::map(const Configuration& ms) {
           qcMapped.h(reverse.first);
           qcMapped.h(reverse.second);
           qcMapped.x(reverse.second,
-                     dd::Control{static_cast<dd::Qubit>(reverse.first)});
+                     qc::Control{static_cast<qc::Qubit>(reverse.first)});
           qcMapped.h(reverse.second);
           qcMapped.h(reverse.first);
 
           results.output.directionReverse++;
           gateidx += 5;
         } else {
           qcMapped.x(cnot.second,
-                     dd::Control{static_cast<dd::Qubit>(cnot.first)});
+                     qc::Control{static_cast<qc::Qubit>(cnot.first)});
           gateidx++;
         }
       }
@@ -127,8 +127,8 @@ void HeuristicMapper::map(const Configuration& ms) {
   std::size_t count = 0U;
   for (std::size_t i = 0U; i < architecture.getNqubits(); ++i) {
     if (qubits[i] != -1) {
-      qcMapped.outputPermutation[static_cast<dd::Qubit>(i)] =
-          static_cast<dd::Qubit>(qubits[i]);
+      qcMapped.outputPermutation[static_cast<qc::Qubit>(i)] =
+          static_cast<qc::Qubit>(qubits[i]);
     } else {
       qcMapped.setLogicalQubitGarbage(qc.getNqubits() + count);
       ++count;
@@ -171,10 +171,10 @@ void HeuristicMapper::map(const Configuration& ms) {
             ++loc;
           }
           locations.at(target) = loc;
-          op->setTargets({static_cast<dd::Qubit>(loc)});
+          op->setTargets({static_cast<qc::Qubit>(loc)});
           qcMapped.initialLayout.at(target) = loc;
         } else {
-          op->setTargets({static_cast<dd::Qubit>(targetLocation)});
+          op->setTargets({static_cast<qc::Qubit>(targetLocation)});
         }
       }
     }

test/cliffordsynthesis/test_synthesis.cpp

@@ -66,7 +66,7 @@ class SynthesisTest : public ::testing::TestWithParam<TestConfiguration> {
     if (!test.initialCircuit.empty()) {
       std::stringstream      ss(test.initialCircuit);
       qc::QuantumComputation qc{};
-      qc.import(ss, qc::OpenQASM);
+      qc.import(ss, qc::Format::OpenQASM);
       std::cout << "Initial circuit:\n" << qc;
       targetTableau = Tableau(qc);
       if (test.initialTableau.empty()) {

test/test_architecture.cpp

@@ -11,8 +11,6 @@ class TestArchitecture : public testing::TestWithParam<std::string> {
 protected:
   std::string test_architecture_dir = "./architectures/";
   std::string test_calibration_dir  = "./calibration/";
-
-  void SetUp() override { using namespace dd::literals; }
 };
 
 INSTANTIATE_TEST_SUITE_P(Architecture, TestArchitecture,

test/test_encodings.cpp

@@ -37,7 +37,7 @@ INSTANTIATE_TEST_SUITE_P(
                     std::pair{Encoding::Bimander, CommanderGrouping::Fixed3}));
 
 TEST_P(TestEncodings, ThreeToSevenQubits) {
-  using namespace dd::literals;
+  using namespace qc::literals;
 
   qc = qc::QuantumComputation(3U);
   qc.x(2, 1_pc);
@@ -59,7 +59,7 @@ TEST_P(TestEncodings, ThreeToSevenQubits) {
 }
 
 TEST_P(TestEncodings, FiveToSevenQubits) {
-  using namespace dd::literals;
+  using namespace qc::literals;
 
   qc = qc::QuantumComputation(5U);
   qc.x(1, 0_pc);