metatrade4索罗斯都要用到的外汇交易术
20160627
1.
#property strict
#property indicator_chart_window
#property indicator_buffers 2
double highBuffer[];
double lowBuffer[];
datetime StartHour=0;
int cnt,i,j;
int tempStartHour,tempEndHour;
int tempStartHourShift,tempEndHourShift;
int OnInit()
{
  IndicatorDigits(MarketInfo(Symbol(),MODE_DIGITS));//根据市场报价形式显示数据
  SetIndexBuffer(0,highBuffer);
  SetIndexStyle(0,DRAW_LINE,STYLE_SOLID,2,Blue);
  SetIndexLabel(0,"区间高位");
  SetIndexBuffer(1,lowBuffer);
  SetIndexStyle(1,DRAW_LINE,STYLE_SOLID,2,Red);
  SetIndexLabel(1,"区间低位");
  return(INIT_SUCCEEDED);
}
//
void iHighLowInteral(int myBarShift)
{
  int myBarTime=iTime(NULL,0,myBarShift);//指定k线时间  ?datetime 
  int myStartHour=StrToTime(TimeYear(myBarTime)+"."+TimeMonth(myBarTime)+"."+TimeDay(myBarTime))+StartHour*60*60;//当前区间开始时间
  int myEndHour=myStartHour+24*60*60;
  if(tempStartHour!=myStartHour || tempEndHour!=myEndHour)
  {
     tempStartHour=myStartHour;
     tempEndHour=myEndHour;
     tempStartHourShift=iBarShift(NULL,0,tempStartHour);
     tempEndHourShift=iBarShift(NULL,0,tempEndHour);
     int tempBars=tempStartHourShift-tempEndHourShift;//区间k线数量
     int myHighBar=iHighest(NULL,0,MODE_HIGH,tempBars,tempEndHourShift);
     double myHighPrice=High[myHighBar];
     int myLowBar=iLowest(NULL,0,MODE_LOW,tempBars,tempEndHourShift);
     double myLowPrice=Low[myLowBar];
     //给指标赋值
     for(i=tempEndHourShift; i<=(tempEndHourShift+tempBars); i++)
     {
        highBuffer[i]=myHighPrice;
        lowBuffer[i]=myLowPrice;
     }
  }
}
int OnCalculate(const int rates_total,
               const int prev_calculated,
               const datetime &time[],
               const double &open[],
               const double &high[],
               const double &low[],
               const double &close[],
               const long &tick_volume[],
               const long &volume[],
               const int &spread[])
{
  int counted_bars=prev_calculated;
  if(counted_bars<0)return(-1);
  //左边最后数的主子将被重新数
  if(counted_bars>0)counted_bars--;
  int limit=Bars-counted_bars;
  //
  for(int i=0;i
     iHighLowInteral(i);
  return(rates_total);
}
20160626
1.extern string PassWord="";//预定义密码变量
void OnTick()
{
  //有效期限制
  if(TimeCurrent()>D'2016.7.12')
  {
     Comment("软件过期");
     return;
  }
  //密码认证
  if(PassWord!="Qd9fDe4cA")
  {
     Comment("密码不正确");
     return;
  }
}
2.
double iLotsFormat(double myLots)
{
  double minLot=MarketInfo(Symbol(),MODE_MINLOT);
  myLots=MathRound(myLots/minLot)*minLot; //四舍五入 整形化
  myLots=(myLots
  return(myLots);
}
3.
double iFundsToHands(string mySymbol,double myFunds)
{
  double myLots=myFunds/MarketInfo(mySymbol,MODE_MARGINREQUIRED);
  myLots=iLotsFormat(myLots);
  return(myLots);
}
4.
int iOrderProfitToPoint(int myTicket)
{
  int myPoint=0;
  if(OrderSelect(myTicket,SELECT_BY_POS,MODE_TRADES))
  {
     myPoint=NormalizeDouble(((OrderProfit()-OrderSwap())/MarketInfo(OrderSymbol(),MODE_TICKVALUE))/OrderLots(),0);
  }
  return(myPoint);
}
5.
double iLotsOptimized(double myFunds,double myCapitalRisk)
{
  double myMargin=myFunds*myCapitalRisk/100;//计算可用保证金额度
  double myLots=iLotsFormat(iFundsToHands(Symbol(),myMargin));//可开仓手数
  return(myLots);
}
6.
int iBarCode(int myBarShift)
{
  int result=0;
  double myOpen,myHigh,myLow,myClose;//开高低收
  myOpen=iOpen(NULL,0,myBarShift);
  myHigh=iHigh(NULL,0,myBarShift);
  myLow=iLow(NULL,0,myBarShift);
  myClose=iClose(NULL,0,myBarShift);
  if(myOpen
     result=1;//光头光脚阳线
  }else if(myOpen>myClose&&myOpen==myHigh&&myClose==myLow){
     result=-1;//光头光脚阴线
  }else if(myOpenmyLow&&myClose==myHigh){
     result=2;//下引线阳线
  }else if(myOpen>myClose&&myOpen==myHigh&&myClose>myLow){
     result=-2;//下引线阴线
  }else if(myOpen
     result=3;//上引线阳线
  }else if(myOpen>myClose&&myOpen
     result=-3;//上引线阴线
  }else if(myOpenmyLow&&myClose
     result=4;//上下引线阳线
  }else if(myOpen>myClose&&myOpenmyLow){
     result=-4;//上下引线阴线
  }else if(myOpen==myClose&&myOpen==myLow&&myClose
     result=5;//倒T字型
  }else if(myOpen==myClose&&myOpen==myHigh&&myClose
     result=-5;//T字型
  }else if(myOpen==myClose&&myOpen>myLow&&myClose
     result=6;//十字型
  }else if(myOpen==myClose&&myOpen==myHigh&&myClose==myLow){
     result=-6;//一字型
  }
  return(result);
}
20160625
1.//平仓和开仓如果一起运行 很容易出现奇怪的 需要用全部变量 p20
bool CloseAllBool=false; //预定义全平仓公共变量
void CommonpProcess(string 交易信号) //通用流程
{
  if(BuyGroupOrders==0)
  {
     CloseAllBool=false; //如果持仓单为0，全平仓变量赋值false，允许建仓和新开仓
  }
  if(交易信号=="买入单平仓"&&BuyGroupOrders>0)
  {
     CloseAllBool=true;//持仓单大于0，且信号为平仓，全平仓变量赋为true
  }
  if(CloseAllBool==true)
  {
     //执行买入单平仓
     return(0);//不执行后面的代码
  }
  //以下代码为建仓，加仓流程 增加了全平仓变量判断
  if(BuyGroupOrders==0&&交易信号=="买入单建仓"&&CloseAllBool==false)
  {
     //执行买入单建仓
  }
  else if(BuyGroupOrders==1&&交易信号=="买入单建仓"&&CloseAllBool==false)
  {
     //执行买入单加仓
  }
}
20160624
1.
#property version   "1.00"
#property strict
//程序默认参数
extern string str="====默认系统参数====";
extern double preOpenLot=0.1;//预设开仓量
double Lots;
string orderComment="";//订单注释
string MyOrderComment;
int orderMagic=0;//订单特征码
int MyMagicNum;
//---------程控参数
int BuyGroupOrders,SellGroupOrders;//买入组，卖出组成交持仓单 数量统计
int BuyGroupFirstTicket,SellGroupFirstTicket; //买入组，卖出组第一单单号
int BuyGroupLastTicket,SellGroupLastTicket;//买入组，卖出组最后一单单号
int BuyGroupMaxProfitTicket,SellGroupMaxProfitTicket;//买入组，卖出组最大盈利单单号
int BuyGroupMinProfitTicket,SellGroupMinProfitTicket;//买入组，卖出组最小盈利单单号
int BuyGroupMaxLossTicket,SellGroupMaxLossTicket;//买入组，卖出组最大亏损单单号
int BuyGroupMinLossTicket,SellGroupMinLossTicket;//买入组，卖出组最小亏损单单号
int BuyGroupLots,SellGroupLots;//买入组，卖出组 成交持仓单开仓量总计
int BuyGroupProfit,SellGroupProfit;//买入组，卖出组成交单利润总计
int BuyLimitOrders,SellLimitOrders;//买入组，卖出组限价挂单数量
int BuyStopOrders,SellStopOrders;//买入组，卖出组突破挂单总计
//持仓单基本信息：0订单号，1开仓时间，2订单利润，3订单类型，4开仓量，5开仓价，6止损价，7止盈价，8订单特征码，9订单佣金，10掉期，11挂单有效日期
double OrdersArray[][12];//第1维：订单序号；第2维：订单基本信息   时间排序用
double myTempOrdersArray[][12];   //利润排序    存的buy sell单 而且是真实的数组个数大小
int MyArrayRange;//数组记录数量 ？
int cun,i,j,k;//计数器变量
int OnInit()
{
  //iShowInfo();
  //初始化参数
  Lots=preOpenLot;
  MyOrderComment="订单注释";
  MyMagicNum=20160626;
  return(INIT_SUCCEEDED);
}
void OnDeinit(const int reason)
 {
 }
void OnTick()
{
  iMain();
}
void sortOrderArray()
{
  int myArrayCnt=0;
  int myArrayCnt1=0;
  //创建临时
  double myTempArray[][12];
  ArrayResize(myTempArray,MyArrayRange);//?
  ArrayInitialize(myTempArray,0.0);
  myArrayCnt=BuyGroupOrders+SellGroupOrders;//真正的有效数组个数
  myArrayCnt1=myArrayCnt-1; //最后一个
  ArrayResize(myTempOrdersArray,myArrayCnt);
  ArrayInitialize(myTempOrdersArray,0.0);
  for(i=0; i
  {
     if(OrdersArray[i][0]!=0)
     {
        if(OrdersArray[i][3]==OP_BUY||OrdersArray[i][3]==OP_SELL)
        {
           for(k=0; k<=11; k++)
              myTempOrdersArray[myArrayCnt1][k]=OrdersArray[i][k];
           myArrayCnt1--;
        }
     }
  }
  //按时间降序排列数组
  //if(myOrderSort==0)
  {
     for(i=0; i
     {
        for(j=MyArrayRange-1; j>i; j--)
        {
           if(OrdersArray[j][1]>OrdersArray[j-1][1]) //交换
           {
              for(k=0; k<=11; k++)
                 myTempArray[0][k]=OrdersArray[j-1][k];
              for(k=0; k<=11; k++)
                 OrdersArray[j-1][k]=OrdersArray[j][k];
              for(k=0; k<=11; k++)
                 OrdersArray[j][k]=myTempArray[0][k];
           }
        }
     }
  }
  //if(myOrderSort==1 || myOrderSort==2) //按利润降序排列数组
  {
     for(i=0; i
     {
        for(j=myArrayCnt-1; j>i; j--)
        {
           if(myTempOrdersArray[j][2]>myTempOrdersArray[j-1][2])
           {
              for(k=0; k<=11; k++)
                 myTempArray[0][k]=myTempOrdersArray[j-1][k];
              for(k=0; k<=11; k++)
                 myTempOrdersArray[j-1][k]=myTempOrdersArray[j][k];
              for(k=0; k<=11; k++)
                 myTempOrdersArray[j][k]=myTempArray[0][k];
           }
        }
     }
  }
}
int iOrderSortTicket(int myOrderType,int myOrderSort,int myMaxMin)
{
  int myTicket=0;
  int myArrayCnt=BuyGroupOrders+SellGroupOrders;//真正的有效数组个数
  if(myArrayCnt==0)return(0);
  int myType;
  //X订单类型最小亏损单
  if(myOrderSort==2&&myMaxMin==1) //亏损 最小
  {
     for(i=0; i
     {
        myType=NormalizeDouble(myTempOrdersArray[i][3],0);
        if(myTempOrdersArray[i][2]<0&&myType==myOrderType)
        {
           myTicket=NormalizeDouble(myTempOrdersArray[i][0],0);
           break;
        }
     }
  }
  else if(myOrderSort==2&&myMaxMin==0)//亏损 最大
  {
     for(i=myArrayCnt-1 ;i>=0; i--)
     {
        myType=NormalizeDouble(myTempOrdersArray[i][3],0);
         if(myTempOrdersArray[i][2]<0&&myType==myOrderType)
        {
           myTicket=NormalizeDouble(myTempOrdersArray[i][0],0);
           break;
        }
     }
  }
  else if(myOrderSort==1&&myMaxMin==0)//盈利 最小
  {
     for(i=myArrayCnt-1; i>=0; i--)
     {
        myType=NormalizeDouble(myTempOrdersArray[i][3],0);
         if(myTempOrdersArray[i][2]>0&&myType==myOrderType)
        {
           myTicket=NormalizeDouble(myTempOrdersArray[i][0],0);
           break;
        }
     }
  }
  else if(myOrderSort==1&&myMaxMin==0) //盈利 最大
  {
     for(i=0; i
     {
        myType=NormalizeDouble(myTempOrdersArray[i][3],0);
        if(myTempOrdersArray[i][2]>0&&myType==myOrderType)
        {
           myTicket=NormalizeDouble(myTempOrdersArray[i][0],0);
           break;
        }
     }
  }
  else if(myOrderSort==0&&myMaxMin==1) //时间 最小  第一开仓单
  {
     for(i=myArrayCnt-1; i>=0; i--)
     {
        myType=NormalizeDouble(myTempOrdersArray[i][3],0);
        if(OrdersArray[i][0]!=0 && myType==myOrderType)
        {
           myTicket=NormalizeDouble(OrdersArray[i][0],0);
           break;
        }
     }
  }
  else if(myOrderSort==0&&myMaxMin==0) //时间 最大  最后开仓单 最新开仓单
  {
     for(i=0; i
     {
        myType=NormalizeDouble(myTempOrdersArray[i][3],0);
        if(OrdersArray[i][0]!=0 && myType==myOrderType)
        {
           myTicket=NormalizeDouble(OrdersArray[i][0],0);
           break;
        }
     }
  }
  return(myTicket);
}
void iShowInfo()
{
  //设置初始值
  BuyGroupOrders=SellGroupOrders=0;
  BuyGroupFirstTicket=SellGroupFirstTicket=0;
  BuyGroupLastTicket=SellGroupLastTicket=0;
  BuyGroupMaxProfitTicket=SellGroupMaxProfitTicket=0;
  BuyGroupMinProfitTicket=SellGroupMinProfitTicket=0;
  BuyGroupMaxLossTicket=SellGroupMaxLossTicket=0;
  BuyGroupMinLossTicket=SellGroupMinLossTicket=0;
  BuyGroupLots=SellGroupLots=0;
  BuyGroupProfit=SellGroupProfit=0;
  BuyLimitOrders=SellLimitOrders=0;
  BuyStopOrders=SellStopOrders=0;
  //初始化订单数组
  MyArrayRange=OrdersTotal();//?和书不一样
  ArrayResize(OrdersArray,MyArrayRange);//重新设定数组个数
  ArrayInitialize(OrdersArray,0.0);//初始化
  if(OrdersTotal()>0)
  {
     for(i=0; i
     {
        if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)&&OrderSymbol()==Symbol()&&OrderMagicNumber()==MyMagicNum)
        {
           OrdersArray[i][0]=OrderTicket();
           OrdersArray[i][1]=OrderOpenTime();
           OrdersArray[i][2]=OrderProfit();
           OrdersArray[i][3]=OrderType();
           OrdersArray[i][4]=OrderLots();
           OrdersArray[i][5]=OrderOpenPrice();
           OrdersArray[i][6]=OrderStopLoss();
           OrdersArray[i][7]=OrderTakeProfit();
           OrdersArray[i][8]=OrderMagicNumber();
           OrdersArray[i][9]=OrderCommission();
           OrdersArray[i][10]=OrderSwap();
           OrdersArray[i][11]=OrderExpiration();
        }
     }
     //统计基本信息
     for(i=0; i
     {
        if(OrdersArray[i][0]!=0) //有订单
        {
           if(OrdersArray[i][3]==OP_BUY) //买入持仓单
           {
              BuyGroupOrders++;
              BuyGroupLots+=OrdersArray[i][4];
              BuyGroupProfit+=OrdersArray[i][2];
           } 
           else if(OrdersArray[i][3]==OP_SELL)//卖出持仓单
           {
              SellGroupOrders++;
              SellGroupLots+=OrdersArray[i][4];
              SellGroupProfit+=OrdersArray[i][2];
           }
           else if(OrdersArray[i][3]==OP_BUYLIMIT)//买入 限价
           {
              BuyLimitOrders++;
           }
           else if(OrdersArray[i][3]==OP_SELLLIMIT)//卖出 限价
           {
              SellLimitOrders++;
           }
           else if(OrdersArray[i][3]==OP_BUYSTOP)//买入 突破
           {
              BuyStopOrders++;
           }
           else if(OrdersArray[i][3]==OP_SELLSTOP)//卖出 突破
           {
              SellStopOrders++;
           }
        }
     }
     //计算买入卖出组首尾等信息
     sortOrderArray();//先排序下面在取值（提高效率）
     BuyGroupFirstTicket=iOrderSortTicket(OP_BUY,0,1);
     SellGroupFirstTicket=iOrderSortTicket(OP_SELL,0,1);
     BuyGroupLastTicket=iOrderSortTicket(OP_BUY,0,0);
     SellGroupLastTicket=iOrderSortTicket(OP_SELL,0,0);
     BuyGroupMinProfitTicket=iOrderSortTicket(OP_BUY,1,1);
     SellGroupMinProfitTicket=iOrderSortTicket(OP_SELL,1,1);
     BuyGroupMaxProfitTicket=iOrderSortTicket(OP_BUY,1,0);
     SellGroupMaxProfitTicket=iOrderSortTicket(OP_SELL,1,0);
     BuyGroupMaxLossTicket=iOrderSortTicket(OP_BUY,2,0);
     SellGroupMaxLossTicket=iOrderSortTicket(OP_SELL,2,0);
     BuyGroupMinLossTicket=iOrderSortTicket(OP_BUY,2,1);
     SellGroupMinLossTicket=iOrderSortTicket(OP_SELL,2,1);
  }
}
void iMain()
{
  iShowInfo() ;
}
20160623
1./*变色的指标
*/
#property strict
#property indicator_chart_window
#property indicator_buffers 2
extern int MA_Period=20;
double UpLineBuffer[],DownLineBuffer[];
int ExtCountedBars=0;
int OnInit()
 {
  IndicatorDigits(MarketInfo(Symbol(),MODE_DIGITS));//根据市场报价形式显示数据
  int i=0;
  SetIndexBuffer(i,UpLineBuffer);
  SetIndexStyle(i,DRAW_LINE,STYLE_SOLID,2,Red);
  SetIndexLabel(i,"上线（"+MA_Period+"）");
  i=1;
  SetIndexBuffer(i,DownLineBuffer);
  SetIndexStyle(i,DRAW_LINE,STYLE_SOLID,2,Blue);
  SetIndexLabel(i,"下线（"+MA_Period+"）");
  return(INIT_SUCCEEDED);
 }
int OnCalculate(const int rates_total,
               const int prev_calculated,
               const datetime &time[],
               const double &open[],
               const double &high[],
               const double &low[],
               const double &close[],
               const long &tick_volume[],
               const long &volume[],
               const int &spread[])
 {
  int counted_bars=prev_calculated;
  if(counted_bars<0)return(-1);
  //左边最后数的主子将被重新数
  if(counted_bars>0)counted_bars--;
  int limit=Bars-counted_bars;
  //
  for(int i=0;i
  {
     double sum=0;
     for(int j=0;j
        sum+=Close[i+j];
     double ma=sum/MA_Period;
     if(Close[i]>ma) DownLineBuffer[i]=ma;
     else UpLineBuffer[i]=ma;
  }
  return(rates_total);
 }
2.
#property version   "1.00"
#property strict
//新建/重写文件
bool WriteFile(string docName)
{
  bool result;
  string myDocName=docName+".csv";
  int handle=FileOpen(myDocName,FILE_CSV|FILE_READ|FILE_WRITE,',');
  if(handle<1)
  {
     result=false;
     Comment("写入文件失败");
  }
  else if(handle>0)
  {
     result=true;
     FileWrite(handle,"序号","开盘价","收盘价","最高价","最低价","成交量","成交量","日期");
     for(int i=1;i<=100;i++)
     {
        FileWrite(handle,i,Open[i],Close[i],High[i],Low[i],Volume[i],TimeToStr(Time[i]));
     }
     FileClose(handle);
     handle=0;
  }
  return(result);
}
//读取文件   显示指定记录
bool ReadFile(string docName,int i)
{
  bool result;
  string myDocName=docName+".csv";
  int handle=FileOpen(myDocName,FILE_CSV|FILE_READ,';');
  if(handle<1)
  {
     result=false;
     Comment("读取文件失败");
  }
  else if(handle>0)
  {
     int myPos=0; //文件指针变量
     int num=0;//记录总数
     result=true;//读取文件成功
     while(!FileIsEnding(handle))
     {
        FileSeek(handle,myPos,SEEK_SET);//指针点位到开始位置
        string myRecord=FileReadString(handle);//读入一条记录
        if(num==i) Comment("第"+i+"条记录："+myRecord);
        if(FileIsEnding(handle)) break; //文件结束 退出循环
        myPos=FileTell(handle);//当前指针位置
        num++;   
     }
     Print("指针总数："+myPos+" 总记录数"+num);//2016.06.23 21:50:19.042    CSV文件操作 GBPUSD,H1: 指针总数：5738 总记录数100
     FileClose(handle);//关闭文件
     handle=0;
  }
  return(result);
}
void iWait()
{
  while(!IsTradeAllowed() || IsTradeContextBusy())Sleep(100);
  RefreshRates();
}
3.为什么EA开仓会报错
a,即时交易中开仓价位，开仓量有问题
b,有些平台不允许开仓时设置止盈止损
c,止盈止损价格不符合StopLevel规则
d,挂单交易中价格设置不当。
20160622
1.//如何控制在一个k线中只做一次交易动作
int lastTime=0; //k线时间变量
void OnTick()
{
  if(lastTime==Time[0])return; //判断是否是当前k线
  //doSomething
  lastTime=Time[0];//更新时间
}
2.//计算适合报价平台的价格并返回  入参为买入或卖出报价
double ND(double price)
{
  return (NormalizeDouble(price,Digits));
}
20160621
1.MM平台 有对赌平台的成功，尤其是无监管的黑平台
ECN平台 好， 通常不允许开仓时设置止盈止损。
OrderSelect  不论持仓单还是历史订单， 订单最远的那张需要为0，最近的那张序号是订单总数-1
2.
#property strict
#property indicator_chart_window
#property  indicator_buffers 1
double CrossBuffer[];
int OnInit()
 {
  int i=0;
  SetIndexStyle(i,DRAW_SECTION,STYLE_SOLID,1,Red);
  SetIndexBuffer(i,CrossBuffer);
  SetIndexLabel(i,"十字星价位");
  ArrayInitialize(CrossBuffer,0.0);
  return(INIT_SUCCEEDED);
 }
int deinit()
{
  ObjectsDeleteAll();
  return(0);
}
int OnCalculate(const int rates_total,
               const int prev_calculated,
               const datetime &time[],
               const double &open[],
               const double &high[],
               const double &low[],
               const double &close[],
               const long &tick_volume[],
               const long &volume[],
               const int &spread[])
 {
   int counted_bars=prev_calculated;
   if(counted_bars<0)return(-1);
   //左边最后数的主子将被重新数
   if(counted_bars>0)counted_bars--;
   int limit=Bars-counted_bars;
   //最新这根不处理
   for(int i=1;i
   {
      if(Close[i]==Open[i])CrossBuffer[i]=Close[i];
   }
   return(rates_total);
  }
3。
#property strict
void OnStart()
 {
  if(OrdersTotal()==0)
  {
     Comment("没有持仓单");
     return;
  }
  string currentSymbol=Symbol();
  for(int i=OrdersTotal()-1;i>=0;i--)
  {
     if(OrderSelect(i,SELECT_BY_POS)==false)continue;
     else
     {
        if(OrderSymbol()==currentSymbol)
        {
           if(OrderClose(OrderTicket(),OrderLots(),Close[0],0)==true)
              Comment("订单"+DoubleToStr(OrderTicket(),0)+"已按照"+DoubleToStr(Close[0],Point)+"价格平仓");
        }
     }
  }
 }
20160620
1.显示市场信息脚本
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
void OnStart()
{
  string lableDoc="===================="+"\n"+
     "交易商："+TerminalCompany()+
     "交易平台："+TerminalName()+
     "服务器名称："+AccountServer()+"\n"+
     "开户公司："+AccountCompany()+
     "账号："+AccountNumber()+
     "账户名称："+AccountName()+
     "交易货币："+AccountCurrency()+
     "杠杆：1:"+AccountLeverage()+"\n"+
     "===================="+"\n"+
     "当前品种："+Symbol()+
     "当前点差："+DoubleToStr(MarketInfo(Symbol(),MODE_SPREAD),0)+
     "停止水平点："+DoubleToStr(MarketInfo(Symbol(),MODE_STOPLEVEL),0)+"\n"+
     "报价小数位数："+Digits+
     "最小报价单位："+DoubleToStr(Point,Digits)+"\n"+
     "1标准手价值："+DoubleToStr(MarketInfo(Symbol(),MODE_LOTSIZE),0)+
     "1个点价值："+DoubleToStr(MarketInfo(Symbol(),MODE_TICKVALUE),4)+
     "1个点报价："+DoubleToStr(MarketInfo(Symbol(),MODE_TICKSIZE),Digits)+"\n"+
     "最小开仓手数："+DoubleToStr(MarketInfo(Symbol(),MODE_MINLOT),Digits)+
     "最大允许标准手数："+DoubleToStr(MarketInfo(Symbol(),MODE_MAXLOT),0)+
     "开仓量最小递增量："+DoubleToStr(MarketInfo(Symbol(),MODE_LOTSTEP),Digits)+"\n"+
     "1标准手的护盘保证金："+DoubleToStr(MarketInfo(Symbol(),MODE_MARGINHEDGED),2)+
     "1标准手的初始保证金："+DoubleToStr(MarketInfo(Symbol(),MODE_MARGININIT),2)+"\n"+
     "冻结订单水平点："+DoubleToStr(MarketInfo(Symbol(),MODE_FREEZELEVEL),2)+
     "账户信用点数："+DoubleToStr(AccountCredit(),2)+"\n"+
     "===================="+"\n"+
     "账户余额："+DoubleToStr(AccountBalance(),2)+
     "账户净值："+DoubleToStr(AccountEquity(),2)+
     "已用保证金："+DoubleToStr(AccountMargin(),2)+
     "账户利润："+DoubleToStr(AccountProfit(),2)+"\n"+
     "1标准手保证金："+DoubleToStr(MarketInfo(Symbol(),MODE_MARGINREQUIRED),2)+
     "当前可用保证金："+DoubleToStr(AccountFreeMargin(),2)+
     "停止水平值："+AccountStopoutLevel()+"\n"+
     "当前价格买入1手保证金："+DoubleToStr(AccountFreeMarginCheck(Symbol(),OP_BUY,1.0),2)+
     "当前价格卖出1手保证金："+DoubleToStr(AccountFreeMarginCheck(Symbol(),OP_SELL,1.0),2)+
     "买入持仓单隔夜利息："+DoubleToStr(MarketInfo(Symbol(),MODE_SWAPLONG),2)+
     "卖出持仓单隔夜利息："+DoubleToStr(MarketInfo(Symbol(),MODE_SWAPSHORT),2)+"\n"+
     "====================";
  Comment(lableDoc);
}
20160619
1.函数默认参数
void somefunc(double first,double sec=0.0001,int level=10);
//正常调用
  somefunc(3.14);
  somefunc(3.14,0.0002); 
2.指标-交易历史图形化
#property copyright "MT4"
#property link      ""
#property version   "1.00"
#property strict
#include
//指标在主图上显示
#property indicator_chart_window
#property indicator_buffers 3
//定义买入订单开盘箭头 卖出订单开盘箭头，平仓符号
double OpenBuyArrow[],OpenSellArrow[],CloseArrow[];
int OnInit()
{
  //设置开仓买入订单箭头模型
  int i=0;
  SetIndexStyle(i,DRAW_ARROW,EMPTY,1,Green);
  SetIndexArrow(i,221);
  SetIndexBuffer(i,OpenBuyArrow);
  SetIndexLabel(i,"买入订单开仓价");
  //设置开仓卖出订单箭头模型
  i=1;
  SetIndexStyle(i,DRAW_ARROW,EMPTY,1,Red);
  SetIndexArrow(i,222);
  SetIndexBuffer(i,OpenSellArrow);
  SetIndexLabel(i,"卖出订单开仓价");
  //平仓
  i=2;
  SetIndexStyle(i,DRAW_ARROW,EMPTY,1,DarkOrange);
  SetIndexArrow(i,251);
  SetIndexBuffer(i,CloseArrow);
  SetIndexLabel(i,"平仓价");
  return(INIT_SUCCEEDED);
}
int deinit()
{
  ObjectsDeleteAll(0); //删除主图上的对象
  return (0);
}
int OnCalculate(const int rates_total,
               const int prev_calculated,
               const datetime &time[],
               const double &open[],
               const double &high[],
               const double &low[],
               const double &close[],
               const long &tick_volume[],
               const long &volume[],
               const int &spread[])
{
  ObjectsDeleteAll(0);
  //定义统计变量
  int BuyOrders,SellOrders,ProfitOrders;//买入订单，卖出订单，盈利订单数量
  double TotalTradeLots;//交易总手
  double TotalProfit,TotalLoss;
  iSetLabel("标题栏","老王作品",200,1,8,"黑体",Red);
  string lableDoc="动态报价时间："+TimeToStr(TimeCurrent(),TIME_DATE|TIME_SECONDS)+" 星期"+DayOfWeek();
  iSetLabel("时间栏",lableDoc,4,15,9,"Verdana",Red);
  //画历史订单
  int hstTotal=OrdersHistoryTotal();//获得历史订单总数  应该只有OP_BUY OP_SELL 这两种类型
  for(int i=0;i
  {
     OrderSelect(i,SELECT_BY_POS,MODE_HISTORY);
     int openBar=iBarShift(Symbol(),0,OrderOpenTime());
     int closeBar=iBarShift(Symbol(),0,OrderCloseTime());
     if(OrderType()==OP_BUY)//多单
     {
        OpenBuyArrow[openBar]=OrderOpenPrice();
        BuyOrders++;
        //计算盈亏
        if(OrderProfit()>0)
        {
           TotalProfit+=OrderProfit();
           ProfitOrders++;
        }
        if(OrderProfit()<0) TotalLoss+=OrderProfit();
     }
     if(OrderType()==OP_SELL)//空单
     {
        OpenSellArrow[openBar]=OrderOpenPrice();
        SellOrders++;
        //计算盈亏
        if(OrderProfit()>0)
        {
           TotalProfit+=OrderProfit();
           ProfitOrders++;
        }
        if(OrderProfit()<0) TotalLoss+=OrderProfit();
     }
     //交易总手数
     TotalTradeLots+=OrderLots();
     //平仓符号
     CloseArrow[closeBar]=OrderCloseTime();
     SetObj(OrderTicket(),OrderType(),OrderOpenTime(),OrderOpenPrice(),OrderCloseTime(),OrderClosePrice());
  }
  //画持仓订单，动态显示开仓单与当前价的连线
  int total=OrdersTotal();
  for(int i=0;i
  {
     OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
     if(OrderType()<=1)//只处理持仓单
     {
        //删除旧连线对象
        string objectName="订单号-"+DoubleToStr(OrderTicket(),0);
        ObjectDelete(objectName);
        int openBar=iBarShift(Symbol(),0,OrderOpenTime());
        int closeBar=iBarShift(Symbol(),0,OrderCloseTime());
        if(OrderType()==OP_BUY)
        {
           OpenBuyArrow[openBar]=OrderOpenPrice();
        }
        if(OrderType()==OP_SELL)
        {
           OpenSellArrow[openBar]=OrderOpenPrice();
        }
        SetObj(OrderTicket(),OrderType(),OrderOpenTime(),OrderOpenPrice(),Time[0],Close[0]);
     }
     //显示统计信息
     lableDoc="历史交易单总计："+hstTotal+" (买入订单："+BuyOrders+" 卖出订单："+SellOrders+")";
     iSetLabel("交易单统计",lableDoc,4,35,9,"Verdana",Gray);
     lableDoc="盈利订单百分比："+DoubleToStr((ProfitOrders*0.01)/(hstTotal*0.01)*100,2)+"%";
     iSetLabel("胜率",lableDoc,4,50,9,"Verdana",Gray);
     lableDoc="净盈利："+DoubleToStr((TotalProfit+TotalLoss),2)+" (总获利："+DoubleToStr(TotalProfit,2)+" 总亏损："+DoubleToStr(TotalLoss,2)+")";
     iSetLabel("盈亏统计",lableDoc,4,65,9,"Verdana",Gray);
     lableDoc="账户余额："+DoubleToStr(AccountBalance(),2)+" 账户净值："+DoubleToStr(AccountEquity(),2);
     iSetLabel("账户余额",lableDoc,4,80,9,"Verdana",Gray);
     lableDoc="总下单量（手）："+DoubleToStr(TotalTradeLots,2);
     iSetLabel("下单量",lableDoc,4,95,9,"Verdana",Gray);
  }
  return(rates_total);
}
20160618
1.MACD与补仓3 主要学习代码逻辑用的
#include
extern double Init_Lots=0.01;
extern double Profit_Rate=34;
extern double Max_Bet_Lots=0.4;
extern double LostRate=2;
int Order_Total=50;
int Bet_Order=50;
bool LotsDouble=true;
int iBet_Order=0;//加倍订单计数器变量
double perProfit=0;//每批订单总盈亏变量
double iLots;//追加订单开仓量变量   //? 是不是用static 会好一点
double Init_Balance;//账户初始资金变量
double xMax_Bet_Lots;//最大浮动开仓量变量
int TicketNo;
int OnInit()
{
  iLots=Init_Lots;
  xMax_Bet_Lots=Max_Bet_Lots;
  Init_Balance=AccountBalance();
  return(INIT_SUCCEEDED);
}
void OnDeinit(const int reason)
{
}
string ReturnMarketInformation()
{
  string result="N/A";
  double macd0=iMACD(NULL,0,10,60,1,PRICE_CLOSE,MODE_SIGNAL,0);
  double macd2=iMACD(NULL,0,10,60,1,PRICE_CLOSE,MODE_SIGNAL,10);
  double price0=Close[0];
  double high2=High[2];
  double low2=Low[2];
  if(macd0>(macd2+0.00003)&&price0>high2)result="Sell";
  if(macd0<(macd2-0.00003)&&price0
  return result;
}
//计算账户余额，返回最新开仓量
double NewLots()
{
  //计算翻倍倍数
  double xRate=((AccountBalance()-Init_Balance)/Init_Balance)/(Profit_Rate/100);//? 取倍数的整数部分
  //计算开仓手数
  double xLots=NormalizeDouble(Init_Lots*xRate,2);
  if(xLots<0.01) xLots=0.01;
  //如果翻倍倍数大于1，才计算最大浮动开仓量变量
  if(xRate>1)xMax_Bet_Lots=Max_Bet_Lots*xRate;
  return xLots;
}
//根据市场信息开新仓
void OpenNewOrder(double myLots)
{
  string MktInfo=ReturnMarketInformation();
  if(MktInfo=="Buy" || MktInfo=="Sell")
  {
     TicketNo=iOpenOrders(MktInfo,myLots,0,0);
     Draw_Mark(TicketNo);
  }
}
void OnTick()
{
  //提取市场信号
  string mktSignal=ReturnMarketInformation();
  //显示市场信息
 string labelDoc="星期"+DayOfWeek()+"市场时间： "+Year()+"-"+Month()+"-"+Day()+" "+Hour()+":"+Seconds();
 iSetLabel("时间栏",labelDoc,200,0,9,"Verdana",Red);
 labelDoc="市场信号："+mktSignal+" 最大开仓量："+DoubleToStr(xMax_Bet_Lots,2);
 iSetLabel("信息栏",labelDoc,5,60,10,"Verdana",Blue);
 labelDoc="初始余额："+DoubleToStr(Init_Balance,2)+" 当前余额："+DoubleToStr(AccountBalance(),2);
 iSetLabel("信息栏1",labelDoc,5,20,10,"Verdana",Blue);
 labelDoc="最低开仓量："+DoubleToStr(NewLots(),2)+" 浮动开仓量："+DoubleToStr(iLots,2);
 iSetLabel("信息栏2",labelDoc,5,40,10,"Verdana",Blue);
 //新开仓
 if(OrdersTotal()==0)
 {
 //如果前一单亏损，则亏损加倍
  if(perProfit<0&& LotsDouble==true)iLots=iLots*LostRate;
  if(iLots>xMax_Bet_Lots)iLots=xMax_Bet_Lots;
  OpenNewOrder(iLots);
  perProfit=0;//前一批订单盈利清零
 }
 //处理已有持仓单
 if(OrdersTotal()>1)
 {
  //选定当前订单
  OrderSelect(OrdersTotal()-1,SELECT_BY_POS);
  //新订单不足一个周期，不做任何操作
  if((TimeCurrent()-OrderOpenTime())<=Period()*60) return;
  //追加盈利订单
  double iiLots=iLots;
  //如果超过加倍订单数量，交易量恢复初始值
  if(iBet_Order>=Bet_Order) iiLots=NewLots();
  //追加买入订单
  if(OrderType()==OP_BUY&&mktSignal=="Buy"&&OrdersTotal()<=Order_Total&&Ask>OrderOpenPrice())
  {
     TicketNo=iOpenOrders(mktSignal,iiLots,0,0);
     Draw_Mark(TicketNo);
     iBet_Order++; //加倍订单计数
  }
  //追加卖出订单
  if(OrderType()==OP_SELL&&mktSignal=="Sell"&&OrdersTotal()<=Order_Total&&Bid
  {
     TicketNo=iOpenOrders(mktSignal,iiLots,0,0);
     Draw_Mark(TicketNo);
     iBet_Order++; //加倍订单计数
  }
  //止损平仓 如果出现反向信号，平掉所有订单
  if((OrderType()==OP_BUY&&mktSignal=="Sell") ||(OrderType()==OP_SELL&&mktSignal=="Buy"))
  {
   for(int i=OrdersTotal()-1;i>=0;i--) //? 和书不一样
   {
     if(OrderSelect(i,SELECT_BY_POS)==false)continue;
     else
     {
        OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0);
        perProfit+=OrderProfit();//利润累加
     }
   }
   //盈利后，重新计算开仓量
   if(perProfit>0)iLots=NewLots();
   iBet_Order=0; //加倍订单变量清零
  }
 }
 return;
}
20160617
1，鳄鱼三线3.5EA   测试不开单
#include
extern int StopLoss=40;
extern int TakeProfit=0;
extern double MaxRisk=30;//资金风险1=1%
extern double Filter=0.35;//Force指标过滤参数
double Alligator_jaw,Alligator_teeth,Alligator_lips,Envelops21_upper,Envelops21_lower,Force3;
string objectSymbol="EURUSD";
int timeFrame=PERIOD_M30;
int OnInit()
 {
  return(INIT_SUCCEEDED);
 }
void OnDeinit(const int reason)
 {
 }
string ReturnMarketInformation()
{
  string result="N/A";
  Alligator_jaw=NormalizeDouble((iAlligator(objectSymbol,timeFrame,8,0,5,0,3,0,MODE_EMA,PRICE_WEIGHTED,MODE_GATORJAW,0)),4);
  Alligator_teeth=NormalizeDouble((iAlligator(objectSymbol,timeFrame,8,0,5,0,3,0,MODE_EMA,PRICE_WEIGHTED,MODE_GATORTEETH,0)),4);
  Alligator_lips=NormalizeDouble((iAlligator(objectSymbol,timeFrame,8,0,5,0,3,0,MODE_EMA,PRICE_WEIGHTED,MODE_GATORLIPS,0)),4);
  double Alligator_jaw_1=NormalizeDouble((iAlligator(objectSymbol,timeFrame,8,0,5,0,3,0,MODE_EMA,PRICE_WEIGHTED,MODE_GATORJAW,1)),4);
  double Alligator_teeth_1=NormalizeDouble((iAlligator(objectSymbol,timeFrame,8,0,5,0,3,0,MODE_EMA,PRICE_WEIGHTED,MODE_GATORTEETH,1)),4);
  double Alligator_lips_1=NormalizeDouble((iAlligator(objectSymbol,timeFrame,8,0,5,0,3,0,MODE_EMA,PRICE_WEIGHTED,MODE_GATORLIPS,1)),4);
  Force3=NormalizeDouble((iForce(objectSymbol,timeFrame,3,MODE_EMA,PRICE_WEIGHTED,0)),4);
  //技术分析
  if(Alligator_lips>Alligator_teeth&&Alligator_lips_1<=Alligator_teeth_1)
     result="UpCross";
  if(Alligator_lips=Alligator_teeth_1)
     result="DownCross";
  if(Alligator_lips>Alligator_teeth&&Alligator_teeth>Alligator_jaw)
     result="Rise"; 
  if(Alligator_lips
     result="Fall";
  if(Force3>Filter&&result=="Rise")
     result="Buy";
  if(Force3<-Filter&&result=="Fall")
     result="Sell";
  return result;
}
double LotsOptimized(double RiskValue)
{
  //最大可开仓手数  ？最好用净值 不要用余额
  double iLots=NormalizeDouble((AccountBalance()*RiskValue/100/MarketInfo(Symbol(),MODE_MARGINREQUIRED)),2);
  //如果上一次订单亏损，本次开仓量减半
  OrderSelect(OrdersHistoryTotal()-1,SELECT_BY_POS,MODE_HISTORY);
  if(OrderProfit()<0)iLots=iLots/2;
  if(iLots<0.01){iLots=0;Print("保证金余额不足");}
  return iLots;
}
void OnTick()
{
 //选择当前订单
 OrderSelect(0,SELECT_BY_POS);  //?
 //显示市场信息
 string labelDoc="星期"+DayOfWeek()+"市场时间： "+Year()+"-"+Month()+"-"+Day()+" "+Hour()+":"+Seconds();
 iSetLabel("时间栏",labelDoc,200,0,9,"Verdana",Red);
 labelDoc="市场信号： "+ReturnMarketInformation()+"当前订单盈亏："+DoubleToStr(OrderProfit(),2);
 iSetLabel("信息栏",labelDoc,5,20,10,"Verdana",Blue);
 //周五20点停止交易，如果盈利订单平仓
 if(DayOfWeek()==5 && Hour()>=20 && Minute()>=0)
 {
  if(OrderProfit()>0)OrderClose(OrderTicket(),OrderLots(),Ask,0);
//? Ask bid Close[0] 
  
  return;
 }
 //新开仓订单时间不足一个时间周期，不做任何操作；
 if(OrdersTotal()>0)
 {
 //空仓的时候这里如果return就不会开仓了? 30*60  应该是半个小时
  if((TimeCurrent()-OrderOpenTime())<=PERIOD_M30*60) return; 
 }
 //开仓操作
 if(Symbol()==objectSymbol && OrdersTotal()==0)
 {
  if(ReturnMarketInformation()=="Buy")
     iOpenOrders("Buy",LotsOptimized(MaxRisk),StopLoss,TakeProfit);
  if(ReturnMarketInformation()=="Sell")
     iOpenOrders("Sell",LotsOptimized(MaxRisk),StopLoss,TakeProfit);
 }
 //感觉有问题没有选择就直接用了么, 可能正常因为这个EA最多只持仓一个订单
 //止盈操作
 if(OrderProfit()>0)
 {
  if(Symbol()==objectSymbol&&OrdersTotal()==1&&OrderType()==OP_BUY&&ReturnMarketInformation()=="DownCross")
     OrderClose(OrderTicket(),OrderLots(),Ask,0);
  if(Symbol()==objectSymbol&&OrdersTotal()==1&&OrderType()==OP_SELL&&ReturnMarketInformation()=="UpCross")
     OrderClose(OrderTicket(),OrderLots(),Bid,0);
 }
 //止损操作
 if(OrderProfit()<0)
 {
  if(Symbol()==objectSymbol&&OrdersTotal()==1&&OrderType()==OP_BUY&&Alligator_lips
     OrderClose(OrderTicket(),OrderLots(),Ask,0);
  if(Symbol()==objectSymbol&&OrdersTotal()==1&&OrderType()==OP_SELL&&Alligator_lips>Alligator_jaw)
     OrderClose(OrderTicket(),OrderLots(),Bid,0);
 }
 return;
}
20160617
1. //最大开仓量
double testMaxLot()
{
  double myLots = (AccountEquity()/MarketInfo(Symbol(),MODE_MARGINREQUIRED));
  return (NormalizeDouble(myLots,2));
}
2.//使用本函数 最好不要设置止盈止损功能
int iOpenOrders(string myType,double myLots,int myLossStop,int myTakeProfit)
{
  int ticketNo=-1;
  int mySpread=MarketInfo(Symbol(),MODE_SPREAD);//点差 手续费 市场滑点
  double sl_buy=(myLossStop<=0)?0:(Ask-myLossStop*Point);
  double tp_buy=(myTakeProfit<=0)?0:(Ask+myTakeProfit*Point);
  double sl_sell=(myLossStop<=0)?0:(Bid+myLossStop*Point);
  double tp_sell=(myTakeProfit<=0)?0:(Bid-myTakeProfit*Point);
  if(myType=="Buy")
   ticketNo=OrderSend(Symbol(),OP_BUY,myLots,Ask,mySpread,sl_buy,tp_buy);
  if(myType=="Sell")
   ticketNo=OrderSend(Symbol(),OP_SELL,myLots,Bid,mySpread,sl_sell,tp_sell);
  return ticketNo;
}
void iCloseOrders(string myType)
{
  int cnt=OrdersTotal();
  int i;
  //选择当前持仓单
  if(OrderSelect(cnt-1,SELECT_BY_POS)==false)return;
  if(myType=="All")
  {
     for(i=cnt-1;i>=0;i--)
     {
        if(OrderSelect(i,SELECT_BY_POS)==false)continue;
        else OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0); //? Close[0]与OrderClosePrice()有区别么
     }
  }
  else if(myType=="Buy")
  {
     for(i=cnt-1;i>=0;i--)
     {
        if(OrderSelect(i,SELECT_BY_POS)==false)continue;
        else if(OrderType()==OP_BUY) OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0);
     }
  }
  else if(myType=="Sell")
  {
     for(i=cnt-1;i>=0;i--)
     {
        if(OrderSelect(i,SELECT_BY_POS)==false)continue;
        else if(OrderType()==OP_SELL) OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0);
     }
  }
  else if(myType=="Profit")
  {
     for(i=cnt-1;i>=0;i--)
     {
        if(OrderSelect(i,SELECT_BY_POS)==false)continue;
        else if(OrderProfit()>0) OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0);
     }
  }
  else if(myType=="Loss")
  {
     for(i=cnt-1;i>=0;i--)
     {
        if(OrderSelect(i,SELECT_BY_POS)==false)continue;
        else if(OrderProfit()<0) OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0);
     }
  }
}
3.//建议尽量不要对持仓订单设置止损价格，而是用程序计算平仓
void iMoveStopLoss(int myStopLoss)
{
  int Cnt=OrdersTotal()-1;
  if(OrdersTotal()>0)
  {
     for(int i=Cnt;i>=0;i--)
     {
        if(OrderSelect(i,SELECT_BY_POS)==false)continue;
        else
        {
           if(OrderProfit()>0&& OrderType()==OP_BUY && ((Close[0]-OrderStopLoss())>2*myStopLoss*Point))
           {
              OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*myStopLoss,OrderTakeProfit(),0);
           }
           if(OrderProfit()>0&& OrderType()==OP_SELL && ((OrderStopLoss()-Close[0])>2*myStopLoss*Point))
           {
              OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*myStopLoss,OrderTakeProfit(),0);
           }
        }
     }
  }
}
4.//感觉会有问题，应该用大于小于， 
bool EAValid=false;
bool iTimeControl(int myStartHour,int myStartMinute,int myStopHour,int myStopMinute)
{
  if(Hour()==0&&Minute()==0)EAValid=false;//new day
  if(Hour()==myStopHour&&Minute()==myStopMinute+1) //满足结束时间
  {
     EAValid=false;
  }
  if(Hour()==myStartHour&&Minute()==myStartMinute)//满足开始时间
  {
     EAValid=true;
  }
 return EAValid;
}
bool iValidTime(string myStartTime,string myEndTime,bool myServerTime)
{
  bool myValue=false;
  int myST=StrToTime(myStartTime);
  int myET=StrToTime(myEndTime);
  if(myST>myET)myET+=1440*60;
  datetime tempDateTime=(myServerTime==false)?TimeLocal():TimeCurrent();
  if(tempDateTime>myST&&tempDateTime
  if(myST==myET)myValue=true;
  return(myValue);
}
5.
void iSetLabel(string lableName,string lableDoc,int x,int y,int docSize,string docStyle,color docColor)
{
  iDisplayInfo(lableName,lableDoc,0,x,y,docSize,docStyle,docColor);
}
void iDisplayInfo(string lableName,string labelDoc,int corner,int x,int y,int docSize,string docStyle,color docColor)
{
  if(corner==-1)return;
  ObjectCreate(lableName,OBJ_LABEL,0,0,0);
  ObjectSetText(lableName,labelDoc,docSize,docStyle,docColor);
  ObjectSet(lableName,OBJPROP_CORNER,corner);//确定左边原点，0左上角，1右上角，2左下角，3右下角，-1不显示
  ObjectSet(lableName,OBJPROP_XDISTANCE,x);
  ObjectSet(lableName,OBJPROP_YDISTANCE,y);
}
void iBarText(string myString,int myBars,double myPrice,int docSize,string docStyle,color myColor)
{
  string TextBarString=myString+Time[myBars];//文本名称
  ObjectCreate(TextBarString,OBJ_TEXT,"",Time[myBars],myPrice);//建立一个文本对象
  ObjectSetText(TextBarString,myString,docSize,docStyle,myColor);//文字内容
}
6.
int LineNo=0;
string myObjectName="Line"+LineNo;
void iDrawLine(string myObjectName,int myFirstTime,double myFirstPrice,int mySecondTime,double mySecondPrice)
{
  iTwoPointsLine(myObjectName,myFirstTime,myFirstPrice,mySecondTime,mySecondPrice,STYLE_DOT,Green);
}
void iTwoPointsLine(string myObjectName,int myFirstTime,double myFirstPrice,int mySecondTime,double mySecondPrice,int myLineStyle,color myLineColor)
{
  ObjectCreate(myObjectName,OBJ_TREND,0,myFirstTime,myFirstPrice,mySecondTime,mySecondPrice);//确定两点坐标
  ObjectSet(myObjectName,OBJPROP_STYLE,myLineStyle);//线型
  ObjectSet(myObjectName,OBJPROP_COLOR,myLineColor); //线色
  ObjectSet(myObjectName,OBJPROP_WIDTH,1); //线宽
  ObjectSet(myObjectName,OBJPROP_BACK,false); //设置背景无效
  ObjectSet(myObjectName,OBJPROP_RAY,false);//设置射线无效
}
void SetObj(int orderTicket,int orderType,int openTime,int openPrice,int closeTime,int closePrice)
{
  string objectName="订单号-"+DoubleToStr(orderTicket,0);
  ObjectCreate(objectName,OBJ_TREND,0,openTime,openPrice,closeTime,closePrice);
  color clr=(orderType==0)?Green:Red;
  ObjectSet(objectName,OBJPROP_COLOR,clr);
  ObjectSet(objectName,OBJPROP_STATE,STYLE_DOT);
  ObjectSet(objectName,OBJPROP_WIDTH,1);
  ObjectSet(objectName,OBJPROP_BACK,false);
  ObjectSet(objectName,OBJPROP_RAY,false);
}
void DrawRectangle(string myRectangleName,color myColor,int myFirstTime,double myFirstPrice,int mySecondTime,double mySecondPrice,bool myBackColor)
{
  ObjectCreate(myRectangleName,OBJ_RECTANGLE,0,myFirstTime,myFirstPrice,mySecondTime,mySecondPrice);
  ObjectSet(myRectangleName,OBJPROP_COLOR,myColor);
  ObjectSet(myRectangleName,OBJPROP_BACK,myBackColor);
}
7.
void iDrawSign(string mySignal,double myPrice)
{
  string myObjectName;
  if(mySignal=="Buy")
  {
     myObjectName="BuyPoint-"+Time[0];
     ObjectCreate(myObjectName,OBJ_ARROW,0,Time[0],myPrice);
     ObjectSet(myObjectName,OBJPROP_COLOR,Green);
     ObjectSet(myObjectName,OBJPROP_ARROWCODE,241);
  }
  if(mySignal=="Sell")
  {
     myObjectName="SellPoint-"+Time[0];
     ObjectCreate(myObjectName,OBJ_ARROW,0,Time[0],myPrice);
     ObjectSet(myObjectName,OBJPROP_COLOR,Red);
     ObjectSet(myObjectName,OBJPROP_ARROWCODE,242);
  }
  if(mySignal=="GreenMark")
  {
     myObjectName="GreenMark-"+Time[0];
     ObjectCreate(myObjectName,OBJ_ARROW,0,Time[0],myPrice);
     ObjectSet(myObjectName,OBJPROP_COLOR,Green);
     ObjectSet(myObjectName,OBJPROP_ARROWCODE,162);
  }
  if(mySignal=="RedMark")
  {
     myObjectName="RedMark-"+Time[0];
     ObjectCreate(myObjectName,OBJ_ARROW,0,Time[0],myPrice);
     ObjectSet(myObjectName,OBJPROP_COLOR,Red);
     ObjectSet(myObjectName,OBJPROP_ARROWCODE,162);
  }
}
void iDrawSign2(string myType,int myBarPos,double myPrice,color myColor)
{
  string myObjectName;
  if(myType=="HLine")
  {
     myObjectName=myType+Time[myBarPos];
     ObjectCreate(myObjectName,OBJ_HLINE,0,Time[myBarPos],myPrice);
     ObjectSet(myObjectName,OBJPROP_COLOR,myColor);
  }
  else if(myType=="VLine")
  {
     myObjectName=myType+Time[myBarPos];
     ObjectCreate(myObjectName,OBJ_VLINE,0,Time[myBarPos],myPrice);
     ObjectSet(myObjectName,OBJPROP_COLOR,myColor);
  }
}
法2
//屏幕上做出开仓标记，红色箭头为卖出订单，绿色为买入订单 
void Draw_Mark(int myTicket)
{
  if(myTicket>0)//有效的订单
  {
     string myObjectName="Arrow-"+DoubleToStr(myTicket,0);
     //选定当前订单
     OrderSelect(OrdersTotal()-1,SELECT_BY_POS);
     int arrowValue; color arrowColor;
     if(OrderType()==OP_BUY){arrowValue=221;arrowColor=Green;}
     if(OrderType()==OP_SELL){arrowValue=222;arrowColor=Red;}
     ObjectCreate(myObjectName,OBJ_ARROW,0,Time[0],OrderOpenPrice());
     ObjectSet(myObjectName,OBJPROP_ARROWCODE,arrowValue);
     ObjectSet(myObjectName,OBJPROP_COLOR,arrowColor);
  }
}
8./*快慢指标线交叉信号   周期短的是快线，周期长的是慢线
参数说明， 当前快线，当前慢线，前一个快线，前一个慢线   
返回值：UpCross 上穿  DownCross 下穿 N/A 无穿越
*/
string iCrossSignal(double myFast0,double mySlow0,double myFast1,double mySlow1)
{
  string result="N/A";
  if(myFast0>mySlow0 && myFast1<=mySlow1) result="UpCross";
  if(myFast0=mySlow1) result="DownCross";
  return result;
} 

metatrade4索罗斯都要用到的外汇交易术相关推荐

  1. 领导当众说“辛苦了”，抢答“谢谢”会翻车，高手都用这3个话术

    华子正在工位上敲键盘.领导拿着方案走过来,拍拍华子肩膀说"辛苦啦".华子站起来,按照网文教的办法回复"谢谢领导".领导微微一笑,"先别着急抢答,虽然你 ...

  2. （五）巴菲特与索罗斯的投资习惯：市场总是错的

    作者:chen_h 微信号 & QQ:862251340 微信公众号:coderpai (一)巴菲特与索罗斯的投资习惯:思考习惯的力量 (二)巴菲特与索罗斯的投资习惯:七种致命的投资信念 (三 ...

  3. 巴菲特与索罗斯的投资习惯

    第1篇 巴菲特与索罗斯的投资习惯 第1章 思考习惯的力量 沃伦"巴菲特和乔治"索罗斯是世界上最成功的投资者.在分析了他们的信仰.行为.态度和决策方法后,我发现了两人均虔诚奉行的23 ...

  4. 幸运从来都只偏爱有准备的人——大龄码农的慌张日记

    很多人将一件事的成功归结于能力,也有很多人将其归结为运气.今天要在这里跟大家分享的朋友名叫Leon,他在纽村政府注重本地人就业的大环境下,用时1个月以配偶工签的身份成功拿到大厂offer. 接到我们的 ...

  5. 清华、北大、浙大的计算机课程资源集都在这里

    清华.北大.浙大的计算机课程资源集都在这里 整理 | 一一 出品 | AI科技大本营(ID:rgznai100) 此前,一份介绍中科大的相关课程资源的 repo 火了,但不知后来是不是因为太火,居然被 ...

  6. 人心比万物都诡诈，谁能识透呢？

    在二零零六年,我主持了十次面试,又担任了十多次面试的评审委员.这些面试 决定某些人能否获得社工员.就业辅导员.侨生辅导员或研究助理的工作机会. 我也曾多次参与职员晋升的口试,评量某些人能否升迁.在学校 ...

  7. 清华、北大、浙大的计算机课程资源集都在这里了

    参加 2019 Python开发者日,请扫码咨询 ↑↑↑ 整理 | 一一 出品 | AI科技大本营(ID:rgznai100) 此前,一份介绍中科大的相关课程资源的 repo 火了,但不知后来是不是因 ...

  8. 清华、北大、浙大的计算机课程资源集都在这里了(转载自 -- AI科技大本营)

    整理 | 一一 出品 | AI科技大本营(ID:rgznai100) 此前,一份介绍中科大的相关课程资源的 repo 火了,但不知后来是不是因为太火,居然被 404 了,如果你不幸错过了,别紧张,Gi ...

  9. 南京都昌科技电子病历模板库清单

    2015年1月30号南京都昌科技电子病历模板库有1074个模板文件,目前正在不断增加中,以后大家都不用操心做模板了,直接照抄就行了.清单如下,有意购买者请致电13382028281南京都昌科技市场部刘 ...

最新文章

  1. java多线程 ThreadPoolExecutor 策略的坑
  2. php流媒体视频下载,如何使用PHP流媒体文件？
  3. 实现BX的内容加上123 并把和送到寄存器AX
  4. javascript 原生得到document.Element的方法
  5. [渝粤教育] 西安工业大学 园中画境 中国古典园林造园艺术 参考 资料
  6. sqlyog设置自动补全_Visual Studio Code 最好的功能、插件和设置
  7. Angular之jwt令牌身份验证
  8. python ftp下载文件_文件上传下载Python
  9. Linux下编译protobuf
  10. 14-08-08 考核试题总结~
  11. 怎么使用可视化数据库工具 DBeaver 连接本地数据库？
  12. OAuth 2.0 开放授权的那些事儿
  13. 为什么顶级程序员都有超强逆商？顶级程序员马化腾在艰难的时候，是如何度过的？
  14. 四六级分数竟是这样算出来的！交白卷都不会得零分 （转）
  15. 在北京工作5年的程序员，通过人才引进入职县城事业编，月薪曝光
  16. ONF和ON.Lab合并为一 加速推进SDN落地
  17. PHPEMS +XAMPP 验证码显示不出来解决方法
  18. 如何用PS将gif图背景变透明
  19. python列表两两相减_Python数据分析实例一：医院药品销售数据
  20. Oracle 数据库导出数据库语句

热门文章

  1. Colored Rectangles【简单DP】
  2. hihoCoder 买零食
  3. 855 AIMA学习笔记（by菜菜子）
  4. Google文件系统（一）
  5. ​力扣解法汇总764. 最大加号标志
  6. 楼宇系统服务器,【产品介绍】楼宇管理平台
  7. android代码实现手机加速功能,神奇的安卓手机提速方法 只需设置两步立即提速70%以上...
  8. android layout_gravity gravity
  9. swin transformer 转 onnx
  10. matlab pi表示,matlab中pi是什么意思