js版本：

相应注释已经写上，具体分析等考完试再写-=-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
const setting = {
    length     : 8,   // 染色体长度
    count      : 200, // 随机生成初始种群中的染色体数量
}
var population = gen_population(setting.length, setting.count) // 随机生成初始种群
;(function () {
    // 200次进化迭代
    for (let i = 0; i < 200; i++) {
        evolve()
    }
    // 输出结果
    let rst = result()
    console.log(`
函数f(x)=xcosx的最优解为：${rst}
所取到的最大值为：${rst * Math.cos(rst)}
    `)
})()
/**
* 进化，对当前一代种群依次进行选择、交叉并生成新一代种群，然后对新一代种群进行变异
* @param  {Number} param
* @return {String} return
*/
function evolve(retain_rate = 0.2, random_select_rate = 0.6, mutation_rate = 0.01) {
    let parents = selection(retain_rate, random_select_rate)
    crossover(parents)
    mutation(mutation_rate)
}
/**
* 随机生成长度为length的染色体，每个基因的取值是0或1，这里用一个bit表示一个基因
* @param  {Number} length 随机生成长度为length的染色体
* @return {String} return 长度为length的染色体
*/
function gen_chromosome(length) {
    let chromosome = 0
    for (let i = 0; i <= length; i++) 
        chromosome |= (1 << i) * Math.random()
    return chromosome
}
/**
* 获取初始种群（一个含有count个长度为length的染色体的列表）
* @param  {Number} length 长度为length的染色体
* @param  {Number} count个染色体
* @return {String} return 染色体数组
*/
function gen_population(length, count) {
    let population_array = []
    for (let i = 0; i < count; i++)
        population_array.push(gen_chromosome(length))
    return population_array
}
/**
* 计算适应值函数(也是我们需要求解的函数)
* @param  {Number} x 自变量
* @return {String} 因变量
*/
function fitness(chromosome){
    // 因为是求最大值，所以数值越大，适应度越高
    let x = decode(chromosome)
    return x * Math.cos(x)
}
/**
* 染色体选择
* @param  {Number} param
* @return {String} return 
*/
function selection(retain_rate, random_select_rate) {
    // 先对适应度从大到小排序，选出存活的染色体
    let graded = []
    for (let i of population) {
        graded.push({
            fitness: fitness(i),
            chromosome: i
        })
    }
    graded.sort( function(a, b){return b.fitness - a.fitness} )
    // for (let i)
    for(let i = 0; i<graded.length; i++) {
        graded[i] = graded[i].chromosome
    }
    // 选出适应性强的染色体
    let retain_length = Math.floor(graded.length * retain_rate)
    let parents = graded.slice( 0, retain_length )
    // 选出适应性不强，但是幸存的染色体
    for (let i of graded.slice( retain_length, graded.length )) {
        if (Math.random() < random_select_rate) {
            parents.push(i)
        }
    }
    return parents
}
/**
* 染色体的交叉、繁殖，生成新一代的种群
* @param  {Number} parents 父代
* @return {String} return
*/
function crossover(parents) {
    // 新出生的孩子，最终会被加入存活下来的父母之中，形成新一代的种群。
    let children = []
    // 需要繁殖的孩子的量
    let children_num = population.length - parents.length
    // 开始根据需要的量进行繁殖
    while (children.length < children_num) {
        let male = Math.round( Math.random() * (parents.length - 1) )
        let female = Math.round( Math.random() * (parents.length - 1) )
        if (male != female) {
            // 随机选取交叉点
            let cross_pos = Math.round( Math.random() * setting.length )
            // 生成掩码，方便位操作
            let mask = 0
            for (let i = 0; i < cross_pos; i++) {
                mask |= (1 << i)
            }
            male = parents[male]
            female = parents[female]
            // 孩子将获得父亲在交叉点前的基因和母亲在交叉点后（包括交叉点）的基因
            let child = ((male & mask) | (female & ~mask)) & ((1 << setting.length) - 1)
            children.push(child)
        }
    }
    population = parents.concat(children)
}
/**
* 变异，对种群中的所有个体，随机改变某个个体中的某个基因
* @param  {Number} param
* @return {String} return
*/
function mutation(rate) {
    for(let i = 0; i < population.length; i++) {
        if (Math.random() < rate) {
            let j = Math.round( Math.random() * (setting.length - 1) )
            population[i] ^= 1 << j
        }
    }
}
/**
* 解码染色体，将二进制转化为属于[0, pi/4]的实数
 * @param  {Number} chromosome
 * @return {String} 属于[0, pi/4]的实数
 */
function decode(chromosome) {
    return chromosome * (Math.PI / 4) / (2 ** setting.length - 1)
}
/**
* 获得当前代的最优值，这里取的是函数取最大值时x的值。
* @param  {Number} param
* @return {String} return
*/
function result() {
    let graded = []
    for (let i of population) {
        graded.push({
            fitness: fitness(i),
            chromosome: i
        })
    }
    graded.sort( function(a, b){return b.fitness - a.fitness} )
    // for (let i)
    for(let i = 0; i<graded.length; i++) {
        graded[i] = graded[i].chromosome
    }
    return decode(graded[0])
}