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;