Why does the multiplication node not exist when traversing the representation tree

[nczsl]

public class ExprVisitor : ExpressionVisitor {
    public Expr exp;
    public override Expression Visit(Expression node) {
        return base.Visit(node);
    }
    protected override Expression VisitBinary(BinaryExpression node) {
        Console.WriteLine(node.Left);
        Console.WriteLine(node.Right);
        Console.WriteLine(node.NodeType);
        return base.VisitBinary(node);
    }
    protected override Expression VisitBlock(BlockExpression node) {
      ...

[nczsl]

Because I expect every computing node in the computing tree to be included so that I can do my transcription work, but now it seems that the multiplication node has been omitted? What should I do now?

[CyrusNajmabadi]

Expressions follow the rules of the C# language. In this case you have constants multiplied together. The compiler will replace that with the final constant value. You might be able to play around with defining your own type that has operators, and using those instead. May or may not work, but it could bypass the compiler's constant evaluation.

[nczsl]

This is a + case. As you can see, each computing node has been traversed

[CyrusNajmabadi]

These cases are not equivalent. Addition will be treated as (((x + 3d) + 2d) + 3d). This is not constant, so the compiler will not do constant folding. In the multiple case you have effectively (x + 3d) + (2d * 3d). Here (2d * 3d) is constant, do you get (x + 3d) + 6d).

[nczsl]

I just hope that there is no compilation and folding, but I need to traverse each calculation node so that I can transcribe it into a correct mathematical tree. The canstant class is my own custom, which overloads ^ as the multiplier operator. If this is mixed, this tree cannot be done correctly by me when traversing. Is there any way or suggestion for me?

[CyrusNajmabadi]

I can think of no way to support this without you needing to at least occasionally tweak the expression. For example, if you did: x + 3d + (Constant.One * 2d * 3d ^ x) then you might be ok. But as long as you have subexpressions that are parsed out independently that are only doubles, then you will get constant folding.

[nczsl]

ok thanks!