C＃中更好的电源功能？ [英] A better power function in C#?

问题描述

我是一名工程师，编写相当数学的代码，有时Math.Pow（）函数使复杂的方程非常难以阅读和调试。



结果我写了以下简单的代码来覆盖^函数，它有点帮助，但唯一的问题是^的优先级低于*。这意味着添加多余的（在我的视图中，在不需要它们的地方）。



有没有更好的方法将功能函数转换为C＃？ br />

  public   struct  MyDouble 
 {
  double   var ; 
 
  private  MyDouble（ double   var ）
 {
  this 。 var  =  VAR ; 
} 
 
  public   static  隐式 运算符 MyDouble（ double  价值）
 {
 返回 新 MyDouble（值）; 
} 
 
  public   static  显式 运算符  double （MyDouble 值）
 {
 返回 值。 VAR ; 
} 
 
  public   static  MyDouble  operator  ^（MyDouble val1，MyDouble val2）
 {
  return   new  MyDouble（Math.Pow（val1。 var ，val2。 var ））; 
} 
 
  public   static  MyDouble  operator  *（MyDouble val1，MyDouble val2）
 {
  return   new  MyDouble（val1。 var  * val2。 var ）; 
} 
 
  public   static  MyDouble  operator  /（MyDouble val1，MyDouble val2）
 {
  return   new  MyDouble（val1。 var  / val2。 var ）; 
} 
 
  public   static  MyDouble  operator  +（MyDouble val1，MyDouble val2）
 {
  return   new  MyDouble（val1。 var  + val2。 var ）; 
} 
 
  public   static  MyDouble  operator   - （MyDouble val1， double  val2）
 {
  return   new  MyDouble（val1。 var   -  val2）; 
} 
 
  public   static  MyDouble  operator   - （MyDouble val1，MyDouble val2）
 {
  return   new  MyDouble（val1。 var   -  val2。 var ）; 
} 
 
  public   static  MyDouble  operator   - （MyDouble val1）
 {
  return   new  MyDouble（-val1。 var ）; 
} 
 
  public   static  MyDouble  operator   - （ double  val1，MyDouble val2）
 {
  return   new  MyDouble（val1  -  val2。 var ）; 
} 
 
  public   static   bool  运算符 > （MyDouble val1，MyDouble val2）
 {
  return  val1。 var  >  val2。 var ; 
} 
 
  public   static   bool  运算符 < （MyDouble val1，MyDouble val2）
 {
  return  val1。 var  <  val2。 var ; 
} 
 
  public   static  MyDouble  operator  ^（MyDouble val1， double  val2）
 {
  return   new  MyDouble（Math.Pow（val1。 var ，val2））; 
} 
} 

解决方案

您无法更改（或覆盖）C＃中运算符的评估优先级。因此*总是优先于^，即使你反过来也会超负荷。



你的抱怨只是Math.Pow很难看？

我想给你一个很好的实用建议：永远不要覆盖数学运算符，使它们表示数学函数。现在看起来它只会提高可读性，但事实上它甚至会让你感到困惑。同时，覆盖数学运算符以表示非算术的东西是非常方便的。例如，'+'可以从两个树操作数构建树。或者将一个元素添加到列表中。或其他。

-SA

我知道你对

double a = ...;
double b = ...;
double c = Math.Pow（a，b）;

怎么样

 ... 
  double  c = a.Pow（b）; 

如果这是您想要的，请为 double 创建一个名为 Pow 的类型的扩展方法。例如。

  public   static   class  DoubleExtension 
 {
  public   static   double  Pow（此  double  a， double  b）{ return  Math.Pow（a，b）; } 
} 

您当然可以使用 Pow 以外的其他名称作为扩展方法。 />
干杯

Andi

I am an engineer writing fairly mathematical code and sometimes the Math.Pow() function makes complex equations extremely difficult to read and debug.

As result I wrote the following simple code to override the ^ function, it sort of helps but the only probelm is that ^ has less priority than * for example. This means adding superfluous (in my view brackets in places where they shouldn't be needed).

Is there any better way to get a power function into C#?

public struct MyDouble
    {
        double var;

        private MyDouble(double var)
        {
            this.var = var;
        }

        public static implicit operator MyDouble(double value)
        {
            return new MyDouble(value);
        }

         public static explicit operator double(MyDouble value)
         {
             return value.var;
         }

        public static MyDouble operator ^(MyDouble val1, MyDouble val2)
        {
            return new MyDouble(Math.Pow(val1.var, val2.var));
        }

        public static MyDouble operator *(MyDouble val1, MyDouble val2)
        {
            return new MyDouble(val1.var * val2.var);
        }

        public static MyDouble operator /(MyDouble val1, MyDouble val2)
        {
            return new MyDouble(val1.var / val2.var);
        }

        public static MyDouble operator +(MyDouble val1, MyDouble val2)
        {
            return new MyDouble(val1.var + val2.var);
        }

        public static MyDouble operator -(MyDouble val1, double val2)
        {
            return new MyDouble(val1.var - val2);
        }

        public static MyDouble operator -(MyDouble val1, MyDouble val2)
        {
            return new MyDouble(val1.var - val2.var);
        }

        public static MyDouble operator -(MyDouble val1)
        {
            return new MyDouble(-val1.var);
        }

        public static MyDouble operator -(double val1, MyDouble val2)
        {
            return new MyDouble(val1 - val2.var);
        }

        public static bool operator >(MyDouble val1, MyDouble val2)
        {
            return val1.var > val2.var;
        }

        public static bool operator <(MyDouble val1, MyDouble val2)
        {
            return val1.var < val2.var;
        }

        public static MyDouble operator ^(MyDouble val1, double val2)
        {
            return new MyDouble(Math.Pow(val1.var, val2));
        }
}

解决方案

You cannot change (or override) the evaluation precedence of operators in C#. Thus * will always take priority over ^ even if you were to overload them the other way round.

Is your gripe merely that Math.Pow is ugly?

I want to give you a good practical advice: never override mathematical operators to make them denote mathematical functions. It only seems to you now that it would improve readability, but in fact it will later confuse even you. At the same time, it can be very convenient to override mathematical operator to denote something non-arithmetic. For example '+' can build a tree from two tree operands. Or add an element to a list. Or something else.

—SA

I understand that you are not happy with

double a = ...;
double b = ...;
double c = Math.Pow(a,b);

How about

...
double c = a.Pow(b);

If this is what you want, create an extension method for double type named Pow. E.g.

public static class DoubleExtension
{
    public static double Pow(this double a, double b) { return Math.Pow(a, b); }
}

You may of course use other names than Pow for the extension method.
Cheers
Andi

这篇关于C＃中更好的电源功能？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！