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());
}
internal void Evaluate(ParametricGate gate, bool runBackward)
{
MethodInfo rightMethod = null;
if (runBackward)
{
rightMethod = gate.InverseMethod;
}
else
{
rightMethod = gate.ComputationMethod;
}
if (rightMethod != null)
{
Func <object, object> fromModel = x =>
{
if (x is RegisterRefModel)
{
return(ModelToSource((RegisterRefModel)x));
}
else if (x is RegisterPartModel)
{
return(ModelToSource((RegisterPartModel)x));
}
else
{
return(x);
}
};
object[] parameters = new object[gate.Parameters.Length];
ParameterInfo[] infos = rightMethod.GetParameters();
for (int i = 1; i < parameters.Length; i++)
{
object par = gate.Parameters[i];
if (infos[i].GetCustomAttributes(typeof(ParamArrayAttribute), false).Length > 0)
{
IEnumerable pars = par as IEnumerable;
ArrayList newPars = new ArrayList();
foreach (var item in pars)
{
newPars.Add(fromModel(item));
}
Array arr = newPars.ToArray(infos[i].ParameterType.GetElementType());
parameters[i] = arr;
}
else
{
parameters[i] = fromModel(par);
}
}
parameters[0] = _comp;
rightMethod.Invoke(_comp, parameters);
}
}
public void AddParametricGate(string name, object[] parameters)
{
MethodInfo rightMethod = FindExtension(name, parameters, ExtensionGates);
if (rightMethod != null)
{
ParametricGate cg = CreateParametricGate(rightMethod, parameters);
AddGate(cg);
}
}
internal ParametricGate CreateParametricGate(MethodInfo method, object[] parameters)
{
string name = method.Name;
string invName = name;
string[] sep = new string[] { "Inverse" };
if (name.StartsWith("Inverse"))
{
string[] splitted = name.Split(sep, StringSplitOptions.RemoveEmptyEntries);
invName = splitted[0];
}
else
{
invName = "Inverse" + name;
}
MethodInfo computationMethod = FindExtension(name, parameters, LibExtensionGates);
MethodInfo inverseMethod = FindExtension(invName, parameters, LibExtensionGates);
MethodCode methodCode = FindMethodCode(computationMethod);
string methodBody = null;
if (methodCode != null)
{
methodBody = methodCode.Code;
}
for (int i = 0; i < parameters.Length; i++)
{
Type t = parameters[i].GetType();
if (t == typeof(RegisterRef))
{
parameters[i] = ((RegisterRef)parameters[i]).ToRefModel();
}
else if (t == typeof(Register))
{
parameters[i] = (parameters[i] as Register).ToPartModel();
}
else if (t == typeof(RegisterRef[]))
{
parameters[i] = ((RegisterRef[])parameters[i])
.Select <RegisterRef, RegisterRefModel>(x => x.ToRefModel()).ToArray();
}
else if (t == typeof(Register[]))
{
parameters[i] = (parameters[i] as Register[])
.Select <Register, RegisterPartModel>(x => x.ToPartModel()).ToArray();
}
}
ParametricGate cg = new ParametricGate(method, computationMethod, inverseMethod, methodBody, parameters);
return(cg);
}
private void RefreshCompositePane(CustomGate gate)
{
_selectedType = SelectedType.CompositeGate;
_name = gate.FunctionName;
if (gate.Name == GateName.Parametric)
{
ParametricGate cg = gate as ParametricGate;
PopulateCandidates();
OnPropertyChanged("Candidates");
int methodIndex = _candidates.IndexOf(cg.Method);
_paramsValues[methodIndex] = cg.Parameters;
MethodIndex = methodIndex;
}
else // Composite
{
CompositeGate cg = gate as CompositeGate;
PopulateCandidates();
OnPropertyChanged("Candidates");
_paramsValues[0] = new object[] { null, cg.TargetRegister };
MethodIndex = 0;
}
}
internal void Decompose(ParametricGate gate)
{
MethodInfo rightMethod = gate.Method;
if (rightMethod != null)
{
object[] parameters = gate.Parameters.Select <object, object>(x =>
{
if (x is RegisterRefModel)
{
return(ModelToRef((RegisterRefModel)x));
}
else if (x is RegisterPartModel)
{
return(ModelToRef((RegisterPartModel)x));
}
else if (x is RegisterRefModel[])
{
return((x as RegisterRefModel[])
.Select <RegisterRefModel, RegisterRef>(y => ModelToRef(y)).ToArray());
}
else if (x is RegisterPartModel[])
{
return((x as RegisterPartModel[])
.Select <RegisterPartModel, Register>(y => ModelToRef(y)).ToArray());
}
else
{
return(x);
}
}).ToArray();
parameters[0] = this;
Group = false;
rightMethod.Invoke(this, parameters);
}
}
public void Decompose(ParametricGate cg)
{
_comp.Decompose(cg);
}
public bool RunStep(IList <Gate> gates, bool runBackward = false, bool runComposite = false)
{
Quantum.Register root = _comp.GetSourceRoot();
bool somethingChanged = false;
int i = 0;
int maxI = (runComposite ? 1 : gates.Count);
while (i < maxI)
{
Gate gate = gates[i];
int? control = null;
if (gate.Control.HasValue)
{
control = gate.Control.Value.OffsetToRoot;
}
switch (gate.Name)
{
case GateName.Hadamard: // the same as inversion
root.Hadamard(gate.Target.OffsetToRoot, control);
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.SigmaX: // the same as inversion
root.SigmaX(gate.Target.OffsetToRoot);
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.SigmaY: // the same as inversion
root.SigmaY(gate.Target.OffsetToRoot, control);
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.SigmaZ: // the same as inversion
root.SigmaZ(gate.Target.OffsetToRoot, control);
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.SqrtX:
if (runBackward)
{
Complex[,] m = new Complex[2, 2];
Complex a = new Complex(0.5, -0.5);
Complex b = new Complex(0.5, 0.5);
m[0, 0] = b;
m[0, 1] = a;
m[1, 0] = a;
m[1, 1] = b;
root.Gate1(m, gate.Target.OffsetToRoot, control);
}
else
{
root.SqrtX(gate.Target.OffsetToRoot, control);
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.RotateX:
RotateXGate rx = gate as RotateXGate;
if (runBackward)
{
root.RotateX(-rx.Gamma, rx.Target.OffsetToRoot, control);
}
else
{
root.RotateX(rx.Gamma, rx.Target.OffsetToRoot, control);
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.RotateY:
RotateYGate ry = gate as RotateYGate;
if (runBackward)
{
root.RotateY(-ry.Gamma, ry.Target.OffsetToRoot, control);
}
else
{
root.RotateY(ry.Gamma, ry.Target.OffsetToRoot, control);
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.RotateZ:
RotateZGate rz = gate as RotateZGate;
if (runBackward)
{
root.RotateZ(-rz.Gamma, rz.Target.OffsetToRoot, control);
}
else
{
root.RotateZ(rz.Gamma, rz.Target.OffsetToRoot, control);
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.PhaseKick:
PhaseKickGate pk = gate as PhaseKickGate;
if (pk.Controls.Length > 0)
{
int[] controls1 = pk.Controls.Select <RegisterRefModel, int>(x => x.OffsetToRoot).ToArray <int>();
if (runBackward)
{
root.PhaseKick(-pk.Gamma, pk.Target.OffsetToRoot, controls1);
}
else
{
root.PhaseKick(pk.Gamma, pk.Target.OffsetToRoot, controls1);
}
}
else
{
if (runBackward)
{
root.PhaseKick(-pk.Gamma, pk.Target.OffsetToRoot);
}
else
{
root.PhaseKick(pk.Gamma, pk.Target.OffsetToRoot);
}
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.PhaseScale:
PhaseScaleGate ps = gate as PhaseScaleGate;
if (runBackward)
{
root.PhaseScale(-ps.Gamma, ps.Target.OffsetToRoot, control);
}
else
{
root.PhaseScale(ps.Gamma, ps.Target.OffsetToRoot, control);
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.CPhaseShift:
CPhaseShiftGate cps = gate as CPhaseShiftGate;
if (cps.Controls.Length > 0)
{
int[] controls1 = cps.Controls.Select <RegisterRefModel, int>(x => x.OffsetToRoot).ToArray <int>();
if (runBackward)
{
root.InverseCPhaseShift(cps.Dist, cps.Target.OffsetToRoot, controls1);
}
else
{
root.CPhaseShift(cps.Dist, cps.Target.OffsetToRoot, controls1);
}
}
else
{
if (runBackward)
{
root.InverseCPhaseShift(cps.Dist, cps.Target.OffsetToRoot);
}
else
{
root.CPhaseShift(cps.Dist, cps.Target.OffsetToRoot);
}
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.InvCPhaseShift:
InvCPhaseShiftGate icps = gate as InvCPhaseShiftGate;
if (icps.Controls.Length > 0)
{
int[] controls1 = icps.Controls.Select <RegisterRefModel, int>(x => x.OffsetToRoot).ToArray <int>();
if (runBackward)
{
root.CPhaseShift(icps.Dist, icps.Target.OffsetToRoot, controls1);
}
else
{
root.InverseCPhaseShift(icps.Dist, icps.Target.OffsetToRoot, controls1);
}
}
else
{
if (runBackward)
{
root.CPhaseShift(icps.Dist, icps.Target.OffsetToRoot);
}
else
{
root.InverseCPhaseShift(icps.Dist, icps.Target.OffsetToRoot);
}
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.CNot:
CNotGate cn = gate as CNotGate;
root.CNot(cn.Target.OffsetToRoot, cn.Control.Value.OffsetToRoot);
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.Toffoli:
ToffoliGate t = gate as ToffoliGate;
int[] controls = t.Controls.Select <RegisterRefModel, int>(x => x.OffsetToRoot).ToArray <int>();
root.Toffoli(t.Target.OffsetToRoot, controls);
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.Unitary:
UnitaryGate u = gate as UnitaryGate;
if (runBackward)
{
Complex[,] m = new Complex[2, 2];
m[0, 0] = Complex.Conjugate(u.Matrix[0, 0]);
m[0, 1] = Complex.Conjugate(u.Matrix[1, 0]);
m[1, 0] = Complex.Conjugate(u.Matrix[0, 1]);
m[1, 1] = Complex.Conjugate(u.Matrix[1, 1]);
root.Gate1(m, gate.Target.OffsetToRoot, control);
}
else
{
root.Gate1(u.Matrix, u.Target.OffsetToRoot, control);
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.Measure:
MeasureGate mg = gate as MeasureGate;
for (int j = mg.Begin; j <= mg.End; j++)
{
root.Measure(j);
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.Parametric:
ParametricGate pg = gate as ParametricGate;
_comp.Evaluate(pg, runBackward);
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.Composite:
CompositeGate cg = gate as CompositeGate;
List <Gate> actual = _comp.GetActualGates(cg);
if (runBackward)
{
actual.Reverse();
}
foreach (Gate g in actual)
{
// TODO refactor RunStep() into RunGate()
List <Gate> toRun = new List <Gate>()
{
g
};
RunStep(toRun, runBackward, true);
}
somethingChanged = true;
i = gate.End + 1;
break;
case GateName.Empty:
default:
i++;
break;
}
}
return(somethingChanged);
}
