vc算法

Ⅰ VC++ 算法。

没有做过这方面的开发，不过听着题目蛮好玩的。
我想，可以将跳舞分为动作、强度和节奏 三部分，其中动作指模型运行的一组序列，强度指完成动作的幅度，节奏控制这组序列变化的速度。这三个因素中，动作应该是预先设置好的，强度和节奏是控制模型的变量。
接着只要想办法从音乐信号中分离强度和节奏，这应该就和FFT算法衔接上了吧

Ⅱ vc算法,若转子磁链小怎么控制，若转速偏高，又如何控制

关于矢量控制，通俗理解是：
1. 先把电机想象成2块飞速旋转磁铁，定子磁铁和转子磁铁。进一步可以引申为定子磁场和转子磁场。
2. 电机的电磁转矩与定子磁场强度、转子磁场强度、2块磁铁之间的夹角的正弦成正比。关于这一点不难理解，两块磁铁对齐的时候（0度，sin0=0;），不存在电磁转矩；两块磁铁相差90度的时候（sin90=1;），电磁转矩达到顶峰； 3. 接下来控制的目标就是：
1）稳定其中的一个旋转磁场的强度（恒定磁场）； 2） 控制磁铁之间角度为90度（磁场定向FOC）；
3） 控制另一个磁场（受控磁场）的强度以达到控制电磁转矩大小（力矩控制）。 4. 关于坐标变换的物理意义（以同步电机为例）：
1）在电机不失步的情况下，可以认为两个磁极之间相对静止，最多在夹角0——90度之间移动。 2）既然交流电产生的是一个旋转磁场，那么自然可以把它想象成一个直流电产生的恒磁场，只不过这个恒磁场处于旋转当中。
3）如果恒磁场对应的直流电流产生的磁场强度，与对应交流电产生的磁场强度相等，就可以认为两者等同。
4）坐标变换基于以上认知，首先认为观察者站在恒定定磁场上并随之运转，观察被控磁场的直流电线圈电流及两个磁场之间的夹角。
5）实际的坐标变化计算出的结果有两个，直轴电流Id和交轴电流Iq。通过Id和Iq可以算出两者的矢量和（总电流），及两个磁场之间的夹角。
6）直轴电流Id是不出力的，交轴电流Iq是产生电磁转矩关键因素。 5. 对于交流同步隐极电动机：
1） 其转子磁场是恒定的。
2） 转子的当前磁极位置用旋转编码器实时检测。
3） 定子磁极（旋转磁场）的位置从A相轴线为起点，由变频器所发的正弦波来决定。
4） 实际上先有定子磁场的旋转，然后才有转子磁场试图与之对齐而产生的跟随。
5） 计算出转子磁场与A相轴线之间的偏差角度。
6） 通过霍尔元件检测三相定子电流，以转子磁场与A相轴线之间的偏差角度作为算子（相当于观察者与转子磁场同步旋转），通过坐标变换分解出定子旋转磁场中与转子磁极对齐的分量（直轴电流Id），产生转矩的分量（交轴电流Iq）。
7） 定子电流所产生旋转磁场与观察者基本同步，最多在夹角0——90度之间移动。移动量是多少，会体现在直轴电流Id、交轴电流Iq的数值对比上。
8） 驱动器通过前面的速度环的输出产生电流环的给定，通过第6）条引入电流环的反馈Iq，通过PI控制产生Iq输出。
9） 设定Id=0。这一点不难理解，使两个磁极对齐的电流我们是不需要的。通过这一点，我们实现了磁场定向FOC（控制磁铁之间角度为90度）。
10） 计算出了Iq, Id=0。引入偏差角度算子通过坐标反变换变换产生了三相电流的输出。 11） 当Iq>0, 定子旋转磁场对转子磁场的超前90度，电磁转矩依靠两个磁场之间异性相吸的原理来产生，这时候电磁转矩起到加速的作用。
12） 当Iq<0, 定子旋转磁场对转子磁场的仍然超前90度，但是定子磁场的N、S极调换了一下，电磁转矩依靠两个磁场之间同性相排斥的原理来产生，这时候电磁转矩起到减速制动的作用。

Ⅲ VC与算法的实现

在VC中画图 画圆是最基本的操作 可以直接调用API函数来实现。但是要画出自己定义的图象，需要自己定义画笔 画刷 然后用算法来重新给画笔 画刷进行复制等工作。 主要使用的CDC 等类。 比较傻瓜的就是定义一个按纽， 然后在按纽里面的函数 开始画就行了。

Ⅳ VC中值滤波快速算法

unsigned char WINAPI GetMedianNum(unsigned char * bArray, int iFilterH,int iFilterW)
{
/* unsigned char m = mid(
mid(bArray[0],bArray[1],bArray[2]),
mid(bArray[3],bArray[4],bArray[5]),
mid(bArray[6],bArray[7],bArray[8]));
return m;*/
// 循环变量
int i;
int j;
int k;
// 中间变量
unsigned char bTemp;
int iFilterLen=iFilterH*iFilterW;
float average=0;//用于均值加速
//求均值
for (i=0;i<iFilterLen;i++)
{
average+=bArray[i];
}
average=average/iFilterLen;
unsigned char pixel_mid;
pixel_mid=bArray[(iFilterH-1)/2*iFilterW+(iFilterW-1)/2];//滤波窗口中心的取中值前的像素值

if (abs(average-pixel_mid)>10) //均值加速，其中“10”为原中值和均值之差，根据你的实际情况自行设置大小
//if(1) //不用均值加速时选此
{
//超快速中值法（本质就是伪中值法）
//行排列
if (0)
{
for (k = 0; k < iFilterH; k ++)
{
for (j = 0; j < iFilterH-1; j ++)
{
for (i = 0; i < iFilterW-1-j; i++)
{
number++;
if (bArray[i+iFilterH*k] > bArray[i+iFilterH*k+1])
{ // 互换
bTemp = bArray[i+iFilterH*k];
bArray[i+iFilterH*k] = bArray[i+iFilterH*k+1];
bArray[i+iFilterH*k+1] = bTemp;
}
}

还有什么疑问，把邮箱发给我。

Ⅳ vc环境 最短路径算法

单源最短路径算法---Dijkstra算法
转自:http://space.flash8.net/space/html/07/14107_itemid_400760.html

算法介绍
Dijkstra算法是由荷兰计算机科学家艾兹格·迪科斯彻发现的。算法解决的是有向图中最短路径问题。

举例来说，如果图中的顶点表示城市，而边上的权重表示着城市间开车行经的距离。 Dijkstra算法可以用来找到两个城市之间的最短路径。

Dijkstra 算法的输入包含了一个有权重的有向图G，以及G中的一个来源顶点S。我们以V表示G中所有顶点的集合。每一个图中的边，都是两个顶点所形成的有序元素对。 (u,v)表示从顶点u到v有路径相连。我们以E所有边的集合，而边的权重则由权重函数w: E → [0, ∞]定义。因此，w(u,v)就是从顶点u到顶点v的非负花费值(cost)。边的花费可以想象成两个顶点之间的距离。任两点间路径的花费值，就是该路径 上所有边的花费值总和。已知有V中有顶点s及t，Dijkstra算法可以找到s到t的最低花费路径(i.e. 最短路径)。这个算法也可以在一个图中，找到从一个顶点s到任何其他顶点的最短路径。

算法描述
这个算法是通过为每个顶点v保留目前为止所找到的从s到v的最短路径来工作的。 初始时，源点s的路径长度值被赋为0（d[s]=0），同时把所有其他顶点的路径长度设为无穷大，即表示我们不知道任何通向这些顶点的路径（对于V中所有 顶点v除s外d[v]= ∞）。当算法结束时，d[v]中储存的便是从s到v的最短路径，或者如果路径不存在的话是无穷大。 Dijstra算法的基础操作是边的拓展：如果存在一条从u到v的边，那么从s到u的最短路径可以通过将边(u,v)添加到尾部来拓展一条从s到v的路 径。这条路径的长度是d[u]+w(u,v)。如果这个值比目前已知的d[v]的值要小，我们可以用新值来替代当前d[v]中的值。拓展边的操作一直执行 到所有的d[v]都代表从s到v最短路径的花费。这个算法经过组织因而当d[u]达到它最终的值的时候没条边(u,v)都只被拓展一次。

算法维护两个顶点集S和Q。集合S保留了我们已知的所有d[v]的值已经是最短路径的值顶点，而集合Q则保留其他所有顶点。集合S初始状态为空，而后每一步 都有一个顶点从Q移动到S。这个被选择的顶点是Q中拥有最小的d[u]值的顶点。当一个顶点u从Q中转移到了S中，算法对每条外接边(u,v)进行拓展。

伪码
在下面的算法中,u:=Extract_Min(Q)在在顶点集Q中搜索有最小的d[u]值的顶点u。这个顶点被从集合Q中删除并返回给用户。

function Dijkstra(G, w, s)

// 初始化
for each vertex v in V[G] {
d[v] := infinity
previous[v] := undefined
d[s] := 0
}

S := empty set
Q := set of all vertices

while Q is not an empty set { // Dijstra算法主体
u := Extract_Min(Q)
S := S union {u}
for each edge (u,v) outgoing from u
if d[v] > d[u] + w(u,v) // 拓展边(u,v)
d[v] := d[u] + w(u,v)
previous[v] := u
}

如果我们只对在s和t之间寻找一条最短路径的话，我们可以在第9行添加条件如果满足u=t的话终止程序。

现在我们可以通过迭代来回溯出s到t的最短路径

1 S := empty sequence
2 u := t
3 while defined u
4 insert u to the beginning of S
5 u := previous[u]

现在序列S就是从s到t的最短路径的顶点集.

时间复杂度
我们可以用大O符号将Dijkstra算法的运行时间表示为边数m和顶点数n的函数。

Dijkstra算法最简单的实现方法是用一个链表或者数组来存储所有顶点的集合Q,所以搜索Q中最小元素的运算(Extract-Min(Q))只需要线性搜索Q中的所有元素。这样的话算法的运行时间是O(n2)。

对 于边数少于n2稀疏图来说，我们可以用邻接表来更有效的实现Dijkstra算法。同时需要将一个二叉堆或者斐波纳契堆用作优先队列来寻找最小的顶点 (Extract-Min)。当用到二叉堆的时候，算法所需的时间为O((m+n)log n)，斐波纳契堆能稍微提高一些性能，让算法运行时间达到O(m + n log n)。

相关问题和算法
在Dijkstra 算法的基础上作一些改动，可以扩展其功能。例如，有时希望在求得最短路径的基础上再列出一些次短的路径。为此，可先在原图上计算出最短路径，然后从图中删 去该路径中的某一条边，在余下的子图中重新计算最短路径。对于原最短路径中的每一条边，均可求得一条删去该边后子图的最短路径，这些路径经排序后即为原图 的一系列次短路径。

OSPF（open shortest path first, 开放最短路径优先）算法是Dijkstra算法在网络路由中的一个具体实现。

与Dijkstra算法不同，Bellman-Ford算法可用于具有负花费边的图，只要图中不存在总花费为负值且从源点 s 可达的环路（如果有这样的环路，则最短路径不存在，因为沿环路循环多次即可无限制的降低总花费）。

与最短路径问题有关的一个问题是旅行商问题(traveling salesman problem)，它要求找出通过所有顶点恰好一次且最终回到源点的最短路径。该问题是NP难的；换言之，与最短路径问题不同，旅行商问题不太可能具有多项式时间算法。

如果有已知信息可用来估计某一点到目标点的距离，则可改用A*算法 ，以减小最短路径的搜索范围。

另外，用于解决最短路径问题的算法被称做“最短路径算法”， 有时被简称作“路径算法”。 最常用的路径算法有：
Dijkstra算法
A*算法
SPFA算法
Bellman-Ford算法
Floyd-Warshall算法
Johnson算法
所谓单源最短路径问题是指：已知图G＝（V，E），我们希望找出从某给定的源结点S∈V到V中的每个结点的最短路径。
首先，我们可以发现有这样一个事实：如果P是G中从vs到vj的最短路，vi是P中的一个点，那么，从vs沿P到vi的路是从vs到vi的最短路。

Ⅵ VC++一个算法问题

CString串可以当作char s[]来处理。

1、从s[0]开始，查找冒号":"，找到后，此位置当作返回串的首地址。

2、继续往后找，找到""就更换为"/"，知道串尾。

/*

s1改动前:E: mareasrcarea.txt

s1改动后::/nm/area/src/area.txt

s2改动前:E: mschoolsrcschool.txt

s2改动后::/nm/school/src/school.txt

Press any key to continue

*/

#include<stdio.h>

char*Change(chars[]){
	inti=0,pos=0;
	while(s[i]){
		if(s[i]==':'){
			pos=i;
			break;
		}
		++i;
	}
	while(s[i]){
		if(s[i]=='\'){//不能用''
			s[i]='/';
		}
		++i;
	}
	returns+pos;
}

intmain(){
	chars1[]="E:\nm\area\src\area.txt";
	chars2[]="E:\nm\school\src\school.txt";
	printf("s1改动前:%s
",s1);
	printf("s1改动后:%s
",Change(s1));
	printf("s2改动前:%s
",s2);
	printf("s2改动后:%s
",Change(s2));
	return0;
}

Ⅶ vc时间算法

将字符串转换成数字，再进行比较，
像这样太长的串，可以分成两段或三段再进行比较，
字符串转数字，可以使用函数atoi

Ⅷ 关于VC图形编程中的算法

有个专门的科目是图形学的，里面全是研究些如何处理一些2D或3D图形的问题
（包括绘制，碰撞之类的）

Ⅸ VC++ 算法 x+=a 这个算法是怎么算的

x+=a是x=x+a的简略写法

Ⅹ vc程序设计（遗传算法）

/**************************************************************/
/* 基于基本遗传算法的函数最优化 */
/* 同济大学计算机系 王小平 2000年5月 */
/**************************************************************/

#include<stdio.h>
#include<stdlib.h>
#include<graphics.h>
#include<math.h>
#include<time.h>
#include<string.h>
#include "graph.c"
#include "operator.c"

#define POP_SIZE 25 /* 种群大小 */
#define G_LENGTH 8 /* 染色体长度 */
#define C_RATE 0.2 /* 交叉概率 */
#define M_RATE 0.01 /* 变异概率 */
#define XMAX 255 /* 函数变量最大值 */
#define X1 350 /* 函数图形区窗口左上点X坐标 */
#define Y1 40 /* 函数图形区窗口左上点Y坐标 */
#define XR1 255 /* 函数图形区窗口长度 */
#define YR1 200 /* 函数图形区窗口高度 */
#define X2 360 /* 适应度图形区窗口左上点X坐标 */
#define Y2 280 /* 适应度图形区窗口左上点Y坐标 */
#define XR2 250 /* 适应度图形区窗口长度 */
#define YR2 100 /* 适应度图形区窗口宽度 */
#define STEP 2 /* 适应度图形区X方向步长 */

void initialize_gene(gene,pop_size,g_length)
/* 种群中个体遗传基因型的初始化 */
unsigned char *gene; /* 遗传基因 */
int pop_size; /* 种群大小 */
int g_length; /* 个体染色体长度 */
{
int i,j;
randomize();
for(i=0;i<pop_size;i++)
for(j=0;j<g_length;j++)
*(gene+i*g_length+j)=random(2);
}

int gene_to_pheno(gene,g_length)
/* 基因型到表现型的变换--解码 */
unsigned char *gene; /* 基因型 */
int g_length; /* 染色体长度 */
{
int i,pheno;
pheno=0;
for(i=0;i<g_length;i++)
pheno=pheno*2+*(gene+i);
return(pheno);
}

void calc_fitness(gene,fitness,pop_size,g_length,func, max_fit,avg_fit)
/* 计算种群中个体的适应度 */
unsigned char *gene; /* 个体的遗传基因 */
double *fitness; /* 个体的适应度 */
double *func; /* 评价函数 */
double *max_fit,*avg_fit; /* 最大适应度与平均适应度 */
int pop_size; /* 种群大小 */
int g_length; /* 个体染色体长度 */
{
unsigned char *g; /* 个体的遗传基因指针变量 */
int pheno; /* 个体的表现型 */
int i,j;
double f;
*max_fit=0.0;
*avg_fit=0.0;
f=(double)pop_size;
for(i=0;i<pop_size;i++)
{
g=gene+i*g_length;
pheno=gene_to_pheno(g,g_length);
*(fitness+i)=*(func+pheno);
if(*(fitness+i)>*max_fit)
*max_fit=*(fitness+i);
*avg_fit=*avg_fit+*(fitness+i)/f;
}
}

void sga_reproction(gene,fitness,new_gene,new_fitness,pop_size,g_length)
/* 基于个体的适应度评价进行新一代个体的选择(轮盘赌方法)，选择后分别将新的基因型和适应度代入到新个体中 */
unsigned char *gene; /* 当前代的个体遗传基因型 */
unsigned char *new_gene; /* 新一代的个体遗传基因型 */
double *fitness; /* 当前代的个体适应度 */
double *new_fitness; /* 新一代的个体适应度 */
int pop_size; /* 种群大小 */
int g_length; /* 染色体长度 */
{
double sum_of_fitness;
double border;
double r; /* 轮盘上的选择位置变量 */
int i,j;
int num;
sum_of_fitness=0.0;
for(i=0;i<pop_size;i++) /* 轮盘赌的选择循环 */
sum_of_fitness=sum_of_fitness+*(fitness+i);
for(i=0;i<pop_size;i++)
{
r=sum_of_fitness*(random(10001)/10000.0);
num=0;
border=*fitness;
while(border<r)
{
num++;
border=border+*(fitness+num);
}
for(j=0;j<g_length;j++)
*(new_gene+i*g_length+j)=*(gene+num*g_length+j);
*(new_fitness+i)=*(fitness+num);
}
}

void sga_crossover(gene,pop_size,g_length,c_rate)
/* 基本遗传算法的交叉操作--单点交叉 */
unsigned char *gene; /* 遗传基因 */
int pop_size; /* 种群大小 */
int g_length; /* 个体染色体长度 */
double c_rate; /* 交叉概率 */
{
unsigned char *gene1; /* 父个体1的遗传基因指针变量 */
unsigned char *gene2; /* 父个体1的遗传基因指针变量 */
unsigned char work; /* 中间变量 */
int i,j;
int c_pos; /* 交叉位置变量 */
double r; /* 随机数变量 */
for(i=0;i<pop_size-1;i=i+2)
{
r=random(10001)/10000.0;
if(r<=c_rate)
{
gene1=gene+g_length*i;
gene2=gene1+g_length;
c_pos=random(g_length-2)+1;
for(j=c_pos;j<g_length;j++) /* 两个父个体之间部分遗传基因的交换 */
{ work=*(gene1+j);
*(gene1+j)=*(gene2+j);
*(gene2+j)=work;
}
}
}
}

void sga_mutation(gene,pop_size,g_length,m_rate)
/* 基本遗传算法的变异操作--个体遗传基因按小概率翻转 */
unsigned char *gene; /* 遗传基因 */
int pop_size; /* 种群大小 */
int g_length; /* 染色体长度 */
double m_rate; /* 变异概率 */
{
int i,j;
double r;
for(i=0;i<pop_size;i++)
{
for(j=0;j<g_length;j++)
r=random(10001)/10000.0;
if(r<=m_rate) /* 变异发生判断 */
{
if ( *(gene+g_length*i+j)==0)
*(gene+g_length*i+j)=1;
else
*(gene+g_length*i+j)=0;
}
}
}

void make_function(func,xmax)
/* 生成一个函数, 用于最优化计算的目标函数(最大化) */
/* f=∑ai*sin(x* bi+ci) 其中 ai∈[0, 0.35]的均匀随机数
bi∈[2*pi, 5*2*pi] /xmax的均匀随机数
ci∈[0, 2*pi]的均匀随机数
x∈[0,xmax]为优化变量
i=1,2,3 */
double *func; /* 函数值 */
int xmax; /* 变量最大值 <XMAX */
{
int x,i;
double a[3],b[3],c[3];
double pi=3.141592;
double fxmax,fx,f_value;
double f_min,f_max,f_mid,f_range;
double dbl;
randomize();
fxmax=(double)xmax;
for(i=0;i<3;i++) /* 优化函数为三个三角函数之和 */
{
a[i]=0.35*(random(10001)/10000.0);
b[i]=(4*(random(10001)/10000.0)+1)*2.0*pi/fxmax;
c[i]=2.0*pi*(random(10001)/10000.0);
}
f_min=1.0;
f_max=0.0;
for(x=0;x<=xmax;x++) /* 将优化函数正规化为[0,1]区间数 */
{
fx=(double)x;
f_value=0.0;
for(i=0;i<3;i++)
{
dbl=b[i]*fx+c[i];
f_value=f_value+a[i]*sin(dbl);
}
f_value=f_value+0.5;
if(f_value>f_max) f_max=f_value;
if(f_value<f_min) f_min=f_value;
*(func+x)=(double)f_value;
}
f_range=f_max-f_min;
f_mid=(f_max+f_min)/2.0;
for(x=0;x<=xmax;x++)
{
f_value=(*(func+x)-f_mid)/f_range+0.5;
if(f_value>1.0) f_value=1.0;
else if(f_value<0.0) f_value=0.0;
*(func+x)=f_value;
}
}

void g_draw_func(func,xmax)
/* 绘制优化函数的图形 */
double *func; /* 函数值 */
int xmax; /* 变量最大值 */
{
int x,y,x_old,y_old,i;
double f;
g_rectangle(X1+1,Y1+1,X1+XR1-1,Y1+YR1-1,0,1);
g_rectangle(X1+1,Y1-12,X1+XR1,Y1-1,8,1);
g_rectangle(X1,Y1,X1+XR1,Y1+YR1,6,0);
x_old=X1;
y_old=Y1+YR1-(int)(*func*YR1);
f=XR1/(double)xmax;
for(i=1;i<=xmax;i++)
{
x=X1+(int)(i*f);
y=Y1+YR1-(int)(*(func+i)*YR1);
g_line(x_old,y_old,x,y,12);
x_old=x;
y_old=y;
}
}

void g_init_grph(func,xmax)
/* 初始化画面的图形 */
double *func; /* 函数值 */
int xmax; /* 变量最大值 */
{
int x,y,x_old,y_old,i;
char c[5];
/*初始化函数图形区*/
g_rectangle(320,0,639,399,8,1);
g_rectangle(321,1,638,16,8,1);
disp_hz16("基于基本遗传算法的函数最优化",370,1,15);
disp_hz16("g(x)",X1-30,Y1-18,15);
disp_hz16("1.0",X1-30,Y1,15);
disp_hz16("0",X1-10,Y1+YR1,15);
disp_hz16("x",X1+XR1+10,Y1+YR1-20,15);
disp_hz16("XMAX",X1+XR1-10,Y1+YR1,15);
g_draw_func(func,xmax);
/* 初始化适应度图形区 */
g_rectangle(X2,Y2,X2+XR2,Y2+YR2,0,1);
g_rectangle(X2,Y2,X2+XR2,Y2+YR2,6,0);
setcolor(15);
disp_hz16("最大适应度",X2+5,Y2-18,15);
g_line(X2+90,Y2-10,X2+110,Y2-10,11);
setcolor(15);
disp_hz16("平均适应度",X2+120,Y2-18,15);
g_line(X2+205,Y2-10,X2+225,Y2-10,9);
setcolor(15);
disp_hz16("世代数",X2+168,Y2+YR2+10,15);
g_text(X2-30,Y2,15,"1.0");
/* g_text(X2-30,Y2+YR2,15,"0.0");*/
}

void g_plot_grph(num,gene,fitness,pop_size,g_length,func, xmax,max_fit,m_f_old,avg_fit,a_f_old,gen_num)
/* 随世代进化更新图形 */
unsigned char *gene; /* 遗传基因 */
double *fitness; /* 适应度 */
double *func; /* 函数值 */
double max_fit,m_f_old; /* 当前代最大适应度，上一代最大适应度 */
double avg_fit,a_f_old; /* 当前代平均适应度，上一代平均适应度 */
int num; /* 当前世代数 */
int pop_size; /* 种群大小 */
int g_length; /* 染色体长度 */
int xmax; /* 变量最大值 */
int gen_num; /* 最大世代数 */
{
int i,j,x,y,x_old,y_old;
double f;
unsigned char *g;
char c[10];
/* 显示当前世代种群中个体的遗传基因 */
if(num==gen_num-1)
{
for(i=0;i<pop_size;i++)
{
printf("Indv.%2d:",i+1);
for(j=0;j<g_length;j++)
printf("%d",*(gene+i*g_length+j));
printf("==>Fitness %.4f\n",*(fitness+i));
}
printf("Max_fit=%f \n",max_fit);
printf("Avg_fit=%f \n",avg_fit);
}
/* 显示个体在函数图形区中的位置 */
g_draw_func(func,xmax);
f=XR1/(double)xmax;
for(i=0;i<pop_size;i++)
{
g=gene+i*g_length;
j=gene_to_pheno(g,g_length);
x=X1+(int)(j*f);
y=Y1+YR1-*(func+j)*YR1;
g_line(x,y-10,x,y,15);
}
/* 适应度曲线的更新 */
if(num!=1 && num<=XR2/STEP)
{
if(num%10==0) /* 每隔10代更新一次 */
{
x=X2+(num-1)*STEP;
g_line(x,Y2+1,x,Y2+YR2-1,1);
sprintf(c,"%d",num);
if(num<100 || num%20==0)
g_text(x-8,Y2+YR2,15,c);
}
x_old=X2+(num-1)*STEP;
x=x_old+STEP;
y_old=Y2+YR2-(int)(m_f_old*YR2);
y=Y2+YR2-(int)(max_fit*YR2);
g_line(x_old,y_old,x,y,11);
y_old=Y2+YR2-(int)(a_f_old*YR2);
y=Y2+YR2-(int)(avg_fit*YR2);
g_line(x_old,y_old,x,y,9);
}
}

void generation(gene,fitness,pop_size,g_length, c_rate,m_rate,new_gene,new_fitness,func,xmax)
/* 世代进化的模拟 */
unsigned char *gene; /* 当前世代的个体遗传基因型 */
unsigned char *new_gene; /* 新一代的个体遗传基因型 */
double *fitness; /* 当前世代的个体适应度 */
double *new_fitness; /* 新一代的个体适应度 */
double *func; /* 优化函数 */
double c_rate,m_rate; /* 交叉概率和变异概率 */
int pop_size, g_length; /* 种群大小与染色体长度 */

{ int gen_max; /* 最大模拟世代数 */
int i,j,k;
double max_fit,avg_fit; /* 当前代最大适应度和平均适应度 */
double m_f_old,a_f_old; /* 新一代最大适应度和平均适应度 */
char choice[3];
setcolor(15);
disp_hz16("输入最大模拟世代数:",10,1,20);
gscanf(170,1,4,0,3,"%s",choice);
gen_max=atoi(choice);
m_f_old=0.0;
a_f_old=0.0;
for(i=0;i<gen_max;i++)
{
if(i==gen_max-1)
{
printf("\n");
printf("************Gen.%d*************\n",i+1);
}
calc_fitness(gene,fitness,pop_size,g_length,func,
&max_fit,&avg_fit);
sga_reproction(gene,fitness,new_gene,new_fitness,
pop_size,g_length);
for(j=0;j<pop_size;j++)
{
*(fitness+j)=*(new_fitness+j);
for(k=0;k<g_length;k++)
*(gene+g_length*j+k)=*(new_gene+g_length*j+k);
}
sga_crossover(gene,pop_size,g_length,c_rate);
sga_mutation(gene,pop_size,g_length,m_rate);
g_plot_grph(i,gene,fitness,pop_size,g_length,func,
xmax,max_fit,m_f_old,avg_fit,a_f_old,gen_max);
m_f_old=max_fit;
a_f_old=avg_fit;
}
}

main() /* 主程序 */
{
/*当前代的个体遗传基因型与新一代的个体遗传基因型 */
unsigned char gene[POP_SIZE][G_LENGTH], new_gene[POP_SIZE][G_LENGTH];
/*当前代的个体适应度与新一代个体的适应度 */
double fitness[POP_SIZE], new_fitness[POP_SIZE];
/* 优化函数 */
double func[XMAX+1];
/* 初始化图形设置 */
g_init();
/* 生成优化函数 */
make_function(func,XMAX);
/* 初始化显示画面 */
g_init_grph(func,XMAX);
/* 初始化种群 */
initialize_gene(gene,POP_SIZE,G_LENGTH);
/* 世代进化模拟 */
generation(gene,fitness,POP_SIZE,G_LENGTH,
C_RATE,M_RATE,new_gene,new_fitness,func,XMAX);
setcolor(9);
disp_hz16("回车键结束",350,430,20);
getch();

}