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();
}