1.3-8译码器的棋牌棋牌功能
2.138译码器作为数据分配器使用时，使能端的译码源码译码源码设置方法都有哪些
3.c++ code128码 解码译码 源代码
4.3-8译码器的功能
5.什么是源程序? 请描述源程序实现过程中文件扩展名的变化顺序
6.请问哪位有模拟退火遗传算法的源程序?

3-8译码器的功能

       3-8译码器的主要功能在于实现地址的二进制编码转换为输出信号。当选通端E1为高电平，棋牌棋牌A0、译码源码译码源码A1、棋牌棋牌A2中的译码源码译码源码推看源码两个为低电平时，例如A2A1A0=，棋牌棋牌它会将该二进制编码转换为对应的译码源码译码源码Y0至Y7输出端以低电平形式输出。这种设计灵活，棋牌棋牌可以级联扩展，译码源码译码源码如通过E1、棋牌棋牌E2和E3扩展成线译码器，译码源码译码源码甚至加上反相器进一步扩展至线。棋牌棋牌此外，译码源码译码源码当其中一个选通端作为数据输入端时，棋牌棋牌教程整站源码LS还能作为数据分配器使用，常见于等计算机的译码电路中，以扩展内存。

       现代计算机系统的工作流程涉及多个步骤，从源代码经过预处理器、编译器转化为目标代码，再通过链接器生成可执行程序。村站源码高级编程语言如C、Java等，其源代码首先被编译成通用中间语言的字节码，最后由通用语言运行库转换为CPU可以直接执行的机器码。这种设计极大地提高了程序员的编程效率和代码的可读性。

译码器作为数据分配器使用时，使能端的触屏源码设置方法都有哪些

       利用使能短的一个输入端输入数据信息，做数据分配器时，如S1输入，S‘2=S’3=0，地址码对应输出是S1的反码。如果从S2'输入，S1=0，S3=0，lock源码分析地址发对应输出是S2‘端数据信息的源码

c++ code码 解码译码 源代码

       code字符集包括A，B，C常用的是优化过的CODEAUTO,所有的条码软件都支持，如Bartender,Codesoft,LabelMatrix,NiceLabel等。

3-8译码器的功能

       1、当一个选通端（E1）为高电平，另两个选通端为低电平时，可将地址端（A0、A1、A2）的二进制编码在Y0至Y7对应的输出端以低电平译出。（即输出为Y0至Y7的非）比如：A2A1A0=时，则Y6输出端输出低电平信号。

       2、利用 E1、E2和E3可级联扩展成线译码器；若外接一个反相器还可级联扩展成线译码器。

       3、若将选通端中的一个作为数据输入端时，LS还可作数据分配器。

       4、可用在的译码电路中，扩展内存。

扩展资料

       ä¸€ä¸ªçŽ°ä»£è¯‘码器的主要工作流程：源代码 (source code) →预处理器 (preprocessor) →编译器 (compiler) →目标代码 (object code) →链接器 (Linker) →可执行程序 (executables)。

       é«˜çº§è®¡ç®—机语言便于人编写，阅读交流，维护。机器语言为计算机能直接解读、运行的。

       è¯‘码器将汇编或高级计算机语言源程序（Source program）作为输入，翻译成目标语言（Target language）机器代码的等价程序。

       æºä»£ç ä¸€èˆ¬ä¸ºé«˜çº§è¯­è¨€ (High-level language)， 如Pascal、C、C++、Java、汉语编程等或汇编语言，而目标则是机器语言的目标代码（Object code），有时也称作机器代码（Machine code）。

       å¯¹äºŽC#、VB等高级语言而言，此时编译器完成的功能是把源码（SourceCode）编译成通用中间语言（MSIL/CIL）的字节码（ByteCode）。

       æœ€åŽè¿è¡Œçš„时候通过通用语言运行库的转换，编程最终可以被CPU直接计算的机器码（NativeCode）。

       å‚考资料来源：百度百科-编译器

       å‚考资料来源：百度百科-LS

什么是源程序? 请描述源程序实现过程中文件扩展名的变化顺序

       源程序是指在计算机上运行时必须进行译码的程序文件，它包括源代码和指令的组合。源程序实现的过程中，文件扩展名的变化顺序为：.c → .o → .exe。首先，使用编辑器将源代码编写成.c文件，然后将.c文件编译成.o文件，最后用链接器将.o文件链接起来，生成可执行的.exe文件。

请问哪位有模拟退火遗传算法的源程序?

       遗传算法求解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;

       }