泛型类的隐式转换仅限于某些类型

Question

假设我们对泛型类 Matrix<T> 有想法，其中 T 是数字类型（Complex 或 double 或 float、int 等）。

很自然，我们在 C# 中进行了从 float 到 double、从 double 到 Complex 的隐式转换。一般规则是我们有从较小类型到较大类型的隐式转换。到目前为止一切顺利。

现在假设我们正在实现我们的Matrix<T> 类型。由于这种新类型在某种程度上也是数字的（或者至少它包含数值），所以从Matrix<float> 到Matrix<double>、从Matrix<double> 到Matrix<Complex> 等进行隐式转换是很自然的。至少它是很高兴将这些用于乘法、加法等数学运算。但这似乎无法正确实现，因为隐式运算符要求至少一种类型与我们在其中实现它的类相同。

示例：即使认为可以解决我的问题，以下代码也无法编译。

public abstract partial class Matrix<T>
{
    /// <summary>
    /// Implicitly converts a matrix to double precision complex numbers.
    /// </summary>
    public static implicit operator Matrix<Complex64>(Matrix<double> matrix)
    {
        matrix.ToComplex();
    }

    /// <summary>
    /// Implicitly converts a matrix to double precision real numbers.
    /// </summary>
    public static implicit operator Matrix<double>(Matrix<float> matrix)
    {
        matrix.ToDouble();
    }
}

它不会编译，因为“CS0556 用户定义的转换必须转换为封闭类型或从封闭类型转换”，假设我很好，因为它是语言规范的一部分，但不应该有任何其他方式实现这个？

例如，这也不编译。

public abstract partial class Matrix<double>
{
    /// <summary>
    /// Implicitly converts a matrix to single precision real numbers.
    /// </summary>
    public static implicit operator Matrix<double>(Matrix<float> matrix)
    {
        matrix.ToDouble();
    }
}

有没有办法实现这个东西，感觉很自然所以我觉得应该可以实现？

现在我创建了一个解决方法，它可以将所有类型隐式转换为最大类型，但不能解决从Matrix<float> 到Matrix<double> 的转换，它只能解决到Matrix<Complex> 的转换。

public abstract partial class Matrix<T>
{
    /// <summary>
    /// Implicitly converts a matrix to double precision complex numbers.
    /// </summary>
    public static implicit operator Matrix<Complex64>(Matrix<T> matrix)
    {
        return matrix.Map(x =>
        {
            if (x is Numerics.Complex32)
            {
                var xc32 = (Numerics.Complex32)(object)x;
                return new Complex64(xc32.Real, xc32.Imaginary);
            }
            return new Complex64(Convert.ToDouble(x), 0);
        }, Zeros.AllowSkip);
    }
}

如果有人对这个问题的背景感兴趣，你可以看看https://github.com/mathnet/mathnet-numerics/issues/304

解决此问题的另一种选择可能是使用“扩展运算符”（类似于扩展方法）之类的东西，但这些在 C# 中不存在。

Answer 1

我知道创建通用向量或矩阵类并让它进行代数（加法、减法、乘法）的唯一方法是发出调用运算符的MSIL 代码（例如operator +）。然后它可以与定义了static MyType operator + (MyType a, MyTYpe b) 的任何 类型以及内置类型一起使用。

有关更多详细信息，请参阅this answer of mine 类似问题。

使用Operation<T> 中的静态方法，您可以获得以下示例代码

public class Matrix<T>
{
    T[,] elements;

    static readonly Func<T,T> add = Operation<T>.Add;

    public static Matrix<T> operator + (Matrix<T> A, Matrix<T> B)
    {
       Matrix<T> result = new Matrix<T>(rows,cols);
       for(int i=0; i<rows; i++)
       {
         for(int j=0; j<cols; j++)
         {
            result[i,j] = add(A[i,j], B[i,j]);
         }
       }
       return result;
    }    
    // rest of algebra
}

因此，如果您确实定义了 Complex64 类并定义了 operator +，则可以声明 Matrix<Complex64> 并直接像 var C = A+2*B 那样做代数。运行时将为内置类型或自定义类型调用适当的运算符。速度影响很小，因为在第一次使用时，每种类型只进行一次一次的反射来找到调用的适当方法。

Answer 2

首先，我不确定将泛型与数字基元类型一起使用是否是一条好路。这是该语言的一个非常严重的缺陷，并且似乎没有任何计划在短时间内解决它。阅读this SO answer了解更多信息。

1. 没有数字限制，你能做的最好的就是struct，这很糟糕。

2. 对于任何算术支持，如果你正在实现一个矩阵，这是必须的，你需要用Add、Multiply等定义一个IArithmetic接口，你将在整个过程中装箱和拆箱可能会对性能产生重大影响的地方。

   您的代码远比这差；因为您似乎缺少T 的通用接口，您需要转换为对象才能使通用转换成功。

   另外如果你没有类似if (typeof(T) == typeof(Complex)) ...的通用接口代码开始出现，这是使用泛型时的一个大红旗；泛型类/方法应该适用于 无限 种类型，而不仅仅是几个预设类型，这就是 generic 的含义。

我认为你应该退后一步，重新考虑你的方法。当语言类型系统似乎在与您作斗争并且没有任何帮助时，这肯定表明您做错了。

为什么不简单地实现一个最大类型的非泛型矩阵呢？复数矩阵。拥有浮点数或双精度矩阵有什么好处？它不可能是性能或内存效率，因为任何非通用解决方案都会比您当前的方法更好，所有的装箱和拆箱都在进行。

更新：在查看了您所基于的库后，我不确定您为什么不首先使用 Matrix<T>：作为基本类型。

public class DoubleMatrix : Matrix<double>
{
    //now this is legal
    public static implicit operator DoubleMatrix(FloatMatrix matrix)
        => matrix.ToDouble();
}

FloatMatrix 显然是FloatMatrix: Matrix<Float>。