public override object Evaluate(object source = null) { var left = LeftOperand.Evaluate(); var right = RightOperand.Evaluate(); switch (Operator) { case QueryComparisonOperator.Equal: return((dynamic)left == (dynamic)right); case QueryComparisonOperator.NotEqual: return((dynamic)left != (dynamic)right); case QueryComparisonOperator.GreaterThan: return((dynamic)left > (dynamic)right); case QueryComparisonOperator.GreaterThanOrEqual: return((dynamic)left >= (dynamic)right); case QueryComparisonOperator.LessThan: return((dynamic)left < (dynamic)right); case QueryComparisonOperator.LessThanOrEqual: return((dynamic)left <= (dynamic)right); default: throw new StorageArgumentOutOfRangeException(nameof(Operator), $"Operator {Operator} not supported"); } }
// Evaluate the expression. public float Evaluate() { switch (Operator) { case Operators.Literal: return(float.Parse(LiteralText)); case Operators.Plus: return(LeftOperand.Evaluate() + RightOperand.Evaluate()); case Operators.Minus: return(LeftOperand.Evaluate() - RightOperand.Evaluate()); case Operators.Times: return(LeftOperand.Evaluate() * RightOperand.Evaluate()); case Operators.Divide: return(LeftOperand.Evaluate() / RightOperand.Evaluate()); case Operators.Negate: return(-LeftOperand.Evaluate()); } throw new ArithmeticException("Unknown operator " + Operator.ToString()); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IEvaluationContext evalContext) { var left = LeftOperand.Evaluate(evalContext); var right = RightOperand.Evaluate(evalContext); switch (left.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: var leftNum = left.AsLong(); switch (right.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: return(new ExpressionValue(leftNum ^ right.AsLong())); case ExpressionValueType.Real: case ExpressionValueType.String: EvaluationError = RIGHT_OPER_ERROR; return(ExpressionValue.Error); default: return(ExpressionValue.Error); } case ExpressionValueType.Real: case ExpressionValueType.String: EvaluationError = LEFT_OPER_ERROR; return(ExpressionValue.Error); default: return(ExpressionValue.Error); } }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IExpressionEvaluationContext evalContext) { // --- Check operands for errors var leftValue = LeftOperand.Evaluate(evalContext); if (leftValue.Type == ExpressionValueType.Error) { EvaluationError = LeftOperand.EvaluationError; return(ExpressionValue.Error); } var rightValue = RightOperand.Evaluate(evalContext); if (rightValue.Type == ExpressionValueType.Error) { EvaluationError = RightOperand.EvaluationError; return(ExpressionValue.Error); } // --- Test for incompatible types if (leftValue.Type == ExpressionValueType.ByteArray || rightValue.Type == ExpressionValueType.ByteArray) { EvaluationError = "'>>' operator cannot be applied on a byte array"; return(ExpressionValue.Error); } // --- Numeric operands return(new ExpressionValue(leftValue.AsNumber() >> (ushort)rightValue.AsNumber())); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IEvaluationContext evalContext) { var left = LeftOperand.Evaluate(evalContext); var right = RightOperand.Evaluate(evalContext); switch (left.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: var leftNum = left.AsLong(); switch (right.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: return(new ExpressionValue(leftNum >= right.AsLong())); case ExpressionValueType.Real: return(new ExpressionValue(leftNum >= right.AsReal())); case ExpressionValueType.String: EvaluationError = "Cannot compare an integer number with a string"; return(ExpressionValue.Error); default: return(ExpressionValue.Error); } case ExpressionValueType.Real: var leftReal = left.AsReal(); switch (right.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: return(new ExpressionValue(leftReal >= right.AsLong())); case ExpressionValueType.Real: return(new ExpressionValue(leftReal >= right.AsReal())); case ExpressionValueType.String: EvaluationError = "Cannot compare an integer number with a string"; return(ExpressionValue.Error); default: return(ExpressionValue.Error); } case ExpressionValueType.String: if (right.Type == ExpressionValueType.String) { return(new ExpressionValue(string.CompareOrdinal(left.AsString(), right.AsString()) >= 0)); } EvaluationError = "String can be compared only to another string"; return(ExpressionValue.Error); default: return(ExpressionValue.Error); } }
public bool Evaluate(IReadOnlyMemory memory) { var leftValue = LeftOperand.Evaluate(memory).ToInt(); var rightValue = RightOperand.Evaluate(memory).ToInt(); var result = EvaluateExpression(leftValue, rightValue, Operation); return(result); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IExpressionEvaluationContext evalContext) { var left = LeftOperand.Evaluate(evalContext); var right = RightOperand.Evaluate(evalContext); SuggestWiderType(); return(left.IsValid && right.IsValid ? new ExpressionValue(left.Value >> (int)right.Value) : ExpressionValue.Error); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IExpressionEvaluationContext evalContext) { var left = LeftOperand.Evaluate(evalContext); var right = RightOperand.Evaluate(evalContext); SuggestType(ExpressionValueType.Bool); return(left.IsValid && right.IsValid ? new ExpressionValue(left.Value >= right.Value ? 1u : 0u) : ExpressionValue.Error); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ushort Calculate(IEvaluationContext evalContext) { var divider = RightOperand.Evaluate(evalContext); if (divider != 0) { return((ushort)(LeftOperand.Evaluate(evalContext) / divider)); } EvaluationError = "Divide by zero error"; return(0); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IExpressionEvaluationContext evalContext) { // --- Check operands for errors var leftValue = LeftOperand.Evaluate(evalContext); if (leftValue.Type == ExpressionValueType.Error) { EvaluationError = LeftOperand.EvaluationError; return(ExpressionValue.Error); } var rightValue = RightOperand.Evaluate(evalContext); if (rightValue.Type == ExpressionValueType.Error) { EvaluationError = RightOperand.EvaluationError; return(ExpressionValue.Error); } // --- Test if both operands are byte arrays if (leftValue.Type == ExpressionValueType.ByteArray) { if (rightValue.Type != ExpressionValueType.ByteArray) { EvaluationError = "Cannot apply bitwise XOR on a numeric value and a byte array"; return(ExpressionValue.Error); } // --- Bitwise XOR each array elements (shortest) var leftArray = leftValue.AsByteArray(); var rightArray = rightValue.AsByteArray(); var shortest = leftArray.Length > rightArray.Length ? leftArray.Length : rightArray.Length; var resultArray = new byte[shortest]; for (var i = 0; i < shortest; i++) { resultArray[i] = (byte)(leftArray[i] ^ rightArray[i]); } return(new ExpressionValue(resultArray)); } // --- Test incompatible types if (rightValue.Type == ExpressionValueType.ByteArray) { EvaluationError = "Cannot apply bitwise XOR on a byte array and a numeric value"; return(ExpressionValue.Error); } // --- Numeric operands return(new ExpressionValue(leftValue.AsNumber() ^ rightValue.AsNumber())); }
public override void Evaluate([CanBeNull] object parameter, [NotNull] RuleStack stack) { Assert.ArgumentNotNull(stack, nameof(stack)); LeftOperand.Evaluate(parameter, stack); var left = (bool)stack.Pop(); if (!left) { stack.Push(false); return; } RightOperand.Evaluate(parameter, stack); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IEvaluationContext evalContext) { var left = LeftOperand.Evaluate(evalContext); var right = RightOperand.Evaluate(evalContext); if (left.Type != ExpressionValueType.Bool && left.Type != ExpressionValueType.Integer) { EvaluationError = "The left operand of the shift left operator must be integral"; return(ExpressionValue.Error); } if (right.Type != ExpressionValueType.Bool && right.Type != ExpressionValueType.Integer) { EvaluationError = "Right operand of the shift left operator must be integral"; return(ExpressionValue.Error); } return(new ExpressionValue(left.AsLong() << (ushort)right.AsLong())); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IExpressionEvaluationContext evalContext) { // --- Check operands for errors var leftValue = LeftOperand.Evaluate(evalContext); if (leftValue.Type == ExpressionValueType.Error) { EvaluationError = LeftOperand.EvaluationError; return(ExpressionValue.Error); } var rightValue = RightOperand.Evaluate(evalContext); if (rightValue.Type == ExpressionValueType.Error) { EvaluationError = RightOperand.EvaluationError; return(ExpressionValue.Error); } // --- Test if both operands are byte arrays if (leftValue.Type == ExpressionValueType.ByteArray) { if (rightValue.Type != ExpressionValueType.ByteArray) { EvaluationError = "Cannot add a numeric value to a byte array"; return(ExpressionValue.Error); } // --- Concatenate the two byte arrays var leftArray = leftValue.AsByteArray(); var rightArray = rightValue.AsByteArray(); var resultArray = new byte[leftArray.Length + rightArray.Length]; System.Buffer.BlockCopy(leftArray, 0, resultArray, 0, leftArray.Length); System.Buffer.BlockCopy(rightArray, 0, resultArray, leftArray.Length, rightArray.Length); return(new ExpressionValue(resultArray)); } // --- Test for incompatible types if (rightValue.Type == ExpressionValueType.ByteArray) { EvaluationError = "Cannot add a byte array to a numeric value"; return(ExpressionValue.Error); } // --- Numeric operands return(new ExpressionValue(leftValue.AsNumber() + rightValue.AsNumber())); }
public override object Evaluate(object source = null) { switch (Operator) { case QueryLogicalOperator.And: return((bool)LeftOperand.Evaluate() && (bool)RightOperand.Evaluate()); case QueryLogicalOperator.Or: return((bool)LeftOperand.Evaluate() || (bool)RightOperand.Evaluate()); case QueryLogicalOperator.Not: return(!(bool)LeftOperand.Evaluate()); default: throw new StorageArgumentOutOfRangeException(nameof(Operator), $"Operator {Operator} not supported"); } }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IExpressionEvaluationContext evalContext) { var left = LeftOperand.Evaluate(evalContext); var right = RightOperand.Evaluate(evalContext); if (!left.IsValid || !right.IsValid) { return(ExpressionValue.Error); } if (right.Value != 0) { SuggestWiderType(); return(new ExpressionValue(left.Value % right.Value)); } EvaluationError = "Divide by zero error"; return(ExpressionValue.Error); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IExpressionEvaluationContext evalContext) { // --- Check operands for errors var leftValue = LeftOperand.Evaluate(evalContext); if (leftValue.Type == ExpressionValueType.Error) { EvaluationError = LeftOperand.EvaluationError; return(ExpressionValue.Error); } var rightValue = RightOperand.Evaluate(evalContext); if (rightValue.Type == ExpressionValueType.Error) { EvaluationError = RightOperand.EvaluationError; return(ExpressionValue.Error); } // --- Test if both operands are byte arrays if (leftValue.Type == ExpressionValueType.ByteArray) { if (rightValue.Type != ExpressionValueType.ByteArray) { EvaluationError = "Byte array can be compared only to byte array"; return(ExpressionValue.Error); } return(new ExpressionValue(!leftValue.AsByteArray().SequenceEqual(rightValue.AsByteArray()))); } // --- Test for incompatible types if (rightValue.Type == ExpressionValueType.ByteArray) { EvaluationError = "Cannot compare a byte array with a numeric value"; return(ExpressionValue.Error); } // --- Numeric operands return(new ExpressionValue(leftValue.AsNumber() != (ushort)rightValue.AsNumber())); }
// Evaluate the expression. public float Evaluate() { switch (Operator) { case Operators.Literal: return(float.Parse(LiteralText)); case Operators.Plus: return(LeftOperand.Evaluate() + RightOperand.Evaluate()); case Operators.Minus: return(LeftOperand.Evaluate() - RightOperand.Evaluate()); case Operators.Times: return(LeftOperand.Evaluate() * RightOperand.Evaluate()); case Operators.Divide: return(LeftOperand.Evaluate() / RightOperand.Evaluate()); case Operators.Negate: return(-LeftOperand.Evaluate()); case Operators.SquareRoot: return((float)Math.Sqrt(LeftOperand.Evaluate())); case Operators.Factorial: return(Factorial(LeftOperand.Evaluate())); case Operators.Sine: return((float)Math.Sin(Math.PI / 180.0 * LeftOperand.Evaluate())); case Operators.Squared: float left = LeftOperand.Evaluate(); return(left * left); } throw new ArithmeticException("Unknown operator " + Operator.ToString()); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ushort Calculate(IEvaluationContext evalContext) => (ushort)(LeftOperand.Evaluate(evalContext) & RightOperand.Evaluate(evalContext));
public override double Evaluate() { return(LeftOperand.Evaluate() - RightOperand.Evaluate()); }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IEvaluationContext evalContext) { var left = LeftOperand.Evaluate(evalContext); var right = RightOperand.Evaluate(evalContext); switch (right.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: var rightNum = right.AsLong(); if (rightNum == 0) { EvaluationError = DIV_BY_ZERO_ERROR; return(ExpressionValue.Error); } switch (left.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: return(new ExpressionValue(left.AsLong() / rightNum)); case ExpressionValueType.Real: return(new ExpressionValue(left.AsReal() / rightNum)); case ExpressionValueType.String: EvaluationError = LEFT_STRING_ERROR; return(ExpressionValue.Error); default: return(ExpressionValue.Error); } case ExpressionValueType.Real: var rightReal = right.AsReal(); if (Math.Abs(rightReal) < double.Epsilon) { EvaluationError = DIV_BY_ZERO_ERROR; return(ExpressionValue.Error); } switch (left.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: return(new ExpressionValue(left.AsLong() / rightReal)); case ExpressionValueType.Real: return(new ExpressionValue(left.AsReal() / rightReal)); case ExpressionValueType.String: EvaluationError = LEFT_STRING_ERROR; return(ExpressionValue.Error); default: return(ExpressionValue.Error); } case ExpressionValueType.String: EvaluationError = RIGHT_STRING_ERROR; return(ExpressionValue.Error); default: return(ExpressionValue.Error); } }
/// <summary> /// Calculates the result of the binary operation. /// </summary> /// <param name="evalContext">Evaluation context</param> /// <returns>Result of the operation</returns> public override ExpressionValue Calculate(IEvaluationContext evalContext) { var left = LeftOperand.Evaluate(evalContext); var right = RightOperand.Evaluate(evalContext); switch (left.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: var leftNum = left.AsLong(); switch (right.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: return(new ExpressionValue(leftNum + right.AsLong())); case ExpressionValueType.Real: return(new ExpressionValue(leftNum + right.AsReal())); case ExpressionValueType.String: EvaluationError = "Cannot add an integral value and a string"; return(ExpressionValue.Error); default: return(ExpressionValue.Error); } case ExpressionValueType.Real: var leftReal = left.AsReal(); switch (right.Type) { case ExpressionValueType.Bool: case ExpressionValueType.Integer: return(new ExpressionValue(leftReal + right.AsLong())); case ExpressionValueType.Real: return(new ExpressionValue(leftReal + right.AsReal())); case ExpressionValueType.String: EvaluationError = "Cannot add a real value and a string"; return(ExpressionValue.Error); default: return(ExpressionValue.Error); } case ExpressionValueType.String: if (right.Type == ExpressionValueType.String) { return(new ExpressionValue($"{left.AsString()}{right.AsString()}")); } else { EvaluationError = "Only a string can be added to a string"; return(ExpressionValue.Error); } default: return(ExpressionValue.Error); } }
public override int Evaluate() { return(LeftOperand.Evaluate() + RightOperand.Evaluate()); }