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

adding ddcl example 



Signed-off-by: Mccaskey, Alex's avatarAlex McCaskey <mccaskeyaj@ornl.gov>
parent 48b0d22e

examples/ddcl_simple.cpp

0 → 100644
+26 −0
Original line number Diff line number Diff line 
#include "qcor.hpp"



int main(int argc, char **argv) {



  qcor::Initialize(argc, argv);



  auto ansatz = [&](qbit q, std::vector<double> x) {

    Rx(q[0], x[0]);

    Ry(q[0], x[1]);

    Rx(q[0], x[2]);

  };



  auto optimizer =

      qcor::getOptimizer("nlopt", std::make_pair("nlopt-maxeval", 20));



  HeterogeneousMap ddclOptions{

      std::make_pair("loss", "js"),

      std::make_pair("target_dist", std::vector<double>{.5, .5})};



  auto handle = qcor::taskInitiate(ansatz, "ddcl", optimizer, ddclOptions,

                                   std::vector<double>{});

  auto results = qcor::sync(handle);



  std::cout << "JS: " << results->getInformation("opt-val").as<double>()

            << "\n";

}

examples/hwe_for_loop_xasm_deuteron.cpp

+3 −10
Original line number Diff line number Diff line 
#include "qcor.hpp"

#include <heterogeneous.hpp>



int main(int argc, char **argv) {



  qcor::Initialize(argc, argv);



  auto ansatz = [&](qbit q, std::vector<double> x) {

    for (int i = 0; i < 2; i++) {

    for (auto i = 0; i < 2; i++) {

        Rx(q[i],x[i]);

        Rz(q[i],x[2+i]);

    }

    CX(q[1],q[0]);

    for (int i = 0; i < 2; i++) {

    for (auto i = 0; i < 2; i++) {

        Rx(q[i], x[i+4]);

        Rz(q[i], x[i+4+2]);

        Rx(q[i], x[i+4+4]);
@@ -26,12 +25,6 @@ int main(int argc, char **argv) { 
      qcor::getObservable("pauli", std::string("5.907 - 2.1433 X0X1 "

                                               "- 2.1433 Y0Y1"

                                               "+ .21829 Z0 - 6.125 Z1"));

  int nq = observable->nBits();



  auto handle = qcor::submit([&](qcor::qpu_handler &qh) {

    qh.vqe(ansatz,

        observable, optimizer, std::vector<double>{});

  });



  auto handle = qcor::taskInitiate(ansatz, "vqe", optimizer, observable, std::vector<double>{});

  auto results = qcor::sync(handle);

}

runtime/qcor.hpp

+54 −30
Original line number Diff line number Diff line
@@ -397,6 +397,28 @@ public: 
  }

};



template <typename QuantumKernel, typename... InitialArgs>

Handle

taskInitiate(QuantumKernel &kernel, const std::string objectiveFunctionName,

             std::shared_ptr<Optimizer> optimizer,

             HeterogeneousMap& algoOptions, InitialArgs... args) {

  auto function = qcor::__internal::getCompositeInstruction(kernel, args...);

  auto parameters = __internal::parametersFromVariadic(function, args...);

  return qcor::submit([&, parameters, function](qcor::qpu_handler &q) {

    auto nLogicalBits = function->nLogicalBits();

    auto accelerator = xacc::getAccelerator(function->accelerator_signature());

    auto buffer = xacc::qalloc(nLogicalBits);



    optimizer->appendOption("initial-parameters", parameters);



    algoOptions.insert("optimizer", optimizer);

    algoOptions.insert("accelerator", accelerator);

    algoOptions.insert("ansatz", function);



    q.execute(objectiveFunctionName, kernel, algoOptions, parameters);

  });

}



// Full TaskInitiate, built in objective function (given by its name)

template <typename QuantumKernel, typename... InitialArgs>

Handle
@@ -420,36 +442,6 @@ taskInitiate(QuantumKernel &&kernel, const std::string objectiveFunctionName, 
  });

}



// TaskInitiate just execute kernel with measurements (parameterized, rvalue

// kernel)

template <typename QuantumKernel, typename FirstArg, typename... InitialArgs>

Handle taskInitiate(QuantumKernel &&kernel, FirstArg arg, InitialArgs... args) {

  return taskInitiate(kernel, arg, args...);

}



// TaskInitiate just execute kernel with measurements (parameterized, lvalue

// kernel)

template <typename QuantumKernel, typename FirstArg, typename... InitialArgs>

Handle taskInitiate(QuantumKernel &kernel, FirstArg arg, InitialArgs... args) {

  auto function =

      qcor::__internal::getCompositeInstruction(kernel, arg, args...);

  auto parameters = __internal::parametersFromVariadic(function, arg, args...);

  return qcor::submit([&, parameters](qcor::qpu_handler &qh) {

    qh.execute(kernel, parameters);

  });

}



// TaskInitiate just execute kernel with measurements (no params, rvalue kernel)

template <typename QuantumKernel> Handle taskInitiate(QuantumKernel &&kernel) {

  return taskInitiate(kernel);

}



// TaskInitiate just execute kernel with measurements (no params, rvalue kernel)

template <typename QuantumKernel> Handle taskInitiate(QuantumKernel &kernel) {

  auto function = qcor::__internal::getCompositeInstruction(kernel);

  return qcor::submit([&](qcor::qpu_handler &qh) { qh.execute(kernel); });

}



// No observable, assume Z on all qubits, objective function given by name

template <typename QuantumKernel, typename... InitialArgs>

Handle taskInitiate(QuantumKernel &&kernel,
@@ -561,6 +553,38 @@ Handle taskInitiate(QuantumKernel &&kernel, 
  auto observable = getObservable("pauli", allZsObsStr);

  return taskInitiate(kernel, objFunction, observable, args...);

}





// TaskInitiate just execute kernel with measurements (parameterized, rvalue

// kernel)

// template <typename QuantumKernel, typename FirstArg, typename... InitialArgs>

// Handle taskInitiate(QuantumKernel &&kernel, FirstArg arg, InitialArgs... args) {

//   return taskInitiate(kernel, arg, args...);

// }



// // TaskInitiate just execute kernel with measurements (parameterized, lvalue

// // kernel)

// template <typename QuantumKernel, typename FirstArg, typename... InitialArgs>

// Handle taskInitiate(QuantumKernel &kernel, FirstArg arg, InitialArgs... args) {

//   auto function =

//       qcor::__internal::getCompositeInstruction(kernel, arg, args...);

//   auto parameters = __internal::parametersFromVariadic(function, arg, args...);

//   return qcor::submit([&, parameters](qcor::qpu_handler &qh) {

//     qh.execute(kernel, parameters);

//   });

// }



// // TaskInitiate just execute kernel with measurements (no params, rvalue kernel)

// template <typename QuantumKernel> Handle taskInitiate(QuantumKernel &&kernel) {

//   return taskInitiate(kernel);

// }



// // TaskInitiate just execute kernel with measurements (no params, rvalue kernel)

// template <typename QuantumKernel> Handle taskInitiate(QuantumKernel &kernel) {

//   auto function = qcor::__internal::getCompositeInstruction(kernel);

//   return qcor::submit([&](qcor::qpu_handler &qh) { qh.execute(kernel); });

// }



} // namespace qcor



#endif