metatrade4索罗斯都要用到的外汇交易术

最新推荐文章于 2024-02-16 23:05:34 发布

catubhuja

最新推荐文章于 2024-02-16 23:05:34 发布

阅读量1.8k

点赞数 3

分类专栏： MT4 编程

本文链接：https://blog.csdn.net/catubhuja/article/details/78348136

版权

MT4 编程专栏收录该内容

2 篇文章 2 订阅

订阅专栏

metatrade4索罗斯都要用到的外汇交易术

20160627

#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;

}

double iLotsFormat(double myLots)

{

double minLot=MarketInfo(Symbol(),MODE_MINLOT);

myLots=MathRound(myLots/minLot)*minLot; //四舍五入整形化

myLots=(myLots

return(myLots);

}

double iFundsToHands(string mySymbol,double myFunds)

{

double myLots=myFunds/MarketInfo(mySymbol,MODE_MARGINREQUIRED);

myLots=iLotsFormat(myLots);

return(myLots);

}

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);

}

double iLotsOptimized(double myFunds,double myCapitalRisk)

{

double myMargin=myFunds*myCapitalRisk/100;//计算可用保证金额度

double myLots=iLotsFormat(iFundsToHands(Symbol(),myMargin));//可开仓手数

return(myLots);

}

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

#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);

}

#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

#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 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);

}

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);//文字内容

}

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);

}

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;

}

catubhuja

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录