皮皮网

1.苹果笔记本电脑怎么用万能wifi钥匙苹果电脑怎么用wifi万能钥匙
2.wine其他Wine版本
3.请问哪位有模拟退火遗传算法的源译源程序?
4.期货软件TB系统源代码解读系列19-函数上穿、下跌
5.如何借助CrossOver在Linux上运行Windows程序

苹果笔记本电脑怎么用万能wifi钥匙苹果电脑怎么用wifi万能钥匙

       ① Macbook Air如何使用wifi万能钥匙

       苹果电脑自己也可以当Wi-Fi 打开 ，码编不必用万能钥匙。源译系统偏好设置 下 --共享--互联网共享。码编就是源译

       ② 苹果笔记本电脑（苹果系统）如何破解wifi

       摘要首先大家登陆“WiFi万能钥匙”官网，下载针对Mac版本的码编Mfc 绘图 源码“WiFi万能钥匙”程序。

       ③ 苹果笔记本电脑wifi万能钥匙能用吗

       可以 需要手机查看密码，源译步骤如下

       1：下载WiFi万能钥匙链接该网络

       2：下载wifi侠密码查看（需要root手机）

       3：只要万能钥匙链接过的码编wifi，用wifi侠都可以看到密码

        注：超级root root手机

       ④ 苹果电脑怎么用wifi万能钥匙

       下载WiFi万能钥匙Mac版，源译安装时根据提示一步步操作。码编

       ⑤ 苹果电脑怎么用wifi万能钥匙

       操作方法如下：

       1.下载安装crossover软件

       ⑥ 苹果笔记本电脑（苹果系统）如何破解wifi

       苹果mac破解wifi密码方法和步骤：

       1、源译首先需要确保电脑装有 Xcode 和 MacPorts。码编Xcode 可以直接从 App Store 免费下载。源译

       MacPorts 前称 DarwinPorts，码编是源译一个软件包管理系统，用来简化 Mac OS X 系统上软件的安装。它是一个用来简化自由软件/开放源代码软件的安装的自由/开放源代码项目，与Fink和BSD类ports套件的目标和功能类似。它可以让用户在终端中简单的输入 port install 软件包名称来安装软件包，软件的源码交易的平台下载、编译、安装以及它依赖的所有其他软件包的安装都会自动完成。

       推荐下载“MacPorts-2.2.1-.9-Mavericks.pkg”这个版本。

       2、安装好 Macport 后，则开始安装Aircrack，打开终端输入命令：

       sudo port install aircrack-ng

       等待一段时间安装，然后使用mac系统下自带的 airport 进行附近 wifi 信号的监测。

       1）首先将 airport 命令引入到用户命令里，在终端输入：

       sudo ln -s /System/Library/PrivateFrameworks/Apple.framework/Versions/Current/Resources/airport /usr/sbin/airport

       2）然后在终端内输入如下命令，就能看到 airport 监测到的附近 wifi 信息：

       airport -s

       SSID 是 wifi名称，RSSI 是信号强度，CHANNEL 是信道。

       3）接着挑选一个信号强的信道进行监听抓包（比如信道1），在终端输入：

       sudo airport en1 sniff 1

       这时，会提示输入管理员密码，输入时密码是不会显示出来，输入完敲回车就开始监听抓包了。命令中的视频小网站源码 en1 是自己电脑的网卡地址，有的电脑可能是 en0，根据自己的实际情况进行输入，查看电脑网卡地址的地方如下：

       大概等待2-5分钟就可以按 command + c 组合键退出查看含有抓包的cap文件了，文件所在地址是/tmp，可以使用Finder的前往文件夹功能进入：

       可以将cap文件移到我们想保存的地方，也可以不移走（重启后就没有了）。

       接下来就进入关键的破解wifi密码的过程了，先在桌面建一个文件夹，取名“wifi”，将字典和cap文件都放到这个文件夹内（假设字典是.txt，cap文件名是.cap，在终端输入：

       cd ~/Desktop/wifi

       aircrack-ng -w .txt .cap

       就可以看到cap文件内的抓包情况，Encryption中（0 handshake）是抓包失败，（1 handshake）则是抓包成功。图中看到第行抓包成功，则在“Index number of target network ?”这里输入后敲回车：

       如果cap文件内全是（0 handshake），就按 command + c 组合键退出。重新回到“sudo airport en1 sniff 1”这步进行监听抓包。抓包成功率受到 wifi 信号强弱、漫画采集网站源码电脑与路由器距离远近、路由器是否正处在收发数据状态的影响。总之多试几次、监听时间适当延长些，可以大大提高成功率。

       进入到破解过程界面，如图：

       接下来等待破解结果就行了，中断破解过程可以直接按 command + c 组合键退出。破解过程所需时间长短受电脑硬件配置、字典体积大小的影响。如果.txt字典破解失败，则可以换其它字典进行破解，直到破解成功。

       ⑦ 苹果MAC电脑到底怎么使用WiFi万能钥匙

       电脑版的wifi万能钥匙和手机版的使用方法一样的，需要连接手机的数据连接，或者连接现在的无线网络热点才能辅助破解网络连接。

       使用万能钥匙需要开启手机数据流量或者连接无线wifi热点网络，需要从网络下载WiFi热点网络数据进行分析才能连接上被分享的wifi网络热点。

       能不能连接上无线wifi网络热点，php维修系统源码关键靠其他的用户分享无线wifi热点账户数据才能连接。

wine其他Wine版本

       尽管Wine能够运行大部分Windows程序，但它在运行依赖于DirectX技术的游戏方面的能力有限，这意味着许多游戏并不能在Wine环境中流畅运行。

       Wine的扩展计划包含了两个主要项目，一个是CodeWeavers开发的CrossOver，另一个是TransGaming Technologies的Cedega。CrossOver的主要目标是为用户提供办公应用的支持，而Cedega则专注于游戏娱乐。CodeWeavers和Wine项目之间保持着紧密的合作，CodeWeavers甚至聘请了Alexandre Juillard，以将CrossOver Office的源代码回馈给Wine，以促进其技术发展。

       在年6月日，CodeWeavers宣布了一个重要更新，即支持基于英特尔处理器的苹果电脑，这进一步扩大了Wine的适用范围。

       另一方面，Transgaming的Cedega起初是建立在Wine基础之上的商业软件。然而，随着Wine许可的变化，Cedega不再直接使用Wine的源代码。尽管Cedega提供了源代码下载，但如果没有包含专利技术，其功能和可用性可能会受到限制。尽管如此，Cedega仍为用户提供了一个基于Wine的定制游戏解决方案。

扩展资料

       wine，是一款优秀的Linux系统平台下的模拟器软件，用来将Windows系统下的软件在Linux系统下稳定运行，该软件更新频繁，日臻完善，可以运行许多大型Windows系统下的软件。另外英语单词wine是葡萄酒的意思。

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

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

       }

期货软件TB系统源代码解读系列-函数上穿、下跌

       理解期货软件中的函数CrossOver与CrossUnder，对于交易策略的实现至关重要。这两者在技术分析中代表了价格穿越某一水平线的关键时刻。代码实现过程相对直接且逻辑清晰，通过条件判断与循环结构，准确捕捉价格变动趋势。

       让我们以CrossOver函数为例进行解析。首先，定义了两个数值序列参数Price1和Price2，用于表示两个价格序列。接着，声明了布尔型变量Con1与PreCon，用于判断与保存特定条件下的价格关系。变量Counter用于追踪当前处理的k线位置。

       在开始部分，通过条件判断Price1是否大于Price2，如果成立，则执行一系列操作。首先，将Counter设为1，然后更新Con1，检查前一价格是否相等。接着，利用循环结构，不断更新Counter和Con1，直到条件不再满足或Counter达到当前k线索引值。在此过程中，记录了价格的穿越情况，并将结果赋值给PreCon，表示价格穿越的最终状态。最终返回PreCon值，作为函数输出。

       与CrossOver类似，CrossUnder函数主要通过修改条件判断为Price1小于Price2，实现对价格下降趋势的捕捉。通过同样的逻辑结构，准确识别价格穿越的情况。

       为了验证函数的实际效果，我们尝试将KD指标（动量指标）与上述函数结合，实现简单的程序化交易策略。通过对比使用CrossOver与CrossUnder函数的交易结果，我们发现两者在实际操作中的效果基本一致，这反映了函数在策略实现中的简洁性和高效性。

       实际上，CrossOver与CrossUnder函数的使用并不复杂，它们的核心逻辑在于条件判断与循环结构的巧妙结合。在编写交易策略时，选择合适的函数能够帮助我们更加精确地捕捉价格变动，进而优化交易决策。

       总的来说，期货软件中的函数CrossOver与CrossUnder为交易者提供了一种直观且有效的工具，用于分析价格趋势并执行交易策略。通过理解和应用这些函数，交易者能够更加灵活地调整和优化自己的投资策略，实现更为精准的市场预测和操作。尽管在特定情况下可能有多种实现方法，但函数本身的设计简洁明了，易于理解和实现，是程序化交易领域中不可或缺的元素。

如何借助CrossOver在Linux上运行Windows程序

       è¯šç„¶ï¼Œåœ¨ Linux 上使用类似于 MS Office 这样的应用程序可能是困难的；在这里我们来看一些原因，为什么确实是这样。在开始之前，我们应该指出，CodeWeavers 提供的商用 Wine 已经解决了大部分此类问题（参阅 参考资料以获得链接）。假以时日，这些问题将可能在开放源代码的 Wine 中同样得到解决。 使用命令行与大部分 Linux 中的应用程序一样，Wine 必须在命令行中安装。用户必须回到命令行中来在 Wine 下运行应用程序。例如，要运行Internet Explorer，用户通常需要在 shell 中输入 wine IEXPLORE.EXE 。尽管经验丰富的用户喜欢这样做，但初学者会发现这比较困难，而且不太可能懂得起别名等快捷方式。 配置CDROM 和驱动器映射等工作必须手工完成。这对初学者来说也是个问题。 取消对隐藏文件的隐藏 如果挂载 CDROM 时没有使用专门的 unhide 选项，那么安装 CD 上的一些文件可能会无法找到，从而导致安装失败。 调整配置 Wine 安装很少能直接使用（对它来说也就是从 tarfile 解开）。通常需要进行全面的调整；例如，一个程序的安装可能与您在配置文件中设置的 Windows 版本不相容；而修改那个版本又可能会影响一些已安装的应用程序。对很多 DLL 来说也是如此。为此，Wine 提供了一个巧妙的修复，让您可以设置特定于应用程序的属性。不过，一般的用户可能不会像我们一样满意。 额外的安装步骤 大部分应用程序的安装过程都不是标准的。例如，当我们安装 Internet Explorer 6 时，必须跳过一些步骤，比如 DCOM 的定位与安装。对用户来说，这类事情可能是最大的障碍。 注意，这些并不是病症，而是举例说明了是哪些种类的事情导致对一般用户来说 Wine 看起来复杂而且困难。 更多Wine 所不能做的看完Wine 的可用性问题后，现在让我们来总结在尝试使用 Wine 时一些常见的技术问题。 缺少DLL,这可能是最常见的问题：很多安装由于缺少 DLL 而失败。人们应该熟练使用调试器来决定下一步如何去做。（稍后将深入讨论调试器）。 DLL 版本问题 一些安装程序在开始之前会检查现有的系统 DLL。Wine 解决这一问题的方法是，创建假 DLL 以满足安装程序的需要。不过，有一些安装程序会更进一步并深入检查 DLL 以获得它们的版本。这对假的 DLL 来说要求太高了，会导致安装失败。 DLL 加载次序 Wine 有对很多 Windows DLL 的实现，而且如果可用，它还可以使用原始的 Windows DLL。如果两种 DLL 都可用，好像显然应该选择总是使用 Windows 自己的 DLL，但实际上 Windows DLL 有时会包含不能被满足的依赖。要确定是更应该使用 Wine 的 DLL 还是应该使用本机 DLL，惟一的方法是，基于各个应用程序反复进行试验。 DLL 中的函数 当一个 Wine DLL 没有实现 Windows 中相应的 DLL 的全部功能时，应用程序可能会遭遇函数调用失败。由于 DLL 是动态加载的，可能没有办法事先知道会发生这样的事情。这是一个复杂的问题，有一些可做的工作，但最终实际来说它只是取决于应用程序的代码如何编写。 有一些因素会减轻这些问题。一方面，您将会一个一个地遇到这些问题，而不是一次遇到全部问题，这样处理起来要容易些。另外，您遇到的那些问题可能其他人曾遇到过并已经解决（而且解决方案已经公布出来）。Wine 用户组非常活跃，会提供许多帮助，每周一次的 Wine 时事通讯（参阅 参考资料）是极好的信息资源。 Wine 中还没有实现的 Win API在Wine 中，很多 Win API5 的函数是残缺不全的。最常见的原因是，相当多的 Win API 并没有被文档化。这就意味着一个特别的应用程序可能会调用某个函数，而完全没有关于此函数的可用资料。例如，我们在运行一个简单的 RPC 程序时发现了 RtlAnsiCharToUnicodeChar 这个函数。在 MSDN 上的搜索结果显示没有关于这个函数的资料，而且没有关于所有 RtlXXXX 类别函数的资料。因此，如果它们在 Wine 中的实现对一些应用程序来说至关重要，那么人们可能只有去猜测它们的行为了。 商用的 WineCodeWeavers 为 Wine 做了很多工作。多年来他们为 Wine 项目贡献了很多代码，他们出售商用版本的 Wine，其改进的用户界面解决了我们在本文中提出的很多问题。 例如，CodeWeavers 的二进制安装文件会在用户的开始菜单中添加一个 Crossover 条目；安装后，绝大多数 Crossover 相关的任务可以通过开始菜单条目来完成。在开放源代码的 Wine 中，所有这些任务 -- 安装、程序执行以及其他任务 -- 都必须在命令行中执行。此外，CodeWeavers Crossover 将会尝试去为新安装的软件包配置一个合理的默认值，如果需要的话会在安装完成后自动重新引导，并以其他形式减轻用户的负担。 CodeWeavers 使用开放源代码的 Wine 作为他们的 Crossover 产品的基础，所以，除非遇到上面我们讨论过的可用性问题，否则，在其中一个产品中能运行的应用程序，在另一个产品中同样也能运行。要深入了解 CodeWeavers 和 Crossover，以及要获得可以在 Wine 上运行的应用程序列表，请参阅在 参考资料中列出的链接。 应用程序安装分析由于Wine 支持 Windows 可执行文件的运行，您会想当然地认为可以使用程序的安装程序从头安装，这是正常的。不幸的是，几乎不会那样。对 Windows 安装过程的理解将有助于解释原因。下面非常简单地描述了 Windows 安装程序通常要做的事情的（不必是这个次序）： 将文件拷贝到一些目录。 注册DLL，并将其他应用程序相关的信息添加到注册表中。 在安装过程中，有时会检查 DLL 的版本（如前面所提到的）。 修改INI 和一些其他配置文件。 因而，Wine 会遇到两种类型的问题，必须按顺序解决： 安装过程中的问题。 执行过程中的问题。 在调试 Wine 安装的过程中，如果您同时有一个可用的 Windows 系统的话会非常有帮助。那样，您可以对 Windows 安装使用追踪器以确切断定哪些文件被拷贝，哪些注册表条目被添加或更新，哪个 INI 文件被修改，等等。记录安装步骤的顺序并与失败的 Wine 安装相比较，是故障诊断的好向导。 在Linux 上安装 Wine如果您正在使用 Red Hat 或者 SUSE，最简单的方法是从 CD 安装 Wine。不过，如果那些 CD 比较老，您可能需要通过源文件安装，因为 Wine 项目经常更新。如果通过源文件安装，您会发现 Wine 用户指南（参阅 参考资料以获得链接）是一份价值无法估量的资料。简化的安装过程如下： 解开源文件后，切换到 tools 目录下以用户身份运行 ./tools/wineinstall。 在tools 目录下运行 winecheck 脚本来检查安装。您可能不会获得 % 的成功，但只要没有关键问题就行。 Wine 的所有配置都保存在 ~/.wine/config 文件中。这个文件很容易理解：它描述了您希望将 Linux 文件系统的哪部分看作是 Windows C 驱动器，以及 DLL 的加载次序等其他的细节。 您应该可以快速进行了。例如，要安装 WinZip 8.1，您可以下载安装程序并在命令行中运行 wine winzip.exe 。 快速浏览一下可以了解很多内容：您可以看到 WinZip 在运行，它的文件浏览器组件显示出熟悉的 Windows 驱动器 C、软盘驱动器 A、一个 CD-ROM M 以及另外的 Z 驱动器。您可以猜到，所有这些都映射在我们上面提到的 ~/.wine/config 文件中。