private void Gates_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
Gate gate;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
int addIndex = e.NewStartingIndex;
foreach (object item in e.NewItems)
{
gate = item as Gate;
if (gate != null)
{
RegisterRefModel gateRow = _model.GetRefFromOffset(addIndex);
Gates.Insert(addIndex, new GateVM(_model, gateRow, _column));
for (int i = addIndex + 1; i < _gates.Count; i++)
{
_gates[i].UpdateRow(i);
}
if (_gates.Count == 2)
{
_gates[0].UpdateDeleteRowCommand(true);
_gates[1].UpdateDeleteRowCommand(true);
}
}
}
break;
case NotifyCollectionChangedAction.Replace:
foreach (object item in e.NewItems)
{
gate = item as Gate;
for (int i = gate.Begin; i <= gate.End; i++)
{
Gates[i].Refresh();
}
}
break;
case NotifyCollectionChangedAction.Remove:
int oldRow = e.OldStartingIndex;
foreach (object item in e.OldItems)
{
if (item is Gate)
{
Gates.RemoveAt(oldRow);
for (int i = oldRow; i < _gates.Count; i++)
{
_gates[i].UpdateRow(i);
}
if (_gates.Count == 1)
{
_gates[0].UpdateDeleteRowCommand(false);
}
}
}
break;
}
OnPropertyChanged("ScaleCenterY");
}
public GateVM(ComputerModel model, RegisterRefModel row, int column)
{
_model = model;
_row = row;
_column = column;
_model.StepChanged += _model_CurrentStepChanged;
}
public MultiControlledGate(RegisterRefModel target, RegisterRefModel control, params RegisterRefModel[] restControls)
{
_controls = new RegisterRefModel[restControls.Length + 1];
_controls[0] = control;
Array.Copy(restControls, 0, _controls, 1, restControls.Length);
_target = target;
}
public ulong Measure()
{
RegisterRefModel beginRef, endRef;
if (_model == null)
{
beginRef = _compModel.GetRefFromOffset(0);
endRef = _compModel.GetRefFromOffset(_register.Width - 1);
}
else
{
beginRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel
};
endRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + _register.Width - 1
};
}
MeasureGate gate = new MeasureGate(beginRef, endRef);
AddGate(gate);
return(_register.Measure());
}
public void InverseCPhaseShift(int dist, int target, params int[] controls)
{
Validate(target, "InverseCPhaseShift", "target");
for (int i = 0; i < controls.Length; i++)
{
Validate(controls[i], "InverseCPhaseShift", "controls[" + i + "]");
}
RegisterRefModel targetRef;
RegisterRefModel[] controlsRefs;
if (_model == null)
{
targetRef = _compModel.GetRefFromOffset(target);
controlsRefs = controls
.Select <int, RegisterRefModel>(x => _compModel.GetRefFromOffset(x))
.ToArray <RegisterRefModel>();
}
else
{
targetRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + target
};
controlsRefs = controls
.Select <int, RegisterRefModel>(x => new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + x
})
.ToArray <RegisterRefModel>();
}
InvCPhaseShiftGate gate = new InvCPhaseShiftGate(dist, targetRef, controlsRefs);
AddGate(gate);
}
public void Toffoli(int target, params int[] controls)
{
ValidateToffoli(controls);
Validate(target, "Toffoli", "target");
for (int i = 0; i < controls.Length; i++)
{
Validate(controls[i], "Toffoli", "controls[" + i + "]");
}
if (_model == null)
{
RegisterRefModel[] toffoliParams = controls
.Select <int, RegisterRefModel>(x => _compModel.GetRefFromOffset(x))
.ToArray <RegisterRefModel>();
ToffoliGate gate = new ToffoliGate(_compModel.GetRefFromOffset(target), toffoliParams);
AddGate(gate);
}
else
{
RegisterRefModel[] toffoliParams = controls
.Select <int, RegisterRefModel>(x => new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + x
})
.ToArray <RegisterRefModel>();
RegisterRefModel targetRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + target
};
ToffoliGate gate = new ToffoliGate(targetRef, toffoliParams);
AddGate(gate);
}
}
public void CNot(int target, int control)
{
Validate(target, "CNot", "target");
Validate(control, "CNot", "control");
RegisterRefModel controlRef, targetRef;
if (_model == null)
{
controlRef = _compModel.GetRefFromOffset(control);
targetRef = _compModel.GetRefFromOffset(target);
}
else
{
controlRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + control
};
targetRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + target
};
}
CNotGate gate = new CNotGate(targetRef, controlRef);
AddGate(gate);
}
private string GenerateParametricGateCode(ParametricGate cg, string defaultRegName = null)
{
Func <object, string> appendPar = x =>
{
StringBuilder builder = new StringBuilder();
if (x.GetType() == typeof(RegisterPartModel))
{
RegisterPartModel rm = (RegisterPartModel)x;
builder.Append(GetRegName(rm.Register, defaultRegName));
if (rm.Register == null || rm.Width != rm.Register.Qubits.Count)
{
builder.Append("[").Append(rm.Offset).Append(", ");
builder.Append(rm.Width).Append("]");
}
}
else if (x.GetType() == typeof(RegisterRefModel))
{
RegisterRefModel rrm = (RegisterRefModel)x;
builder.Append(GetRegName(rrm.Register, defaultRegName)).Append("[").Append(rrm.Offset).Append("]");
}
else
{
builder.Append(x.ToString());
}
return(builder.ToString());
};
StringBuilder sb = new StringBuilder("comp.").Append(cg.FunctionName).Append("(");
ParameterInfo[] infos = cg.Method.GetParameters();
for (int i = 1; i < cg.Parameters.Length; i++)
{
object par = cg.Parameters[i];
if (infos[i].GetCustomAttributes(typeof(ParamArrayAttribute), false).Length > 0)
{
IEnumerable pars = par as IEnumerable;
foreach (var item in pars)
{
sb.Append(", ");
sb.Append(appendPar(item));
}
}
else
{
if (i > 1)
{
sb.Append(", ");
}
sb.Append(appendPar(par));
}
}
sb.Append(");");
return(sb.ToString());
}
private string ValueToString(object value)
{
Type type = value.GetType();
if (type == typeof(RegisterRefModel))
{
RegisterRefModel rrm = (RegisterRefModel)value;
StringBuilder sb = new StringBuilder();
if (rrm.Register != null)
{
sb.Append(rrm.Register.Name);
}
else
{
sb.Append("root");
}
sb.Append("[").Append(rrm.Offset).Append("]");
return(sb.ToString());
}
if (type == typeof(RegisterPartModel))
{
RegisterPartModel rm = (RegisterPartModel)value;
if (rm.Register != null)
{
if (rm.Width == rm.Register.Qubits.Count)
{
return(rm.Register.Name);
}
else
{
StringBuilder sb = new StringBuilder();
sb.Append(rm.Register.Name);
sb.Append("[").Append(rm.Offset).Append(", ").Append(rm.Width).Append("]");
return(sb.ToString());
}
}
else
{
CircuitEvaluator eval = CircuitEvaluator.GetInstance();
int rootWidth = eval.RootRegister.Width;
if (rm.Width == rootWidth)
{
return("root");
}
else
{
StringBuilder sb = new StringBuilder();
sb.Append("root");
sb.Append("[").Append(rm.Offset).Append(", ").Append(rm.Width).Append("]");
return(sb.ToString());
}
}
}
return(value.ToString());
}
private ObservableCollection <GateVM> CreateGatesFromModel()
{
ObservableCollection <GateVM> gates = new ObservableCollection <GateVM>();
for (int i = 0; i < _model.Steps[_column].Gates.Count; i++)
{
Gate gate = _model.Steps[_column].Gates[i];
RegisterRefModel gateRow = _model.GetRefFromOffset(i);
gates.Add(new GateVM(_model, gateRow, _column));
}
return(gates);
}
public MeasureGate(RegisterRefModel beginRow, RegisterRefModel endRow)
{
if (beginRow.OffsetToRoot > endRow.OffsetToRoot)
{
_beginRow = endRow;
_endRow = beginRow;
}
else
{
_beginRow = beginRow;
_endRow = endRow;
}
}
public void Gate1(Complex[,] matrix, int target, int?control = null)
{
Validate(target, "Gate1", "target");
if (control.HasValue)
{
Validate(control.Value, "Gate1", "control");
}
ValidateMatrix(matrix, "Gate1", "matrix");
RegisterRefModel targetRef;
RegisterRefModel?controlRef;
if (control == null)
{
controlRef = null;
if (_model == null)
{
targetRef = _compModel.GetRefFromOffset(target);
}
else
{
targetRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + target
};
}
}
else
{
if (_model == null)
{
controlRef = _compModel.GetRefFromOffset(control.Value);
targetRef = _compModel.GetRefFromOffset(target);
}
else
{
controlRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + control.Value
};
targetRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + target
};
}
}
UnitaryGate gate = new UnitaryGate(matrix, targetRef, controlRef);
AddGate(gate);
}
public void SigmaX(int target, int?control = null)
{
Validate(target, "SigmaX", "target");
if (control.HasValue)
{
Validate(control.Value, "SigmaX", "control");
}
RegisterRefModel targetRef;
RegisterRefModel?controlRef;
if (control == null)
{
controlRef = null;
if (_model == null)
{
targetRef = _compModel.GetRefFromOffset(target);
}
else
{
targetRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + target
};
}
SigmaXGate gate = new SigmaXGate(targetRef);
AddGate(gate);
}
else
{
if (_model == null)
{
controlRef = _compModel.GetRefFromOffset(control.Value);
targetRef = _compModel.GetRefFromOffset(target);
}
else
{
controlRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + control.Value
};
targetRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + target
};
}
CNotGate gate = new CNotGate(targetRef, controlRef.Value);
AddGate(gate);
}
}
public void RotateZ(double gamma, int target, int?control = null)
{
Validate(target, "RotateZ", "target");
if (control.HasValue)
{
Validate(control.Value, "RotateZ", "control");
}
RegisterRefModel targetRef;
RegisterRefModel?controlRef;
if (control == null)
{
controlRef = null;
if (_model == null)
{
targetRef = _compModel.GetRefFromOffset(target);
}
else
{
targetRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + target
};
}
}
else
{
if (_model == null)
{
controlRef = _compModel.GetRefFromOffset(control.Value);
targetRef = _compModel.GetRefFromOffset(target);
}
else
{
controlRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + control.Value
};
targetRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + target
};
}
}
RotateZGate gate = new RotateZGate(gamma, targetRef, controlRef);
AddGate(gate);
}
//internal List<Gate> ChangeGatesContainer(List<Gate> newContainer)
//{
// List<Gate> prev = _gatesContainer;
// _gatesContainer = newContainer;
// return prev;
//}
internal RegisterRef ModelToRef(RegisterRefModel model)
{
if (model.Register != null)
{
return(new RegisterRef()
{
Register = _modelRefs[model.Register],
Offset = model.Offset
});
}
else
{
return(new RegisterRef()
{
Register = _parserRoot,
Offset = model.Offset
});
}
}
internal Quantum.RegisterRef ModelToSource(RegisterRefModel model)
{
if (model.Register != null)
{
return(new Quantum.RegisterRef()
{
Register = _modelRefs[model.Register].SourceRegister,
Offset = model.Offset
});
}
else
{
return(new Quantum.RegisterRef()
{
Register = _parserRoot.SourceRegister,
Offset = model.Offset
});
}
}
public byte Measure(int position)
{
Validate(position, "Measure", "position");
RegisterRefModel targetRef;
if (_model == null)
{
targetRef = _compModel.GetRefFromOffset(position);
}
else
{
targetRef = new RegisterRefModel()
{
Register = _model, Offset = _offsetToModel + position
};
}
MeasureGate gate = new MeasureGate(targetRef);
AddGate(gate);
return(_register.Measure(position));
}
public MultiControlledGate(RegisterRefModel target, params RegisterRefModel[] controls)
{
_controls = controls;
_target = target;
}
protected Tuple<RegisterRefModel, RegisterRefModel[]> CopyRefs(int referenceBeginRow)
{
RegisterRefModel targetRef = new RegisterRefModel()
{
Register = null,
Offset = _target.OffsetToRoot - referenceBeginRow
};
RegisterRefModel[] controls = _controls.Select<RegisterRefModel, RegisterRefModel>(x =>
new RegisterRefModel() { Register = null, Offset = x.OffsetToRoot - referenceBeginRow })
.ToArray<RegisterRefModel>();
return new Tuple<RegisterRefModel, RegisterRefModel[]>(targetRef, controls);
}
public void SqrtX(int target, int? control = null)
{
Validate(target, "SqrtX", "target");
if (control.HasValue)
{
Validate(control.Value, "SqrtX", "control");
}
RegisterRefModel targetRef;
RegisterRefModel? controlRef;
if (control == null)
{
controlRef = null;
if (_model == null)
{
targetRef = _compModel.GetRefFromOffset(target);
}
else
{
targetRef = new RegisterRefModel() { Register = _model, Offset = _offsetToModel + target };
}
}
else
{
if (_model == null)
{
controlRef = _compModel.GetRefFromOffset(control.Value);
targetRef = _compModel.GetRefFromOffset(target);
}
else
{
controlRef = new RegisterRefModel() { Register = _model, Offset = _offsetToModel + control.Value };
targetRef = new RegisterRefModel() { Register = _model, Offset = _offsetToModel + target };
}
}
SqrtXGate gate = new SqrtXGate(targetRef, controlRef);
AddGate(gate);
}
public CNotGate(RegisterRefModel target, RegisterRefModel control)
{
_control = control;
_target = target;
}
public void PhaseKick(double gamma, int target, params int[] controls)
{
Validate(target, "PhaseKick", "target");
for (int i = 0; i < controls.Length; i++)
{
Validate(controls[i], "PhaseKick", "controls[" + i + "]");
}
RegisterRefModel targetRef;
RegisterRefModel[] controlsRefs;
if (_model == null)
{
targetRef = _compModel.GetRefFromOffset(target);
controlsRefs = controls
.Select<int, RegisterRefModel>(x => _compModel.GetRefFromOffset(x))
.ToArray<RegisterRefModel>();
}
else
{
targetRef = new RegisterRefModel() { Register = _model, Offset = _offsetToModel + target };
controlsRefs = controls
.Select<int, RegisterRefModel>(x => new RegisterRefModel() { Register = _model, Offset = _offsetToModel + x })
.ToArray<RegisterRefModel>();
}
PhaseKickGate gate = new PhaseKickGate(gamma, targetRef, controlsRefs);
AddGate(gate);
}
public void UpdateRow(int offsetToRoot)
{
_row = _model.GetRefFromOffset(offsetToRoot);
Refresh();
}
public SigmaXGate(RegisterRefModel target)
: base(target)
{
}
protected Tuple<RegisterRefModel, RegisterRefModel?> CopyRefs(int referenceBeginRow)
{
RegisterRefModel targetRef = new RegisterRefModel() {
Register = null,
Offset = _target.OffsetToRoot - referenceBeginRow
};
RegisterRefModel? controlRef = null;
if (_control.HasValue)
{
controlRef = new RegisterRefModel()
{
Register = null,
Offset = _control.Value.OffsetToRoot - referenceBeginRow
};
}
return new Tuple<RegisterRefModel, RegisterRefModel?>(targetRef, controlRef);
}
public MeasureGate(RegisterRefModel row)
{
_beginRow = row;
_endRow = row;
}
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);
}
}
public override Gate Copy(int referenceBeginRow)
{
RegisterRefModel targetRef = new RegisterRefModel()
{
Register = null,
Offset = _target.OffsetToRoot - referenceBeginRow
};
RegisterRefModel controlRef = new RegisterRefModel()
{
Register = null,
Offset = _control.OffsetToRoot - referenceBeginRow
};
return new CNotGate(targetRef, controlRef);
}
public HadamardGate(RegisterRefModel target, RegisterRefModel? control = null)
: base(target, control)
{
}
public CPhaseShiftGate(int dist, RegisterRefModel target, params RegisterRefModel[] controls)
: base(target, controls)
{
_dist = dist;
}
public override Gate Copy(int referenceBeginRow)
{
RegisterRefModel beginRef = new RegisterRefModel()
{
Register = null,
Offset = _beginRow.OffsetToRoot - referenceBeginRow
};
RegisterRefModel endRef = new RegisterRefModel()
{
Register = null,
Offset = _endRow.OffsetToRoot - referenceBeginRow
};
return new MeasureGate(beginRef, endRef);
}
public PhaseKickGate(double gamma, RegisterRefModel target, params RegisterRefModel[] controls)
: base(target, controls)
{
_gamma = gamma;
}
public UnitaryGate(Complex[,] matrix, RegisterRefModel target, RegisterRefModel? control = null)
: base(target, control)
{
_matrix = matrix;
}
public override Gate Copy(int referenceBeginRow)
{
RegisterRefModel targetRef = new RegisterRefModel()
{
Register = null,
Offset = _row.OffsetToRoot - referenceBeginRow
};
return new EmptyGate(targetRef);
}
public void Toffoli(int target, params int[] controls)
{
ValidateToffoli(controls);
Validate(target, "Toffoli", "target");
for (int i = 0; i < controls.Length; i++)
{
Validate(controls[i], "Toffoli", "controls[" + i + "]");
}
if (_model == null)
{
RegisterRefModel[] toffoliParams = controls
.Select<int, RegisterRefModel>(x => _compModel.GetRefFromOffset(x))
.ToArray<RegisterRefModel>();
ToffoliGate gate = new ToffoliGate(_compModel.GetRefFromOffset(target), toffoliParams);
AddGate(gate);
}
else
{
RegisterRefModel[] toffoliParams = controls
.Select<int, RegisterRefModel>(x => new RegisterRefModel() { Register = _model, Offset = _offsetToModel + x })
.ToArray<RegisterRefModel>();
RegisterRefModel targetRef = new RegisterRefModel() { Register = _model, Offset = _offsetToModel + target };
ToffoliGate gate = new ToffoliGate(targetRef, toffoliParams);
AddGate(gate);
}
}
public PhaseScaleGate(double gamma, RegisterRefModel target, RegisterRefModel? control = null)
: base(gamma, target, control)
{
}
public void Delete()
{
if (_selectedItems.HasValue)
{
if (_selectedItems.Value.RowSpan == 1 && _selectedItems.Value.ColumnSpan == 1)
{
int column = _selectedItems.Value.BeginColumn;
int row = _selectedItems.Value.BeginRow;
Gate oldGate = _steps[column].Gates[row];
if (oldGate.Name != GateName.Empty)
{
for (int i = oldGate.Begin; i <= oldGate.End; i++)
{
RegisterRefModel gateRef = GetRefFromOffset(i);
Gate newGate = new EmptyGate(gateRef);
_steps[column].SetGate(newGate);
}
if (oldGate is MultiControlledGate)
{
MultiControlledGate mcg = oldGate as MultiControlledGate;
RegisterRefModel rowRef = GetRefFromOffset(row);
if (mcg.Controls.Contains<RegisterRefModel>(rowRef))
{
RegisterRefModel[] toRemove = new RegisterRefModel[] { rowRef };
RegisterRefModel[] newControls = mcg.Controls.Except<RegisterRefModel>(toRemove).ToArray();
Gate toAdd = null;
if (oldGate.Name == GateName.PhaseKick)
{
PhaseKickGate pk = oldGate as PhaseKickGate;
toAdd = new PhaseKickGate(pk.Gamma, pk.Target, newControls);
}
else if (oldGate.Name == GateName.CPhaseShift)
{
CPhaseShiftGate cps = oldGate as CPhaseShiftGate;
toAdd = new CPhaseShiftGate(cps.Dist, cps.Target, newControls);
}
else if (oldGate.Name == GateName.InvCPhaseShift)
{
InvCPhaseShiftGate icps = oldGate as InvCPhaseShiftGate;
toAdd = new InvCPhaseShiftGate(icps.Dist, icps.Target, newControls);
}
else // Toffoli
{
if (newControls.Length > 1)
{
toAdd = new ToffoliGate(oldGate.Target, newControls);
}
else
{
toAdd = new CNotGate(oldGate.Target, newControls[0]);
}
}
_steps[column].SetGate(toAdd);
}
}
else if (oldGate.Name == GateName.CNot)
{
if (oldGate.Control.Value.OffsetToRoot == row)
{
Gate toAdd = new SigmaXGate(oldGate.Target);
_steps[column].SetGate(toAdd);
}
}
else if (oldGate is SingleGate)
{
SingleGate sg = oldGate as SingleGate;
if (sg.Control.HasValue)
{
if (sg.Control.Value.OffsetToRoot == row)
{
Gate toAdd = null;
switch (sg.Name)
{
case GateName.Hadamard:
toAdd = new HadamardGate(sg.Target);
break;
case GateName.PhaseScale:
toAdd = new PhaseScaleGate((sg as PhaseScaleGate).Gamma, sg.Target);
break;
case GateName.RotateX:
toAdd = new RotateXGate((sg as RotateXGate).Gamma, sg.Target);
break;
case GateName.RotateY:
toAdd = new RotateYGate((sg as RotateYGate).Gamma, sg.Target);
break;
case GateName.RotateZ:
toAdd = new RotateZGate((sg as RotateZGate).Gamma, sg.Target);
break;
case GateName.SigmaX:
toAdd = new SigmaXGate(sg.Target);
break;
case GateName.SigmaY:
toAdd = new SigmaYGate(sg.Target);
break;
case GateName.SigmaZ:
toAdd = new SigmaZGate(sg.Target);
break;
case GateName.SqrtX:
toAdd = new SqrtXGate(sg.Target);
break;
case GateName.Unitary:
toAdd = new UnitaryGate((sg as UnitaryGate).Matrix, sg.Target);
break;
default:
break;
}
_steps[column].SetGate(toAdd);
}
}
}
}
}
else
{
for (int i = _selectedItems.Value.BeginColumn; i <= _selectedItems.Value.EndColumn; i++)
{
for (int j = _selectedItems.Value.BeginRow; j <= _selectedItems.Value.EndRow; j++)
{
Gate oldGate = _steps[i].Gates[j];
for (int k = oldGate.Begin; k <= oldGate.End; k++)
{
RegisterRefModel gateRef = GetRefFromOffset(k);
Gate newGate = new EmptyGate(gateRef);
_steps[i].SetGate(newGate);
}
j = oldGate.End;
}
}
}
}
}
public SingleGate(RegisterRefModel target, RegisterRefModel? control = null)
{
_control = control;
_target = target;
}
public SigmaZGate(RegisterRefModel target, RegisterRefModel? control = null)
: base(target, control)
{
}
public AngleGate(double gamma, RegisterRefModel target, RegisterRefModel? control = null)
: base(target, control)
{
_gamma = gamma;
}
public ToffoliGate(RegisterRefModel target, params RegisterRefModel[] controls)
: base(target, controls)
{
}
public void SetGate(int pressedColumn, RegisterRefModel pressedRow, DragDropKeyStates keyStates)
{
ActionName action = HomeVM.SelectedAction;
Gate oldGate;
// make selection
if (keyStates.HasFlag(DragDropKeyStates.ShiftKey))
{
// move selection
if (keyStates.HasFlag(DragDropKeyStates.ControlKey))
{
if (_model.IsSelected(pressedRow.OffsetToRoot, pressedColumn))
{
_model.Cut();
_model.Select(_row.OffsetToRoot, _row.OffsetToRoot, _column, _column);
_model.Paste();
}
}
else
{
_model.Select(pressedRow.OffsetToRoot, _row.OffsetToRoot, pressedColumn, _column);
}
}
else
{
switch (action)
{
case ActionName.Empty:
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (oldGate.Name != GateName.Empty)
{
for (int i = oldGate.Begin; i <= oldGate.End; i++)
{
RegisterRefModel gateRef = _model.GetRefFromOffset(i);
Gate newGate = new EmptyGate(gateRef);
_model.Steps[_column].SetGate(newGate);
}
if (oldGate is MultiControlledGate)
{
MultiControlledGate mcg = oldGate as MultiControlledGate;
if (mcg.Controls.Contains<RegisterRefModel>(_row))
{
RegisterRefModel[] toRemove = new RegisterRefModel[] { _row };
RegisterRefModel[] newControls = mcg.Controls.Except<RegisterRefModel>(toRemove).ToArray();
Gate toAdd = null;
if (oldGate.Name == GateName.PhaseKick)
{
PhaseKickGate pk = oldGate as PhaseKickGate;
toAdd = new PhaseKickGate(pk.Gamma, pk.Target, newControls);
}
else if (oldGate.Name == GateName.CPhaseShift)
{
CPhaseShiftGate cps = oldGate as CPhaseShiftGate;
toAdd = new CPhaseShiftGate(cps.Dist, cps.Target, newControls);
}
else if (oldGate.Name == GateName.InvCPhaseShift)
{
InvCPhaseShiftGate icps = oldGate as InvCPhaseShiftGate;
toAdd = new InvCPhaseShiftGate(icps.Dist, icps.Target, newControls);
}
else // Toffoli
{
if (newControls.Length > 1)
{
toAdd = new ToffoliGate(oldGate.Target, newControls);
}
else
{
toAdd = new CNotGate(oldGate.Target, newControls[0]);
}
}
_model.Steps[_column].SetGate(toAdd);
}
}
else if (oldGate.Name == GateName.CNot)
{
if (oldGate.Control.Value.OffsetToRoot == _row.OffsetToRoot)
{
Gate toAdd = new SigmaXGate(oldGate.Target);
_model.Steps[_column].SetGate(toAdd);
}
}
else if (oldGate is SingleGate)
{
SingleGate sg = oldGate as SingleGate;
if (sg.Control.HasValue)
{
if (sg.Control.Value.OffsetToRoot == _row.OffsetToRoot)
{
Gate toAdd = null;
switch (sg.Name)
{
case GateName.Hadamard:
toAdd = new HadamardGate(sg.Target);
break;
case GateName.PhaseScale:
toAdd = new PhaseScaleGate((sg as PhaseScaleGate).Gamma, sg.Target);
break;
case GateName.RotateX:
toAdd = new RotateXGate((sg as RotateXGate).Gamma, sg.Target);
break;
case GateName.RotateY:
toAdd = new RotateYGate((sg as RotateYGate).Gamma, sg.Target);
break;
case GateName.RotateZ:
toAdd = new RotateZGate((sg as RotateZGate).Gamma, sg.Target);
break;
case GateName.SigmaX:
toAdd = new SigmaXGate(sg.Target);
break;
case GateName.SigmaY:
toAdd = new SigmaYGate(sg.Target);
break;
case GateName.SigmaZ:
toAdd = new SigmaZGate(sg.Target);
break;
case GateName.SqrtX:
toAdd = new SqrtXGate(sg.Target);
break;
case GateName.Unitary:
toAdd = new UnitaryGate((sg as UnitaryGate).Matrix, sg.Target);
break;
default:
break;
}
_model.Steps[_column].SetGate(toAdd);
}
}
}
}
break;
case ActionName.Hadamard:
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (oldGate.Name == GateName.Empty)
{
_model.Steps[_column].SetGate(new HadamardGate(_row));
_model.AddStepAfter(_column);
}
break;
case ActionName.SigmaX:
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (oldGate.Name == GateName.Empty)
{
_model.Steps[_column].SetGate(new SigmaXGate(_row));
_model.AddStepAfter(_column);
}
break;
case ActionName.SigmaY:
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (oldGate.Name == GateName.Empty)
{
_model.Steps[_column].SetGate(new SigmaYGate(_row));
_model.AddStepAfter(_column);
}
break;
case ActionName.SigmaZ:
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (oldGate.Name == GateName.Empty)
{
_model.Steps[_column].SetGate(new SigmaZGate(_row));
_model.AddStepAfter(_column);
}
break;
case ActionName.SqrtX:
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (oldGate.Name == GateName.Empty)
{
_model.Steps[_column].SetGate(new SqrtXGate(_row));
_model.AddStepAfter(_column);
}
break;
case ActionName.RotateX:
case ActionName.RotateY:
case ActionName.RotateZ:
case ActionName.PhaseKick:
case ActionName.PhaseScale:
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (oldGate.Name == GateName.Empty)
{
MainWindow window = App.Current.MainWindow as MainWindow;
GammaInputVM gammmaVM = new GammaInputVM();
ICustomContentDialog dialog = window.DialogManager.CreateCustomContentDialog(new GammaInput(gammmaVM), DialogMode.OkCancel);
dialog.Ok = () =>
{
double gamma = gammmaVM.Gamma;
if (action == ActionName.RotateX)
{
_model.Steps[_column].SetGate(new RotateXGate(gamma, _row));
_model.AddStepAfter(_column);
}
else if (action == ActionName.RotateY)
{
_model.Steps[_column].SetGate(new RotateYGate(gamma, _row));
_model.AddStepAfter(_column);
}
else if (action == ActionName.RotateZ)
{
_model.Steps[_column].SetGate(new RotateZGate(gamma, _row));
_model.AddStepAfter(_column);
}
else if (action == ActionName.PhaseKick)
{
_model.Steps[_column].SetGate(new PhaseKickGate(gamma, _row));
_model.AddStepAfter(_column);
}
else
{
_model.Steps[_column].SetGate(new PhaseScaleGate(gamma, _row));
_model.AddStepAfter(_column);
}
};
dialog.Show();
}
break;
case ActionName.Unitary:
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (oldGate.Name == GateName.Empty)
{
MainWindow window1 = App.Current.MainWindow as MainWindow;
MatrixInputVM matrixVM = new MatrixInputVM();
ICustomContentDialog dialog1 = window1.DialogManager.CreateCustomContentDialog(new MatrixInput(matrixVM), DialogMode.OkCancel);
dialog1.Ok = () =>
{
Complex[,] matrix = matrixVM.Matrix;
if (matrix != null)
{
_model.Steps[_column].SetGate(new UnitaryGate(matrix, _row));
_model.AddStepAfter(_column);
}
};
dialog1.Show();
}
break;
case ActionName.Control:
if (pressedColumn == _column)
{
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (!_row.Equals(pressedRow))
{
if (oldGate.Name == GateName.CNot)
{
CNotGate oldCnot = oldGate as CNotGate;
if (pressedRow.OffsetToRoot < oldGate.Begin)
{
if (_model.Steps[_column].HasPlace(pressedRow.OffsetToRoot, oldGate.Begin - 1))
{
_model.Steps[_column].SetGate(new ToffoliGate(oldCnot.Target, oldCnot.Control.Value, pressedRow));
}
}
else if (pressedRow.OffsetToRoot > oldGate.End)
{
if (_model.Steps[_column].HasPlace(oldGate.End + 1, pressedRow.OffsetToRoot))
{
_model.Steps[_column].SetGate(new ToffoliGate(oldCnot.Target, oldCnot.Control.Value, pressedRow));
}
}
else // new Control inside
{
//check if not doubled
if (_row.OffsetToRoot != oldCnot.Target.OffsetToRoot &&
_row.OffsetToRoot != oldCnot.Control.Value.OffsetToRoot)
{
_model.Steps[_column].SetGate(new ToffoliGate(oldCnot.Target, oldCnot.Control.Value, _row));
}
}
}
else if (oldGate.Name == GateName.Toffoli)
{
ToffoliGate oldT = oldGate as ToffoliGate;
if (pressedRow.OffsetToRoot < oldGate.Begin)
{
if (_model.Steps[_column].HasPlace(pressedRow.OffsetToRoot, oldGate.Begin - 1))
{
_model.Steps[_column].SetGate(new ToffoliGate(oldT.Target, pressedRow, oldT.Controls));
}
}
else if (pressedRow.OffsetToRoot > oldGate.End)
{
if (_model.Steps[_column].HasPlace(oldGate.End + 1, pressedRow.OffsetToRoot))
{
_model.Steps[_column].SetGate(new ToffoliGate(oldT.Target, pressedRow, oldT.Controls));
}
}
else // new Control inside
{
//check if not doubled
if (_row.OffsetToRoot != oldT.Target.OffsetToRoot &&
!oldT.Controls.Contains<RegisterRefModel>(_row))
{
_model.Steps[_column].SetGate(new ToffoliGate(oldT.Target, _row, oldT.Controls));
}
}
}
else if (oldGate.Name == GateName.CPhaseShift)
{
CPhaseShiftGate oldT = oldGate as CPhaseShiftGate;
if (pressedRow.OffsetToRoot < oldGate.Begin)
{
if (_model.Steps[_column].HasPlace(pressedRow.OffsetToRoot, oldGate.Begin - 1))
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(pressedRow);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new CPhaseShiftGate(oldT.Dist, oldT.Target, cParams));
}
}
else if (pressedRow.OffsetToRoot > oldGate.End)
{
if (_model.Steps[_column].HasPlace(oldGate.End + 1, pressedRow.OffsetToRoot))
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(pressedRow);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new CPhaseShiftGate(oldT.Dist, oldT.Target, cParams));
}
}
else // new Control inside
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(_row);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new CPhaseShiftGate(oldT.Dist, oldT.Target, cParams));
}
}
else if (oldGate.Name == GateName.InvCPhaseShift)
{
InvCPhaseShiftGate oldT = oldGate as InvCPhaseShiftGate;
if (pressedRow.OffsetToRoot < oldGate.Begin)
{
if (_model.Steps[_column].HasPlace(pressedRow.OffsetToRoot, oldGate.Begin - 1))
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(pressedRow);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new InvCPhaseShiftGate(oldT.Dist, oldT.Target, cParams));
}
}
else if (pressedRow.OffsetToRoot > oldGate.End)
{
if (_model.Steps[_column].HasPlace(oldGate.End + 1, pressedRow.OffsetToRoot))
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(pressedRow);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new InvCPhaseShiftGate(oldT.Dist, oldT.Target, cParams));
}
}
else // new Control inside
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(_row);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new InvCPhaseShiftGate(oldT.Dist, oldT.Target, cParams));
}
}
else if (oldGate.Name == GateName.PhaseKick)
{
PhaseKickGate oldT = oldGate as PhaseKickGate;
if (pressedRow.OffsetToRoot < oldGate.Begin)
{
if (_model.Steps[_column].HasPlace(pressedRow.OffsetToRoot, oldGate.Begin - 1))
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(pressedRow);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new PhaseKickGate(oldT.Gamma, oldT.Target, cParams));
}
}
else if (pressedRow.OffsetToRoot > oldGate.End)
{
if (_model.Steps[_column].HasPlace(oldGate.End + 1, pressedRow.OffsetToRoot))
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(pressedRow);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new PhaseKickGate(oldT.Gamma, oldT.Target, cParams));
}
}
else // new Control inside
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(_row);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new PhaseKickGate(oldT.Gamma, oldT.Target, cParams));
}
}
else if (oldGate.Control == null)
{
int lastEmptyRow = _row.OffsetToRoot - 1;
if (pressedRow.OffsetToRoot > _row.OffsetToRoot)
{
lastEmptyRow = lastEmptyRow + 2;
}
if (_model.Steps[_column].HasPlace(pressedRow.OffsetToRoot, lastEmptyRow))
{
switch (oldGate.Name)
{
case GateName.Hadamard:
_model.Steps[_column].SetGate(new HadamardGate(_row, pressedRow));
break;
case GateName.PhaseScale:
PhaseScaleGate oldPs = oldGate as PhaseScaleGate;
_model.Steps[_column].SetGate(new PhaseScaleGate(oldPs.Gamma, _row, pressedRow));
break;
case GateName.RotateX:
RotateXGate oldRx = oldGate as RotateXGate;
_model.Steps[_column].SetGate(new RotateXGate(oldRx.Gamma, _row, pressedRow));
break;
case GateName.RotateY:
RotateYGate oldRy = oldGate as RotateYGate;
_model.Steps[_column].SetGate(new RotateYGate(oldRy.Gamma, _row, pressedRow));
break;
case GateName.RotateZ:
RotateZGate oldRz = oldGate as RotateZGate;
_model.Steps[_column].SetGate(new RotateZGate(oldRz.Gamma, _row, pressedRow));
break;
case GateName.SigmaX:
_model.Steps[_column].SetGate(new CNotGate(_row, pressedRow));
break;
case GateName.SigmaY:
_model.Steps[_column].SetGate(new SigmaYGate(_row, pressedRow));
break;
case GateName.SigmaZ:
_model.Steps[_column].SetGate(new SigmaZGate(_row, pressedRow));
break;
case GateName.SqrtX:
_model.Steps[_column].SetGate(new SqrtXGate(_row, pressedRow));
break;
case GateName.Unitary:
UnitaryGate oldU = oldGate as UnitaryGate;
_model.Steps[_column].SetGate(new UnitaryGate(oldU.Matrix, _row, pressedRow));
break;
case GateName.Empty:
_model.Steps[_column].SetGate(new CNotGate(_row, pressedRow));
_model.AddStepAfter(_column);
break;
default:
break;
}
}
}
}
else // add control inside (only CNot or Toffoli)
{
if (oldGate.Name == GateName.CNot)
{
CNotGate oldCnot = oldGate as CNotGate;
//check if not doubled
if (_row.OffsetToRoot != oldCnot.Target.OffsetToRoot &&
_row.OffsetToRoot != oldCnot.Control.Value.OffsetToRoot)
{
_model.Steps[_column].SetGate(new ToffoliGate(oldCnot.Target, _row, oldCnot.Control.Value));
}
}
else if (oldGate.Name == GateName.Toffoli)
{
ToffoliGate oldT = oldGate as ToffoliGate;
//check if not doubled
if (_row.OffsetToRoot != oldT.Target.OffsetToRoot &&
!oldT.Controls.Contains<RegisterRefModel>(_row))
{
_model.Steps[_column].SetGate(new ToffoliGate(oldT.Target, _row, oldT.Controls));
}
}
else if (oldGate.Name == GateName.CPhaseShift)
{
CPhaseShiftGate oldT = oldGate as CPhaseShiftGate;
//check if not doubled
if (_row.OffsetToRoot != oldT.Target.OffsetToRoot &&
!oldT.Controls.Contains<RegisterRefModel>(_row))
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(_row);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new CPhaseShiftGate(oldT.Dist, oldT.Target, cParams));
}
}
else if (oldGate.Name == GateName.InvCPhaseShift)
{
InvCPhaseShiftGate oldT = oldGate as InvCPhaseShiftGate;
//check if not doubled
if (_row.OffsetToRoot != oldT.Target.OffsetToRoot &&
!oldT.Controls.Contains<RegisterRefModel>(_row))
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(_row);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new InvCPhaseShiftGate(oldT.Dist, oldT.Target, cParams));
}
}
else if (oldGate.Name == GateName.PhaseKick)
{
PhaseKickGate oldT = oldGate as PhaseKickGate;
//check if not doubled
if (_row.OffsetToRoot != oldT.Target.OffsetToRoot &&
!oldT.Controls.Contains<RegisterRefModel>(_row))
{
List<RegisterRefModel> cList = oldT.Controls.ToList<RegisterRefModel>();
cList.Add(_row);
RegisterRefModel[] cParams = cList.ToArray<RegisterRefModel>();
_model.Steps[_column].SetGate(new PhaseKickGate(oldT.Gamma, oldT.Target, cParams));
}
}
}
}
break;
case ActionName.CPhaseShift:
if (pressedColumn == _column)
{
if (_model.Steps[_column].HasPlace(pressedRow.OffsetToRoot, _row.OffsetToRoot))
{
MainWindow window1 = App.Current.MainWindow as MainWindow;
PhaseDistInputVM vm = new PhaseDistInputVM();
vm.DistText = Math.Abs(pressedRow.OffsetToRoot - _row.OffsetToRoot).ToString();
ICustomContentDialog dialog1 = window1.DialogManager.CreateCustomContentDialog(
new PhaseDistInput(vm), DialogMode.OkCancel);
dialog1.Ok = () =>
{
int? dist = vm.Dist;
if (dist.HasValue)
{
if (_row.Equals(pressedRow))
{
_model.Steps[_column].SetGate(new CPhaseShiftGate(dist.Value, _row));
}
else
{
_model.Steps[_column].SetGate(new CPhaseShiftGate(dist.Value, _row, pressedRow));
}
_model.AddStepAfter(_column);
}
};
dialog1.Show();
}
}
break;
case ActionName.InvCPhaseShift:
if (pressedColumn == _column)
{
if (_model.Steps[_column].HasPlace(pressedRow.OffsetToRoot, _row.OffsetToRoot))
{
MainWindow window1 = App.Current.MainWindow as MainWindow;
PhaseDistInputVM vm = new PhaseDistInputVM();
vm.DistText = Math.Abs(pressedRow.OffsetToRoot - _row.OffsetToRoot).ToString();
ICustomContentDialog dialog1 = window1.DialogManager.CreateCustomContentDialog(
new PhaseDistInput(vm), DialogMode.OkCancel);
dialog1.Ok = () =>
{
int? dist = vm.Dist;
if (dist.HasValue)
{
if (_row.Equals(pressedRow))
{
_model.Steps[_column].SetGate(new InvCPhaseShiftGate(dist.Value, _row));
}
else
{
_model.Steps[_column].SetGate(new InvCPhaseShiftGate(dist.Value, _row, pressedRow));
}
_model.AddStepAfter(_column);
}
};
dialog1.Show();
}
}
break;
case ActionName.Measure:
if (pressedColumn == _column)
{
if (_model.Steps[_column].HasPlace(pressedRow.OffsetToRoot, _row.OffsetToRoot))
{
_model.Steps[_column].SetGate(new MeasureGate(pressedRow, _row));
_model.AddStepAfter(_column);
}
}
break;
case ActionName.Ungroup:
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (oldGate.Name == GateName.Parametric)
{
CircuitEvaluator eval = CircuitEvaluator.GetInstance();
//eval.InitFromModel(_model);
try
{
_model.SetStepForGates(_column);
int oldColumns = _model.Steps.Count;
int oldBegin = oldGate.Begin;
int oldEnd = oldGate.End;
eval.Decompose(oldGate as ParametricGate);
int columnsAdded = _model.Steps.Count - oldColumns;
_model.ResetStepForGates();
//remove old composite gate
for (int i = oldGate.Begin; i <= oldGate.End; i++)
{
RegisterRefModel gateRef = _model.GetRefFromOffset(i);
Gate newGate = new EmptyGate(gateRef);
_model.Steps[_column].SetGate(newGate);
}
//delete step on _column (if it is empty)
bool isEmpty = true;
int j = 0;
while (isEmpty && j < _model.Steps[_column].Gates.Count)
{
if (_model.Steps[_column].Gates[j].Name != GateName.Empty)
{
isEmpty = false;
}
j++;
}
if (isEmpty)
{
_model.DeleteStep(_column);
_model.Select(oldBegin, oldEnd, _column, _column + columnsAdded - 1);
}
else
{
_model.Select(oldBegin, oldEnd, _column + 1, _column + columnsAdded);
}
}
catch (Exception ex)
{
string msg = "Unable to ungroup gate. Its parameters are invalid.\n" +
"Inner exception:\n" +
(ex.InnerException == null ? ex.Message : ex.InnerException.Message);
MessageBox.Show(
msg,
"Unable to ungroup gate",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
else if (oldGate.Name == GateName.Composite)
{
CompositeGate cg = oldGate as CompositeGate;
List<Gate> toAdd = _model.GetActualGates(cg);
int column = _column;
foreach (Gate g in toAdd)
{
if (g.Name != GateName.Empty)
{
_model.InsertStepRight(column);
column++;
_model.Steps[column].SetGate(g);
}
}
//remove old composite gate
for (int i = oldGate.Begin; i <= oldGate.End; i++)
{
RegisterRefModel gateRef = _model.GetRefFromOffset(i);
Gate newGate = new EmptyGate(gateRef);
_model.Steps[_column].SetGate(newGate);
}
//delete step on _column (if it is empty)
bool isEmpty = true;
int j = 0;
while (isEmpty && j < _model.Steps[_column].Gates.Count)
{
if (_model.Steps[_column].Gates[j].Name != GateName.Empty)
{
isEmpty = false;
}
j++;
}
if (isEmpty)
{
_model.DeleteStep(_column);
}
}
break;
case ActionName.Composite:
oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
if (oldGate.Name == GateName.Empty)
{
MainWindow window1 = App.Current.MainWindow as MainWindow;
CircuitEvaluator eval = CircuitEvaluator.GetInstance();
//eval.InitFromModel(_model);
Dictionary<string, List<MethodInfo>> dict = eval.GetExtensionGates();
if (!string.IsNullOrWhiteSpace(HomeVM.SelectedComposite))
{
ParametricInputVM vm = new ParametricInputVM(HomeVM.SelectedComposite, dict, _model.CompositeGates);
ParametricInput ci = new ParametricInput(vm);
ICustomContentDialog dialog1 = window1.DialogManager
.CreateCustomContentDialog(ci, DialogMode.OkCancel);
dialog1.Ok = () =>
{
try
{
if (vm.IsValid)
{
if (vm.Method != null)
{
ParametricGate cg = eval.CreateParametricGate(vm.Method, vm.ParamValues);
_model.Steps[_column].SetGate(cg);
_model.AddStepAfter(_column);
}
else if (vm.CopositeGateTarget != null)
{
int minWidth = _model.MinWidthForComposite(vm.FunctionName);
if (vm.CopositeGateTarget.Value.Width < minWidth)
{
StringBuilder sb = new StringBuilder("Entered parameter has too small width.\n");
sb.Append("Entered width: ");
sb.Append(vm.CopositeGateTarget.Value.Width).AppendLine();
sb.Append("Minimum width: ");
sb.Append(minWidth).AppendLine();
throw new Exception(sb.ToString());
}
else
{
CompositeGate cg = new CompositeGate(vm.FunctionName, vm.CopositeGateTarget.Value);
_model.Steps[_column].SetGate(cg);
_model.AddStepAfter(_column);
}
}
}
}
catch (Exception ex)
{
string msg = "Unable to add gate. The parameters are invalid.\n" +
"Inner exception:\n" +
(ex.InnerException != null ? ex.InnerException.Message : ex.Message);
MessageBox.Show(
msg,
"Unable to add gate",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
};
dialog1.Show();
}
}
break;
case ActionName.Selection:
_model.Select(pressedRow.OffsetToRoot, _row.OffsetToRoot, pressedColumn, _column);
break;
case ActionName.Pointer:
default:
break;
}
}
}
public ToffoliGate(RegisterRefModel target, RegisterRefModel control, params RegisterRefModel[] restControls)
: base(target, control, restControls)
{
}
public RotateYGate(double gamma, RegisterRefModel target, RegisterRefModel? control = null)
: base(gamma, target, control)
{
}
public EmptyGate(RegisterRefModel row)
{
_row = row;
}
