private static string GetNewEqualityTestCode(AssignmentExpression assignmentExpression)
{
RelationalOperation relationalOperation = new RelationalOperation(assignmentExpression.LeftSide.Clone() as Expression,
RelationalOperator.Equality,
assignmentExpression.RightSide.Clone() as Expression);
string newEqualityTest = CodeRush.Language.GenerateElement(relationalOperation);
return(newEqualityTest);
}
/// <summary>
/// Product equation factory.
/// </summary>
/// <param name="matrix1">The matrix1.</param>
/// <param name="matrix2">The matrix2.</param>
/// <param name="matrixResult">The matrix result.</param>
/// <returns></returns>
public static RelationalOperation ProductEquationFactory(NumericMatrixFactor matrix1, NumericMatrixFactor matrix2, out NumericMatrixFactor matrixResult)
{
var values1 = matrix1.Coefficients;
var values2 = matrix2.Coefficients;
var values3 = Operations.Multiply <double>(values1, values2);
matrixResult = new NumericMatrixFactor(values3, false);
var equation = new RelationalOperation(
ComparisonOperators.Equals,
new NomialExpression(
new ProductTerm(new NumericFactor(1), matrix1, matrix2)
),
new ProductTerm(new NumericFactor(1), matrixResult)
);
return(equation);
}
/// <summary>
/// Transposes the matrix equation.
/// </summary>
/// <param name="matrix">The matrix2.</param>
/// <param name="matrixResult">The matrix result.</param>
/// <returns></returns>
public static RelationalOperation TransposeMatrixEquationFactory(NumericMatrixFactor matrix, out NumericMatrixFactor matrixResult)
{
var values1 = matrix.Coefficients;
var values2 = Operations.Transpose <double>(values1);
var squareMatrix = new NumericMatrixFactor(matrix, new VariableFactor('T', 1), null);
matrixResult = new NumericMatrixFactor(values2, false);
var equation = new RelationalOperation(
ComparisonOperators.Equals,
new NomialExpression(
new ProductTerm(new NumericFactor(1), squareMatrix)
),
new ProductTerm(new NumericFactor(1), matrixResult)
);
return(equation);
}
/// <summary>
/// Fractions the scale equation factory.
/// </summary>
/// <param name="scalar">The scalar.</param>
/// <param name="matrix">The matrix2.</param>
/// <param name="matrixResult">The matrix result.</param>
/// <returns></returns>
public static RelationalOperation FractionScaleEquationFactory(FractionFactor scalar, NumericMatrixFactor matrix, out FractionNumericMatrixFactor matrixResult)
{
var values1 = (double)scalar.Numerator / scalar.Denominator;
var values2 = matrix.Coefficients;
var values3 = Operations.Scale(values1, values2);
matrixResult = new FractionNumericMatrixFactor(values3, false);
var equation = new RelationalOperation(
ComparisonOperators.Equals,
new NomialExpression(
new ProductTerm(scalar, matrix)
),
new ProductTerm(new NumericFactor(1), matrixResult)
);
return(equation);
}
/// <summary>
/// Choleskies the solve.
/// </summary>
/// <param name="matrix1">The matrix1.</param>
/// <param name="matrix2">The matrix2.</param>
/// <param name="matrixResult">The matrix result.</param>
/// <returns></returns>
public static RelationalOperation CholeskySolve(NumericMatrixFactor matrix1, NumericMatrixFactor matrix2, out NumericMatrixFactor matrixResult)
{
var values1 = matrix1.Coefficients;
var cMatrix1 = new NumericMatrixFactor(matrix1, new VariableFactor('C', 1), null);
var values2 = matrix2.Coefficients;
var cMatrix2 = new NumericMatrixFactor(matrix2, new VariableFactor('C', 1), null);
var solver = new CholeskyDecomposition(values1.AsSpan2D());
var values3 = solver.Solve(values2).Items;
matrixResult = new NumericMatrixFactor(values3, false);
var equation = new RelationalOperation(
ComparisonOperators.Equals,
new NomialExpression(
new ProductTerm(new NumericFactor(1), cMatrix1, cMatrix2)
),
new ProductTerm(new NumericFactor(1), matrixResult)
);
return(equation);
}
private static string GetNewEqualityTestCode(AssignmentExpression assignmentExpression)
{
RelationalOperation relationalOperation = new RelationalOperation(assignmentExpression.LeftSide.Clone() as Expression,
RelationalOperator.Equality,
assignmentExpression.RightSide.Clone() as Expression);
string newEqualityTest = CodeRush.Language.GenerateElement(relationalOperation);
return newEqualityTest;
}
private static DataArray<double> PerformRelationalOperation(DataArray<double> data, double value, RelationalOperation operation)
{
if (data == null)
{
throw new ArgumentNullException("data", "DataArray<double> must not be null.");
}
var array = new DataArray<double>(data.Count);
for (int i = 0; i < data.StartIndex; i++)
{
array.Add(0.0);
}
switch (operation)
{
case RelationalOperation.Equal:
for (int j = data.StartIndex; j < data.Count; j++)
{
array.Add(Convert.ToDouble(data[j] == value));
}
break;
case RelationalOperation.NotEqual:
for (int k = data.StartIndex; k < data.Count; k++)
{
array.Add(Convert.ToDouble(data[k] != value));
}
break;
case RelationalOperation.Greater:
for (int m = data.StartIndex; m < data.Count; m++)
{
array.Add(Convert.ToDouble(data[m] > value));
}
break;
case RelationalOperation.GreaterEqual:
for (int n = data.StartIndex; n < data.Count; n++)
{
array.Add(Convert.ToDouble(data[n] >= value));
}
break;
case RelationalOperation.Less:
for (int num6 = data.StartIndex; num6 < data.Count; num6++)
{
array.Add(Convert.ToDouble(data[num6] < value));
}
break;
case RelationalOperation.LessEqual:
for (int num7 = data.StartIndex; num7 < data.Count; num7++)
{
array.Add(Convert.ToDouble(data[num7] <= value));
}
break;
}
array.StartIndex = data.StartIndex;
return array;
}
private static DataArray<double> PerformRelationalOperation(DataArray<double> data1, DataArray<double> data2,
RelationalOperation operation)
{
if (data1 == null)
{
throw new ArgumentNullException("data1", "DataArray<double> must not be null.");
}
if (data2 == null)
{
throw new ArgumentNullException("data2", "DataArray<double> must not be null.");
}
if (data1.Count != data2.Count)
{
throw new ArgumentException("Array sizes do not match.", "data1");
}
var array = new DataArray<double>(data1.Count);
DataArray<double> array2 = data2;
if (data1.StartIndex > data2.StartIndex)
{
array2 = data1;
}
for (int i = 0; i < array2.StartIndex; i++)
{
array.Add(0.0);
}
switch (operation)
{
case RelationalOperation.Equal:
for (int j = array2.StartIndex; j < array2.Count; j++)
{
array.Add(Convert.ToDouble(data1[j] == data2[j]));
}
break;
case RelationalOperation.NotEqual:
for (int k = array2.StartIndex; k < array2.Count; k++)
{
array.Add(Convert.ToDouble(data1[k] != data2[k]));
}
break;
case RelationalOperation.Greater:
for (int m = array2.StartIndex; m < array2.Count; m++)
{
array.Add(Convert.ToDouble(data1[m] > data2[m]));
}
break;
case RelationalOperation.GreaterEqual:
for (int n = array2.StartIndex; n < array2.Count; n++)
{
array.Add(Convert.ToDouble(data1[n] >= data2[n]));
}
break;
case RelationalOperation.Less:
for (int num6 = array2.StartIndex; num6 < array2.Count; num6++)
{
array.Add(Convert.ToDouble(data1[num6] < data2[num6]));
}
break;
case RelationalOperation.LessEqual:
for (int num7 = array2.StartIndex; num7 < array2.Count; num7++)
{
array.Add(Convert.ToDouble(data1[num7] <= data2[num7]));
}
break;
}
array.StartIndex = array2.StartIndex;
return array;
}
/// <summary>
/// Interprets the given words into a logical model.
/// As there are different possible approaches, we choose a left to right packing method to provide
/// a readable debug string for the user.
/// </summary>
internal static BooleanExpression InterpretBooleanExpression(Terminals data, IProcessingData context)
{
if (data.IsEndReached)
{
return(null);
}
BooleanExpression currentExpression = null;
// B -> ( B )
if (data.Current == "(")
{
data.MoveNext();
BooleanExpression subExpression = InterpretBooleanExpression(data, context);
if (data.IsEndReached || data.Current != ")")
{
return(new Grouping(currentExpression, false));
}
data.MoveNext();
currentExpression = new Grouping(subExpression, true);
if (data.IsEndReached)
{
return(currentExpression);
}
}
// B -> I B
if (LogicalInverter.Values.Contains(data.Current))
{
data.MoveNext();
BooleanExpression nextExpression = InterpretBooleanExpression(data, context);
currentExpression = new LogicalInverter(nextExpression);
if (data.IsEndReached)
{
return(currentExpression);
}
}
// B -> b
if (IsRepresentingBoolean(data.Current, context))
{
currentExpression = InterpretBoolean(data.Current, context);
data.MoveNext();
if (data.IsEndReached)
{
return(currentExpression);
}
}
// B -> N R N
else if (IsRepresentingNumerical(data.Current, context))
{
// N -> n
Numerical.NumericalExpression leftNumber = Numerical.Interpreter.AsNumericalExpression(data.Current, context);
data.MoveNext();
if (data.IsEndReached)
{
return(null);
}
// R -> r
string relation = data.Current;
if (!RelationalOperation.Values.Contains(relation))
{
return(null);
}
data.MoveNext();
if (data.IsEndReached)
{
return(null);
}
// N -> n
if (!IsRepresentingNumerical(data.Current, context))
{
return(null);
}
Numerical.NumericalExpression rightNumber = Numerical.Interpreter.AsNumericalExpression(data.Current, context);
currentExpression = new RelationalOperation(relation, leftNumber, rightNumber);
data.MoveNext();
if (data.IsEndReached)
{
return(currentExpression);
}
}
// B -> B E B
if (LogicalCombination.Values.Contains(data.Current))
{
string combination = data.Current;
data.MoveNext();
BooleanExpression nextExpression = InterpretBooleanExpression(data, context);
return(new LogicalCombination(combination, currentExpression, nextExpression));
}
if (data.Current == ")")
{
return(currentExpression);
}
return(currentExpression); // Partial failure
}
private static DataArray <double> PerformRelationalOperation(DataArray <double> data, double value, RelationalOperation operation)
{
if (data == null)
{
throw new ArgumentNullException("data", "DataArray<double> must not be null.");
}
var array = new DataArray <double>(data.Count);
for (int i = 0; i < data.StartIndex; i++)
{
array.Add(0.0);
}
switch (operation)
{
case RelationalOperation.Equal:
for (int j = data.StartIndex; j < data.Count; j++)
{
array.Add(Convert.ToDouble(data[j] == value));
}
break;
case RelationalOperation.NotEqual:
for (int k = data.StartIndex; k < data.Count; k++)
{
array.Add(Convert.ToDouble(data[k] != value));
}
break;
case RelationalOperation.Greater:
for (int m = data.StartIndex; m < data.Count; m++)
{
array.Add(Convert.ToDouble(data[m] > value));
}
break;
case RelationalOperation.GreaterEqual:
for (int n = data.StartIndex; n < data.Count; n++)
{
array.Add(Convert.ToDouble(data[n] >= value));
}
break;
case RelationalOperation.Less:
for (int num6 = data.StartIndex; num6 < data.Count; num6++)
{
array.Add(Convert.ToDouble(data[num6] < value));
}
break;
case RelationalOperation.LessEqual:
for (int num7 = data.StartIndex; num7 < data.Count; num7++)
{
array.Add(Convert.ToDouble(data[num7] <= value));
}
break;
}
array.StartIndex = data.StartIndex;
return(array);
}
private static DataArray <double> PerformRelationalOperation(DataArray <double> data1, DataArray <double> data2,
RelationalOperation operation)
{
if (data1 == null)
{
throw new ArgumentNullException("data1", "DataArray<double> must not be null.");
}
if (data2 == null)
{
throw new ArgumentNullException("data2", "DataArray<double> must not be null.");
}
if (data1.Count != data2.Count)
{
throw new ArgumentException("Array sizes do not match.", "data1");
}
var array = new DataArray <double>(data1.Count);
DataArray <double> array2 = data2;
if (data1.StartIndex > data2.StartIndex)
{
array2 = data1;
}
for (int i = 0; i < array2.StartIndex; i++)
{
array.Add(0.0);
}
switch (operation)
{
case RelationalOperation.Equal:
for (int j = array2.StartIndex; j < array2.Count; j++)
{
array.Add(Convert.ToDouble(data1[j] == data2[j]));
}
break;
case RelationalOperation.NotEqual:
for (int k = array2.StartIndex; k < array2.Count; k++)
{
array.Add(Convert.ToDouble(data1[k] != data2[k]));
}
break;
case RelationalOperation.Greater:
for (int m = array2.StartIndex; m < array2.Count; m++)
{
array.Add(Convert.ToDouble(data1[m] > data2[m]));
}
break;
case RelationalOperation.GreaterEqual:
for (int n = array2.StartIndex; n < array2.Count; n++)
{
array.Add(Convert.ToDouble(data1[n] >= data2[n]));
}
break;
case RelationalOperation.Less:
for (int num6 = array2.StartIndex; num6 < array2.Count; num6++)
{
array.Add(Convert.ToDouble(data1[num6] < data2[num6]));
}
break;
case RelationalOperation.LessEqual:
for (int num7 = array2.StartIndex; num7 < array2.Count; num7++)
{
array.Add(Convert.ToDouble(data1[num7] <= data2[num7]));
}
break;
}
array.StartIndex = array2.StartIndex;
return(array);
}
/// <summary>
/// Initializes a new instance of the <see cref="CanvasControl"/> class.
/// </summary>
public CanvasControl()
{
DoubleBuffered = true;
InitializeComponent();
Expression = new RelationalOperation(ComparisonOperators.Equals, null, null);
}
