🎨 pre-commit fixes

include/Architecture.hpp

@@ -399,7 +399,7 @@ class Architecture {
 
   /** true if the coupling map contains no unidirectional edges */
   [[nodiscard]] bool bidirectional() const { return isBidirectional; }
-  
+
   /** true if the coupling map contains no bidirectional edges */
   [[nodiscard]] bool unidirectional() const { return isUnidirectional; }
 

include/heuristic/HeuristicMapper.hpp

@@ -144,7 +144,7 @@ class HeuristicMapper : public Mapper {
   bool                        principallyAdmissibleHeur = true;
   bool                        tightHeur                 = true;
   bool                        fidelityAwareHeur         = false;
-  
+
   /**
    * @brief check the `results.config` for any invalid settings
    */
@@ -486,4 +486,4 @@ inline bool operator>(const HeuristicMapper::Node& x,
   }
 
   return x < y;
-}
+}

include/utils.hpp

@@ -89,18 +89,18 @@ class Dijkstra {
    * if k > distanceTables.size() a cost of 0 can be assumed
    *
    * @param couplingMap coupling map specifying all edges in the architecture
-   * @param distanceTables vector to fill with target tables (from 0 skips in 
-   * the first entry to k skips in the last entry, where k is the last index 
-   * not containing a matrix of pure 0s i.e. k+1 = diameter of the coupling 
+   * @param distanceTables vector to fill with target tables (from 0 skips in
+   * the first entry to k skips in the last entry, where k is the last index
+   * not containing a matrix of pure 0s i.e. k+1 = diameter of the coupling
    * graph)
    * @param edgeWeights matrix containing costs for swapping any two, connected
    * qubits (this might be uniform for all edges or different for each edge, as
    * e.g. in the case of fidelity-aware distances or distances on
    * mixed bi/unidirectional architectures)
    */
-  static void buildEdgeSkipTable(const CouplingMap& couplingMap, 
+  static void buildEdgeSkipTable(const CouplingMap&   couplingMap,
                                  std::vector<Matrix>& distanceTables,
-                                 const Matrix& edgeWeights);
+                                 const Matrix&        edgeWeights);
   /**
    * @brief builds a distance table containing the minimal costs for moving
    * logical qubits from one physical qubit to another (along the cheapest path)

src/Architecture.cpp

@@ -276,7 +276,8 @@ void Architecture::createFidelityTable() {
 
   fidelityDistanceTables.clear();
   if (fidelityAvailable) {
-    Dijkstra::buildEdgeSkipTable(couplingMap, fidelityDistanceTables, swapFidelityCosts);
+    Dijkstra::buildEdgeSkipTable(couplingMap, fidelityDistanceTables,
+                                 swapFidelityCosts);
   }
 }
 

src/configuration/Configuration.cpp

@@ -19,19 +19,22 @@ nlohmann::json Configuration::json() const {
   config["debug"]                              = debug;
 
   if (method == Method::Heuristic) {
-    auto& heuristicJson             = config["settings"];
-    heuristicJson["heuristic"]      = ::toString(heuristic);
-    auto& heuristicPropertiesJson   = heuristicJson["heuristic_properties"];
+    auto& heuristicJson           = config["settings"];
+    heuristicJson["heuristic"]    = ::toString(heuristic);
+    auto& heuristicPropertiesJson = heuristicJson["heuristic_properties"];
     heuristicPropertiesJson["admissible"] = isAdmissible(heuristic);
-    heuristicPropertiesJson["principally_admissible"] = isPrincipallyAdmissible(heuristic);
-    heuristicPropertiesJson["tight"] = isTight(heuristic);
+    heuristicPropertiesJson["principally_admissible"] =
+        isPrincipallyAdmissible(heuristic);
+    heuristicPropertiesJson["tight"]          = isTight(heuristic);
     heuristicPropertiesJson["fidelity_aware"] = isFidelityAware(heuristic);
-    heuristicJson["initial_layout"] = ::toString(initialLayout);
+    heuristicJson["initial_layout"]           = ::toString(initialLayout);
     if (lookaheadHeuristic != LookaheadHeuristic::None) {
-      auto& lookaheadSettings           = heuristicJson["lookahead"];
-      lookaheadSettings["heuristic"]    = ::toString(lookaheadHeuristic);
-      auto& lookaheadHeuristicPropertiesJson = lookaheadSettings["heuristic_properties"];
-      heuristicPropertiesJson["fidelity_aware"] = isFidelityAware(lookaheadHeuristic);
+      auto& lookaheadSettings        = heuristicJson["lookahead"];
+      lookaheadSettings["heuristic"] = ::toString(lookaheadHeuristic);
+      auto& lookaheadHeuristicPropertiesJson =
+          lookaheadSettings["heuristic_properties"];
+      heuristicPropertiesJson["fidelity_aware"] =
+          isFidelityAware(lookaheadHeuristic);
       lookaheadSettings["lookaheads"]   = nrLookaheads;
       lookaheadSettings["first_factor"] = firstLookaheadFactor;
       lookaheadSettings["factor"]       = lookaheadFactor;

src/heuristic/HeuristicMapper.cpp

@@ -865,7 +865,7 @@ void HeuristicMapper::recalculateFixedCostNonFidelity(Node& node) {
   // swap costs
   for (auto& swap : node.swaps) {
     if (swap.op == qc::SWAP) {
-      // branch clone intended for performance reasons (checking edge-wise for 
+      // branch clone intended for performance reasons (checking edge-wise for
       // bidirectionality is not O(1))
       // NOLINTBEGIN(bugprone-branch-clone)
       if (architecture->bidirectional()) {
@@ -1023,7 +1023,7 @@ void HeuristicMapper::applySWAP(const Edge& swap, std::size_t layer,
     node.costFixed +=
         architecture->getSwapFidelityCost(swap.first, swap.second);
   } else {
-    // branch clone intended for performance reasons (checking edge-wise for 
+    // branch clone intended for performance reasons (checking edge-wise for
     // bidirectionality is not O(1))
     // NOLINTBEGIN(bugprone-branch-clone)
     if (architecture->bidirectional()) {

src/utils.cpp

@@ -72,9 +72,9 @@ void Dijkstra::dijkstra(const CouplingMap& couplingMap,
   }
 }
 
-void Dijkstra::buildEdgeSkipTable(const CouplingMap& couplingMap, 
+void Dijkstra::buildEdgeSkipTable(const CouplingMap&   couplingMap,
                                   std::vector<Matrix>& distanceTables,
-                                  const Matrix& edgeWeights) {
+                                  const Matrix&        edgeWeights) {
   /* to find the cheapest distance between 2 qubits skipping any 1 edge, we
   iterate over all edges, for each assume the current edge to be the one skipped
   and are thereby able to retrieve the distance by just adding the distances