🎨 pre-commit fixes

Author: pre-commit-ci[bot]

include/na/NAGraphAlgorithms.hpp

@@ -152,7 +152,8 @@ class NAGraphAlgorithms {
    * @return A tuple of vectors containing the moveable vertices, the fixed
    * vertices mapped to their relative x-position in every time step.
    */
-  [[nodiscard]] static auto computeSequence(const InteractionGraph& g, std::size_t maxSites)
+  [[nodiscard]] static auto computeSequence(const InteractionGraph& g,
+                                            std::size_t             maxSites)
       -> std::pair<std::vector<std::unordered_map<qc::Qubit, std::int64_t>>,
                    std::unordered_map<qc::Qubit, std::int64_t>>;
 };

src/na/NAGraphAlgorithms.cpp

@@ -184,17 +184,20 @@ auto NAGraphAlgorithms::colorEdges(
     std::copy_if(edges.cbegin(), edges.cend(),
                  std::back_inserter(adjacentEdges),
                  [&](const Edge& e) { return e.first == v or e.second == v; });
-    std::sort(adjacentEdges.begin(), adjacentEdges.end(), [&](const Edge& a, const Edge& b) {
+    std::sort(adjacentEdges.begin(), adjacentEdges.end(),
+              [&](const Edge& a, const Edge& b) {
                 const auto u = a.first == v ? a.second : a.first;
                 const auto w = b.first == v ? b.second : b.first;
-                return u != w && (partialOrder.isReachable(u, w) ||
-                       (!partialOrder.isReachable(w, u) &&
-                        (nAdjColors[a] > nAdjColors[b] ||
-                         (nAdjColors[a] == nAdjColors[b] &&
-                          (edgeDegree[a] > edgeDegree[b] ||
-                          (edgeDegree[a] == edgeDegree[b] && u < w))))));
-                          // the last line together with the first clause (u != w) is necessary for a
-                          // well-defined compare function to handle edges that compare equally correctly
+                return u != w &&
+                       (partialOrder.isReachable(u, w) ||
+                        (!partialOrder.isReachable(w, u) &&
+                         (nAdjColors[a] > nAdjColors[b] ||
+                          (nAdjColors[a] == nAdjColors[b] &&
+                           (edgeDegree[a] > edgeDegree[b] ||
+                            (edgeDegree[a] == edgeDegree[b] && u < w))))));
+                // the last line together with the first clause (u != w) is
+                // necessary for a well-defined compare function to handle edges
+                // that compare equally correctly
               });
     for (const auto& e : adjacentEdges) {
       // color the edge
@@ -429,7 +432,8 @@ auto NAGraphAlgorithms::groupByConnectedComponent(
   return result;
 }
 
-auto NAGraphAlgorithms::computeSequence(const InteractionGraph& g, const std::size_t maxSites)
+auto NAGraphAlgorithms::computeSequence(const InteractionGraph& g,
+                                        const std::size_t       maxSites)
     -> std::pair<std::vector<std::unordered_map<qc::Qubit, std::int64_t>>,
                  std::unordered_map<qc::Qubit, std::int64_t>> {
   const auto& maxIndepSet = getMaxIndependentSet(g);
@@ -439,13 +443,14 @@ auto NAGraphAlgorithms::computeSequence(const InteractionGraph& g, const std::si
             [&](const auto& u, const auto& v) {
               return g.getDegree(u) > g.getDegree(v);
             });
-  auto sequence = groupByConnectedComponent(g, sequenceUngrouped);
+  auto        sequence = groupByConnectedComponent(g, sequenceUngrouped);
   const auto& colorEdgesResult =
       colorEdges(g, coveredEdges(g, maxIndepSet), sequence);
-  std::unordered_map<Edge, Color, qc::PairHash<qc::Qubit, qc::Qubit>> coloring = colorEdgesResult.first;
+  std::unordered_map<Edge, Color, qc::PairHash<qc::Qubit, qc::Qubit>> coloring =
+      colorEdgesResult.first;
   auto partialOrder = colorEdgesResult.second;
-  auto fixed   = partialOrder.orderTopologically();
-  auto resting = computeRestingPositions(sequence, fixed, coloring);
+  auto fixed        = partialOrder.orderTopologically();
+  auto resting      = computeRestingPositions(sequence, fixed, coloring);
   // compute relative x positions of fixed vertices
   std::unordered_map<qc::Qubit, std::int64_t> fixedPositions{};
   for (std::uint32_t x = 0, i = 0; x < fixed.size(); ++x) {
@@ -455,26 +460,46 @@ auto NAGraphAlgorithms::computeSequence(const InteractionGraph& g, const std::si
     }
   }
 
-  const auto maxSiteUsed = std::max_element(fixedPositions.cbegin(), fixedPositions.cend(), [](const auto& a, const auto& b){ return a.second < b.second; })->second;
+  const auto maxSiteUsed =
+      std::max_element(
+          fixedPositions.cbegin(), fixedPositions.cend(),
+          [](const auto& a, const auto& b) { return a.second < b.second; })
+          ->second;
   const auto maxSitesSigned = static_cast<std::int64_t>(maxSites);
   if (maxSiteUsed >= maxSitesSigned) {
-    // Handle the situation when the entangling zone is not big enough to fit all fixed qubits
-    for (auto it = fixedPositions.begin(); it != fixedPositions.end(); ) {
+    // Handle the situation when the entangling zone is not big enough to fit
+    // all fixed qubits
+    for (auto it = fixedPositions.begin(); it != fixedPositions.end();) {
       if (it->second >= maxSitesSigned) {
         it = fixedPositions.erase(it); // erase returns the next iterator
       } else {
         ++it; // move to the next element
       }
     }
-    fixed.erase(std::remove_if(fixed.begin(), fixed.end(), [&fixedPositions](const auto& q){ return fixedPositions.find(q) == fixedPositions.end(); }), fixed.end());
-    for (auto it = coloring.begin(); it != coloring.end(); ) {
-      if (fixedPositions.find(it->first.first) == fixedPositions.end() && fixedPositions.find(it->first.second) == fixedPositions.end()) {
+    fixed.erase(std::remove_if(fixed.begin(), fixed.end(),
+                               [&fixedPositions](const auto& q) {
+                                 return fixedPositions.find(q) ==
+                                        fixedPositions.end();
+                               }),
+                fixed.end());
+    for (auto it = coloring.begin(); it != coloring.end();) {
+      if (fixedPositions.find(it->first.first) == fixedPositions.end() &&
+          fixedPositions.find(it->first.second) == fixedPositions.end()) {
         it = coloring.erase(it); // erase returns the next iterator
       } else {
         ++it; // move to the next element
       }
     }
-    sequence.erase(std::remove_if(sequence.begin(), sequence.end(), [&coloring](const auto& q){ return !std::any_of(coloring.cbegin(), coloring.cend(), [q](const auto& elem){ return elem.first.first == q || elem.first.second == q; }); }), sequence.end());
+    sequence.erase(std::remove_if(sequence.begin(), sequence.end(),
+                                  [&coloring](const auto& q) {
+                                    return !std::any_of(
+                                        coloring.cbegin(), coloring.cend(),
+                                        [q](const auto& elem) {
+                                          return elem.first.first == q ||
+                                                 elem.first.second == q;
+                                        });
+                                  }),
+                   sequence.end());
     // recalculate resting positions
     resting = computeRestingPositions(sequence, fixed, coloring);
   }

src/na/NAMapper.cpp

@@ -971,8 +971,9 @@ auto NAMapper::map(const qc::QuantumComputation& qc) -> void {
       }
       const Zone interactionZone =
           *arch.getPropertiesOfOperation({qc::OpType::Z, 1}).zones.begin();
-      const auto sites = arch.getSitesInRow(interactionZone, 0);
-      const auto& sequence = NAGraphAlgorithms::computeSequence(graph, sites.size());
+      const auto  sites = arch.getSitesInRow(interactionZone, 0);
+      const auto& sequence =
+          NAGraphAlgorithms::computeSequence(graph, sites.size());
       const auto& moveable = sequence.first;
       const auto& fixed    = sequence.second;
       // 3. move the atoms accordingly and execute the gates