错误：cannot convert 'double' to 'double*' for argument '1'

tmxdlsd

套用了一个程序，想实现粒子群优化算法求得最优值，但是一直报错，不知道怎么解决了

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<math.h>
   
4. #include<time.h>
   
5. #define c1 1.49445 //加速度因子一般是根据大量实验所得
   
6. #define c2 1.49445
   
7. #define ger 50  // 迭代次数
   
8. #define N 50 // 种群规模
   
9. #define Xmax 50 // 个体最大取值
   
10. #define Xmin 0 // 个体最小取值
    
11. #define Vmax 1 // 速度最大值
    
12. #define Vmin -1 //速度最小值
    
13. #define d 1 // 粒子的维数
    
14. #define wmax 0.9
    
15. #define wmin 0.4
    
16. #define pi 3.1415926 //圆周率
    
17. 
    
18. double x[N]; // 定义种群数组
    
19. double v[N]; // 定义种群速度数组
    
20. double fitness[N]; // 定义种群的适应度数组
    
21. double result[ger];  //定义存放每次迭代种群最优值的数组
    
22. double pbest[N];  // 个体极值的位置
    
23. double gbest; //群体极值的位置
    
24. double fitnesspbest[N]; //个体极值适应度的值
    
25. double fitnessgbest; // 群体极值适应度值
    
26. double genbest[ger]; //每一代最优值取值粒子
    
27. 
    
28. //适应度函数
    
29. void func(double I[], double x)
    
30. {
    
31.     double t[2] = {3.05e-4,3.25e-4};
    
32.     double Iz[2]={13.8137,13.8206};
    
33.     double L0 = 73e-6;
    
34.     double C0=119.5e-9;
    
35.     double L1=152.87e-6;
    
36.     double C1=68.26e-9;
    
37.     double L2=153.6e-6;
    
38.     double C2=67.73e-9;
    
39.     double R1=0.49;
    
40.     double R2=0.5;
    
41.     //RL=30;
    
42.     double R=R2+x;
    
43.     double Edc=100;
    
44.     double f=50000;
    
45.     double M=140.5e-6;
    
46. 
    
47.     double w=2*pi*f;
    
48.     double u0=w*L0-1/(w*C0);
    
49.     double u1=w*L1-1/(w*C1);
    
50.     double u2=w*L2-1/(w*C2);
    
51.     double a=R1+(pow(M,2)*R*pow(w,2))/(pow(R,2) + pow(u2,2));
    
52.     double b=1/(C0*w) - u1 + (pow(M,2)*u2*pow(w,2))/(pow(R,2) + pow(u2,2));
    
53.     double c=L0/C0 - u0*u1 + (pow(M,2)*u0*u2*pow(w,2))/(pow(R,2) + pow(u2,2));
    
54. 
    
55.     double alpha=(a*(c-u0*b))/(pow(a,2)+pow(b,2));
    
56.     double beta=(c*b+u0*pow(a,2))/(pow(a,2)+pow(b,2));
    
57.     double I0=(4*Edc)/(pi*sqrt(pow(alpha,2)+pow(beta,2)));
    
58.     double fai=atan(beta/alpha);
    
59.     I[0]=I0*sin(w*t[0]+fai);
    
60.     I[1]=I0*sin(w*t[1]+fai);
    
61.     double fitness = sqrt((pow((Iz[0]-I[0]),2)+pow((Iz[1]-I[1]),2))/2);
    
62. 
    
63. }
    
64. 
    
65. // 种群初始化
    
66. void pop_init(void)
    
67. {
    
68.     srand(time(NULL));
    
69.     for(int i=0;i<N;i++)
    
70.     {
    
71. 
    
72.         x[i] = rand()%51; //0到50之间的随机数
    
73.         v[i] = rand()%3-1; //-1到1之间
    
74. 
    
75.         fitness[i] = func(x[i]); //计算适应度函数值
    
76.     }
    
77. }
    
78. 
    
79. // min()函数定义
    
80. 
    
81. double * min(double * fit,int size)
    
82. {
    
83.     int index = 0; // 初始化序号
    
84.     double min = *fit; // 初始化最小值为数组第一个元素
    
85.     static double best_fit_index[2];
    
86.     for(int i=1;i<size;i++)
    
87.     {
    
88.         if(*(fit+i) < min)
    
89.             min = *(fit+i);
    
90.             index = i;
    
91.     }
    
92.     best_fit_index[0] = index;
    
93.     best_fit_index[1] = min;
    
94.     return best_fit_index;
    
95. 
    
96. }
    
97. 
    
98. // 迭代寻优
    
99. void PSO_func(void)
    
100. {
     
101.     pop_init();
     
102.     double * best_fit_index; // 用于存放群体极值和其位置(序号)
     
103.     best_fit_index = min(fitness,N); //求群体极值
     
104.     int index = (int)(*best_fit_index);
     
105.     // 群体极值位置
     
106. 
     
107.         gbest = x[index];
     
108. 
     
109.     // 个体极值位置
     
110.     for(int i=0;i<N;i++)
     
111.     {
     
112. 
     
113.             pbest[i] = x[i];
     
114.   
     
115.     // 个体极值适应度值
     
116. 
     
117.         fitnesspbest[i] = fitness[i];
     
118.     }
     
119.     //群体极值适应度值
     
120.     double bestfitness = *(best_fit_index+1);
     
121.     fitnessgbest = bestfitness;
     
122. 
     
123.     //迭代寻优
     
124.     for(int i=0;i<ger;i++)
     
125.     {
     
126.         for(int j=0;j<N;j++)
     
127.         {
     
128.             //速度更新及粒子更新
     
129.             
     
130.                 // 速度更新
     
131.                 double rand1 = (double)rand()/RAND_MAX; //0到1之间的随机数
     
132.                 double rand2 = (double)rand()/RAND_MAX;
     
133.                 double w;
     
134.                 double Tmax = (double)ger;
     
135.                        w = wmin + (wmax - wmin)*(Tmax-i)/Tmax;
     
136.                 v[j] = w*v[j] + c1*rand1*(pbest[j]-x[j]) + c2*rand2*(gbest-x[j]);
     
137.                 if(v[j] > Vmax)
     
138.                     v[j] = Vmax;
     
139.                 if(v[j] < Vmin)
     
140.                     v[j] = Vmin;
     
141.                 // 粒子更新
     
142.                 x[j] = x[j] + v[j];
     
143.                 if(x[j] > Xmax)
     
144.                     x[j] = Xmax;
     
145.                 if(x[j] < Xmin)
     
146.                     x[j] = Xmin;
     
147. 
     
148.             fitness[j] = func(x[j]); //新粒子的适应度值
     
149.         }
     
150.         for(int j=0;j<N;j++)
     
151.         {
     
152.             // 个体极值更新
     
153.             if(fitness[j] > fitnesspbest[j])
     
154.             {
     
155. 
     
156.                     pbest[j] = x[j];
     
157. 
     
158.                 fitnesspbest[j] = fitness[j];
     
159.             }
     
160.             // 群体极值更新
     
161.             if(fitness[j] > fitnessgbest)
     
162.             {
     
163.                
     
164.                     gbest = x[j];
     
165.                 fitnessgbest = fitness[j];
     
166.             }
     
167.         }
     
168. 
     
169.             genbest[i] = gbest; // 每一代最优值取值粒子位置记录
     
170. 
     
171.         result[i] = fitnessgbest; // 每代的最优值记录到数组
     
172.     }
     
173. }
     
174. 
     
175. // 主函数
     
176. int main(void)
     
177. {
     
178.     clock_t start,finish; //程序开始和结束时间
     
179.     start = clock(); //开始计时
     
180.     srand((unsigned)time(NULL)); // 初始化随机数种子
     
181.     PSO_func();
     
182.     double * best_fit_index = min(result,ger);
     
183.     double best_result = *(best_fit_index+1); //最优解
     
184.     printf("每次实验迭代%d次,求得最优值为:%lf",ger,best_result);   
     
185.     finish = clock(); //结束时间
     
186.     double duration = (double)(finish - start)/CLOCKS_PER_SEC; // 程序运行时间
     
187.     printf("程序运行耗时:%lf\n",duration);
     
188.     return 0;
     
189. }
     

复制代码

报错信息：

2191265529

传参类型不一致,double类型传给了double *

tmxdlsd

2191265529 发表于 2019-8-16 15:09
传参类型不一致,double类型传给了double *

能麻烦您帮我改下吗？我不太懂C语言编程，临时要求下到硬件里做实验才急着套用了一个程序!