A different idea ... it works

#1
Hi friends,

My English not good.I try to explain my question.
Please try to understand and help.


I think I discovered a detail important How do I write it as formula.


I use 15-minute system.15 minutes in every system I discovered that,

Bad orders many time back to back , and generally the same day orders and next days orders bad orders.I thought of a solution to the problem.

My idea ;available in every system.

We apply buy sell signals...when İf same day or next day orders we are stop.... and we wait. If prices continue to go in the direction orders.Example 400 pips( I use 400 pips..changeable) We give orders to the system but 400 pips later. and We put stoploss of 400 pips.

example


Date Price orders Profit

3 72575 sell 2175
6 70400 buy -900
6 69500 sell 2125 same day order so enter order 1000 points later.Profit 1125 points
7 67375 buy -600 next day dont enter order..wait
7 66775 sell -1800 same day order dont enter..waşt
10 68575 buy 3925
13 72500 sell 3400
17 69100 buy 0
20 69100 sell 1100
21 68000 buy -2700 next day dont enter order..wait
25 65300 sell -775
26 66075 buy 2700 next day order so enter order 1000 points later.Profit 1700 points
28 68775 sell 1400

Normal point =10050
Next day rule =12550 point



In summary ;

In all systems ,
do not apply immediately on the same day or the next day orders.We stop and wait.if price in the same direction with orders.400 pips later we enter the order.And apply stop 400 pips.


This rule profitability increases of around 20%.

How can we write this rule as formula.
 
#2
I accept , hard to understand.Do you understand?

example simple code.How can add next day rule in this afl.

*when same day and next day orders stop and wait.400 pips(changeable) later we enter the order.
 

boarders

Well-Known Member
#3
Please explain your setup properly as cant understand anything about your setup.
Also in which charting software are you looking for this formula
 
#5
Please explain your setup properly as cant understand anything about your setup.
Also in which charting software are you looking for this formula
Seems like he wants to delay his entry to the trade by 400 pips and the SL set to original level of his entry price.

But yes, which platform/TF/interments what if the signal flips before the 400 pips. etc left out to your imagination :)


Happy :)
 
#6
I request afl experts to help me in converting the below MT4 into afl. This pertains to basic of NeoWave concepts by Glenn Neely and this monowave is the building block for identifying the larger pattern. Thanks in advance. I posted in this thread though I am not sure.


//+------------------------------------------------------------------+
//| FX5_NellyElliotWave.mq4 |
//| FX5, Copyright © 2007 |
//| [email protected] |
//+------------------------------------------------------------------+
#property copyright "FX5, Copyright © 2007"
#property link "[email protected]"

#property indicator_chart_window
#property indicator_buffers 8

#define Sunday 0
#define Monday 1

//---- input parameters
extern string segment_0="*** Daily Close Settings ***";
extern bool enableCustomDailyClose=false;
extern string dailyCloseTime="00:00";
extern string segment_1="*** Waves Display Setting ***";
extern bool showMonthlyWaves= true;
extern bool showWeeklyWaves = true;
extern bool showDailyWaves=true;
extern bool showQuarterDailyWaves=true;
extern string segment_2="*** Waves Color Settings ***";
extern color monthlyWavesColor= clrBlueViolet;
extern color weeklyWavesColor = clrGreen;
extern color dailyWavesColor=clrBlue;
extern color quarterDailyWavesColor=clrYellow;
extern string segment_3="*** SwingPoints Color Settings ***";
extern color monthlySwingColor= clrYellow;
extern color weeklySwingColor = clrFireBrick;
extern color dailySwingColor=clrRed;
extern color quarterDailySwingColor=clrChocolate;
//---- buffers
double monthlyWaves[];
double monthlySwings[];
double weeklyWaves[];
double weeklySwings[];
double dailyWaves[];
double dailySwings[];
double quarterDailyWaves[];
double quarterDailySwings[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
{
datetime time=StrToTime(dailyCloseTime);
dailyCloseTime=TimeToStr(time,TIME_MINUTES);

//---- indicators
int timeFrame=Period();

int monthlyWidth= 2;
int weeklyWidth = 2;
int dailyWidth=2;
int quarterDailyWidth=1;

if(timeFrame>=PERIOD_D1)
weeklyWidth= 1;
if(timeFrame >= PERIOD_H4)
dailyWidth = 1;

SetIndexStyle(0,DRAW_SECTION,STYLE_SOLID,monthlyWidth,monthlyWavesColor);
SetIndexStyle(2,DRAW_SECTION,STYLE_SOLID,weeklyWidth,weeklyWavesColor);
SetIndexStyle(4,DRAW_SECTION,STYLE_SOLID,dailyWidth,dailyWavesColor);
SetIndexStyle(6,DRAW_SECTION,STYLE_SOLID,quarterDailyWidth,quarterDailyWavesColor);

SetIndexStyle(1,DRAW_ARROW,EMPTY,monthlyWidth,monthlySwingColor);
SetIndexStyle(3,DRAW_ARROW,EMPTY,weeklyWidth,weeklySwingColor);
SetIndexStyle(5,DRAW_ARROW,EMPTY,dailyWidth,dailySwingColor);
SetIndexStyle(7,DRAW_ARROW,EMPTY,quarterDailyWidth,quarterDailySwingColor);

SetIndexArrow(1,159);
SetIndexArrow(3,159);
SetIndexArrow(5,159);
SetIndexArrow(7,159);

SetIndexBuffer(0,monthlyWaves);
SetIndexBuffer(1,monthlySwings);
SetIndexBuffer(2,weeklyWaves);
SetIndexBuffer(3,weeklySwings);
SetIndexBuffer(4,dailyWaves);
SetIndexBuffer(5,dailySwings);
SetIndexBuffer(6,quarterDailyWaves);
SetIndexBuffer(7,quarterDailySwings);

SetIndexEmptyValue(0,0);
SetIndexEmptyValue(1,0);
SetIndexEmptyValue(2,0);
SetIndexEmptyValue(3,0);
SetIndexEmptyValue(4,0);
SetIndexEmptyValue(5,0);
SetIndexEmptyValue(6,0);
SetIndexEmptyValue(7,0);

IndicatorDigits(Digits);
//----
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
Comment("");

return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int start()
{
Comment("Designed & Prgramed By: FX5\n","***[email protected]***");
int countedBars=IndicatorCounted();
if(countedBars<0)
countedBars=0;

int timeFrame=Period();

if(showMonthlyWaves)
{
if(timeFrame==PERIOD_D1 || timeFrame==PERIOD_H4)
IdentifyMonthlyWaves(countedBars);
}

if(showWeeklyWaves)
{
if(timeFrame==PERIOD_D1 || timeFrame==PERIOD_H4 ||
timeFrame==PERIOD_H1)
IdentifyWeeklyWaves(countedBars);
}
if(showDailyWaves)
{
if(timeFrame==PERIOD_H4 || timeFrame==PERIOD_H1 ||
timeFrame == PERIOD_M30 ||timeFrame == PERIOD_M15 ||
timeFrame == PERIOD_M5 || timeFrame == PERIOD_M1)
IdentifyDailyWaves(countedBars);
}
if(showQuarterDailyWaves)
{
if(timeFrame==PERIOD_H1 || timeFrame==PERIOD_M30 ||
timeFrame == PERIOD_M15 || timeFrame == PERIOD_M5 ||
timeFrame == PERIOD_M1)
IdentifyQuarterDailyWaves(countedBars);
}

return(0);
}
//+------------------------------------------------------------------+
void IdentifyMonthlyWaves(int countedBars)
{
int lastShift=-1;
int limit=Bars-countedBars;
if(countedBars==0) limit--;

for(int i=limit; i>=0; i--)
{
int lastClose=GetLastMonthlyClose(i);

if(lastShift==lastClose)
continue;
else
lastShift=lastClose;

int lastOpen=GetLastMonthlyClose(lastClose);

if(lastClose==-1 || lastOpen==-1)
continue;

int highShift= GetHighestHighShift(lastClose+1,lastOpen-lastClose);
int lowShift = GetLowestLowShift(lastClose+1,lastOpen-lastClose);

double highPrice= High[highShift];
double lowPrice = Low[lowShift];

if(highShift>lowShift)
{
monthlyWaves[lastOpen]=highPrice;
int middleShift=lastClose+MathCeil((lastOpen-lastClose+1)/2);
monthlyWaves[middleShift]=lowPrice;
}
else
{
monthlyWaves[lastOpen]=lowPrice;
middleShift=lastClose+MathCeil((lastOpen-lastClose+1)/2);
monthlyWaves[middleShift]=highPrice;
}

int swing_0 = GetLastMonthlySwing(i);
int swing_1 = GetLastMonthlySwing(swing_0);
int swing_2 = GetLastMonthlySwing(swing_1);
int swing_3 = GetLastMonthlySwing(swing_2);
if(swing_0>=0 && swing_1>=0 && swing_2>=0 && swing_3>=0)
{
if(monthlyWaves[swing_1]>monthlyWaves[swing_0] && monthlyWaves[swing_1]>monthlyWaves[swing_2])
monthlySwings[swing_1]=monthlyWaves[swing_1];

if(monthlyWaves[swing_1]<monthlyWaves[swing_0] && monthlyWaves[swing_1]<monthlyWaves[swing_2])
monthlySwings[swing_1]=monthlyWaves[swing_1];

if(monthlyWaves[swing_2]>monthlyWaves[swing_1] && monthlyWaves[swing_2]>monthlyWaves[swing_3])
monthlySwings[swing_2]=monthlyWaves[swing_2];

if(monthlyWaves[swing_2]<monthlyWaves[swing_1] && monthlyWaves[swing_2]<monthlyWaves[swing_3])
monthlySwings[swing_2]=monthlyWaves[swing_2];
}
}
}
//+------------------------------------------------------------------+
void IdentifyWeeklyWaves(int countedBars)
{
int lastShift=-1;
int limit=Bars-countedBars;
if(countedBars==0) limit--;
for(int i=limit; i>=0; i--)
{
int lastWeekClose=GetLastWeeklyClose(i);

if(lastShift==lastWeekClose)
continue;
else
lastShift=lastWeekClose;

int lastWeekOpen=GetLastWeeklyClose(lastWeekClose);

if(lastWeekClose==-1 || lastWeekOpen==-1)
continue;

int weekHighShift= GetHighestHighShift(lastWeekClose+1,lastWeekOpen-lastWeekClose);
int weekLowShift = GetLowestLowShift(lastWeekClose+1,lastWeekOpen-lastWeekClose);

double weekHighPrice= High[weekHighShift];
double weekLowPrice = Low[weekLowShift];

if(weekHighShift>weekLowShift)
{
weeklyWaves[lastWeekOpen]=weekHighPrice;
int middleWeekShift=lastWeekClose+MathCeil((lastWeekOpen-lastWeekClose+1)/2);
weeklyWaves[middleWeekShift]=weekLowPrice;
}
else
{
weeklyWaves[lastWeekOpen]=weekLowPrice;
middleWeekShift=lastWeekClose+MathCeil((lastWeekOpen-lastWeekClose+1)/2);
weeklyWaves[middleWeekShift]=weekHighPrice;
}

int swing_0 = GetLastWeeklySwing(i);
int swing_1 = GetLastWeeklySwing(swing_0);
int swing_2 = GetLastWeeklySwing(swing_1);
int swing_3 = GetLastWeeklySwing(swing_2);
if(swing_0>=0 && swing_1>=0 && swing_2>=0 && swing_3>=0)
{
if(weeklyWaves[swing_1]>weeklyWaves[swing_0] && weeklyWaves[swing_1]>weeklyWaves[swing_2])
weeklySwings[swing_1]=weeklyWaves[swing_1];

if((swing_2>=0) && weeklyWaves[swing_1]<weeklyWaves[swing_0] && weeklyWaves[swing_1]<weeklyWaves[swing_2])
weeklySwings[swing_1]=weeklyWaves[swing_1];

if(weeklyWaves[swing_2]>weeklyWaves[swing_1] && weeklyWaves[swing_2]>weeklyWaves[swing_3])
weeklySwings[swing_2]=weeklyWaves[swing_2];

if(weeklyWaves[swing_2]<weeklyWaves[swing_1] && weeklyWaves[swing_2]<weeklyWaves[swing_3])
weeklySwings[swing_2]=weeklyWaves[swing_2];
}
}
}
//+------------------------------------------------------------------+
void IdentifyDailyWaves(int countedBars)
{
int lastShift=-1;
int limit=Bars-countedBars;
if(countedBars==0) limit--;
for(int i=limit; i>=0; i--)
{
int lastDayClose=GetLastDailyClose(i);

if(lastShift==lastDayClose)
continue;
else
lastShift=lastDayClose;

int lastDayOpen=GetLastDailyClose(lastDayClose);

if(lastDayClose==-1 || lastDayOpen==-1)
continue;

int dayHighShift= GetHighestHighShift(lastDayClose+1,lastDayOpen-lastDayClose);
int dayLowShift = GetLowestLowShift(lastDayClose+1,lastDayOpen-lastDayClose);

double dayHighPrice= High[dayHighShift];
double dayLowPrice = Low[dayLowShift];
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
if(dayHighShift>dayLowShift)
{
dailyWaves[lastDayOpen]=dayHighPrice;
int middleDayShift=lastDayClose+MathCeil((lastDayOpen-lastDayClose+1)/2);
dailyWaves[middleDayShift]=dayLowPrice;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
else
{
dailyWaves[lastDayOpen]=dayLowPrice;
middleDayShift=lastDayClose+MathCeil((lastDayOpen-lastDayClose+1)/2);
dailyWaves[middleDayShift]=dayHighPrice;
}

int swing_0 = GetLastDailySwing(i);
int swing_1 = GetLastDailySwing(swing_0);
int swing_2 = GetLastDailySwing(swing_1);
int swing_3 = GetLastDailySwing(swing_2);
if(swing_0>=0 && swing_1>=0 && swing_2>=0 && swing_3>=0)
{
if(dailyWaves[swing_1]>dailyWaves[swing_0] && dailyWaves[swing_1]>dailyWaves[swing_2])
dailySwings[swing_1]=dailyWaves[swing_1];

if(dailyWaves[swing_1]<dailyWaves[swing_0] && dailyWaves[swing_1]<dailyWaves[swing_2])
dailySwings[swing_1]=dailyWaves[swing_1];

if(dailyWaves[swing_2]>dailyWaves[swing_1] && dailyWaves[swing_2]>dailyWaves[swing_3])
dailySwings[swing_2]=dailyWaves[swing_2];

if(dailyWaves[swing_2]<dailyWaves[swing_1] && dailyWaves[swing_2]<dailyWaves[swing_3])
dailySwings[swing_2]=dailyWaves[swing_2];
}
}
}
//+------------------------------------------------------------------+
void IdentifyQuarterDailyWaves(int countedBars)
{
int lastShift=-1;
int limit=Bars-countedBars;
if(countedBars==0) limit--;
for(int i=limit; i>=0; i--)
{
int lastClose=GetLastQuarterDailyClose(i);

if(lastShift==lastClose)
continue;
else
lastShift=lastClose;

int lastOpen=GetLastQuarterDailyClose(lastClose);

if(lastClose==-1 || lastOpen==-1)
continue;

int highShift= GetHighestHighShift(lastClose+1,lastOpen-lastClose);
int lowShift = GetLowestLowShift(lastClose+1,lastOpen-lastClose);

double highPrice= High[highShift];
double lowPrice = Low[lowShift];
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
if(highShift>lowShift)
{
quarterDailyWaves[lastOpen]=highPrice;
int middleShift=lastClose+MathCeil((lastOpen-lastClose+1)/2);
quarterDailyWaves[middleShift]=lowPrice;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
else
{
quarterDailyWaves[lastOpen]=lowPrice;
middleShift=lastClose+MathCeil((lastOpen-lastClose+1)/2);
quarterDailyWaves[middleShift]=highPrice;
}

int swing_0 = GetLastQuarterDailySwing(i);
int swing_1 = GetLastQuarterDailySwing(swing_0);
int swing_2 = GetLastQuarterDailySwing(swing_1);
int swing_3 = GetLastQuarterDailySwing(swing_2);
if(swing_0>=0 && swing_1>=0 && swing_2>=0 && swing_3>=0)
{
if(quarterDailyWaves[swing_1]>quarterDailyWaves[swing_0] && quarterDailyWaves[swing_1]>quarterDailyWaves[swing_2])
quarterDailySwings[swing_1]=quarterDailyWaves[swing_1];

if(quarterDailyWaves[swing_1]<quarterDailyWaves[swing_0] && quarterDailyWaves[swing_1]<quarterDailyWaves[swing_2])
quarterDailySwings[swing_1]=quarterDailyWaves[swing_1];

if(quarterDailyWaves[swing_2]>quarterDailyWaves[swing_1] && quarterDailyWaves[swing_2]>quarterDailyWaves[swing_3])
quarterDailySwings[swing_2]=quarterDailyWaves[swing_2];

if(quarterDailyWaves[swing_2]<quarterDailyWaves[swing_1] && quarterDailyWaves[swing_2]<quarterDailyWaves[swing_3])
quarterDailySwings[swing_2]=quarterDailyWaves[swing_2];
}
}
}
//+------------------------------------------------------------------+
int GetLastMonthlySwing(int shift)
{
for(int i=shift+1;(i<Bars-1); i++)
{
if(monthlyWaves!=0)
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+
int GetLastWeeklySwing(int shift)
{
for(int i=shift+1;(i<Bars-1); i++)
{
if(weeklyWaves!=0)
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+
int GetLastDailySwing(int shift)
{
for(int i=shift+1;(i<Bars-1); i++)
{
if(dailyWaves!=0)
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+
int GetLastQuarterDailySwing(int shift)
{
for(int i=shift+1;(i<Bars-1); i++)
{
if(quarterDailyWaves!=0)
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+
int GetLastMonthlyClose(int shift)
{
for(int i=shift+1;(i<Bars-1); i++)
{
if(TimeDay(Time)<TimeDay(Time[i+1]))
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+
int GetLastWeeklyClose(int shift)
{
for(int i=shift+1;(i<Bars-1); i++)
{
if(TimeDayOfWeek(Time)<TimeDayOfWeek(Time[i+1]))
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+
int GetLastDailyClose(int shift)
{
if(enableCustomDailyClose)
{
for(int i=shift+1;(i<Bars-1); i++)
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
{
string candleDateString=TimeToStr(Time,TIME_DATE);
datetime closeTime=StrToTime(candleDateString+" "+dailyCloseTime);

if(closeTime<Time[shift] && closeTime>=Time)
return(i);
}
}
else
{
for(i=shift+1;(i<Bars-1); i++)
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
{
if(TimeDayOfWeek(Time)!=TimeDayOfWeek(Time[i+1]) &&
TimeDayOfWeek(Time)!=Monday && TimeDayOfWeek(Time[i+1])!=Sunday)
return(i);
}
}
return(-1);
}
//+------------------------------------------------------------------+
int GetLastQuarterDailyClose(int shift)
{
if(enableCustomDailyClose)
{
int colonIndex= StringFind(dailyCloseTime,":",0);
if(colonIndex == -1)
return(-1);

string closeHourString=StringSubstr(dailyCloseTime,0,colonIndex);
int closeHour=StrToInteger(closeHourString);
}
else
closeHour=0;

for(int i=shift+1; i<Bars; i++)
{
string candleDateString=TimeToStr(Time,TIME_DATE);

int quarterHour=HourSum(closeHour,0);
datetime closeTime=StrToTime(candleDateString+" "+DoubleToStr(quarterHour,0)+":00");
if(closeTime<Time[shift] && closeTime>=Time)
return(i);

quarterHour=HourSum(closeHour,6);
closeTime=StrToTime(candleDateString+" "+DoubleToStr(quarterHour,0)+":00");
if(closeTime<Time[shift] && closeTime>=Time)
return(i);

quarterHour=HourSum(closeHour,12);
closeTime=StrToTime(candleDateString+" "+DoubleToStr(quarterHour,0)+":00");
if(closeTime<Time[shift] && closeTime>=Time)
return(i);

quarterHour=HourSum(closeHour,18);
closeTime=StrToTime(candleDateString+" "+DoubleToStr(quarterHour,0)+":00");
if(closeTime<Time[shift] && closeTime>=Time)
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+
int HourSum(int firstHour,int secondHour)
{
int sum = firstHour + secondHour;
if(sum >= 24)
sum -= 24;

return(sum);
}
//+------------------------------------------------------------------+
int GetHighestHighShift(int start,int count)
{
int highestShift=-1;
double highestPrice=-1;
for(int i=start; i<start+count; i++)
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
{
if(High>highestPrice)
{
highestShift = i;
highestPrice = High;
}
}
return(highestShift);
}
//+------------------------------------------------------------------+
int GetLowestLowShift(int start,int count)
{
int lowestShift=-1;
double lowestPrice=9999999;
for(int i=start; i<start+count; i++)
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
{
if(Low<lowestPrice)
{
lowestShift = i;
lowestPrice = Low;
}
}
return(lowestShift);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+


Once again thanks in advance
 

Similar threads

Zerodha – Open Paperless Account

Open online account with Zerodha. Free delivery trading and Max Rs 20 for Intraday, F&O, Currency and Commodity Trading. Intraday High leverage with MIS, CO and BO.

Name:Phone:
Email:City:
State:
Are you a day trader?