public void TupleEmptyConstructor()
{
var NullOrEmptyQubits = new Action <IApplyData>((t) =>
{
var qubits = t.Qubits;
Assert.True(qubits == null || qubits?.Where(q => q != null).Count() == 0);
});
{
var actual = new Q();
Assert.Null(((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new I();
Assert.Equal(0L, ((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleA();
Assert.Equal(default((Int64, Pauli, Qubit, (Qubit, Int64, Qubit))), ((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleC();
Assert.Equal(default((Qubit, TupleB)), ((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleD();
Assert.Empty(((IApplyData)actual).Value as IQArray <Qubit>);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleE();
Assert.Equal(default((Int64, IQArray <Qubit>)), ((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleF();
Assert.Null(((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleH();
Assert.Equal(default((TupleD, TupleG)), ((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleI();
Assert.Null(((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleJ();
Assert.Empty(((IApplyData)actual).Value as IQArray <(Int64, Qubit)>);
NullOrEmptyQubits(actual);
}
}
public void TupleBasicConstructor()
{
var AssertQubitsCount = new Action <int, IApplyData>((count, t) =>
{
var qubits = t.Qubits;
if (count == 0)
{
Assert.True(qubits == null || qubits?.Where(q => q != null).Count() == 0);
}
else
{
Assert.Equal(count, qubits?.Where(q => q != null).Count());
}
});
var q0 = new FreeQubit(0) as Qubit;
var q1 = new FreeQubit(1) as Qubit;
var q2 = new FreeQubit(2) as Qubit;
{
var actual = new Q(q0);
Assert.Equal(q0, ((IApplyData)actual).Value);
AssertQubitsCount(1, actual);
}
{
var actual = new I(32L);
Assert.Equal(32L, ((IApplyData)actual).Value);
AssertQubitsCount(0, actual);
}
{
var data = (2L, Pauli.PauliY, q1, (q0, -7L, null as Qubit));
var actual = new TupleA(data);
Assert.Equal(data, ((IApplyData)actual).Value);
AssertQubitsCount(2, actual);
}
{
var data = (q1, new TupleB(((2L, 3L), (q1, (4L, (q0, q2)), 3.0))));
var actual = new TupleC(data);
Assert.Equal(data, ((IApplyData)actual).Value);
AssertQubitsCount(4, actual);
}
{
var data = new QArray <Qubit>(q1, q2, q0, q0, q1);
var actual = new TupleD(data);
Assert.Equal((IQArray <Qubit>)data, ((IApplyData)actual).Value);
AssertQubitsCount(5, actual);
}
{
var data = (5L, new QArray <Qubit>(q1, q2, q0));
var actual = new TupleE(data);
Assert.Equal((data.Item1, (IQArray <Qubit>)data.Item2), ((IApplyData)actual).Value);
AssertQubitsCount(3, actual);
}
{
var data = new UnitaryNoOp <(TupleA, TupleD)>();
var actual = new TupleF(data);
Assert.Equal(data, ((IApplyData)actual).Value);
AssertQubitsCount(0, actual);
}
{
var op = new UnitaryNoOp <(TupleA, TupleD)>();
var mapper = new Func <(TupleA, TupleD), (IQArray <Qubit>, (TupleA, TupleD))>((_arg) => (new QArray <Qubit>(q1, q2), _arg));
var data = op.Controlled.Partial(mapper);
var actual = new TupleF(data);
Assert.Equal(data, ((IApplyData)actual).Value);
AssertQubitsCount(2, actual);
}
{
var data = (new TupleD(new QArray <Qubit>(q1, q2, q0)), new TupleG());
var actual = new TupleH(data);
Assert.Equal(data, ((IApplyData)actual).Value);
AssertQubitsCount(3, actual);
}
{
var data = new QArray <(Int64, Qubit)>((1L, q1));
var actual = new TupleJ(data);
Assert.Equal((IQArray <(Int64, Qubit)>)data, ((IApplyData)actual).Value);
AssertQubitsCount(1, actual);
}
}
public void TupleEmptyConstructor()
{
var NullOrEmptyQubits = new Action <IApplyData>((t) =>
{
var qubits = t.Qubits;
Assert.True(qubits == null || qubits?.Where(q => q != null).Count() == 0);
});
{
var actual = new Q();
Assert.Null(((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new I();
Assert.Equal(0L, ((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleA();
Assert.Equal(default((Int64, Pauli, Qubit, (Qubit, Int64, Qubit))), ((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleC();
Assert.Equal((null as Qubit, new TupleB()), ((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleD();
Assert.Empty(((IApplyData)actual).Value as IQArray <Qubit>);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleE();
var value = ((IApplyData)actual).Value as (long, IQArray <Qubit>)?;
Assert.True(value.HasValue);
Assert.Equal(0, value.Value.Item1);
Assert.Equal(0, value.Value.Item2?.Length);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleF();
Assert.Null(((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleH();
var value = ((IApplyData)actual).Value as (TupleD, TupleG)?;
Assert.True(value.HasValue);
Assert.NotNull(value.Value.Item1);
Assert.NotNull(value.Value.Item2);
Assert.Equal(0, value.Value.Item1.Data?.Length);
Assert.Null(value.Value.Item2.Item1);
Assert.Equal(new TupleF(), value.Value.Item2.Item2);
Assert.Equal(new TupleC(), value.Value.Item2.Item3);
Assert.Equal(0, value.Value.Item2.Item4?.Data?.Length);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleI();
Assert.Null(((IApplyData)actual).Value);
NullOrEmptyQubits(actual);
}
{
var actual = new TupleJ();
Assert.Empty(((IApplyData)actual).Value as IQArray <(Int64, Qubit)>);
NullOrEmptyQubits(actual);
}
}