Ejemplo n.º 1
0
        private string GenerateGateCode(ComputerModel model, Gate gate, int column, string indent, string defaultRegName = null)
        {
            Func<string, Gate, string> appendControlTarget = (string begin, Gate g) =>
            {
                if (g.Control.HasValue)
                {
                    string namedC = "control: ";
                    string namedT = "target: ";
                    if (g.Name != GateName.CNot)
                    {
                        namedC = "";
                        namedT = "";
                    }

                    if (g.Control.Value.Register == g.Target.Register)
                    {
                        return String.Format("{0}.{1}{4}{2}, {5}{3});",
                            GetRegName(g.Target.Register, defaultRegName),
                            begin,
                            g.Target.Offset,
                            g.Control.Value.Offset,
                            namedT,
                            namedC);
                    }
                    else
                    {
                        return String.Format("comp.{0}{5}{1}[{2}], {6}{3}[{4}]);",
                           begin,
                           GetRegName(g.Target.Register, defaultRegName),
                           g.Target.Offset,
                           GetRegName(g.Control.Value.Register, defaultRegName),
                           g.Control.Value.Offset,
                            namedT,
                            namedC);
                    }
                }
                else
                {
                    return String.Format("{0}.{1}{2});", GetRegName(g.Target.Register, defaultRegName), begin, g.Target.Offset);
                }
            };

            Func<string, string, Gate, RegisterRefModel[], string> appendMoreControls =
                (string begin, string beginComment, Gate g, RegisterRefModel[] controls) =>
                {

                    if (controls.All<RegisterRefModel>(x => x.Register == g.Target.Register)
                        && (g.Control == null || g.Control.Value.Register == g.Target.Register))
                    {
                        StringBuilder format = new StringBuilder(GetRegName(g.Target.Register, defaultRegName)).Append(".").Append(begin);
                        format.Append(g.Target.Offset);

                        if (g.Control.HasValue)
                        {
                            format.Append(", ").Append(g.Control.Value.Offset);
                        }

                        for (int i = 0; i < controls.Length; i++)
                        {
                            format.Append(", ").Append(controls[i].Offset);
                        }
                        format.Append(");");
                        format.Append("\t\t// ").Append(beginComment).Append("<target_bit>, ... <control_bits> ...)");
                        return format.ToString();
                    }
                    else
                    {
                        StringBuilder format = new StringBuilder("comp.").Append(begin);
                        format.Append(GetRegName(g.Target.Register, defaultRegName))
                            .Append("[").Append(g.Target.Offset).Append("]");

                        if (g.Control.HasValue)
                        {
                            format.Append(", ")
                                .Append(GetRegName(g.Control.Value.Register, defaultRegName)).Append("[")
                                .Append(g.Control.Value.Offset).Append("]");
                        }

                        for (int i = 0; i < controls.Length; i++)
                        {
                            format.Append(", ")
                                .Append(GetRegName(controls[i].Register, defaultRegName)).Append("[")
                                .Append(controls[i].Offset).Append("]");
                        }
                        format.Append(");");
                        format.Append("\t\t// ").Append(beginComment).Append("<target_bit>, ... <control_bits> ...)");
                        return format.ToString();
                    }
                };

            switch (gate.Name)
            {
                case GateName.Hadamard:
                    return appendControlTarget("Hadamard(", gate);
                case GateName.SigmaX:
                    return appendControlTarget("SigmaX(", gate);
                case GateName.SigmaY:
                    return appendControlTarget("SigmaY(", gate);
                case GateName.SigmaZ:
                    return appendControlTarget("SigmaZ(", gate);
                case GateName.SqrtX:
                    return appendControlTarget("SqrtX(", gate);
                case GateName.RotateX:
                    RotateXGate rx = gate as RotateXGate;
                    return appendControlTarget(String.Format("RotateX({0}, ", rx.Gamma), gate);
                case GateName.RotateY:
                    RotateYGate ry = gate as RotateYGate;
                    return appendControlTarget(String.Format("RotateY({0}, ", ry.Gamma), gate);
                case GateName.RotateZ:
                    RotateZGate rz = gate as RotateZGate;
                    return appendControlTarget(String.Format("RotateZ({0}, ", rz.Gamma), gate);
                case GateName.PhaseKick:
                    PhaseKickGate pk = gate as PhaseKickGate;
                    if (pk.Controls.Length > 0)
                    {
                        return appendMoreControls(
                            String.Format("PhaseKick({0}, ", pk.Gamma),
                            "PhaseKick(<gamma_value>, ",
                            gate,
                            pk.Controls);
                    }
                    else
                    {
                        return appendControlTarget(String.Format("PhaseKick({0}, ", pk.Gamma), gate);
                    }
                case GateName.PhaseScale:
                    PhaseScaleGate ps = gate as PhaseScaleGate;
                    return appendControlTarget(String.Format("PhaseScale({0}, ", ps.Gamma), gate);
                case GateName.CNot:
                    return appendControlTarget("CNot(", gate);
                case GateName.CPhaseShift:
                    CPhaseShiftGate cps = gate as CPhaseShiftGate;
                    if (cps.Controls.Length > 0)
                    {
                        return appendMoreControls(
                            String.Format("CPhaseShift({0}, ", cps.Dist),
                            "CPhaseShift(<phase_distance_value>, ",
                            gate,
                            cps.Controls);
                    }
                    else
                    {
                        return appendControlTarget(String.Format("CPhaseShift({0}, ", cps.Dist), gate);
                    }
                case GateName.InvCPhaseShift:
                    InvCPhaseShiftGate icps = gate as InvCPhaseShiftGate;
                    if (icps.Controls.Length > 0)
                    {
                        return appendMoreControls(
                            String.Format("InverseCPhaseShift({0}, ", icps.Dist),
                            "InverseCPhaseShift(<phase_distance_value>, ",
                            gate,
                            icps.Controls);
                    }
                    else
                    {
                        return appendControlTarget(String.Format("InverseCPhaseShift({0}, ", icps.Dist), gate);
                    }
                case GateName.Toffoli:
                    ToffoliGate t = gate as ToffoliGate;
                    return appendMoreControls(
                        "Toffoli(",
                        "Toffoli(",
                        gate,
                        t.Controls);
                case GateName.Measure:
                    MeasureGate m = gate as MeasureGate;
                    if (m.Begin == m.End)
                    {
                        return String.Format("{0}.Measure({1});", GetRegName(m.Target.Register, defaultRegName), m.Target.Offset);
                    }
                    else if (m.BeginRow.Register == m.EndRow.Register)
                    {
                        string regName = GetRegName(m.BeginRow.Register, defaultRegName);
                        if (m.BeginRow.Register != null)
                        {
                            if (m.End - m.Begin + 1 == m.BeginRow.Register.Qubits.Count)
                            {
                                return String.Format("{0}.Measure();", regName);
                            }
                            else
                            {
                                StringBuilder builder = new StringBuilder();
                                for (int i = m.BeginRow.Offset; i <= m.EndRow.Offset; i++)
                                {
                                    builder.AppendFormat("{0}.Measure({1});\n", regName, i);
                                }
                                return builder.ToString();
                            }
                        }
                        else
                        {
                            if (m.End - m.Begin + 1 == model.TotalWidth)
                            {
                                return String.Format("{0}.Measure();", regName);
                            }
                            else
                            {
                                StringBuilder builder = new StringBuilder();
                                for (int i = m.BeginRow.Offset; i <= m.EndRow.Offset; i++)
                                {
                                    builder.AppendFormat("{0}.Measure({1});\n", regName, i);
                                }
                                return builder.ToString();
                            }
                        }
                    }
                    else
                    {
                        StringBuilder builder = new StringBuilder();
                        int i = m.Begin;
                        while (i <= m.End)
                        {
                            RegisterRefModel regRef = model.GetRefFromOffset(i);
                            if (i + regRef.Register.Qubits.Count < m.End + 2)
                            {
                                builder.AppendFormat("{0}.Measure();\n", regRef.Register.Name);
                                i += regRef.Register.Qubits.Count;
                            }
                            else
                            {
                                builder.AppendFormat("{0}.Measure({1});\n", regRef.Register.Name, regRef.Offset);
                                i++;
                            }
                        }
                        return builder.ToString();
                    }
                case GateName.Unitary:
                    UnitaryGate u = gate as UnitaryGate;
                    string uMatrixName = "unitary_" + column + "_" + u.Target.OffsetToRoot;
                    string matrixDef = GenerateMatrixDefinition(uMatrixName, u.Matrix, indent);
                    string gateDef = appendControlTarget(String.Format("Gate1({0}, ", uMatrixName), gate);
                    return String.Format("{0}\n{1}{2}", matrixDef, indent, gateDef);
                case GateName.Parametric:
                    return GenerateParametricGateCode(gate as ParametricGate, defaultRegName);
                case GateName.Composite:
                    return GenerateCompositeGateCode(gate as CompositeGate, defaultRegName);
                case GateName.Empty:
                default:
                    return String.Empty;
            }
        }
Ejemplo n.º 2
0
 public void SetGate(Gate gate)
 {
     int beginRow = gate.Begin;
     int endRow = gate.End;
     for (int i = beginRow; i <= endRow; i++)
     {
         _gates[i] = gate;
     }
 }
Ejemplo n.º 3
0
        public void AddGate(Gate gate)
        {
            //StepModel currentStep = _steps.Count > 0 ? _steps[_steps.Count - 1] : null;
            //if (currentStep != null && currentStep.HasPlace(gate.Begin, gate.End))
            //{
            //    currentStep.SetGate(gate);
            //}
            //else
            //{

            if (_stepForNewGates == -1)
            {
                StepModel step = new StepModel(Registers);
                step.SetGate(gate);
                _steps.Add(step);
            }
            else
            {
                InsertStepRight(_stepForNewGates);
                _stepForNewGates++;
                _steps[_stepForNewGates].SetGate(gate);
            }

            //}
        }
Ejemplo n.º 4
0
        private Gate PasteGate(Gate gate, int referenceBeginRow)
        {
            RegisterRefModel targetRef = GetRefFromOffset(gate.Target.OffsetToRoot + referenceBeginRow);
            RegisterRefModel? controlRef = null;
            if (gate.Control.HasValue)
            {
                controlRef = GetRefFromOffset(gate.Control.Value.OffsetToRoot + referenceBeginRow);
            }

            switch (gate.Name)
            {
                case GateName.CNot:
                    return new CNotGate(targetRef, controlRef.Value);
                case GateName.Parametric:
                    return PasteParametricGate(gate as ParametricGate, referenceBeginRow);
                case GateName.Composite:
                    CompositeGate cg = gate as CompositeGate;
                    RegisterRefModel partEndRef = GetRefFromOffset(cg.TargetRegister.EndOffsetToRoot + referenceBeginRow);
                    if (partEndRef.Register.OffsetToRoot == targetRef.Register.OffsetToRoot)
                    {
                        RegisterPartModel target = new RegisterPartModel()
                        {
                            Register = targetRef.Register,
                            Offset = targetRef.Offset,
                            Width = cg.TargetRegister.Width
                        };
                        return new CompositeGate(cg.FunctionName, target);
                    }
                    else
                    {
                        RegisterPartModel target = new RegisterPartModel()
                        {
                            Register = null,
                            Offset = cg.TargetRegister.Offset + referenceBeginRow,
                            Width = cg.TargetRegister.Width
                        };
                        return new CompositeGate(cg.FunctionName, target);
                    }
                case GateName.CPhaseShift:
                    CPhaseShiftGate cps = gate as CPhaseShiftGate;
                    RegisterRefModel[] controls = cps.Controls.Select<RegisterRefModel, RegisterRefModel>(x =>
                        GetRefFromOffset(x.OffsetToRoot + referenceBeginRow)).ToArray<RegisterRefModel>();
                    return new CPhaseShiftGate(cps.Dist, targetRef, controls);
                case GateName.Empty:
                    return new EmptyGate(targetRef);
                case GateName.Hadamard:
                    return new HadamardGate(targetRef, controlRef);
                case GateName.InvCPhaseShift:
                    InvCPhaseShiftGate icps = gate as InvCPhaseShiftGate;
                    RegisterRefModel[] icontrols = icps.Controls.Select<RegisterRefModel, RegisterRefModel>(x =>
                        GetRefFromOffset(x.OffsetToRoot + referenceBeginRow)).ToArray<RegisterRefModel>();
                    return new InvCPhaseShiftGate(icps.Dist, targetRef, icontrols);
                case GateName.Measure:
                    MeasureGate mg = gate as MeasureGate;
                    RegisterRefModel beginRef = GetRefFromOffset(mg.Begin + referenceBeginRow);
                    RegisterRefModel endRef = GetRefFromOffset(mg.End + referenceBeginRow);
                    return new MeasureGate(beginRef, endRef);
                case GateName.PhaseKick:
                    PhaseKickGate pk = gate as PhaseKickGate;
                    RegisterRefModel[] controls1 = pk.Controls.Select<RegisterRefModel, RegisterRefModel>(x =>
                        GetRefFromOffset(x.OffsetToRoot + referenceBeginRow)).ToArray<RegisterRefModel>();
                    return new PhaseKickGate(pk.Gamma, targetRef, controls1);
                case GateName.PhaseScale:
                    PhaseScaleGate ps = gate as PhaseScaleGate;
                    return new PhaseScaleGate(ps.Gamma, targetRef, controlRef);
                case GateName.RotateX:
                    RotateXGate rx = gate as RotateXGate;
                    return new RotateXGate(rx.Gamma, targetRef, controlRef);
                case GateName.RotateY:
                    RotateYGate ry = gate as RotateYGate;
                    return new RotateYGate(ry.Gamma, targetRef, controlRef);
                case GateName.RotateZ:
                    RotateZGate rz = gate as RotateZGate;
                    return new RotateZGate(rz.Gamma, targetRef, controlRef);
                case GateName.SigmaX:
                    return new SigmaXGate(targetRef);
                case GateName.SigmaY:
                    return new SigmaYGate(targetRef, controlRef);
                case GateName.SigmaZ:
                    return new SigmaZGate(targetRef, controlRef);
                case GateName.SqrtX:
                    return new SqrtXGate(targetRef, controlRef);
                case GateName.Toffoli:
                    ToffoliGate t = gate as ToffoliGate;
                    RegisterRefModel[] tcontrols = t.Controls.Select<RegisterRefModel, RegisterRefModel>(x =>
                        GetRefFromOffset(x.OffsetToRoot + referenceBeginRow)).ToArray<RegisterRefModel>();
                    return new ToffoliGate(targetRef, tcontrols);
                case GateName.Unitary:
                    UnitaryGate u = gate as UnitaryGate;
                    return new UnitaryGate(u.Matrix, targetRef, controlRef);
                default:
                    return null;
            }
        }
Ejemplo n.º 5
0
 private void AddGate(Gate gate)
 {
     QuantumComputer comp = QuantumComputer.GetInstance();
     comp.AddGate(gate);
 }