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);
