restructure, add hadamard test, remove unneeded demos

namespace QCOR 

{

open Microsoft.Quantum.Intrinsic;

open Microsoft.Quantum.Convert;

open Microsoft.Quantum.Canon;

operation SWAP(q1 : Qubit, q2: Qubit) : Unit is Adj {

  CNOT(q1, q2);

  CNOT(q2, q1);

  CNOT(q1, q2);

}

operation IQFT(qq: Qubit[]): Unit {

  Message("Hello from Q# IQFT");

  for i in 0 .. Length(qq)/2 - 1 {

    SWAP(qq[i], qq[Length(qq)-i-1]);

  }

  for i in 0 .. Length(qq) - 2 {

    H(qq[i]);

    let j = i + 1;

    mutable y = i;

    repeat {

      let theta = -3.14159 / IntAsDouble(1 <<< (j-y));

      // Controlled R1 == CPhase

      Controlled R1([qq[j]], (theta, qq[y]));

      set y = y - 1;

    } until (y < 0);

  }

  H(qq[Length(qq) -1]);

}

}

 No newline at end of file

#include "qir_nisq_kernel_utils.hpp"

// Compile:

// qcor qft.qs qpe.cpp -shots 1024 -print-final-submission

qcor_import_qsharp_kernel(QCOR__IQFT);

// Typedef for the Oracle Kernel Function

using QPEOracleSignature = KernelSignature<qubit>;

__qpu__ void qpe(qreg q, QPEOracleSignature oracle) {

  // Extract the counting qubits and the state qubit

  auto counting_qubits = q.extract_range({0,3});

  auto state_qubit = q[3];

  // Put it in |1> eigenstate

  X(state_qubit);

  // Create uniform superposition on all 3 qubits

  H(counting_qubits);

  // run ctr-oracle operations

  for (auto i : range(counting_qubits.size())) {

    const int nbCalls = 1 << i;

    for (auto j : range(nbCalls)) {

      oracle.ctrl(counting_qubits[i], state_qubit);

    }

  }

  // Run Inverse QFT on counting qubits

  // Using the Q# Kernel (wrapped as a QCOR kernel)

  QCOR__IQFT(counting_qubits);

  // Measure the counting qubits

  Measure(counting_qubits);

}

// Oracle to consider

__qpu__ void oracle(qubit q) { T(q); }

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

  auto q = qalloc(4);

  qpe::print_kernel(q, oracle);

  // Run

  qpe(q, oracle);

  q.print();

}