iK_tay_v01
Download script
This script is a sophisticated mathematical tool designed for MetaTrader to analyze price movements and identify the most effective trading parameters—specifically regarding "Take Profit" (TP) and "Stop Loss" (SL) levels—based on historical market behavior.
Instead of using simple visual cues, the logic employs an optimization process that simulates various market scenarios to see which settings historically yield the highest returns. Here is a breakdown of how the logic functions:
Core Logic Overview
The indicator works by "stress-testing" different trading rules against your historical price data. It looks for patterns where the market moves in specific directions and measures whether those movements reached target goals or hit safety limits first.
Key Components of the Analysis
-
Comparative Strategies: The script evaluates two distinct mathematical philosophies:
- "Today as Yesterday": This assumes that the current price movement will mirror the magnitude and behavior of recent past data.
- "Today NOT as Yesterday": This explores an inverse logic, looking for opportunities where the market behaves differently than its immediate history.
-
Optimization Loops: The script does not just pick one random setting. It runs multiple "loops" to find the best values for three specific variables:
- Reference Range ("Yesterday"): Determining how much price movement is considered "normal."
- Stop Loss (SL): Finding the optimal distance to set a safety net to prevent large losses.
- Take Profit (TP): Identifying the sweet spot for capturing gains without letting the profit disappear.
-
Dynamic History Scanning: Depending on the timeframe you are viewing (e.g., 5-minute charts vs. Daily charts), the script automatically adjusts how many historical bars it analyzes to ensure the data is relevant to your current trading speed.
How it Determines "Success"
The indicator performs a simulation for every iteration:
- It looks at the high, low, and closing prices of previous candles.
- It identifies whether a "Buy" or "Sell" signal would have occurred based on the chosen rules.
- It then calculates the outcome: Did the price move far enough to hit the Take Profit? Did it drop far enough to hit the Stop Loss? Or did it simply close halfway (calculating a partial profit/loss)?
- Weighting: It applies a mathematical weight to these outcomes, giving more significance to results that occur earlier in the sequence.
Final Output
After scanning all possibilities, the script selects the "winning" combination—the specific set of Take Profit and Stop Loss levels that resulted in the highest cumulative value during the test period. It then displays these optimized values on your chart as a visual guide, effectively telling you: "Based on the history of this specific asset, these are the most mathematically sound targets for your next trade."
Miscellaneous
12
Views
0
Downloads
0
Favorites
iK_tay_v01
//+------------------------------------------------------------------+
//| iK_tay_v01.mq4 |
//| Ivan Katsko |
//+------------------------------------------------------------------+
#property copyright "Ivan Katsko"
#property link ""
#property indicator_separate_window // Îòîáðàæåíèå â îòäåëüíîì îêíå
#property indicator_buffers 7 // Êîëè÷åñòâî áóôåðîâ
#property indicator_color1 DeepPink // Öâåò ïåðâîé ëèíèè
#property indicator_color2 Purple // Öâåò âòîðîé ëèíèè
#property indicator_color3 Red // Öâåò òðåòüåé ëèíèè
#property indicator_color4 LawnGreen // Öâåò ÷åðâåðòîé ëèíèè
#property indicator_color5 Gold // Öâåò ïÿòîé ëèíèè
#property indicator_color6 DarkBlue // Öâåò øåñòîé ëèíèè
#property indicator_color7 SteelBlue // Öâåò ñåäüìîé ëèíèè
extern int Discret=1; // Äèñêðåòíîñòü ïîäáîðà: 1 - êàæäàÿ ïîçèöèÿ; 2 - ÷åðåç ïîçèöèþ è ò.ä.
extern double Level=10; // Ìèíèìàëüíûé óðîâåíü SL/TP
int i,j,x,
Repeat_Count=30, // Êîëè÷åñòâî ïîâòîðîâ
Action_Count, // Êîëè÷åñòâî ñäåëîê
History, // Êîëè÷.áàðîâ â ðàñ÷¸òíîé èñòîðèè
Iteration; // Êîëè÷.èòåðàöèé
static datetime New_Time;
double
k, // Êîýô.
Alg_Minus=-0.001, // Àëãîðèòì: "ñåãîäíÿ - íå êàê â÷åðà"
Alg_Plus = 0.001, // Àëãîðèòì: "ñåãîäíÿ - êàê â÷åðà"
Buy = 0.001, // Âåëè÷èíà èíäèêàòîðà
Sell=-0.001, // Âåëè÷èíà èíäèêàòîðà
Scope_Up, // Ðàçìàõ Ââåðõ
Scope_Dn, // Ðàçìàõ Âíèç
Max_Alg_Minus, // Ìàêñèìóì äëÿ àëãîðèòìà "ìèíóñ"
Max_Alg_Plus, // Ìàêñèìóì äëÿ àëãîðèòìà "ïëþñ"
Max_Value=-0.1,
YT_Alg_Minus,
TP_Alg_Minus,
SL_Alg_Minus,
Set_Alg_Minus,
YT_Alg_Plus,
TP_Alg_Plus,
SL_Alg_Plus,
Set_Alg_Plus,
Scope_Cl, // Ðàçìàõ çàêðûòèÿ
Repeat[30,3], // Ìàññèâ ïîâòîðîâ ïîâòîðèòü
Algoritm[], // Àëãîðèòì: 1 - "ñåãîäíÿ êàê â÷åðà", -1 - "ñåãîäíÿ íå êàê â÷åðà"
Direction[], // Íàïðàâëåíèå ïðèêàçà: 1 - ïîêóïêà, -1 - ïðîäàæà
Value_TP[], // Ìàññèâ - Çíà÷åíèå Òåéê Ïðîôèò äàëåå áóäåò ïåðåîïðåäåëåí ðàçìåð
Sum_TP[], // Ìàññèâ - Íàðàñòàþùåé àäàïòèâíîé ñóììû Òåéê Ïðîôèò
Sum_na_TP[], // Ìàññèâ - Íàðàñòàþùåé ñóììû Òåéê Ïðîôèò
Im_Sum_TP[30], // Ìàññèâ - ïðîìåæóòî÷íîé Íàðàñòàþùåé ñóììû Òåéê Ïðîôèò
Spread, // Ñïðåä
Set_YT, // Çàäàííûé ðàçìàõ "â÷åðà"
Set_TP[], // Çàäàííûé Òåéê Ïðîôèò
Set_SL[], // Çàäàííûé Ñòîï Ëîññ
Found_TP, // Íàéäåííîå çíà÷åíèå Òåéê Ïðîôèò
Found_SL, // Íàéäåííîå çíà÷åíèå Ñòîï Ëîññ
Found_Scope_YT; // Íàéäåííûé ðàçìàõ "â÷åðà"
bool
New_Bar=false; // Ôëàã íîâîãî áàðà
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
{
if (Discret<=0)
{
Discret=1; // Íå êîððåêòíî ââåäåí äèñêðåò
Alert ("Äèñêðåòíîñòü óñòàíîâëåíà ðàâíîé 1");
}
New_Time=Time[0]; // Âðåìÿ òåêóùåãî áàðà
Spread=MarketInfo(Symbol(), MODE_SPREAD)*Point;
SetIndexBuffer(0,Set_TP); // Íàçíà÷åíèå ìàññèâà Òåéê Ïðîôèò
SetIndexStyle (0,DRAW_LINE,STYLE_SOLID,2); // Ñòèëü ëèíèè
SetIndexBuffer(1,Set_SL); // Íàçíà÷åíèå ìàññèâà Ñòîï Ëîññ
SetIndexStyle (1,DRAW_LINE,STYLE_SOLID,1); // Ñòèëü ëèíèè
SetIndexBuffer(2,Sum_TP); // Íàçíà÷åíèå ìàññèâà ñóììà ïðîôèòà
SetIndexStyle (2,DRAW_LINE,STYLE_SOLID,2); // Ñòèëü ëèíèè
SetIndexBuffer(3,Direction); // Íàçíà÷åíèå ìàññèâà Íàïðàâëåíèå òîðãîâëè
SetIndexStyle (3,DRAW_HISTOGRAM,STYLE_SOLID,4); // Ñòèëü ëèíèè
SetIndexBuffer(4,Algoritm); // Íàçíà÷åíèå ìàññèâà àëãîðèòìà
SetIndexStyle (4,DRAW_LINE,STYLE_SOLID,1); // Ñòèëü ëèíèè
SetIndexBuffer(5,Value_TP); // Íàçíà÷åíèå ìàññèâà Ïðîôèòà
SetIndexStyle (5,DRAW_HISTOGRAM,STYLE_SOLID,2); // Ñòèëü ëèíèè
switch (Period()) // Óñòàíîâêà êîëè÷.èññëåäóåìûõ áàðîâ
{
case 5: History = 24; break; // Ïåðèîä 5-òè ìèíóòíûé
case 15: History = 24; break; // Ïåðèîä 15-òè ìèíóòíûé
case 30: History = 24; break; // Ïåðèîä 30-òè ìèíóòíûé
case 60: History = 24; break; // Ïåðèîä ÷àñîâîé
case 240: History = 30; break; // Ïåðèîä 4-õ ÷àñîâîé
case 1440: History = 22; break; // Ïåðèîä äíåâíîé
default: Alert("Âûáåðèòå ïåðèîä îò M5 äî D1."); break;// Íåâåðíî âûáðàí ïåðèîä
}
return(0);
}
//+------------------------------------------------------------------+
int start()
{
Fun_New_Bar(); // Îïðåäåëåíèå íà÷àëà íîâîãî áàðà
for (int n=1; n<3; n++) // Äëÿ äâóõ âàðèàíòîâ àëãîðèòìîâ
{
Fun_Sum_TP(10*Point,10*Point,10*Point,Alg_Minus); // Èùåì ÷èñëî èòåðàöèé (ðàâíî íàèáîëüøåìó ðàçìàõó)
Set_YT =0.5*Iteration*Discret*Point; // Íà÷àëüíûé ðàçìàõ "â÷åðà"
Set_SL[0]=0.5*Iteration*Discret*Point; // Íà÷àëüíûé Ñòîï Ëîññ
Set_TP[0]=0.5*Iteration*Discret*Point; // Íà÷àëüíûé Òåéê Ïðîôèò
Alg_Minus=-0.25*Set_SL[0];
Alg_Plus = 0.25*Set_TP[0];
if (n==1) Algoritm[0]=Alg_Minus; // Ïåðâûé ïðîõîä - àëãîðèòì "ñåãîäíÿ íå êàê â÷åðà"
if (n==2) Algoritm[0]=Alg_Plus; // Âòîðîé ïðîõîä - àëãîðèòì "ñåãîäíÿ êàê â÷åðà"
Repeat_Count=5+History/MathSqrt(Iteration*Discret/10);
ArrayResize(Repeat,Repeat_Count); // Èçìåíåí ðàçìåð ìàññèâà
ArrayResize(Im_Sum_TP,Repeat_Count); // Èçìåíåí ðàçìåð ìàññèâà
ArrayInitialize(Im_Sum_TP,0); // Î÷èñòèòü ìàññèâ ñóìì
ArrayInitialize(Repeat,0); // Î÷èñòèòü ìàññèâ ïîâòîðîâ
Action_Count=0; // Îáíóëèì ñ÷åò÷èê êîëè÷åñòâà ñäåëîê
x=0; // Ñáðîñèòü èíäåêñ ìàññèâ ïîâòîðîâ
while (Action_Count<History/2 // Ïîêà ÷èñëî ñäåëîê ìåíüøå ïîëîâèíû
|| Sum_TP[0]<0)
{ // áóäåì èñêàòü äðóãîé âàðèàíò
Action_Count=0; // Îáíóëèì ñ÷åò÷èê êîëè÷åñòâà ñäåëîê
//---- Îïðåäåëÿåì îïòèìàëüíîå çíà÷åíèå "â÷åðà"
for (j=0; j<Iteration-1; j++)
{
if (j==0)
{
Max_Value=-0.1;
Set_YT=0;
}
Set_YT += Discret*Point;
if (Fun_Repeat(Set_YT,Set_SL[0],Set_TP[0])) continue;// Åñëè òàêîé âàðèàíò áûë - âçÿòü ñëåäóþùèé
Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Algoritm[0]); // Èùåì ìàêñèìàëüíîå çíà÷åíèå "â÷åðà"
if (Max_Value<Sum_TP[0])
{
Max_Value=Sum_TP[0];
Found_Scope_YT=Set_YT;
}
}
Set_YT=Found_Scope_YT; // Íàøëè ìàêñèìàëüíîå çíà÷åíèå "â÷åðà"
//---- Îïðåäåëÿåì îïòèìàëüíîå çíà÷åíèå Ñòîï Ëîññ
for (j=0; j<Iteration-1; j++)
{
if (j==0)
{
Max_Value=-0.1;
Set_SL[0]=Level*Point; // Íà÷èíàÿ îò ìèíèìàëüíî äîïóñòèìîãî óðîâíÿ
}
Set_SL[0] += Discret*Point;
if (Fun_Repeat(Set_YT,Set_SL[0],Set_TP[0])) continue;// Åñëè òàêîé âàðèàíò áûë - âçÿòü ñëåäóþùèé
Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Algoritm[0]); // Ìàêñèìàëüíîå çíà÷åíèå Ñòîï Ëîññ
if (Max_Value<Sum_TP[0])
{
Max_Value=Sum_TP[0];
Found_SL=Set_SL[0];
}
}
Set_SL[0]=Found_SL; // Íàøëè ìàêñèìàëüíîå çíà÷åíèå Ñòîï Ëîññ
//---- Îïðåäåëÿåì îïòèìàëüíîå çíà÷åíèå Òåéê Ïðîôèò
for (j=0; j<Iteration-1; j++)
{
if (j==0)
{
Max_Value=-0.1;
Set_TP[0]=Level*Point; // Íà÷èíàÿ îò ìèíèìàëüíî äîïóñòèìîãî óðîâíÿ
}
Set_TP[0] += Discret*Point;
if (Fun_Repeat(Set_YT,Set_SL[0],Set_TP[0])) continue;// Åñëè òàêîé âàðèàíò áûë - âçÿòü ñëåäóþùèé
Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Algoritm[0]); // Ìàêñèìàëüíîå çíà÷åíèå Òåéê Ïðîôèò
if (Max_Value<Sum_TP[0])
{
Max_Value=Sum_TP[0];
Found_TP=Set_TP[0];
}
}
Set_TP[0]=Found_TP; // Íàøëè ìàêñèìàëüíîå çíà÷åíèå Òåéê Ïðîôèò
Alg_Minus=-0.25*Set_SL[0];
Alg_Plus = 0.25*Set_TP[0];
if (n==1) Algoritm[0]=Alg_Minus; // Ïåðâûé ïðîõîä - àëãîðèòì "ñåãîäíÿ íå êàê â÷åðà"
if (n==2) Algoritm[0]=Alg_Plus; // Âòîðîé ïðîõîä - àëãîðèòì "ñåãîäíÿ êàê â÷åðà"
//---- Êîëè÷åñòâî ñëåäîê çà âñå âðåìÿ íå äîëæíî áûòü ìåíüøå ïîëîâèíû âîçìîæíûõ
Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Algoritm[0]); // Ïîñìîòðèì ñêîëüêî ïîëó÷àåòñÿ ñäåëîê
for (j=0; j<=History-1; j++) // Ïîäñ÷åò ÷èñëà ñäåëîê
if (Direction[j]!=0) Action_Count+=1;
if (Action_Count<History/2 // Åñëè ÷èñëî ñäåëîê ìåíüøå ïîëîâèíû
|| Sum_TP[0]<0)
{
Repeat[x,0] =Set_YT; // çàïîìíèòü ýòîò âàðèàí YT
Repeat[x,1] =Set_SL[0]; // çàïîìíèòü ýòîò âàðèàíò SL
Repeat[x,2] =Set_TP[0]; // çàïîìíèòü ýòîò âàðèàíò ÒÐ
Im_Sum_TP[x]=Sum_TP[0]; // çàïîìíèòü ýòîò âàðèàíò Sum
x++;
}
if (x==Repeat_Count) // íåò îïòèìàëüíûõ âàðèàíòîâ
{ // îïðåäåëèì ëó÷øèé èç õóäøèõ
Sum_TP[0]=Im_Sum_TP[ArrayMaximum(Im_Sum_TP)];
Set_YT =Repeat[ArrayMaximum(Im_Sum_TP),0];
Set_SL[0]=Repeat[ArrayMaximum(Im_Sum_TP),1];
Set_TP[0]=Repeat[ArrayMaximum(Im_Sum_TP),2];
break; // Çàêîí÷èòü while
}
} // Êîíåö while
if (n==1)
{
Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Alg_Minus); // Îáíîâèì âñå
Max_Alg_Minus=Sum_TP[0];
YT_Alg_Minus=Set_YT;
TP_Alg_Minus=Set_TP[0];
SL_Alg_Minus=Set_SL[0];
Set_Alg_Minus=Alg_Minus;
}
if (n==2)
{
Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Alg_Plus); //Îáíîâèì âñå
Max_Alg_Plus =Sum_TP[0];
YT_Alg_Plus=Set_YT;
TP_Alg_Plus=Set_TP[0];
SL_Alg_Plus=Set_SL[0];
Set_Alg_Plus=Alg_Plus;
}
} // Êîíåö äâóõ âàðèàíòîâ àëãîðèòìîâ
if (Max_Alg_Minus>=Max_Alg_Plus) // Åñëè ëó÷øèì îêàçàëñÿ àäãîðèòì "ìèíóñ"
{
Max_Value=Max_Alg_Minus;
Set_YT=YT_Alg_Minus;
for (i=0; i<History/3; i++)
{
Set_TP[i]=TP_Alg_Minus;
Set_SL[i]=SL_Alg_Minus;
if (Max_Alg_Minus>0)
Algoritm[i]=Set_Alg_Minus;
else
Algoritm[i]=0;
Alg_Minus=Set_Alg_Minus;
}
}
else
{
Max_Value=Max_Alg_Plus;
Set_YT=YT_Alg_Plus;
for (i=0; i<History/3; i++)
{
Set_TP[i]=TP_Alg_Plus;
Set_SL[i]=SL_Alg_Plus;
if (Max_Alg_Plus>0)
Algoritm[i]=Set_Alg_Plus;
else
Algoritm[i]=0;
Alg_Plus=Set_Alg_Plus;
}
}
Buy = 0.5*Set_YT;
Sell=-0.5*Set_SL[0];
Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Algoritm[0]); // Íàðèñóåì îêîí÷àòåëüíûé ãðàôèê
return(0);
}
//+------------------------------------------------------------------+
double Fun_Sum_TP(double set_YT, // Ô-èÿ îïðåäåëåíèÿ íàðàñòàþùåãî çíà÷åíèÿ Òåéê Ïðîôèò
double set_SL,double set_TP,double algoritm)
{
int i, // Èíäåêñ áàðà
Count_bars; // Êîëè÷åñòâî ïðîñ÷èòàííûõ áàðîâ
Sum_TP[History]=0; // Îáíóëèì ïîñëåäíèå çíà÷åíèÿ
Sum_na_TP[History]=0;
Direction[History]=0;
Value_TP[History-1]=0;
i=Bars-1; // Èíäåêñ ïåðâîãî
if (i>History-1) // Åñëè ìíîãî áàðîâ òî ..
i=History-1; // ..ðàññ÷èòûâàòü çàäàííîå êîëè÷.
while(i>=0) // Öèêë ïî áàðàì
{
//---- Îïðåäåëèì ðàçìàõ
Scope_Up=(High[i] -Open[i]); // Çíà÷åíèå Ðàçìàõà Ââåðõ íà i-îì áàðå
Scope_Dn=(Low[i] -Open[i]); // Çíà÷åíèå Ðàçìàõà Âíèç íà i-îì áàðå
Scope_Cl=(Close[i]-Open[i]); // Çíà÷åíèå Ðàçìàõà Çàêðûòèÿ íà i-îì áàðå
//---- Îïðåäåëèì êîëè÷åñòâî èòåðàöèé
if ( Scope_Up>Iteration*Discret*Point) Iteration= (Scope_Up/Point)/Discret;
if (-Scope_Dn>Iteration*Discret*Point) Iteration=(-Scope_Dn/Point)/Discret;
//---- Îïðåäåëèì íàïðàâëåíèå ïðèêàçà
if ((Scope_Up>=(-Scope_Dn) // Åñëè ðàçìàõ ââåðõ áîëüøå ðàçìàõà âíèç
&& Scope_Up>=set_YT // áîëüøå çàäàííîãî ðàçìàõà "â÷åðà"
&& algoritm==Alg_Plus) // çàäàí àëãîðèòì "ñåãîäíÿ êàê â÷åðà"
|| // ÈËÈ
(Scope_Up<(-Scope_Dn) // Åñëè ðàçìàõ âíèç áîëüøå ðàçìàõà ââåðõ
&& (-Scope_Dn)>=set_YT // áîëüøå çàäàííîãî ðàçìàõà "â÷åðà"
&& algoritm==Alg_Minus)) // çàäàí àëãîðèòì "ñåãîäíÿ íå êàê â÷åðà"
{
Direction[i]=Buy; // íàäî ïîêóïàòü
}
if ((Scope_Up>(-Scope_Dn) // Åñëè ðàçìàõ ââåðõ áîëüøå ðàçìàõà âíèç
&& Scope_Up>=set_YT // áîëüøå çàäàííîãî ðàçìàõà "â÷åðà"
&& algoritm==Alg_Minus) // çàäàí àëãîðèòì "ñåãîäíÿ íå êàê â÷åðà"
|| // ÈËÈ
(Scope_Up<(-Scope_Dn) // Åñëè ðàçìàõ âíèç áîëüøå ðàçìàõà ââåðõ
&& (-Scope_Dn)>=set_YT // áîëüøå çàäàííîãî ðàçìàõà "â÷åðà"
&& algoritm==Alg_Plus)) // çàäàí àëãîðèòì "ñåãîäíÿ êàê â÷åðà"
{
Direction[i]=Sell; // íàäî ïðîäàâàòü
}
if ((Scope_Up>=(-Scope_Dn) // Åñëè ðàçìàõ ââåðõ áîëüøå ðàçìàõà âíèç
&& Scope_Up<set_YT) // ìåíüøå ðàçìàõà "â÷åðà"
|| // ÈËÈ
(Scope_Up<=(-Scope_Dn) // Åñëè ðàçìàõ âíèç áîëüøå ðàçìàõà ââåðõ
&& (-Scope_Dn)<set_YT)) // ìåíüøå ðàçìàõà "â÷åðà"
{
Direction[i]=0; // íàïðàâëåíèå íå îïðåäåëåíî
}
//---- Îïðåäåëèì çíà÷åíèÿ Òåéê Ïðîôèò ïðè âûèãðàøå
if ((Direction[i+1]==Buy // Åñëè íàäî ïîêóïàòü
&& Scope_Up>=(set_TP+Spread) // ðàçìàõ ââåðõ áîëüøå Òåéê Ïðîôèòà + Ñïðåä
&& (-Scope_Dn)<(set_SL-Spread)) // ðàçìàõ âíèç ìåíüøå Ñòîï Ëîññà - Ñïðåä
|| // ÈËÈ
(Direction[i+1]==Sell // Åñëè íàäî ïðîäàâàòü
&& (-Scope_Dn)>=(set_TP+Spread) // ðàçìàõ âíèç áîëüøå Òåéê Ïðîôèòà + Ñïðåä
&& Scope_Up<(set_SL-Spread))) // ðàçìàõ ââåðõ ìåíüøå Ñòîï Ëîññà - Ñïðåä
Value_TP[i]=set_TP; // ïîëó÷åí çàäàííûé Òåéê Ïðîôèò
//---- Îïðåäåëèì çíà÷åíèÿ Òåéê Ïðîôèò ïðè ïðîèãðûøå
if ((Direction[i+1]==Buy // Åñëè íàäî ïîêóïàòü
&& (-Scope_Dn)>=(set_SL-Spread)) // ðàçìàõ âíèç ìåíüøå Ñòîï Ëîññà - Ñïðåä
|| // ÈËÈ
(Direction[i+1]==Sell // Åñëè íàäî ïðîäàâàòü
&& Scope_Up>=(set_SL-Spread))) // ðàçìàõ ââåðõ ìåíüøå Ñòîï Ëîññà - Ñïðåä
Value_TP[i]=-set_SL; // ïîëó÷åí çàäàííûé Òåéê Ïðîôèò
//---- Îïðåäåëèì çíà÷åíèÿ Òåéê Ïðîôèò â äðóãèõ ñëó÷àÿõ
if (Direction[i+1]==0) Value_TP[i]=0;// Åñëè íàïðàâëåíèå íå îïðåäåëåíî - Òåéê Ïðîôèò ðàâåí íóëþ
if ((Direction[i+1]==Buy // Åñëè íàäî ïîêóïàòü
&& Scope_Up<(set_TP+Spread) // ðàçìàõ ââåðõ ìåíüøå Òåéê Ïðîôèòà + Ñïðåä
&& (-Scope_Dn)<(set_SL-Spread) // ðàçìàõ âíèç ìåíüøå Ñòîï Ëîññà - Ñïðåä
&& Scope_Cl>=0)
|| // ÈËÈ
(Direction[i+1]==Sell // Åñëè íàäî ïðîäàâàòü
&& (-Scope_Dn)<(set_TP+Spread) // ðàçìàõ âíèç ìåíüøå Òåéê Ïðîôèòà + Ñïðåä
&& Scope_Up<(set_SL-Spread) // ðàçìàõ ââåðõ ìåíüøå Ñòîï Ëîññà - Ñïðåä
&& -Scope_Cl>=0))
Value_TP[i]=MathAbs(Scope_Cl)-Spread; // Òåéê Ïðîôèò ðàâåí çàêðûòèþ ìèíóñ ñïðåä
if ((Direction[i+1]==Buy // Åñëè íàäî ïîêóïàòü
&& Scope_Up<(set_TP+Spread) // ðàçìàõ ââåðõ ìåíüøå Òåéê Ïðîôèòà + Ñïðåä
&& (-Scope_Dn)<(set_SL-Spread) // ðàçìàõ âíèç ìåíüøå Ñòîï Ëîññà - Ñïðåä
&& Scope_Cl<0)
|| // ÈËÈ
(Direction[i+1]==Sell // Åñëè íàäî ïðîäàâàòü
&& (-Scope_Dn)<(set_TP+Spread) // ðàçìàõ âíèç ìåíüøå Òåéê Ïðîôèòà + Ñïðåä
&& Scope_Up<(set_SL-Spread) // ðàçìàõ ââåðõ ìåíüøå Ñòîï Ëîññà - Ñïðåä
&& -Scope_Cl<0))
Value_TP[i]=-(MathAbs(Scope_Cl)+Spread); // Òåéê Ïðîôèò ðàâåí çàêðûòèþ ìèíóñ ñïðåä
//---- Îïðåäåëèì íàðàñòàþùåå çíà÷åíèå Òåéê Ïðîôèò
k=i;
Sum_TP[i]=Sum_TP[i+1]+Value_TP[i]/((k+10)/10);
Sum_na_TP[i]=Sum_na_TP[i+1]+Value_TP[i];
i--; // Ðàñ÷¸ò èíäåêñà ñëåäóþùåãî áàðà
}
return(0); // âîçâðàùàåìîå çíà÷åíèå
}
//+------------------------------------------------------------------+
void Fun_New_Bar() // Ô-èÿ îáíàðóæåíèÿ íîâîãî áàðà
{
New_Bar=false; // Íîâîãî áàðà íåò
if(New_Time!=Time[0]) // Ñðàâíèâàåì âðåìÿ
{
New_Time=Time[0]; // Òåïåðü âðåìÿ òàêîå
New_Bar=true; // Ïîéìàëñÿ íîâûé áàð
}
}
//+------------------------------------------------------------------+
bool Fun_Repeat(double yt,double sl,double tp ) // Ô-èÿ ñðàâíåíèÿ ñ ìàññèâîì ïîâòîðîâ
{
for (int X=0; X<Repeat_Count; X++)
{
if (Repeat[X,0]==yt &&
Repeat[X,1]==sl &&
Repeat[X,2]==tp)
return(true);
}
return(false);
}
Comments