在 C 中使用泛型创建数学库#

首先，你的类应该将泛型参数限制为基元（ public class Fraction where T ： struct， new（） ）。

其次，您可能需要创建隐式强制转换重载，以便可以处理从一种类型到另一种类型的强制转换，而不会让编译器哭泣。

第三，您还可以重载四个基本运算符，以使界面在组合不同类型的分数时更加灵活。

最后，您必须考虑如何处理算术上溢和下溢。一个好的库将非常明确地处理溢出;否则，您不能信任不同分数类型的运算结果。

我相信这回答了你的问题：

http://www.codeproject.com/KB/cs/genericnumerics.aspx

这是一种相对轻松的抽象运算符的方法。

    abstract class MathProvider<T>
    {
        public abstract T Divide(T a, T b);
        public abstract T Multiply(T a, T b);
        public abstract T Add(T a, T b);
        public abstract T Negate(T a);
        public virtual T Subtract(T a, T b)
        {
            return Add(a, Negate(b));
        }
    }

    class DoubleMathProvider : MathProvider<double>
    {
        public override double Divide(double a, double b)
        {
            return a / b;
        }

        public override double Multiply(double a, double b)
        {
            return a * b;
        }

        public override double Add(double a, double b)
        {
            return a + b;
        }

        public override double Negate(double a)
        {
            return -a;
        }
    }

    class IntMathProvider : MathProvider<int>
    {
        public override int Divide(int a, int b)
        {
            return a / b;
        }

        public override int Multiply(int a, int b)
        {
            return a * b;
        }

        public override int Add(int a, int b)
        {
            return a + b;
        }

        public override int Negate(int a)
        {
            return -a;
        }
    }

    class Fraction<T>
    {
        static MathProvider<T> _math;
        // Notice this is a type constructor.  It gets run the first time a
        // variable of a specific type is declared for use.
        // Having _math static reduces overhead.
        static Fraction()
        {
            // This part of the code might be cleaner by once
            // using reflection and finding all the implementors of
            // MathProvider and assigning the instance by the one that
            // matches T.
            if (typeof(T) == typeof(double))
                _math = new DoubleMathProvider() as MathProvider<T>;
            else if (typeof(T) == typeof(int))
                _math = new IntMathProvider() as MathProvider<T>;
            // ... assign other options here.

            if (_math == null)
                throw new InvalidOperationException(
                    "Type " + typeof(T).ToString() + " is not supported by Fraction.");
        }

        // Immutable impementations are better.
        public T Numerator { get; private set; }
        public T Denominator { get; private set; }

        public Fraction(T numerator, T denominator)
        {
            // We would want this to be reduced to simpilest terms.
            // For that we would need GCD, abs, and remainder operations
            // defined for each math provider.
            Numerator = numerator;
            Denominator = denominator;
        }

        public static Fraction<T> operator +(Fraction<T> a, Fraction<T> b)
        {
            return new Fraction<T>(
                _math.Add(
                  _math.Multiply(a.Numerator, b.Denominator),
                  _math.Multiply(b.Numerator, a.Denominator)),
                _math.Multiply(a.Denominator, b.Denominator));
        }

        public static Fraction<T> operator -(Fraction<T> a, Fraction<T> b)
        {
            return new Fraction<T>(
                _math.Subtract(
                  _math.Multiply(a.Numerator, b.Denominator),
                  _math.Multiply(b.Numerator, a.Denominator)),
                _math.Multiply(a.Denominator, b.Denominator));
        }

        public static Fraction<T> operator /(Fraction<T> a, Fraction<T> b)
        {
            return new Fraction<T>(
                _math.Multiply(a.Numerator, b.Denominator),
                _math.Multiply(a.Denominator, b.Numerator));
        }

        // ... other operators would follow.
    }

如果无法实现所使用的类型，则会在运行时而不是在编译时失败（这很糟糕）。实现的定义总是相同的（也很糟糕）。我建议您避免在 C# 中执行此操作，而使用 F# 或其他更适合此抽象级别的语言。MathProvider<T>

编辑：修复了 的加法和减法的定义。 另一个有趣且简单的事情是实现一个在抽象语法树上运行的 MathProvider。这个想法立即指向了自动微分之类的事情：http://conal.net/papers/beautiful-differentiation/Fraction<T>

这是泛型类型带来的一个微妙问题。假设一个算法涉及除法，比如用高斯消元法来求解方程组。如果你传入整数，你会得到一个错误的答案，因为你将进行整数除法。但是，如果你传入恰好有整数值的双参数，你会得到正确的答案。

平方根也会发生同样的事情，就像在 Cholesky 因式分解中一样。因式分解整数矩阵会出错，而对恰好具有整数值的双精度矩阵进行因式分解会很好。

此处的其他方法将起作用，但它们对原始运算符的性能影响很大。我想我会在这里发布这个，供需要最快而不是最漂亮方法的人使用。

如果你想在不付出性能损失的情况下进行通用数学运算，那么不幸的是，这是这样做的方法：

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static T IncrementToMax(T value)
{
    if (typeof(T) == typeof(char))
        return (char)(object)value! < char.MaxValue ? (T)(object)(char)((char)(object)value + 1) : value;
 
    if (typeof(T) == typeof(byte))
        return (byte)(object)value! < byte.MaxValue ? (T)(object)(byte)((byte)(object)value + 1) : value;

    // ...rest of the types
}

我知道，这看起来很可怕，但使用此方法将生成运行速度尽可能快的代码。JIT 将优化所有强制转换和条件分支。

您可以在此处阅读说明和其他一些重要细节：http://www.singulink.com/codeindex/post/generic-math-at-raw-operator-speed

.NET 7 引入了一项新功能 - 泛型数学（在此处和此处阅读更多内容），它基于添加静态抽象接口方法。此功能引入了许多接口，这些接口允许对数字类型和/或数学运算进行一般抽象：

class Fraction<T> :
    IAdditionOperators<Fraction<T>, Fraction<T>, Fraction<T>>,
    ISubtractionOperators<Fraction<T>, Fraction<T>, Fraction<T>>,
    IDivisionOperators<Fraction<T>, Fraction<T>, Fraction<T>>
    where T : INumber<T>
{
    public T Numerator { get; }
    public T Denominator { get; }

    public Fraction(T numerator, T denominator)
    {
        Numerator = numerator;
        Denominator = denominator;
    }

    public static Fraction<T> operator +(Fraction<T> left, Fraction<T> right) =>
        new(left.Numerator * right.Denominator + right.Numerator * left.Denominator,
            left.Denominator * right.Denominator);

    public static Fraction<T> operator -(Fraction<T> left, Fraction<T> right) =>
        new(left.Numerator * right.Denominator - right.Numerator * left.Denominator,
            left.Denominator * right.Denominator);

    public static Fraction<T> operator /(Fraction<T> left, Fraction<T> right) =>
        new(left.Numerator * right.Denominator, left.Denominator * right.Numerator);
}