C#中的遗传编程

using System;

public class GeneticAlgorithm {
    private int populationSize;
    private double mutationRate;
    private double crossoverRate;
    private int eliteSize;
    private Func<double[], double> fitnessFunc;

    public GeneticAlgorithm(int populationSize, double mutationRate, double crossoverRate, int eliteSize, Func<double[], double> fitnessFunc) {
        this.populationSize = populationSize;
        this.mutationRate = mutationRate;
        this.crossoverRate = crossoverRate;
        this.eliteSize = eliteSize;
        this.fitnessFunc = fitnessFunc;
    }

    public double[] Optimize(double[] lowerBounds, double[] upperBounds, int maxGenerations) {
        Random random = new Random();
        double[][] population = new double[populationSize][];
        for (int i = 0; i< populationSize; i++) {
            population[i] = GetRandomSolution(lowerBounds, upperBounds);
        }

        for (int i = 0; i < maxGenerations; i++) {
            double[] fitness = new double[populationSize];
            for (int j = 0; j< populationSize; j++) {
                fitness[j] = fitnessFunc(population[j]);
            }

            int[] indices = GetSortedIndices(fitness);

            double[][] newPopulation = new double[populationSize][];
            for (int j = 0; j < eliteSize; j++) {
                newPopulation[j] = population[indices[j]];
            }

            for (int j = eliteSize; j< populationSize; j += 2) {
                int index1 = GetIndex(random, populationSize);
                int index2 = GetIndex(random, populationSize);

                double[] parent1 = population[indices[index1]];
                double[] parent2 = population[indices[index2]];

                double[] child1, child2;
                if (random.NextDouble() < crossoverRate) {
                    child1 = Crossover(parent1, parent2);
                    child2 = Crossover(parent2, parent1);
                } else {
                    child1 = parent1;
                    child2 = parent2;
                }

                child1 = Mutate(child1, lowerBounds, upperBounds, mutationRate);
                child2 = Mutate(child2, lowerBounds, upperBounds, mutationRate);

                newPopulation[j] = child1;
                newPopulation[j + 1] = child2;
            }

            population = newPopulation;
        }

        double[] bestSolution = population[GetIndex(new Random(), populationSize)];
        return bestSolution;
    }

    private double[] GetRandomSolution(double[] lowerBounds, double[] upperBounds) {
        Random random = new Random();
        double[] solution = new double[lowerBounds.Length];
        for (int i = 0; i< solution.Length; i++) {
            solution[i] = lowerBounds[i] + random.NextDouble() * (upperBounds[i] - lowerBounds[i]);
        }
        return solution;
    }

    private int[] GetSortedIndices(double[] fitness) {
        int[] indices = new int[fitness.Length];
        for (int i = 0; i< indices.Length; i++) {
            indices[i] = i;
        }

        Array.Sort(fitness, indices);

        return indices;
    }

    private int GetIndex(Random random, int size) {
        int index = random.Next(size);
        return index;
    }

    private double[] Crossover(double[] parent1, double[] parent2) {
        Random random = new Random();
        double[] child = new double[parent1.Length];
        int crossoverPoint = random.Next(parent1.Length);
        for (int i = 0; i < crossoverPoint; i++) {
            child[i] = parent1[i];
        }
        for (int i = crossoverPoint; i< child.Length; i++) {
            child[i] = parent2[i];
        }
        return child;
    }

    private double[] Mutate(double[] solution, double[] lowerBounds, double[] upperBounds, double mutationRate) {
        Random random = new Random();
        for (int i = 0; i< solution.Length; i++) {
            if (random.NextDouble() < mutationRate) {
                solution[i] = lowerBounds[i] + random.NextDouble() * (upperBounds[i] - lowerBounds[i]);
            }
        }
        return solution;
    }
}