public override Expression Visit(AdditionNode node) { var left = Visit(node.Left); var right = Visit(node.Right); return(new Expression(left.Terms, right.Terms)); }
public void FlattenExpression_Assignment_MemoryValue_Both() { var ast = new ASTNode(); ast.AddChild(new VariableDeclarationNode("byte", "x")); var additionnode = new AdditionNode(new MemoryValueNode(100), new MemoryValueNode(100)); var assignment = new VariableAssignmentNode("x", additionnode); ast.AddChild(assignment); var changes = FlattenExpression(ast, 1); Assert.IsTrue(changes > 0); var children = ast.GetChildren().ToList(); Assert.AreEqual(6, children.Count); Assert.IsInstanceOfType(additionnode.Left, typeof(VariableValueNode)); Assert.IsInstanceOfType(additionnode.Right, typeof(VariableValueNode)); Assert.IsInstanceOfType(children[0], typeof(VariableDeclarationNode)); Assert.IsInstanceOfType(children[1], typeof(VariableDeclarationNode)); Assert.IsInstanceOfType(children[2], typeof(VariableAssignmentNode)); Assert.IsInstanceOfType(children[3], typeof(VariableDeclarationNode)); Assert.IsInstanceOfType(children[4], typeof(VariableAssignmentNode)); Assert.IsInstanceOfType(children[5], typeof(VariableAssignmentNode)); Assert.AreSame(children[5], assignment); Assert.AreNotEqual(((VariableAssignmentNode)children[2]).VariableName, ((VariableAssignmentNode)children[4]).VariableName); }
// Make calls to the classes that does the final calculation public override double Evaluate() { switch (this.Operator) { case '+': AdditionNode add = new AdditionNode('+'); add.Left = this.Left; add.Right = this.Right; return(add.Evaluate()); case '-': SubtractionNode sub = new SubtractionNode('-'); sub.Left = this.Left; sub.Right = this.Right; return(sub.Evaluate()); case '*': MultiplicationNode mul = new MultiplicationNode('*'); mul.Left = this.Left; mul.Right = this.Right; return(mul.Evaluate()); case '/': DivisionNode div = new DivisionNode('/'); div.Left = this.Left; div.Right = this.Right; return(div.Evaluate()); default: break; } return(0.0); }
public override Node VisitInfixValueExpr(ML4DParser.InfixValueExprContext context) { InfixExpressionNode node; switch (context.op.Type) { case ML4DLexer.PLUS: node = new AdditionNode("+"); break; case ML4DLexer.MINUS: node = new SubtractionNode("-"); break; case ML4DLexer.MUL: node = new MultiplicationNode("*"); break; case ML4DLexer.DIV: node = new DivisionNode("/"); break; case ML4DLexer.POW: node = new PowerNode("**"); break; default: throw new NotSupportedException( $"The operator {context.op.Text}, is not a valid arithmetic operator."); } node.Left = (ExpressionNode)Visit(context.left); node.Right = (ExpressionNode)Visit(context.right); return(node); }
public void Setup() { _left = Mock.Interface<ICalculationNode>(); _right = Mock.Interface<ICalculationNode>(); _additionNode = new AdditionNode(_left, _right); }
/// <summary> /// 加算ノードの評価 /// </summary> /// <param name="node">加算ノード</param> /// <returns>演算後の数値(Double)、もしくは文字列(String)</returns> public override object Visit(AdditionNode node) { if (Visit(node.Left).GetType() == typeof(string) || Visit(node.Right).GetType() == typeof(string)) { return(Visit(node.Left).ToString() + Visit(node.Right).ToString()); //文字列の結合 } return((double)Visit(node.Left) + (double)Visit(node.Right)); }
public void Addition_Optimize_UnknownVariableRemains() { var originalnode = new AdditionNode(new ShortValueNode(1), new VariableValueNode("x")); var optimizednode = originalnode.Optimize(NoVariables); Assert.IsInstanceOfType(optimizednode, typeof(AdditionNode)); }
public void Addition_Optimize_FullyConstantCollapses() { var originalnode = new AdditionNode(new ShortValueNode(1), new ShortValueNode(1)); var optimizednode = originalnode.Optimize(NoVariables); Assert.IsInstanceOfType(optimizednode, typeof(ConstantNode)); }
public void Addition_Optimize_FullyConstant_Value() { var originalnode = new AdditionNode(new ShortValueNode(1), new ShortValueNode(1)); var optimizednode = originalnode.Optimize(NoVariables); Assert.AreEqual(2, optimizednode.GetValue()); }
private object AdditionNode(AdditionNode a) { var l = Evaluate(a.l); var r = Evaluate(a.r); if (l is decimal && r is decimal) { return((decimal)l + (decimal)r); } throw(new Exception($"Can't add {l.GetType()} and {r.GetType()}")); }
public void Generate(Grid grid) { for (int i = 0; i < grid.Width; i++) { for (int j = 0; j < grid.Height; j++) { if (Random.Range(0, 2) == 0) { grid[i, j] = new AdditionNode(); } else { grid[i, j] = new SubtractionNode(); } } } }
public void Addition_Optimize_RecursiveReduction() { var originalnode = new AdditionNode( new VariableValueNode("a"), new VariableValueNode("b") ); var optimizednode = originalnode.Optimize(new Dictionary <string, ushort> { { "a", 1 }, { "b", 1 } }); Assert.IsInstanceOfType(optimizednode, typeof(ConstantNode)); }
public void PropagateConstants_DetectsSubNodeChanges() { var ast = new ASTNode(); ast.AddChild(new VariableDeclarationNode("byte", "x")); ast.AddChild(new VariableAssignmentNode("x", new ShortValueNode(5))); ast.AddChild(new VariableDeclarationNode("byte", "a")); var value = new AdditionNode(new VariableValueNode("y"), new VariableValueNode("x")); ast.AddChild(new VariableAssignmentNode("a", value)); var changed = PropagateConstants(ast); Assert.IsTrue(changed); }
public void Visit_AdditionNodeWithIncompatibleTypes_LogsCannotUseWithOperatorError() { // Arrange AdditionNode additionNode = new AdditionNode(DummySrcPos); ReferenceNode left = PlayerReferenceNode; IntegerLiteral right = new IntegerLiteral("5", DummySrcPos); additionNode.Left = left; additionNode.Right = right; // Act Checker.Visit(additionNode); // Assert Assert.IsTrue(ErrorLogger.Errors.Count == 1 && ErrorLogger.Errors.First() is CannotUseWithOperatorError); }
public void Visit_AdditionNodeWithCompatibleTypes_LogsNoError() { // Arrange AdditionNode additionNode = new AdditionNode(DummySrcPos); IntegerLiteral left = new IntegerLiteral("2", DummySrcPos); IntegerLiteral right = new IntegerLiteral("5", DummySrcPos); additionNode.Left = left; additionNode.Right = right; // Act Checker.Visit(additionNode); // Assert Assert.IsTrue(ErrorLogger.Errors.Count == 0); }
public void IllegalTensorAddition() { // tensor a[2][1] = { [2.4], [5.1] } // tensor b[2][2] = { [1, 1], // [1, 1] } // tencor c[2][2] = a*b; TensorInitNode aInit = new TensorInitNode(); aInit.FirstRowElements = new List <ExpressionNode>() { new DoubleNode(2.4) }; aInit.Elements = new List <ExpressionNode>() { new DoubleNode(5.1) }; TensorDCLNode a = new TensorDCLNode("tensor", "a", 2, 1, aInit); TensorInitNode bInit = new TensorInitNode(); bInit.FirstRowElements = new List <ExpressionNode>() { new DoubleNode(1), new DoubleNode(1) }; bInit.Elements = new List <ExpressionNode>() { new DoubleNode(1), new DoubleNode(1), }; TensorDCLNode b = new TensorDCLNode("tensor", "b", 2, 2, bInit); AdditionNode addNode = new AdditionNode("+"); addNode.Left = new IDNode("a"); addNode.Right = new IDNode("b"); SymbolTable symbolTable = new SymbolTable(); TypeCheckSymbolTableVisitor visitor = new TypeCheckSymbolTableVisitor(symbolTable); visitor.Visit(a); visitor.Visit(b); Assert.ThrowsException <InvalidOperandsException>(() => { visitor.Visit(addNode); }); }
public void MixedExpressionDoubleAndIntBecomesDoubleNode() { //Arrange InfixExpressionNode node = new AdditionNode("+"); node.Left = new DoubleNode(25.5); node.Right = new IntNode(1); SymbolTable symbolTable = new SymbolTable(); TypeCheckSymbolTableVisitor visitor = new TypeCheckSymbolTableVisitor(symbolTable); //Act visitor.Visit(node); //Assert Assert.AreEqual(node.Type, "double"); }
public void Visit_AdditionNode_EmitsCorrectCode() { // Arrange AdditionNode additionNode = new AdditionNode(DummySrcPos); IntegerLiteral left = new IntegerLiteral("2", DummySrcPos); IntegerLiteral right = new IntegerLiteral("5", DummySrcPos); additionNode.Left = left; additionNode.Right = right; string expectedResult = "2 + 5"; // Act string actualResult = CodeGenerator.Visit(additionNode); // Assert Assert.AreEqual(expectedResult, actualResult); }
public void ValidOperandsToOrOperation() { OrNode node = new OrNode("Or"); EqualNode fourplus6equal10 = new EqualNode("="); InfixExpressionNode addNode = new AdditionNode("+"); addNode.Left = new IntNode(4); addNode.Right = new IntNode(6); fourplus6equal10.Left = addNode; fourplus6equal10.Right = new IntNode(10); node.Left = fourplus6equal10; node.Right = new BoolNode(false); SymbolTable symbolTable = new SymbolTable(); TypeCheckSymbolTableVisitor visitor = new TypeCheckSymbolTableVisitor(symbolTable); visitor.Visit(node); Assert.AreEqual(node.Type, "bool"); }
private ExpressionNode ParseMathExpr() { var lhs = ParseTerm(); while (true) { if (_reader.Peek() is Plus) { Match <Plus>(); lhs = new AdditionNode(lhs, ParseTerm()); } else if (_reader.Peek() is Dash) { Match <Dash>(); lhs = new SubtractionNode(lhs, ParseTerm()); } else { break; } } return(lhs); }
protected SyntaxNode buildSyntaxTree(List <ISyntaxUnit> postfixForm) { Queue <ISyntaxUnit> inputQueue = new Queue <ISyntaxUnit>(postfixForm); Stack <SyntaxNode> operandStack = new Stack <SyntaxNode>(); while (inputQueue.Count > 0) { ISyntaxUnit input = inputQueue.Dequeue(); if (input is Lexeme) { Lexeme token = input as Lexeme; Lexeme.LexemeType ttype = token.Type; if (properties.IsVariable(token.Value)) { VariableIdentifierNode variable = new VariableIdentifierNode(token.Value); operandStack.Push(variable); } else if (properties.IsConstant(token.Value)) { double constantValue = properties.getConstantValue(token.Value); ConstantIdentifierNode constant = new ConstantIdentifierNode(token.Value, constantValue); operandStack.Push(constant); } else if (properties.IsFunctionName(token.Value)) { int nArguments = properties.getFunctionArgumentsCount(token.Value); FunctionApplyNode.FunctionBody funcBody = properties.getFunctionDefinition(token.Value); ArgumentListNode argumentList = new ArgumentListNode(); try { for (int i = 0; i < nArguments; i++) { argumentList.addArgument(operandStack.Pop()); } } catch (InvalidOperationException ex) { throw new ParseException("Not enough operands on operand stack for function call."); } FunctionApplyNode functionCall = new FunctionApplyNode(argumentList, funcBody, token.Value); operandStack.Push(functionCall); } else if (ttype == Lexeme.LexemeType.REAL_VALUE) { double value; if (!double.TryParse(token.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out value)) { throw new ParseException("Couldn't parse literal value: " + token.Value); } LiteralNode literal = new LiteralNode(value); operandStack.Push(literal); } else if (ttype == Lexeme.LexemeType.OP_PLUS) { try { SyntaxNode right = operandStack.Pop(); SyntaxNode left = operandStack.Pop(); AdditionNode addition = new AdditionNode(left, right); operandStack.Push(addition); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for addition."); } } else if (ttype == Lexeme.LexemeType.OP_MINUS) { try { SyntaxNode right = operandStack.Pop(); SyntaxNode left = operandStack.Pop(); SubtractionNode subtraction = new SubtractionNode(left, right); operandStack.Push(subtraction); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for subtraction."); } } else if (ttype == Lexeme.LexemeType.OP_MUL) { try { SyntaxNode right = operandStack.Pop(); SyntaxNode left = operandStack.Pop(); MultiplicationNode multiplication = new MultiplicationNode(left, right); operandStack.Push(multiplication); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for multiplication."); } } else if (ttype == Lexeme.LexemeType.OP_DIV) { try { SyntaxNode right = operandStack.Pop(); SyntaxNode left = operandStack.Pop(); DivisionNode division = new DivisionNode(left, right); operandStack.Push(division); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for division."); } } else if (ttype == Lexeme.LexemeType.OP_POW) { try { SyntaxNode exponent = operandStack.Pop(); SyntaxNode baseNode = operandStack.Pop(); PowerNode power = new PowerNode(baseNode, exponent); operandStack.Push(power); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for exponentiation."); } } else if (ttype == Lexeme.LexemeType.EQ_SIGN) { try { SyntaxNode right = operandStack.Pop(); SyntaxNode left = operandStack.Pop(); EqualsNode eqNode = new EqualsNode(left, right); operandStack.Push(eqNode); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand(s) for assignment."); } } else if (ttype == Lexeme.LexemeType.OP_PLUS_UNARY) { try { SyntaxNode child = operandStack.Pop(); UnaryPlusNode unaryPlus = new UnaryPlusNode(child); operandStack.Push(unaryPlus); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand for unary plus."); } } else if (ttype == Lexeme.LexemeType.OP_MINUS_UNARY) { try { SyntaxNode child = operandStack.Pop(); UnaryMinusNode unaryMinus = new UnaryMinusNode(child); operandStack.Push(unaryMinus); } catch (InvalidOperationException ex) { throw new ParseException("Missing operand for unary minus."); } } else { throw new ParseException("Unexpected token in postfix expression: " + token.simpleRepresentation()); } } else if (input is SyntaxNode) { operandStack.Push(input as SyntaxNode); } else { throw new ParseException("Unexpected object type in postfix expression."); } } if (operandStack.Count == 1) { return(operandStack.Pop()); } else { throw new ParseException("Too many operands in postfix expression."); } }
public abstract T Visit(AdditionNode node);
public void CalculateCorrectly() { var additionNode = new AdditionNode(new NumberNode(42), new NumberNode(54)); additionNode.Calculate().Should().Be(96); }
public void PrintCorrectly() { var additionNode = new AdditionNode(new NumberNode(42), new NumberNode(54)); additionNode.Print().Should().Be("(+ 42 54)"); }
public BinaryExpressionNode ParseBinaryExpresssion(Token operatorToken, AstNode leftOperand, AstNode rightOperand) { BinaryExpressionNode expression = null; switch (operatorToken.Type) { case TokenType.Plus: expression = new AdditionNode(operatorToken.SourceLine); break; case TokenType.Minus: expression = new SubstractionNode(operatorToken.SourceLine); break; case TokenType.Asterisk: expression = new MultiplicationNode(operatorToken.SourceLine); break; case TokenType.Slash: expression = new DivisionNode(operatorToken.SourceLine); break; case TokenType.Equals: expression = new EqualsComparisonNode(operatorToken.SourceLine); break; case TokenType.NotEquals: expression = new NotEqualsComparisonNode(operatorToken.SourceLine); break; case TokenType.Less: expression = new LessComparisonNode(operatorToken.SourceLine); break; case TokenType.EqualsOrLess: expression = new EqualsOrLessComparisonNode(operatorToken.SourceLine); break; case TokenType.Greater: expression = new GreaterComparisonNode(operatorToken.SourceLine); break; case TokenType.EqualsOrGreater: expression = new EqualsOrGreaterComparisonNode(operatorToken.SourceLine); break; case TokenType.And: expression = new LogicalAndNode(operatorToken.SourceLine); break; case TokenType.Or: expression = new LogicalOrNode(operatorToken.SourceLine); break; default: throw new CompilerException($"`{MethodBase.GetCurrentMethod().Name}` called with a bad token. Expected a binary operator, token has type `{operatorToken.Type}` instead."); } expression.LeftOperand = leftOperand; expression.RightOperand = rightOperand; return(expression); }
public GaussianBlurPS() { Name = "GaussianBlurPS"; Type = ShaderType.Pixel; FeatureLevel = FeatureLevel.PS_4_0_Level_9_1; KeyPart = new TechniqueKey(ps: PixelShaderFlags.DiffuseMap); EnableSeparators = true; Struct inputStruct = SpriteVS.VSOut; inputStruct.Name = "input"; InputStruct = inputStruct; var cbStatic = CBFrame; var fOffsetsAndWeights = CBFrame[Param.Floats.BlurOffsetsAndWeights]; Texture tDiffuse = Texture.Diffuse; Sampler sLinear = Sampler.MinMagMipLinearWrap; Add(tDiffuse); Add(sLinear); Add(cbStatic); DeclarationNode nColor = DeclarationNode.InitNode("color", Shaders.Type.Float4, 0, 0, 0, 0); ArrayNode fOffsetWeight = new ArrayNode { Input = fOffsetsAndWeights, Index = "i" }; AdditionNode nBlur = new AdditionNode { PreCondition = new ForBlock { PreCondition = nColor, StartCondition = new ScalarNode { Value = 0 }, EndCondition = new ScalarNode { Value = 15 } }, OpensBlock = true, Input1 = nColor, Input2 = new MultiplyNode { Input1 = new TextureSampleNode { Texture = tDiffuse, Sampler = sLinear, Coordinates = new AdditionNode { Input1 = new ReferenceNode { Value = InputStruct[Param.SemanticVariables.Texture] }, Input2 = new SwizzleNode { Input = fOffsetWeight, Swizzle = new [] { Swizzle.X, Swizzle.Y } }, } }, Input2 = new SwizzleNode { Input = fOffsetWeight, Swizzle = new[] { Swizzle.Z } }, }, ClosesBlock = true, IsVerbose = true, Declare = false, AssignToInput1 = true, Output = nColor.Output }; OutputStruct = Struct.PixelShaderOutput; Result = new PSOutputNode { FinalColor = nBlur, Output = OutputStruct }; }
public override int Visit(AdditionNode node) => Visit(node.Left) + Visit(node.Right);
private Value Addition(AdditionNode exp) { try { Constant left = Eval(exp.Left).GetRValue(); Constant right = Eval(exp.Right).GetRValue(); Constant.Type leftType = left.ConstantType; Constant.Type rightType = right.ConstantType; Constant.Type bt = Max(leftType, rightType); switch (bt) { case Constant.Type.Complex: { ComplexValue l = (ComplexValue)Convert(left, bt); ComplexValue r = (ComplexValue)Convert(right, bt); return(ComplexValue.OpAdd(l, r)); } case Constant.Type.Int: { IntValue l = (IntValue)Convert(left, bt); IntValue r = (IntValue)Convert(right, bt); return(IntValue.OpAdd(l, r)); } case Constant.Type.Float: { FloatValue l = (FloatValue)Convert(left, bt); FloatValue r = (FloatValue)Convert(right, bt); return(FloatValue.OpAdd(l, r)); } case Constant.Type.String: { StringValue l = (StringValue)Convert(left, bt); StringValue r = (StringValue)Convert(right, bt); return(StringValue.OpAdd(l, r)); } } throw new ModelInterpreterException("Сложение не определено для типа \"" + bt.ToString() + "\".") { Line = exp.Line, Position = exp.Position }; } catch (TypeConversionError exc) { throw new ModelInterpreterException($"Не удалось преобразование из \"{exc.Src}\" в \"{exc.Dst}\"") { Line = exp.Line, Position = exp.Position }; } catch (ModelInterpreterException exc) { throw exc; } catch (Exception exc) { throw new ModelInterpreterException(exc.Message) { Line = exp.Line, Position = exp.Position }; } }