灰狼算法C语言代码包围猎物

灰狼算法是一种新的优化算法，可以用于求解各种优化问题。下面是使用C语言实现的灰狼算法代码，该代码实现了灰狼算法对猎物进行包围。

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

#define MAX_ITER 100    // 迭代次数
#define N 30            // 灰狼数量
#define dim 2           // 变量维度
#define lb -10          // 变量下限
#define ub 10           // 变量上限

void init(double (*pos)[dim], double (*vel)[dim])
{
    int i, j;
    for (i = 0; i < N; i++) {
        for (j = 0; j < dim; j++) {
            pos[i][j] = lb + (ub - lb) * rand() / (RAND_MAX + 1.0);
            vel[i][j] = 0;
        }
    }
}

double func(double x[dim])
{
    double sum = 0;
    int i;
    for (i = 0; i < dim; i++) {
        sum += x[i] * x[i];
    }
    return sum;
}

void update(double (*pos)[dim], double (*vel)[dim], double alpha[], double beta[], double delta[])
{
    int i, j, k;
    double a, A, C, D, r1, r2;
    double x[N][dim];
    double A1[dim], C1[dim], D1[dim];

    for (i = 0; i < N; i++) {
        for (j = 0; j < dim; j++) {
            x[i][j] = pos[i][j];
        }
    }

    for (i = 0; i < N; i++) {
        for (j = 0; j < dim; j++) {
            vel[i][j] = 0;
        }
    }

    for (i = 0; i < N; i++) {
        a = 2 - 2 * ((double)i + 1) / (double)N;
        A = 2 * a * rand() / (RAND_MAX + 1.0) - a;
        C = 2 * rand() / (RAND_MAX + 1.0);
        D = fabs(C * delta[j] - x[i][j]);
        for (j = 0; j < dim; j++) {
            r1 = rand() / (RAND_MAX + 1.0);
            r2 = rand() / (RAND_MAX + 1.0);
            A1[j] = 2 * A * r1 - A;
            C1[j] = 2 * C * r2 - C;
            D1[j] = fabs(C1[j] * delta[j] - x[i][j]);
            vel[i][j] = vel[i][j] + A1[j] * D1[j];
        }
    }

    for (i = 0; i < N; i++) {
        for (j = 0; j < dim; j++) {
            x[i][j] = x[i][j] + vel[i][j];
            if (x[i][j] < lb) {
                x[i][j] = lb;
            }
            if (x[i][j] > ub) {
                x[i][j] = ub;
            }
        }
    }

    double score[N];
    for (i = 0; i < N; i++) {
        score[i] = func(x[i]);
    }

    double max_score = score[0];
    int max_index = 0;
    for (i = 1; i < N; i++) {
        if (score[i] > max_score) {
            max_score = score[i];
            max_index = i;
        }
    }
    for (j = 0; j < dim; j++) {
        alpha[j] = x[max_index][j];
    }

    double min_score = score[0];
    int min_index = 0;
    for (i = 1; i < N; i++) {
        if (score[i] < min_score) {
            min_score = score[i];
            min_index = i;
        }
    }
    for (j = 0; j < dim; j++) {
        delta[j] = x[min_index][j];
    }

    for (i = 0; i < N; i++) {
        if (i == max_index) {
            continue;
        }
        for (j = 0; j < dim; j++) {
            x[i][j] = x[max_index][j] - A1[j] * D1[j];
            if (x[i][j] < lb) {
                x[i][j] = lb;
            }
            if (x[i][j] > ub) {
                x[i][j] = ub;
            }
        }
    }

    for (i = 0; i < N; i++) {
        if (i == min_index) {
            continue;
        }
        for (j = 0; j < dim; j++) {
            x[i][j] = x[i][j] + C1[j] * D1[j];
            if (x[i][j] < lb) {
                x[i][j] = lb;
            }
            if (x[i][j] > ub) {
                x[i][j] = ub;
            }
        }
    }

    for (i = 0; i < N; i++) {
        for (j = 0; j < dim; j++) {
            pos[i][j] = x[i][j];
        }
    }
}

int main()
{
    srand(time(NULL));
    double pos[N][dim], vel[N][dim];
    double alpha[dim], beta[dim], delta[dim];

    init(pos, vel);

    int i, j;
    for (i = 0; i < dim; i++) {
        alpha[i] = pos[0][i];
        beta[i] = pos[1][i];
        delta[i] = pos[2][i];
    }

    for (i = 0; i < MAX_ITER; i++) {
        update(pos, vel, alpha, beta, delta);
        printf("Iteration %d: ", i + 1);
        for (j = 0; j < dim; j++) {
            printf("%f ", alpha[j]);
        }
        printf("\n");
    }

    return 0;
}

在主函数中，首先调用init函数初始化灰狼的位置和速度。接着定义alpha、beta、delta三个向量，表示当前最好、次好和最差的灰狼位置。然后进入迭代循环，每次调用update函数更新灰狼的位置和速度，并更新alpha、beta、delta三个向量。最终输出迭代结果。

在update函数中，首先根据公式计算出新的速度，然后根据公式计算出新的位置。为了确保位置在变量的范围内，需要进行边界处理。接着计算每个灰狼的适应度值，找出当前最好、次好和最差的灰狼位置，并更新alpha、beta、delta三个向量。最后根据公式计算出其他灰狼的新位置，并更新pos数组