-1.#在C中使用距离库塔法的IND0误差

我试图用四点范围的库塔法解一个耦合的一阶微分方程。当输出

m

的值时，我得到

-1.#IND0

错误。我知道这可能是NaN，但对我来说没有意义，因为

m

的值应该增加，并且我在有效值之间得到

-1IND0

。以下是我的输出示例：

3110047776596300800000000000000000000.00000 35953700.00
-1.#IND0 35984000.00
-1.#IND0 36013700.00
3721056749337648900000000000000000000.00000 36042800.00
-1.#IND0 36071400.00
4132402773947312100000000000000000000.00000 36099500.00
-1.#IND0 36127200.00
4546861919240663800000000000000000000.00000 36154400.00

这是我的代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define pi 3.141592654


double f(double p, double m, double r)
{
    return -0.000000000000000012812899255404507 * m * pow(p, 1.0/3) / (r * r);
}

double g(double p, double r)
{
    return 4 * pi * r * r * p;
}

int main()
{
    double  p_c,        //central density
            p,              //densities
            m,              //masses
            f_val[4],       //arrayed f
            g_val[4],       //arrayed g
            r = 1e-15,      //radius
        dr = 100,       //radius increment
        p_0 = 0.001;    //effective zero density
double p_min = 1e6;
double p_max = 1e14;
int i;                  //Loop counter

FILE *data=fopen("dwarf.txt", "w");//Output file

for(p_c = p_min; p_c <= p_max; p_c += (p_max - p_min) / 100)
{
    p = p_c;
    m = (4.0/3) * pi * r * r * r * p_c;

    while(p > p_0)
    {
        //fprintf(data, "%.5lf %.2lf %.2lf\n", p, m, r);

        f_val[0] = f(p, m, r) * dr;
        g_val[0] = g(p, r) * dr;

        f_val[1] = f(p + f_val[0]/2, m + g_val[0]/2, r + dr/2) * dr;
        g_val[1] = g(p + f_val[0]/2, r + dr/2) * dr;

        f_val[2] = f(p + f_val[1]/2, m + g_val[1]/2, r + dr/2) * dr;
        g_val[2] = g(p + f_val[1]/2, r + dr/2) * dr;

        f_val[3] = f(p + f_val[2], m + g_val[2], r + dr) * dr;
        g_val[3] = g(p + f_val[2], r + dr) * dr;

        m += (g_val[0] + 2 * g_val[1] + 2 * g_val[2] + g_val[3]) / 6; 
        p += (f_val[0] + 2 * f_val[1] + 2 * f_val[2] + f_val[3]) / 6;

        r += dr;
    }

    fprintf(data, "%.5lf %.2lf\n", m, r);
    printf("%.5lf %.2lf\n", m, r);
}
exit;
}

#包括
#包括
#包括
#定义pi 3.141592654
双f（双p，双m，双r）
{
返回-0.000000000000000012812899255404507*m*pow（p，1.0/3）/（r*r）；
}
双g（双p，双r）
{
返回4*pi*r*r*p；
}
int main（）
{
双p_c，//中心密度
p、 //密度
m、 //质量
f_val[4]，//阵列f
g_val[4]，//阵列g
r=1e-15，//半径
dr=100，//半径增量
p_0=0.001；//有效零密度
双p_最小值=1e6；
双p_最大值=1e14；
int i；//循环计数器
FILE*data=fopen（“dwarf.txt”，“w”）；//输出文件
对于（p_c=p_min；p_c p_0）
{
//fprintf（数据，“%.5lf%.2lf%.2lf\n”，p，m，r）；
f_val[0]=f（p，m，r）*dr；
g_val[0]=g（p，r）*dr；
f_val[1]=f（p+f_val[0]/2，m+g_val[0]/2，r+dr/2）*dr；
g_val[1]=g（p+f_val[0]/2，r+dr/2）*dr；
f_val[2]=f（p+f_val[1]/2，m+g_val[1]/2，r+dr/2）*dr；
g_val[2]=g（p+f_val[1]/2，r+dr/2）*dr；
f_val[3]=f（p+f_val[2]，m+g_val[2]，r+dr）*dr；
g_val[3]=g（p+f_val[2]，r+dr）*dr；
m+=（g_val[0]+2*g_val[1]+2*g_val[2]+g_val[3]）/6；
p+=（f_val[0]+2*f_val[1]+2*f_val[2]+f_val[3]）/6；
r+=dr；
}
fprintf（数据“%.5lf%.2lf\n”，m，r）；
printf（“%.5lf%.2lf\n”，m，r）；
}
出口
}

我得了楠氏症。在cygwin上编译并运行：

3110047776596300799965078807132504064.00000 35953700.00
nan 35984000.00
nan 36013700.00
3721056749337648263817730951571570688.00000 36042800.00
nan 36071400.00
4132402773947312079489066295688691712.00000 36099500.00
nan 36127200.00
4546861919240663813565041399809703936.00000 36154400.00

---

我已经有一段时间没有学习龙格库塔了。。。看看你的代码，我认为r是自变量，dr是步长，m是你试图求解的因变量。我不知道p是什么。你能告诉我们更多的细节吗？如果我能看到你试图求解的实际方程，那就更有意义了。

-0.0000000000000000 12812899255404507

这总共是16个有效数字。标准（

double

）文本是否支持该精度的每一位并不明显。在

长双精度

比

双精度

更长的平台上，使用

-0.0000000000000000 12812899255404507L

将获得更多。（你可能想要，也可能不想要，这取决于…）嗯…你只把π定义为10个有效数字，所以f中的额外值是零。考虑<代码> const双π＝4 *AATN（1）< /代码>。您可以尝试使用建议的编辑使用编译器编译代码吗？我似乎无法让它工作。对不起，我是c语言的初学者。你们有相同的错误吗？顺便说一句——我的笔记不会影响你们的问题，我只是记下了一些你们可能想知道的事情。但你需要习惯于调试……如果你坚持编程，从现在开始你将做很多。德里克，在StackOverflow上，“答案”应该是真正回答这个问题的东西。寻求更多信息的答复属于对原始问题的评论。欢迎来到StackOverflow。对不起，我在任何地方都看不到关于这个问题的评论选项，尽管我显然可以对我自己的答案发表评论……不幸的是，在你对别人的问题或答案发表评论之前，你需要一定的声誉（50），IIRC。这样做很好。