public void CloneTest()
{
var exp = new GreaterOrEqual(new Number(2), new Number(3));
var clone = exp.Clone();
Assert.Equal(exp, clone);
}
public override bool Visit(GreaterOrEqual node)
{
traverse(node.left);
outputCode(" >= ", false, false);
traverse(node.right);
//Visit((LogicalBinaryExpression) node);
return(true);
}
/// <summary>
/// Analyzes the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>The result of analysis.</returns>
public string Analyze(GreaterOrEqual exp)
{
if (exp.Parent is BinaryExpression && !(exp.Parent is While))
{
return(ToString(exp, "({0} >= {1})"));
}
return(ToString(exp, "{0} >= {1}"));
}
//-----------------------------------------------------------
public string Visit(GreaterOrEqual node)
{
var sb = new StringBuilder();
sb.Append(VisitBinaryOperator("cgt\n", node));
sb.Append(VisitBinaryOperator("ceq\n", node));
sb.Append("\t\t or\n");
return(sb.ToString());
}
public void CalculateGreaterFalseTest()
{
var parameters = new ParameterCollection()
{
new Parameter("x", 0)
};
var lessThen = new GreaterOrEqual(new Variable("x"), new Number(10));
Assert.Equal(false, lessThen.Execute(parameters));
}
public void CalculateGreaterFalseTest()
{
var parameters = new ParameterCollection()
{
new Parameter("x", 0)
};
var greaterOrEqual = new GreaterOrEqual(Variable.X, new Number(10));
Assert.False((bool)greaterOrEqual.Execute(parameters));
}
public void CalculateGreaterTrueTest2()
{
var parameters = new ParameterCollection()
{
new Parameter("x", 10)
};
var lessThen = new GreaterOrEqual(Variable.X, new Number(10));
Assert.True((bool)lessThen.Execute(parameters));
}
public void Visit(GreaterOrEqual bin)
{
var left = bin.Left;
var right = bin.Right;
PrepareBinaryOperation(left, right);
Emit("clt");
Emit($"ldc.{MiniType.Bool.ToPrimitive()} 0");
EmitStackDown("ceq");
}
public void Check_Whether_First_Is_Greater_Than_Or_Equal_To_Second(object param1, object param2, bool expected)
{
// given
var sut = new GreaterOrEqual(param1, param2);
// when
var result = Evaluator.Evaluate(sut);
// then
Assert.Equal(expected, result);
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (property == null)
{
return;
}
EditorGUI.BeginChangeCheck();
GreaterOrEqual greaterOrEqualAttribute = (GreaterOrEqual)attribute;
int intThreshold = greaterOrEqualAttribute.intThreshold;
float floatThreshold = greaterOrEqualAttribute.floatThreshold;
EditorGUI.PropertyField(position, property, label);
if (property.propertyType == SerializedPropertyType.Integer)
{
if (property.intValue < intThreshold)
{
property.intValue = intThreshold;
}
}
else
{
if (property.propertyType == SerializedPropertyType.Float)
{
if (property.floatValue < floatThreshold)
{
property.floatValue = floatThreshold;
}
}
}
if (EditorGUI.EndChangeCheck())
{
property.serializedObject.ApplyModifiedProperties();
}
}
public static ParamLessInstruction GetInstructionForOperator(
string operatorVal,
bool twoArg = true,
DatSymbolType leftSideType = DatSymbolType.Void)
{
ParamLessInstruction instruction = new ParamLessInstruction();
switch (operatorVal)
{
case "=":
instruction = GetAssignInstructionForDatSymbolType(leftSideType);
break;
case "+=":
instruction = new AssignAdd();
break;
case "-=":
instruction = new AssignSubtract();
break;
case "*=":
instruction = new AssignMultiply();
break;
case "/=":
instruction = new AssignDivide();
break;
case "+":
if (twoArg)
{
instruction = new Add();
}
else
{
instruction = new Plus();
}
break;
case "-":
if (twoArg)
{
instruction = new Subtract();
}
else
{
instruction = new Minus();
}
break;
case "<<":
instruction = new ShiftLeft();
break;
case ">>":
instruction = new ShiftRight();
break;
case ">":
instruction = new Greater();
break;
case ">=":
instruction = new GreaterOrEqual();
break;
case "<":
instruction = new Less();
break;
case "<=":
instruction = new LessOrEqual();
break;
case "==":
instruction = new Equal();
break;
case "!=":
instruction = new NotEqual();
break;
case "!":
instruction = new Not();
break;
case "~":
instruction = new Negate();
break;
case "*":
instruction = new Multiply();
break;
case "/":
instruction = new Divide();
break;
case "%":
instruction = new Modulo();
break;
case "&":
instruction = new BitAnd();
break;
case "|":
instruction = new BitOr();
break;
case "&&":
instruction = new LogAnd();
break;
case "||":
instruction = new LogOr();
break;
}
if (instruction == null)
{
throw new Exception($"'{operatorVal}' does't have insctruction");
}
return(instruction);
}
public void CalculateInvalidTypeTest()
{
var greaterOrEqual = new GreaterOrEqual(new Bool(true), new Bool(true));
Assert.Throws <ResultIsNotSupportedException>(() => greaterOrEqual.Execute());
}
public void GreatOrEqualToString()
{
var exp = new GreaterOrEqual(new Number(5), new Number(5));
Assert.Equal("5 >= 5", exp.ToString(commoonFormatter));
}
public virtual T Visit(GreaterOrEqual node)
{
return(Visit((ComparisonBinaryExpression)node));
}
public override bool Visit(GreaterOrEqual node)
{
Visit((ComparisonBinaryExpression)node);
return(true);
}
/// <summary>
/// Analyzes the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>
/// The result of analysis.
/// </returns>
/// <exception cref="System.NotSupportedException">Always.</exception>
public virtual TResult Analyze(GreaterOrEqual exp)
{
throw new NotSupportedException();
}
public void TestGreaterOrEqualException()
{
var exp = new GreaterOrEqual(new Bool(true), new Bool(false));
TestException(exp);
}
public void TestGreaterOrEqualBoolNumberException()
{
var exp = new GreaterOrEqual(new Bool(true), new Number(10));
TestBinaryException(exp);
}
public void TestGreaterOrEqualNumber()
{
var exp = new GreaterOrEqual(new Number(10), new Number(10));
Test(exp, ResultType.Boolean);
}
public void TestGreaterOrEqualUndefined()
{
var exp = new GreaterOrEqual(Variable.X, Variable.X);
Test(exp, ResultType.Undefined);
}
public virtual void loadFunctions(Rete engine)
{
Abs abs = new Abs();
engine.declareFunction(abs);
funcs.Add(abs);
Acos acos = new Acos();
engine.declareFunction(acos);
funcs.Add(acos);
Add add = new Add();
engine.declareFunction(add);
funcs.Add(add);
Asin asin = new Asin();
engine.declareFunction(asin);
funcs.Add(asin);
Atan atan = new Atan();
engine.declareFunction(atan);
funcs.Add(atan);
Ceil ceil = new Ceil();
engine.declareFunction(ceil);
funcs.Add(ceil);
Const cnst = new Const();
engine.declareFunction(cnst);
funcs.Add(cnst);
Cos cos = new Cos();
engine.declareFunction(cos);
funcs.Add(cos);
Degrees degrees = new Degrees();
engine.declareFunction(degrees);
funcs.Add(degrees);
Divide div = new Divide();
engine.declareFunction(div);
funcs.Add(div);
EqFunction eqf = new EqFunction();
engine.declareFunction(eqf);
funcs.Add(eqf);
Evenp evenp = new Evenp();
engine.declareFunction(evenp);
funcs.Add(evenp);
Exp exp = new Exp();
engine.declareFunction(exp);
funcs.Add(exp);
Floor floor = new Floor();
engine.declareFunction(floor);
funcs.Add(floor);
Greater gr = new Greater();
engine.declareFunction(gr);
funcs.Add(gr);
GreaterOrEqual gre = new GreaterOrEqual();
engine.declareFunction(gre);
funcs.Add(gre);
Less le = new Less();
engine.declareFunction(le);
funcs.Add(le);
LessOrEqual leoe = new LessOrEqual();
engine.declareFunction(leoe);
funcs.Add(leoe);
Log log = new Log();
engine.declareFunction(log);
funcs.Add(log);
Max max = new Max();
engine.declareFunction(max);
funcs.Add(max);
Min min = new Min();
engine.declareFunction(min);
funcs.Add(min);
Multiply mul = new Multiply();
engine.declareFunction(mul);
funcs.Add(mul);
NeqFunction neq = new NeqFunction();
engine.declareFunction(neq);
funcs.Add(neq);
Oddp oddp = new Oddp();
engine.declareFunction(oddp);
funcs.Add(oddp);
Pow pow = new Pow();
engine.declareFunction(pow);
funcs.Add(pow);
Radians radians = new Radians();
engine.declareFunction(radians);
funcs.Add(radians);
Random random = new Random();
engine.declareFunction(random);
funcs.Add(random);
Rint rint = new Rint();
engine.declareFunction(rint);
funcs.Add(rint);
Round round = new Round();
engine.declareFunction(round);
funcs.Add(round);
Sin sin = new Sin();
engine.declareFunction(sin);
funcs.Add(sin);
Sqrt sqrt = new Sqrt();
engine.declareFunction(sqrt);
funcs.Add(sqrt);
Subtract sub = new Subtract();
engine.declareFunction(sub);
funcs.Add(sub);
Tan tan = new Tan();
engine.declareFunction(tan);
funcs.Add(tan);
// now we Add the functions under alias
engine.declareFunction("+", add);
engine.declareFunction("-", sub);
engine.declareFunction("*", mul);
engine.declareFunction("/", div);
engine.declareFunction("**", pow);
engine.declareFunction(">", gr);
engine.declareFunction(">=", gre);
engine.declareFunction("<", le);
engine.declareFunction("<=", leoe);
}
//-----------------------------------------------------------
public Type Visit(GreaterOrEqual node)
{
VisitBinaryNumericOperator(".ge.", node);
return(Type.LOGICAL);
}
