c - 求解公式中每个变量的算法

Closed. This question is off-topic。它当前不接受答案。












                            想改善这个问题吗？ Update the question，所以它是on-topic，用于堆栈溢出。

                        4年前关闭。



我正在开发一个iOS应用程序来解决物理问题，首先要让它使用以下公式来解决基本的运动学问题（我已经用C而不是Swift对其进行了编码，因为我对C的了解更好）：

时间：t
距离变化：d
平均速度：VA
初始速度：vi
最终速度：vf
加速度：

va = (vf + vi) / 2   
vf^2 = vi^2 + 2ad   
d = vit + 1/2at^2   
a = (vf - vi) / t   
va = d / t

输入给定变量后，我将使用以下代码来解决尽可能多的变量。传入的数组包含我上面显示的相同顺序的变量。布尔值（例如tChanged或vaChanged）被初始化为false，然后如果用户为其输入值或我的算法为其分配了值，则将其更改为true：

void calculateUnknowns1(double values[6])
    {
    int i = 0;

    do{
        i = 0;

    /*-------------------------------------------DERIVED FROM: va = (vf+vi)/2----------------------------------------------------*/

            if((vfChanged)&&(viChanged)){
                if(!vaChanged){
                    values[2] = (values[4]+values[3]) / 2;
                    i++;
                    vaChanged = true;
                }
            }
            if((vaChanged)&&(viChanged)){
                if(!vfChanged){
                    values[4] = 2*values[2] - values[3];
                    i++;
                    vfChanged = true;
                }
            }
            if((vaChanged)&&(vfChanged)){
                if(!viChanged){
                    values[3] = 2*values[2] - values[4];
                    i++;
                    viChanged = true;
                }
            }


/*----------------------------------------DERIVED FROM: vf*vf = vi*vi + 2*a*d------------------------------------------------*/

            if((viChanged)&&(aChanged)&&(dChanged)){
                if(!vfChanged){
                    values[4] = sqrtl(values[3]*values[3] + 2*values[5]*values[1]);
                    i++;
                    vfChanged = true;
                }
            }
            if((vfChanged)&&(aChanged)&&(dChanged)){
                if(!viChanged){
                    values[3] = sqrtl(values[4]*values[4] - 2*values[5]*values[1]);
                    i++;
                    viChanged = true;
                }
            }
            if((viChanged)&&(vfChanged)&&(aChanged)){
                if(!dChanged){
                    values[1] = (values[4]*values[4] - values[3]*values[3]) / (2*values[5]);
                    i++;
                    dChanged = true;
                }
            }
            if((viChanged)&&(vfChanged)&&(dChanged)){
                if(!aChanged){
                    values[5] = (values[4]*values[4] - values[3]*values[3]) / (2*values[1]);
                    i++;
                    aChanged = true;
                }
            }


/*-------------------------------------------DERIVED FROM: d = vit+1/2at*t---------------------------------------------------*/

            /*if((tChanged)&&(dChanged)&&(values[3]==0)){
                if(!aChanged){
                    values[5] = values[1]/(0.5*values[0]*values[0]);
                    i++;
                    aChanged = true;                                      EXTRANNEOUS
                }
            }
            if((tChanged)&&(dChanged)&&(values[5]==0)){
                if(!viChanged){
                    values[3] = values[1]/values[0];
                    i++;
                    viChanged = true;
                }
            }*/
            if((tChanged)&&(viChanged)&&(aChanged)){
                if(!dChanged){
                    values[1] = values[3]*values[0] + 0.5*values[5]*values[0]*values[0];
                    i++;
                    dChanged = true;
                }
            }
            if((tChanged)&&(dChanged)&&(aChanged)){
                if(!viChanged){
                    values[3] = (values[1] - 0.5*values[5]*values[0]*values[0]) / values[0];
                    i++;
                    viChanged = true;
                }
            }
            if((tChanged)&&(dChanged)&&(viChanged)){
                if(!aChanged){
                    values[5] = (values[1] - values[3]*values[0]) / (0.5*values[0]*values[0]);
                    i++;
                    aChanged = true;
                }
            }
            if((dChanged)&&(viChanged)&&(aChanged)){
                if(!tChanged){
                    values[0] = (-(values[3]) + sqrtl(values[3]*values[3] - 4*0.5*values[5]*(-values[1]))) / values[5];
                    if(!((values[1] == values[3]*values[0] + 0.5*values[5]*values[0]*values[0])&&(values[0]>=0))){
                        values[0] = (-(values[3]) - sqrtl(values[3]*values[3] - 4*0.5*values[5]*(-values[1]))) / values[5];
                    }
                    i++;
                    tChanged = true;
                }
            }


/*-------------------------------------------DERIVED FROM: a=(vf-vi)/t-------------------------------------------------------*/

            if((vfChanged)&&(viChanged)&&(tChanged)){
                if(!aChanged){
                    values[5] = (values[4]-values[3]) / values[0];
                    i++;
                    aChanged = true;
                }
            }
            if((vfChanged)&&(viChanged)&&(aChanged)){
                if(!tChanged){
                    values[0] = (values[4]-values[3]) / values[5];
                    i++;
                    tChanged = true;
                }
            }
            if((vfChanged)&&(aChanged)&&(tChanged)){
                if(!viChanged){
                    values[3] = values[4] - values[5]*values[0];
                    i++;
                    viChanged = true;
                }
            }
            if((viChanged)&&(aChanged)&&(tChanged)){
                if(!vfChanged){
                    values[4] = values[3] + values[5]*values[0];
                    i++;
                    vfChanged = true;
                }
            }


/*-------------------------------------------DERIVED FROM: va = d/t---------------------------------------------------------*/

            if((dChanged)&&(tChanged)){
                if(!vaChanged){
                    values[2] = values[1] / values[0];
                    i++;
                    vaChanged = true;
                }
            }
            if((dChanged)&&(vaChanged)){
                if(!tChanged){
                    values[0] = values[1] / values[2];
                    i++;
                    tChanged = true;
                }
            }
            if((vaChanged)&&(tChanged)){
                if(!dChanged){
                    values[1] = values[2]*values[0];
                    i++;
                    dChanged = true;
                }
            }


/*-------------------------------------------SOLVING FOR t WITH vi--------------------------------------------------------*/

            if((aChanged)&&(vfChanged)&&(dChanged)){
                if(!tChanged){
                    values[0] = (sqrtl(values[4]*values[4] - 2*values[5]*values[1]) + values[4]) / -(values[5]);
                    if(values[0]<=0){
                        values[0] = (sqrtl(values[4]*values[4] -     2*values[5]*values[1]) - values[4]) / -(values[5]);
                    }
                    i++;
                    tChanged = true;
                }
            }


    }while(i>0);
}

这个算法确实可以正常工作，但是对我来说似乎效率很低。在我进一步研究《力量与动量》之前，谁能建议一个替代方案？

最佳答案

本质上，您要做的是在任何变量已更改时迭代循环。对于每个变量，请检查其依赖的变量是否已更改，如果是，请重新计算该变量。在下面的if语句中，可以测试此变量现在已更改的事实，并且可以重新计算依赖于此变量的变量，等等，但这不是必需的。

通过使用数组很难读取该方法。使用具有专有名称的变量将更易读。

我没有其他主要建议。该方法很好。由于它仅使用基本数学，因此也不是昂贵/低效的。在数学界可能有一种更好的算法可以解决您的问题，但我不知道。

附言：确实，您的问题更适合在Code Review进行审核。

关于c - 求解公式中每个变量的算法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34242824/

上一篇：c - 运行 md5sum shell 命令并将输出保存在 C 中

下一篇：c - 有 %50 的机会猜错数字

相关文章：

python - python中圆圈内均匀间隔点的生成器

c - "%p"printf参数

arrays - 区分排序算法

javascript - 通过距离和摩擦力计算速度

c++ - 给定 1000 个长度为 100 的字符串，找出最小的唯一子字符串的长度

python - 插入数据以协调链接不同端的读数的算法？

c++ - OpenMP 的缩放问题

c - amd64编译器编译的程序可执行并且可以运行，在x86 cpu上正常工作吗？

c - 为什么函数式编程优于 C

c - 如何在 glade 中设置按钮的 Action ？