设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › Python交流 › 关于C语言和python语言数学运算的问题
返回列表 发新帖
查看: 401|回复: 3

[已解决]关于C语言和python语言数学运算的问题

[复制链接]
xxfholic
发表于 2020-4-15 22:17:21 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
问题背景：本人初学python，最近在完成学校里老师留的大作业，将祖传的C语言代码改成Python语言代码，在改的过程中发现两组代码产生的数据不同，想向fishc大佬们求助。
代码如下：
  1. Python代码
  2. import numpy as np
  3. #from numba import jit

  5. rho = 2850
  6. E = 7.154*1e10
  7. X = np.array([
  8.     0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.10
  9. ])
  10. A = np.array([
  11.     1.7*1e-4, 1.46*1e-4, 1.26*1e-4, 1.09*1e-4, 0.96*1e-4, 0.86*1e-4, 0.77*1e-4, 0.73*1e-4, 0.7*1e-4, 0.68*1e-4, 0.68*1e-4
  12. ])
  13. I = np.array([
  14.     2.79*1e-10, 2.12*1e-10, 1.57*1e-10, 1.08*1e-10, 0.84*1e-10, 0.61*1e-10, 0.45*1e-10, 0.37*1e-10, 0.32*1e-10, 0.30*1e-10, 0.30*1e-10
  15. ])
  16. Y0js = np.array([
  17.     0, 0.1, 0.2, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0
  18. ])
  19. Y2js = np.array([
  20.     0, -0.1, -0.3, -0.5, -0.4, -0.2, -0.1, 0.5, 0.8, 1.0
  21. ])
  22. Y3js = np.array([
  23.     0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0
  24. ])

  26. Y0sj = np.zeros(10)
  27. Y0xxx = np.zeros(10)
  28. Y2 = np.zeros(10)
  29. Y2sj = np.zeros(10)
  30. Y3 = np.zeros(10)
  31. Y3sj = np.zeros(10)

  33. xz = 2.58

  35. # midpoint function
  36. def midpoint(x):
  37.     return (x[:-1]+x[1:])/2.0

  39. def _1st(Ab, Ib, Y0js, Y0sj, Y0xxx):
  40.     dev = 10

  42.     while dev >= 1e-6:
  43.         
  44.         _1st = np.zeros(10)
  45.         _2nd = np.zeros(10)
  46.         _3rd = np.zeros(10)
  47.         _4th = np.zeros(10)
  48.         
  49.         #cycle 1
  50.         a, b = 0 ,0
  51.         while a <= 9:
  52.             b = a
  53.             while b <= 8:
  54.                 _1st[a] +=  Ab[b+1] * Y0js[b+1] * 0.01
  55.                 b += 1
  56.             a += 1
  57.         
  58.         #cycle 2
  59.         a, b = 0 ,0
  60.         while a <= 9:
  61.             b = a
  62.             while b <= 8:
  63.                 _2nd[a] += _1st[b+1] * 0.01
  64.                 b += 1
  65.             a += 1
  66.       
  67.         #cycle 3
  68.         a, b = 0 ,0
  69.         while a <= 9:
  70.             b = 0
  71.             while a >= b:
  72.                 _3rd[a] += _2nd[b] * 0.01 * (1/Ib[b])
  73.                 b += 1
  74.             a += 1
  75.         
  76.         #cycle 4
  77.         a, b = 0 ,0
  78.         while a <= 9:
  79.             b = 0
  80.             while a >= b:
  81.                 _4th[a] += _3rd[b] * 0.01
  82.                 b += 1
  83.             a += 1

  85.         a = 0
  86.         while a <= 9:
  87.             Y0sj[a] = _4th[a] / _4th[9]
  88.             Y0xxx[a] = _4th[a]
  89.             a += 1
  90.         
  91.         dev = 0
  92.         a = 0
  93.         while a <= 9:
  94.             dev += abs(Y0js[a] - Y0sj[a])
  95.             a += 1
  96.         
  97.         a = 0
  98.         while a <= 9:
  99.             Y0js[a] = Y0sj[a]
  100.             a += 1
  101.    
  102.     return 5000 * _4th[9] **-0.5 / 2 / np.pi

  104. def _2nd(E, xz, rho, Ab, Ib, Y0xxx, Y2js, Y2, Y2sj):
  105.     a21 = 10

  107.     while abs(a21) >= 1e-8:
  108.         b11 = 0
  109.         c21 = 0
  110.         a21 = 0

  112.         i = 0
  113.         while i <= 9:
  114.             b11 += 2850 * Ab[i] * Y0xxx[i] **2 * 0.01
  115.             i += 1
  116.         
  117.         i = 0
  118.         while i <= 9:
  119.             c21 += 2850 * Ab[i] * Y0xxx[i] * Y2js[i] * 0.01
  120.             i += 1

  122.         a21 = c21 / b11

  124.         i = 0
  125.         while i <= 9:
  126.             Y2[i] = Y2js[i] - a21 * Y0xxx[i]
  127.             i += 1
  128.         
  129.         i = 0
  130.         while i <= 9:
  131.             Y2js[i] = Y2[i]
  132.             i += 1
  133.         
  134.     i = 0
  135.     while i <= 9:
  136.         Y2sj[i] = Y2[i] / Y2[9]
  137.         i += 1
  138.    
  139.     _1st = np.zeros(10)
  140.     _2nd = np.zeros(10)
  141.     _3rd = np.zeros(10)
  142.     _4th = np.zeros(10)

  144.     #cycle 1
  145.     a, b = 0 ,0
  146.     while a <= 9:
  147.         b = a
  148.         while b <= 7:
  149.             _1st[a] +=  Ab[b+2] * Y2sj[b+2] * 0.01
  150.             b += 1
  151.         a += 1
  152.    
  153.     #cycle 2
  154.     a, b = 0 ,0
  155.     while a <= 9:
  156.         b = a
  157.         while b <= 8:
  158.             _2nd[a] += _1st[b+1] * 0.01
  159.             b += 1
  160.         a += 1
  161.    
  162.     #cycle 3
  163.     a, b = 0 ,0
  164.     while a <= 9:
  165.         b = 0
  166.         while a >= b:
  167.             _3rd[a] += _2nd[b] * 0.01 * (1/Ib[b])
  168.             b += 1
  169.         a += 1
  170.    
  171.     #cycle 4
  172.     a, b = 0 ,0
  173.     while a <= 9:
  174.         b = 0
  175.         while a >= b:
  176.             _4th[a] += _3rd[b] * 0.01
  177.             b += 1
  178.         a += 1
  179.    
  180.     return (E / rho / _4th[9]) ** 0.5 / 2 / np.pi * xz

  182. def _3rd(E, rho, Ab, Ib, Y0xxx, Y2js, Y2, Y2sj, Y3, Y3js):
  183.     cvg = 10
  184.     b11, b12, b21, b22, c31, c32, a31, a32 = 0, 0, 0, 0, 0, 0, 0, 10
  185.     i = 10
  186.     while cvg >= 1e-4:
  187.         
  188.         #while i <= 9:
  189.         #    Y3js[i] = Y3[i]
  190.         #    i += 1

  192.         b12, b21, b22, c31, c32, a31 = 0, 0, 0, 0, 0, 0

  194.         i = 0
  195.         while i <= 9:
  196.             b11 += 2850 * Ab[i] * Y0xxx[i] **2 * 0.01
  197.             i += 1
  198.         
  199.         i = 0
  200.         while i <= 9:
  201.                 b12 += 2850 * Ab[i] * Y0xxx[i] * Y2[i] * 0.01
  202.                 i += 1

  204.         i = 0
  205.         while i <= 9:
  206.                 b21 += 2850 * Ab[i] * Y0xxx[i] * Y2[i] * 0.01
  207.                 i += 1

  209.         i = 0
  210.         while i <= 9:
  211.                 #b22 += 2850 * Ab[i] * Y2[b] * Y2[i] * 0.01
  212.             b22 += 2850 * Ab[i] * Y2[9] **2 * 0.01
  213.             i += 1

  215.         i = 0
  216.         while i <= 9:
  217.                 c31 += 2850 * Ab[i] * Y0xxx[i] * Y3js[i] * 0.01
  218.                 i += 1

  220.         i = 0
  221.         while i <= 9:
  222.                 c32 += 2850 * Ab[i] * Y2[i] * Y3js[i] * 0.01
  223.                 i += 1
  224.         
  225.         a31 = c31 / b11
  226.         a32 = c32 / b22
  227.         
  228.         i=0
  229.         while i <= 9:
  230.                 Y3[i] = Y3js[i] - a31 * Y0xxx[i] - a32 * Y2[i]
  231.                 i += 1
  232.         
  233.         cvg = abs(Y3js[0] - Y3[0])

  235.     _1st = np.zeros(10)
  236.     _2nd = np.zeros(10)
  237.     _3rd = np.zeros(10)
  238.     _4th = np.zeros(10)

  240.     #cycle 1
  241.     a, b = 0 ,0
  242.     while a <= 9:
  243.         b = a
  244.         while b <= 7:
  245.             _1st[a] +=  Ab[b+2] * Y3[b+2] * 0.01
  246.             b += 1
  247.         a += 1
  248.    
  249.     #cycle 2
  250.     a, b = 0 ,0
  251.     while a <= 9:
  252.         b = a
  253.         while b <= 8:
  254.             _2nd[a] += _1st[b+1] * 0.01
  255.             b += 1
  256.         a += 1
  257.    
  258.     #cycle 3
  259.     a, b = 0 ,0
  260.     while a <= 9:
  261.         b = 0
  262.         while a >= b:
  263.             _3rd[a] += _2nd[b] * 0.01 * (1/Ib[b])
  264.             b += 1
  265.         a += 1
  266.    
  267.     #cycle 4
  268.     a, b = 0 ,0
  269.     while a <= 9:
  270.         b = 0
  271.         while a >= b:
  272.             _4th[a] += _3rd[b] * 0.01
  273.             b += 1
  274.         a += 1
  275.    
  276.     return (E / rho / _4th[9]) ** 0.5 * cvg /np.pi

  278. if __name__ == "__main__":
  279.    
  280.     Ab = midpoint(A)
  281.     Ib = midpoint(I)

  283.     omega_1 = _1st(Ab, Ib, Y0js, Y0sj, Y0xxx)
  284.     omega_2 = _2nd(E, xz, rho, Ab, Ib, Y0xxx, Y2js, Y2, Y2sj)
  285.     omega_3 = _3rd(E, rho, Ab, Ib, Y0xxx, Y2js, Y2, Y2sj, Y3, Y3js)
  286.     print(omega_1)
  287.     print(omega_2)
  288.     print(omega_3)
复制代码

  1. C代码
  2. #include<stdio.h>
  3. #include<math.h>
  4. #include<stdlib.h>
  5. int main(void)
  6. {
  7.         float rou=2850;
  8.         float E=71540000000;
  9.         float X[11]={0.0,0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.10};
  10.         float A[11]={0.00017,0.000146,0.000126,0.000109,0.000096,0.000086,0.000077,0.000073,0.00007,0.000068,0.000068};
  11.         float I[11]={0.000000000279,0.000000000212,0.000000000157,0.000000000108,0.000000000084,0.000000000061,0.000000000045,0.000000000037,0.000000000032,0.000000000030,0.000000000030};
  12.         float Ab[10];
  13.         float Ib[10];
  14.        
  15.         int i=0;
  16.         while(i<=9)
  17.         {
  18.                   Ab[i]=((A[i+1]+A[i])/2);
  19.                   i=i+1;
  20.         }
  21.        
  22.         i=0;
  23.         while(i<=9)
  24.         {
  25.                   Ib[i]=((I[i+1]+I[i])/2);
  26.                   i=i+1;
  27.         }
  28.        
  29.         //第一个函数开始
  30.         float Y0js[10]={0,0.1,0.2,0.4,0.5,0.6,0.7,0.8,0.9,1};
  31.         float Y0sj[10]={0,0,0,0,0,0,0,0,0,0};
  32.         float Y0xxx[10]={0,0,0,0,0,0,0,0,0,0};
  33.         float one[10]={0,0,0,0,0,0,0,0,0,0};
  34.         float two[10]={0,0,0,0,0,0,0,0,0,0};
  35.         float three[10]={0,0,0,0,0,0,0,0,0,0};
  36.         float four[10]={0,0,0,0,0,0,0,0,0,0};
  37.         float wucha=10;
  38.         float xz=2.58;
  39.         int a=0;
  40.         int b=0;
  41.         int c=0;
  42.         int d=0;
  43.         int e=0;
  44.         int f=0;
  45.         int g=0;
  46.         int h=0;
  47.         int j=0;
  48.         int k=0;
  49.         int p=0;
  50.         int q=0;
  51.         while(wucha>=0.000001)                  //给定拟合精确度
  52.         {
  53.                    q=0;
  54.                    while(9>=q)
  55.             {
  56.                       one[q]=0;
  57.                       two[q]=0;
  58.                       three[q]=0;
  59.                       four[q]=0;
  60.                       q=q+1;
  61.                    }                             //这步是给数组清零，千万不能忘！
  62.                   
  63.                 a=0;
  64.                    b=9;
  65.             while(9>=a)
  66.                 {
  67.                       b=a;
  68.                       while(9>=b+1)
  69.                         {
  70.                           one[a]=one[a]+(Ab[b+1]*Y0js[b+1]*0.01);
  71.                           b=b+1;
  72.                       }   
  73.                 a=a+1;
  74.                 }                                         //第一重循环
  75.                
  76.                 c=0;
  77.             d=0;
  78.                    while(9>=c)
  79.             {
  80.                       d=c;
  81.                       while(9>=d+1)
  82.                 {
  83.                               two[c]=two[c]+(one[d+1]*0.01);
  84.                           d=d+1;
  85.                 }
  86.                 c=c+1;
  87.             }                                 //第二重循环

  89.                 e=0;
  90.             f=0;
  91.             while(9>=e)
  92.             {
  93.                         f=0;
  94.                       while(e>=f)
  95.                 {
  96.                           three[e]=three[e]+two[f]*0.01*(1/Ib[f]);
  97.                           f=f+1;
  98.                 }
  99.                 e=e+1;
  100.             }                                 //第三重循环  
  101.    
  102.                 g=0;
  103.             h=0;
  104.             while(9>=g)
  105.             {
  106.                       h=0;
  107.                       while(g>=h)
  108.                 {
  109.                                  four[g]=four[g]+three[h]*0.01;
  110.                                  h=h+1;
  111.                 }
  112.                 g=g+1;
  113.             }                                 //第四重循环
  114.    
  115.             k=0;
  116.             while(9>=k)
  117.             {
  118.                       Y0sj[k]=four[k]/four[9];
  119.                       Y0xxx[k]=four[k];
  120.                           k=k+1;
  121.               }                                //求出实际y0，以便和假设yo对比迭代
  122.    
  123.             wucha=0;
  124.            
  125.             j=0;
  126.             while(j<=9)
  127.               {
  128.                       wucha=wucha+fabs(Y0js[j]-Y0sj[j]);
  129.                       j=j+1;
  130.               }                                 //假设的y0与求出y0之间的误差  
  131.    
  132.             p=0;
  133.             while(9>=p)
  134.              {
  135.                       Y0js[p]=Y0sj[p];
  136.                 p=p+1;
  137.             }                                 //令实际值等于假设值，再次迭代运算
  138.    }
  139.         float omega=0;
  140.         omega=5000*sqrt((1/four[9]));
  141.         printf("一阶固有静频为：%.5fHZ\n",omega/(2*3.1415926));  
  142.        
  143.         //第二个函数开始
  144.         float Y2js[10]={0,-0.1,-0.3,-0.5,-0.4,-0.2,-0.1,0.5,0.8,1};
  145.         float Y2[10]={0,0,0,0,0,0,0,0,0,0};
  146.         float xiuzhen=4;
  147.         float Y2sj[10]={0,0,0,0,0,0,0,0,0,0};
  148.         float b11=0;
  149.         float C21=0;
  150.         float a21=0;
  151.         a21=10;

  153.         while(fabs(a21)>=0.00000001)                  //给定拟合精确度
  154.         {
  155.                    b11=0;
  156.                    C21=0;
  157.                    a21=0;
  158.                
  159.                 i=0;
  160.                 while(i<=9)
  161.                 {
  162.                         b11=b11+2850*Ab[i]*Y0xxx[i]*Y0xxx[i]*0.01;
  163.                         i++;
  164.                 }
  165.                
  166.                 i=0;
  167.                 while(i<=9)
  168.                 {
  169.                         C21=C21+2850*Ab[i]*Y0xxx[i]*Y2js[i]*0.01;
  170.                         i++;
  171.                 }
  172.                
  173.                 a21=C21/b11;

  175.                 i=0;
  176.                 while(i<=9)
  177.                 {
  178.                         Y2[i]=Y2js[i]-a21*Y0xxx[i];
  179.                         i++;
  180.                 }

  182.                 p=0;
  183.             while(9>=p)
  184.             {
  185.                       Y2js[p]=Y2[p];
  186.                 p=p+1;
  187.             }                                 //令实际值等于假设值，再次迭代运算
  188.    }
  189.                
  190.                 i=0;
  191.                 while (i<=9)
  192.                 {
  193.                         Y2sj[i]=Y2[i]/Y2[9];
  194.                            i++;       
  195.                    }                                     //归一化
  196.                  
  197.                 q=0;
  198.                    while(9>=q)
  199.         {
  200.                   one[q]=0;
  201.                   two[q]=0;
  202.                   three[q]=0;
  203.                   four[q]=0;
  204.                   q=q+1;
  205.         }                             //这步是给数组清零，千万不能忘！
  206.            
  207.                 a=0;
  208.             b=0;
  209.             while(9>=a)
  210.             {
  211.                       b=a;
  212.                       while(9>=b+2)
  213.                 {
  214.                           one[a]=one[a]+(Ab[b+2]*Y2sj[b+2]*0.01);
  215.                           b=b+1;
  216.                   }
  217.                 a=a+1;
  218.               }                                 //第一重循环

  220.             c=0;
  221.             d=0;
  222.             while(9>=c)
  223.             {
  224.                           d=c;
  225.                       while(9>=d+1)
  226.                 {
  227.                           two[c]=two[c]+(one[d+1]*0.01);
  228.                           d=d+1;
  229.                 }
  230.                 c=c+1;
  231.             }                                 //第二重循环
  232.   
  233.             e=0;
  234.             f=0;
  235.             while(9>=e)
  236.             {
  237.                       f=0;
  238.                       while(e>=f)
  239.                 {
  240.                           three[e]=three[e]+two[f]*0.01*(1/Ib[f]);
  241.                           f=f+1;
  242.                 }
  243.                 e=e+1;
  244.             }                                 //第三重循环  
  245.    
  246.             g=0;
  247.             h=0;
  248.             while(9>=g)
  249.             {
  250.                       h=0;
  251.                       while(g>=h)
  252.                 {
  253.                                  four[g]=four[g]+three[h]*0.01;
  254.                                  h=h+1;
  255.                 }
  256.                 g=g+1;
  257.               }                                 //第四重循环
  258.    
  259.         omega=sqrt((E/rou)*(1/four[9]));
  260.         omega=omega*xz;
  261.         printf("二阶固有静频为：%.5fHZ\n",omega/(2*3.1415926));

  263.         //第三个函数开始
  264.         float Y3js[10]={0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1};
  265.         float Y3[10]={0,0,0,0,0,0,0,0,0,0};
  266.         float Y3sj[10]={0,0,0,0,0,0,0,0,0,0};

  268.         b11=0;
  269.         float b12=0;
  270.         float b21=0;
  271.         float b22=0;
  272.         float C31=0;
  273.         float C32=0;
  274.         float a31=0;
  275.         float a32=0;
  276.         a32=10;
  277.         float shoulian=10;

  279.         while(shoulian>=0.0001)                  //给定拟合精确度
  280.         {       
  281.                 while(i<=9)
  282.                   {
  283.                         Y3js[i]=Y3[i];
  284.                         i++;
  285.                   }
  286.        
  287.             b12=0;
  288.             b21=0;
  289.             b22=0;
  290.             C31=0;
  291.             C32=0;
  292.             a31=0;
  293.             a32=0;
  294.                
  295.                 i=0;
  296.                 while(i<=9)
  297.                   {
  298.                         b11=b11+2850*Ab[i]*Y0xxx[i]*Y0xxx[i]*0.01;
  299.                         i++;
  300.                   }
  301.                
  302.                 i=0;
  303.                 while(i<=9)
  304.                   {
  305.                         b12=b12+2850*Ab[i]*Y0xxx[i]*Y2[i]*0.01;
  306.                         i++;
  307.                   }

  309.                 i=0;
  310.                 while(i<=9)
  311.                 {
  312.                         b21=b21+2850*Ab[i]*Y0xxx[i]*Y2[i]*0.01;
  313.                         i++;
  314.                 }  

  316.                 i=0;
  317.                 while(i<=9)
  318.                 {
  319.                         b22=b22+2850*Ab[i]*Y2[b]*Y2[i]*0.01;
  320.                         i++;
  321.                   }   

  323.                 i=0;
  324.                 while(i<=9)
  325.                   {
  326.                         C31=C31+2850*Ab[i]*Y0xxx[i]*Y3js[i]*0.01;
  327.                         i++;
  328.                 }

  330.                 i=0;
  331.                 while(i<=9)
  332.                 {
  333.                         C32=C32+2850*Ab[i]*Y2[i]*Y3js[i]*0.01;
  334.                         i++;
  335.                   }
  336.                
  337.                 a31=C31/b11;  
  338.                 a32=C32/b22;   
  339.                
  340.                 i=0;
  341.                 while(i<=9)
  342.                 {
  343.                         Y3[i]=Y3js[i]-a31*Y0xxx[i]-a32*Y2[i];
  344.                         i++;
  345.                 }
  346.                  
  347.                   shoulian=fabs(Y3js[0]-Y3[0]);
  348.         }

  350.     q=0;
  351.            while(9>=q)
  352.     {
  353.         one[q]=0;
  354.         two[q]=0;
  355.         three[q]=0;
  356.         four[q]=0;
  357.         q=q+1;
  358.     }                             //这步是给数组清零，千万不能忘！
  359.    
  360.         a=0;
  361.     b=0;
  362.     while(9>=a)
  363.     {
  364.               b=a;
  365.               while(9>=b+2)
  366.         {
  367.                   one[a]=one[a]+(Ab[b+2]*Y3[b+2]*0.01);
  368.                   b=b+1;
  369.         }
  370.         a=a+1;
  371.     }                                 //第一重循环

  373.     c=0;
  374.     d=0;
  375.     while(9>=c)
  376.     {
  377.               d=c;
  378.               while(9>=d+1)
  379.         {
  380.                   two[c]=two[c]+(one[d+1]*0.01);
  381.                   d=d+1;
  382.         }
  383.         c=c+1;
  384.     }                                 //第二重循环
  385.   
  386.     e=0;
  387.     f=0;
  388.     while(9>=e)
  389.     {
  390.               f=0;
  391.               while(e>=f)
  392.         {
  393.                   three[e]=three[e]+two[f]*0.01*(1/Ib[f]);
  394.                   f=f+1;
  395.         }
  396.         e=e+1;
  397.         }                                 //第三重循环  
  398.    
  399.     g=0;
  400.     h=0;
  401.     while(9>=g)
  402.     {
  403.               h=0;
  404.               while(g>=h)
  405.         {
  406.                  four[g]=four[g]+three[h]*0.01;
  407.                  h=h+1;
  408.         }
  409.         g=g+1;
  410.         }                                 //第四重循环
  411.    
  412.         omega=sqrt((E/rou)*(1/four[9]));
  413.         omega=omega*xz;
  414.         omega=sqrt((E/rou)*(1/four[9]));
  415.         omega=omega*xiuzhen;
  416.         printf("三阶固有静频为：%.5fHZ\n",(2*omega)/(2*3.1415926));
  417.         system("pause");
  418. }
复制代码


问题描述：两个程序第一个函数和第二个函数产生数据相同，第三个函数从变量b12开始计算有误。结算结果两者相差1e9。
最佳答案
月排行榜 / 总排行榜
耻思lhj
2020-4-15 23:09:10
本帖最后由 耻思lhj 于 2020-4-15 23:33 编辑

所以你python的答案是什么？
我把你所有的float改成了double，因为我认为可能是精度的问题，下面是改了后c运行的结果
一阶固有静频为：406.98650HZ
二阶固有静频为：1795.49790HZ
三阶固有静频为：4594.51734HZ
都改为double：第九次循环b12=-4e-019
没改之前float:第九次循环b12=3e-010

小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

xxfholic
 楼主| 发表于 2020-4-15 22:22:39 | 显示全部楼层
续帖：
与b12有关的数组：Ab，Y2，Y0xxx三组数值相同
  1. python数组
  2. Y2 = array([-0.00915524,
  3. -0.12828047,
  4. -0.3583434 ,
  5. -0.59971634,
  6. -0.55154928,
  7. -0.41236732,
  8. -0.37925495,
  9. 0.15134434,  
  10. 0.38194363,
  11. 0.51254293])

  13. Y0xxx =
  14. array([0.07180484,
  15. 0.22180461,
  16. 0.45758906,
  17. 0.78207828,
  18. 1.1886056 ,
  19. 1.66560334,
  20. 2.19020504,
  21. 2.73451689,
  22. 3.27882874,
  23. 3.82314059])

  25. Ab=
  26. array([1.580e-04,
  27. 1.360e-04,
  28. 1.175e-04,
  29. 1.025e-04,
  30. 9.100e-05,
  31. 8.150e-05,
  32. 7.500e-05,
  33. 7.150e-05,
  34. 6.900e-05,
  35. 6.800e-05])
复制代码

  1. C数组
  2. Ab =
  3. {0.00015800001,
  4. 0.000136000002,
  5. 0.0001175,
  6. 0.000102500002,
  7. 9.10000017e-005,
  8. 8.14999948e-005,
  9. 7.50000036e-005,
  10. 7.1500006e-005,
  11. 6.90000015e-005,
  12. 6.80000012e-005}

  14. Y0xxx =
  15. {0.0718048364,
  16. 0.221804589,
  17. 0.45758903,
  18. 0.782078266,
  19. 1.18860555,
  20. 1.66560328,
  21. 2.1902051,
  22. 2.73451686,
  23. 3.27882862,
  24. 3.82314038}

  26. Y2 =
  27. {-0.00915524177,
  28. -0.128280476,
  29. -0.358343422,
  30. -0.599716365,
  31. -0.551549315,
  32. -0.412367314,
  33. -0.379254967,
  34. 0.151344314,
  35. 0.381943643,
  36. 0.512542963}
复制代码


在执行循环时，前八次循环b12值相同，然而第九次循环结束后，两个代码b12的值就相差1e9，目前不知道为何，希望鱼C论坛的大佬们能够帮助我，比较着急，跪谢！
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

耻思lhj
发表于 2020-4-15 23:09:10 | 显示全部楼层    本楼为最佳答案   
本帖最后由 耻思lhj 于 2020-4-15 23:33 编辑

所以你python的答案是什么？
我把你所有的float改成了double，因为我认为可能是精度的问题，下面是改了后c运行的结果
一阶固有静频为：406.98650HZ
二阶固有静频为：1795.49790HZ
三阶固有静频为：4594.51734HZ
都改为double：第九次循环b12=-4e-019
没改之前float:第九次循环b12=3e-010

小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 1 反对 0

使用道具 举报

xxfholic
 楼主| 发表于 2020-4-16 07:44:54 | 显示全部楼层
耻思lhj 发表于 2020-4-15 23:09
所以你python的答案是什么？
我把你所有的float改成了double，因为我认为可能是精度的问题，下面是改了后c ...

谢谢带佬，原来是float和double的问题！
我这个python程序可能还有点问题，我再去看看。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-6-17 07:38

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表