public override Expression Visit(ComplexExpression complex)
{
var expressions = new List<Expression>();
int count = complex.Count;
for (int i = 0; i < count; i++)
{
bool found = false;
var left = complex[i];
for (int j=i+1;j<count;j++)
{
var right = complex[j];
if (left == right)
{
found = true;
}
}
if (!found)
expressions.Add(left);
}
if (expressions.Count == 1)
return expressions[0];
return expressions.Count != count ? new ComplexExpression(complex.Operator, expressions) : complex;
}
public override Expression Visit(ComplexExpression complex)
{
var expressions = new List<Expression>();
if (complex.Operator == Operator.And)
{
foreach (var expression in complex)
{
if (expression == Expression.False)
return Expression.False;
if (expression != Expression.True)
expressions.Add(expression);
}
}
else
{
foreach (var expression in complex)
{
if (expression == Expression.True)
return Expression.True;
if (expression != Expression.False)
expressions.Add(expression);
}
}
if (expressions.Count == 0)
return complex.Operator == Operator.And ? Expression.True : Expression.False;
if (expressions.Count == 1)
return expressions[0];
if (expressions.Count != complex.Count)
{
return new ComplexExpression(complex.Operator, expressions);
}
return complex;
}
public override Expression Visit(ComplexExpression complex)
{
if (complex.Operator == Operator.And)
{
var andExpressions = new List<Expression>();
var orExpressions = new List<ComplexExpression>();
foreach (var expression in complex)
{
var inner = expression as ComplexExpression;
if (inner != null && inner.Operator == Operator.Or)
{
orExpressions.Add(inner);
}
else
{
andExpressions.Add(expression);
}
}
if (orExpressions.Count == 0)
return complex;
var product = orExpressions.Select(x => x).CartesianProduct();
var result =
product.Select(p => new ComplexExpression(Operator.And, p.Concat(andExpressions)));
return new ComplexExpression(Operator.Or, result);
}
return complex;
}
public static IExpression Build(List <ISymbol> RPNStack)
{
List <IExpression> stack = new List <IExpression>();
var i = 0;
try
{
for (i = 0; i < RPNStack.Count; i++)
{
var s = RPNStack[i];
if (s.Type != SymbolTypes.Number)
{
if (s.Type == SymbolTypes.BinaryOperator)
{
var tmp = new BinaryExpression(stack[stack.Count - 2], Operators.Get(s.Value).Type, stack[stack.Count - 1]);
stack.RemoveAt(stack.Count - 1);
stack.RemoveAt(stack.Count - 1);
stack.Add(tmp);
}
else if (s.Type == SymbolTypes.UnaryOperator)
{
var tmp = new UnaryExpression(Operators.Get(s.Value).Type, stack[stack.Count - 1]);
stack.RemoveAt(stack.Count - 1);
stack.Add(tmp);
}
else if (s.Type == SymbolTypes.Function)
{
var tmp = Functions.Get(s.Value, stack[stack.Count - 1]);
stack.RemoveAt(stack.Count - 1);
stack.Add(tmp);
}
else if (s.Type == SymbolTypes.Variable)
{
var tmp = new VariableExpression(s.Value, 1m);
stack.RemoveAt(stack.Count - 1);
stack.Add(tmp);
}
else if (s.Type == SymbolTypes.Imaginary)
{
var tmp = new ComplexExpression(1m);
stack.RemoveAt(stack.Count - 1);
stack.Add(tmp);
}
}
else
{
stack.Add(new NumberExpression(s.Value));
}
}
}
catch (Exception ex)
{
var msg = "I couldn't undertand what you mean by '" + RPNStack[i].Value + "' before " + string.Join("", stack);
throw new WrongSyntaxException(msg, ex);
}
return(stack[0]);
}
public override Expression Visit(ComplexExpression complex)
{
bool modified = false;
var expressions = new List<Expression>();
foreach (var expression in complex)
{
var visited = expression.Accept(this);
expressions.Add(visited);
if (visited != expression)
modified = true;
}
return modified ? new ComplexExpression(complex.Operator, expressions) : complex;
}
public void Sign_Complex()
{
//Arrange
var expected = new ComplexExpression(-4, -3);
var c = new ComplexExpression(4, 3);
var expr = new UnaryExpression(OperatorTypes.Sign, c);
//Act
var actual = (ComplexExpression)expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
Assert.AreEqual(expected.Count.Im.ToNumber(), actual.Count.Im.ToNumber());
}
public void Subtract_Complex_ResultAsNumber()
{
//Arrange
var expected = new NumberExpression(1);
var c = new ComplexExpression(2, 3);
var n = new ComplexExpression(1, 3);
var expr = new BinaryExpression(c, OperatorTypes.Subtract, n);
//Act
var actual = (NumberExpression)expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
}
public void Pow_Complex_0()
{
//Arrange
var expected = new NumberExpression(1);
var c = new ComplexExpression(-2, 3);
var n = new NumberExpression(0);
var expr = new BinaryExpression(c, OperatorTypes.Power, n);
//Act
var actual = (NumberExpression)expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
}
public void Expression_Or_Success()
{
var left = new ComplexExpression {
Left = new Value(88), Right = new Value(16.789), Operator = new EqualOperator()
};
var right = new ComplexExpression {
Left = new Value(55), Right = new Value(55), Operator = new EqualOperator()
};
var expression = new ComplexExpression {
Left = left, Right = right, Operator = new OrOperator()
};
Assert.IsTrue(expression.EvaluateToBool(_context));
}
public void Multiply_Number_Complex()
{
//Arrange
var expected = new ComplexExpression(2, -6);
var c = new NumberExpression(2);
var n = new ComplexExpression(1, -3);
var expr = new BinaryExpression(c, OperatorTypes.Multiply, n);
//Act
var actual = (ComplexExpression)expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
Assert.AreEqual(expected.Count.Im.ToNumber(), actual.Count.Im.ToNumber());
}
public void Divide_Complex_Complex()
{
//Arrange
var expected = new ComplexExpression(new Fraction(-7, 10), new Fraction(9, 10));
var c = new ComplexExpression(2, 3);
var n = new ComplexExpression(1, -3);
var expr = new BinaryExpression(c, OperatorTypes.Divide, n);
//Act
var actual = (ComplexExpression)expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
Assert.AreEqual(expected.Count.Im.ToNumber(), actual.Count.Im.ToNumber());
}
public void Add_Complex_NegativeNumber()
{
//Arrange
var expected = new ComplexExpression(1, 3);
var c = new ComplexExpression(2, 3);
var n = new NumberExpression(-1);
var expr = new BinaryExpression(c, OperatorTypes.Add, n);
//Act
var actual = (ComplexExpression)expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
Assert.AreEqual(expected.Count.Im.ToNumber(), actual.Count.Im.ToNumber());
}
public override Expression Visit(ComplexExpression complex)
{
bool modified = false;
var expressions = new List<Expression>();
foreach (var expression in complex)
{
var nestedComplex = expression as ComplexExpression;
if (nestedComplex != null && nestedComplex.Operator == complex.Operator)
{
expressions.AddRange(nestedComplex);
modified = true;
}
else
{
expressions.Add(expression);
}
}
return modified ? new ComplexExpression(complex.Operator, expressions) : complex;
}
public void Expression_NotEqualOperator_Success()
{
var expression1 = new ComplexExpression {
Left = new Value(88), Right = new Value(48), Operator = new NotEqualOperator()
};
var expression2 = new ComplexExpression {
Left = new Value(88.99), Right = new Value(88.98), Operator = new NotEqualOperator()
};
var expression3 = new ComplexExpression {
Left = new Value(true), Right = new Value(false), Operator = new NotEqualOperator()
};
var expression4 = new ComplexExpression {
Left = new Value("bob"), Right = new Value("fred"), Operator = new NotEqualOperator()
};
Assert.IsTrue(expression1.EvaluateToBool(_context));
Assert.IsTrue(expression2.EvaluateToBool(_context));
Assert.IsTrue(expression3.EvaluateToBool(_context));
Assert.IsTrue(expression4.EvaluateToBool(_context));
}
public void Expression_GreaterThan_Success()
{
var expression1 = new ComplexExpression {
Left = new Value(127), Right = new Value(5), Operator = new GreaterThanOperator()
};
var expression2 = new ComplexExpression {
Left = new Value(127.77), Right = new Value(127.76999), Operator = new GreaterThanOperator()
};
var expression3 = new ComplexExpression {
Left = new Value(true), Right = new Value(false), Operator = new GreaterThanOperator()
};
var expression4 = new ComplexExpression {
Left = new Value("bobfred"), Right = new Value("bob"), Operator = new GreaterThanOperator()
};
Assert.IsTrue(expression1.EvaluateToBool(_context));
Assert.IsTrue(expression2.EvaluateToBool(_context));
Assert.IsTrue(expression3.EvaluateToBool(_context));
Assert.IsTrue(expression4.EvaluateToBool(_context));
}
public override Expression Visit(ComplexExpression complex)
{
for (int i = 0; i < complex.Count; i++)
{
var left =complex[i];
for (int j = i + 1; j < complex.Count; j++)
{
var right = complex[j];
if ((left is NotExpression && ((NotExpression)left).Operand == right )||
(right is NotExpression && ((NotExpression)right).Operand == left))
{
return complex.Operator == Operator.And ? Expression.False : Expression.True;
}
}
}
return complex;
}
public override Expression Visit(ComplexExpression complex)
{
//for (int i = 0; i < complex.Count; i++)
//{
// Expression left = complex[i];
// for (int j = i+1;j<complex.Count;j++)
// {
// Expression right = complex[j];
// var complexRight = right as ComplexExpression;
// if (complexRight != null && complex.Operator != complexRight.Operator)
// {
// if (complexRight.Any(x=>x==left))
// {
// }
// }
// }
//}
return complex;
}
internal ComplexAddExpression(ComplexExpression Left, ComplexExpression Right)
: base(Left, Right, (L, R) => Add(L.Re, R.Re), (L, R) => Add(L.Im, R.Im))
{
}
public IEquationSolutions Solve(IExpression expression, string variable, IClassificationResult classification)
{
var res = new EquationSolutions();
IExpression a = null;
IExpression b = null;
List <IExpression> ba = new List <IExpression>();
if (expression is FlatAddExpression fa)
{
foreach (var expr in fa.Expressions)
{
if (expr.Value[0] is FlatExpression fe)
{
if (fe.Expressions.Any(e => e.Key == variable))
{
if (expr.Value[0] is VariableExpression)
{
a = new ComplexExpression(expr.Value[0].Count);
}
else
{
var tmp = (FlatExpression)expr.Value[0].Clone();
tmp.Remove(variable, 1);
a = tmp;
}
}
}
else if (expr.Key == variable)
{
if (expr.Value[0] is VariableExpression)
{
a = new ComplexExpression(expr.Value[0].Count);
}
else
{
var tmp = (FlatExpression)expr.Value[0].Clone();
tmp.Remove(variable, 1);
a = tmp;
}
}
else
{
ba.Add(expr.Value[0]);
}
}
if (ba.Count > 1)
{
b = new FlatAddExpression();
var ct = (FlatAddExpression)b;
foreach (var ci in ba)
{
ct.Add(ci);
}
}
else if (ba.Count == 1)
{
b = ba[0];
}
var sol = new BinaryExpression(new UnaryExpression(Enums.Operators.OperatorTypes.Sign, b), Enums.Operators.OperatorTypes.Divide, a).Execute();
res.Solutions.Add(variable, new Tuple <IExpression, List <IExpression> >(classification.SearchResult[variable].Item1, new List <IExpression>()
{
sol
}));
}
return(res);
}
public IEquationSolutions Solve(IExpression expression, string variable, IClassificationResult classification)
{
var res = new EquationSolutions();
if (expression is FlatAddExpression fa)
{
IExpression a = null;
IExpression b = null;
IExpression c = null;
List <IExpression> ca = new List <IExpression>();
for (int i = 0; i < fa.Expressions.Count; i++)
{
var kv = fa.Expressions.ElementAt(i);
var deg = kv.Value[0].DimensionKey.Value;
var key = kv.Value[0].DimensionKey.Key;
var expr = kv.Value[0];
if (deg.ToNumber() == 2 && key == variable)
{
if (expr is VariableExpression)
{
a = new ComplexExpression(expr.Count);
}
else if (expr is IFunctionExpression)
{
a = new ComplexExpression(expr.Count);
}
else
{
var tmp = (FlatExpression)expr.Clone();
tmp.Remove(variable, 2);
a = tmp;
}
}
else if (deg.ToNumber() == 1 && key == variable)
{
if (expr is VariableExpression)
{
b = new ComplexExpression(expr.Count);
}
else if (expr is IFunctionExpression)
{
b = new ComplexExpression(expr.Count);
}
else
{
var tmp = (FlatExpression)expr.Clone();
tmp.Remove(variable, 2);
b = tmp;
}
}
else
{
ca.Add(kv.Value[0]);
}
}
if (ca.Count > 1)
{
c = new FlatAddExpression();
var ct = (FlatAddExpression)c;
foreach (var ci in ca)
{
ct.Add(ci);
}
}
else if (ca.Count == 1)
{
c = ca[0];
}
if (a != null && c != null)
{
var delta = this.Delta(a, b, c);
var ds = new BinaryExpression(delta, Enums.Operators.OperatorTypes.Power, new NumberExpression(new Fraction(1, 2)));
var dsqrt = ds.Execute();
var r1 = X1X2(b, dsqrt, a, true);
var r2 = X1X2(b, dsqrt, a, false);
res.Solutions.Add(variable, new Tuple <IExpression, List <IExpression> >(classification.SearchResult[variable].Item1, new List <IExpression>()
{
r1.Execute()
}));
res.Solutions[variable].Item2.Add(r2.Execute());
}
}
return(res);
}
internal ComplexMultiplyExpression(ComplexExpression Left, ComplexExpression Right)
: base(Left, Right,
(L, R) => Subtract(Multiply(L.Re, R.Re), Multiply(L.Im, R.Im)),
(L, R) => Add(Multiply(L.Re, R.Im), Multiply(L.Im, R.Re)))
{
}
internal ComplexSubtractExpression(ComplexExpression Left, ComplexExpression Right)
: base(Left, Right, (L, R) => Subtract(L.Re, R.Re), (L, R) => Subtract(L.Im, R.Im))
{
}
public ComplexInverseExpression(ComplexExpression Value) : base(Value, z => Negate(z.Re), z => Negate(z.Im))
{
}
protected ComplexBinaryExpression(ComplexExpression Left, ComplexExpression Right)
{
this.Left = Left;
this.Right = Right;
}
public ComplexConjugateExpression(ComplexExpression Value) : base(Value, z => z.Re, z => Negate(z.Im))
{
}
protected ComplexUnaryExpression(ComplexExpression Value) => this.Value = Value;
