I want to overload some mathematical operators. How do I specify the priority?

[nczsl]

using System;
using System.Collections.Generic;
using System.Text;

namespace Util.Mathematics {
///

/// 二叉树遍历方式
///

public enum TravelType {
Foreword, Middle, Back
}
abstract public class Expr {
protected Expr left, right, parent;
public IEnumerable Travel(TravelType tt = TravelType.Back) {
switch (tt) {
case TravelType.Foreword:
yield return this;
if (left != null) foreach (var item in left.Travel(tt)) yield return item;
if (right != null) foreach (var item in right.Travel(tt)) yield return item;
break;
case TravelType.Middle:
if (left != null) foreach (var item in left.Travel(tt)) yield return item;
yield return this;
if (right != null) foreach (var item in right.Travel(tt)) yield return item;
break;
case TravelType.Back:
if (left != null) foreach (var item in left.Travel(tt)) yield return item;
if (right != null) foreach (var item in right.Travel(tt)) yield return item;
yield return this;
break;
default:
break;
}
}
public struct Type {
internal string value;
public Type(string value) {
this.value = value;
}
static public Type None = nameof(None);
static public Type Add = "+";
static public Type Subtract = "-";
static public Type Multiply = "*";
static public Type Divide = "/";
static public Type Pow = "^";
static public Type Log = "log";
static public Type Lg = "lg";
static public Type Sin = "sin";
static public Type Cos = "cos";
static public Type Tan = "tan";
static public Type Ctan = "ctan";
static public Type Abs = "abs";
static public Type Exp = "exp";
static public Type Ln = "ln";
static public Type Round = "round";
static public Type Floor = "floor";
static public Type Max = "max";
static public Type Min = "min";
static public Type Ceiling = "ceiling";
static public Type Asin = "asin";
static public Type Acos = "acos";
static public Type Atan = "atan";
static public implicit operator Type(string value) => new Type(value);
static public implicit operator string(Type con) => con.value;
public int Priority => this switch
{
Type x when x == Add => 0,
Type x when x == Subtract => 0,
Type x when x == Multiply => 1,
Type x when x == Divide => 1,
Type x when x == Pow => 2,
Type x when x == Log => 2,
Type x when x == Lg => 2,
Type x when x == Ln => 2,
_ => 3
};
public override string ToString() => this.value;
}
public Expr.Type OperType { get; set; }

    public Expr(Expr.Type type) {
        this.OperType = type;
    }
    protected virtual void Transform() { }
    abstract public Expr Merage();
    abstract public Expr Extand();
    abstract public T Calculate<T>();
}
public class Constant : Expr {
    public double Value { get; private set; }
    public Constant(double value = 0d) : base(Expr.Type.None) {
        this.Value = value;
    }
    Func<Constant, Constant, Constant> func;
    public Constant(Expr.Type type) : base(type) {
        func = type.value switch
        {
            "+" => (l, r) => l.Value + r.Value,
            "-" => (l, r) => l.Value - r.Value,
            "*" => (l, r) => l.Value * r.Value,
            "/" => (l, r) => l.Value / r.Value,
            "^" => (l, r) => Math.Pow(l, r),
            "&" => (l, r) => Math.Log(l, r),
            "sin" => (l, r) => Sin(l ?? r),
            "cos" => (l, r) => Cos(l ?? r),
            "tan" => (l, r) => Tan(l ?? r),
            "ctan" => (l, r) => 1d / Tan(l ?? r),
            "exp" => (l, r) => Math.Exp(l ?? r),
            "ln" => (l, r) => Math.Log(l ?? r),
            "abs" => (l, r) => Abs(l ?? r),
            "max" => (l, r) => Math.Max(l, r),
            "min" => (l, r) => Math.Min(l, r),
            "floor" => (l, r) => Math.Floor(l ?? r),
            "ceiling" => (l, r) => Math.Ceiling(l ?? r),
            "round" => (l, r) => Math.Round(l ?? r),
            "asin" => (l, r) => Math.Asin(l ?? r),
            "acos" => (l, r) => Math.Acos(l ?? r),
            "atan" => (l, r) => Math.Atan(l ?? r),
            _ => null,
        };
    }
    static public implicit operator double(Constant item) => item.Value;
    static public implicit operator Constant(double value) => new Constant(value);
    static public Constant operator -(Constant a, Constant b)
        => new Constant(Expr.Type.Subtract) { left = a, right = b };
    static public Constant operator -(Constant a, double b)
        => new Constant(Expr.Type.Subtract) { left = a, right = (Constant)b };
    static public Constant operator -(double a, Constant b)
        => new Constant(Expr.Type.Subtract) { left = (Constant)a, right = b };
    static public Constant operator *(Constant a, Constant b)
        => new Constant(Expr.Type.Multiply) { left = a, right = b };
    static public Constant operator *(Constant a, double b)
         => new Constant(Expr.Type.Multiply) { left = a, right = (Constant)b };
    static public Constant operator *(double a, Constant b)
        => new Constant(Expr.Type.Multiply) { left = (Constant)a, right = b };
    static public Constant operator /(Constant a, Constant b)
        => new Constant(Expr.Type.Divide) { left = a, right = b };
    static public Constant operator /(Constant a, double b)
        => new Constant(Expr.Type.Divide) { left = a, right = (Constant)b };
    static public Constant operator /(double a, Constant b)
        => new Constant(Expr.Type.Divide) { left = (Constant)a, right = b };
    static public Constant operator ^(Constant a, Constant b)
        => new Constant(Expr.Type.Pow) { left = a, right = b };
    static public Constant operator ^(Constant a, double b)
        => new Constant(Expr.Type.Pow) { left = a, right = (Constant)b };
    static public Constant operator ^(double a, Constant b)
        => new Constant(Expr.Type.Pow) { left = (Constant)a, right = b };
    static public Constant operator &(Constant a, Constant b)
        => new Constant(Expr.Type.Log) { left = a, right = b };
    static public Constant operator &(Constant a, double b)
        => new Constant(Expr.Type.Log) { left = a, right = (Constant)b };
    static public Constant operator &(double a, Constant b)
        => new Constant(Expr.Type.Log) { left = (Constant)a, right = b };
    static public Constant operator +(Constant a, Constant b)
        => new Constant(Expr.Type.Add) { left = a, right = b };
    static public Constant operator +(Constant a, double b)
        => new Constant(Expr.Type.Add) { left = a, right = (Constant)b };
    static public Constant operator +(double a, Constant b)
        => new Constant(Expr.Type.Add) { left = (Constant)a, right = b };
    public const double PI = Math.PI;
    public const double E = Math.E;
    public Constant Sin(Constant v) => Math.Sin(v.Value);
    public Constant Cos(Constant v) => Math.Cos(v.Value);
    public Constant Pow(Constant l, Constant r) => Math.Pow(l.Value, r.Value);
    public Constant Sqrt(Constant v) => Math.Sqrt(v.Value);
    public Constant Round(Constant v) => Math.Round(v.Value);
    public Constant Abs(Constant v) => Math.Abs(v.Value);
    public Constant Acos(Constant v) => Math.Acos(v.Value);
    public Constant Acosh(Constant v) => Math.Acosh(v.Value);
    public Constant Asin(Constant v) => Math.Asin(v.Value);
    public Constant Asinh(Constant v) => Math.Asinh(v.Value);
    public Constant Atan(Constant v) => Math.Atan(v.Value);
    //public Constant Atan2(Constant v) => Math.Atan2(v.value);
    public Constant Atanh(Constant v) => Math.Atanh(v.Value);
    public Constant Cbrt(Constant v) => Math.Cbrt(v.Value);
    public Constant Ceiling(Constant v) => Math.Ceiling(v.Value);
    public Constant Tan(Constant v) => Math.Tan(v.Value);
    public override Expr Merage() {
        if (this.OperType != Type.None) {
            var l = left?.Merage() as Constant;
            var r = right?.Merage() as Constant;
            return func(l, r);
        } else {
            return this;
        }
    }

    public override Expr Extand() {
        throw new NotImplementedException();
    }

    public override T Calculate<T>() {
        var x=Merage() as Constant;
        return (T)(object)x.Value;
    }
}
public class Vector : Expr {
    int no;
    Matrix refMatrix;
    bool isRow;
    public Vector(Matrix m, int no, bool isRow = true) : base(Expr.Type.None) {
        this.refMatrix = m;
        this.no = no;
        this.isRow = isRow;
    }
    public override Expr Merage() {
        throw new NotImplementedException();
    }

    public override T Calculate<T>() {
        throw new NotImplementedException();
    }

    public override Expr Extand() {
        throw new NotImplementedException();
    }
}
public class Matrix : Expr {
    public double[,] Value { get; private set; }
    public Matrix(double[,] value) : base(Expr.Type.None) {
        this.Value = value;
    }
    public override Expr Merage() {
        throw new NotImplementedException();
    }

    public override Expr Extand() {
        throw new NotImplementedException();
    }

    public override T Calculate<T>() {
        throw new NotImplementedException();
    }
}
public class Symbol : Expr {
    Func<Symbol, Symbol, Symbol> func;
    public Symbol(Expr.Type type) : base(type) {
        this.Times = this.Coefficient = 1;
        func = type.value switch
        {
            "+" => (l, r) => {
                switch (l, r) {
                    case (Symbol x, Symbol y) when x.OperType == Expr.Type.None && y.OperType == Expr.Type.None:
                        if (x.Id == y.Id && x.Times == y.Times) {
                            this.Id = x.Id;
                            this.Coefficient = x.Coefficient + y.Coefficient;
                            this.Times = x.Times;
                            this.left = this.right = null;
                            this.OperType = Expr.Type.None;
                        }
                        break;
                }
                return this;
            }
            ,
            "-" => (l, r) => {
                var result = this;
                switch (l, r) {
                    case (Symbol x, Symbol y) when x.OperType == Expr.Type.None && y.OperType == Expr.Type.None:
                        if (x.Id == y.Id && x.Times == y.Times) {
                            this.Id = x.Id;
                            this.Coefficient = x.Coefficient - y.Coefficient;
                            this.Times = x.Times;
                            this.left = this.right = null;
                            this.OperType = Expr.Type.None;
                        }
                        break;
                }
                return result;
            }
            ,
            "*" => (l, r) => {
                var result = this;
                switch (l, r) {
                    case (Symbol x, Symbol y) when x.OperType == Expr.Type.None && y.OperType == Expr.Type.None:
                        if (x.Id == y.Id) {
                            this.Id = x.Id;
                            this.Coefficient = x.Coefficient * y.Coefficient;
                            this.Times = x.Times + y.Times;
                            this.left = this.right = null;
                            this.OperType = Expr.Type.None;
                        }
                        break;
                }
                return result;
            }
            ,
            //"/" => (l, r) => (Constant)((Constant)l / (Constant)r),
            //"^" => (l, r) => (Constant)Math.Pow((Constant)l, (Constant)r),
            //"&" => (l, r) => (Constant)Math.Log((Constant)l, (Constant)r),
            ////"sin" => (l, r) => Math.Sin((Constant)l ?? (Constant)r),
            ////"cos" => (l, r) => Cos((Constant)l ?? (Constant)r),
            ////"tan" => (l, r) => (Constant)Tan((Constant)l ?? (Constant)r),
            ////"ctan" => (l, r) => (Constant)(1d / Tan((Constant)l ?? (Constant)r)),
            //"exp" => (l, r) => (Constant)Math.Exp((Constant)l ?? (Constant)r),
            //"ln" => (l, r) => (Constant)Math.Log((Constant)l ?? (Constant)r),
            ////"abs" => (l, r) => (Constant)Abs((Constant)l ?? (Constant)r),
            //"max" => (l, r) => (Constant)Math.Max((Constant)l, (Constant)r),
            //"min" => (l, r) => (Constant)Math.Min((Constant)l, (Constant)r),
            //"floor" => (l, r) => (Constant)Math.Floor((Constant)l ?? (Constant)r),
            //"ceiling" => (l, r) => (Constant)Math.Ceiling((Constant)l ?? (Constant)r),
            //"round" => (l, r) => (Constant)Math.Round((Constant)l ?? (Constant)r),
            //"asin" => (l, r) => (Constant)Math.Asin((Constant)l ?? (Constant)r),
            //"acos" => (l, r) => (Constant)Math.Acos((Constant)l ?? (Constant)r),
            //"atan" => (l, r) => (Constant)Math.Atan((Constant)l ?? (Constant)r),
            _ => null,
        };
    }
    public string Id { get; set; }
    public double Times { get; set; }
    public double Coefficient { get; set; }
    public string Value {
        get {
            var v="";
            if (Coefficient!=1) {
                v=$"{Coefficient}.";
            }
            if (string.IsNullOrWhiteSpace(Id)) {
                v+=Id;
            }
            if (Times!=1) {
                v+=$"^{Times}";
            }
            return v;
        }
    }
    static public Symbol operator -(Symbol a, Symbol b)
        => new Symbol(Expr.Type.Subtract) { left = a, right = b };
    static public Symbol operator -(Symbol a, double b)
        => new Symbol(Expr.Type.Subtract) { left = a, right = (Constant)b };
    static public Symbol operator -(double a, Symbol b)
        => new Symbol(Expr.Type.Subtract) { left = (Constant)a, right = b };
    static public Symbol operator *(Symbol a, Symbol b)
        => new Symbol(Expr.Type.Multiply) { left = a, right = b };
    static public Symbol operator *(Symbol a, double b)
         => new Symbol(Expr.Type.Multiply) { left = a, right = (Constant)b };
    static public Symbol operator *(double a, Symbol b)
        => new Symbol(Expr.Type.Multiply) { left = (Constant)a, right = b };
    static public Symbol operator /(Symbol a, Symbol b)
        => new Symbol(Expr.Type.Divide) { left = a, right = b };
    static public Symbol operator /(Symbol a, double b)
        => new Symbol(Expr.Type.Divide) { left = a, right = (Constant)b };
    static public Symbol operator /(double a, Symbol b)
        => new Symbol(Expr.Type.Divide) { left = (Constant)a, right = b };
    static public Symbol operator ^(Symbol a, Symbol b)
        => new Symbol(Expr.Type.Pow) { left = a, right = b };
    static public Symbol operator ^(Symbol a, double b)
        => new Symbol(Expr.Type.Pow) { left = a, right = (Constant)b };
    static public Symbol operator ^(double a, Symbol b)
        => new Symbol(Expr.Type.Pow) { left = (Constant)a, right = b };
    static public Symbol operator &(Symbol a, Symbol b)
        => new Symbol(Expr.Type.Log) { left = a, right = b };
    static public Symbol operator &(Symbol a, double b)
        => new Symbol(Expr.Type.Log) { left = a, right = (Constant)b };
    static public Symbol operator &(double a, Symbol b)
        => new Symbol(Expr.Type.Log) { left = (Constant)a, right = b };
    static public Symbol operator +(Symbol a, Symbol b)
        => new Symbol(Expr.Type.Add) { left = a, right = b };
    static public Symbol operator +(Symbol a, double b)
        => new Symbol(Expr.Type.Add) { left = a, right = (Constant)b };
    static public Symbol operator +(double a, Symbol b)
        => new Symbol(Expr.Type.Add) { left = (Constant)a, right = b };

    public override Expr Merage() {
        throw new NotImplementedException();
    }

    public override Expr Extand() {
        throw new NotImplementedException();
    }

    public override T Calculate<T>() {
        throw new NotImplementedException();
    }
}

}
//
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
using Util.Mathematics;

namespace Netlibs.Test {
[Microsoft.VisualStudio.TestTools.UnitTesting.TestClass]
public class MathBasic {
[TestMethod]
public void m11() {
Expression<Func<Constant, Constant>> exp =
x => x + 3d + 2d ^ x;
Expression<Func<double, double>> exp1 =
x => x + 3d + 2d * x;
Expression<Func<Constant, Constant>> exp2 =
x => x + (Constant)3d + (Constant)2d ^ x;
var x = new ExprVisitor();
x.Visit(exp.Body);
Console.WriteLine();
x.Visit(exp1.Body);
Console.WriteLine();
x.Visit(exp2.Body);
var constantR = exp.Compile().Invoke(10);
Console.WriteLine("befor:{0}", constantR.Value);
Console.WriteLine("after:{0}", constantR.Calculate());
}
}
}
//
^The operator is a power, but because its priority cannot be set, the expression expression used in the test cannot be parsed into a correct mathematical expression tree. How can this be done?

So I hope C# can support more complete mathematical symbols

[CyrusNajmabadi]

You can not change parser precedence. Sorry!

[nczsl]

oh。。