遗传算法用什么语言_遗传算法要用什么软件

怎么用遗传算法或者C语言实现无人机协同任务规划

遗传算法在matlab里有两个函数，分别是ga和gaoptimset，前者用来调用遗传算法，后者用来设定遗传算法的参数，具体内容可以doc ga查看，遗传算法有哪些参数可以直接在命令窗口输入gaoptimset查看，祝好。

遗传算法用什么语言_遗传算法要用什么软件

用R语言实现遗传算法

模式识别的三大核心问题包括：

特征选择 和 特征变换 都能够达到降维的目的，但是两者所采用的方式方法是不同的。

特征提取 主要是通过分析特征间的关系，变换原来特征空间，从而达到压缩特征的目的。主要方法有：主成分分析（PCA）、离散K-L变换法（DKLT）等。

特征选择 选择方法是从原始特征集中挑选出子集，是原始特征的选择和组合，并没有更改原始特征空间，特征选择的过程必须确保不丢失重要特征。主要方法有：遗传算法（GA）、统计检验法、分支定界法等。

这里主要讲讲特征选择中 遗传算法 以及它的R语言实现（因为要写作业，虽然不一定写对了）。

遗传算法受进化论启发，根据“物竞天择，适者生存”这一规则，模拟自然界进化机制，寻找目标函数的值。

采用遗传算法对男女生样本数据中的身高、体重、鞋码、50m成绩、肺活量、是否喜欢运动共6个特征进行特征选择。

由于有6个特征，因此选用6位0/1进行编码，1表示选中该特征。

适应度函数的实现

示例

结果如下

有什么不对的地方欢迎大家在评论区指出。

谁能给一个C语言的遗传算法例题

程序太长了，不知道能不能贴下：

//

/ This is a simple genetic algorithm implementation where the /

/ evaluation function takes positive values only and the /

/ fitness of an individual is the same as the value of the /

/ objective function /

//

#include

#include

#include

/ Change any of these parameters to match your needs /

#define POPSIZE 50 / population size /

#define MAXGENS 1000 / max. number of generations /

#define NVARS 3 / no. of problem variables /

#define PXOVER 0.8 / probability of crossover /

#define PMUTATION 0.15 / probability of mutation /

#define TRUE 1

#define FALSE 0

int generation; / current generation no. /

int cur_best; / best individual /

FILE galog; / an output file /

struct genotype / genotype (GT), a member of the population /

{double gene[NVARS]; / a string of variables /

double fitness; / GT's fitness /

double upper[NVARS]; / GT's variables upper bound /

double lower[NVARS]; / GT's variables lower bound /

double rfitness; / relative fitness /

double cfitness; / cumulative fitness /

};

struct genotype population[POPSIZE+1]; / population /

struct genotype newpopulation[POPSIZE+1]; / new population; /

/ replaces the /

/ old generation /

/ Declaration of procedures used by this genetic algorithm /

void initialize(void);

double randval(double, double);

void evaluate(void);

void keep_the_best(void);

void elitist(void);

void select(void);

void crossover(void);

void Xover(int,int);

void swap(double , double );

void mutate(void);

void report(void);

//

/ Initialization function: Initializes the values of genes /

/ within the variables bounds. It also initializes (to zero) /

/ all fitness values for each member of the population. It /

/ reads upper and lower bounds of each variable from the /

/ input file `gadata.txt'. It randomly generates values /

/ between these bounds for each gene of each genotype in the /

/ population. The format of the input file `gadata.txt' is /

/ var1_lower_bound var1_upper bound /

/ var2_lower_bound var2_upper bound ... /

//

void initialize(void)

{FILE infile;

int i, j;

double lbound, ubound;

if ((infile = fopen("gadata.txt","r"))==NULL)

{fprintf(galog,"\nCannot open input file!\n");

exit(1);

}/ initialize variables within the bounds /

for (i = 0; i < NVARS; i++)

{fscanf(infile, "%lf",&lbound);

fscanf(infile, "%lf",&ubound);

for (j = 0; j < POPSIZE; j++)

{population[j].fitness = 0;

population[j].rfitness = 0;

population[j].cfitness = 0;

population[j].lower[i] = lbound;

population[j].upper[i]= ubound;

population[j].gene[i] = randval(population[j].lower[i],

population[j].upper[i]);

}}

fclose(infile);

}//

/ Random value generator: Generates a value within bounds /

//

double randval(double low, double high)

{double val;

val = ((double)(rand()%1000)/1000.0)(high - low) + low;

return(val);

}//

/ Evaluation function: This takes a user defined function. /

/ Each time this is changed, the code has to be recompiled. /

/ The current function is: x[1]^2-x[1]x[2]+x[3] /

//

void evaluate(void)

{int mem;

int i;

double x[NVARS+1];

for (mem = 0; mem < POPSIZE; mem++)

{for (i = 0; i < NVARS; i++)

x[i+1] = population[mem].gene[i];

population[mem].fitness = (x[1]x[1]) - (x[1]x[2]) + x[3];

}}

//

/ Keep_the_best function: This function keeps track of the /

/ best member of the population. Note that the last entry in /

/ the array Population holds a copy of the best individual /

//

void keep_the_best()

{int mem;

int i;

cur_best = 0; / stores the index of the best individual /

for (mem = 0; mem < POPSIZE; mem++)

{if (population[mem].fitness > population[POPSIZE].fitness)

{cur_best = mem;

population[POPSIZE].fitness = population[mem].fitness;

}}

/ once the best member in the population is found, copy the genes /

for (i = 0; i < NVARS; i++)

population[POPSIZE].gene[i] = population[cur_best].gene[i];

}//

/ Elitist function: The best member of the previous generation /

/ is stored as the last in the array. If the best member of /

/ the current generation is worse then the best member of the /

/ previous generation, the latter one would replace the worst /

/ member of the current population /

//

void elitist()

{int i;

double best, worst; / best and worst fitness values /

int best_mem, worst_mem; / indexes of the best and worst member /

best = population[0].fitness;

worst = population[0].fitness;

for (i = 0; i < POPSIZE - 1; ++i)

{if(population[i].fitness > population[i+1].fitness)

{if (population[i].fitness >= best)

{best = population[i].fitness;

best_mem = i;

}if (population[i+1].fitness <= worst)

{worst = population[i+1].fitness;

worst_mem = i + 1;

}}

else

{if (population[i].fitness <= worst)

{worst = population[i].fitness;

worst_mem = i;

}if (population[i+1].fitness >= best)

{best = population[i+1].fitness;

best_mem = i + 1;

}}

}/ if best individual from the new population is better than /

/ the best individual from the previous population, then /

/ copy the best from the new population; else replace the /

/ worst individual from the current population with the /

/ best one from the previous generation /

if (best >= population[POPSIZE].fitness)

{for (i = 0; i < NVARS; i++)

population[POPSIZE].gene[i] = population[best_mem].gene[i];

population[POPSIZE].fitness = population[best_mem].fitness;

}else

{for (i = 0; i < NVARS; i++)

population[worst_mem].gene[i] = population[POPSIZE].gene[i];

population[worst_mem].fitness = population[POPSIZE].fitness;

}}

//

/ Selection function: Standard proportional selection for /

/ maximization problems incorporating elitist model - makes /

/ sure that the best member survives /

//

void select(void)

{int mem, i, j, k;

double sum = 0;

double p;

/ find total fitness of the population /

for (mem = 0; mem < POPSIZE; mem++)

{sum += population[mem].fitness;

}/ calculate relative fitness /

for (mem = 0; mem < POPSIZE; mem++)

{population[mem].rfitness = population[mem].fitness/sum;

}population[0].cfitness = population[0].rfitness;

/ calculate cumulative fitness /

for (mem = 1; mem < POPSIZE; mem++)

{population[mem].cfitness = population[mem-1].cfitness +

population[mem].rfitness;

}/ finally select survivors using cumulative fitness. /

for (i = 0; i < POPSIZE; i++)

{p = rand()%1000/1000.0;

if (p < population[0].cfitness)

newpopulation[i] = population[0];

else

{for (j = 0; j < POPSIZE;j++)

if (p >= population[j].cfitness &&

p

newpopulation[i] = population[j+1];

}}

/ once a new population is created, copy it back /

for (i = 0; i < POPSIZE; i++)

population[i] = newpopulation[i];

}//

/ Crossover selection: selects two parents that take part in /

/ the crossover. Implements a single point crossover /

//

void crossover(void)

{int i, mem, one;

int first = 0; / count of the number of members chosen /

double x;

for (mem = 0; mem < POPSIZE; ++mem)

{x = rand()%1000/1000.0;

if (x < PXOVER)

{++first;

if (first % 2 == 0)

Xover(one, mem);

else

one = mem;

}}

}//

/ Crossover: performs crossover of the two selected parents. /

//

void Xover(int one, int two)

{int i;

int point; / crossover point /

/ select crossover point /

if(NVARS > 1)

{if(NVARS == 2)

point = 1;

else

point = (rand() % (NVARS - 1)) + 1;

for (i = 0; i < point; i++)

swap(&population[one].gene[i], &population[two].gene[i]);

}}

//

/ Swap: A swap procedure that helps in swapping 2 variables /

//

void swap(double x, double y)

{double temp;

temp = x;

x = y;

y = temp;

}//

/ Mutation: Random uniform mutation. A variable selected for /

/ mutation is replaced by a random value between lower and /

/ upper bounds of this variable /

//

void mutate(void)

{int i, j;

double lbound, hbound;

double x;

for (i = 0; i < POPSIZE; i++)

for (j = 0; j < NVARS; j++)

{x = rand()%1000/1000.0;

if (x < PMUTATION)

{/ find the bounds on the variable to be mutated /

lbound = population[i].lower[j];

hbound = population[i].upper[j];

population[i].gene[j] = randval(lbound, hbound);

}}

}//

/ Report function: Reports progress of the simulation. Data /

/ dumped into the output file are separated by commas /

//

void report(void)

{int i;

double best_val; / best population fitness /

double g; / g population fitness /

double stddev; / std. deviation of population fitness /

double sum_square; / sum of square for std. calc /

double square_sum; / square of sum for std. calc /

double sum; / total population fitness /

sum = 0.0;

sum_square = 0.0;

for (i = 0; i < POPSIZE; i++)

{sum += population[i].fitness;

sum_square += population[i].fitness population[i].fitness;

}g = sum/(double)POPSIZE;

square_sum = g g POPSIZE;

stddev = sqrt((sum_square - square_sum)/(POPSIZE - 1));

best_val = population[POPSIZE].fitness;

fprintf(galog, "\n%5d, %6.3f, %6.3f, %6.3f \n\n", generation,

best_val, g, stddev);

}//

/ Main function: Each generation involves selecting the best /

/ members, performing crossover & mutation and then /

/ evaluating the resulting population, until the terminating /

/ condition is satisfied /

//

void main(void)

{int i;

if ((galog = fopen("galog.txt","w"))==NULL)

{exit(1);

}generation = 0;

fprintf(galog, "\n generation best erage standard \n");

fprintf(galog, " number value fitness deviation \n");

initialize();

evaluate();

keep_the_best();

while(generation

{generation++;

select();

crossover();

mutate();

report();

evaluate();

elitist();

}fprintf(galog,"\n\n Simulation completed\n");

fprintf(galog,"\n Best member: \n");

for (i = 0; i < NVARS; i++)

{fprintf (galog,"\n var(%d) = %3.3f",i,population[POPSIZE].gene[i]);

}fprintf(galog,"\n\n Best fitness = %3.3f",population[POPSIZE].fitness);

fclose(galog);

printf("Success\n");

}//

想学遗传算法，MATLAB和C++哪种好入手一些？

具体说，c++更容易入手，因为c++更接近自然语言，而matlab里面要记很多函数的用法，知道函数有哪些参数

MATLAB是针对数学计算的，C++应用比较宽广。

MATLAB入手相对容易些。

用C#语言在Visual studio下运用遗传算法编写排课系统

遗传算法没研究过（你可以去百度文库里搜一下，很多资料的）下,语言只是个形式,任何语言写的代码终编译后的都是msil,不过简单易学的,c#.

C#吧，教程多，例子也多，语法和现在主流的语言不多。

c语言实现/遗传算法改进BP神经网络原理和算法实现怎么弄

你提供的代码是一个基本的BP神经网络训练过程。一般都是用GA训练，之后再用改进动量法继续训练，直至后达到目标。

遗传算法（Genetic Algorithm）是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索解的方法。遗传算法是从代表问题可能潜在的解集的一个种群（population）开始的，而一个种群则由经过基因（gene）编码的一定数目的个体(individual)组成。每个个体实际上是染色体(chromosome)带有特征的实体。染色体作为遗传物质的主要载体，即多个基因的，其内部表现（即基因型）是某种基因组合，它决定了个体的形状的外部表现，如黑头发的特征是由染色体中控制这一特征的某种基因组合决定的。