private IExpression ParseUnary()
{
while (true)
{
IExpression res = new ErrorExpression();
switch (_tokenizer.GetNextToken())
{
case Token.Number:
res = new Number(_tokenizer.GetValue());
_tokenizer.GetNextToken();
break;
case Token.Negate:
res = new Negate(ParseUnary());
break;
case Token.OpenParenthesis:
res = ParseAddSubtract();
if (_tokenizer.GetCurToken() != Token.CloseParenthesis)
{
_tokenizer.AddException(new MissingCloseParenthesisException(
_tokenizer.GetExpression(),
_tokenizer.GetInd()));
}
_tokenizer.GetNextToken();
break;
case Token.Error:
continue;
}
return(res);
}
}
/// <summary>
/// Negates a raster, multiplies by -1
/// </summary>
/// <param name="inRaster">input raster can be a constant, raster, or string (full path)</param>
/// <param name="outRst">string full path</param>
public void inversRaster(object inRaster, string outRst)
{
Negate ng = new Negate();
ng.in_raster_or_constant = inRaster;
ng.out_raster = outRst;
string rsl = getMessages(gpExecute(ng));
}
public void NegateTest()
{
Negate op = new Negate();
Assert.IsTrue(op.Execute(_boolFalse));
Assert.IsFalse(op.Execute(_boolTrue));
Assert.IsTrue(op.Execute(op.Execute(_boolTrue)));
}
public void Evaluate_Negate_Bool_True_Test()
{
Expression expression = CreateBoolLiteral(false);
Expression negate = new Negate(expression, pos);
Values.Bool value = ((Values.Bool)negate.Accept(evaluator));
Assert.IsTrue(value.GetValue());
}
public override int GetHashCode()
{
unchecked
{
var hashCode = Negate.GetHashCode();
hashCode = (hashCode * 397) ^ (Expression != null ? Expression.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Lower != null ? Lower.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Upper != null ? Upper.GetHashCode() : 0);
return(hashCode);
}
}
public Criteria <TItem> ApplyModifications(Criteria <TItem> criteriaBeforeModifications)
{
var result = criteriaBeforeModifications;
if (_negateCriteria)
{
result = new Negate <TItem>(criteriaBeforeModifications);
}
return(result);
}
public void UnaryNegateTest()
{
Negate neg = new Negate();
UnaryStatement negT = new UnaryStatement(neg, tn);
UnaryStatement negF = new UnaryStatement(neg, fn);
Assert.AreEqual(f, negT.Evaluate(varTable));
Assert.AreNotEqual(negF.Evaluate(varTable), negT.Evaluate(varTable));
Assert.AreEqual(t, new UnaryStatement(neg, new TemporaryVariable(ref varTable, negT.Evaluate(varTable))).Evaluate(varTable));
}
public void Negate()
{
var x = new Const <double>(1.0, "x");
var op = new Negate <double>(x);
var xml = op.ToXml();
var deserialized = SerializationExtensions.FromXml <double>(xml) as Negate <double>;
Assert.IsNotNull(deserialized);
Assert.AreEqual(1, deserialized.Parents.Count);
Assert.AreEqual("x", (deserialized.Parents[0] as Const <double>).Name);
}
public void Negate001()
{
// Arrange
var expected = "-tst";
string actual;
var parameter = new Negate <TestDocument>(new Any <TestDocument>("tst"));
// Act
actual = parameter.Execute();
// Assert
Assert.Equal(expected, actual);
}
public override bool Equals(object obj)
{
if (obj is null)
{
return(false);
}
if (!(obj is RegexSet set))
{
return(false);
}
return(CharacterClass.Equals(set.CharacterClass) &&
Negate.Equals(set.Negate));
}
public override bool Equals(object obj)
{
if ((object)obj == null)
{
return(false);
}
var set = obj as RegexSet;
if ((object)set == null)
{
return(false);
}
return(CharacterClass.Equals(set.CharacterClass) &&
Negate.Equals(set.Negate));
}
public virtual TResult Visit(BaseExpression expression)
{
return(expression switch {
Phi a => Visit(a),
Increment a => Visit(a),
Decrement a => Visit(a),
ErrorExpression a => Visit(a),
Bracketed a => Visit(a),
Abs a => Visit(a),
Sqrt a => Visit(a),
Sine a => Visit(a),
Cosine a => Visit(a),
Tangent a => Visit(a),
ArcSine a => Visit(a),
ArcCos a => Visit(a),
ArcTan a => Visit(a),
PostIncrement a => Visit(a),
PreIncrement a => Visit(a),
PostDecrement a => Visit(a),
PreDecrement a => Visit(a),
Add a => Visit(a),
Subtract a => Visit(a),
Multiply a => Visit(a),
Divide a => Visit(a),
Modulo a => Visit(a),
Negate a => Visit(a),
Exponent a => Visit(a),
Or a => Visit(a),
And a => Visit(a),
Not a => Visit(a),
Factorial a => Visit(a),
Variable a => Visit(a),
ConstantNumber a => Visit(a),
ConstantString a => Visit(a),
EqualTo a => Visit(a),
NotEqualTo a => Visit(a),
GreaterThan a => Visit(a),
GreaterThanEqualTo a => Visit(a),
LessThan a => Visit(a),
LessThanEqualTo a => Visit(a),
_ => VisitUnknown(expression)
});
public void NegateOpForward()
{
var nodeMockA = new Mock <Op <double> >();
var volA = new VolumeMock(1.0, new Shape(1));
nodeMockA.Setup(o => o.Evaluate(It.IsAny <Session <double> >())).Returns(volA);
var op = new Negate <double>(nodeMockA.Object);
using (var session = new Session <double>())
{
var eval = op.Evaluate(session);
Assert.IsNotNull(eval);
var s = session;
nodeMockA.Verify(o => o.Evaluate(s));
Assert.AreEqual(1, volA.DoNegateCount);
}
}
public void UsageTest()
{
Card x;
x = new Attack(CardSuit.Club, 0);
Assert.AreEqual(1, x.numOfTargets());
x = new Miss(CardSuit.Club, 0);
Assert.AreEqual(-1, x.numOfTargets()); // this means not usable
x = new Wine(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
x = new Peach(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
x = new Negate(CardSuit.Club, 0);
Assert.AreEqual(-1, x.numOfTargets());
x = new Barbarians(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
x = new HailofArrow(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
x = new PeachGarden(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
x = new Wealth(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
x = new Steal(CardSuit.Club, 0);
Assert.AreEqual(1, x.numOfTargets());
x = new Break(CardSuit.Club, 0);
Assert.AreEqual(1, x.numOfTargets());
x = new Capture(CardSuit.Club, 0);
Assert.AreEqual(1, x.numOfTargets());
x = new Starvation(CardSuit.Club, 0);
Assert.AreEqual(1, x.numOfTargets());
x = new Crossbow(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
x = new IceSword(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
x = new Scimitar(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
x = new BlackShield(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
x = new EightTrigrams(CardSuit.Club, 0);
Assert.AreEqual(0, x.numOfTargets());
}
public static void SetupBuiltins(SymbolSpace space)
{
globalSpace = space;
Unless.Setup();
When.Setup();
If.Setup();
Let.Setup();
Equal.Setup();
Bind.Setup();
DerefSymbol.Setup();
Evaluate.Setup();
In.Setup();
Print.Setup();
Negate.Setup();
Quote.Setup();
Unquote.Setup();
MakeSpace.Setup();
Def.Setup();
Get.Setup();
Add.Setup();
Defn.Setup();
}
protected override Type Visit(Negate neg) => UnaryNumeric(neg, neg.Parameter, false, false);
[NotNull] protected abstract TResult Visit([NotNull] Negate neg);
public SuperHappyScript(string script)
{
ValueNode currentNode = null;
string currentParseValue = "";
int predenceLevel = 0;
_variables = new List <string>();
int index = 0;
char currentToken = ' ';
char nextToken = ' ';
_script = script;
try {
foreach (char token in script)
{
index++;
if (script.Length > index)
{
nextToken = script[index];
}
currentToken = token;
if (currentParseValue.StartsWith("[") && !currentParseValue.EndsWith("]") && !(currentParseValue + token).EndsWith(">=") && !(currentParseValue + token).EndsWith("<=") && !(currentParseValue + token).EndsWith("<>"))
{
currentParseValue += token;
continue;
}
if (IgnoreSet.Contains(token))
{
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
}
else if (token == ']')
{
currentParseValue += token;
currentNode = AddValue(currentNode, currentParseValue);
}
else if (token == ',')
{
if (predenceLevel == 0)
{
throw new Exception("Parsing error");
}
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
currentNode = WrapFunction(currentNode, predenceLevel, false);
}
else if ((currentParseValue + token).ToUpper() == "ABS(")
{
currentNode = new Absolute(predenceLevel).AttachNode(currentNode);
predenceLevel += MAX_PREDENCE + 1;
}
else if ((currentParseValue + token).ToUpper() == "ROUND(")
{
currentNode = new Round(predenceLevel).AttachNode(currentNode);
predenceLevel += MAX_PREDENCE + 1;
}
else if ((currentParseValue + token).ToUpper() == "INT(")
{
currentNode = new RoundDown(predenceLevel).AttachNode(currentNode);
predenceLevel += MAX_PREDENCE + 1;
}
else if ((currentParseValue + token).ToUpper() == "IIF(")
{
currentNode = new IfStatement(predenceLevel).AttachNode(currentNode);
predenceLevel += MAX_PREDENCE + 1;
}
else if ((currentParseValue + token).ToUpper() == "MAX(")
{
currentNode = new Max(predenceLevel).AttachNode(currentNode);
predenceLevel += MAX_PREDENCE + 1;
}
else if ((currentParseValue + token).ToUpper() == "ISNAN(")
{
currentNode = new IsNaN(predenceLevel).AttachNode(currentNode);
predenceLevel += MAX_PREDENCE + 1;
}
else if ((currentParseValue + token).ToUpper() == "MIN(")
{
currentNode = new Min(predenceLevel).AttachNode(currentNode);
predenceLevel += MAX_PREDENCE + 1;
}
else if ((currentParseValue + token).ToUpper() == "AND")
{
if (currentParseValue.Length > 2)
{
currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 2));
}
currentNode = new And(predenceLevel).AttachNode(currentNode);
}
else if ((currentParseValue + token).ToUpper() == "OR")
{
if (currentParseValue.Length > 2)
{
currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 2));
}
currentNode = new Or(predenceLevel).AttachNode(currentNode);
}
else if ((currentParseValue + token).ToUpper() == "NOT")
{
if (currentParseValue.Length > 2)
{
currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 2));
}
currentNode = new Not(predenceLevel).AttachNode(currentNode);
}
else if (token == '(')
{
if (currentParseValue != "")
{
throw new Exception("Parsing error");
}
predenceLevel += MAX_PREDENCE + 1;
}
else if (token == ')')
{
if (predenceLevel == 0)
{
throw new Exception("Parsing error");
}
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
currentNode = WrapFunction(currentNode, predenceLevel, true);
predenceLevel -= MAX_PREDENCE + 1;
}
else if ((currentParseValue + token).EndsWith("="))
{
if (currentParseValue.Length > 1)
{
currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length));
}
currentNode = new Equal(predenceLevel).AttachNode(currentNode);
}
else if ((currentParseValue + token).EndsWith(">="))
{
if (currentParseValue.Length > 2)
{
currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 1));
}
currentNode = new EqualOrGreaterThan(predenceLevel).AttachNode(currentNode);
}
else if ((currentParseValue + token).EndsWith("<="))
{
if (currentParseValue.Length > 2)
{
currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 1));
}
currentNode = new EqualOrLessThan(predenceLevel).AttachNode(currentNode);
}
else if ((currentParseValue + token).EndsWith("<>"))
{
if (currentParseValue.Length > 2)
{
currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 1));
}
currentNode = new NotEqual(predenceLevel).AttachNode(currentNode);
}
else if (token == '>' && nextToken != '=')
{
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
currentNode = new GreaterThan(predenceLevel).AttachNode(currentNode);
}
else if (token == '<' && nextToken != '>' && nextToken != '=')
{
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
currentNode = new LessThan(predenceLevel).AttachNode(currentNode);
}
else if (token == '+')
{
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
currentNode = new Add(predenceLevel).AttachNode(currentNode);
}
else if (token == '-')
{
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
if (currentNode == null || currentNode is Operand || currentNode is Function)
{
currentNode = new Negate(predenceLevel).AttachNode(currentNode);
}
else
{
currentNode = new Subtract(predenceLevel).AttachNode(currentNode);
}
}
else if (token == '*')
{
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
currentNode = new Multiply(predenceLevel).AttachNode(currentNode);
}
else if (token == '/')
{
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
currentNode = new Divide(predenceLevel).AttachNode(currentNode);
}
else if (token == '^')
{
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
currentNode = new PowerOf(predenceLevel).AttachNode(currentNode);
}
else
{
if (currentParseValue.StartsWith("[") && currentParseValue.EndsWith("]") && token == '[')
{
throw new Exception("Two variables declared in a row");
}
currentParseValue += token;
continue;
}
currentParseValue = "";
}
} catch (Exception exc) {
throw new Exception(exc.Message + " at token: " + currentToken + " in row: " + index);
}
if (currentParseValue != "")
{
currentNode = AddValue(currentNode, currentParseValue);
}
if (predenceLevel != 0)
{
throw new Exception("Parsing error");
}
while (currentNode.Parent != null)
{
currentNode = currentNode.Parent;
}
_startNode = currentNode;
_variables = new List <string>(_variables.Distinct());
Test();
}
protected override IDataFlowGraphExpressionNode Visit(Negate neg)
{
return(VisitUnary(new UnaryOp(Guid.NewGuid(), "negate", Visit(neg.Parameter), a => new Negate(a))));
}
public void NegateTest2()
{
Negate c = new Negate(CardSuit.Club, (byte)1);
Assert.AreEqual("Negate", c.ToString());
}
int ComputeHashCode()
{
return(HashCode.Compute(
Negate.GetHashCode(),
CharacterClass.GetHashCode()));
}
public void Evaluate_Negate_Bool_True_Test()
{
Expression expression = CreateBoolLiteral(false);
Expression negate = new Negate(expression, pos);
Values.Bool value = ((Values.Bool)negate.Accept(evaluator));
Assert.IsTrue(value.GetValue());
}
public Types.Type Visit(Negate node)
{
return(VisitUnaryExpectedType(node, new Types.BoolType()));
}
protected override BaseExpression Visit(Negate neg)
{
using (AppendLine("negate"))
return(base.Visit(neg));
}
[NotNull] protected virtual BaseExpression Visit([NotNull] Negate neg)
{
return(new Negate(Visit(neg.Parameter)));
}
/// <summary>
/// Negates a raster, multiplies by -1
/// </summary>
/// <param name="inRaster">input raster can be a constant, raster, or string (full path)</param>
/// <param name="outRst">string full path</param>
public void inversRaster(object inRaster, string outRst)
{
Negate ng = new Negate();
ng.in_raster_or_constant = inRaster;
ng.out_raster = outRst;
string rsl = getMessages(gpExecute(ng));
}
protected override bool Visit(Negate neg) => StaticFalse(neg);
protected override IEnumerable <BaseStatement> Visit(Negate neg) => Unary(neg, a => new Negate(a));
public void TestNegate()
{
IExpression e = new Negate(new Constant(-1.0));
Assert.AreEqual(1, e.Calculate());
}
// return string representation in given radix
public string ToString(int radix)
{
if (sign < 0)
{
return("-" + Negate.ToString(radix));
}
var k = 0;
switch (radix)
{
case 16:
k = 4;
break;
case 8:
k = 3;
break;
case 2:
k = 1;
break;
case 32:
k = 5;
break;
case 4:
k = 2;
break;
default:
return(ToRadix(radix));
}
var km = (1 << k) - 1;
var d = 0;
var m = false;
var result = string.Empty;
var i = t;
var p = DB - (i * DB) % k;
if (i-- > 0)
{
if (p < DB && (d = this[i] >> p) > 0)
{
m = true;
result = Int2Char(d).ToString();
}
while (i >= 0)
{
if (p < k)
{
d = (this[i] & ((1 << p) - 1)) << (k - p);
d |= this[--i] >> (p += DB - k);
}
else
{
d = (this[i] >> (p -= k)) & km;
if (p <= 0)
{
p += DB;
i--;
}
}
m |= d > 0;
if (m)
{
result += Int2Char(d);
}
}
}
return(m ? result : "0");
}
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);
}
protected override bool Visit(Negate neg) => Visit(neg.Parameter);
