protected RegisterPartModel incRegPart(RegisterPartModel regRef, RegisterModel register, int afterOffset, int delta = 1)
{
if (regRef.Register == register)
{
if (regRef.Width + delta == register.Qubits.Count)
{
return new RegisterPartModel()
{
Register = regRef.Register,
Offset = regRef.Offset,
Width = regRef.Width + delta
};
}
else if (regRef.Offset > afterOffset)
{
return new RegisterPartModel()
{
Register = regRef.Register,
Offset = regRef.Offset + delta,
Width = regRef.Width
};
}
else if (regRef.Offset + regRef.Width - 1 > afterOffset)
{
return new RegisterPartModel()
{
Register = regRef.Register,
Offset = regRef.Offset,
Width = regRef.Width + delta
};
}
}
return regRef;
}
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());
}
protected RegisterPartModel copyRegPart(RegisterPartModel regRef, int referenceBeginRow)
{
return new RegisterPartModel()
{
Register = null,
Offset = regRef.OffsetToRoot - referenceBeginRow,
Width = regRef.Width
};
}
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 string GenerateCompositeGateCode(CompositeGate cg, string defaultRegName = null)
{
StringBuilder sb = new StringBuilder("comp.").Append(cg.FunctionName).Append("(");
RegisterPartModel rm = cg.TargetRegister;
sb.Append(GetRegName(rm.Register, defaultRegName));
if (rm.Register == null || (rm.Width != rm.Register.Qubits.Count))
{
sb.Append("[").Append(rm.Offset).Append(", ");
sb.Append(rm.Width).Append("]");
}
sb.Append(");");
return(sb.ToString());
}
internal Quantum.Register ModelToSource(RegisterPartModel model)
{
Quantum.Register toReturn = _parserRoot.SourceRegister;
if (model.Register != null)
{
toReturn = _modelRefs[model.Register].SourceRegister;
}
if (model.Width == toReturn.Width)
{
return(toReturn);
}
else
{
return(toReturn[model.Offset, model.Width]);
}
}
internal Register ModelToRef(RegisterPartModel model)
{
Register toReturn = _parserRoot;
if (model.Register != null)
{
toReturn = _modelRefs[model.Register];
}
if (model.Width == toReturn.Width)
{
return(toReturn);
}
else
{
return(toReturn[model.Offset, model.Width]);
}
}
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 Update(Register rootRegister, RegisterPartModel? regModel = null)
{
Register register = rootRegister;
if (regModel.HasValue)
{
_selectedRegister = regModel.Value;
}
if (_selectedRegister.HasValue && _selectedRegister.Value.Width < rootRegister.Width)
{
register = rootRegister[_selectedRegister.Value.OffsetToRoot, _selectedRegister.Value.Width];
}
_states.Clear();
IReadOnlyDictionary<ulong, Complex> amplitudes = register.GetAmplitudes();
if (amplitudes != null)
{
foreach (ulong state in amplitudes.Keys)
{
OutputState newState = new OutputState(state, amplitudes[state], register.Width);
_states.Add(newState);
}
}
else
{
IReadOnlyDictionary<ulong, double> probabilities = register.GetProbabilities();
foreach (ulong state in probabilities.Keys)
{
OutputState newState = new OutputState(state, probabilities[state], register.Width);
_states.Add(newState);
}
}
OnOutputChanged();
}
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;
}
}
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 CompositeGate(string name, List<Gate> gates, RegisterPartModel target)
//{
// _name = name;
// _gates = gates;
// _targetRegister = target;
//}
public CompositeGate(string name, RegisterPartModel target)
{
_name = name;
_targetRegister = target;
}
public override void IncrementRow(RegisterModel register, int afterOffset, int delta = 1)
{
_targetRegister = incRegPart(_targetRegister, register, afterOffset, delta);
}
