面向对象方法的类型安全

Question

我正在考虑如何使用面向对象的方法正确解决这个问题。语言并不重要——我其实很想写代码，但我更关心的是一般原则。

我想实现一个field：一个“数字”的集合，+、-、* 和 / 操作在这些“数字”上进行。此外，我希望能够实现更高的操作，例如 ^ 和循环查找，其中 (1) 不需要为给定字段定义，但 (2) 可以在需要时被覆盖，例如出于效率原因。

问题来了。声明还不够好

FieldElement power (FieldElement base, FieldElement exponent)

因为我想要类型安全：不可能将有限域的成员添加到整数。

也许我真正在寻找的是元对象，或超级接口，或将不同类联系在一起的东西（一个用于整数，一个用于 7-adics，一个用于有限域 F_4 等） .或者也许有更好的东西。

注意欢迎（甚至鼓励）在答案中使用代码，如果它有启发性的话，但声明可能就足够了：大概这里的每个人都可以为至少几个领域写出明显的方法。

---

我会提到其他对我很重要但（显然）与主要 OO 问题无关的条件：我不希望字段元素携带它们的类型信息，而且我希望它们是轻量级的（因为我可能需要处理大量的字段元素）。这些需求可能无法实现——尽管坦率地说，我更可能在这里放弃面向对象而不是效率。但无论如何，我们都将不胜感激，因为我有兴趣了解这些问题，即使除了手头的特定问题。

Answer 1

这称为二元方法问题。快速谷歌搜索将显示一些（大量）信息。尤其是Luca Cardelli等人的《论二元方法》一文，对这个问题进行了彻底的处理。

您可能想学习一些 Haskell 来了解实用的编程语言如何处理这个问题。

编辑洛卢卡 → 卢卡。该死的小手机屏幕和更小的键盘；）

Answer 2

我之前尝试过用C#来表达这些概念，但是遇到了语言障碍：语言不够丰富，或者不够具体。例如，如果我这样定义一个字段的元素：

public abstract class FieldElement 
{
    public abstract FieldElement Add(FieldElement another);
    public abstract FieldElement SumInvert();
    public abstract FieldElement MultiplicationInvert();
    public abstract FieldElement MultiplyBy(FieldElement another);
    public abstract FieldElement One; //Multiplication neutral element
    public abstract FieldElement Zero; //Addition neutral element

    public FieldElement Subtract(FieldElement another)
    {
        return this.Add(another.SumInvert());
    }

    public FieldElement Divide(FieldElement another)
    {
        return this.MultiplyBy(another.MultiplicationInvert());
    }
    public virtual FieldElement Power(uint b)
    {
        if (b == 0)
            return this.One;
        else
        {
            FieldElement result = this;
            for (int i = 0; i < b - 1; i++)
                result = result.MultiplyBy(result);
            return result;
        }
    }
}

然后我这样定义实数：

public class RealNumber : FieldElement
{
    public double Value { get; set; }

    public RealNumber(double value)
    {
        this.Value = value;
    }
    public override FieldElement Power(uint b)
    {
        return new RealNumber(Math.Pow(Value, b));
    }
    public override FieldElement Add(FieldElement another)
    {
        if (another.GetType() != typeof(RealNumber)) //Ugly typecast to enforce type-safety
            throw new ArgumentException("RealNumber expected in Add method");

        return new RealNumber(Value + (another as RealNumber).Value);
    }
}

然后我可以定义对字段元素的通用操作（通过使用泛型）：

public class FieldOperations<T> where T: FieldElement 
{
    public T Add(T a, T b)        
    {
        return a.Add(b) as T;
    }
    public T Multiply(T a, T b)
    {
        return a.MultiplyBy(b) as T;
    }
    public T Subtract(T a, T b)
    {
        return a.Subtract(b) as T;
    }
    public T Divide(T a, T b)
    {
        return a.Divide(b) as T;
    }
    public T Power(T a, uint b)
    {
        return a.Power(b) as T;
    }   
}

我会在代码中这样使用它：

public class TestFieldOperations
{
    public static void TestAddRealNumbers()
    {
        FieldOperations<RealNumber> operations = new FieldOperations<RealNumber>();
        RealNumber a = new RealNumber(0.5);
        RealNumber b = new RealNumber(0.7);
        RealNumber c = operations.Add(a, b);
        RealNumber d = operations.Power(c, 3);
    }
}

同样，我可以在向量上使用 FieldOperations，在 InvMatrix 上使用 FieldOperations...

能够以类型安全和面向对象的方式抽象字段操作的概念可能非常强大：能够在同一抽象级别处理数字、向量和（可逆）矩阵算术。