public void AllocateQubit2Test()
{
using (var sim = new QuantumSimulator())
{
try
{
IgnorableAssert.Disable();
QVoid res = sim.Execute <AllocateQubit2, QVoid, QVoid>(QVoid.Instance);
}
catch (ExecutionFailException)
{
StackFrame[] stackFrames = sim.CallStack;
// The following assumes that Assert is on Q# stack.
Assert.Equal(2, stackFrames.Length);
Assert.Equal("Microsoft.Quantum.Intrinsic.Assert", stackFrames[0].Callable.FullName);
Assert.Equal(namespacePrefix + "AllocateQubit2", stackFrames[1].Callable.FullName);
Assert.Equal(OperationFunctor.Body, stackFrames[0].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[1].Callable.Variant);
Assert.Equal(94, stackFrames[1].FailedLineNumber);
}
finally
{
IgnorableAssert.Enable();
}
}
}
public void AllocateQubit2Test()
{
using var sim = new QuantumSimulator();
try
{
IgnorableAssert.Disable();
QVoid res = sim.Execute <AllocateQubit2, QVoid, QVoid>(QVoid.Instance);
}
catch (ExecutionFailException)
{
var stackFrames = sim.CallStack;
// Make sure that the call stack isn't null before proceeding.
Assert.NotNull(stackFrames);
// The following assumes that Assert is on Q# stack.
Assert.Equal(2, stackFrames !.Length);
Assert.Equal("Microsoft.Quantum.Diagnostics.AssertMeasurement", stackFrames[0].Callable.FullName);
Assert.Equal(namespacePrefix + "AllocateQubit2", stackFrames[1].Callable.FullName);
Assert.Equal(OperationFunctor.Body, stackFrames[0].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[1].Callable.Variant);
Assert.Equal(94, stackFrames[1].FailedLineNumber);
}
finally
{
IgnorableAssert.Enable();
}
}
/// <summary>
/// Allocates numToAllocate new qubits.
/// </summary>
public virtual IQArray <Qubit> Allocate(long numToAllocate)
{
IgnorableAssert.Assert(numToAllocate >= 0, "Attempt to allocate negative number of qubits.");
if (numToAllocate < 0)
{
throw new ArgumentException("Attempt to allocate negative number of qubits.");
}
else if (numToAllocate == 0)
{
return(QArray <Qubit> .Create(0));
}
QArray <Qubit> result = QArray <Qubit> .Create(numToAllocate);
for (int i = 0; i < numToAllocate; i++)
{
result.Modify(i, AllocateOneQubit(usedOnlyForBorrowing: false));
if (result[i] == null)
{
for (int k = 0; k < i; k++)
{
Release(result[k]);
}
throw new NotEnoughQubits(numToAllocate, GetFreeQubitsCount());
}
}
return(result);
}
/// <summary>
/// Borrows a number of qubits. Chooses them from among already allocated ones.
/// Makes sure borrowed qubits are not on the exclusion list.
/// Exclusion list is supposed to contain qubits that can not be borrowed,
/// for example those, that are being used (or could be used) in the current context.
/// If there are not enough qubits to borrow, allocates new ones.
/// </summary>
public virtual IQArray <Qubit> Borrow(long numToBorrow, IEnumerable <Qubit> excludedQubitsSortedById) // Note, excluded could be an array of Ids for efficiency, if it is convenient for compiler.
{
IgnorableAssert.Assert(numToBorrow > 0, "Attempt to borrow zero qubits.");
if (numToBorrow <= 0)
{
throw new ArgumentException("Attempt to borrow zero qubits.");
}
if (DisableBorrowing)
{
return(Allocate(numToBorrow));
}
var result = QArray <Qubit> .Create(numToBorrow);
long numBorrowed = TryBorrow(numToBorrow, result, excludedQubitsSortedById);
if (numBorrowed < numToBorrow)
{ // Not enough qubits to borrow. Allocate what was not borrowed.
for (long i = numBorrowed; i < numToBorrow; i++)
{
result.Modify(i, AllocateOneQubit(usedOnlyForBorrowing: true));
if (result[(int)i] == null)
{
for (long k = numBorrowed; k < i; k++)
{
ReleaseOneQubit(result[(int)k], usedOnlyForBorrowing: true);
}
throw new NotEnoughQubits(numToBorrow, numBorrowed + GetFreeQubitsCount());
}
}
}
return(result);
}
public void SimpleRange()
{
Helper.RunWithMultipleSimulators((s) =>
{
IgnorableAssert.Disable();
try
{
//We have to call the method in the same thread for IgnorableAssert.Disable() to work
s.Get <SimpleRangeTest>().Apply(QVoid.Instance);
}
finally
{
IgnorableAssert.Enable();
}
var tracer = s.GetTracer <long>();
Assert.Equal(0, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (0L)));
Assert.Equal(0, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (1L)));
Assert.Equal(0, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (2L)));
Assert.Equal(0, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (3L)));
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (4L)));
Assert.Equal(0, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (5L)));
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (6L)));
Assert.Equal(0, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (7L)));
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (8L)));
Assert.Equal(0, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (9L)));
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (10L)));
Assert.Equal(0, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, (11L)));
});
}
protected virtual void DisableOneQubit(Qubit qubit)
{
// Note: Borrowed qubits cannot be disabled.
IgnorableAssert.Assert(qubits[qubit.Id] == Allocated, "Attempt to disable qubit that has not been allocated.");
qubits[qubit.Id] = Disabled;
numDisabledQubits++;
numAllocatedQubits--;
Debug.Assert(numAllocatedQubits >= 0);
}
/// <summary>
/// Makes sure the angle for a rotation or exp operation is not NaN or Infinity.
/// </summary>
static void CheckAngle(double angle)
{
IgnorableAssert.Assert(!(double.IsNaN(angle) || double.IsInfinity(angle)), "Invalid angle for rotation/exponentiation.");
if (double.IsNaN(angle))
{
throw new ArgumentOutOfRangeException("angle", "Angle can't be NaN.");
}
if (double.IsInfinity(angle))
{
throw new ArgumentOutOfRangeException("angle", "Angle can't be Infity.");
}
}
protected virtual void ReleaseOneQubit(Qubit qubit, bool usedOnlyForBorrowing)
{
long Occupied = (usedOnlyForBorrowing? AllocatedForBorrowing : Allocated);
IgnorableAssert.Assert(qubits[qubit.Id] == Occupied, "Attempt to free qubit that has not been allocated.");
if (qubits[qubit.Id] != Occupied)
{
throw new ArgumentException("Attempt to free qubit that has not been allocated.");
}
qubits[qubit.Id] = free;
free = qubit.Id;
numAllocatedQubits--;
Debug.Assert(numAllocatedQubits >= 0);
}
protected virtual void ReleaseOneQubit(Qubit qubit, bool usedOnlyForBorrowing)
{
if (qubits[qubit.Id] == Disabled)
{
// Nothing to do. It will stay disabled.
// Alternatively, we could mark is as None here.
}
else
{
long Occupied = (usedOnlyForBorrowing ? AllocatedForBorrowing : Allocated);
IgnorableAssert.Assert(qubits[qubit.Id] == Occupied, "Attempt to free qubit that has not been allocated.");
if (qubits[qubit.Id] != Occupied)
{
throw new ArgumentException("Attempt to free qubit that has not been allocated.");
}
qubits[qubit.Id] = free;
free = qubit.Id;
numAllocatedQubits--;
Debug.Assert(numAllocatedQubits >= 0);
}
}
