Commit b7f4ee2c authored by Mccaskey, Alex's avatar Mccaskey, Alex
Browse files

Adding trivial embedding algorithm, got dwave example running, minus results analysis

parent a036fb8d
......@@ -2,4 +2,4 @@ get_filename_component(SELF_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
set (XACC_ROOT "${SELF_DIR}")
set (XACC_INCLUDE_DIRS "${SELF_DIR}/include;${SELF_DIR}/include/xacc;${SELF_DIR}/include/quantum/gate;${SELF_DIR}/include/quantum/aqc")
set (XACC_LIBRARY_DIR "${SELF_DIR}/lib")
set (XACC_LIBRARIES "${SELF_DIR}/lib/libxacc-quantum-gate.so")
\ No newline at end of file
set (XACC_LIBRARIES "${SELF_DIR}/lib/libxacc-quantum-gate.so;${SELF_DIR}/lib/libxacc-quantum-aqc.so")
\ No newline at end of file
......@@ -49,7 +49,7 @@ if (OPENSSL_FOUND)
add_library(${LIBRARY_NAME} SHARED ${SRC})
target_link_libraries(${LIBRARY_NAME} ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES})
target_link_libraries(${LIBRARY_NAME} ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES} xacc-quantum-aqc)
install(TARGETS ${LIBRARY_NAME} DESTINATION lib)
......
......@@ -158,10 +158,64 @@ void DWAccelerator::execute(std::shared_ptr<AcceleratorBuffer> buffer,
std::cout << "COMPLETEDMESSAGE:\n" << message << "\n";
/**
* Looks like we now want document["answer"]["energies"].GetArray(),
* and document["answer"]["num_occurrences"].GetArray(), and
* document["answer"]["solutions"]. Then we have to decode
* solutions string
*/
}
void DWAccelerator::initialize() {
auto options = RuntimeOptions::instance();
searchAPIKey(apiKey, url);
auto tempURL = url;
boost::replace_all(tempURL, "https://", "");
boost::replace_all(tempURL, "/sapi", "");
// Set up the extra HTTP headers we are going to need
headers.insert(std::make_pair("X-Auth-Token", apiKey));
headers.insert(std::make_pair("Content-type", "application/x-www-form-urlencoded"));
headers.insert(std::make_pair("Accept", "*/*"));
// Get the Remote URL Solver data...
auto getSolverClient = fire::util::AsioNetworkingTool<SimpleWeb::HTTPS>(tempURL, false);
auto r = getSolverClient.get("/sapi/solvers/remote", headers);
std::stringstream ss;
ss << r.content.rdbuf();
auto message = ss.str();
Document document;
document.Parse(message.c_str());
if (document.IsArray()) {
for (auto i = 0; i < document.Size(); i++) {
DWSolver solver;
solver.name = document[i]["id"].GetString();
boost::trim(solver.name);
solver.description = document[i]["description"].GetString();
if (document[i]["properties"].FindMember("j_range") != document[i]["properties"].MemberEnd()) {
solver.jRangeMin = document[i]["properties"]["j_range"][0].GetDouble();
solver.jRangeMax = document[i]["properties"]["j_range"][1].GetDouble();
solver.hRangeMin = document[i]["properties"]["h_range"][0].GetDouble();
solver.hRangeMax = document[i]["properties"]["h_range"][1].GetDouble();
}
solver.nQubits = document[i]["properties"]["num_qubits"].GetInt();
// Get the connectivity
auto couplers = document[i]["properties"]["couplers"].GetArray();
for (int j = 0; j < couplers.Size(); j++) {
solver.edges.push_back(std::make_pair(couplers[j][0].GetInt(), couplers[j][1].GetInt()));
}
availableSolvers.insert(std::make_pair(solver.name, solver));
}
}
}
void DWAccelerator::searchAPIKey(std::string& key, std::string& url) {
// Search for the API Key in $HOME/.dwave_config,
......@@ -224,5 +278,34 @@ void DWAccelerator::findApiKeyInFile(std::string& apiKey, std::string& url,
}
}
}
/**
* Return the graph structure for this Accelerator.
*
* @return connectivityGraph The graph structure of this Accelerator
*/
std::shared_ptr<AcceleratorGraph> DWAccelerator::getAcceleratorConnectivity() {
auto options = RuntimeOptions::instance();
std::string solverName = "DW_2000Q_VFYC";
if (options->exists("dwave-solver")) {
solverName = (*options)["dwave-solver"];
}
if (!availableSolvers.count(solverName)) {
XACCError(solverName + " is not available.");
}
auto solver = availableSolvers[solverName];
auto graph = std::make_shared<AcceleratorGraph>(solver.nQubits);
for (auto es : solver.edges) {
graph->addEdge(es.first, es.second);
}
return graph;
}
}
}
......@@ -59,6 +59,7 @@ struct DWSolver {
double hRangeMin;
double hRangeMax;
int nQubits;
std::vector<std::pair<int,int>> edges;
};
/**
......@@ -88,6 +89,13 @@ public:
*/
virtual bool isValidBufferSize(const int NBits);
/**
* Return the graph structure for this Accelerator.
*
* @return connectivityGraph The graph structure of this Accelerator
*/
virtual std::shared_ptr<AcceleratorGraph> getAcceleratorConnectivity();
/**
* Execute the kernel on the provided AcceleratorBuffer through a
* HTTP Post of Quil instructions to the Rigetti QPU at api.rigetti.com/qvm
......@@ -139,13 +147,13 @@ public:
static void registerAccelerator() {
DWAccelerator acc;
xacc::RegisterAccelerator<xacc::quantum::DWAccelerator> DWTEMP(
"d-wave", acc.getOptions());
"dwave", acc.getOptions());
}
DWAccelerator() {
}
virtual void initialize() {
virtual void initialize(); /* {
auto options = RuntimeOptions::instance();
searchAPIKey(apiKey, url);
auto tempURL = url;
......@@ -155,7 +163,7 @@ public:
// Set up the extra HTTP headers we are going to need
headers.insert(std::make_pair("X-Auth-Token", apiKey));
headers.insert(std::make_pair("Content-type", "application/x-www-form-urlencoded"));
headers.insert(std::make_pair("Accept", "*/*"));
headers.insert(std::make_pair("Accept", "**"));
// Get the Remote URL Solver data...
auto getSolverClient = fire::util::AsioNetworkingTool<SimpleWeb::HTTPS>(tempURL, false);
......@@ -165,6 +173,7 @@ public:
ss << r.content.rdbuf();
auto message = ss.str();
std::cout << "MESSAGE:\n" << message << "\n";
Document document;
document.Parse(message.c_str());
......@@ -182,11 +191,15 @@ public:
}
solver.nQubits = document[i]["properties"]["num_qubits"].GetInt();
// Get the connectivity
auto couplers = document[i]["properties"]["parameters"]["couplers"].GetArray();
std::cout << "HELLO WORLD: " << couplers.Size() << "\n";
std::cout << "INSERTING: " << solver.name << "\n";
availableSolvers.insert(std::make_pair(solver.name, solver));
}
}
}
}*/
virtual std::shared_ptr<AcceleratorBuffer> createBuffer(
const std::string& varId) {
......
......@@ -105,7 +105,6 @@ std::shared_ptr<IR> DWQMICompiler::compile(const std::string& src,
} else {
problemGraph->addEdge(qbit1, qbit2,
weightOrBias);
}
}
......
......@@ -80,8 +80,9 @@ public:
* Register this Compiler with the framework.
*/
static void registerCompiler() {
xacc::RegisterCompiler<xacc::quantum::DWQMICompiler> Scaffold(
"dwave-qmi");
DWQMICompiler c;
xacc::RegisterCompiler<xacc::quantum::DWQMICompiler> DWQMITEMP(
"dwave-qmi", c.getOptions());
}
virtual const std::string translate(const std::string& bufferVariable,
......
......@@ -53,13 +53,10 @@ int main (int argc, char** argv) {
// Initialize the XACC Framework
xacc::Initialize(argc, argv);
std::cout << "GETTING THE ACC\n";
auto qpu = xacc::getAccelerator("d-wave");
std::cout << "GOT THE ACC\n";
auto qpu = xacc::getAccelerator("dwave");
auto qubits = qpu->createBuffer("qbits");
std::cout << "CREATED THE BUFFER\n";
// Create a Program
xacc::Program program(qpu, src);
......
......@@ -84,8 +84,10 @@ BOOST_AUTO_TEST_CASE(checkKernelExecution) {
auto options = RuntimeOptions::instance();
// DWAccelerator acc;
// acc.initialize();
// auto buffer = acc.createBuffer("qubits", 1);
auto f = std::make_shared<DWKernel>("shor15");
auto f = std::make_shared<DWKernel>("simple");
f->addInstruction(std::make_shared<DWQMI>(0, 0, 20));
f->addInstruction(std::make_shared<DWQMI>(1, 1, 50));
......@@ -102,7 +104,7 @@ BOOST_AUTO_TEST_CASE(checkKernelExecution) {
f->addInstruction(std::make_shared<DWQMI>(1, 6, -128));
f->addInstruction(std::make_shared<DWQMI>(2, 6, -128));
// acc.execute(acc.createBuffer("qubits", 1), f);
// acc.execute(, f);
// BOOST_VERIFY(client->postOccured);
}
......
......@@ -144,8 +144,8 @@ public:
BOOST_AUTO_TEST_CASE(checkSimpleCompile) {
EmbeddingAlgorithmRegistry::instance()->add(FakeEmbedding().name(),
[]() {return std::make_shared<FakeEmbedding>();});
EmbeddingAlgorithmRegistry::instance()->add(FakeEmbedding().name(),std::make_shared<EmbeddingAlgorithmRegistry::CreatorFunction>(
[]() {return std::make_shared<FakeEmbedding>();}));
auto compiler = std::make_shared<DWQMICompiler>();
......@@ -185,7 +185,7 @@ BOOST_AUTO_TEST_CASE(checkSimpleCompile) {
BOOST_AUTO_TEST_CASE(checkShor15OneToOneMapping) {
EmbeddingAlgorithmRegistry::instance()->add(Shor15FakeEmbedding().name(),
[]() {return std::make_shared<Shor15FakeEmbedding>();});
std::make_shared<EmbeddingAlgorithmRegistry::CreatorFunction>([]() {return std::make_shared<Shor15FakeEmbedding>();}));
auto compiler = std::make_shared<DWQMICompiler>();
......
......@@ -37,14 +37,14 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ir)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/compiler)
file (GLOB_RECURSE HEADERS *.hpp)
file (GLOB SRC ir/*.cpp compiler/*.cpp)
file (GLOB SRC compiler/TrivialEmbeddingAlgorithm.cpp)
#add_library(${LIBRARY_NAME} SHARED ${SRC})
add_library(${LIBRARY_NAME} SHARED ${SRC})
#target_link_libraries(${LIBRARY_NAME} ${Boost_LIBRARIES})
target_link_libraries(${LIBRARY_NAME} ${Boost_LIBRARIES})
add_subdirectory(ir)
add_subdirectory(compiler)
install(FILES ${HEADERS} DESTINATION include/quantum/aqc)
#install(TARGETS ${LIBRARY_NAME} DESTINATION lib)
install(TARGETS ${LIBRARY_NAME} DESTINATION lib)
......@@ -28,19 +28,7 @@
# Initial API and implementation - Alex McCaskey
#
#**********************************************************************************/
set (PACKAGE_NAME "DWave Compiler XACC Runtime")
set (PACKAGE_DESCIPTION "DWave Compiler XACC Programming Framework")
set (LIBRARY_NAME xacc-dwavecompiler)
file (GLOB HEADERS *.hpp)
file (GLOB SRC *.cpp)
#add_library(${LIBRARY_NAME} SHARED ${SRC})
install(FILES ${HEADERS} DESTINATION include/quantum/aqc)
#install(TARGETS ${LIBRARY_NAME} DESTINATION lib)
# Gather tests
file (GLOB test_files tests/*.cpp)
#add_tests("${test_files}" "${CMAKE_CURRENT_SOURCE_DIR}" "${LIBRARY_NAME};${Boost_LIBRARIES};dl;pthread")
add_tests("${test_files}" "${CMAKE_CURRENT_SOURCE_DIR}" "${LIBRARY_NAME};${Boost_LIBRARIES};dl;pthread;xacc-quantum-aqc")
......@@ -105,13 +105,16 @@ template<typename T>
class RegisterEmbeddingAlgorithm {
public:
RegisterEmbeddingAlgorithm(const std::string& name) {
EmbeddingAlgorithmRegistry::instance()->add(name,
(std::function<std::shared_ptr<xacc::quantum::EmbeddingAlgorithm>()>) ([]() {
return std::make_shared<T>();
}));
EmbeddingAlgorithmRegistry::CreatorFunctionPtr f = std::make_shared<
EmbeddingAlgorithmRegistry::CreatorFunction>([]() {
return std::make_shared<T>();
});
EmbeddingAlgorithmRegistry::instance()->add(name, f);
}
};
#define RegisterEmbeddingAlgorithm(TYPE) BOOST_DLL_ALIAS(TYPE::registerEmbeddingAlgorithm, registerEmbeddingAlgorithm)
}
}
......
/***********************************************************************************
* Copyright (c) 2017, UT-Battelle
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the xacc nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Contributors:
* Initial API and implementation - Alex McCaskey
*
**********************************************************************************/
#include "TrivialEmbeddingAlgorithm.hpp"
namespace xacc {
namespace quantum {
std::map<int, std::list<int>> TrivialEmbeddingAlgorithm::embed(
std::shared_ptr<DWGraph> problem,
std::shared_ptr<xacc::AcceleratorGraph> hdware,
std::map<std::string, std::string> params) {
std::map<int, std::list<int>> xaccEmbedding;
bool failHard = true;
if (params.count("failhard")) {
failHard = params["failhard"] == "false" ? false : true;
}
for (int i = 0; i < problem->order(); i++) {
for (int j = 0; j < problem->order(); j++) {
if (i < j && i != j
&& (problem->edgeExists(i, j) && !hdware->edgeExists(i, j))) {
if (failHard) {
XACCError(
"Trivial Embedding not possible, there is no hardware edge corresponding to ("
+ std::to_string(i) + ", "
+ std::to_string(j) + ") problem edge.");
} else {
XACCInfo("This embedding failed, but user requested to not fail hard. Returning empty embedding.");
xaccEmbedding.clear();
return xaccEmbedding;
}
}
}
xaccEmbedding.insert(std::make_pair(i, std::list<int>{i}));
}
return xaccEmbedding;
}
xacc::quantum::RegisterEmbeddingAlgorithm<TrivialEmbeddingAlgorithm> TRIVEMB(
"trivial");
}
}
/***********************************************************************************
* Copyright (c) 2017, UT-Battelle
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the xacc nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Contributors:
* Initial API and implementation - Alex McCaskey
*
**********************************************************************************/
#ifndef QUANTUM_AQC_COMPILER_TRIVIALEMBEDDINGALGORITHM_HPP_
#define QUANTUM_AQC_COMPILER_TRIVIALEMBEDDINGALGORITHM_HPP_
#include "EmbeddingAlgorithm.hpp"
namespace xacc {
namespace quantum {
/**
* The EmbeddingAlgorithm class provides an interface
* for minor graph embedding algorithms.
*
*/
class TrivialEmbeddingAlgorithm : public EmbeddingAlgorithm {
public:
/**
* The Constructor
*/
TrivialEmbeddingAlgorithm() {}
/**
* The Destructor
*/
virtual ~TrivialEmbeddingAlgorithm() {}
/**
* Implementations of EmbeddingAlgorithm implement this method to
* provide a valid minor graph embedding of the given problem
* graph into the given hardware graph.
*
* @param problem The problem graph to be embedded into the hardware graph
* @param hardware The hardware graph.
* @param params Any key-value string parameters to influence the algorithm.
* @return embedding A mapping of problem vertex indices to the list of hardware vertices they map to
*/
virtual std::map<int, std::list<int>> embed(std::shared_ptr<DWGraph> problem,
std::shared_ptr<AcceleratorGraph> hardware,
std::map<std::string, std::string> params = std::map<std::string,
std::string>());
/**
* Return the name of this Embedding Algorithm
* @return
*/
virtual std::string name() {
return "trivial";
}
// static void registerEmbeddingAlgorithm() {
// xacc::quantum::RegisterEmbeddingAlgorithm<TrivialEmbeddingAlgorithm> TRIVEMB(
// "trivial");
// }
};
//RegisterEmbeddingAlgorithm(xacc::quantum::TrivialEmbeddingAlgorithm);
}
}
#endif
/***********************************************************************************
* Copyright (c) 2016, UT-Battelle
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the xacc nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Contributors:
* Initial API and implementation - Alex McCaskey
*
**********************************************************************************/
#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MODULE TrivialEmbeddingAlgorithm
#include <boost/test/included/unit_test.hpp>
#include "TrivialEmbeddingAlgorithm.hpp"
using namespace xacc::quantum;
BOOST_AUTO_TEST_CASE(checkSimpleEmbed) {
TrivialEmbeddingAlgorithm algo;
auto k44 = std::make_shared<K44Bipartite>();
// Set some params
std::map<std::string, std::string> params;
params.insert(std::make_pair("failhard", "false"));
auto triviallyMappedProblem = std::make_shared<DWGraph>(7);
triviallyMappedProblem->setVertexProperties(0, 20);
triviallyMappedProblem->setVertexProperties(1, 50);
triviallyMappedProblem->setVertexProperties(2, 60);
triviallyMappedProblem->setVertexProperties(4, 50);
triviallyMappedProblem->setVertexProperties(5, 60);
triviallyMappedProblem->setVertexProperties(6, -160);
triviallyMappedProblem->addEdge(2, 5);// -10000);
triviallyMappedProblem->setEdgeWeight(2,5, -10000);
triviallyMappedProblem->addEdge(1,4);
triviallyMappedProblem->setEdgeWeight(2,5, -1000);
triviallyMappedProblem->addEdge(0,4);
triviallyMappedProblem->setEdgeWeight(2,5, -14);
triviallyMappedProblem->addEdge(0,5);
triviallyMappedProblem->setEdgeWeight(2,5, -12);
triviallyMappedProblem->addEdge(0, 6);
triviallyMappedProblem->setEdgeWeight(2,5, 32);
triviallyMappedProblem->addEdge(1, 5);
triviallyMappedProblem->setEdgeWeight(2,5, 68);
triviallyMappedProblem->addEdge(1, 6);
triviallyMappedProblem->setEdgeWeight(2,5, -128);
triviallyMappedProblem->addEdge(2,6);
triviallyMappedProblem->setEdgeWeight(2,5, -128);
auto embedding = algo.embed(triviallyMappedProblem, k44->getAcceleratorGraph(), params);
int i = 0;
for (auto& kv : embedding) {
std::cout << kv.first << ": ";
for (auto h : kv.second) {
std::cout << h << " ";
BOOST_VERIFY(h == i);
}
std::cout << "\n";
BOOST_VERIFY(kv.first == i);
BOOST_VERIFY(kv.second.size() == 1);
i++;
}
auto complete5 = std::make_shared<CompleteGraph>(5);
embedding = algo.embed(complete5, k44->getAcceleratorGraph(), params);
BOOST_VERIFY(embedding.empty());
}
......@@ -28,19 +28,6 @@
# Initial API and implementation - Alex McCaskey
#
#**********************************************************************************/
#set (PACKAGE_NAME "Quantum XACC Gate Compiler Runtime")
#set (PACKAGE_DESCIPTION "Quantum XACC Gate Compiler Utilities")
#set (LIBRARY_NAME xacc-gate-compiler)