protected override double Operate(double arg1, double arg2, BinaryOperators operation) { switch (operation) { case BinaryOperators.Add: return(arg1 + arg2); case BinaryOperators.Subtract: return(arg1 - arg2); case BinaryOperators.Multiply: return(arg1 * arg2); case BinaryOperators.Divide: return(arg1 / arg2); case BinaryOperators.Exponent: return(Mathf.Pow(Convert.ToSingle(arg1), Convert.ToSingle(arg2))); case BinaryOperators.Mod: return(arg1 % arg2); case BinaryOperators.DivisibleBy: return(arg1 % arg2 < .0001f ? 1 : 0); case BinaryOperators.Max: return(arg1 > arg2 ? arg1 : arg2); case BinaryOperators.Min: return(arg1 < arg2 ? arg1 : arg2); default: throw new Exception("Unknown operation type!"); } }
protected override int Operate(int arg1, int arg2, BinaryOperators operation) { switch (operation) { case BinaryOperators.Add: return(arg1 + arg2); case BinaryOperators.Subtract: return(arg1 - arg2); case BinaryOperators.Multiply: return(arg1 * arg2); case BinaryOperators.Divide: return(arg1 / arg2); case BinaryOperators.Exponent: return(Mathf.FloorToInt(Mathf.Pow(arg1, arg2))); case BinaryOperators.Mod: return(arg1 % arg2); case BinaryOperators.DivisibleBy: return(arg1 % arg2 == 0 ? 1 : 0); case BinaryOperators.Max: return(Mathf.Max(arg1, arg2)); case BinaryOperators.Min: return(Mathf.Min(arg1, arg2)); default: throw new Exception("Unknown operation type!"); } }
public Condition(string left, string right, BinaryOperators opr) { Fields = new string[2] { left, right }; Operator = opr; }
public void Invoke(IExecutionContext context) { var value = context.Pop(); var arguments = new Object[] { 1.0, value }; context.Push(BinaryOperators.Sub(arguments)); }
public BoundBinaryExpression(BoundExpression left, BoundExpression right, BinaryOperators @operator, BinaryExpressionSyntax binaryExpressionSyntax, IType type) : base(binaryExpressionSyntax, type) { Left = left; Right = right; Operator = @operator; }
protected override Vector3 Operate(Vector3 arg1, Vector3 arg2, BinaryOperators operation) { switch (operation) { case BinaryOperators.Add: return(arg1 + arg2); case BinaryOperators.Subtract: return(arg1 - arg2); case BinaryOperators.Multiply: return(arg1.PiecewiseMultiply(arg2)); case BinaryOperators.Divide: throw new InvalidOperationException("One does not simply divide two vectors!"); case BinaryOperators.Exponent: throw new InvalidOperationException("One does not simply exponentiate two vectors!"); case BinaryOperators.Mod: throw new InvalidOperationException("One does not simply mod two vectors!"); case BinaryOperators.DivisibleBy: throw new InvalidOperationException("One does not simply check if two vectors are divisible!"); case BinaryOperators.Max: throw new InvalidOperationException("One does not simply max two vectors!"); case BinaryOperators.Min: throw new InvalidOperationException("One does not simply min two vectors!"); default: throw new Exception("Unknown operation type!"); } }
public decimal CalculateRPN(string rpnExpression) { decimal result = 0; decimal number = 0; Stack <decimal> stack = new Stack <decimal>(); foreach (string str in rpnExpression.Split(',')) { if (decimal.TryParse(str, out number)) { stack.Push(number); } else { if (string.IsNullOrEmpty(str)) { throw new InvalidOperationException(); } foreach (var binaryOperator in BinaryOperators.Where(x => x.oprator == str)) { stack.Push(binaryOperator.Calculate(stack.Pop(), stack.Pop())); } foreach (var unaryOperator in UnaryOperators.Where(x => x.oprator == str)) { stack.Push(unaryOperator.Calculate(stack.Pop())); } } } return(stack.Pop()); }
public void BinaryConstructorTest() { string left = string.Empty; // TODO: Initialize to an appropriate value BinaryOperators op = new BinaryOperators(); // TODO: Initialize to an appropriate value string right = string.Empty; // TODO: Initialize to an appropriate value jgshort.SqlDom.Expressions.Binary target = new jgshort.SqlDom.Expressions.Binary(left, op, right); Assert.Inconclusive("TODO: Implement code to verify target"); }
public void BinaryConstructorTest2() { System.Decimal left = new System.Decimal(); // TODO: Initialize to an appropriate value BinaryOperators op = new BinaryOperators(); // TODO: Initialize to an appropriate value System.Decimal right = new System.Decimal(); // TODO: Initialize to an appropriate value jgshort.SqlDom.Expressions.Binary target = new jgshort.SqlDom.Expressions.Binary(left, op, right); Assert.Inconclusive("TODO: Implement code to verify target"); }
public Condition ToCondition(ComparisonOperators compOp, BinaryOperators binOp) { var cond = new Condition() { PropertyName = this.Name, ComparisonOperator = compOp, Value1 = this.Value, BinaryOperator = binOp }; return(cond); }
public BinaryOperatorExpression( ExpressionBase <T> left, BinaryOperators @operator, ExpressionBase <T> right ) { Left = left; Operator = @operator; Right = right; }
public Predicate(string firstOperand, string secondOperand, BinaryOperators binaryOperator) { if (string.IsNullOrWhiteSpace(firstOperand)) { ExpressionValue = secondOperand; } else { ExpressionValue = string.Concat(firstOperand, binaryOperator.GetSqlExpression(), secondOperand); } }
/// <summary> /// Evaluates the specified binary operator expression and returns the result. /// </summary> /// <param name="context">The runtime context.</param> /// <param name="oper">The operator.</param> /// <param name="left">The left expression.</param> /// <param name="right">The right expression.</param> /// <returns>The result of the expression.</returns> /// <exception cref="ArithmeticException">No operator is matched.</exception> IScriptObject IOperatorCalculator.CalculateBinaryOperator(RuntimeContext context, string oper, Expression left, Expression right) { Func <RuntimeContext, Expression, Expression, IScriptObject> bin; if (BinaryOperators.TryGetValue(oper, out bin)) { return(bin(context, left, right)); } throw new ArithmeticException( string.Format(ExceptionResource.OperatorNotSupported, oper)); }
public static ExpressionEmitter Prepare(BinaryOperators binaryOperator, DecodeContext decodeContext) { var si1 = decodeContext.PopStack(); var si0 = decodeContext.PopStack(); char opChar; switch (binaryOperator) { case BinaryOperators.And: opChar = '&'; break; case BinaryOperators.Or: opChar = '|'; break; case BinaryOperators.Xor: opChar = '^'; break; default: throw new Exception(); } // See also: ECMA-335: III.1.5 Operand type table - Integer Operations // Int32 = (Int32) op (Int32) if (si0.TargetType.IsInt32StackFriendlyType && si1.TargetType.IsInt32StackFriendlyType) { var result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int32Type); return((extractContext, _) => new[] { string.Format( "{0} = {1} {2} {3}", extractContext.GetSymbolName(result), extractContext.GetSymbolName(si0), opChar, extractContext.GetSymbolName(si1)) }); } // Int64 = (Int64) op (Int64) if (si0.TargetType.IsInt64StackFriendlyType && si1.TargetType.IsInt64StackFriendlyType) { var result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int64Type); return((extractContext, _) => new[] { string.Format( "{0} = {1} {2} {3}", extractContext.GetSymbolName(result), extractContext.GetSymbolName(si0), opChar, extractContext.GetSymbolName(si1)) }); } // IntPtr = (Int32|IntPtr) op (Int32|IntPtr) if ((si0.TargetType.IsInt32StackFriendlyType || si0.TargetType.IsIntPtrStackFriendlyType) && (si1.TargetType.IsInt32StackFriendlyType || si1.TargetType.IsIntPtrStackFriendlyType)) { var result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.IntPtrType); return((extractContext, _) => new[] { string.Format( "{0} = (intptr_t){1} {2} (intptr_t){3}", extractContext.GetSymbolName(result), extractContext.GetSymbolName(si0), opChar, extractContext.GetSymbolName(si1)) }); } throw new InvalidProgramSequenceException( "Unknown logical operation: Location={0}, Op={1}, Type0={2}, Type1={3}", decodeContext.CurrentCode.RawLocation, binaryOperator, si0.TargetType.FriendlyName, si1.TargetType.FriendlyName); }
public static string GetSqlExpression(this BinaryOperators predicateOperation) { string result; switch (predicateOperation) { case BinaryOperators.Equal: result = " = "; break; case BinaryOperators.NotEqual: result = " <> "; break; case BinaryOperators.GreaterThen: result = " > "; break; case BinaryOperators.GreaterOrEqualThen: result = " >= "; break; case BinaryOperators.LessThen: result = " < "; break; case BinaryOperators.LessOrEqualThen: result = " <= "; break; case BinaryOperators.Like: result = " LIKE "; break; case BinaryOperators.NotLike: result = " NOT LIKE "; break; case BinaryOperators.And: result = " AND "; break; case BinaryOperators.Or: result = " OR "; break; default: throw new ArgumentOutOfRangeException(); } return(result); }
protected override bool Operate(bool arg1, bool arg2, BinaryOperators operation) { switch (operation) { case BinaryOperators.Add: return(arg1 || arg2); case BinaryOperators.Multiply: return(arg1 && arg2); default: throw new Exception("Unknown operation type on bools!"); } }
public static BinaryOperators GetBinaryOperator(string binaryOp) { BinaryOperators binOp = BinaryOperators.None; switch (binaryOp.ToUpper()) { case "AND": case "&&": binOp = BinaryOperators.And; break; case "OR": case "||": binOp = BinaryOperators.Or; break; default: break; } return(binOp); }
public Binary(float left, BinaryOperators op, float right) : this(new ConstantTypes.Float(left), op, new ConstantTypes.Float(right)) { // }
public Binary(System.Decimal left, BinaryOperators op, System.Decimal right) : this(new ConstantTypes.Decimal(left), op, new ConstantTypes.Decimal(right)) { // }
public Binary(System.DateTime left, BinaryOperators op, System.DateTime right) : this(new ConstantTypes.DateTime(left), op, new ConstantTypes.DateTime(right)) { // }
public Binary(string left, BinaryOperators op, string right) : this(new ConstantTypes.String(left), op, new ConstantTypes.String(right)) { // }
public Binary(int left, BinaryOperators op, int right) : this(new ConstantTypes.Integer(left), op, new ConstantTypes.Integer(right)) { // }
public Binary(Expression left, BinaryOperators op, Expression right) { Left = left; Operator = op; Right = right; }
private Operand ParseBinaryOperator(Operand left, ref List <Token> tokens, int grammarRule = int.MaxValue) { if (grammarRule == int.MaxValue) { grammarRule = BinaryOperators.Length - 1; } if (tokens.Count == 0) { return(left); } Token first = tokens.First(); if (grammarRule < 0) { return(ParseTerm(tokens: ref tokens)); } Operator[] operators = BinaryOperators [grammarRule]; Log.Debug("ParseBinaryOperator: grammarRule: ", grammarRule, ", operators: ", operators.Join(",")); if (first.Type == TokenType.OPERATOR) { while (tokens.Count > 0) { first = tokens.First(); Log.Debug("tokens: ", string.Join(" ", tokens.Select(t => t.Text))); if (first.Type == TokenType.OPERATOR) { // if the current operator is this binary operator if (operators.Any(o => first.Text == o.OperatorChar)) { Operator op = operators.First(o => first.Text == o.OperatorChar); Log.Debug("found binary operator: ", op); tokens.RemoveAt(0); Log.Indent++; Operand right = ParseTerm(tokens: ref tokens, maxBinaryGrammarRule: grammarRule); Log.Indent--; left = (op as BinaryOperator).Eval(l: left, r: right); } // if the current operator has higher precedence as this one else if (BinaryOperators.Take(grammarRule).Any(ops => ops.Any(o => o.OperatorChar == first.Text))) { Log.Indent++; left = ParseBinaryOperator(left: left, tokens: ref tokens, grammarRule: grammarRule - 1); Log.Indent--; } // if the current operator has lower precedence as this one else { break; } } else if (first.Type == TokenType.CLOSING_BRACKET) { break; // ignore } else { Log.Debug("ParseBinaryOperator: Invalid token (1): should be binary operator: " + first); } } } else if (first.Type == TokenType.CLOSING_BRACKET) { // ignore } else { Log.Debug("ParseBinaryOperator: Invalid token (2): should be binary operator: " + first); } return(left); }
protected abstract T Operate(T arg1, T arg2, BinaryOperators operation);
public static ExpressionEmitter Prepare(BinaryOperators binaryOperator, DecodeContext decodeContext) { var si1 = decodeContext.PopStack(); var si0 = decodeContext.PopStack(); char opChar; switch (binaryOperator) { case BinaryOperators.Add: opChar = '+'; break; case BinaryOperators.Sub: opChar = '-'; break; case BinaryOperators.Mul: opChar = '*'; break; case BinaryOperators.Div: opChar = '/'; break; case BinaryOperators.Rem: opChar = '%'; break; default: throw new Exception(); } // See also: ECMA-335: III.1.5 Operand type table - Binary Numeric Operations // Int32 = (Int32) op (Int32) if (si0.TargetType.IsInt32StackFriendlyType && si1.TargetType.IsInt32StackFriendlyType) { var result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int32Type); return((extractContext, _) => new[] { string.Format( "{0} = {1} {2} {3}", extractContext.GetSymbolName(result), extractContext.GetSymbolName(si0), opChar, extractContext.GetSymbolName(si1)) }); } // Int64 = (Int64) op (Int64) if (si0.TargetType.IsInt64StackFriendlyType && si1.TargetType.IsInt64StackFriendlyType) { var result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int64Type); return((extractContext, _) => new[] { string.Format( "{0} = {1} {2} {3}", extractContext.GetSymbolName(result), extractContext.GetSymbolName(si0), opChar, extractContext.GetSymbolName(si1)) }); } // Double = (Float) % (Float) if (si0.TargetType.IsFloatStackFriendlyType && si1.TargetType.IsFloatStackFriendlyType && (binaryOperator == BinaryOperators.Rem)) { var result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.DoubleType); // Use special runtime function. return((extractContext, _) => new[] { string.Format( "{0} = il2c_fmod({1}, {2})", extractContext.GetSymbolName(result), extractContext.GetSymbolName(si0), extractContext.GetSymbolName(si1)) }); } // Double = (Float) op (Float) if (si0.TargetType.IsFloatStackFriendlyType && si1.TargetType.IsFloatStackFriendlyType) { var result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.DoubleType); return((extractContext, _) => new[] { string.Format( "{0} = (double){1} {2} (double){3}", extractContext.GetSymbolName(result), extractContext.GetSymbolName(si0), opChar, extractContext.GetSymbolName(si1)) }); } // ByRef = (Int32) + (ByRef) if (si0.TargetType.IsInt32StackFriendlyType && si1.TargetType.IsByReference && (binaryOperator == BinaryOperators.Add)) { var result = decodeContext.PushStack(si1.TargetType); return((extractContext, _) => new[] { string.Format( "{0} = ({1})((intptr_t){2} + (intptr_t){3})", extractContext.GetSymbolName(result), si1.TargetType.CLanguageTypeName, extractContext.GetSymbolName(si0), extractContext.GetSymbolName(si1)) }); } // ByRef = (IntPtr) + (ByRef) if (si0.TargetType.IsIntPtrStackFriendlyType && si1.TargetType.IsByReference && (binaryOperator == BinaryOperators.Add)) { var result = decodeContext.PushStack(si1.TargetType); return((extractContext, _) => new[] { string.Format( "{0} = ({1})((intptr_t){2} + (intptr_t){3})", extractContext.GetSymbolName(result), si1.TargetType.CLanguageTypeName, extractContext.GetSymbolName(si0), extractContext.GetSymbolName(si1)) }); } // ByRef = (ByRef) +/- (Int32|IntPtr) if (si0.TargetType.IsByReference && (si1.TargetType.IsInt32StackFriendlyType || si1.TargetType.IsIntPtrStackFriendlyType) && ((binaryOperator == BinaryOperators.Add) || (binaryOperator == BinaryOperators.Sub))) { var result = decodeContext.PushStack(si0.TargetType); return((extractContext, _) => new[] { string.Format( "{0} = ({1})((intptr_t){2} {3} (intptr_t){4})", extractContext.GetSymbolName(result), si0.TargetType.CLanguageTypeName, extractContext.GetSymbolName(si0), opChar, extractContext.GetSymbolName(si1)) }); } // ByRef = (ByRef) - (ByRef) if (si0.TargetType.IsByReference && si1.TargetType.IsByReference && (binaryOperator == BinaryOperators.Sub)) { var result = decodeContext.PushStack(si0.TargetType); return((extractContext, _) => new[] { string.Format( "{0} = ({1})((intptr_t){2} - (intptr_t){3})", extractContext.GetSymbolName(result), si0.TargetType.CLanguageTypeName, extractContext.GetSymbolName(si0), extractContext.GetSymbolName(si1)) }); } // IntPtr = (Int32|IntPtr) op (Int32|IntPtr) if ((si0.TargetType.IsInt32StackFriendlyType || si0.TargetType.IsIntPtrStackFriendlyType) && (si1.TargetType.IsInt32StackFriendlyType || si1.TargetType.IsIntPtrStackFriendlyType)) { var result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.IntPtrType); return((extractContext, _) => new[] { string.Format( "{0} = (intptr_t){1} {2} (intptr_t){3}", extractContext.GetSymbolName(result), extractContext.GetSymbolName(si0), opChar, extractContext.GetSymbolName(si1)) }); } throw new InvalidProgramSequenceException( "Unknown arithmetical operation: Location={0}, Op={1}, Type0={2}, Type1={3}", decodeContext.CurrentCode.RawLocation, binaryOperator, si0.TargetType.FriendlyName, si1.TargetType.FriendlyName); }
public BinaryOperatorTests(BinaryOperators opt) { // for conditionals func = (x, y) => x.CompareTo(y); switch (opt) { case BinaryOperators.add: func = (x, y) => x + y; optStr = "+"; break; case BinaryOperators.subtract: func = (x, y) => x - y; optStr = "-"; break; case BinaryOperators.multiply: func = (x, y) => x * y; optStr = "*"; break; case BinaryOperators.divide: func = (x, y) => x / y; optStr = "/"; break; case BinaryOperators.pow: func = (x, y) => Math.Pow(x, y); optStr = "^"; break; case BinaryOperators.and: func = (x, y) => Convert.ToDouble(Convert.ToBoolean(x) && Convert.ToBoolean(y)); optStr = "&&"; break; case BinaryOperators.or: func = (x, y) => Convert.ToDouble(Convert.ToBoolean(x) || Convert.ToBoolean(y)); optStr = "||"; break; case BinaryOperators.equals: func = (x, y) => Convert.ToDouble(x == y); optStr = "=="; break; case BinaryOperators.notEqual: func = (x, y) => Convert.ToDouble(x != y); optStr = "!="; break; case BinaryOperators.greaterThan: func = (x, y) => Convert.ToDouble(x > y); optStr = ">"; break; case BinaryOperators.lessThan: func = (x, y) => Convert.ToDouble(x < y); optStr = "<"; break; case BinaryOperators.greaterThanEqualTo: func = (x, y) => Convert.ToDouble(x >= y); optStr = ">="; break; case BinaryOperators.lessThanEqualTo: func = (x, y) => Convert.ToDouble(x <= y); optStr = "<="; break; default: throw new ArithmeticException(opt.ToString()); } }
public BinaryExpression(SourceLocation location, Expression left, Expression right, BinaryOperators @operator) : base(location) { this.Left = left; this.Operator = @operator; this.Right = right; }
public void Test() { BinaryOperators o1 = new BinaryOperators() { X = 20, Y = 12 }; BinaryOperators o2 = new BinaryOperators() { X = 30, Y = 38 }; BinaryOperators o3 = o1 + o2; o3 += 2; Console.WriteLine("o3.X {0}, o3.Y {1}", o3.X, o3.Y); UnaryOperators uOp1 = new UnaryOperators() { X = 100, Y = 200 }; Console.WriteLine("uOp1.X {0}, uOp1.Y {1}", uOp1.X, uOp1.Y); uOp1++; ++uOp1; Console.WriteLine("uOp1.X {0}, uOp1.Y {1}", uOp1.X, uOp1.Y); EqualityOperator eo1 = new EqualityOperator() { X = 100, Y = 200 }; EqualityOperator eo2 = new EqualityOperator() { X = 100, Y = 200 }; Console.WriteLine("eo1 == eo2 {0} eo1.Equals(eo2) {1} ", eo1 == eo2, eo1.Equals(eo2)); ComparisonOperator co1 = new ComparisonOperator() { X = 2, Y = 2 }; ComparisonOperator co3 = new ComparisonOperator() { X = 6, Y = 6 }; ComparisonOperator co2 = new ComparisonOperator() { X = 4, Y = 4 }; Console.WriteLine(" co1 < co2 {0}", co1 < co2); Console.WriteLine(" co1 < co2 {0}", co1 > co2); Console.WriteLine(" co3 < co2 {0}", co3 > co2); CustomConversionA customA = new CustomConversionA() { Description = "My Description" }; CustomConversionC customC = new CustomConversionC() { Description = "My Description" }; CustomConversionB customBfromA = (CustomConversionB)customA; CustomConversionB customBfromCex = (CustomConversionB)customC; CustomConversionB customBfromCimp = customC; Console.WriteLine("CustomBfromA : {0}", customBfromA.ReverseDescription); Console.WriteLine("CustomBfromC(explicit) : {0}", customBfromCex.ReverseDescription); Console.WriteLine("CustomBfromC(implpicit) : {0}", customBfromCimp.ReverseDescription); }