C 计算公式中每个变量的算法

我正在制作一个iOS应用程序来解决物理问题，我从让它用以下公式解决基本运动学问题开始（我用C而不是Swift来编码，因为我更了解C）：

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

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);
}

void calculateUnknowns1（双值[6]）
{
int i=0；
做{
i=0；
/*-------------------------------------------派生自：va=（vf+vi）/2----------------------------------------------------*/
如果（（变更）和（变更））{
如果（！vachange）{
数值[2]=（数值[4]+数值[3]）/2；
i++；
vaChanged=真；
}
}
如果（（变更）和&（变更））{
如果（！vfChanged）{
值[4]=2*值[2]-值[3]；
i++；
vfChanged=true；
}
}
如果（（变更）和（变更））{
如果（！viChanged）{
值[3]=2*值[2]-值[4]；
i++；
viChanged=true；
}
}
/*----------------------------------------派生自：vf*vf=vi*vi+2*a*d------------------------------------------------*/
如果（（变更）和&（变更）和&（变更））{
如果（！vfChanged）{
值[4]=sqrtl（值[3]*值[3]+2*值[5]*值[1]）；
i++；
vfChanged=true；
}
}
如果（（vfChanged）&（aChanged）&（dChanged））{
如果（！viChanged）{
值[3]=sqrtl（值[4]*值[4]-2*值[5]*值[1]）；
i++；
viChanged=true；
}
}
如果（（变更）和（变更）和（变更））{
如果（！dChanged）{
值[1]=（值[4]*值[4]-值[3]*值[3]）/（2*值[5]）；
i++；
dChanged=true；
}
}
如果（（变更的）和（（变更的）和（（变更的））{
如果（！a更改）{
值[5]=（值[4]*值[4]-值[3]*值[3]）/（2*值[1]）；
i++；
a改变=真；
}
}
/*-------------------------------------------派生自：d=vit+1/2at*t---------------------------------------------------*/
/*如果（（tChanged）&（dChanged）&&（值[3]==0））{
如果（！a更改）{
值[5]=值[1]/（0.5*值[0]*值[0]）；
i++；
无变化的=真的；多余的
}
}
如果（（tChanged）&（dChanged）&&（值[5]==0））{
如果（！viChanged）{
值[3]=值[1]/值[0]；
i++；
viChanged=true；
}
}*/
如果（（t更改）和&（b更改）和&（a更改））{
如果（！dChanged）{
数值[1]=数值[3]*数值[0]+0.5*数值[5]*数值[0]*数值[0]；
i++；
dChanged=true；
}
}
如果（（tChanged）&（dChanged）&（aChanged））{
如果（！viChanged）{
数值[3]=（数值[1]-0.5*数值[5]*数值[0]*数值[0]）/数值[0]；
i++；
viChanged=true；
}
}
如果（（t更改）和（d更改）和（b更改））{
如果（！a更改）{
值[5]=（值[1]-值[3]*值[0]）/（0.5*值[0]*值[0]）；
i++；
a改变=真；
}
}
如果（（数据更改）和（（替代更改）和（（更改））{
如果（！t更改）{
数值[0]=（（数值[3]）+sqrtl（数值[3]*数值[3]-4*0.5*数值[5]*（-values[1]））/values[5]；
如果（！（（值[1]==值[3]*值[0]+0.5*值[5]*值[0]*值[0]）&&（值[0]>=0）））{
数值[0]=（（数值[3]）-sqrtl（数值[3]*数值[3]-4*0.5*数值[5]*（-values[1]））/values[5]；
}
i++；
tChanged=true；
}
}
/*-------------------------------------------派生自：a=（vf vi）/t-------------------------------------------------------*/
如果（（vfChanged）&（viChanged）&（tChanged））{
如果（！a更改）{
值[5]=（值[4]-值[3]）/值[0]；
i++；
a改变=真；
}
}
如果（（vfChanged）和（vfChanged）和（aChanged））{
如果（！t更改）{
值[0]=（值[4]-值[3]）/值[5]；
i++；
tChanged=true；
}
}
如果（（vfChanged）&（aChanged）&（tChanged））{
如果（！viChanged）{
值[3]=值[4]-值[5]*值[0]；
i++；
viChanged=true；
}
}
如果（（变更）和&（变更）和&（变更））{
如果（！vfChanged）{
值[4]=值[3]+值[5]*值[0]；
i++；