1048 lines
72 KiB
MQL5
1048 lines
72 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| helper.mq5 |
|
|
//| Copyright 2020, MetaQuotes Software Corp. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
#property tester_everytick_calculate ;
|
|
double Bid,Ask;
|
|
#include<Trade\Trade.mqh>
|
|
#include <ChartObjects\ChartObjectsShapes.mqh>
|
|
#include <Arrays\ArrayDouble.mqh>
|
|
|
|
|
|
|
|
CChartObjectRectangle rect;
|
|
CTrade trade;
|
|
enum sell_or_buy1
|
|
{
|
|
sell,// продать
|
|
buy, // купить
|
|
all // оба
|
|
};
|
|
enum stops
|
|
{
|
|
red,// red
|
|
blue, // blue
|
|
fractal // fractal
|
|
};
|
|
class CDynamicArray
|
|
{
|
|
private:
|
|
int m_ChunkSize; // Размер блока
|
|
int m_ReservedSize; // Реальный размер массива
|
|
int m_Size; // Количество занятых элементов массива
|
|
public:
|
|
double Element[]; // Собственно массив. Находится в секции public,
|
|
// чтобы в случае необходимости работать с ним напрямую
|
|
//+------------------------------------------------------------------+
|
|
//| Конструктор |
|
|
//+------------------------------------------------------------------+
|
|
void CDynamicArray(int ChunkSize=1024)
|
|
{
|
|
m_Size=0; // Количество занятых элементов
|
|
m_ChunkSize=ChunkSize; // Размер блока
|
|
m_ReservedSize=ChunkSize; // Реальный размер массива
|
|
ArrayResize(Element,m_ReservedSize); // Подготовка массива
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Функция добавления в конец массива |
|
|
//+------------------------------------------------------------------+
|
|
void AddValue(double Value)
|
|
{
|
|
// Увеличение количества занятых элементов
|
|
if(m_Size>m_ReservedSize)
|
|
{ // Требуемое количество больше реального размера массива
|
|
m_ReservedSize+=m_ChunkSize; // Рассчитываем новый размер массива
|
|
ArrayResize(Element,m_ReservedSize); // Увеличиваем реальный размер массива
|
|
}
|
|
// Print("m"+ArrayBsearch(Element,Value));
|
|
if(ArrayBsearch(Element,Value)<0){m_Size++;
|
|
Element[m_Size-1]=n(Value); // Добавляем значение
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Функция получения количества занятых элементов массива |
|
|
//+------------------------------------------------------------------+
|
|
int Size()
|
|
{
|
|
return(m_Size);
|
|
}
|
|
string Pri(){
|
|
string str="";
|
|
for(int i=0;i<m_Size;i++)str+="|"+i+"-"+Element[i];
|
|
return str;
|
|
}
|
|
};
|
|
//CDynamicArray val_st,val_tp;
|
|
input double koof=0.00314; // кооф
|
|
input double testlot=0.0314;
|
|
input bool auto=false;
|
|
input sell_or_buy1 s_o_b=all; // поиск сделок
|
|
input stops use_stop=fractal;
|
|
input sell_or_buy1 line_s_o_b=all;
|
|
input ENUM_TIMEFRAMES open_frame=PERIOD_H1; //blue
|
|
input ENUM_TIMEFRAMES open_frame_min=PERIOD_M1;
|
|
input ENUM_TIMEFRAMES stop_frame=PERIOD_M5;
|
|
|
|
input bool use_line=false;
|
|
input bool use_zone=false;
|
|
input bool use_max_lost=false;
|
|
input int max_lost=3;
|
|
input int stop_fr=1;
|
|
input string line_name="top_arr_h1";
|
|
input double usdrub=73.95;
|
|
input double next_risk=0.5;
|
|
bool want_new=true;
|
|
string now_trend="null";
|
|
bool is_open=false;
|
|
double inp[4]; // массив для хранения входных сигналов
|
|
double we[4];
|
|
double we_st[11], we_tp[11];
|
|
double last_max,last_min;
|
|
int last_max_point,last_min_point;
|
|
//double val_st[1], val_tp[1];
|
|
CArrayDouble val_st,val_tp;
|
|
|
|
int OnInit()
|
|
{
|
|
//---
|
|
EventSetTimer(2);
|
|
|
|
/*if(iOpen(NULL,PERIOD_H4,1)>get_fraktal_price(PERIOD_M5,0,1))
|
|
now_trend="sell";
|
|
else now_trend="buy";
|
|
*/
|
|
int i=0;
|
|
for(i=0;i<ArraySize(we);i++){we[i]=0.5;}
|
|
for(i=0;i<ArraySize(we_st);i++){we_st[i]=0.5;we_tp[i]=0.5;}
|
|
//---
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
//---
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTimer()
|
|
{
|
|
//---
|
|
want_new=true;
|
|
//get_fraktal(PERIOD_CURRENT,1,7);
|
|
//get_fraktal(PERIOD_CURRENT,0,7);
|
|
long buy_id,sell_id;
|
|
ulong ticket;
|
|
//string type;
|
|
uint total=PositionsTotal();
|
|
int order_buy_c=0,order_buy_stop=0;
|
|
int order_sell_c=0,order_sell_stop=0;
|
|
double buylot=0,selllot=0,buy_oprice=0,sell_oprice=0,stopprice=0,allprofit=0,all_sl=0,all_tp=0;
|
|
int is_stop=0;
|
|
bool open=true;
|
|
double last_portal_niz=get_fraktal_price(stop_frame,1,stop_fr)-20*_Point;
|
|
double last2_top=get_fraktal_price(stop_frame,0,stop_fr)+(SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)+20)*_Point;
|
|
int handle=iIchimoku(NULL,stop_frame,9,26,52);
|
|
// int handle=iIchimoku(NULL,PERIOD_CURRENT,9,26,52);
|
|
|
|
double red1[],blue1[],span_a[],span_b[];
|
|
if(CopyBuffer(handle,0,0,3,red1)<=0)
|
|
return;
|
|
|
|
ArraySetAsSeries(red1,true);
|
|
if(CopyBuffer(handle,1,0,3,blue1)<=0)
|
|
return;
|
|
ArraySetAsSeries(blue1,true);
|
|
if(CopyBuffer(handle,2,0,3,span_a)<=0)
|
|
return;
|
|
ArraySetAsSeries(span_a,true);
|
|
if(CopyBuffer(handle,3,0,3,span_b)<=0)
|
|
return;
|
|
ArraySetAsSeries(span_b,true);
|
|
|
|
inp[0]=check_res(red1[0]);
|
|
inp[1]=check_res(blue1[0]);
|
|
inp[2]=check_res(span_a[0]);
|
|
inp[3]=check_res(span_b[0]);
|
|
double nero;
|
|
double nero_val=Nero_analys(PERIOD_CURRENT);
|
|
nero=CalculateNeuron(inp,we);
|
|
if(use_stop!=fractal){
|
|
|
|
// Alert(DoubleToString(inp[1]));
|
|
if(use_stop==red){last_portal_niz=red1[0]-20*_Point;last2_top=red1[0]+(SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)+20)*_Point;}
|
|
if(use_stop==blue){last_portal_niz=blue1[0]-20*_Point;last2_top=blue1[0]+(SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)+20)*_Point;}
|
|
}
|
|
//Alert(total);
|
|
|
|
//--- 1 поиск сделок
|
|
|
|
for(uint i=0; i<total; i++)
|
|
{
|
|
//--- получим тикет ордера по его позиции в списке
|
|
if((ticket=PositionGetTicket(i))>0)
|
|
{
|
|
//--- получим свойства ордера
|
|
|
|
// type =EnumToString(ENUM_ORDER_TYPE(OrderGetInteger(ORDER_TYPE)));
|
|
//--- подготовим и выведем информацию об ордере
|
|
// Alert(PositionGetInteger(POSITION_TYPE));
|
|
if(PositionGetString(POSITION_SYMBOL)==_Symbol)
|
|
{
|
|
allprofit+=PositionGetDouble(POSITION_PROFIT);
|
|
double open_price=PositionGetDouble(POSITION_PRICE_OPEN);
|
|
double stop=PositionGetDouble(POSITION_SL);
|
|
int id=PositionGetInteger(POSITION_IDENTIFIER);
|
|
|
|
|
|
if(PositionGetInteger(POSITION_TYPE)==1)
|
|
{
|
|
order_sell_c++;
|
|
all_sl+=find_price(open_price,stop,PositionGetDouble(POSITION_VOLUME),"sl");
|
|
stopprice+=PositionGetDouble(POSITION_VOLUME)*(stop-open_price)/_Point;
|
|
selllot+=PositionGetDouble(POSITION_VOLUME);
|
|
want_new=false;
|
|
|
|
if(last2_top<stop
|
|
//&& last2_top<open_price
|
|
)
|
|
{
|
|
|
|
|
|
if(trade.PositionModify(id,last2_top,PositionGetDouble(POSITION_TP)))
|
|
want_new=true;
|
|
//---
|
|
}
|
|
if(stop<open_price)
|
|
order_sell_stop++;
|
|
}
|
|
else
|
|
{
|
|
order_buy_c++;
|
|
all_sl+=find_price(stop,open_price,PositionGetDouble(POSITION_VOLUME),"sl","buy");
|
|
stopprice+=PositionGetDouble(POSITION_VOLUME)*(open_price-stop)/_Point;
|
|
buylot+=PositionGetDouble(POSITION_VOLUME);
|
|
want_new=false;
|
|
if(last_portal_niz>stop
|
|
// && last_portal_niz>open_price
|
|
)
|
|
{
|
|
|
|
trade.PositionModify(id,last_portal_niz,PositionGetDouble(POSITION_TP));
|
|
|
|
//want_new=true;
|
|
}
|
|
if(stop>open_price)
|
|
order_buy_stop++;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
Bid=SymbolInfoDouble(NULL,SYMBOL_BID);
|
|
Ask=SymbolInfoDouble(NULL,SYMBOL_ASK);
|
|
make_fraktal("h1",PERIOD_H1,clrAqua,3);
|
|
make_fraktal("m5",PERIOD_M5,clrDarkOrange,1);
|
|
make_fraktal("m1",PERIOD_M1,clrYellow,1);
|
|
|
|
make_fraktal("d1",PERIOD_D1,clrDarkGray,4);
|
|
double l_top,l_bot;
|
|
l_top=iHigh(_Symbol,PERIOD_D1,1);
|
|
l_bot=iLow(_Symbol,PERIOD_D1,1);
|
|
if(SymbolInfoDouble(_Symbol,SYMBOL_ASKHIGH)>l_top)
|
|
l_top=SymbolInfoDouble(_Symbol,SYMBOL_ASKHIGH);
|
|
if(l_bot>SymbolInfoDouble(_Symbol,SYMBOL_BIDLOW))
|
|
l_bot=SymbolInfoDouble(_Symbol,SYMBOL_BIDLOW);
|
|
double l_top2=l_top;
|
|
double l_bot2=l_bot;
|
|
if(iOpen(_Symbol,PERIOD_D1,1)<iClose(_Symbol,PERIOD_D1,1))
|
|
{
|
|
l_top2=l_bot;
|
|
l_bot2=l_top;
|
|
// n236=t236;
|
|
}
|
|
ObjectDelete(0,"fib");
|
|
//stop_price
|
|
int all_orders=order_sell_c+order_buy_c;
|
|
if((order_sell_stop==order_sell_c && order_buy_c==0)
|
|
|| (order_buy_stop==order_buy_c && order_sell_c==0)
|
|
)
|
|
{
|
|
string last_ord="null";
|
|
if(order_sell_c>0)
|
|
last_ord="sell";
|
|
if(order_buy_c>0)
|
|
last_ord="buy";
|
|
// есть ли сделки допокупка
|
|
|
|
if(all_orders>0){
|
|
if(last_ord!="null"){
|
|
|
|
// if(find_open_add(PERIOD_M1)!="null" && find_open_add(PERIOD_M1)==last_ord)open_order(find_open_add(PERIOD_M1),"add",1);
|
|
|
|
//1 - niz fraktal 0-vverh
|
|
string f_line=find_open_line("s_o_b",PERIOD_M1,PERIOD_M1);
|
|
string first=find_open_first(PERIOD_M1);
|
|
string f_open=find_open(PERIOD_M1);
|
|
string f_line_bok=find_open_line("m5");
|
|
if(f_line_bok!="null" && f_line_bok==last_ord)open_order(f_line_bok,"bokline",2,all_sl);
|
|
if(f_line!="null" && f_line==last_ord)open_order(f_line,"l1_"+find_open_line("com",1,1),2,all_sl);
|
|
if(f_open!="null" && f_open==last_ord)open_order(f_open,"main",2,all_sl);
|
|
|
|
if(first!="null" && first==last_ord)open_order(first,"ladd1",2,all_sl);
|
|
string f_fr=find_open_fraktal(open_frame_min);
|
|
if(f_fr!="null" && f_fr==last_ord)open_order(f_fr,"a_fr_"+EnumToString(open_frame_min),2,all_sl);
|
|
}
|
|
|
|
}else{
|
|
if(auto==true){
|
|
string fr_ooo=find_open_change(PERIOD_M1);
|
|
if(fr_ooo!="null"){open_order(fr_ooo,"n_ooo");}
|
|
/* string f_fr=find_open_fraktal(open_frame_min);
|
|
if(f_fr!="null" && f_fr==now_trend)open_order(f_fr,"lfr_"+EnumToString(open_frame_min),1);
|
|
|
|
string f_line=find_open_line("s_o_b",PERIOD_M5,PERIOD_M5);
|
|
|
|
if(f_line!="null" && f_line==now_trend)open_order(f_line,"lf5_"+find_open_line("com"),1);
|
|
string find_o=find_open(PERIOD_M5);
|
|
if(find_o!="null" && find_o==now_trend)open_order(find_o,"new_open",1);
|
|
*/
|
|
/*
|
|
if(find_open(open_frame)!="null")
|
|
open_order(find_open(open_frame),"main_h"+EnumToString(open_frame));
|
|
if(find_open_first(PERIOD_M1)!="null")
|
|
open_order(find_open(PERIOD_M1),"first1");
|
|
if(find_open(PERIOD_M1)!="null")
|
|
open_order(find_open(PERIOD_M1),"main1");
|
|
if(find_open_add(PERIOD_M1)!="null")
|
|
open_order(find_open_add(PERIOD_M1),"add1");
|
|
if(find_open_add(PERIOD_M5)!="null")
|
|
open_order(find_open_add(PERIOD_M5),"add_m5");
|
|
*/
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
if(line_s_o_b!=all){
|
|
if(find_open(open_frame)==find_open(open_frame_min))open_order(find_open(open_frame),"nn"+find_open(open_frame));
|
|
}
|
|
ObjectCreate(0,"fib",OBJ_FIBO,0,iTime(NULL,PERIOD_D1,1),l_bot2,TimeCurrent(),l_top2);
|
|
|
|
double testlot2
|
|
=make_lot("buy");
|
|
double sl=find_price(Bid,stop_price("buy"),testlot2,"sl","buy");
|
|
double tp=find_price(Bid,l_top,testlot2);
|
|
string st=n(nero_val)+"|"+n(nero_alltime())+"|"+n(all_sl)+";""l"+testlot2+";sl="+n(sl)+";tp="+n(tp)+";" ;
|
|
/* if(sl!=0)
|
|
st+="b"+n(tp/sl);
|
|
if(tp!=0)st+=";s"+n(sl/tp);
|
|
*/
|
|
//st+="m"+n(all_sl);
|
|
double now_line_top=ObjectGetValueByTime(0,"top_arr_m5",TimeCurrent());
|
|
double now_line_niz=ObjectGetValueByTime(0,"bot_arr_m5",TimeCurrent());
|
|
st+="m1:"+from_to(now_line_niz,now_line_top);
|
|
//+"|"+nero;
|
|
ObjectSetString(0,"text",OBJPROP_TEXT,st);
|
|
// make_bot();
|
|
int spred=SymbolInfoInteger(_Symbol,SYMBOL_SPREAD);
|
|
double up=get_fraktal_next(PERIOD_M5,0,Bid,"up");
|
|
double up2=get_fraktal_next(PERIOD_M5,0,up+(100+spred)*_Point,"up");
|
|
double down=get_fraktal_next(PERIOD_M5,1,Bid,"down");
|
|
double down2=get_fraktal_next(PERIOD_M5,1,down-(100+spred)*_Point,"down");
|
|
make_line("up_line1",up);
|
|
make_line("up_line2",up2);
|
|
make_line("low_line1",down);
|
|
make_line("low_line1",down2);
|
|
// ObjectMove(0,"up_line1",0,TimeCurrent(),up);
|
|
// ObjectMove(0,"up_line2",0,TimeCurrent(),up2);
|
|
//ObjectMove(0,"low_line1",0,TimeCurrent(),down);
|
|
// ObjectMove(0,"low_line2",0,TimeCurrent(),down2);
|
|
make_rect(PERIOD_CURRENT);
|
|
make_rect(PERIOD_M5,2);
|
|
make_rect(PERIOD_H1,1,clrAzure);
|
|
double next_niz=get_fraktal_next(PERIOD_M5,1,up2);
|
|
make_rect1("new_rect",up2,next_niz,iTime(NULL,PERIOD_H1,2),clrAqua);
|
|
//Alert(nero);
|
|
now_trend=get_trend(PERIOD_CURRENT);
|
|
Comment(now_trend,n(all_sl),"w",n(stopprice),"b",n(buylot),"s",n(selllot),"l",make_lot("buy"),"-",order_sell_stop,"-",order_sell_c,st,"-",n(all_sl));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double n(double n)
|
|
{
|
|
return NormalizeDouble(n,2);
|
|
}
|
|
double check_res(double price){
|
|
double out;
|
|
if(Bid>price)out=1;
|
|
else out=0.01;
|
|
out=from_to(price,Bid);
|
|
return out;
|
|
}
|
|
double get_ind(int hand,int buf){
|
|
double ind_val[];
|
|
CopyBuffer(hand,buf,0,3,ind_val);ArraySetAsSeries(ind_val,true);
|
|
return ind_val[0];
|
|
}
|
|
|
|
double Nero_analys(ENUM_TIMEFRAMES frame){
|
|
double red1[],blue1[],span_a[],span_b[],boli_high[],boli_low[],boli_m[],arr_max,arr_min;
|
|
|
|
int h_boli=iBands(NULL,frame,20,0,2,PRICE_CLOSE);
|
|
// Номера буферов: 0 - BASE_LINE, 1 - UPPER_BAND, 2 - LOWER_BAND
|
|
|
|
int handle=iIchimoku(NULL,frame,9,26,52);
|
|
// int handle=iIchimoku(NULL,PERIOD_CURRENT,9,26,52);
|
|
//if(CopyBuffer(h_boli,1,0,3,boli_high)<=0)return;ArraySetAsSeries(boli_high,true);
|
|
|
|
double l_top,l_bot;
|
|
l_top=iHigh(_Symbol,PERIOD_D1,1);
|
|
l_bot=iLow(_Symbol,PERIOD_D1,1);
|
|
if(SymbolInfoDouble(_Symbol,SYMBOL_ASKHIGH)>l_top)
|
|
l_top=SymbolInfoDouble(_Symbol,SYMBOL_ASKHIGH);
|
|
if(l_bot>SymbolInfoDouble(_Symbol,SYMBOL_BIDLOW))
|
|
l_bot=SymbolInfoDouble(_Symbol,SYMBOL_BIDLOW);
|
|
|
|
double fr_niz=get_fraktal_price(frame,1,1)-20*_Point;
|
|
double fr_top=get_fraktal_price(frame,0,1)+(SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)+20)*_Point;
|
|
|
|
double all_pr[10],all_val[10], all_val_sum=0;
|
|
// massiv
|
|
all_pr[0]=get_ind(h_boli,1);
|
|
all_pr[1]=get_ind(h_boli,2);
|
|
all_pr[2]=get_ind(handle,0); //red
|
|
all_pr[3]=get_ind(handle,1); //blue
|
|
all_pr[4]=get_ind(handle,2); //span_a
|
|
all_pr[5]=get_ind(handle,3); //span_b
|
|
//all_pr[6]=l_top;
|
|
//all_pr[7]=l_bot;
|
|
all_pr[6]=fr_niz;
|
|
all_pr[7]=fr_top;
|
|
|
|
all_pr[8]=iHigh(NULL,frame,iHighest(NULL,frame,MODE_CLOSE,5)); //max 5 bars
|
|
all_pr[9]=iLow(NULL,frame,iLowest(NULL,frame,MODE_CLOSE,5)); //min 5 bars
|
|
//all_pr[8]=Ask+20*_Point;
|
|
/*
|
|
|
|
|
|
inp[0]=check_res(red1[0]);
|
|
inp[1]=check_res(blue1[0]);
|
|
inp[2]=check_res(span_a[0]);
|
|
inp[3]=check_res(span_b[0]);*/
|
|
arr_max=all_pr[ArrayMaximum(all_pr)];
|
|
arr_min=all_pr[ArrayMinimum(all_pr)];
|
|
double maxmin=arr_max-arr_min;
|
|
// CDynamicArray val_st,val_tp;
|
|
int arr_size=ArraySize(all_pr);
|
|
for(int n1=0;n1<arr_size;n1++){
|
|
// Bid
|
|
double ind_price=n(all_pr[n1]);
|
|
double val=(Bid-ind_price)/maxmin;
|
|
all_val[n1]=val;
|
|
all_val_sum+=val;
|
|
//if(Bid>ind_price)array_add(val_st,ind_price); else array_add(val_tp,ind_price);
|
|
// val_st.Add()
|
|
if(Bid>ind_price){if(val_st.SearchLinear(ind_price)==-1)val_st.Add(ind_price);} else{
|
|
if(val_tp.SearchLinear(ind_price)==-1)val_tp.Add(ind_price);
|
|
|
|
}
|
|
} string str1="s";
|
|
for(int i=0;i<val_tp.Total();i++)
|
|
{
|
|
double result=val_tp.At(i);
|
|
str1+="|"+i+"-"+result;
|
|
}
|
|
Print("t"+val_tp.Total()+";s"+val_st.Total()+"|"+str1);
|
|
Print("i"+maxmin,"-",all_val_sum+":"+(all_val_sum/arr_size));
|
|
|
|
// int b=val_st.Size();
|
|
Print(print_arr(all_pr));
|
|
|
|
//for(int e=0;e<b;e++)str1=str1+"|"+val_st[e];
|
|
|
|
|
|
// Print("pr"+print_arr(val_st));
|
|
double out=all_val_sum/arr_size;
|
|
string str;
|
|
if(frame==PERIOD_M1){
|
|
if(out>0)str="buy"; else str="sell";
|
|
if(now_trend!=str ){SendNotification(_Symbol+" new tr "+str);
|
|
// now_trend=str;
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
string print_arr(double &x[]){
|
|
string str="";
|
|
for(int i=0;i<ArraySize(x);i++)str+="|"+i+"-"+x[i];
|
|
return str;
|
|
}
|
|
int array_add(double &x[],double add){
|
|
int i=ArraySize(x);
|
|
int b=i+1;
|
|
ArrayResize(x,b);
|
|
Print(i,add);
|
|
x[i]=add;
|
|
return 1;
|
|
}
|
|
|
|
double nero_alltime(){
|
|
//ENUM_TIMEFRAMES
|
|
double out=Nero_analys(PERIOD_M1)+Nero_analys(PERIOD_M5)+Nero_analys(PERIOD_M15)+Nero_analys(PERIOD_M30)+Nero_analys(PERIOD_H1)
|
|
+Nero_analys(PERIOD_H4)+Nero_analys(PERIOD_D1);
|
|
//nero_mas();
|
|
return out/7;
|
|
}
|
|
double nero_mas(){
|
|
//val_tp.Sort();
|
|
for(int i=0;i<val_tp.Total();i++){
|
|
ObjectDelete(0,"tp_l"+i);
|
|
make_line("tp_l"+i,val_tp.At(i),clrDarkRed);
|
|
}
|
|
|
|
for(int b=0;b<val_st.Total();b++){
|
|
ObjectDelete(0,"sl_l"+b);
|
|
make_line("sl_l"+b,val_st.At(b),clrYellowGreen);
|
|
}
|
|
return 0;
|
|
}
|
|
double CalculateNeuron(double &x[],double &w[])
|
|
{
|
|
//--- переменная для хранения средневзвешенной суммы входных сигналов
|
|
double NET=0.0,out;
|
|
//--- В цикле по количеству входов получаем средневзвешенную сумму входов
|
|
double d1=0.0;
|
|
double d2=1.0;
|
|
double x_min=ArrayMinimum(x);
|
|
double x_max=ArrayMaximum(x);
|
|
double xn;
|
|
for(int n=0;n<ArraySize(x);n++)
|
|
{
|
|
// xn=(((x[n]-x_min)*(d2-d1))/(x_max-x_min))+d1;
|
|
xn=x[n];
|
|
NET+=xn*w[n];
|
|
}
|
|
//--- умножаем средневзвешенную сумму входов на добавочный коэффициент
|
|
// NET*=0.4;
|
|
//--- передаем средневзвешенную сумму входов в функцию активации и возвращаем ее значение
|
|
//out=1-1/NET;
|
|
//double out = (exp(NET)-exp(-NET))/(exp(NET)+exp(-NET));
|
|
out=NET;
|
|
out=NormalizeDouble(out,5);
|
|
|
|
return out;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
string make_bot(){
|
|
ENUM_TIMEFRAMES open_frame=PERIOD_H1;
|
|
double ilow=iLow(_Symbol,open_frame,1);
|
|
//ObjectCreate(0,"bot_rect",OBJ_RECTANGLE,1,iTime(_Symbol,open_frame,2),ilow);
|
|
if(ilow>iLow(_Symbol,open_frame,0))
|
|
ilow=iLow(_Symbol,open_frame,0);
|
|
if(iOpen(_Symbol,open_frame,1)>iClose(_Symbol,open_frame,1) && (iClose(_Symbol,open_frame,1)-ilow)>10*_Point
|
|
// && (Bid-iClose(_Symbol,open_frame,1))>_Point*MathAbs(profit_point(iClose(_Symbol,open_frame,1),iOpen(_Symbol,open_frame,1))/2)
|
|
// -&& profit_point(top_rect,Bid)>500
|
|
// && s_o_b!="high_fib"
|
|
)
|
|
{
|
|
|
|
ObjectMove(0,"bot_rect",0,iTime(_Symbol,open_frame,2),ilow);
|
|
ObjectMove(0,"bot_rect",1,TimeCurrent(),iClose(_Symbol,open_frame,1));
|
|
}
|
|
double ihigh=iHigh(_Symbol,open_frame,0);
|
|
if(ihigh<iHigh(_Symbol,open_frame,1))
|
|
ihigh=iHigh(_Symbol,open_frame,1);
|
|
|
|
|
|
if(iOpen(_Symbol,open_frame,1)<iClose(_Symbol,open_frame,1) && (ihigh-iClose(_Symbol,open_frame,1))>10*_Point
|
|
// && (iClose(_Symbol,open_frame,1)-Bid)>_Point*MathAbs(profit_point(iClose(_Symbol,open_frame,1),iOpen(_Symbol,open_frame,1))/2)
|
|
)
|
|
{
|
|
// s_o_b="sell";
|
|
ObjectMove(0,"top_rect",0,iTime(_Symbol,open_frame,2),iClose(_Symbol,open_frame,1));
|
|
ObjectMove(0,"top_rect",1,TimeCurrent(),ihigh);
|
|
}
|
|
return 0;
|
|
}
|
|
string make_fraktal(string name, ENUM_TIMEFRAMES bframe,color clr=clrRed, int width=1)
|
|
{
|
|
//1 - niz fraktal 0-vverh
|
|
int top1,top2,niz1,niz2;
|
|
top1=get_fraktal_point(bframe,0,1);
|
|
top2=get_fraktal_point(bframe,0,2);
|
|
niz1=get_fraktal_point(bframe,1,1);
|
|
niz2=get_fraktal_point(bframe,1,2);
|
|
// Alert("0-"+get_fraktal_point(bframe,0,1)+"-"+get_fraktal_point(PERIOD_CURRENT,0,2));
|
|
// Alert("1-"+get_fraktal_point(PERIOD_CURRENT,1,1)+"-"+get_fraktal_point(PERIOD_CURRENT,1,2));
|
|
string name_top="top_arr_"+name;
|
|
string name_bot="bot_arr_"+name;
|
|
ObjectDelete(0,name_bot);
|
|
ObjectDelete(0,name_top);
|
|
ObjectCreate(0,name_top,OBJ_TREND,0,iTime(NULL,bframe,top2),iHigh(NULL,bframe,top2),iTime(NULL,bframe,top1),iHigh(NULL,bframe,top1));
|
|
ObjectCreate(0,name_bot,OBJ_TREND,0,iTime(NULL,bframe,niz2),iLow(NULL,bframe,niz2),iTime(NULL,bframe,niz1),iLow(NULL,bframe,niz1));
|
|
ObjectSetInteger(0,name_top,OBJPROP_COLOR,clr);
|
|
ObjectSetInteger(0,name_top,OBJPROP_WIDTH,width);
|
|
ObjectSetInteger(0,name_top,OBJPROP_RAY_RIGHT,true);
|
|
ObjectSetInteger(0,name_bot,OBJPROP_COLOR,clr);
|
|
ObjectSetInteger(0,name_bot,OBJPROP_WIDTH,width);
|
|
ObjectSetInteger(0,name_bot,OBJPROP_RAY_RIGHT,true);
|
|
string out="o";
|
|
if(top2-top1<10*_Point)
|
|
out="top_flat";
|
|
return out;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
int get_fraktal_point(ENUM_TIMEFRAMES bframe,int buffer,int shift=0)
|
|
{
|
|
//
|
|
int fra=iFractals(NULL,bframe);
|
|
if(fra<0)
|
|
{
|
|
Print("Объект iMA не создан: MA_handle= ",INVALID_HANDLE);
|
|
Print("Ошибка исполнения = ",GetLastError());
|
|
//--- принудительное завершение программы
|
|
return(-1);
|
|
}
|
|
double fra1[];
|
|
|
|
int i,b=0,max=200;
|
|
CopyBuffer(fra,buffer,0,max,fra1);
|
|
|
|
ArraySetAsSeries(fra1,true);
|
|
string out;
|
|
for(i=0; i<max; i++)
|
|
{
|
|
if(fra1[i]!=EMPTY_VALUE)
|
|
{
|
|
b++;
|
|
if(shift==b)
|
|
break;
|
|
|
|
|
|
}
|
|
}
|
|
// Alert(out);
|
|
return i;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double get_fraktal_price(ENUM_TIMEFRAMES bframe,int buffer,int shift=0)
|
|
{
|
|
int point=get_fraktal_point(bframe,buffer,shift);
|
|
double out;
|
|
if(buffer==1)
|
|
out=iLow(NULL,bframe,point);
|
|
else
|
|
out=iHigh(NULL,bframe,point);
|
|
return out;
|
|
}
|
|
double get_fraktal_next(ENUM_TIMEFRAMES bframe,int buffer,double pr,string more="up"){
|
|
int i,max=200;
|
|
double out;
|
|
if(more=="up"){
|
|
for(i=1; i<max; i++){
|
|
out=get_fraktal_price(bframe,buffer,i);
|
|
if(out>pr) break;
|
|
}
|
|
}
|
|
else{
|
|
for(i=1; i<max; i++){
|
|
out=get_fraktal_price(bframe,buffer,i);
|
|
if(out<pr) break;
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double make_rect(ENUM_TIMEFRAMES bframe,int fr=1, color col=clrDarkOrange){
|
|
//1 - niz fraktal 0-vverh
|
|
get_fraktal_next(bframe,0,Bid,"up");
|
|
double niz=get_fraktal_price(bframe,1,fr);
|
|
double top=get_fraktal_price(bframe,0,fr);
|
|
int topfr=get_fraktal_point(bframe,0,fr);
|
|
int botfr=get_fraktal_point(bframe,1,fr);
|
|
string name_top="top_r"+EnumToString(bframe);
|
|
string name_bot="bot_r"+EnumToString(bframe);
|
|
ObjectCreate(0,name_bot,OBJ_RECTANGLE,0,0,0);
|
|
|
|
if(fr==2)col=clrOrangeRed;
|
|
ObjectSetInteger(0,name_bot,OBJPROP_COLOR,col);
|
|
ObjectSetInteger(0,name_bot,OBJPROP_FILL,1);
|
|
ObjectCreate(0,name_top,OBJ_RECTANGLE,0,0,0);
|
|
ObjectSetInteger(0,name_top,OBJPROP_COLOR,col);
|
|
ObjectSetInteger(0,name_top,OBJPROP_FILL,1);
|
|
ObjectMove(0,name_top,0,iTime(_Symbol,bframe,topfr),top);
|
|
double close1=iClose(_Symbol,bframe,topfr);
|
|
double open1=iOpen(_Symbol,bframe,topfr);
|
|
if(close1<open1)close1=open1;
|
|
ObjectMove(0,name_top,1,TimeCurrent(),close1);
|
|
|
|
double close2=iClose(NULL,bframe,botfr);
|
|
double open2=iOpen(NULL,bframe,botfr);
|
|
if(close2>open2)close2=open2;
|
|
ObjectMove(0,name_bot,0,iTime(NULL,bframe,botfr),close2);
|
|
|
|
ObjectMove(0,name_bot,1,TimeCurrent(),niz);
|
|
return 1;
|
|
}
|
|
int make_rect1(string name_bot,double price1, double price2, datetime time2,color col=clrDarkOrange){
|
|
|
|
ObjectCreate(0,name_bot,OBJ_RECTANGLE,0,0,0);
|
|
|
|
ObjectSetInteger(0,name_bot,OBJPROP_COLOR,col);
|
|
ObjectSetInteger(0,name_bot,OBJPROP_FILL,1);
|
|
|
|
ObjectMove(0,name_bot,0,time2,price2);
|
|
|
|
ObjectMove(0,name_bot,1,TimeCurrent(),price1);
|
|
return 0;
|
|
}
|
|
int make_line(string name,double price,color col=clrYellow){
|
|
|
|
ObjectCreate(0,name,OBJ_HLINE,0,TimeCurrent(),price);
|
|
ObjectSetInteger(0,name,OBJPROP_COLOR,col);
|
|
//--- установим стиль отображения линии
|
|
// ObjectSetInteger(0,up_line1,OBJPROP_STYLE,style);
|
|
//--- установим толщину линии
|
|
ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
|
|
return 1;
|
|
}
|
|
string find_open_first(ENUM_TIMEFRAMES bframe){
|
|
//1 - niz fraktal 0-vverh
|
|
string out="null";
|
|
double niz1=get_fraktal_price(bframe,1,1);
|
|
double niz2=get_fraktal_price(bframe,1,2);
|
|
double niz3=get_fraktal_price(bframe,1,3);
|
|
if(niz2<niz3 && niz2<niz1 && Bid>niz1 )out="buy";
|
|
|
|
double vv1=get_fraktal_price(bframe,0,1);
|
|
double vv2=get_fraktal_price(bframe,0,2);
|
|
double vv3=get_fraktal_price(bframe,0,3);
|
|
if(niz2>niz3 && niz2>niz1 && Bid<niz1 )out="sell";
|
|
|
|
return out;
|
|
}
|
|
string find_open_line(string want="s_o_b",ENUM_TIMEFRAMES bframe=PERIOD_M1,ENUM_TIMEFRAMES line_frame=PERIOD_M5){
|
|
string out="null";
|
|
string out2="null";
|
|
//1 - niz fraktal 0-vverh
|
|
double f_line_top=get_fraktal_price(line_frame,0,1);
|
|
double f_line_bot=get_fraktal_price(line_frame,1,1);
|
|
if(want!="s_o_b" && want!="com"){double f_line_top=ObjectGetValueByTime(0,"top_arr_"+want,TimeCurrent());
|
|
double f_line_bot=ObjectGetValueByTime(0,"bot_arr_"+want,TimeCurrent());}
|
|
|
|
double high1=iHigh(NULL,bframe,1);
|
|
if(iOpen(NULL,bframe,2)<f_line_top && high1>f_line_top && Bid>high1){out="buy";out2="prob_top";} // probivka
|
|
if(iOpen(NULL,bframe,2)<f_line_top && high1>f_line_top && Bid<f_line_top){out="sell";out2="ots_top";} // otskok
|
|
|
|
double low1=iLow(NULL,bframe,1);
|
|
if(iOpen(NULL,bframe,2)>f_line_bot && low1<f_line_bot && Bid<low1){out="sell";out2="prob_niz";} //proboy
|
|
if(iOpen(NULL,bframe,2)>f_line_bot && low1<f_line_bot && Bid>f_line_bot){out="buy";out2="ots_bot";} //otskok
|
|
if(want=="com")out=out2;
|
|
return out;
|
|
}
|
|
string find_open_fraktal(ENUM_TIMEFRAMES bframe){
|
|
string out="null";
|
|
double f_line_top=get_fraktal_price(bframe,0,1);
|
|
int top=get_fraktal_point(bframe,0,1);
|
|
double f_line_bot=get_fraktal_price(bframe,1,1);
|
|
int bot=get_fraktal_point(bframe,1,1);
|
|
if(Bid>f_line_top && bot<top)out="buy";
|
|
if(Bid<f_line_bot && bot>top)out="sell";
|
|
return out;
|
|
}
|
|
string find_open(ENUM_TIMEFRAMES bframe)
|
|
{
|
|
//1 - niz fraktal 0-vverh
|
|
string out="null";
|
|
int top1,top2,top3,niz1,niz2,niz3;
|
|
top1=get_fraktal_point(bframe,0,1);
|
|
top2=get_fraktal_point(bframe,0,2);
|
|
niz1=get_fraktal_point(bframe,1,1);
|
|
niz2=get_fraktal_point(bframe,1,2);
|
|
niz3=get_fraktal_point(bframe,1,3);
|
|
top3=get_fraktal_point(bframe,0,3);
|
|
if(iHigh(NULL,bframe,top3)<iHigh(NULL,bframe,top2) && iHigh(NULL,bframe,top1)<iHigh(NULL,bframe,top2) &&
|
|
iLow(NULL,bframe,niz1)> iLow(NULL,bframe,niz2) && iLow(NULL,bframe,niz1)>Bid)
|
|
out="sell";
|
|
|
|
if(iHigh(NULL,bframe,top2)>iHigh(NULL,bframe,top1)
|
|
//&& iHigh(NULL,bframe,top1)>iHigh(NULL,bframe,top2)
|
|
&& iLow(NULL,bframe,niz3)>iLow(NULL,bframe,niz2) && iLow(NULL,bframe,niz2)<iLow(NULL,bframe,niz1)
|
|
&& iHigh(NULL,bframe,top1)<Bid)
|
|
out="buy";
|
|
return out;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
string find_open_add(ENUM_TIMEFRAMES bframe)
|
|
{
|
|
string out="null";
|
|
double low1=iLow(NULL,bframe,1);
|
|
//ObjectGetDouble(0,"bot_arr_m1",
|
|
if(get_trend(bframe)=="sell" && get_fraktal_price(bframe,0,1)>Bid)
|
|
out="sell";
|
|
if(get_trend(bframe)=="buy" && Bid-get_fraktal_price(bframe,1,1)>SymbolInfoInteger(NULL,SYMBOL_SPREAD)*_Point)
|
|
out="buy";
|
|
|
|
return out;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
string check_line(string s_b){
|
|
string out;
|
|
double line=ObjectGetDouble(0,"my",OBJPROP_PRICE);
|
|
double line_niz=ObjectGetDouble(0,"my_niz",OBJPROP_PRICE);
|
|
if(use_line==true){
|
|
|
|
|
|
if(s_o_b==buy && Bid>line)out="buy";
|
|
if(s_o_b==sell && Bid<line)out="sell";
|
|
}else out=s_b;
|
|
if(use_zone==true){
|
|
if(s_o_b==buy){
|
|
if(Bid<line && Bid>line_niz)out="buy";
|
|
}
|
|
if(s_o_b==sell){
|
|
if(Bid>line_niz && Bid<line)out="sell";
|
|
}
|
|
}else out=s_b;
|
|
return out;
|
|
}
|
|
|
|
double open_order(string s_b,string com,int bar=2,double sum=0)
|
|
{
|
|
double lot=make_lot(s_b,sum);
|
|
string check=check_line(s_b);
|
|
if(SymbolInfoInteger(NULL,SYMBOL_SPREAD)<50 && check==s_b)
|
|
{
|
|
if(s_b=="sell"){
|
|
if(auto==false) trade.Sell(lot,NULL,0,stop_price("sell",bar),0,com);
|
|
else{
|
|
if(s_o_b==sell || s_o_b==all)trade.Sell(lot,NULL,0,stop_price("sell",bar),0,com);
|
|
}
|
|
}
|
|
if(s_b=="buy"){
|
|
if(auto==false)trade.Buy(lot,NULL,0,stop_price("buy",bar),0,com);
|
|
else{
|
|
if(s_o_b==buy || s_o_b==all) trade.Buy(lot,NULL,0,stop_price("buy",bar),0,com);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double make_lot(string ss,double sum=0)
|
|
{
|
|
|
|
double free=AccountInfoDouble(ACCOUNT_MARGIN_FREE);
|
|
double mkoof=koof;
|
|
|
|
if(sum>0){
|
|
if(sum>testlot*free){
|
|
free=sum;mkoof=next_risk;
|
|
}else{mkoof=testlot;}
|
|
}
|
|
double stop=stop_price(ss);
|
|
double cross=0.00001;
|
|
if(ss=="sell")
|
|
cross=stop-Bid;
|
|
if(ss=="buy")
|
|
cross=Ask-stop;
|
|
|
|
// return 0;
|
|
int point=cross/_Point;
|
|
double min=SymbolInfoDouble(NULL,SYMBOL_VOLUME_MIN);
|
|
double m;
|
|
if(point>0)
|
|
m=free*mkoof/point;
|
|
else
|
|
m=min;
|
|
if(AccountInfoString(ACCOUNT_CURRENCY)=="RUB")
|
|
m=(free/usdrub)*mkoof/point;
|
|
|
|
m=NormalizeDouble(m,2);
|
|
|
|
if(m<=min)
|
|
m=min;
|
|
return m;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double find_price(double open_price,double to_price, double lot,string want="tp",string s_b="sell")
|
|
{
|
|
double out=0.1;
|
|
if(want=="tp")
|
|
{
|
|
if(s_b=="sell")
|
|
{
|
|
out=(open_price-to_price)/_Point*lot;
|
|
}
|
|
if(s_b=="buy")
|
|
{
|
|
out=(to_price-open_price)/_Point*lot;
|
|
}
|
|
}
|
|
if(want=="sl")
|
|
{
|
|
if(s_b=="buy")
|
|
{
|
|
out=(open_price-to_price)/_Point*lot;
|
|
}
|
|
if(s_b=="sell")
|
|
{
|
|
out=(open_price-to_price)/_Point*lot;
|
|
}
|
|
}
|
|
if(AccountInfoString(ACCOUNT_CURRENCY)=="RUB")out=out*usdrub/100;
|
|
return out;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double stop_price(string s_b,int bar=1)
|
|
{
|
|
double out,add;
|
|
add=(SymbolInfoInteger(_Symbol,SYMBOL_SPREAD)+20)*_Point;
|
|
|
|
int level=SymbolInfoInteger(NULL,SYMBOL_TRADE_STOPS_LEVEL);
|
|
if(s_b=="sell")
|
|
{
|
|
double top1=get_fraktal_point(stop_frame,0,bar);
|
|
top1=get_fraktal_next(stop_frame,0,top1);
|
|
out=iHigh(NULL,stop_frame,top1)+add;
|
|
if((out-Ask)/_Point <level)
|
|
out=Ask+(level+10)*_Point;
|
|
}
|
|
if(s_b=="buy")
|
|
{
|
|
double niz=get_fraktal_point(stop_frame,1,bar);
|
|
niz=get_fraktal_next(stop_frame,1,niz);
|
|
out=iLow(NULL,stop_frame,niz)-10*_Point;
|
|
if((Ask-out)/_Point <level)
|
|
out=Bid-(level+10)*_Point;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
string get_trend(ENUM_TIMEFRAMES bframe)
|
|
{
|
|
//1 - niz fraktal 0-vverh
|
|
string out="null";
|
|
int niz_point1=get_fraktal_point(bframe,1,1);
|
|
int niz_point2=get_fraktal_point(bframe,1,2);
|
|
int top_point1=get_fraktal_point(bframe,0,1);
|
|
int top_point2=get_fraktal_point(bframe,0,2);
|
|
double top_price1=get_fraktal_price(bframe,0,1);
|
|
double top_price2=get_fraktal_price(bframe,0,2);
|
|
double niz_price1=get_fraktal_price(bframe,1,1);
|
|
double niz_price2=get_fraktal_price(bframe,1,2);
|
|
|
|
if(niz_price1>niz_price2 && top_price1>top_price2){
|
|
out="buy";
|
|
|
|
if(Bid>top_price1 )out="cool_buy";
|
|
if(Bid<niz_price1){out="change_sell";last_min=niz_price1;last_min_point=niz_point1;}
|
|
|
|
}
|
|
if(niz_price1<niz_price2 && top_price1<top_price2){
|
|
out="sell";
|
|
|
|
if(Bid>top_price1){out="change_buy"; last_max=top_price1;last_max_point=top_point1;}
|
|
if(Bid<niz_price1)out="cool_sell";
|
|
}
|
|
return out;
|
|
}
|
|
string find_open_change(ENUM_TIMEFRAMES bframe){
|
|
string trend=get_trend(bframe);
|
|
string out="null";
|
|
int top_point1=get_fraktal_point(bframe,0,1);
|
|
double top_price1=get_fraktal_price(bframe,0,1);
|
|
|
|
// from buy change to sell
|
|
if(trend=="change_sell"){
|
|
if(last_min > top_price1 && last_min_point> top_point1)out="sell";
|
|
}
|
|
int niz_point1=get_fraktal_point(bframe,1,1);
|
|
double niz_price1=get_fraktal_price(bframe,1,1);
|
|
if(trend=="change_buy"){
|
|
if(last_max <niz_price1 && niz_point1<last_max_point)out="buy";
|
|
|
|
}
|
|
return out;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool free_balance()
|
|
{
|
|
double free=AccountInfoDouble(ACCOUNT_MARGIN_FREE);
|
|
double bal=AccountInfoDouble(ACCOUNT_BALANCE);
|
|
// if(free>bal)
|
|
return 0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double stop_balance()
|
|
{
|
|
return 0;
|
|
}
|
|
int from_to(double niz,double vverh){
|
|
int out=(vverh-niz)/_Point;
|
|
return out;
|
|
}
|
|
/*
|
|
double open_order(){
|
|
|
|
MqlTradeRequest m_request; // request data
|
|
MqlTradeResult m_result;
|
|
m_request.action =TRADE_ACTION_DEAL;
|
|
m_request.symbol =NULL;
|
|
//m_request.magic =m_magic;
|
|
m_request.volume =0.01;
|
|
m_request.type =ORDER_TYPE_SELL;
|
|
m_request.price =Bid;
|
|
/* m_request.sl =sl;
|
|
m_request.tp =tp;
|
|
m_request.deviation=m_deviation;
|
|
|
|
m_request.comment="test";
|
|
return(OrderSend(m_request,m_result));
|
|
}
|
|
*/
|
|
//+------------------------------------------------------------------+
|