1.int()函数和INT()函数的源码区别有哪些?
2.数字IC异步FIFO设计详解（含源码）
3.计算机的补码原码问题
4.int()函数有什么作用？
5.通信原理板块——正交相移键控(QPSK/4PSK)
6.请问哪位有模拟退火遗传算法的源程序?
int()函数和INT()函数的区别有哪些?
int()函数的作用是将一个字符串或数字转换为整型。INT(x)可以求出一个不大于x的转格最大整数。INT函数，雷码是源码VFP数值函数的一种，是转格将一个要取整的实数向下取整为最接近的整数。利用INT函数可以返回一个小数的雷码摆叫麻将源码整数，如4.，源码返回4，转格它不是雷码四舍五入，而是源码舍尾法，即使4.，转格也是雷码返回4，而不是源码5。
价值和代表
具有整数类型的转格项的值是它对应的数学整数。积分类型可以是雷码无符号的（只能表示非负整数）或有符号（也能表示负整数）。
整数值通常在程序的源代码中指定为可选的前缀为＋或－的数字序列。一些编程语言允许其他符号，例如十六进制或八进制。一些编程语言也允许数字组分隔符。
此数据的内部表示形式是值存储在计算机内存中的方式。与数学整数不同，计算机中的抖音小程序源码市场分析典型数据具有一些最小和最大可能值。
正整数的最常见表示是使用二进制数字系统的一串位。存储位的存储器字节的顺序是变化的；看到字节序。整数类型的宽度或精度是其表示中的位数。
具有n位的整数类型可以编码2数字；例如，无符号类型通常表示非负值0到2-1。有时使用对位模式的整数值的其他编码，例如二进制编码的十进制或格雷码，或者诸如ASCII的打印字符码。
数字IC异步FIFO设计详解（含源码）
深入解析异步FIFO设计：数据流的智能存储与同步艺术
FIFO（First In First Out），这个数据存储领域的基石，凭借其先进先出的特性在许多系统中扮演着关键角色。异步FIFO，作为同步版本的升级版，巧妙地处理不同时钟域和数据宽度的交互，通过结构精妙的模块构建出高效且可靠的缓冲解决方案。 异步FIFO的核心由几个关键模块组成：写数据控制、读数据控制、格雷码转换、同步逻辑、空满信号检测，以及双口RAM数据存储。怎样从微信上打开网页源码写控制模块使用带使能的计数器，智能地在full信号高时暂停写入，确保数据的完整性。与此同时，读控制模块引入empty信号，防止读取过程中的数据丢失，读空后空信号会拉高，暂停读取进程，等待新的数据到来。 格雷码转换模块至关重要，它通过二进制到格雷码的转换，消除了亚稳态错误的风险，确保每次变化仅有一位，便于同步操作的精确执行。例如，读指针同步的代码片段揭示了这种巧妙的转换策略：读指针同步：always @(posedge r_clk or negedge r_rst_n) if(!r_rst_n) r_ptr <= 4'b0; else if(r_en && !empty) r_ptr <= r_ptr + 4'b1;
同步操作是整个设计的灵魂，确保读写指针在各自时钟域内保持一致。当full信号与写时钟同步，empty信号与读时钟同步时，这种同步机制确保了系统的稳定和高效。 在读写指针比较模块中，传奇4服务端源码是什么通过同步后的对比，我们判断空闲（empty）或满（full）状态，这是FIFO状态控制的核心逻辑，确保数据的正确流动。 数据存储模块使用双口RAM，两个时钟输入使得数据传输更为灵活。当写使能且FIFO不满时，新数据会被写入，而读取操作在非空时有效，实现了数据的无缝流动。 在实际的Verilog实现中，如DUT模块定义所示，异步FIFO的设计巧妙地融入了参数化，允许用户根据具体应用调整数据宽度、深度和指针宽度，以满足不同场景的需求。 通过仿真，我们观察到异步FIFO在实际工作中的行为，如full信号在写满时的上升，以及empty信号在读空后的上升。特别地，小程序素材库源码怎么找由于格雷码的使用，异步FIFO能够有效地处理数据同步和亚稳态问题，确保数据的正确读取和存储。 总结来说，异步FIFO的设计不仅是一个技术细节的体现，更是系统集成和数据流控制的精妙实践。它的每一个模块都精心设计，以确保在多时钟、多宽度的复杂环境中，数据能准确无误地按序流动，为系统的稳定性和性能提供了坚实保障。计算机的补码原码问题
1.是这样规定的，如果硬要理解的话，可以这样理解：位的-是，而8位恰好位于分界点，在8位的范围内，-到肯定是很好理解的，而表示-理解成-0也行，理解成-也行，采取后者正好跟位的兼容，所以更佳！2.定点补码表示纯小数，第一位的1表示负数，表示数值，补码的补码是源码，所以的补码是取反加一，等于1，所以等于-1.
int()函数有什么作用？
int()函数的作用是将一个字符串或数字转换为整型。INT(x)可以求出一个不大于x的最大整数。INT函数，是VFP数值函数的一种，是将一个要取整的实数向下取整为最接近的整数。利用INT函数可以返回一个小数的整数，如4.，返回4，它不是四舍五入，而是舍尾法，即使4.，也是返回4，而不是5。
价值和代表
具有整数类型的项的值是它对应的数学整数。积分类型可以是无符号的（只能表示非负整数）或有符号（也能表示负整数）。
整数值通常在程序的源代码中指定为可选的前缀为＋或－的数字序列。一些编程语言允许其他符号，例如十六进制或八进制。一些编程语言也允许数字组分隔符。
此数据的内部表示形式是值存储在计算机内存中的方式。与数学整数不同，计算机中的典型数据具有一些最小和最大可能值。
正整数的最常见表示是使用二进制数字系统的一串位。存储位的存储器字节的顺序是变化的；看到字节序。整数类型的宽度或精度是其表示中的位数。
具有n位的整数类型可以编码2数字；例如，无符号类型通常表示非负值0到2-1。有时使用对位模式的整数值的其他编码，例如二进制编码的十进制或格雷码，或者诸如ASCII的打印字符码。
通信原理板块——正交相移键控(QPSK/4PSK)
探索通信奥秘：深入解析正交相移键控(QPSK/4PSK)的编码与解调
欢迎来到微信公众号***小灰灰的FPGA***，这里我们将为您揭示正交相移键控（QPSK/4PSK）的神秘面纱，定期分享FPGA领域的实用项目与开源源码，涉及领域广泛，包括低速到高速接口驱动、信号处理、图像处理以及AXI总线等技术。 1. QPSK/4PSK的基本概念与编码规则 QPSK，每码元蕴含着两比特信息（ab），它通过将二进制比特分组为双比特组进行编码。共有4种相位排列，, , , ，每个对应一个独特的相位，采用格雷码排列，确保相邻相位仅有一位差异，有效降低了误码判断的风险，提升整体信号的可靠性。 示例：想象一下A方式QPSK信号的矢量图，其中相位代表格雷码编码的一个实例。 2. 从编码到解调的实践路径 QPSK信号的产生可通过两种途径：相乘电路和相位选择法。在相乘电路中，输入的基带信号经处理后，两个正交载波进行相乘，形成每个矢量代表2比特的信息流。而在相位选择法中，输入双比特ab决定输出的特定相位。 解调阶段，QPSK被视为两个2PSK信号的叠加，通过相干解调，提取出并行码元a和b，再并串转换回串行数据。此外，偏置QPSK和π/4相移QPSK都通过调整相位差，优化信号稳定性与同步性。 3. QPSK技术的优化变种 偏置QPSK通过调整码元时间间隔，使得两个比特a和b不会同时变化，降低了因相位突变引起的信号波动。而π/4相移QPSK则通过交替产生两个相位相差π/4的QPSK星座图，确保接收端能够轻松提取码元同步，提升系统性能。 以上就是QPSK/4PSK技术的简要概述，深入理解这些原理，将有助于您在通信领域实现更高效的数据传输。继续关注我们的公众号，获取更多实用教程和项目分享。请问哪位有模拟退火遗传算法的源程序?
遗传算法求解f(x)=xcosx+2的最大值
其中在尺度变换部分应用到了类似模拟退火算法部分，所有变量均使用汉语拼音很好懂
//中国电子科技集团公司
//第一研究室
//呼文韬
//hu_hu@.com
//随机初始种群
//编码方式为格雷码
//选择方法为随机遍历
//采用了精英保存策略
//采用了自适应的交叉率和变异率
//采用了与模拟退火算法相结合的尺度变换
//采用了均匀交叉法
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <iostream.h>
#include <iomanip.h>
#include <time.h>
#include <windows.h>
#define IM1
#define IM2
#define AM (1.0/IM1)
#define IMM1 (IM1-1)
#define IA1
#define IA2
#define IQ1
#define IQ2
#define IR1
#define IR2
#define NTAB
#define NDIV (1+IMM1/NTAB)
#define EPS 1.2e-7
#define RNMX (1.0-EPS)
#define zhizhenjuli 0.
#define PI 3.
#define T0 //温度要取得很高才行。
#define zhongqunshu1
#define zuobianjie -
#define youbianjie
unsigned int seed=0; //seed 为种子，要设为全局变量
void mysrand(long int i) //初始化种子
{
seed = -i;
}
long a[1];
//double hundun;
//double c=4;
//设置全局变量
struct individual
{
unsigned *chrom; //染色体；
double geti;//变量值
double shiyingdu; //目标函数的值；
double fitness; //变换后的适应度值；
};
individual *zuiyougeti;//精英保存策略
int zhongqunshu; //种群大小
individual *nowpop;//当前代
individual *newpop;//新一代
double sumfitness;//当代的总适应度fitness
double sumshiyingdu;//当代的总适应度shiyingdu
double maxfitness;//最大适应度
double avefitness;//平均适应度
double maxshiyingdu;//最大适应度
double avgshiyingdu;//平均适应度
float pc;//交叉概率
float pm;//变异概率
int lchrom;//染色体长度
int maxgen;//最大遗传代数
int gen;//遗传代数
//函数
int flipc(double ,double );//判断是否交叉
int flipm(double );//判断是否变异
int rnd(int low,int high);//产生low与high之间的任意数
void initialize();//遗传算法初始化
void preselectfitness(); //计算sumfiness,avefitness,maxfitness
void generation();
double suijibianli();//产生随机遍历指针
int fuzhi(float );//选择要复制的个体
void crossover(individual ,individual ,individual &,individual &);//交叉
void bianyi(individual &);//变异
void mubiaohanshu(individual &);//计算适应度
void chidubianhuan(individual &);//对shiyingdu进行尺度变换赋给fitness
double ran1(long *);//随机数初始
void bianma(double bianliang,unsigned *p);//编码
double yima(unsigned *p);
void guanjiancanshujisuan();//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness，avefitness，maxfitness
void jingyingbaoliu();
void glp(int n,int s,int *,int (*)[1],float (*)[1]);//glp生成函数
BOOL Exist(int Val, int Num, int *Array);//判断一个数在前面是否出现过
int cmpfitness(const void *p1,const void *p2)
{
float i=((individual *)p1)->shiyingdu;//现在是按照"适应度"排序，改成"个体"的话就是按照"个体"排序
float j=((individual *)p2)->shiyingdu;
return i<j ? -1:(i==j ? 0:1);//现在是按升序牌排列，将1和-1互换后就是按降序排列
}
void main()
{
initialize();
cout<<zuiyougeti->geti<<" "<<zuiyougeti->shiyingdu<<endl;/////////////
for(gen=1;gen<maxgen;gen++)
{ generation();
}
jingyingbaoliu();
cout<<setiosflags(ios::fixed)<<setprecision(6)<<zuiyougeti->geti<<" "<<setiosflags(ios::fixed)<<setprecision(6)<<(zuiyougeti->shiyingdu)<<endl;////////////////
delete [] newpop;
delete [] nowpop;
delete [] zuiyougeti;
system("pause");
}
void initialize()
{
int q[zhongqunshu1][1],s=1;
float xx[zhongqunshu1][1];//生成的glp用x储存
int h[1]={ 1};//生成向量
zuiyougeti=new individual;//最优个体的生成
zhongqunshu=;//种群数量
nowpop=new individual[zhongqunshu1];//当代
newpop=new individual[zhongqunshu1];//新一代
maxgen=;//最大代数
gen=0;//起始代
lchrom=;//基因数量的初始化
mysrand(time(0));//随机数种子
a[0]=seed;//随机数种子
//对最优个体的初始化
zuiyougeti->geti=0;
zuiyougeti->fitness=0;
zuiyougeti->shiyingdu=0;
//
glp(zhongqunshu,s,h,q,xx);
//for(int i=0;i<zhongqunshu1;i++)//产生初始种群
//{
// for(int j=0;j<s;j++)
// {
// nowpop[i].geti=zuobianjie+(youbianjie-zuobianjie)*xx[i][j];
// }
//}
for(int i=0;i<zhongqunshu1;i++)//产生初始种群
{
nowpop[i].geti=zuobianjie+(youbianjie-(zuobianjie))*ran1(a);
}
//nowpop[0].geti=;//////////////////////////
guanjiancanshujisuan();
jingyingbaoliu(); //精英保留的实现
guanjiancanshujisuan();//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness，avefitness，maxfitness
}
void jingyingbaoliu() //精英保留的实现
{
individual *zuiyougetiguodu;
zuiyougetiguodu=new individual[zhongqunshu1];//建立一个过渡数组
for(int i=0;i<zhongqunshu;i++)//将当代个体复制到过渡数组中
zuiyougetiguodu[i]=nowpop[i];
qsort(zuiyougetiguodu,zhongqunshu1,sizeof(individual),&cmpfitness);//按fitness升序排序
// cout<<"zuiyougetiguodu适应度:"<<zuiyougetiguodu[zhongqunshu1-1].shiyingdu<<endl;///////////
// cout<<"zuiyougeti适应度:"<<zuiyougeti->shiyingdu<<endl;///////////////////
//system("pause");
if(zuiyougetiguodu[zhongqunshu-1].shiyingdu>zuiyougeti->shiyingdu)
{
*zuiyougeti=zuiyougetiguodu[zhongqunshu1-1];//如果最优个体的fitness比当代最大的fitness小则用当代的代替之
//cout<<"zuiyougetiguodu个体:"<<zuiyougetiguodu[zhongqunshu1-1].geti<<endl;/////////////
//cout<<"zuiyougeti个体:"<<zuiyougeti->geti<<endl;/////////////
}
else
nowpop[rnd(0,(zhongqunshu1-1))]=*zuiyougeti;//否则的话从当代中随机挑选一个用最优个体代替之
delete [] zuiyougetiguodu;//释放过渡数组
}
void guanjiancanshujisuan()//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness，avefitness，maxfitness
{
for(int i=0;i<zhongqunshu;i++)//计算shiyingdu
mubiaohanshu(nowpop[i]);
for(i=0;i<zhongqunshu;i++)//对shiyingdu进行尺度变换变成fitness
chidubianhuan(nowpop[i]);
preselectfitness();//根据fitness计算sumfitness，avefitness，maxfitness
}
void mubiaohanshu(individual &bianliang)//计算shiyingdu
{
bianliang.shiyingdu=(bianliang.geti*cos(bianliang.geti)+2.0);//目标函数
}
void chidubianhuan(individual &bianliang)//对shiyingdu进行尺度变换变成fitness
{
double T;//退火温度
T=T0*(pow(0.,(gen+1-1)));
double sum=0;
for(int j=0;j<zhongqunshu;j++)
sum+=exp(nowpop[j].shiyingdu/T);
bianliang.fitness=exp(bianliang.shiyingdu/T)/sum;//算出fitness
}
void preselectfitness()//根据fitness计算sumfitness，avefitness，maxfitness
{
int j;
sumfitness=0;
for(j=0;j<zhongqunshu;j++)
sumfitness+=nowpop[j].fitness;
individual *guodu;
guodu=new individual[zhongqunshu1];
for(j=0;j<zhongqunshu;j++)
guodu[j]=nowpop[j];
qsort(guodu,zhongqunshu1,sizeof(individual),&cmpfitness);
maxfitness=guodu[zhongqunshu1-1].fitness;
avefitness=sumfitness/zhongqunshu1;
delete [] guodu;
}
void generation()
{
individual fuqin1,fuqin2,*pipeiguodu,*pipeichi;
int *peiduishuzu;//用来存放产生的随机配对
pipeiguodu=new individual[zhongqunshu1];
pipeichi=new individual[zhongqunshu1];
peiduishuzu=new int[zhongqunshu1];
int member1,member2,j=0,fuzhijishu=0,i=0,temp=0,tt=0;
float zhizhen;
//随机遍历的实现
for(zhizhen=suijibianli();zhizhen<1;(zhizhen=zhizhen+zhizhenjuli))//设定指针1/
{
pipeichi[fuzhijishu]=nowpop[fuzhi(zhizhen)];
fuzhijishu++;
}
//交叉与变异的实现
//交叉
for(i=0;i<zhongqunshu1;i++)
{
peiduishuzu[i]=-1;
}
for (i=0; i<zhongqunshu1; i++)
{
temp =rnd(0,zhongqunshu1-1); //产生值在0-zhongqunshu1-1的随机数
while(Exist(temp, i, peiduishuzu))//判断产生的随机数是否已经产生过，如果是，则再产生一个随机数
{
temp =rnd(0,zhongqunshu1-1);
}
//如果没有的话，则把产生的随机数放在peiduishuzu中
*(peiduishuzu+i) = temp;
}
for(i=0;i<zhongqunshu1-1;i=i+2)
{
fuqin1=pipeichi[peiduishuzu[i]];
fuqin2=pipeichi[peiduishuzu[i+1]];
crossover(fuqin1,fuqin2,newpop[i],newpop[i+1]);
}
for(j=0;j<zhongqunshu1;j++)
{
//if(newpop[j].geti<-)
//cout<<"个体数值小于下界了";
nowpop[j].geti=newpop[j].geti;
}
//
guanjiancanshujisuan();
//变异的实现
for(j=0;j<zhongqunshu;j++)
{
bianyi(nowpop[j]);
}
//
guanjiancanshujisuan();
//精英保留的实现
jingyingbaoliu();
//
guanjiancanshujisuan();
delete [] peiduishuzu;
delete [] pipeichi;
delete [] pipeiguodu;
}
void crossover(individual parent1,individual parent2,individual &child1,individual &child2)//交叉
{
int j;
unsigned *panduan;
panduan=new unsigned[lchrom];
parent1.chrom=new unsigned[lchrom];
parent2.chrom=new unsigned[lchrom];
child1.chrom=new unsigned[lchrom];
child2.chrom=new unsigned[lchrom];
//cout<<"jiaocha"<<endl;///////////////////////
bianma(parent1.geti,parent1.chrom);
bianma(parent2.geti,parent2.chrom);
if(flipc(parent1.fitness,parent2.fitness))
{
for(j=0;j<lchrom;j++)
panduan[j]=rnd(0,1);
//for(j=0;j<lchrom;j++)////////////////
// {
// cout<<panduan[j];/////////////
// }
// cout<<endl;////////////////
// system("pause");////////////////
for(j=0;j<lchrom;j++)
{
if(panduan[j]==1)
child1.chrom[j]=parent1.chrom[j];
else
child1.chrom[j]=parent2.chrom[j];
}
for(j=0;j<lchrom;j++)
{
if(panduan[j]==0)
child2.chrom[j]=parent1.chrom[j];
else
child2.chrom[j]=parent2.chrom[j];
}
//for(j=0;j<lchrom;j++)////////////////
//{
// cout<<child1.chrom[j];/////////////
// }
//cout<<endl;////////////////
// system("pause");////////////////
child1.geti=yima(child1.chrom);
child2.geti=yima(child2.chrom);
delete [] child2.chrom;
delete [] child1.chrom;
delete [] parent2.chrom;
delete [] parent1.chrom;
delete [] panduan;
}
else
{
for(j=0;j<lchrom;j++)
{
child1.chrom[j]=parent1.chrom[j];
child2.chrom[j]=parent2.chrom[j];
}
child1.geti=yima(child1.chrom);
child2.geti=yima(child2.chrom);
delete [] child2.chrom;
delete [] child1.chrom;
delete [] parent2.chrom;
delete [] parent1.chrom;
delete [] panduan;
}
}
void bianyi(individual &child)//变异
{
child.chrom=new unsigned[lchrom];
//cout<<"变异"<<endl;
bianma(child.geti,child.chrom);
for(int i=0;i<lchrom;i++)
if(flipm(child.fitness))
{
if(child.chrom[i]=0)
child.chrom[i]=1;
else
child.chrom[i]=0;
}
child.geti=yima(child.chrom);
delete [] child.chrom;
}
void bianma(double bianliang,unsigned *p)//编码
{
unsigned *q;
unsigned *gray;
q=new unsigned[lchrom];
gray=new unsigned[lchrom];
int x=0;
int i=0,j=0;
if(bianliang<zuobianjie)///////////////////
{
cout<<"bianliang:"<<bianliang<<endl;/////////
system("pause");
}
//cout<<youbianjie-(zuobianjie)<<endl;
//system("pause");
x=(bianliang-(zuobianjie))*((pow(2,lchrom)-1)/(youbianjie-(zuobianjie)));
//cout<<x<<endl;///////////
if(x<0)
system("pause");///////////
for(i=0;i<lchrom;i++)
{
q[i]=0;
p[i]=0;
}
i=0;
while (x!=0&&(i!=lchrom))
{
q[i]=(unsigned)(x%2);
x=x/2;
i++;
}
// for(i=0;i<lchrom;i++)//////////////////
// cout<<q[i];///////////////
// cout<<endl;///////////
int w=lchrom-1;
if(q[w]!=0&&q[w]!=1)
system("pause");
for(j=0;j<lchrom&&w>0;j++)
{
p[j]=q[w];
w--;
}
//cout<<"yuanma"<<endl;
//for(j=0;j<lchrom;j++)///////////
// cout<<p[j];////////
//cout<<endl;////////////////////
gray[0]=p[0];
for(j=1;j<lchrom;j++)
{
if(p[j-1]==p[j])
gray[j]=0;
else if(p[j-1]!=p[j])
gray[j]=1;
}
for(j=0;j<lchrom;j++)
p[j]=gray[j];
//cout<<"geleima"<<endl;
//for(j=0;j<lchrom;j++)///////////
// cout<<p[j];////////
//cout<<endl;////////////////////
//system("pause");///////////
delete [] gray;
delete [] q;
}
double yima(unsigned *p) //译码
{
int i=0;
// for(i=0;i<lchrom;i++)/////////
// {
// cout<<p[i];//////
// }
// cout<<endl;/////////
// system("pause");//////////
int x=0;
unsigned *q;
q=new unsigned[lchrom];
q[0]=p[0];
// cout<<q[0]<<endl;//////////////////
// system("pause");//////////
for(int j=1;j<lchrom;j++)
{
if(q[j-1]==p[j])
q[j]=0;
else if(q[j-1]!=p[j])
q[j]=1;
}
// for(i=0;i<lchrom;i++)//////
// {
// cout<<q[i];//////////
// if(q[i]!=0&&q[i]!=1)
// {
// cout<<q[i];
// system("pause");
// }
// }
// cout<<endl;////////
// system("pause");///////////////////
for(i=0;i<lchrom;i++)
x=x+q[i]*pow(2,(lchrom-i-1));
if(x<0)
{
cout<<"译码出错1"<<endl;
system("pause");
}
//cout<<"x:"<<x<<endl;
double bianliang;
//cout<<pow(2,)<<endl;
//cout<<*x<<endl;
//cout<<(x*(/(pow(2,)-1)))<<endl;
bianliang=(x*((youbianjie-(zuobianjie))/(pow(2,lchrom)-1)))+zuobianjie;
if(bianliang<zuobianjie)
{
cout<<"译码出错2"<<endl;
system("pause");
}
delete [] q;
return bianliang;
}
double ran1(long *idum)
{
int j;
long k;
static long idum2=;
static long iy=0;
static long iv[NTAB];
float temp;
if (*idum <= 0)
{
if (-(*idum) < 1) *idum=1;
else *idum = -(*idum);
idum2=(*idum);
for (j=NTAB+7;j>=0;j--)
{
k=(*idum)/IQ1;
*idum=IA1*(*idum-k*IQ1)-k*IR1;
if (*idum < 0) *idum += IM1;
if (j < NTAB) iv[j] = *idum;
}
iy=iv[0];
}
k=(*idum)/IQ1;
*idum=IA1*(*idum-k*IQ1)-k*IR1;
if (*idum < 0) *idum += IM1;
k=idum2/IQ2;
idum2=IA2*(idum2-k*IQ2)-k*IR2;
if (idum2 < 0) idum2 += IM2;
j=iy/NDIV;
iy=iv[j]-idum2;
iv[j] = *idum;
if (iy < 1) iy += IMM1;
if ((temp=AM*iy) > RNMX) return RNMX;
else return temp;
}
double suijibianli()//随机遍历
{
double i=ran1(a);
while(i>zhizhenjuli)
{
i=ran1(a);
}
//cout<<i<<endl;//////////////
return i;
}
int fuzhi(float p)//复制
{
int i;
double sum=0;
if(sumfitness!=0)
{
for(i=0;(sum<p)&&(i<zhongqunshu);i++)
sum+=nowpop[i].fitness/sumfitness;
}
else
i=rnd(1,zhongqunshu1);
return(i-1);
}
int rnd(int low, int high) /*在整数low和high之间产生一个随机整数*/
{
int i;
if(low >= high)
i = low;
else
{
i =(int)((ran1(a) * (high - low + 1)) + low);
if(i > high) i = high;
}
return(i);
}
int flipc(double p,double q)//判断是否交叉
{
double pc1=0.9,pc2=0.6;
if((p-q)>0)
{
if(p>=avefitness)
{
pc=pc1-(pc1-pc2)*(p-avefitness)/(maxfitness-avefitness);
}
else
pc=pc1;
}
else
{
if(q>=avefitness)
{
pc=pc1-(pc1-pc2)*(q-avefitness)/(maxfitness-avefitness);
}
else
pc=pc1;
}
if(ran1(a)<=pc)
return(1);
else
return(0);
}
int flipm(double p)//判断是否变异
{
double pm1=0.,pm2=0.;
if(p>=avefitness)
{
pm=(pm1-(pm1-pm2)*(maxfitness-p)/(maxfitness-avefitness));
}
else
pm=pm1;
if(ran1(a)<=pm)
return(1);
else
return(0);
}
void glp(int n,int s,int *h,int (*q)[1],float (*xx)[1])//glp
{
int i=0,j=0;
//求解q
for(i=0;i<n;i++)
{
for(j=0;j<s;j++)
{
*(*(q+i)+j)=((i+1)*(*(h+j)))%n;
}
}
i=n-1;
for(j=0;j<s;j++)
{
*(*(q+i)+j)=n;
}
//求解x
for(i=0;i<n;i++)
{
for(j=0;j<s;j++)
{
*(*(xx+i)+j)=(float)(2*(*(*(q+i)+j))-1)/(2*n);
}
}
}
BOOL Exist(int Val, int Num, int *Array)//判断一个数是否在一个数组的前Num个数中
{
BOOL FLAG = FALSE;
int i;
for (i=0; i<Num; i++)
if (Val == *(Array + i))
{
FLAG = TRUE;
break;
}
return FLAG;
}