开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 人工智能/神经网络 > 查看源码
sga.c
资源名称：遗传算法_VC源码.rar　[点击查看]
上传用户：helpmateqq
上传日期：2013-03-23
资源大小：86k
文件大小：19k
源码类别：

人工智能/神经网络

开发平台：

Visual C++

sga.c：源码内容
  1. /********************************************************************/
  2. /*             基于基本遗传算法的函数最优化(预选择机制)   SGA_Y.C   */
  3. /*     A Function Optimizer using Simple Genetic Algorithm          */
  4. /* developed from the Pascal SGA code presented by David E.Goldberg */
  5. /*              华南理工大学电子与信息学院   苏勇          2004年4月*/
  6. /********************************************************************/
  7. #include <stdio.h>
  8. #include <math.h>
  9. /* 全局变量 */
  10. struct individual                       /* 个体*/
  11. {
  12.     unsigned *chrom;                    /* 染色体 */
  13.     double   fitness;                   /* 个体适应度*/
  14.     double   varible;                   /* 个体对应的变量值*/   
  15.     int      xsite;                     /* 交叉位置 */
  16.     int      parent[2];                 /* 父个体  */
  17.     int      *utility;                  /* 特定数据指针变量 */
  18. };
  19. struct bestever                         /* 最佳个体*/
  20. {
  21.     unsigned *chrom;                    /* 最佳个体染色体*/
  22.     double   fitness;                   /* 最佳个体适应度 */
  23.     double   varible;                   /* 最佳个体对应的变量值 */
  24.     int      generation;                /* 最佳个体生成代 */
  25. };
  26.  struct individual *oldpop;             /* 当前代种群 */
  27.  struct individual *newpop;             /* 新一代种群 */
  28.  struct bestever bestfit;               /* 最佳个体 */
  29.  double sumfitness;                     /* 种群中个体适应度累计 */
  30.  double max;                            /* 种群中个体最大适应度 */
  31.  double avg;                            /* 种群中个体平均适应度 */
  32.  double min;                            /* 种群中个体最小适应度 */
  33.  float  pcross;                         /* 交叉概率 */
  34.  float  pmutation;                      /* 变异概率 */
  35.  int    popsize;                        /* 种群大小  */
  36.  int    lchrom;                         /* 染色体长度*/
  37.  int    chromsize;                      /* 存储一染色体所需字节数 */
  38.  int    gen;                            /* 当前世代数 */
  39.  int    maxgen;                         /* 最大世代数   */
  40.  int    run;                            /* 当前运行次数 */
  41.  int    maxruns;                        /* 总运行次数   */
  42.  int    printstrings;                   /* 输出染色体编码的判断，0 -- 不输出, 1 -- 输出 */
  43.  int    nmutation;                      /* 当前代变异发生次数 */
  44.  int    ncross;                         /* 当前代交叉发生次数 */
  46. /* 随机数发生器使用的静态变量 */
  47. static double oldrand[55];
  48. static int jrand;
  49. static double rndx2;
  50. static int rndcalcflag;
  51. /* 输出文件指针 */
  52. FILE *outfp ;
  53. /* 函数定义 */
  54. void advance_random();
  55. int flip(float);rnd(int, int);
  56. void randomize();
  57. double randomnormaldeviate();
  58. float randomperc(),rndreal(float,float);
  59. void warmup_random(float);
  60. void initialize(),initdata(),initpop();
  61. void initreport(),generation(),initmalloc();
  62. void freeall(),nomemory(char *),report();
  63. void writepop(),writechrom(unsigned *);
  64. void preselect();
  65. void statistics(struct individual *);
  66. void title(),repchar (FILE *,char *,int);
  67. void skip(FILE *,int);
  68. int select();
  69. void objfunc(struct individual *);
  70. int crossover (unsigned *, unsigned *, unsigned *, unsigned *);
  71. void mutation(unsigned *);
  74. void initialize()      /* 遗传算法初始化 */
  75. {
  76.     /* 键盘输入遗传算法参数 */
  77.     initdata();
  78.     /* 确定染色体的字节长度 */
  79.     chromsize = (lchrom/(8*sizeof(unsigned)));
  80.     if(lchrom%(8*sizeof(unsigned))) chromsize++;
  81.     /*分配给全局数据结构空间 */
  82.     initmalloc();
  83.     /* 初始化随机数发生器 */
  84.     randomize();
  85.     /* 初始化全局计数变量和一些数值*/
  86.     nmutation = 0;
  87.     ncross = 0;
  88.     bestfit.fitness = 0.0;
  89.     bestfit.generation = 0;
  90.     /* 初始化种群，并统计计算结果 */
  91.     initpop();
  92.     statistics(oldpop);
  93.     initreport();
  94. }
  96. void initdata()           /* 遗传算法参数输入 */
  97. {
  98.    char  answer[2];
  99.    popsize=30;
  100.    if((popsize%2) != 0)
  101.    {
  102. fprintf(outfp, "种群大小已设置为偶数n");
  103. popsize++;
  104.    };
  105.    lchrom=22;
  106.    printstrings=1;
  107.    maxgen=150;
  108.    pcross=0.8;
  109.    pmutation=0.005;
  110. }
  112. void initpop()           /* 随机初始化种群 */
  113. {
  114.     int j, j1, k, stop;
  115.     unsigned mask = 1;
  116.     for(j = 0; j < popsize; j++)
  117.     {
  118.         for(k = 0; k < chromsize; k++)
  119.         {
  120.             oldpop[j].chrom[k] = 0;
  121.             if(k == (chromsize-1))
  122.                 stop = lchrom - (k*(8*sizeof(unsigned)));
  123.             else
  124.                 stop =8*sizeof(unsigned);
  125.             for(j1 = 1; j1 <= stop; j1++)
  126.             {
  127.                oldpop[j].chrom[k] = oldpop[j].chrom[k]<<1;
  128.                if(flip(0.5))
  129.                   oldpop[j].chrom[k] = oldpop[j].chrom[k]|mask;
  130.             }
  131.         }
  132.         oldpop[j].parent[0] = 0;     /* 初始父个体信息 */
  133.         oldpop[j].parent[1] = 0;
  134.         oldpop[j].xsite = 0;
  135.         objfunc(&(oldpop[j]));       /* 计算初始适应度*/
  136.     }
  137. }
  139. void initreport()               /* 初始参数输出 */
  140. {
  141.     void   skip();
  142.     skip(outfp,1);
  143.     fprintf(outfp,"             基本遗传算法参数n");
  144.     fprintf(outfp," -------------------------------------------------n");
  145.     fprintf(outfp,"    种群大小(popsize)     =   %dn",popsize);
  146.     fprintf(outfp,"    染色体长度(lchrom)    =   %dn",lchrom);
  147.     fprintf(outfp,"    最大进化代数(maxgen)  =   %dn",maxgen);
  148.     fprintf(outfp,"    交叉概率(pcross)      =   %fn",pcross);
  149.     fprintf(outfp,"    变异概率(pmutation)   =   %fn",pmutation);
  150.     fprintf(outfp," -------------------------------------------------n");
  151.     skip(outfp,1);
  152.     fflush(outfp);
  153. }
  155. void generation()
  156. {
  157.   int mate1, mate2, jcross, i=0, j = 0;
  158.   /*  每代运算前进行预选 */
  159.   preselect();
  160.   /* 选择, 交叉, 变异 */
  161.   do
  162.     {
  163.       /* 挑选交叉配对 */
  164.       mate1 = select();
  165.       mate2 = select();
  166.       /* 交叉和变异 */
  167.       jcross = crossover(oldpop[mate1].chrom, oldpop[mate2].chrom, newpop[j].chrom, newpop[j+1].chrom);
  168.       mutation(newpop[j].chrom);
  169.       mutation(newpop[j+1].chrom);
  170.       /* 解码, 计算适应度 */
  171.   objfunc(&(oldpop[mate1]));
  172.   objfunc(&(oldpop[mate2]));
  173.       objfunc(&(newpop[j]));
  174.   objfunc(&(newpop[j+1]));
  175.   /* 子代全部优于父代 */
  176.   if((newpop[j].fitness>oldpop[mate1].fitness)&&(newpop[j].fitness>oldpop[mate2].fitness)&&(newpop[j+1].fitness>oldpop[mate1].fitness)&&(newpop[j+1].fitness>oldpop[mate2].fitness))
  177.   {
  178.   
  179.   }
  180.   /* 子代全部劣于父代 */
  181.   else if((newpop[j].fitness<oldpop[mate1].fitness)&&(newpop[j].fitness<oldpop[mate2].fitness)&&(newpop[j+1].fitness<oldpop[mate1].fitness)&&(newpop[j+1].fitness<oldpop[mate2].fitness))
  182.   {
  183.   for(i=0;i<chromsize;i++)
  184.   {
  185. newpop[j].chrom[i]=oldpop[mate1].chrom[i];
  186. newpop[j+1].chrom[i]=oldpop[mate2].chrom[i];
  187.   }
  188.   }
  189.   /* 子代中有一个比父代优秀 */
  190.   else
  191.   {
  192.   if(oldpop[mate1].fitness>=oldpop[mate2].fitness)
  193.   {
  194.   if(newpop[j].fitness>=newpop[j+1].fitness)
  195.   {
  196.   for(i=0;i<chromsize;i++)
  197.   {
  198.  newpop[j+1].chrom[i]=oldpop[mate1].chrom[i];
  199.   }
  200.   }
  201.   else
  202.   {
  203.   for(i=0;i<chromsize;i++)
  204.   {
  205.  newpop[j].chrom[i]=oldpop[mate1].chrom[i];
  206.   }
  207.   }
  208.   }
  209.   else
  210.   {
  211.   if(newpop[j].fitness>=newpop[j+1].fitness)
  212.   {
  213.   for(i=0;i<chromsize;i++)
  214.   {
  215.  newpop[j+1].chrom[i]=oldpop[mate2].chrom[i];
  216.   }
  217.   }
  218.   else
  219.   {
  220.   for(i=0;i<chromsize;i++)
  221.   {
  222.  newpop[j].chrom[i]=oldpop[mate2].chrom[i];
  223.   }
  224.   }
  225.   }
  226.   }
  227.   /*记录亲子关系和交叉位置 */
  228.       newpop[j].parent[0] = mate1+1;
  229.   newpop[j].xsite = jcross;
  230.   newpop[j].parent[1] = mate2+1;
  231.   newpop[j+1].parent[0] = mate1+1;
  232.   newpop[j+1].xsite = jcross;
  233.   newpop[j+1].parent[1] = mate2+1;
  234.       j = j + 2;
  235.     }
  236.   while(j < (popsize-1));
  238. }
  240. void initmalloc()              /*为全局数据变量分配空间 */
  241. {
  242.   unsigned nbytes;
  243.   char  *malloc();
  244.   int j;
  245.   /* 分配给当前代和新一代种群内存空间 */
  246.   nbytes = popsize*sizeof(struct individual);
  247.   if((oldpop = (struct individual *) malloc(nbytes)) == NULL)
  248.     nomemory("oldpop");
  249.   if((newpop = (struct individual *) malloc(nbytes)) == NULL)
  250.     nomemory("newpop");
  251.   /* 分配给染色体内存空间 */
  252.   nbytes = chromsize*sizeof(unsigned);
  253.   for(j = 0; j < popsize; j++)
  254.     {
  255.       if((oldpop[j].chrom = (unsigned *) malloc(nbytes)) == NULL)
  256. nomemory("oldpop chromosomes");
  257.       if((newpop[j].chrom = (unsigned *) malloc(nbytes)) == NULL)
  258. nomemory("newpop chromosomes");
  259.     }
  260.   if((bestfit.chrom = (unsigned *) malloc(nbytes)) == NULL)
  261.     nomemory("bestfit chromosome");
  263. }
  265. void freeall()               /* 释放内存空间 */
  266. {
  267.   int i;
  268.    for(i = 0; i < popsize; i++)
  269.     {
  270.       free(oldpop[i].chrom);
  271.       free(newpop[i].chrom);
  272.     }
  273.   free(oldpop);
  274.   free(newpop);
  275.   free(bestfit.chrom);
  276.    }
  278. void nomemory(string)        /* 内存不足，退出*/
  279.   char *string;
  280. {
  281.   fprintf(outfp,"malloc: out of memory making %s!!n",string);
  282.   exit(-1);
  283. }
  285. void report()                /* 输出种群统计结果 */
  286. {
  287.     void  repchar(), skip();
  288.     void  writepop(), writestats();
  289.     repchar(outfp,"-",80);
  290.     skip(outfp,1); 
  291.     if(printstrings == 1)
  292.     {
  293.         repchar(outfp," ",((80-17)/2));
  294.         fprintf(outfp,"模拟计算统计报告  n");
  295.         fprintf(outfp, "世代数 %3d", gen);
  296.         repchar(outfp," ",(80-28));
  297.         fprintf(outfp, "世代数 %3dn", (gen+1));
  298.         fprintf(outfp,"个体  染色体编码");
  299.         repchar(outfp," ",lchrom-5);
  300.         fprintf(outfp,"适应度    父个体 交叉位置  ");
  301.         fprintf(outfp,"染色体编码 ");
  302.         repchar(outfp," ",lchrom-5);
  303.         fprintf(outfp,"适应度n");
  304.         repchar(outfp,"-",80);
  305.         skip(outfp,1);
  306.         writepop(outfp);
  307.         repchar(outfp,"-",80);
  308.         skip(outfp,1);
  309.      }
  310.     fprintf(outfp,"第 %d 代统计: n",gen);
  311.     fprintf(outfp,"总交叉操作次数 = %d, 总变异操作数 = %dn",ncross,nmutation);
  312.     fprintf(outfp," 最小适应度：%f 最大适应度：%f  平均适应度 %fn", min,max,avg);
  313.     fprintf(outfp," 迄今发现最佳个体 =>  所在代数： %d  ", bestfit.generation);
  314.     fprintf(outfp," 适应度：%f  染色体：", bestfit.fitness);
  315.     writechrom((&bestfit)->chrom);
  316.     fprintf(outfp," 对应的变量值: %f", bestfit.varible);
  317.     skip(outfp,1);
  318.     repchar(outfp,"-",80);
  319.     skip(outfp,1);  
  320. }
  322. void writepop()
  323. {
  324.     struct individual *pind;
  325.     int j;
  326.     for(j=0; j<popsize; j++)
  327.     {
  328.         fprintf(outfp,"%3d)  ",j+1);
  329.         /* 当前代个体 */
  330.         pind = &(oldpop[j]);
  331.         writechrom(pind->chrom);
  332.         fprintf(outfp,"  %8f | ", pind->fitness);
  333.         /* 新一代个体 */
  334.         pind = &(newpop[j]);
  335.         fprintf(outfp,"(%2d,%2d)   %2d   ",
  336.         pind->parent[0], pind->parent[1], pind->xsite);
  337.         writechrom(pind->chrom);
  338.         fprintf(outfp,"  %8fn", pind->fitness);
  339.     }
  340. }
  342. void writechrom(chrom)           /* 输出染色体编码 */
  343. unsigned *chrom;
  344. {
  345.     int j, k, stop;
  346.     unsigned mask = 1, tmp;
  347.     for(k = 0; k < chromsize; k++)
  348.     {
  349.         tmp = chrom[k];
  350.         if(k == (chromsize-1))
  351.             stop = lchrom - (k*(8*sizeof(unsigned)));
  352.         else
  353.             stop =8*sizeof(unsigned);
  354.         for(j = 0; j < stop; j++)
  355.         {
  356.             if(tmp&mask)
  357.                 fprintf(outfp,"1");
  358.             else
  359.                 fprintf(outfp,"0");
  360.             tmp = tmp>>1;
  361.         }
  362.     }
  363. }
  365. void preselect()
  366. {
  367.     int j;
  368.     sumfitness = 0;
  369.     for(j = 0; j < popsize; j++) sumfitness += oldpop[j].fitness;
  370. }
  372. int select()                    /* 轮盘赌选择*/
  373. {
  374.     extern float randomperc();
  375.     float sum, pick;
  376.     int i;
  377.     pick = randomperc();
  378.     sum = 0;
  379.     if(sumfitness != 0)
  380.     {
  381.         for(i = 0; (sum < pick) && (i < popsize); i++)
  382.             sum += oldpop[i].fitness/sumfitness;
  383.     }
  384.     else
  385.         i = rnd(1,popsize);
  386.     return(i-1);
  387. }
  389. void statistics(pop)  /* 计算种群统计数据 */
  390. struct individual *pop;
  391. {
  392.     int i, j;
  393.     sumfitness = 0.0;
  394.     min = pop[0].fitness;
  395.     max = pop[0].fitness;
  396.     /* 计算最大、最小和累计适应度 */
  397.     for(j = 0; j < popsize; j++)
  398.     {
  399.         sumfitness = sumfitness + pop[j].fitness;            
  400.         if(pop[j].fitness > max) max = pop[j].fitness;        
  401.         if(pop[j].fitness < min) min = pop[j].fitness;         
  402.         /* new global best-fit individual */
  403.         if(pop[j].fitness > bestfit.fitness)
  404.   {
  405.    for(i = 0; i < chromsize; i++)
  406.     bestfit.chrom[i]      = pop[j].chrom[i];
  407.             bestfit.fitness    = pop[j].fitness;
  408.             bestfit.varible   = pop[j].varible;  
  409.             bestfit.generation = gen;
  410.   }
  411.       }
  412.     /* 计算平均适应度 */
  413.     avg = sumfitness/popsize;
  414. }
  416. void title()
  417. {
  418.   printf("SGA Optimizer Jean.Timexn");
  419. }
  421. void repchar (outfp,ch,repcount)
  422. FILE *outfp;
  423. char *ch;
  424. int repcount;
  425. {
  426.     int j;
  427.     for (j = 1; j <= repcount; j++) fprintf(outfp,"%s", ch);
  428. }
  430. void skip(outfp,skipcount)
  431. FILE *outfp;
  432. int skipcount;
  433. {
  434.     int j;
  435.     for (j = 1; j <= skipcount; j++) fprintf(outfp,"n");
  436. }
  438. void objfunc(critter)            /* 计算适应度函数值 */
  439. struct individual *critter;
  440. {
  441.     unsigned mask=1;
  442.     unsigned bitpos;
  443.     unsigned tp;
  444.     double pow(), bitpow ;
  445.     int j, k, stop;
  446.     critter->varible = 0.0;
  447.     for(k = 0; k < chromsize; k++)
  448.     {
  449.         if(k == (chromsize-1))
  450.             stop = lchrom-(k*(8*sizeof(unsigned)));
  451.         else
  452.             stop =8*sizeof(unsigned);
  453.         tp = critter->chrom[k];
  454.         for(j = 0; j < stop; j++)
  455.         {
  456.             bitpos = j + (8*sizeof(unsigned))*k;
  457.             if((tp&mask) == 1)
  458.             {
  459.                 bitpow = pow(2.0,(double) bitpos);
  460.                 critter->varible = critter->varible + bitpow;
  461.             }
  462.             tp = tp>>1;
  463.         }
  464.     }
  465.     critter->varible =-1+critter->varible*3/(pow(2.0,(double)lchrom)-1);
  466.     critter->fitness =critter->varible*sin(critter->varible*10*atan(1)*4)+2.0;
  467. }
  469. void  mutation(unsigned *child)   /*变异操作*/
  470. {
  471.     int j, k, stop;
  472.     unsigned mask, temp = 1;
  473.     for(k = 0; k < chromsize; k++)
  474.     {
  475.         mask = 0;
  476.         if(k == (chromsize-1))
  477.             stop = lchrom - (k*(8*sizeof(unsigned)));
  478.         else
  479.             stop = 8*sizeof(unsigned);
  480.         for(j = 0; j < stop; j++)
  481.         {
  482.             if(flip(pmutation))
  483.             {
  484.                 mask = mask|(temp<<j);
  485.                 nmutation++;
  486.             }
  487.         }
  488.         child[k] = child[k]^mask;
  489.     }
  490. }
  492. int crossover (unsigned *parent1, unsigned *parent2, unsigned *child1, unsigned *child2)
  493. /* 由两个父个体交叉产生两个子个体 */
  494. {
  495.     int j, jcross, k;
  496.     unsigned mask, temp;
  497.     if(flip(pcross))
  498.     {
  499.         jcross = rnd(1 ,(lchrom - 1));/* Cross between 1 and l-1 */
  500.         ncross++;
  501.         for(k = 1; k <= chromsize; k++)
  502.         {
  503.             if(jcross >= (k*(8*sizeof(unsigned))))
  504.             {
  505.                 child1[k-1] = parent1[k-1];
  506.                 child2[k-1] = parent2[k-1];
  507.             }
  508.             else if((jcross < (k*(8*sizeof(unsigned)))) && (jcross > ((k-1)*(8*sizeof(unsigned)))))
  509.             {
  510.                 mask = 1;
  511.                 for(j = 1; j <= (jcross-1-((k-1)*(8*sizeof(unsigned)))); j++)
  512.                 {
  513.                     temp = 1;
  514.                     mask = mask<<1;
  515.                     mask = mask|temp;
  516.                 }
  517.                 child1[k-1] = (parent1[k-1]&mask)|(parent2[k-1]&(~mask));
  518.                 child2[k-1] = (parent1[k-1]&(~mask))|(parent2[k-1]&mask);
  519.             }
  520.             else
  521.             {
  522.                 child1[k-1] = parent2[k-1];
  523.                 child2[k-1] = parent1[k-1];
  524.             }
  525.         }
  526.     }
  527.     else
  528.     {
  529.         for(k = 0; k < chromsize; k++)
  530.         {
  531.             child1[k] = parent1[k];
  532.             child2[k] = parent2[k];
  533.         }
  534.         jcross = 0;
  535.     }
  536.     return(jcross);
  537. }
  539. void advance_random()          /* 产生55个随机数 */
  540. {
  541.     int j1;
  542.     double new_random;
  543.     for(j1 = 0; j1 < 24; j1++)
  544.     {
  545.         new_random = oldrand[j1] - oldrand[j1+31];
  546.         if(new_random < 0.0) new_random = new_random + 1.0;
  547.         oldrand[j1] = new_random;
  548.     }
  549.     for(j1 = 24; j1 < 55; j1++)
  550.     {
  551.         new_random = oldrand [j1] - oldrand [j1-24];
  552.         if(new_random < 0.0) new_random = new_random + 1.0;
  553.         oldrand[j1] = new_random;
  554.     }
  555. }
  557. int flip(float prob)          /* 以一定概率产生0或1 */
  558. {
  559.     float randomperc();
  560.     if(randomperc() <= prob)
  561.         return(1);
  562.     else
  563.         return(0);
  564. }
  566. void randomize()            /* 设定随机数种子并初始化随机数发生器 */
  567. {
  568.     float randomseed;
  569.     int j1;
  570.     for(j1=0; j1<=54; j1++)
  571.       oldrand[j1] = 0.0;
  572.     jrand=0;
  573.     randomseed=0.5;
  574.     warmup_random(randomseed);
  575. }
  577. double randomnormaldeviate()         /* 产生随机标准差 */
  578. {
  579.     double sqrt(), log(), sin(), cos();
  580.     float randomperc();
  581.     double t, rndx1;
  582.     if(rndcalcflag)
  583.     {   rndx1 = sqrt(- 2.0*log((double) randomperc()));
  584.         t = 6.2831853072 * (double) randomperc();
  585.         rndx2 = rndx1 * sin(t);
  586.         rndcalcflag = 0;
  587.         return(rndx1 * cos(t));
  588.     }
  589.     else
  590.     {
  591.         rndcalcflag = 1;
  592.         return(rndx2);
  593.     }
  594. }
  596. float randomperc()            /*与库函数random()作用相同, 产生[0,1]之间一个随机数 */
  597. {
  598.     jrand++;
  599.     if(jrand >= 55)
  600.     {
  601.         jrand = 1;
  602.         advance_random();
  603.     }
  604.     return((float) oldrand[jrand]);
  605. }
  607. int rnd(low, high)           /*在整数low和high之间产生一个随机整数*/
  608. int low,high;
  609. {
  610.     int i;
  611.     float randomperc();
  612.     if(low >= high)
  613.         i = low;
  614.     else
  615.     {
  616.         i = (randomperc() * (high - low + 1)) + low;
  617.         if(i > high) i = high;
  618.     }
  619.     return(i);
  620. }
  623. void warmup_random(float random_seed)       /* 初始化随机数发生器*/
  624. {
  625.     int j1, ii;
  626.     double new_random, prev_random;
  628.     oldrand[54] = random_seed;
  629.     new_random = 0.000000001;
  630.     prev_random = random_seed;
  631.     for(j1 = 1 ; j1 <= 54; j1++)
  632.     {
  633.         ii = (21*j1)%54;
  634.         oldrand[ii] = new_random;
  635.         new_random = prev_random-new_random;
  636.         if(new_random<0.0) new_random = new_random + 1.0;
  637.         prev_random = oldrand[ii];
  638.     }
  639.     advance_random();
  640.     advance_random();
  641.     advance_random();
  642.     jrand = 0;
  643. }
  646. main(argc,argv)           /*  主程序  */
  647. int argc;
  648. char *argv[];
  649. {
  650.     struct individual *temp;
  651.     FILE   *fopen();
  652.     void   title();
  653.     char   *malloc();
  654.     //if()
  655. argv[1]="output";
  656. if((outfp = fopen(argv[1],"w")) == NULL)
  657.         {
  658.            fprintf(stderr,"Cannot open output file %sn",argv[1]);
  659.             exit(-1);
  660.         }
  661.      title();
  662.      maxruns=10;
  663.      for(run=1; run<=maxruns; run++)
  664.     {
  665.         initialize();
  666.         for(gen=0; gen<maxgen; gen++)
  667.         {
  668.          fprintf(outfp,"n第 %d / %d 次运行: 当前代为 %d, 共 %d 代n", run,maxruns,gen,maxgen);
  669.             /* 产生新一代 */
  670.             generation();
  671.             /* 计算新一代种群的适应度统计数据 */
  672.             statistics(newpop);
  673.             /* 输出新一代统计数据 */
  674.             report();
  675.             temp = oldpop;
  676.             oldpop = newpop;
  677.             newpop = temp;
  678.         }
  679.         freeall();
  680.     }
  681. }