internal override object Eval() { var left = LeftOperand.Eval(); var right = RightOperand.Eval(); return(Microsoft.VisualBasic.CompilerServices.LikeOperator.LikeString(left as string ?? left.ToString(), right as string ?? right.ToString(), Microsoft.VisualBasic.CompareMethod.Text)); }
internal override object Eval() { var left = LeftOperand.Eval(); var right = RightOperand.Eval(); return(!left.Equals(right)); }
internal override object Eval() { var left = LeftOperand.Eval(); var right = RightOperand.Eval(); return(Regex.Match(left as string ?? left.ToString(), right as string ?? right.ToString())); }
internal override object Eval() { var left = LeftOperand.Eval(); var right = RightOperand.Eval(); if (left.GetType() == right.GetType()) { return(!left.Equals(right)); } return(!(left as string ?? left.ToString()).Equals(right as string ?? right.ToString())); }
internal override object Eval() { var left = LeftOperand.Eval(); var right = RightOperand.Eval(); if (left.GetType() == right.GetType() && left is IComparable lCom && right is IComparable rCom) { return(lCom.CompareTo(rCom) >= 0); } return((left as string ?? left.ToString()).CompareTo((right as string ?? right.ToString())) >= 0); }
internal override object Eval() { var left = LeftOperand.Eval(); var right = RightOperand.Eval(); if (left is double lDbl && right is double rDbl) { return(Math.Pow(lDbl, rDbl)); } //if (left is bool lBool && right is bool rBool) return Math.Pow((lBool ? 1 : 0), (rBool ? 1 : 0)); //if (left is bool lBool2 && right is double rDbl2) return Math.Pow((lBool2 ? 1 : 0), rDbl2); //if (left is double lDbl2 && right is bool rBool2) return Math.Pow(lDbl2, (rBool2 ? 1 : 0)); throw new InvalidOperationException($"Power can not be performed on the operands [{left}] and [{right}]"); }
internal override object Eval() { var left = LeftOperand.Eval(); var right = RightOperand.Eval(); if (left is double lDbl && right is double rDbl) { return(lDbl * rDbl); } if (left is bool lBool && right is bool rBool) { return((lBool ? 1 : 0) * (rBool ? 1 : 0)); } if (left is bool lBool2 && right is double rDbl2) { return((lBool2 ? 1 : 0) * rDbl2); } if (left is double lDbl2 && right is bool rBool2) { return(lDbl2 * (rBool2 ? 1 : 0)); } throw new InvalidOperationException($"Multiplication can not be performed on the operands [{left}] and [{right}]"); }
internal override object Eval() { var left = LeftOperand.Eval(); var right = RightOperand.Eval(); if (left is double lDbl && right is double rDbl) { return(lDbl - rDbl); } if (left is bool lBool && right is bool rBool) { return((lBool ? 1 : 0) - (rBool ? 1 : 0)); // Maybe throw an exception instead? } if (left is bool lBool2 && right is double rDbl2) { return((lBool2 ? 1 : 0) - rDbl2); } if (left is double lDbl2 && right is bool rBool2) { return(lDbl2 - (rBool2 ? 1 : 0)); } return(left.ToString().Replace(right.ToString(), "")); //Interesting concept... I wonder if other languages do this? }
internal override object Eval() { var left = LeftOperand.Eval(); var right = RightOperand.Eval(); if (left is double lDbl && right is double rDbl) { return(lDbl + rDbl); } if (left is bool lBool && right is bool rBool) { return((lBool ? 1 : 0) + (rBool ? 1 : 0)); } if (left is bool lBool2 && right is double rDbl2) { return((lBool2 ? 1 : 0) + rDbl2); } if (left is double lDbl2 && right is bool rBool2) { return(lDbl2 + (rBool2 ? 1 : 0)); } return(left.ToString() + right.ToString()); }