Simulator_pybind11.cpp File Reference

#include "pybind11/pybind11.h"
#include "pybind11/iostream.h"
#include "Simulator.hpp"
#include "IntelSimulator.cpp"
#include "pybind11/complex.h"
#include "pybind11/stl.h"
#include <pybind11/numpy.h>
#include <mpi.h>

Include dependency graph for Simulator_pybind11.cpp:

Go to the source code of this file.

Data Structures
class	IntelSimPy

Macros
#define	PYBIND11_EXPORT

Typedefs
using	DCM = qhipster::TinyMatrix< std::complex< double >, 2u, 2u, 32u >

Functions
template<class SimulatorType >
void	intel_simulator_binding (py::module &m)
	PYBIND11_MODULE (_PyQNLPSimulator, m)

Macro Definition Documentation

PYBIND11_EXPORT

#define PYBIND11_EXPORT

Definition at line 10 of file Simulator_pybind11.cpp.

Typedef Documentation

DCM

using DCM = qhipster::TinyMatrix<std::complex<double>, 2u, 2u, 32u>

Definition at line 14 of file Simulator_pybind11.cpp.

Function Documentation

intel_simulator_binding()

template<class SimulatorType >

void intel_simulator_binding

(

py::module &

m

)

Definition at line 46 of file Simulator_pybind11.cpp.

                                         {

    py::class_<SimulatorType>(m, "PyQNLPSimulator")
        .def(py::init<const std::size_t &, const bool &>())
        .def("getGateX", &SimulatorType::getGateX, py::return_value_policy::reference)
        .def("getGateY", &SimulatorType::getGateY, py::return_value_policy::reference)
        .def("getGateZ", &SimulatorType::getGateZ, py::return_value_policy::reference)
        .def("getGateI", &SimulatorType::getGateI, py::return_value_policy::reference)
        .def("getGateH", &SimulatorType::getGateH, py::return_value_policy::reference)
        .def("applyGateX", &SimulatorType::applyGateX)
        .def("applyGateY", &SimulatorType::applyGateY)
        .def("applyGateZ", &SimulatorType::applyGateZ)
        .def("applyGateH", &SimulatorType::applyGateH)
        .def("applyGateI", &SimulatorType::applyGateH)
        .def("applyGateSqrtX", &SimulatorType::applyGateSqrtX)
        .def("applyGateRotX", &SimulatorType::applyGateRotX)
        .def("applyGateRotY", &SimulatorType::applyGateRotY)
        .def("applyGateRotZ", &SimulatorType::applyGateRotZ)
        .def("applyGateCRotX", &SimulatorType::applyGateCRotX)
        .def("applyGateCRotY", &SimulatorType::applyGateCRotY)
        .def("applyGateCRotZ", &SimulatorType::applyGateCRotZ)
        .def("applyGateU", &SimulatorType::applyGateU)
        .def("applyGateCU", &SimulatorType::applyGateCU)
        .def("applyGateSwap", &SimulatorType::applyGateSwap)
        .def("applyGateSqrtSwap", &SimulatorType::applyGateSqrtSwap)
        .def("applyGatePhaseShift", &SimulatorType::applyGatePhaseShift)
        .def("applyGateCPhaseShift", &SimulatorType::applyGateCPhaseShift)
        .def("applyGateCX", &SimulatorType::applyGateCX)
        .def("applyGateCCX", &SimulatorType::applyGateCCX)
        .def("applyGateCSwap", &SimulatorType::applyGateCSwap)
        .def("getNumQubits", &SimulatorType::getNumQubits)
        .def("applyQFT", &SimulatorType::applyQFT)
        .def("applyIQFT", &SimulatorType::applyIQFT)
        .def("applyDiffusion", &SimulatorType::applyDiffusion)
        .def("encodeToRegister", &SimulatorType::encodeToRegister)
        .def("encodeBinToSuperpos_unique", &SimulatorType::encodeBinToSuperpos_unique)
        .def("applyHammingDistanceRotY", &SimulatorType::applyHammingDistanceRotY)
        .def("applyMeasurement", &SimulatorType::applyMeasurement)
        .def("applyMeasurementToRegister", &SimulatorType::applyMeasurementToRegister)
        .def("collapseToBasisZ", &SimulatorType::collapseToBasisZ)
        .def("initRegister", &SimulatorType::initRegister)
        .def("printStates", &SimulatorType::PrintStates, py::call_guard<py::scoped_ostream_redirect,py::scoped_estream_redirect>())
        .def("applyGateNCU", &SimulatorType::applyGateNCU_nonlinear)
        .def("applyGateNCU", &SimulatorType::applyGateNCU_5CX_Opt)
        .def("addUToCache", &SimulatorType::addUToCache_U)
        .def("subReg", &SimulatorType::subReg)
        .def("sumReg", &SimulatorType::sumReg)
        .def("applyOracleU", &SimulatorType::applyOracle_U)
        .def("applyOracleU", &SimulatorType::applyOracle_Opt)
        .def("getGateCounts", &SimulatorType::getGateCounts)
        .def("applyOraclePhase", &SimulatorType::applyOraclePhase)
        .def("groupQubits", &SimulatorType::groupQubits)
        .def("overlap", &SimulatorType::computeOverlap)
        .def("applyHammingDistanceOverwrite", &SimulatorType::applyHammingDistanceOverwrite);
/*
        .def("adjointMatrix", &SimulatorType::adjointMatrix)
        .def("matrixSqrt", &SimulatorType::matrixSqrt)
        .def("getQubitRegister", &SimulatorType::getQubitRegister)        
*/

    //TinyMatrix
    py::class_<DCM>(m, "DCMatrix")
        .def(py::init<>())
        .def(py::init([](std::vector<std::complex<double>> &values) { 
            DCM m;
            m(0,0) = values[0];
            m(0,1) = values[1];
            m(1,0) = values[2];
            m(1,1) = values[3];
            return m;
        }))
        .def("__repr__",
            [](const DCM &s) {
                return s.tostr();
            }
        )
        .def("__getitem__", 
            [](const DCM &s, std::size_t i, std::size_t j) {
                if (i >= 2 || j >= 2) 
                    throw py::index_error();
                return s(i,j);
            })
        .def("__mul__", [](const DCM &s0, const DCM &s1) {
            DCM m;
            m(0,0) = s0(0,0)*s1(0,0) + s0(0,1)*s1(1,0);
            m(0,1) = s0(0,0)*s1(1,0) + s0(0,1)*s1(1,1);
            m(1,0) = s0(1,0)*s1(0,0) + s0(1,1)*s1(1,0);
            m(1,1) = s0(1,0)*s1(1,0) + s0(1,1)*s1(1,1);
            return m;
        })
        .def("__rmul__", [](const DCM &s0, std::complex<double> d1) {
            DCM m(s0);
            m(0,0) *= d1;
            m(0,1) *= d1;
            m(1,0) *= d1;
            m(1,1) *= d1;
            return m;
        })
        .def("__mul__", [](const DCM &s0, std::complex<double> d1) {
            DCM m(s0);
            m(0,0) *= d1;
            m(0,1) *= d1;
            m(1,0) *= d1;
            m(1,1) *= d1;
            return m;
        })
        .def("__radd__", [](const DCM &s0, std::complex<double> d1) {
            DCM m(s0);
            m(0,0) += d1;
            m(0,1) += d1;
            m(1,0) += d1;
            m(1,1) += d1;
            return m;
        })
        .def("__add__", [](const DCM &s0, const DCM &s1) {
            DCM m(s0);
            m(0,0) += s1(0,0);
            m(0,1) += s1(0,1);
            m(1,0) += s1(1,0);
            m(1,1) += s1(1,1);
            return m;
        })
        .def("__sub__", [](const DCM &s0, const DCM &s1) {
            DCM m(s0);
            m(0,0) -= s1(0,0);
            m(0,1) -= s1(0,1);
            m(1,0) -= s1(1,0);
            m(1,1) -= s1(1,1);
            return m;
        })
        .def("adjoint", [](const DCM &s0) {
            return SimulatorType::adjointMatrix(s0);;
        })
        .def("conjugate", [](const DCM &s0) {
            DCM m(s0);
            m(0,0) = std::conj(m(0,0));
            m(0,1) = std::conj(m(0,1));
            m(1,0) = std::conj(m(1,0));
            m(1,1) = std::conj(m(1,1));
            return m;
        })
        .def("transpose", [](const DCM &s0) {
            DCM m(s0);
            auto tmp = m(0,1);
            m(0,1) = m(1,0);
            m(1,0) = tmp;
            return m;
        })
        .def("as_numpy",[](DCM &s0){
            py::array_t<std::complex<double>> arr({ 2, 2 });
            py::buffer_info arr_buff = arr.request();
            std::complex<double>* ptr = (std::complex<double>*) arr_buff.ptr;

            ptr[0] = s0(0,0);
            ptr[1] = s0(0,1);
            ptr[2] = s0(1,0);
            ptr[3] = s0(1,1);

            return arr;
        });
}

References QNLP::adjointMatrix(), QNLP.tagging.test_tagging::s1, and QNLP.tagging.tag_file::tmp.

Here is the call graph for this function:

PYBIND11_MODULE()

PYBIND11_MODULE	(	_PyQNLPSimulator	,
		m
	)

Definition at line 208 of file Simulator_pybind11.cpp.

                                    {
    intel_simulator_binding<IntelSimPy>(m);
}