private void PrintExpression(InfixExpressionNode node) { if (node.Type == "tensor") { TensorCodeGen(node); } else if (node is PowerNode) { Emit("pow("); Visit(node.Left); Emit(", "); Visit(node.Right); Emit(")"); } else { Visit(node.Left); if (node is AndNode || node is OrNode) { string symbol = node is AndNode ? "&&" : "||"; Emit(" " + symbol + " "); } else { Emit(" " + node.Symbol + " "); } Visit(node.Right); } }
// --- Arithmetic --- public override void Visit(InfixExpressionNode node) { if (node.Parenthesized) { Emit("("); } PrintExpression(node); if (node.Parenthesized) { Emit(")"); } }
public override ExpressionNode VisitInfixExpr(CoronaParser.InfixExprContext context) { // Get infix expression node type InfixExpressionNode node = context.op.GetText() switch { "+" => new AdditionNode(), "-" => new SubstractionNode(), "*" => new MultiplicationNode(), "/" => new DivisionNode(), _ => throw new ArgumentOutOfRangeException("context", "Unknown operator in switch statement - VisitInfixExpr") }; // Visit the left and of the node node.Left = Visit(context.left); node.Right = Visit(context.right); return(node); }
/// <summary> /// Visit Operation node /// </summary> public override ExpressionNode VisitOp([NotNull] QueryFilterParser.OpContext context) { var column = context.COLUMN(); var target = context.TARGET(); var verb = context.VERB(); var node = new InfixExpressionNode() { Verb = verb.GetText(), Left = new ColumnNode() { Value = column.GetText() }, Right = new TargetNode() { Value = target.GetText() } }; return(node); }
private void TensorCodeGen(InfixExpressionNode node) { switch (node) { // Left or right is a tensor case AdditionNode or SubtractionNode: Emit(node is AdditionNode ? "tadd(" : "tsub("); if (node.Left.Type != "tensor") { Emit("convertToTensor("); Visit(node.Left); Emit($", {node.Rows}, {node.Columns})"); } else { Visit(node.Left); } Emit(", "); if (node.Right.Type != "tensor") { Emit("convertToTensor("); Visit(node.Right); Emit($", {node.Rows}, {node.Columns})"); } else { Visit(node.Right); } Emit(")"); break; case MultiplicationNode when node.Left.Type != "tensor" || node.Right.Type != "tensor": Emit("scalarmul("); if (node.Left.Type != "tensor") { Visit(node.Left); Emit(", "); Visit(node.Right); Emit(")"); } else { Visit(node.Right); Emit(", "); Visit(node.Left); Emit(")"); } break; // Left is tensor and right is double/int case DivisionNode: Emit("tdiv("); Visit(node.Left); Emit(", "); Visit(node.Right); Emit(")"); break; case PowerNode: Emit("tpow("); Visit(node.Left); Emit(", "); Visit(node.Right); Emit(")"); break; // Left and right are tensors case MultiplicationNode: Emit("tmul("); Visit(node.Left); Emit(", "); Visit(node.Right); Emit(")"); break; } }
public override void Visit(InfixExpressionNode node) { switch (node) { // Arithmetic case AdditionNode: Console.WriteLine("+"); break; case SubtractionNode: Console.WriteLine("-"); break; case MultiplicationNode: Console.WriteLine("*"); break; case DivisionNode: Console.WriteLine("/"); break; case PowerNode: Console.WriteLine("**"); break; // Equality case EqualNode: Console.WriteLine("=="); break; case NotEqualNode: Console.WriteLine("!="); break; // Boolean case AndNode: Console.WriteLine("and"); break; case OrNode: Console.WriteLine("or"); break; // Relational case LessThanNode: Console.WriteLine("<"); break; case LessEqualThanNode: Console.WriteLine("<="); break; case GreaterThanNode: Console.WriteLine(">"); break; case GreaterEqualThanNode: Console.WriteLine(">="); break; default: throw new NotSupportedException(); } i += 2; VisitChildren(node, Inden()); i -= 2; }
public override void Visit(InfixExpressionNode node) { base.Visit(node); switch (node) { // Arithmetic case AdditionNode: case SubtractionNode: case MultiplicationNode: case DivisionNode: case PowerNode: if (node.Left.Type == "bool" || node.Right.Type == "bool") { throw new InvalidOperandsException(node, "The operands of a arithmetic operator can only be int and double. It does not allow bool."); } else if (node.Left.Type == "int" && node.Right.Type == "int") { node.Type = "int"; } else if (node.Left.Type == "tensor" || node.Right.Type == "tensor") { TensorTypecheck(node); } else if (node.Left.Type == "double" || node.Right.Type == "double") { node.Type = "double"; } break; // Relational case LessThanNode: case LessEqualThanNode: case GreaterThanNode: case GreaterEqualThanNode: case EqualNode: case NotEqualNode: if (node.Left.Type == "bool" || node.Right.Type == "bool") { throw new InvalidOperandsException(node, "The operands of a relational operator can only be int and double. It does not allow bool."); } else if (node.Left.Type == "tensor" || node.Right.Type == "tensor") { throw new InvalidOperandsException(node, "The operands of a relational operator can only be int and double. It does not allow tensor."); } else { node.Type = "bool"; } break; // Boolean case AndNode: case OrNode: if (node.Left.Type != "bool" || node.Right.Type != "bool") { throw new InvalidOperandsException(node, "The operands of a bool operator can only be bool. It does not allow int, double or tensor."); } else { node.Type = "bool"; } break; default: throw new NotSupportedException(); } }
private void TensorTypecheck(InfixExpressionNode node) { if (node.Left.Type == "tensor" && node.Right.Type == "tensor") { switch (node) { case AdditionNode: case SubtractionNode: if (node.Left.Rows != node.Right.Rows || node.Left.Columns != node.Right.Columns) { throw new InvalidOperandsException(node, $"The dimensions of the tensors are incorrect for the operation \"{node.Symbol}\"."); } node.Rows = node.Left.Rows; node.Columns = node.Left.Columns; node.Type = "tensor"; break; case MultiplicationNode: if (node.Left.Columns != node.Right.Rows) { throw new InvalidOperandsException(node, $"The dimensions of the tensors are incorrect for the operation \"{node.Symbol}\"."); } node.Rows = node.Left.Rows; node.Columns = node.Right.Columns; node.Type = "tensor"; break; default: throw new InvalidOperandsException(node, $"The operator \"{node.Symbol}\", does not allow right operands of type tensor."); } return; } if (node.Left.Type == "tensor") { switch (node) { case AdditionNode: case SubtractionNode: case MultiplicationNode: case DivisionNode: case PowerNode: node.Rows = node.Left.Rows; node.Columns = node.Left.Columns; node.Type = "tensor"; break; default: throw new InvalidOperandsException(node, $"The operator \"{node.Symbol}\", does not allow operands of type tensor."); } return; } if (node.Right.Type == "tensor") { switch (node) { case AdditionNode: case SubtractionNode: case MultiplicationNode: node.Rows = node.Right.Rows; node.Columns = node.Right.Columns; node.Type = "tensor"; break; default: throw new InvalidOperandsException(node, $"The operator \"{node.Symbol}\", does not allow right operands of type tensor."); } } }
public override int Visit(InfixExpressionNode node) { MathExpressionAstEvaluator expressionAstEvaluator = new MathExpressionAstEvaluator(); return(expressionAstEvaluator.Visit(node)); }
public virtual void Visit(InfixExpressionNode node) { VisitChildren(node); }
public abstract T Visit(InfixExpressionNode node);