public void T13_AssertIsEigenstate()
{
using (var sim = new CounterSimulator())
{
sim.OnLog += (msg) => { Debug.WriteLine(msg); };
// First, test state/unitary pairs which are eigenstates.
// Neither pair should throw an exception, so we can test them all together.
try
{
TestAssertIsEigenstate_True.Run(sim).Wait();
}
catch (System.Exception e)
{
System.Console.WriteLine(e);
Xunit.Assert.False(true, "An exception should not have been thrown if the state was an eigenstate");
}
// Second, test pairs which are not eigenstates.
// Since each pair has to throw an exception, each pair has to be tested separately.
var Xgate = sim.Get <IAdjointable, X>();
var Ygate = sim.Get <IAdjointable, Y>();
var Zgate = sim.Get <IAdjointable, Z>();
var Hgate = sim.Get <IAdjointable, H>();
TestFailingAssertOnUnitaries(sim, Zgate, Hgate);
TestFailingAssertOnUnitaries(sim, Xgate, Xgate);
TestFailingAssertOnUnitaries(sim, Xgate, Zgate);
TestFailingAssertOnUnitaries(sim, Ygate, Hgate);
TestFailingAssertOnUnitaries(sim, Ygate, Xgate);
TestFailingAssertOnUnitaries(sim, Ygate, Zgate);
TestFailingAssertOnUnitaries(sim, Hgate, Xgate);
TestFailingAssertOnUnitaries(sim, Hgate, Zgate);
TestFailingAssertOnUnitaries(sim, Hgate, Hgate);
}
}
public void TestTarget(TestOperation op)
{
using (var sim = new CounterSimulator())
{
// OnLog defines action(s) performed when Q# test calls function Message
sim.OnLog += (msg) => { output.WriteLine(msg); };
sim.OnLog += (msg) => { Debug.WriteLine(msg); };
op.TestOperationRunner(sim);
}
}
public void TestTarget(TestOperation op)
{
using (var sim = new CounterSimulator())
{
// OnLog defines action(s) performed when Q# test calls function Message
sim.OnLog += (msg) => { output.WriteLine(msg); };
sim.OnLog += (msg) => { Debug.WriteLine(msg); };
var watch = System.Diagnostics.Stopwatch.StartNew();
op.TestOperationRunner(sim);
watch.Stop();
long ticks = watch.ElapsedTicks;
Console.WriteLine("Name: " + op.className + " RunTime: " + ticks);
}
}
public void Test(Instance instance)
{
var sim = new CounterSimulator();
var len = instance.Kernel.Count;
var saver = new List <IQArray <long> >();
for (int i = 0; i < len * 4; ++i)
{
var(vector, uf) = cs_helper.Run(sim, len, instance.ExtendedTransformation).Result;
Assert.Equal(1, sim.GetOperationCount(uf));
saver.Add(vector);
}
var matrix = new BooleanMatrix(saver);
var kernel = matrix.GetKernel();
Assert.Equal(instance.Kernel.Contains(true) ? 2 : 1, kernel.Count);
Assert.Contains(instance.Kernel, kernel);
}
static void Main()
{
int numTrials = 10;
int maxNumQubits = 23;
int numBVTests = 5;
Stopwatch s = new Stopwatch();
using (var sim = new CounterSimulator()) {
for (int numQubits = 1; numQubits < maxNumQubits; numQubits++)
{
// // DEUTSCH-JOSZA ////////////////////////////////////////////////////////////////
System.Console.WriteLine(String.Format("Testing with {0} qubits: ", numQubits));
// constant: f(x) = 0
s.Start();
for (int i = 0; i < numTrials; i++)
{
var r = DJ_Algorithm_F_0_Test.Run(sim, numQubits).Result;
}
s.Stop();
System.Console.WriteLine(String.Format("Time for f(x) = 0 averaged over {0} trials: {1}", numTrials, s.ElapsedMilliseconds));
s.Reset();
// constant: f(x) = 1
s.Start();
for (int i = 0; i < numTrials; i++)
{
var r = DJ_Algorithm_F_1_Test.Run(sim, numQubits).Result;
}
s.Stop();
System.Console.WriteLine(String.Format("Time for f(x) = 1 averaged over {0} trials: {1}", numTrials, s.ElapsedMilliseconds));
s.Reset();
// balanced: f(x) = 1 if x has odd number of 1s, 0 otherwise
s.Start();
for (int i = 0; i < numTrials; i++)
{
var r = DJ_Algorithm_OddNumberOfOnes_Test.Run(sim, numQubits).Result;
}
s.Stop();
System.Console.WriteLine(String.Format("Time for balanced f(x) (odd number ones) averaged over {0} trials: {1}", numTrials, s.ElapsedMilliseconds));
s.Reset();
// BERNSTEIN-VAZIRANI ////////////////////////////////////////////////////////////////
// test with many random f(x) = ax
Random rnd = new Random();
for (int j = 0; j < numBVTests; j++)
{
s.Start();
// generate random a
int n = rnd.Next(0, (int)Math.Pow(2, numQubits));
var a = IntArrFromPositiveInt.Run(sim, n, numQubits).Result;
for (int i = 0; i < numTrials; i++)
{
var r = BV_Algorithm_Test.Run(sim, a).Result;
}
s.Stop();
System.Console.WriteLine(String.Format("Time for BV with a = {2} averaged over {0} trials: {1}", numTrials, s.ElapsedMilliseconds, n));
s.Reset();
}
// test all possible f(x) = ax
for (int j = 0; j < Math.Pow(2, numQubits); j++)
{
s.Start();
var a = IntArrFromPositiveInt.Run(sim, j, numQubits).Result;
for (int i = 0; i < numTrials; i++)
{
var r = BV_Algorithm_Test.Run(sim, a).Result;
}
s.Stop();
System.Console.WriteLine(String.Format("Time for BV with a = {2} averaged over {0} trials: {1}", numTrials, s.ElapsedMilliseconds, j));
s.Reset();
}
}
}
}
