Beispiel #1
0
        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);
            }
        }
Beispiel #2
0
        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);
            }
        }
Beispiel #3
0
        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);
            }
        }