private void CoefficientsCreate_Click(object sender, RoutedEventArgs e)
{
ErrorMessage.Visibility = Visibility.Collapsed;
Complex[,] coefs = new Complex[2, 1];
double phase;
try
{
coefs[0, 0] = ComplexParser.FromString(Alpha.Text);
coefs[1, 0] = ComplexParser.FromString(Beta.Text);
phase = double.Parse(Phase.Text);
} catch (FormatException)
{
ErrorMessage.Content = "Inserted value(s) could not be parsed";
ErrorMessage.Visibility = Visibility.Visible;
return;
}
if (coefs[0, 0] == Complex.Zero && coefs[1, 0] == Complex.Zero)
{
ErrorMessage.Content = "At least one of alpha/beta must be nonzero";
ErrorMessage.Visibility = Visibility.Visible;
return;
}
Transformation transformation = Transformation.FromCoefficients(coefs[0, 0], coefs[1, 0], phase);
_circuit.DefineUnitaryGateModel(1, false, new StandardGateSymbol(MatrixName.Text), transformation, _circuit.CustomGates);
}
private void CalculateSubsystemState(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(DiscardedQubitsBox.Text))
{
return;
}
StateOperator state = StateOperator.FromQuantumState(Layer.GetSystemState());
List <int> discardedQubits = new List <int>();
string qubits = DiscardedQubitsBox.Text.Replace(",", "");
for (int i = 0; i < qubits.Length; i++)
{
discardedQubits.Add(Convert.ToInt32(qubits[i] - 48));
}
SubState = state.PartialTrace(discardedQubits);
SubsystemState.ResizeGrid(SubState.RowDimension, SubState.ColumnDimension);
for (int i = 0; i < SubState.RowDimension; i++)
{
for (int j = 0; j < SubState.ColumnDimension; j++)
{
SubsystemState[i, j] = ComplexParser.ToString(SubState[i, j], 4);
}
}
SubsystemStateGrid.Visibility = Visibility.Visible;
if (SubState.Size == 1)
{
ExamineSubsystemButton.IsEnabled = false;
}
}
private void Matrix_Click(object sender, RoutedEventArgs e)
{
/*
* Complex[] values = new Complex[MatrixDefinition.Rows*MatrixDefinition.Columns];
* for(int i = 0; i < MatrixDefinition.Columns; i++ )
* for(int j = 0; j < MatrixDefinition.Rows; j++)
* values[i * MatrixDefinition.Rows + j] = ComplexParser.FromString(MatrixDefinition[j, i]);
* Transformation transformation = Transformation.FromValuesColumnMajor(values, MatrixDefinition.Columns);
* _circuit.DefineUnitaryGateModel((int)QubitsBox.SelectedItem, false, new StandardGateSymbol(MatrixName.Text), transformation, _circuit.CustomGates);
*/
ErrorMessage.Visibility = Visibility.Collapsed;
Complex[, ] values = new Complex[MatrixDefinition.Rows, MatrixDefinition.Columns];
for (int i = 0; i < MatrixDefinition.Columns; i++)
{
for (int j = 0; j < MatrixDefinition.Rows; j++)
{
try { values[i, j] = ComplexParser.FromString(MatrixDefinition[i, j]); }
catch (FormatException)
{
ErrorMessage.Content = string.Format($"Value at [{0}, {1}] could not be parsed", i, j);
ErrorMessage.Visibility = Visibility.Visible;
return;
}
}
}
if (!Transformation.IsUnitary(values))
{
ErrorMessage.Content = "Defined matrix is not unitary";
ErrorMessage.Visibility = Visibility.Visible;
return;
}
Transformation transformation = Transformation.FromValues(values);
_circuit.DefineUnitaryGateModel((int)QubitsBox.SelectedItem, false, new StandardGateSymbol(MatrixName.Text), transformation, _circuit.CustomGates);
}
public override ValidationResult Validate(object value, CultureInfo cultureInfo)
{
Complex number;
// Is a number?
if (!ComplexParser.TryParse((string)value, out number))
{
return(new ValidationResult(false, "Not a complex number."));
}
// Number is valid
return(new ValidationResult(true, null));
}
protected override void OnInitialized(EventArgs e)
{
BlochSphere bloch = new BlochSphere(CircuitCell.CellSize);
bloch.Recalculate(Qubit.BlochVector());
bloch.HorizontalAlignment = HorizontalAlignment.Left;
Sphere.Children.Add(bloch);
X.Content = ComplexParser.ToString(bloch.X, 4); Y.Content = ComplexParser.ToString(bloch.Y, 4); Z.Content = ComplexParser.ToString(bloch.Z, 4);
Radius.Content = ComplexParser.ToString(bloch.Radius, 4); Longtitude.Content = ComplexParser.ToString(bloch.Longtitude, 4); Colatitude.Content = ComplexParser.ToString(bloch.Colatitude, 4);
DensityMatrix.ResizeGrid(2, 2);
DensityMatrix.HorizontalAlignment = HorizontalAlignment.Center;
for (int i = 0; i < Qubit.StateOperator.RowDimension; i++)
{
for (int j = 0; j < Qubit.StateOperator.RowDimension; j++)
{
DensityMatrix[i, j] = ComplexParser.ToString(Qubit.StateOperator[i, j], 4);
}
}
base.OnInitialized(e);
}
private Complex[, ] ReadTextMatrix()
{
int rows = MatrixDefinition.Rows, cols = MatrixDefinition.Columns;
Complex[, ] values = new Complex[rows, cols];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
try { values[i, j] = ComplexParser.FromString(MatrixDefinition[i, j]); }
catch (FormatException)
{
ErrorMessage.Content = string.Format($"Value at [{0}, {1}] could not be parsed", i, j);
ErrorMessage.Visibility = Visibility.Visible;
return(null);
}
}
}
return(values);
}
private void InitializeWithStateOperator()
{
Qubits.Items.Add(StateOperator.Size);
Qubits.SelectedIndex = 0;
CCNR.IsChecked = true;
Schmidt.IsEnabled = false;
DensityMatrix.IsChecked = true;
DensityMatrix.IsEnabled = StateMatrix.IsEnabled = false;
Qubits.IsEnabled = false;
//ResizeDefinitionMatrix();
int size = (int)Math.Pow(2, Bipartition.SystemSize);
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
MatrixDefinition[i, j] = ComplexParser.ToString(StateOperator[i, j], 2);
}
}
MatrixDefinition.IsEnabled = false;
}
private void InitializeWithStateVector()
{
Qubits.Items.Add(State.Size);
Qubits.SelectedIndex = 0;
Schmidt.IsChecked = true;
StateMatrix.IsChecked = true;
DensityMatrix.IsEnabled = StateMatrix.IsEnabled = false;
Qubits.IsEnabled = false;
//ResizeDefinitionMatrix();
/*
* for (int i = 0; i < Bipartition.DimensionA; i++)
* for (int j = 0; j < Bipartition.DimensionB; j++)
* MatrixDefinition[i, j] = ComplexParser.ToString(State[i * Bipartition.DimensionB + j], 2);
*/
for (int i = 0; i < MatrixDefinition.Rows; i++)
{
for (int j = 0; j < MatrixDefinition.Columns; j++)
{
MatrixDefinition[i, j] = ComplexParser.ToString(State[i * MatrixDefinition.Columns + j], 2);
}
}
MatrixDefinition.IsEnabled = false;
}
protected override void OnInitialized(EventArgs e)
{
if (Reg.Size == 1)
{
Qubits.Content = "Qubits: " + FirstQubitIndex.ToString();
}
else
{
Qubits.Content = "Qubits: " + FirstQubitIndex.ToString() + "-" + (FirstQubitIndex + Reg.Size - 1).ToString();
}
int matrixRows, matrixCols;
if (Reg.Size % 2 == 0)
{
matrixRows = matrixCols = (int)Math.Pow(2, Reg.Size / 2);
}
else
{
matrixRows = (int)Math.Pow(2, (Reg.Size - 1) / 2);
matrixCols = (int)Math.Pow(2, (Reg.Size + 1) / 2);
}
StateMatrix.ResizeGrid(matrixRows, matrixCols);
for (int i = 0; i < matrixRows; i++)
{
for (int j = 0; j < matrixCols; j++)
{
StateMatrix[i, j] = ComplexParser.ToString(Reg.Amplitude(i * matrixCols + j), 4).ToString();
}
}
if (Reg.Size == 1)
{
Examine.IsEnabled = false;
}
base.OnInitialized(e);
}
/// <summary>Parse a string into a <c>Complex</c>.</summary>
public static Complex Parse(string complex, NumberFormatInfo numberFormat)
{
ComplexParser parser = new ComplexParser(complex, numberFormat);
return(parser.Complex);
}
/// <summary>Parse a string into a <c>Complex</c>.</summary>
/// <remarks>
/// The adopted string representation for the complex numbers is
/// <i>UVW+I*XYZ</i> where <i>UVW</i> and <i>XYZ</i> are <c>double</c>
/// strings. Some alternative representations are <i>UVW+XYZi</i>,
/// <i>UVW+iXYZ</i>, <i>UVW</i> and <i>iXYZ</i>.
/// Additionally the string <c>"NaN"</c> is mapped to
/// <c>Complex.NaN</c>, the string <c>"Infinity"</c> to
/// <c>Complex.ComplexInfinity</c>, <c>"PositiveInfinity"</c>
/// to <c>Complex.DirectedInfinity(Complex.One)</c>,
/// <c>"NegativeInfinity"</c> to <c>Complex.DirectedInfinity(-Complex.One)</c>
/// and finally <c>"DirectedInfinity(WVW+I*XYZ)"</c> to <c>Complex.DirectedInfinity(WVW+I*XYZ)</c>.
/// <code>
/// Complex z = Complex.Parse("12.5+I*7");
/// Complex nan = Complex.Parse("NaN");
/// Complex infinity = Complex.Parse("Infinity");
/// </code>
/// This method is symetric to <see cref="ToString"/>.
/// </remarks>
public static Complex Parse(string complex)
{
ComplexParser parser = new ComplexParser(complex);
return(parser.Complex);
}
