reorganzied pauli-fermi op stuff into runtime/utils (7ce3184c) · Commits · ORNL Quantum Computing Institute / qcor

runtime/CMakeLists.txt

+3 −2

Original line number	Diff line number	Diff line
		@@ -6,7 +6,7 @@ add_library(${LIBRARY_NAME} SHARED ${SRC})

		target_include_directories(${LIBRARY_NAME} PUBLIC . qrt)

		target_link_libraries(${LIBRARY_NAME} PUBLIC xacc::xacc xacc::quantum_gate qrt xacc::pauli xacc::fermion)
		target_link_libraries(${LIBRARY_NAME} PUBLIC xacc::xacc xacc::quantum_gate qrt utils)

		xacc_configure_library_rpath(${LIBRARY_NAME})

		@@ -20,3 +20,4 @@ endif()

		add_subdirectory(objectives)
		add_subdirectory(qrt)
		add_subdirectory(utils)
		No newline at end of file

runtime/qcor.cpp

+0 −8

Original line number	Diff line number	Diff line
		@@ -62,14 +62,6 @@ double observe(std::shared_ptr<CompositeInstruction> program, Observable &obs,
		}
		} // namespace __internal__

		PauliOperator transform(FermionOperator &obs, std::string transf) {
		if (!xacc::isInitialized())
		xacc::internal_compiler::compiler_InitializeXACC();
		auto obsv = std::make_shared<FermionOperator>(obs);
		auto terms = std::dynamic_pointer_cast<PauliOperator>(
		xacc::getService<xacc::ObservableTransform>(transf)->transform(obsv));
		return *terms;
		}

		std::shared_ptr<xacc::Optimizer> createOptimizer(const std::string &type,
		HeterogeneousMap &&options) {

runtime/qcor.hpp

+2 −160

Original line number	Diff line number	Diff line
		@@ -8,14 +8,11 @@
		#include <tuple>

		#include "CompositeInstruction.hpp"
		#include "Observable.hpp"
		#include "Optimizer.hpp"

		#include "FermionOperator.hpp"
		#include "ObservableTransform.hpp"
		#include "PauliOperator.hpp"
		#include "Observable.hpp"
		#include "qalloc"
		#include "qrt.hpp"
		#include "operator_algebra.hpp"
		#include "xacc_internal_compiler.hpp"

		namespace qcor {
		@@ -25,161 +22,6 @@ using HeterogeneousMap = xacc::HeterogeneousMap;
		using Observable = xacc::Observable;
		using Optimizer = xacc::Optimizer;
		using CompositeInstruction = xacc::CompositeInstruction;
		using PauliOperator = xacc::quantum::PauliOperator;
		using FermionOperator = xacc::quantum::FermionOperator;

		PauliOperator X(int idx) { return PauliOperator({{idx, "X"}}); }
		PauliOperator Y(int idx) { return PauliOperator({{idx, "Y"}}); }
		PauliOperator Z(int idx) { return PauliOperator({{idx, "Z"}}); }
		PauliOperator SP(int idx) {
		std::complex<double> imag(0.0, 1.0);
		return X(idx) + imag * Y(idx);
		}
		PauliOperator SM(int idx) {
		std::complex<double> imag(0.0, 1.0);
		return X(idx) - imag * Y(idx);
		}
		FermionOperator a(int idx) {
		std::string s("(1.0, 0) " + std::to_string(idx));
		return FermionOperator(s);
		}
		FermionOperator adag(int idx) {
		std::string s("(1.0, 0) " + std::to_string(idx) + "^");
		return FermionOperator(s);
		}

		PauliOperator allZs(const int nQubits) {
		auto ret = Z(0);
		for (int i = 1; i < nQubits; i++) {
		ret *= Z(i);
		}
		return ret;
		}

		// transform FermionOperator to PauliOperator
		PauliOperator transform(FermionOperator &obs, std::string transf = "jw");

		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		PauliOperator operator+(T coeff, PauliOperator &op) {
		return PauliOperator(coeff) + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		PauliOperator operator+(PauliOperator &op, T coeff) {
		return PauliOperator(coeff) + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		PauliOperator operator-(T coeff, PauliOperator &op) {
		return -1.0 * coeff + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		PauliOperator operator-(PauliOperator &op, T coeff) {
		return -1.0 * coeff + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		FermionOperator operator+(T coeff, FermionOperator &op) {
		return FermionOperator(coeff) + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		FermionOperator operator+(FermionOperator &op, T coeff) {
		return FermionOperator(coeff) + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		FermionOperator operator-(T coeff, FermionOperator &op) {
		return -1.0 * coeff + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		FermionOperator operator-(FermionOperator &op, T coeff) {
		return -1.0 * coeff + op;
		}

		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		PauliOperator operator+(T coeff, PauliOperator &&op) {
		return PauliOperator(coeff) + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		PauliOperator operator+(PauliOperator &&op, T coeff) {
		return PauliOperator(coeff) + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		PauliOperator operator-(T coeff, PauliOperator &&op) {
		return -1.0 * coeff + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		PauliOperator operator-(PauliOperator &&op, T coeff) {
		return -1.0 * coeff + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		FermionOperator operator+(T coeff, FermionOperator &&op) {
		return FermionOperator(coeff) + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		FermionOperator operator+(FermionOperator &&op, T coeff) {
		return FermionOperator(coeff) + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		FermionOperator operator-(T coeff, FermionOperator &&op) {
		return -1.0 * coeff + op;
		}
		template <typename T, typename = typename std::enable_if<
		std::is_arithmetic<T>::value, T>::type>
		FermionOperator operator-(FermionOperator &&op, T coeff) {
		return -1.0 * coeff + op;
		}

		PauliOperator operator+(FermionOperator &&fop, PauliOperator &&pop) {
		auto pfop = transform(fop);
		return pfop + pop;
		}

		PauliOperator operator+(PauliOperator &&pop, FermionOperator &&fop) {
		auto pfop = transform(fop);
		return pop + pfop;
		}

		PauliOperator operator*(PauliOperator &&pop, FermionOperator &&fop) {
		auto pfop = transform(fop);
		return pfop * pop;
		}

		PauliOperator operator*(FermionOperator &&fop, PauliOperator &&pop) {
		auto pfop = transform(fop);
		return pop * pfop;
		}

		PauliOperator operator+(FermionOperator &fop, PauliOperator &pop) {
		auto pfop = transform(fop);
		return pfop + pop;
		}

		PauliOperator operator+(PauliOperator &pop, FermionOperator &fop) {
		auto pfop = transform(fop);
		return pop + pfop;
		}

		PauliOperator operator*(PauliOperator &pop, FermionOperator &fop) {
		auto pfop = transform(fop);
		return pfop * pop;
		}

		PauliOperator operator*(FermionOperator &fop, PauliOperator &pop) {
		auto pfop = transform(fop);
		return pop * pfop;
		}

		class ResultsBuffer {
		public:

runtime/utils/CMakeLists.txt

0 → 100644

+15 −0

Original line number	Diff line number	Diff line
		set(LIBRARY_NAME utils)

		file(GLOB SRC *.cpp)

		add_library(${LIBRARY_NAME} SHARED ${SRC})

		target_include_directories(${LIBRARY_NAME} PUBLIC .)

		target_link_libraries(${LIBRARY_NAME} PUBLIC xacc::xacc xacc::quantum_gate xacc::pauli xacc::fermion)

		xacc_configure_library_rpath(${LIBRARY_NAME})

		file(GLOB HEADERS operator_algebra.hpp)
		install(FILES ${HEADERS} DESTINATION include/qcor)
		install(TARGETS ${LIBRARY_NAME} DESTINATION lib)

runtime/utils/operator_algebra.cpp

0 → 100644

+18 −0

Original line number	Diff line number	Diff line
		#include "operator_algebra.hpp"
		#include "xacc.hpp"
		#include "xacc_service.hpp"
		#include "xacc_internal_compiler.hpp"


		namespace qcor{
		PauliOperator transform(FermionOperator &obs, std::string transf) {
		if (!xacc::isInitialized())
		xacc::internal_compiler::compiler_InitializeXACC();
		auto obsv = std::make_shared<FermionOperator>(obs);
		auto terms = std::dynamic_pointer_cast<PauliOperator>(
		xacc::getService<xacc::ObservableTransform>(transf)->transform(obsv));
		return *terms;
		}
		}