public void MakeComposite(string name, List <Gate> toGroup)
{
Delete();
RegisterPartModel target = new RegisterPartModel()
{
Register = null,
Offset = 0,
Width = toGroup.Select <Gate, int>(x => x.End).Max() + 1
};
CompositeGate cg = new CompositeGate(name, target);
foreach (StepModel step in _steps)
{
for (int j = 0; j < step.Gates.Count; j++)
{
Gate oldGate = step.Gates[j];
CustomGate custom = oldGate as CustomGate;
if (custom != null && custom.FunctionName.Equals(name))
{
for (int k = oldGate.Begin; k <= oldGate.End; k++)
{
RegisterRefModel gateRef = GetRefFromOffset(k);
Gate newGate = new EmptyGate(gateRef);
step.SetGate(newGate);
}
Gate replacement = PasteGate(cg, oldGate.Begin);
if (step.HasPlace(replacement.Begin, replacement.End))
{
step.SetGate(replacement);
}
}
j = oldGate.End;
}
}
_compositeGates[name] = toGroup;
//CompositeGate cg = new CompositeGate(name, toGroup, target);
Gate toPaste = PasteGate(cg, _selectedItems.Value.BeginRow);
bool notPasted = true;
int i = _selectedItems.Value.BeginColumn;
while (notPasted && i <= _selectedItems.Value.EndColumn)
{
if (_steps[i].HasPlace(toPaste.Begin, toPaste.End))
{
_steps[i].SetGate(toPaste);
notPasted = false;
}
i++;
}
if (notPasted)
{
InsertStepLeft(_selectedItems.Value.BeginColumn);
_steps[_selectedItems.Value.BeginColumn].SetGate(toPaste);
}
}
public void DeleteRegister(int registerIndex)
{
if (_currentStep != 0)
{
return;
}
SelectedItems = null;
RegisterModel reg = _registers[registerIndex];
int regBegin = reg.OffsetToRoot;
int regEnd = reg.OffsetToRoot + reg.Qubits.Count - 1;
int regLength = reg.Qubits.Count;
foreach (StepModel step in Steps)
{
Gate firstOld = step.Gates[regBegin];
if (firstOld.Begin < regBegin)
{
for (int j = firstOld.Begin; j <= firstOld.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
step.SetGate(newGate);
}
}
Gate lastOld = step.Gates[regEnd];
if (lastOld.End > regEnd)
{
for (int j = lastOld.Begin; j <= lastOld.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
step.SetGate(newGate);
}
}
for (int i = 0; i < regLength; i++)
{
step.Gates.RemoveAt(regBegin);
}
}
int k = 0;
for (; k < registerIndex; k++)
{
_registers[k].IncrementOffset(-regLength);
}
k++;
for (; k < _registers.Count; k++)
{
_registers[k].UpdateIndex(k - 1);
}
_registers.RemoveAt(registerIndex);
}
public void DeleteQubit(int registerIndex, int row)
{
if (_currentStep != 0)
{
return;
}
SelectedItems = null;
RegisterModel reg = _registers[registerIndex];
int offsetToRoot = reg.OffsetToRoot + row;
foreach (StepModel step in Steps)
{
Gate oldGate = step.Gates[offsetToRoot];
if (oldGate.Name != GateName.Empty)
{
for (int j = oldGate.Begin; j <= oldGate.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
step.SetGate(newGate);
}
}
for (int i = offsetToRoot + 1; i < reg.OffsetToRoot + reg.Qubits.Count; i++)
{
step.Gates[i].IncrementRow(reg, row, -1);
i = step.Gates[i].End + 1;
}
//step.Gates.RemoveAt(offsetToRoot);
}
reg.Qubits.RemoveAt(row);
for (int i = 0; i < registerIndex; i++)
{
_registers[i].IncrementOffset(-1);
}
foreach (StepModel step in Steps)
{
step.Gates.RemoveAt(offsetToRoot);
}
}
private void CutCopy(bool cut)
{
if (_selectedItems.HasValue)
{
_clipboard = new List <List <Gate> >();
_clipboardSelection = new Selection(
0,
_selectedItems.Value.RowSpan - 1,
0,
_selectedItems.Value.ColumnSpan - 1);
for (int i = _selectedItems.Value.BeginColumn; i <= _selectedItems.Value.EndColumn; i++)
{
List <Gate> current = new List <Gate>();
_clipboard.Add(current);
for (int j = _selectedItems.Value.BeginRow; j <= _selectedItems.Value.EndRow; j++)
{
if ((_steps[i].Gates[j].Begin >= _selectedItems.Value.BeginRow) &&
(_steps[i].Gates[j].End <= _selectedItems.Value.EndRow))
{
Gate oldGate = _steps[i].Gates[j];
current.Add(oldGate.Copy(_selectedItems.Value.BeginRow));
if (cut && oldGate.Name != GateName.Empty)
{
for (; j <= oldGate.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
_steps[i].SetGate(newGate);
}
}
j = oldGate.End;
}
}
}
}
}
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 void ChangeParametricParams(object[] parameters)
{
Gate oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
ParametricGate cg = oldGate as ParametricGate;
CircuitEvaluator eval = CircuitEvaluator.GetInstance();
//eval.InitFromModel(_model);
try
{
ParametricGate newCg = eval.CreateParametricGate(cg.Method, parameters);
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 (_model.Steps[_column].HasPlace(newCg.Begin, newCg.End))
{
_model.Steps[_column].SetGate(newCg);
_model.Select(newCg.Begin, newCg.End, _column, _column);
_model.AddStepAfter(_column);
}
else
{
_model.InsertStepRight(_column);
_model.Steps[_column + 1].SetGate(newCg);
_model.Select(newCg.Begin, newCg.End, _column, _column + 1);
_model.AddStepAfter(_column + 1);
}
}
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);
}
}
public void ChangeCompositeTarget(RegisterPartModel target)
{
Gate oldGate = _model.Steps[_column].Gates[_row.OffsetToRoot];
CompositeGate cg = oldGate as CompositeGate;
CompositeGate newCg = new CompositeGate(cg.FunctionName, target);
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 (_model.Steps[_column].HasPlace(newCg.Begin, newCg.End))
{
_model.Steps[_column].SetGate(newCg);
_model.AddStepAfter(_column);
}
else
{
_model.InsertStepRight(_column);
_model.Steps[_column + 1].SetGate(newCg);
_model.AddStepAfter(_column + 1);
}
}
public void Paste()
{
if (_selectedItems.HasValue)
{
int clickedColumn = _selectedItems.Value.BeginColumn;
int clickedRow = _selectedItems.Value.EndRow;
if (_clipboard != null)
{
int endColumn = clickedColumn + _clipboardSelection.Value.ColumnSpan - 1;
int beginRow = clickedRow - _clipboardSelection.Value.RowSpan + 1;
int rightColumn = Math.Min(endColumn, _steps.Count - 1);
int bottomRow = Math.Max(beginRow, 0);
int newUpperRow = bottomRow + _clipboardSelection.Value.RowSpan - 1;
// remove old gates
for (int i = clickedColumn; i <= rightColumn; i++)
{
Gate beginGate = _steps[i].Gates[bottomRow];
if (beginGate.Begin < bottomRow)
{
for (int j = beginGate.Begin; j <= beginGate.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
_steps[i].SetGate(newGate);
}
}
Gate endGate = _steps[i].Gates[clickedRow];
if (endGate.End > clickedRow)
{
for (int j = endGate.Begin; j <= endGate.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
_steps[i].SetGate(newGate);
}
}
}
// make place, if it was too little
for (int i = rightColumn; i < endColumn; i++)
{
InsertStepRight(i);
}
for (int i = bottomRow; i > beginRow; i--)
{
InsertQubitBelow(_registers.Count - 1, 0);
}
// paste
for (int i = 0; i < _clipboard.Count; i++)
{
foreach (Gate oldGate in _clipboard[i])
{
Gate newGate = PasteGate(oldGate, bottomRow);
_steps[i + clickedColumn].SetGate(newGate);
}
}
// and move selection
SelectedItems = new Selection
(bottomRow,
newUpperRow,
clickedColumn,
endColumn);
}
}
}
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;
}
}
}
}
}
private void CutCopy(bool cut)
{
if (_selectedItems.HasValue)
{
_clipboard = new List<List<Gate>>();
_clipboardSelection = new Selection(
0,
_selectedItems.Value.RowSpan - 1,
0,
_selectedItems.Value.ColumnSpan - 1);
for (int i = _selectedItems.Value.BeginColumn; i <= _selectedItems.Value.EndColumn; i++)
{
List<Gate> current = new List<Gate>();
_clipboard.Add(current);
for (int j = _selectedItems.Value.BeginRow; j <= _selectedItems.Value.EndRow; j++)
{
if ((_steps[i].Gates[j].Begin >= _selectedItems.Value.BeginRow) &&
(_steps[i].Gates[j].End <= _selectedItems.Value.EndRow))
{
Gate oldGate = _steps[i].Gates[j];
current.Add(oldGate.Copy(_selectedItems.Value.BeginRow));
if (cut && oldGate.Name != GateName.Empty)
{
for (; j <= oldGate.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
_steps[i].SetGate(newGate);
}
}
j = oldGate.End;
}
}
}
}
}
public void Paste()
{
if (_selectedItems.HasValue)
{
int clickedColumn = _selectedItems.Value.BeginColumn;
int clickedRow = _selectedItems.Value.EndRow;
if (_clipboard != null)
{
int endColumn = clickedColumn + _clipboardSelection.Value.ColumnSpan - 1;
int beginRow = clickedRow - _clipboardSelection.Value.RowSpan + 1;
int rightColumn = Math.Min(endColumn, _steps.Count - 1);
int bottomRow = Math.Max(beginRow, 0);
int newUpperRow = bottomRow + _clipboardSelection.Value.RowSpan - 1;
// remove old gates
for (int i = clickedColumn; i <= rightColumn; i++)
{
Gate beginGate = _steps[i].Gates[bottomRow];
if (beginGate.Begin < bottomRow)
{
for (int j = beginGate.Begin; j <= beginGate.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
_steps[i].SetGate(newGate);
}
}
Gate endGate = _steps[i].Gates[clickedRow];
if (endGate.End > clickedRow)
{
for (int j = endGate.Begin; j <= endGate.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
_steps[i].SetGate(newGate);
}
}
}
// make place, if it was too little
for (int i = rightColumn; i < endColumn; i++)
{
InsertStepRight(i);
}
for (int i = bottomRow; i > beginRow; i--)
{
InsertQubitBelow(_registers.Count - 1, 0);
}
// paste
for (int i = 0; i < _clipboard.Count; i++)
{
foreach (Gate oldGate in _clipboard[i])
{
Gate newGate = PasteGate(oldGate, bottomRow);
_steps[i + clickedColumn].SetGate(newGate);
}
}
// and move selection
SelectedItems = new Selection
(bottomRow,
newUpperRow,
clickedColumn,
endColumn);
}
}
}
public void MakeComposite(string name, List<Gate> toGroup)
{
Delete();
RegisterPartModel target = new RegisterPartModel()
{
Register = null,
Offset = 0,
Width = toGroup.Select<Gate, int>(x => x.End).Max() + 1
};
CompositeGate cg = new CompositeGate(name, target);
foreach (StepModel step in _steps)
{
for (int j = 0; j < step.Gates.Count; j++)
{
Gate oldGate = step.Gates[j];
CustomGate custom = oldGate as CustomGate;
if (custom != null && custom.FunctionName.Equals(name))
{
for (int k = oldGate.Begin; k <= oldGate.End; k++)
{
RegisterRefModel gateRef = GetRefFromOffset(k);
Gate newGate = new EmptyGate(gateRef);
step.SetGate(newGate);
}
Gate replacement = PasteGate(cg, oldGate.Begin);
if (step.HasPlace(replacement.Begin, replacement.End))
{
step.SetGate(replacement);
}
}
j = oldGate.End;
}
}
_compositeGates[name] = toGroup;
//CompositeGate cg = new CompositeGate(name, toGroup, target);
Gate toPaste = PasteGate(cg, _selectedItems.Value.BeginRow);
bool notPasted = true;
int i = _selectedItems.Value.BeginColumn;
while (notPasted && i <= _selectedItems.Value.EndColumn)
{
if (_steps[i].HasPlace(toPaste.Begin, toPaste.End))
{
_steps[i].SetGate(toPaste);
notPasted = false;
}
i++;
}
if (notPasted)
{
InsertStepLeft(_selectedItems.Value.BeginColumn);
_steps[_selectedItems.Value.BeginColumn].SetGate(toPaste);
}
}
public void DeleteRegister(int registerIndex)
{
if (_currentStep != 0)
{
return;
}
SelectedItems = null;
RegisterModel reg = _registers[registerIndex];
int regBegin = reg.OffsetToRoot;
int regEnd = reg.OffsetToRoot + reg.Qubits.Count - 1;
int regLength = reg.Qubits.Count;
foreach (StepModel step in Steps)
{
Gate firstOld = step.Gates[regBegin];
if (firstOld.Begin < regBegin)
{
for (int j = firstOld.Begin; j <= firstOld.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
step.SetGate(newGate);
}
}
Gate lastOld = step.Gates[regEnd];
if (lastOld.End > regEnd)
{
for (int j = lastOld.Begin; j <= lastOld.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
step.SetGate(newGate);
}
}
for (int i = 0; i < regLength; i++)
{
step.Gates.RemoveAt(regBegin);
}
}
int k = 0;
for (; k < registerIndex; k++)
{
_registers[k].IncrementOffset(-regLength);
}
k++;
for (; k < _registers.Count; k++)
{
_registers[k].UpdateIndex(k - 1);
}
_registers.RemoveAt(registerIndex);
}
public void DeleteQubit(int registerIndex, int row)
{
if (_currentStep != 0)
{
return;
}
SelectedItems = null;
RegisterModel reg = _registers[registerIndex];
int offsetToRoot = reg.OffsetToRoot + row;
foreach (StepModel step in Steps)
{
Gate oldGate = step.Gates[offsetToRoot];
if (oldGate.Name != GateName.Empty)
{
for (int j = oldGate.Begin; j <= oldGate.End; j++)
{
RegisterRefModel gateRef = GetRefFromOffset(j);
Gate newGate = new EmptyGate(gateRef);
step.SetGate(newGate);
}
}
for (int i = offsetToRoot + 1; i < reg.OffsetToRoot + reg.Qubits.Count; i++)
{
step.Gates[i].IncrementRow(reg, row, -1);
i = step.Gates[i].End + 1;
}
//step.Gates.RemoveAt(offsetToRoot);
}
reg.Qubits.RemoveAt(row);
for (int i = 0; i < registerIndex; i++)
{
_registers[i].IncrementOffset(-1);
}
foreach (StepModel step in Steps)
{
step.Gates.RemoveAt(offsetToRoot);
}
}
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;
}
}
}
}
}