Move getIndicesAfterExclusion

pennylane_lightning/src/Apply.cpp

@@ -11,29 +11,16 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#include <set>
-
 #include "Apply.hpp"
 #include "Gates.hpp"
 #include "StateVector.hpp"
 #include "Util.hpp"
+#include "Util.cpp"
 
-using std::set;
 using std::string;
 using std::unique_ptr;
 using std::vector;
 
-vector<unsigned int> Pennylane::getIndicesAfterExclusion(const vector<unsigned int>& indicesToExclude, const unsigned int qubits) {
-    set<unsigned int> indices;
-    for (unsigned int i = 0; i < qubits; i++) {
-        indices.insert(indices.end(), i);
-    }
-    for (const unsigned int& excludedIndex : indicesToExclude) {
-        indices.erase(excludedIndex);
-    }
-    return vector<unsigned int>(indices.begin(), indices.end());
-}
-
 vector<size_t> Pennylane::generateBitPatterns(const vector<unsigned int>& qubitIndices, const unsigned int qubits) {
     vector<size_t> indices;
     indices.reserve(exp2(qubitIndices.size()));
@@ -63,7 +50,7 @@ void Pennylane::constructAndApplyOperation(
 
     vector<size_t> internalIndices = generateBitPatterns(opWires, qubits);
 
-    vector<unsigned int> externalWires = getIndicesAfterExclusion(opWires, qubits);
+    vector<unsigned int> externalWires = Pennylane::getIndicesAfterExclusion(opWires, qubits);
     vector<size_t> externalIndices = generateBitPatterns(externalWires, qubits);
 
     vector<CplxType> inputVector(internalIndices.size());

pennylane_lightning/src/Apply.hpp

@@ -33,15 +33,6 @@
 
 namespace Pennylane {
 
-    /**
-     * Produces the list of qubit indices that excludes a given set of indices.
-     * 
-     * @param excludedIndices indices to exclude (must be in the range [0, qubits-1])
-     * @param qubits number of qubits
-     * @return Set difference of [0, ..., qubits-1] and excludedIndices, in ascending order
-     */
-    std::vector<unsigned int> getIndicesAfterExclusion(const std::vector<unsigned int>& indicesToExclude, const unsigned int qubits);
-
     /**
      * Produces the decimal values for all possible bit patterns determined by a set of indices, taking other indices to be fixed at 0.
      * The qubit indices are taken to be big-endian, i.e. qubit 0 is the most significant bit.

pennylane_lightning/src/Util.cpp

@@ -0,0 +1,30 @@
+// Copyright 2021 Xanadu Quantum Technologies Inc.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include <set>
+
+#include "Util.hpp"
+
+using std::set;
+using std::vector;
+
+vector<unsigned int> Pennylane::getIndicesAfterExclusion(const vector<unsigned int>& indicesToExclude, const unsigned int qubits) {
+    set<unsigned int> indices;
+    for (unsigned int i = 0; i < qubits; i++) {
+        indices.insert(indices.end(), i);
+    }
+    for (const unsigned int& excludedIndex : indicesToExclude) {
+        indices.erase(excludedIndex);
+    }
+    return vector<unsigned int>(indices.begin(), indices.end());
+}

pennylane_lightning/src/Util.hpp

@@ -21,6 +21,15 @@
 
 namespace Pennylane {
 
+    /**
+     * Produces the list of qubit indices that excludes a given set of indices.
+     *
+     * @param excludedIndices indices to exclude (must be in the range [0, qubits-1])
+     * @param qubits number of qubits
+     * @return Set difference of [0, ..., qubits-1] and excludedIndices, in ascending order
+     */
+    std::vector<unsigned int> getIndicesAfterExclusion(const std::vector<unsigned int>& indicesToExclude, const unsigned int qubits);
+
     /**
      * Calculates 2^n for some integer n > 0 using bitshifts.
      *