public static Gate Add(IEnumerable <Gate> gates)
{
IEnumerator <Gate> iterator = gates.GetEnumerator();
if (!iterator.MoveNext())
{
return(null);
}
int nbEntriesRef = iterator.Current.NbEntries;
while (iterator.MoveNext())
{
if (iterator.Current.NbEntries != nbEntriesRef)
{
throw new ArgumentException("cannot add gates of different lengths");
}
}
return(new Gate("(" + String.Join("+", FuncTools.Map((Gate gate) => gate.Name, gates)) + ")", nbEntriesRef, LinearAlgebra.Mult(FuncTools.Map((Gate a) => a.Matrix, gates))));
}
public State(IEnumerable <Qubit> trucs) : this(FuncTools.Reduce1(LinearAlgebra.Kronecker, FuncTools.Map((Qubit a) => a.vector, trucs)))
{
}
public Gate(params Gate[] gates) : this(String.Join("*", FuncTools.Map((Gate gate) => gate.Name, gates)), (IEnumerable <Gate>)gates)
{
}
public Gate(string name, IEnumerable <Gate> gates) : this(name, FuncTools.Sum(FuncTools.Map((Gate a) => a.NbEntries, gates)), FuncTools.Reduce1(LinearAlgebra.Kronecker, FuncTools.Map((Gate a) => a.Matrix, gates)))
{
}
/// <summary>
/// Retourne True si toutes les portes de la ligne spécifiée sont des portes IDENTITY, False sinon.
/// </summary>
/// <param name="index"></param>
/// <returns>bool</returns>
public bool IsRowEmpty(int index)
{
return(FuncTools.AllEquals(Gate.IDENTITY, FuncTools.Map((GateStruct a) => a.gate, rows[index])));
}
/// <summary>
/// Evalue partiellement le circuit jusquà la ligne de numéro spécifié
/// </summary>
/// <param name="till_row"></param>
/// <returns>State</returns>
public State Evaluate(int till_row)
{
State entry = GetEntryState();
return(new State(LinearAlgebra.Mult(entry.Vector, Gate.Add(FuncTools.Map(GetRowGate, FuncTools.Take(till_row + 1, rows))).Matrix)));
}
/// <summary>
/// Retourne l'état d'entrée du circuit.
/// </summary>
/// <returns>State</returns>
public State GetEntryState()
{
return(new State(FuncTools.Map((EntryStruct a) => a.qubit, entries)));
}
/// <summary>
/// Convertit le circuit en porte (produit matriciel des portes représenttant les lignes)
/// </summary>
/// <param name="name"></param>
/// <returns>Gate</returns>
public Gate GetCircuitGate(string name)
{
return(new Gate(name, Gate.Add(FuncTools.Map(GetRowGate, rows))));
}
/// <summary>
/// Convertit le circuit en porte (produit matriciel des portes représenttant les lignes).
/// </summary>
/// <returns>Gate</returns>
public Gate GetCircuitGate()
{
return(Gate.Add(FuncTools.Map(GetRowGate, rows)));
}
/// <summary>
/// Convertit une ligne en une porte (produit tensoriel des toutes les portes de la ligne).
/// </summary>
/// <param name="row"></param>
/// <returns>Gate</returns>
public Gate GetRowGate(List <GateStruct> row)
{
return(Gate.Kron(FuncTools.Map((GateStruct a) => a.gate, FilterRow(row))));
}
public static Matrix <Complex> Mult(IEnumerable <Matrix <Complex> > t)
{
return(FuncTools.Reduce1(Mult, t));
}
public static Matrix <Complex> Kronecker(IEnumerable <Matrix <Complex> > t)
{
return(FuncTools.Reduce1(Kronecker, t));
}
