数学公式设计模式

Question

例如，我需要一个计算牛顿定律F=MA的函数，所以我用C#编写了以下代码

private double calcForce(double mass, double acceleration){
        return mass * acceleration;
}

private double calcMass(double force, double acceleration){
        return force / acceleration;
}

private double calcAcceleration(double force, double mass){
        return force / mass;
}

如果数学函数的变量很少(F=MA只有3个)，而函数更复杂(我真正的任务是处理热传递/流体力学函数，它很容易包含10个以上的变量！)方法的数量将等于该数学函数中的变量数量。

那么，有没有好的设计模式来解决这个问题呢？我应该使用这样的东西吗？

private double NewtonsLaw(double? force,double? mass,double? acceleration)
{
        if(!force.HasValue)
            return mass*acceleration;
        //else if
}

还有一件事，我需要用objective-c和java而不是C#编写代码。

Answer 1

一种方法是使用您的质量/加速度/力值创建一个对象，然后(取决于设置的值)计算它们或直接返回它们

public class NewtonLaw {
    private Double mass;
    private Double acceleration;
    private Double force;

    public NewtonLaw(Double mass, Double acceleration, Double force) {
        this.mass = mass;
        this.acceleration = acceleration;
        this.force = force;
    }

    public Double calcMass() {
        if (mass != null) {
            return mass;
        } else if (acceleration == null) {
            throw new IllegalStateException("Acceleration is not set");
        } else if (acceleration == 0) {
            throw new IllegalStateException("Acceleration is zero, cannot calculate the mass");
        } else if (force == null) {
            throw new IllegalStateException("Force is not set");
        } else {
            return force / acceleration;
        }
    }

    public Double calcAcceleration() {
        if (acceleration != null) {
            return acceleration;
        } else ...
    }

    public Double calcForce() {
        if (force != null) {
            return force;
        } else ...
    }
}

诚然，对于一些计算来说，这是大量的代码，但至少逻辑完全封装在对象中

Answer 2

我认为对于每种可能的组合都有一个单独的方法会更好，而不是让用户传递一个值设置为null的可空类型。

如果您提供了一个接受所有值的私有构造函数和一组公共静态工厂方法，每个方法都接受除一个值之外的所有值，这将使代码在调用点变得更加清晰，这也意味着您不需要检查除一个值之外的所有值是否是非空的。

类似这样的东西(用C#编写，但其概念很容易转换为Java或Objective C)：

public class Newton
{
    readonly double _force;
    readonly double _mass;
    readonly double _accel;

    public double Force
    {
        get { return _force; }
    }

    public double Mass
    {
        get { return _mass; }
    }

    public double Accel
    {
        get { return _accel; }
    }

    public static Newton FromForceAndMass(double force, double mass)
    {
        return new Newton(force, mass, calcAccel(force, mass));
    }

    public static Newton FromForceAndAccel(double force, double accel)
    {
        return new Newton(force, calcMass(force, accel), accel);
    }

    public static Newton FromMassAndAccel(double mass, double accel)
    {
        return new Newton(calcForce(mass, accel), mass, accel);
    }

    private static double calcAccel(double force, double mass)
    {
         return force / mass;
    }

    private static double calcForce(double mass, double acceleration)
    {
        return mass * acceleration;
    }

    private static double calcMass(double force, double acceleration)
    {
        return force / acceleration;
    }

    private Newton(double force, double mass, double accel)
    {
        _force = force;
        _mass  = mass;
        _accel = accel;
    }
}

(不会检查这些值是否被零除-您必须为此添加错误检查。)

那么在你调用它的地方，发生的事情就更明显了：

var newton = Newton.FromForceAndAccel(1.234, 6423.2);

这对独立方法的数量没有帮助，但它有一个很好的使用模式。

Answer 3

无论您将使用哪种模式，都必须对新值的计算进行编码。这意味着你的热传递/流体力学问题至少有10个公式。

使用可选参数将所有这些都放在同一个方法中不是一个好主意，因为这会使您的代码更加复杂(因此更多的bug，更难维护，等等)。而且，你可能在你的论点的顺序上是错误的，然后计算出与你所想的不同的东西(你想要计算质量，但你正在计算加速度)。

最好将这10个公式封装在单独的方法中。它将更容易实现任何错误检查/处理，并且更容易调试、测试和维护。

现在，您可以将这10个方法封装在一个对象中，以提供一个方便您自己使用的接口。之前的评论包含了很好的想法。选择一件适合你的。