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

adding updated test example 



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

examples/temp_new_kernel/test.cpp

+102 −29
Original line number Diff line number Diff line
@@ -26,24 +26,14 @@ 
// translated to the following



// the functions will remain, just empty

void measure_bits(qreg q) {

void measure_qbits(qreg q) {

  void __internal_call_function_measure_qbits(qreg);

  __internal_call_function_measure_qbits(q);

  return;

}



void quantum_kernel(qreg q, double x) {

    return;

}



void z0z1(qreg q, double x) {

    return;

}



void check_adjoint(qreg q, double x) {

    return;

}



class measure_qbits : public qcor::QuantumKernel<measure_qbits, qreg> {

  friend class qcor::QuantumKernel<measure_qbits, qreg>;

class measure_qbits : public qcor::QuantumKernel<class measure_qbits, qreg> {

  friend class qcor::QuantumKernel<class measure_qbits, qreg>;



protected:

  void operator()(qreg q) {
@@ -81,9 +71,24 @@ public: 
  }

};



void measure_qbits(std::shared_ptr<qcor::CompositeInstruction> parent, qreg q) {

  class measure_qbits k(parent, q);

  return;

}



void __internal_call_function_measure_qbits(qreg q) {

  class measure_qbits k(q);

}



void quantum_kernel(qreg q, double x) {

  void __internal_call_function_quantum_kernel(qreg, double);

  __internal_call_function_quantum_kernel(q, x);

  return;

}



class quantum_kernel

    : public qcor::QuantumKernel<quantum_kernel, qreg, double> {

  friend class qcor::QuantumKernel<quantum_kernel, qreg, double>;

    : public qcor::QuantumKernel<class quantum_kernel, qreg, double> {

  friend class qcor::QuantumKernel<class quantum_kernel, qreg, double>;



protected:

  void operator()(qreg q, double t) {
@@ -105,17 +110,17 @@ public: 
  inline static const std::string kernel_name = "quantum_kernel";



  quantum_kernel(qreg q, double t)

      : QuantumKernel<quantum_kernel, qreg, double>(q, t) {}

      : qcor::QuantumKernel<quantum_kernel, qreg, double>(q, t) {}

  quantum_kernel(std::shared_ptr<qcor::CompositeInstruction> p, qreg q,

                 double t)

      : QuantumKernel<quantum_kernel, qreg, double>(p, q, t) {}

  quantum_kernel() : QuantumKernel<quantum_kernel, qreg, double>() {}

      : qcor::QuantumKernel<quantum_kernel, qreg, double>(p, q, t) {}

  quantum_kernel() : qcor::QuantumKernel<quantum_kernel, qreg, double>() {}



  virtual ~quantum_kernel() {

    if (disable_destructor) {

      return;

    }

    quantum::set_backend("qpp", 1024);

    quantum::set_backend("tnqvm", 1024);

    auto [q, t] = args_tuple;

    operator()(q, t);

    if (is_callable) {
@@ -124,7 +129,24 @@ public: 
  }

};



class z0z1 : public qcor::QuantumKernel<z0z1, qreg, double> {

void quantum_kernel(std::shared_ptr<qcor::CompositeInstruction> parent, qreg q,

                    double x) {

  class quantum_kernel k(parent, q, x);

  return;

}



void __internal_call_function_quantum_kernel(qreg q, double x) {

  class quantum_kernel k(q, x);

}



void z0z1(qreg q, double x) {

  void __internal_call_function_z0z1(qreg, double);

  __internal_call_function_z0z1(q, x);

  return;

}



class z0z1 : public qcor::QuantumKernel<class z0z1, qreg, double> {

  friend class qcor::QuantumKernel<class z0z1, qreg, double>;



protected:

  void operator()(qreg q, double t) {
@@ -162,7 +184,17 @@ public: 
  }

};



class check_adjoint : public qcor::QuantumKernel<check_adjoint, qreg, double> {

void __internal_call_function_z0z1(qreg q, double x) { class z0z1 k(q, x); }



void __check_adjoint(qreg q, double x) {

  void __internal_call_function_check_adjoint(qreg, double);

  __internal_call_function_check_adjoint(q, x);

  return;

}



class check_adjoint

    : public qcor::QuantumKernel<class check_adjoint, qreg, double> {

  friend class qcor::QuantumKernel<class check_adjoint, qreg, double>;



protected:

  void operator()(qreg q, double t) {
@@ -179,7 +211,6 @@ protected: 


    quantum_kernel(parent_kernel, q, t);

    quantum_kernel::adjoint(parent_kernel, q, t);

    std::cout << "check here\n" << parent_kernel->toString() << "\n";

    measure_qbits(parent_kernel, q);

  }
@@ -188,6 +219,9 @@ public: 


  check_adjoint(qreg q, double t)

      : QuantumKernel<check_adjoint, qreg, double>(q, t) {}

  check_adjoint(std::shared_ptr<qcor::CompositeInstruction> p, qreg q, double t)

      : qcor::QuantumKernel<check_adjoint, qreg, double>(p, q, t) {}

  check_adjoint() : qcor::QuantumKernel<check_adjoint, qreg, double>() {}



  virtual ~check_adjoint() {

    if (disable_destructor) {
@@ -197,13 +231,21 @@ public: 
    auto [q, t] = args_tuple;

    operator()(q, t);

    if (is_callable) {

      //   quantum::program = parent_kernel;

      std::cout << quantum::program->toString() << "\n";

      quantum::submit(q.results());

    }

  }

};



void __internal_call_function_check_adjoint(qreg q, double x) {

  class check_adjoint k(q, x);

}



template <typename... Args>

void test_passing_kernels(void (*quantum_kernel_call)(Args...), Args... args) {

  std::cout << "runnign at the end\n";

  quantum_kernel_call(args...);

}



int main() {

  auto q = qalloc(2);
@@ -220,4 +262,35 @@ int main() { 


  check_adjoint(v, 2.2);

  v.print();



  //   check_adjoint::print_kernel(std::cout, v, 2.2);



  auto xx = qalloc(2);

  test_passing_kernels(z0z1, xx, 2.2);

  xx.print();



  auto H = 5.907 - 2.1433 * qcor::X(0) * qcor::X(1) -

           2.1433 * qcor::Y(0) * qcor::Y(1) + .21829 * qcor::Z(0) -

           6.125 * qcor::Z(1);

  auto opt = qcor::createOptimizer("nlopt");

  auto vqe = qcor::createObjectiveFunction("vqe", quantum_kernel, H);

  std::cout << (*vqe)(xx, .59) << "\n";



  // Call taskInitiate, kick off optimization of the give

  // functor dependent on the ObjectiveFunction, async call

  auto handle = qcor::taskInitiate(

      vqe, opt,

      [&](const std::vector<double> x, std::vector<double> &dx) {

       auto e = (*vqe)(xx, x[0]);

        return e;

      },

      1);



  // Go do other work...



  // Query results when ready.

  auto results = qcor::sync(handle);



  // Print the optimal value.

  printf("<H> = %f\n", results.opt_val);

}
 
 No newline at end of file