遗传算法求函数最大值f(x)=xsin(10π*x)+2.0 x∈[-1,2](C语言实现)

好的，针对您的问题，以下是使用遗传算法求解函数最大值f(x)=xsin(10π*x)+2.0 x∈[-1,2]的C语言实现。

首先需要定义个体结构体，包含个体基因型、适应度等信息：

#define POP_SIZE 100  // 种群大小

typedef struct {
    double x;           // 基因型
    double fitness;     // 适应度
} individual_t;

接下来，需要实现个体的初始化和适应度计算函数：

// 随机生成个体基因型
void init_individuals(individual_t *pop) {
    for (int i = 0; i < POP_SIZE; i++) {
        pop[i].x = -1.0 + (double)rand() / RAND_MAX * 3.0;  // 基因型初始化为[-1, 2]之间的随机数
    }
}

// 计算个体适应度
double calc_fitness(double x) {
    return x * sin(10.0 * M_PI * x) + 2.0;
}

void evaluate_individual(individual_t *pop) {
    for (int i = 0; i < POP_SIZE; i++) {
        pop[i].fitness = calc_fitness(pop[i].x);
    }
}

接下来，需要实现选择、交叉和变异函数：

// 选择函数
void selection(individual_t *pop, individual_t *new_pop) {
    double fitness_sum = 0.0;
    double cum_sum[POP_SIZE];

    // 计算适应度总和
    for (int i = 0; i < POP_SIZE; i++) {
        fitness_sum += pop[i].fitness;
    }

    // 计算累积适应度
    cum_sum[0] = pop[0].fitness / fitness_sum;
    for (int i = 1; i < POP_SIZE; i++) {
        cum_sum[i] = cum_sum[i - 1] + pop[i].fitness / fitness_sum;
    }

    // 选择新种群
    for (int i = 0; i < POP_SIZE; i++) {
        double r = (double)rand() / RAND_MAX;
        int j = 0;
        while (r > cum_sum[j]) j++;
        new_pop[i] = pop[j];
    }
}

// 交叉函数
void crossover(individual_t *pop, individual_t *new_pop) {
    for (int i = 0; i < POP_SIZE; i += 2) {
        double r = (double)rand() / RAND_MAX;
        if (r < CROSSOVER_RATE) {
            int index1 = rand() % POP_SIZE;
            int index2 = rand() % POP_SIZE;
            new_pop[i].x = pop[index1].x;
            new_pop[i + 1].x = pop[index2].x;
            double alpha = (double)rand() / RAND_MAX;
            new_pop[i].x = alpha * pop[index2].x + (1.0 - alpha) * pop[index1].x;
            new_pop[i + 1].x = alpha * pop[index1].x + (1.0 - alpha) * pop[index2].x;
        }
        else {
            new_pop[i] = pop[i];
            new_pop[i + 1] = pop[i + 1];
        }
    }
}

// 变异函数
void mutation(individual_t *pop) {
    for (int i = 0; i < POP_SIZE; i++) {
        double r = (double)rand() / RAND_MAX;
        if (r < MUTATION_RATE) {
            double delta = (double)rand() / RAND_MAX * 0.1 - 0.05;
            pop[i].x += delta;
            if (pop[i].x < -1.0) pop[i].x = -1.0;
            if (pop[i].x > 2.0) pop[i].x = 2.0;
        }
    }
}

最后，实现主函数进行遗传算法的迭代求解：

int main() {
    srand(time(NULL));

    individual_t pop[POP_SIZE];
    individual_t new_pop[POP_SIZE];

    init_individuals(pop);
    evaluate_individual(pop);

    int generation = 0;
    while (generation < MAX_GENERATION) {
        selection(pop, new_pop);
        crossover(new_pop, pop);
        mutation(pop);
        evaluate_individual(pop);
        generation++;
    }

    // 输出最优解
    double max_fitness = -INFINITY;
    int max_index = 0;
    for (int i = 0; i < POP_SIZE; i++) {
        if (pop[i].fitness > max_fitness) {
            max_fitness = pop[i].fitness;
            max_index = i;
        }
    }
    printf("max fitness = %f, x = %f\n", max_fitness, pop[max_index].x);

    return 0;
}

整个遗传算法的实现就完成了。当然，需要根据实际情况调整各种参数，如种群大小、迭代次数、交叉率、变异率等，以获得更好的求解效果。