Continuing work on QIR

quantum/gate/CMakeLists.txt

@@ -29,10 +29,10 @@
 #
 #**********************************************************************************/
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/utils)
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/gateir)
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/gateir/instructions)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/gateqir)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/gateqir/instructions)
 
-add_subdirectory(gateir)
+add_subdirectory(gateqir)
 add_subdirectory(compilers)
 add_subdirectory(accelerators)
 add_subdirectory(utils)

quantum/gate/gateir/CMakeLists.txt → quantum/gate/gateqir/CMakeLists.txt

@@ -42,5 +42,5 @@ install(TARGETS ${LIBRARY_NAME} DESTINATION lib)
 
 # Gather tests
 file (GLOB test_files tests/*.cpp)
-add_tests("${test_files}" "${CMAKE_CURRENT_SOURCE_DIR};${CMAKE_CURRENT_SOURCE_DIR}/instructions" "${LIBRARY_NAME};${Boost_LIBRARIES};xacc-qir")
+add_tests("${test_files}" "${CMAKE_CURRENT_SOURCE_DIR};${CMAKE_CURRENT_SOURCE_DIR}/instructions" "${LIBRARY_NAME};${Boost_LIBRARIES}")
 

quantum/qir/QFunction.cpp → quantum/gate/gateqir/GateFunction.cpp

@@ -28,39 +28,59 @@
  *   Initial API and implementation - Alex McCaskey
  *
  **********************************************************************************/
-#include "QFunction.hpp"
+#include "GateFunction.hpp"
 
 namespace xacc {
 namespace quantum {
 
-QFunction::QFunction(int id, const std::string name) :
+GateFunction::GateFunction(int id, const std::string name) :
 		functionId(id), functionName(name) {
 
 }
 
-void QFunction::accept(QInstructionVisitor& visitor) {
+void GateFunction::accept(QInstructionVisitor& visitor) {
 	return;
 }
 
-void QFunction::addInstruction(InstPtr instruction) {
+void GateFunction::addInstruction(InstPtr instruction) {
 	instructions.push_back(instruction);
 }
 
-void QFunction::replaceInstruction(InstPtr currentInst,
+void GateFunction::replaceInstruction(InstPtr currentInst,
 		InstPtr replacingInst) {
 
 }
 
-void QFunction::replaceInstruction(int instId, InstPtr replacingInst) {
+void GateFunction::replaceInstruction(int instId, InstPtr replacingInst) {
 
 }
 
-const std::string QFunction::toString(const std::string bufferVarName) {
+const std::string GateFunction::toString(const std::string bufferVarName) {
 
+	std::string retStr = "";
+
+	for (auto i : instructions) {
+		retStr += i->toString(bufferVarName) + "\n";
+	}
+
+	return retStr;
 }
 
+const int GateFunction::getId() {
+	return functionId;
 }
+
+const std::string GateFunction::getName() {
+	return functionName;
 }
 
+const std::vector<int> GateFunction::qubits() {
+	return qbits;
+}
 
+const int GateFunction::nInstructions() {
+	return instructions.size();
+}
+}
+}
 

quantum/gate/gateqir/GateFunction.hpp

+/***********************************************************************************
+ * 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_GATEQIR_QFUNCTION_HPP_
+#define QUANTUM_GATEQIR_QFUNCTION_HPP_
+
+#include "QFunction.hpp"
+
+namespace xacc {
+namespace quantum {
+
+class GateFunction: public virtual QFunction {
+
+protected:
+
+	std::vector<std::shared_ptr<QInstruction>> instructions;
+
+	std::string functionName;
+
+	int functionId;
+
+	std::vector<int> qbits;
+
+public:
+
+	GateFunction();
+
+	GateFunction(int id, const std::string name);
+
+	/**
+	 * Add an instruction to this quantum
+	 * intermediate representation.
+	 *
+	 * @param instruction
+	 */
+	virtual void addInstruction(InstPtr instruction);
+
+	/**
+	 * Replace the given current quantum instruction
+	 * with the new replacingInst quantum Instruction.
+	 *
+	 * @param currentInst
+	 * @param replacingInst
+	 */
+	virtual void replaceInstruction(InstPtr currentInst,
+			InstPtr replacingInst);
+
+	/**
+	 * Replace the given current quantum instruction
+	 * with the new replacingInst quantum Instruction.
+	 *
+	 * @param currentInst
+	 * @param replacingInst
+	 */
+	virtual void replaceInstruction(int instId,
+			InstPtr replacingInst);
+
+	virtual const int getId();
+
+	virtual const std::string getName();
+
+	virtual const std::vector<int> qubits();
+
+	virtual const std::string toString(const std::string bufferVarName);
+
+	virtual void accept(QInstructionVisitor& visitor);
+
+	const int nInstructions();
+};
+}
+}
+#endif /* QUANTUM_GATE_IR_QFUNCTION_HPP_ */

quantum/gate/gateir/GateInstruction.hpp → quantum/gate/gateqir/GateInstruction.hpp

@@ -28,14 +28,17 @@
  *   Initial API and implementation - Alex McCaskey
  *
  **********************************************************************************/
-#ifndef QUANTUM_GATE_GATEIR_GATEINSTRUCTION_HPP_
-#define QUANTUM_GATE_GATEIR_GATEINSTRUCTION_HPP_
+#ifndef QUANTUM_GATE_GATEQIR_GATEINSTRUCTION_HPP_
+#define QUANTUM_GATE_GATEQIR_GATEINSTRUCTION_HPP_
 
 #include "QInstruction.hpp"
 
 namespace xacc {
 namespace quantum {
 
+/**
+ *
+ */
 class GateInstruction: public virtual QInstruction {
 
 protected:
@@ -88,4 +91,4 @@ public:
 
 
 
-#endif /* QUANTUM_GATE_GATEIR_GATEINSTRUCTION_HPP_ */
+#endif /* QUANTUM_GATE_GATEQIR_GATEINSTRUCTION_HPP_ */

quantum/gate/gateir/GateQIR.cpp → quantum/gate/gateqir/GateQIR.cpp

@@ -39,6 +39,17 @@ void GateQIR::generateGraph() {
 
 std::string GateQIR::toString() {
 
+	int nQubits = buffer->size();
+	auto bufVarName = buffer->name();
+	std::string retStr = "";
+	for (int i = 0; i < nQubits; i++) {
+		retStr += "qubit " + bufVarName + std::to_string(i) + "\n";
+	}
+	for (auto f : kernels) {
+		retStr += f->toString(bufVarName);
+	}
+
+	return retStr;
 }
 
 void GateQIR::persist(std::ostream& outStream) {

quantum/gate/gateir/GateQIR.hpp → quantum/gate/gateqir/GateQIR.hpp

@@ -31,7 +31,7 @@
 #ifndef QUANTUM_GATE_GATEQIR_HPP_
 #define QUANTUM_GATE_GATEQIR_HPP_
 
-#include "../../qir/QIR.hpp"
+#include "QIR.hpp"
 
 namespace xacc {
 namespace quantum {
@@ -43,8 +43,8 @@ namespace quantum {
  * Parameters: Gate, Layer (ie time sequence), Gate Vertex Id,
  * Qubit Ids that the gate acts on, enabled state, vector of parameters names
  */
-class CircuitNode: public XACCVertex<std::string, int, int,
-		std::vector<int>, bool, std::vector<std::string>> {
+class CircuitNode: public XACCVertex<std::string, int, int, std::vector<int>,
+		bool, std::vector<std::string>> {
 public:
 	CircuitNode() :
 			XACCVertex() {
@@ -67,12 +67,25 @@ public:
  */
 class GateQIR: public virtual xacc::quantum::QIR<xacc::quantum::CircuitNode> {
 
+protected:
+
+	/**
+	 *
+	 */
+	std::shared_ptr<AcceleratorBuffer> buffer;
+
 public:
 
-	GateQIR() : QFunction() {}
+	GateQIR() {
+	}
 
-	GateQIR(int id, const std::string name) : QFunction(id, name) {}
+	GateQIR(std::shared_ptr<AcceleratorBuffer> buf) :
+			buffer(buf) {
+	}
 
+	virtual void setAcceleratorBuffer(std::shared_ptr<AcceleratorBuffer> buf) {
+		buffer = buf;
+	}
 	/**
 	 *
 	 */

quantum/gate/gateir/ParameterizedGateInstruction.hpp → quantum/gate/gateqir/ParameterizedGateInstruction.hpp

@@ -28,11 +28,12 @@
  *   Initial API and implementation - Alex McCaskey
  *
  **********************************************************************************/
-#ifndef QUANTUM_GATE_GATEIR_PARAMETERIZEDGATEINSTRUCTION_HPP_
-#define QUANTUM_GATE_GATEIR_PARAMETERIZEDGATEINSTRUCTION_HPP_
+#ifndef QUANTUM_GATE_GATEQIR_PARAMETERIZEDGATEINSTRUCTION_HPP_
+#define QUANTUM_GATE_GATEQIR_PARAMETERIZEDGATEINSTRUCTION_HPP_
 
 #include "GateInstruction.hpp"
 #include "XACCError.hpp"
+#include "XaccUtils.hpp"
 
 namespace xacc {
 namespace quantum {
@@ -42,26 +43,24 @@ protected:
 	std::tuple<InstructionParameter...> params;
 
 public:
-	ParameterizedGateInstruction(int id, int layer, std::string name,
-			std::vector<int> qubts, InstructionParameter ... pars) :
-			GateInstruction(id, layer, name, qubts), params(
-					std::make_tuple(pars...)) {
+	ParameterizedGateInstruction(InstructionParameter ... pars) :
+			params(std::make_tuple(pars...)) {
 	}
 
 	auto getParameter(const std::size_t idx) {
-		if(idx + 1 > sizeof...(InstructionParameter)) {
+		if (idx + 1 > sizeof...(InstructionParameter)) {
 			XACCError("Invalid Parameter requested from Parameterized Gate Instruction.");
 		}
-		return xacc::runtime_get(params, idx);
+		return xacc::tuple_runtime_get(params, idx);
 	}
 
 	virtual const std::string toString(const std::string bufferVarName) {
 		auto str = gateName;
 		str += "(";
-		xacc::for_each(params, [&](auto element) {
+		xacc::tuple_for_each(params, [&](auto element) {
 			str += std::to_string(element) + ",";
 		});
-		str += str.substr(0, str.length() - 1) + ") ";
+		str = str.substr(0, str.length() - 1) + ") ";
 
 		for (auto q : qubits()) {
 			str += bufferVarName + std::to_string(q) + ",";
@@ -74,7 +73,6 @@ public:
 	}
 
 };
-}
-}
+}}
 
-#endif /* QUANTUM_GATE_GATEIR_PARAMETERIZEDGATEINSTRUCTION_HPP_ */
+#endif

quantum/gate/gateir/instructions/CNOT.hpp → quantum/gate/gateqir/instructions/CNOT.hpp

@@ -28,10 +28,10 @@
  *   Initial API and implementation - Alex McCaskey
  *
  **********************************************************************************/
-#ifndef QUANTUM_GATE_GATEIR_INSTRUCTIONS_CNOT_HPP_
-#define QUANTUM_GATE_GATEIR_INSTRUCTIONS_CNOT_HPP_
+#ifndef QUANTUM_GATE_GATEQIR_INSTRUCTIONS_CNOT_HPP_
+#define QUANTUM_GATE_GATEQIR_INSTRUCTIONS_CNOT_HPP_
 
-#include "GateInstruction.hpp"
+#include "../../gateqir/GateInstruction.hpp"
 class QInstructionVisitor;
 
 namespace xacc {
@@ -54,4 +54,4 @@ public:
 };
 }
 }
-#endif /* QUANTUM_GATE_GATEIR_INSTRUCTIONS_CNOT_HPP_ */
+#endif /* QUANTUM_GATE_GATEQIR_INSTRUCTIONS_CNOT_HPP_ */

quantum/gate/gateir/instructions/Hadamard.hpp → quantum/gate/gateqir/instructions/Hadamard.hpp

@@ -31,7 +31,7 @@
 #ifndef QUANTUM_GATE_IR_HADAMARD_HPP_
 #define QUANTUM_GATE_IR_HADAMARD_HPP_
 
-#include "GateInstruction.hpp"
+#include "../../gateqir/GateInstruction.hpp"
 class QInstructionVisitor;
 
 namespace xacc {

quantum/gate/gateir/instructions/Rz.hpp → quantum/gate/gateqir/instructions/Rz.hpp

@@ -28,8 +28,8 @@
  *   Initial API and implementation - Alex McCaskey
  *
  **********************************************************************************/
-#ifndef QUANTUM_GATE_GATEIR_INSTRUCTIONS_RZ_HPP_
-#define QUANTUM_GATE_GATEIR_INSTRUCTIONS_RZ_HPP_
+#ifndef QUANTUM_GATE_GATEQIR_INSTRUCTIONS_RZ_HPP_
+#define QUANTUM_GATE_GATEQIR_INSTRUCTIONS_RZ_HPP_
 
 #include "ParameterizedGateInstruction.hpp"
 class QInstructionVisitor;
@@ -39,8 +39,8 @@ namespace quantum {
 class Rz: public virtual ParameterizedGateInstruction<double> {
 public:
 	Rz(int id, int layer, int qbit, double theta) :
-			ParameterizedGateInstruction(id, layer, "Rz", std::vector<int> {
-					qbit }, theta) {
+			ParameterizedGateInstruction<double>(theta), GateInstruction(id,
+					layer, "Rz", std::vector<int> { qbit }) {
 	}
 
 	virtual void accept(QInstructionVisitor& visitor) {

quantum/gate/gateqir/tests/CNOTTester.cpp

+
+/***********************************************************************************
+ * 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 HadamardTester
+
+#include <boost/test/included/unit_test.hpp>
+#include "CNOT.hpp"
+
+using namespace xacc::quantum;
+
+BOOST_AUTO_TEST_CASE(checkCreation) {
+
+	CNOT h(0, 0, 0, 1);
+	BOOST_VERIFY(h.toString("qreg") == "CNOT qreg0,qreg1");
+	BOOST_VERIFY(h.getId() == 0);
+	BOOST_VERIFY(h.layer() == 0);
+	BOOST_VERIFY(h.qubits().size() == 2);
+	BOOST_VERIFY(h.qubits()[0] == 0);
+	BOOST_VERIFY(h.qubits()[1] == 1);
+	BOOST_VERIFY(h.getName() == "CNOT");
+
+	CNOT h2(3, 22, 44, 46);
+	BOOST_VERIFY(h2.toString("qreg") == "CNOT qreg44,qreg46");
+	BOOST_VERIFY(h2.getId() == 3);
+	BOOST_VERIFY(h2.layer() == 22);
+	BOOST_VERIFY(h2.qubits().size() == 2);
+	BOOST_VERIFY(h2.qubits()[0] == 44);
+	BOOST_VERIFY(h2.qubits()[1] == 46);
+	BOOST_VERIFY(h2.getName() == "CNOT");
+
+
+}

quantum/gate/gateqir/tests/GateFunctionTester.cpp

+
+/***********************************************************************************
+ * 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 GateFunctionTester
+
+#include <boost/test/included/unit_test.hpp>
+#include "GateFunction.hpp"
+#include "Hadamard.hpp"
+#include "CNOT.hpp"
+
+using namespace xacc::quantum;
+
+const std::string expectedQasm =
+		"H qreg1\n"
+		"CNOT qreg1,qreg2\n"
+		"CNOT qreg0,qreg1\n"
+		"H qreg0\n";
+
+BOOST_AUTO_TEST_CASE(checkCreation) {
+
+	GateFunction f(0, "foo");
+	BOOST_VERIFY(f.getId() == 0);
+	BOOST_VERIFY(f.getName() == "foo");
+	BOOST_VERIFY(f.nInstructions() == 0);
+
+	auto h = std::make_shared<Hadamard>(0, 0, 1);
+	auto cn1 = std::make_shared<CNOT>(1, 1, 1, 2);
+	auto cn2 = std::make_shared<CNOT>(2, 2, 0, 1);
+	auto h2 = std::make_shared<Hadamard>(3, 3, 0);
+
+	f.addInstruction(h);
+	f.addInstruction(cn1);
+	f.addInstruction(cn2);
+	f.addInstruction(h2);
+
+	BOOST_VERIFY(f.nInstructions() == 4);
+
+	BOOST_VERIFY(f.toString("qreg") == expectedQasm);
+}

quantum/gate/gateir/tests/GateQIRTester.cpp → quantum/gate/gateqir/tests/GateQIRTester.cpp

+
 /***********************************************************************************
  * Copyright (c) 2016, UT-Battelle
  * All rights reserved.
@@ -32,6 +33,7 @@
 #define BOOST_TEST_MODULE GateQIRTester
 
 #include <boost/test/included/unit_test.hpp>
+#include "GateFunction.hpp"
 #include "Hadamard.hpp"
 #include "CNOT.hpp"
 #include "Rz.hpp"
@@ -39,7 +41,7 @@
 
 using namespace xacc::quantum;
 
-BOOST_AUTO_TEST_CASE(checkCreation) {
+BOOST_AUTO_TEST_CASE(checkCreationToString) {
 
 	const std::string expectedQasm =
 			"qubit qreg0\n"
@@ -48,28 +50,23 @@ BOOST_AUTO_TEST_CASE(checkCreation) {
 			"H qreg1\n"
 			"CNOT qreg1,qreg2\n"
 			"CNOT qreg0,qreg1\n"
-			"H qreg0\n"
-			"MeasZ qreg0\n"
-			"MeasZ qreg1\n"
-			"H qreg2\n"
-			"CNOT qreg2,qreg1\n"
-			"H qreg2\n"
-			"CNOT qreg2,qreg0";
-
-	auto qir = std::make_shared<GateQIR>();
-
-	auto accBuffer = std::make_shared<AcceleratorBuffer>("qreg", 3);
-	qir->setAcceleratorBuffer(accBuffer);
-
-	auto rz = std::make_shared<Rz>(0, 0, 0, 3.14);
-
-	BOOST_VERIFY(rz->getParameter(0) == 3.14);
+			"H qreg0\n";
 
-	qir->addInstruction(rz);
+	auto buf = std::make_shared<AcceleratorBuffer>("qreg", 3);
+	auto qir = std::make_shared<GateQIR>(buf);
 
-	BOOST_VERIFY(qir->nInstructions() == 1);
+	auto f = std::make_shared<GateFunction>(0, "foo");
+	auto h = std::make_shared<Hadamard>(0, 0, 1);
+	auto cn1 = std::make_shared<CNOT>(1, 1, 1, 2);
+	auto cn2 = std::make_shared<CNOT>(2, 2, 0, 1);
+	auto h2 = std::make_shared<Hadamard>(3, 3, 0);
+	f->addInstruction(h);
+	f->addInstruction(cn1);
+	f->addInstruction(cn2);
+	f->addInstruction(h2);
 
-	std::cout << rz->getParameter(0) << "\n";
+	qir->addQuantumKernel(f);
 
+	BOOST_VERIFY(qir->toString() == expectedQasm);
 
 }

quantum/gate/gateqir/tests/HadamardTester.cpp

+
+/***********************************************************************************
+ * 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 HadamardTester
+
+#include <boost/test/included/unit_test.hpp>
+#include "Hadamard.hpp"
+
+using namespace xacc::quantum;
+
+BOOST_AUTO_TEST_CASE(checkCreation) {
+
+	Hadamard h(0, 0, 0);
+	BOOST_VERIFY(h.toString("qreg") == "H qreg0");
+	BOOST_VERIFY(h.getId() == 0);
+	BOOST_VERIFY(h.layer() == 0);
+	BOOST_VERIFY(h.qubits().size() == 1);
+	BOOST_VERIFY(h.qubits()[0] == 0);
+	BOOST_VERIFY(h.getName() == "H");
+
+	Hadamard h2(3, 22, 44);
+	BOOST_VERIFY(h2.toString("qreg") == "H qreg44");
+	BOOST_VERIFY(h2.getId() == 3);
+	BOOST_VERIFY(h2.layer() == 22);
+	BOOST_VERIFY(h2.qubits().size() == 1);
+	BOOST_VERIFY(h2.qubits()[0] == 44);
+	BOOST_VERIFY(h2.getName() == "H");
+
+
+}

quantum/gate/gateqir/tests/ParameterizedGateTester.cpp

+/***********************************************************************************
+ * 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 ParameterizedGateTester
+
+#include <boost/test/included/unit_test.hpp>
+#include "ParameterizedGateInstruction.hpp"
+
+using namespace xacc::quantum;
+
+class DummyGate: public virtual ParameterizedGateInstruction<double, double> {
+public:
+	DummyGate(int id, int layer, int qbit, double param1, double param2) :
+			ParameterizedGateInstruction(param1, param2), GateInstruction(id, layer, "Dummy",std::vector<int>{qbit}){
+	}
+
+	virtual void accept(QInstructionVisitor& visitor) {
+
+	}
+
+};
+
+BOOST_AUTO_TEST_CASE(checkParameterizedGate) {
+	auto dgate = std::make_shared<DummyGate>(0, 0, 0, 3.14, 33.3);
+	BOOST_VERIFY(dgate->getParameter(0) == 3.14);
+	BOOST_VERIFY(dgate->getParameter(1) == 33.3);
+}

quantum/gate/gateqir/tests/RzTester.cpp

+
+/***********************************************************************************
+ * 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 RzTester
+
+#include <boost/test/included/unit_test.hpp>
+#include "Rz.hpp"
+
+using namespace xacc::quantum;
+
+BOOST_AUTO_TEST_CASE(checkCreation) {
+
+	Rz rz(0, 0, 0, 3.14);
+	BOOST_VERIFY(rz.getParameter(0) == 3.14);
+	BOOST_VERIFY(rz.toString("qreg") == "Rz(3.140000) qreg0");
+	BOOST_VERIFY(rz.getId() == 0);
+	BOOST_VERIFY(rz.layer() == 0);
+	BOOST_VERIFY(rz.qubits().size() == 1);
+	BOOST_VERIFY(rz.qubits()[0] == 0);
+	BOOST_VERIFY(rz.getName() == "Rz");
+
+	Rz rz2(3, 22, 44, 1.71234);
+	BOOST_VERIFY(rz2.getParameter(0) == 1.71234);
+	BOOST_VERIFY(rz2.toString("qreg") == "Rz(1.712340) qreg44");
+	BOOST_VERIFY(rz2.getId() == 3);
+	BOOST_VERIFY(rz2.layer() == 22);
+	BOOST_VERIFY(rz2.qubits().size() == 1);
+	BOOST_VERIFY(rz2.qubits()[0] == 44);
+	BOOST_VERIFY(rz2.getName() == "Rz");
+
+
+}

quantum/qir/CMakeLists.txt

@@ -34,14 +34,14 @@ set (PACKAGE_DESCIPTION "XACC Quantum Intermediate Representation")
 set (LIBRARY_NAME xacc-qir)
 
 file (GLOB HEADERS *.hpp)
-file (GLOB SRC *.cpp)
+#file (GLOB SRC *.cpp)
 
-add_library(${LIBRARY_NAME} SHARED ${SRC})
+#add_library(${LIBRARY_NAME} SHARED ${SRC})
 
 install(FILES ${HEADERS} DESTINATION include)
-install(TARGETS ${LIBRARY_NAME} DESTINATION lib)
+#install(TARGETS ${LIBRARY_NAME} DESTINATION lib)
 
 # Gather tests
-file (GLOB test_files tests/*.cpp)
-add_tests("${test_files}" "${CMAKE_CURRENT_SOURCE_DIR}" "${Boost_LIBRARIES}")
+#file (GLOB test_files tests/*.cpp)
+#add_tests("${test_files}" "${CMAKE_CURRENT_SOURCE_DIR}" "${Boost_LIBRARIES}")
 

quantum/qir/QFunction.hpp

@@ -28,36 +28,22 @@
  *   Initial API and implementation - Alex McCaskey
  *
  **********************************************************************************/
-#ifndef QUANTUM_GATE_IR_QFUNCTION_HPP_
-#define QUANTUM_GATE_IR_QFUNCTION_HPP_
+#ifndef QUANTUM_QIR_QFUNCTION_HPP_
+#define QUANTUM_QIR_QFUNCTION_HPP_
 
 #include "QInstruction.hpp"
 
 namespace xacc {
 namespace quantum {
+using InstPtr = std::shared_ptr<QInstruction>;
 class QFunction: public virtual QInstruction {
 
-	using InstPtr = std::shared_ptr<QInstruction>;
-
-protected:
-
-	std::vector<std::shared_ptr<QInstruction>> instructions;
-
-	std::string functionName;
-
-	int functionId;
-
-	std::vector<int> qbits;
 
 public:
 
-	QFunction() :
-			functionName("UNKNOWN"), functionId(-1), qbits(
-					std::vector<int> { }), instructions(
-					std::vector<InstPtr> { }) {
-	}
+	QFunction() {}
 
-	QFunction(int id, const std::string name);
+	QFunction(int id, const std::string name) {}
 
 	/**
 	 * Add an instruction to this quantum
@@ -65,7 +51,7 @@ public:
 	 *
 	 * @param instruction
 	 */
-	virtual void addInstruction(InstPtr instruction);
+	virtual void addInstruction(InstPtr instruction) = 0;
 
 	/**
 	 * Replace the given current quantum instruction
@@ -75,7 +61,7 @@ public:
 	 * @param replacingInst
 	 */
 	virtual void replaceInstruction(InstPtr currentInst,
-			InstPtr replacingInst);
+			InstPtr replacingInst) = 0;
 
 	/**
 	 * Replace the given current quantum instruction
@@ -85,28 +71,10 @@ public:
 	 * @param replacingInst
 	 */
 	virtual void replaceInstruction(int instId,
-			InstPtr replacingInst);
-
-	virtual const int getId() {
-		return functionId;
-	}
-
-	virtual const std::string getName() {
-		return functionName;
-	}
-
-	virtual const std::vector<int> qubits() {
-		return qbits;
-	}
-
-	virtual const std::string toString(const std::string bufferVarName);
-
-	virtual void accept(QInstructionVisitor& visitor);
+			InstPtr replacingInst) = 0;
 
-	const int nInstructions() {
-		return instructions.size();
-	}
+	virtual const int nInstructions() = 0;
 };
 }
 }
-#endif /* QUANTUM_GATE_IR_QFUNCTION_HPP_ */
+#endif

quantum/qir/QIR.hpp

@@ -43,21 +43,29 @@ namespace quantum {
  */
 template<typename VertexType>
 class QIR: public virtual xacc::Graph<VertexType>,
-		public virtual QFunction,
 		public virtual xacc::IR {
 public:
 
 	QIR() {}
 
+	QIR(std::shared_ptr<AcceleratorBuffer> buf) : IR(buf) {}
+
 	/**
 	 *
 	 */
 	virtual void generateGraph() = 0;
 
+	virtual void addQuantumKernel(std::shared_ptr<QFunction> kernel) {kernels.push_back(kernel);}
+
 	/**
 	 *
 	 */
 	virtual ~QIR() {}
+
+protected:
+
+	std::vector<std::shared_ptr<QFunction>> kernels;
+
 };
 }
 }