This automated trading script is designed to manage currency trades by identifying specific trends using moving averages and executing orders based on price "breakouts." It combines technical analysis, automated risk management, and time-based constraints to operate independently.
Core Trading Logic
The strategy revolves around the relationship between two different moving averages (a "Fast" average and a "Slow" average).
- Entry Signals: The script looks for "crossovers." When the Fast Moving Average moves above the Slow Moving Average, it identifies an upward trend potential. Conversely, when it moves below, it identifies a downward trend.
- Breakout Execution: Rather than entering the market immediately upon a crossover, the script uses a "BreakOutLevel." It places pending orders (Buy Stops or Sell Stops) at a specific distance from the current price. These orders only trigger if the price physically moves past that designated threshold, confirming the strength of the trend.
- Exit Strategy: The script constantly monitors open positions. It will automatically close a trade if the moving averages cross back in the opposite direction (e.g., closing a Buy position if the Fast MA falls below the Slow MA).
Money Management & Risk Control
The script includes several layers of protection to manage capital and minimize risk:
- Dynamic Lot Sizing: Users can choose between a fixed trade size or a "Money Management" mode. In the latter, the script automatically calculates the number of units to trade based on a percentage of the account's current equity.
- Stop Loss & Take Profit: Every trade can be assigned a maximum loss limit (Stop Loss) and a target profit goal (Take Profit).
- Trailing Stops: To lock in profits during a winning streak, the script features an advanced trailing stop system. Depending on the user's settings, it can move the stop loss automatically as the price moves in favor of the trade, or even use "multi-level" steps to transition from breakeven to profit-locking.
- Safety Net: There is a "Margin Cutoff" feature; if the account equity falls below a specific dollar amount, the script will cease all trading activities to prevent further losses.
Operational Constraints
To ensure the robot operates within desired parameters, it includes several logistical rules:
- Time Filtering: The script can be restricted to trade only during specific hours of the day. It also includes logic to close all positions or stop trading on Friday evenings, which is a common practice to avoid weekend market volatility.
- Trade Limits: To prevent over-leveraging, the script is configured to allow only one open trade per currency symbol at any given time.
- Validation: Upon startup, the script performs a "sanity check" on all user inputs (like moving average types and prices) to ensure they are within valid ranges before beginning operation.
Price Data Components
Orders Execution
Indicators Used
Miscellaneous
12
Views
0
Downloads
0
Favorites
Doublema_breakout_ea_v1
//+------------------------------------------------------------------+
//| DoubleMA_Crossover_EA.mq4 |
//| Copyright © 2005 |
//| Written by MrPip from idea of Jason Robinson for Eric | |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, MrPip"
#include <stdlib.mqh>
//----
extern bool AccountIsMini=false; // Change to true if trading mini account
extern bool MoneyManagement=false; // Change to false to shutdown money management controls.
//---- // Lots = 1 will be in effect and only 1 lot will be open regardless of equity.
extern double TradeSizePercent=5; // Change to whatever percent of equity you wish to risk.
extern double Lots=3; // standard lot size.
extern double MaxLots=100;
//+---------------------------------------------------+
//|Indicator Variables |
//| Change these to try your own system |
//| or add more if you like |
//+---------------------------------------------------+
extern int FastMA_Mode=0; // 0=sma, 1=ema, 2=smma, 3=lwma, 4=LSMA
extern int FastMA_Period= 2;
extern int FastMA_Shift=0;
extern int FastMA_AppliedPrice=0; // 0=close, 1=open, 2=high, 3=low, 4=median((h+l/2)), 5=typical((h+l+c)/3), 6=weighted((h+l+c+c)/4)
extern int SlowMA_Mode=0; // 0=sma, 1=ema, 2=smma, 3=lwma, 4=LSMA
extern int SlowMA_Period= 5;
extern int SlowMA_Shift=0;
extern int SlowMA_AppliedPrice=0; // 0=close, 1=open, 2=high, 3=low, 4=median((h+l/2)), 5=typical((h+l+c)/3), 6=weighted((h+l+c+c)/4)
extern double BreakOutLevel=45; // Start trade after breakout is reached
extern int SignalCandle=1;
//+---------------------------------------------------+
//|Money Management |
//+---------------------------------------------------+
extern double StopLoss=250; // Maximum pips willing to lose per position.
extern bool UseTrailingStop=false;
extern int TrailingStopType=3; // Type 1 moves stop immediately, Type 2 waits til value of TS is reached
extern double TrailingStop=40; // Change to whatever number of pips you wish to trail your position with.
extern double TRStopLevel_1=20; // Type 3 first level pip gain
extern double TrailingStop1=20; // Move Stop to Breakeven
extern double TRStopLevel_2=30; // Type 3 second level pip gain
extern double TrailingStop2=20; // Move stop to lock is profit
extern double TRStopLevel_3=50; // type 3 third level pip gain
extern double TrailingStop3=20; // Move stop and trail from there
extern int TakeProfit=0; // Maximum profit level achieved.
extern double Margincutoff=800; // Expert will stop trading if equity level decreases to that level.
extern int Slippage=10; // Possible fix for not getting closed
//----
bool UseTimeLimit=true;
int StartHour =11; // Start trades after time
int StopHour=16; // Stop trading after time
bool UseFridayCloseAll=true;
string FridayCloseTime="21:30";
bool UseFridayStopTrading=false;
string FridayStopTradingTime="19:00";
//+---------------------------------------------------+
//|General controls |
//+---------------------------------------------------+
int MagicNumber;
string setup;
bool YesStop;
double lotMM;
int TradesInThisSymbol;
//+------------------------------------------------------------------+
//| expert initialization function |
//+------------------------------------------------------------------+
int init()
{
setup="DoubleMA_Breakout " + Symbol() + "_" + func_TimeFrame_Val2String(func_TimeFrame_Const2Val(Period()));
MagicNumber=3000 + func_Symbol2Val(Symbol())*100 + func_TimeFrame_Const2Val(Period());
//----
return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
}
//+------------------------------------------------------------------------+
//| LSMA - Least Squares Moving Average function calculation |
//| LSMA_In_Color Indicator plots the end of the linear regression line |
//| Modified to use any timeframe |
//+------------------------------------------------------------------------+
double LSMA(int Rperiod,int prMode, int TimeFrame, int mshift)
{
int i;
double sum, price;
int length;
double lengthvar;
double tmp;
double wt;
//
length=Rperiod;
//
sum=0;
for(i=length; i>=1 ;i--)
{
lengthvar=length + 1;
lengthvar/=3;
tmp=0;
switch(prMode)
{
case 0: price=iClose(NULL,TimeFrame,length-i+mshift);break;
case 1: price=iOpen(NULL,TimeFrame,length-i+mshift);break;
case 2: price=iHigh(NULL,TimeFrame,length-i+mshift);break;
case 3: price=iLow(NULL,TimeFrame,length-i+mshift);break;
case 4: price=(iHigh(NULL,TimeFrame,length-i+mshift) + iLow(NULL,TimeFrame,length-i+mshift))/2;break;
case 5: price=(iHigh(NULL,TimeFrame,length-i+mshift) + iLow(NULL,TimeFrame,length-i+mshift) + iClose(NULL,TimeFrame,length-i+mshift))/3;break;
case 6: price=(iHigh(NULL,TimeFrame,length-i+mshift) + iLow(NULL,TimeFrame,length-i+mshift) + iClose(NULL,TimeFrame,length-i+mshift) + iClose(NULL,TimeFrame,length-i+mshift))/4;break;
}
tmp =(i - lengthvar)*price;
sum+=tmp;
}
wt=sum*6/(length*(length+1));
//----
return(wt);
}
//+------------------------------------------------------------------+
//| CheckExitCondition |
//| Check if any exit condition is met |
//+------------------------------------------------------------------+
bool CheckExitCondition(string TradeType)
{
bool YesClose;
double fMA, sMA;
//----
YesClose=false;
if (FastMA_Mode==4)
{
fMA=LSMA(FastMA_Period,FastMA_AppliedPrice,0,SignalCandle);
}
else
{
fMA=iMA(NULL, 0, FastMA_Period, FastMA_Shift, FastMA_Mode, FastMA_AppliedPrice, SignalCandle);
}
if (SlowMA_Mode==4)
{
sMA=LSMA(SlowMA_Period,SlowMA_AppliedPrice,0,SignalCandle);
}
else
{
sMA=iMA(NULL, 0, SlowMA_Period, SlowMA_Shift, SlowMA_Mode, SlowMA_AppliedPrice, SignalCandle);
}
// Check for cross down
if (TradeType=="BUY" && fMA - sMA < 0) YesClose=true;
// Check for cross up
if (TradeType=="SELL" && fMA - sMA > 0) YesClose=true;
//----
return(YesClose);
}
//+------------------------------------------------------------------+
//| CheckEntryCondition |
//| Check if entry condition is met |
//+------------------------------------------------------------------+
bool CheckEntryCondition(string TradeType)
{
bool YesTrade;
double fMA, sMA;
//----
YesTrade=false;
if (FastMA_Mode==4)
{
fMA=LSMA(FastMA_Period,FastMA_AppliedPrice,0,SignalCandle);
}
else
{
fMA=iMA(NULL, 0, FastMA_Period, FastMA_Shift, FastMA_Mode, FastMA_AppliedPrice, SignalCandle);
}
if (SlowMA_Mode==4)
{
sMA=LSMA(SlowMA_Period,SlowMA_AppliedPrice,0,SignalCandle);
}
else
{
sMA=iMA(NULL, 0, SlowMA_Period, SlowMA_Shift, SlowMA_Mode, SlowMA_AppliedPrice, SignalCandle);
}
// Check for cross up
if (TradeType=="BUY" && fMA - sMA > 0) YesTrade=true;
// Check for cross down
if (TradeType=="SELL" && fMA - sMA < 0)YesTrade=true;
//----
return(YesTrade);
}
//+------------------------------------------------------------------+
//| expert start function |
//+------------------------------------------------------------------+
int start()
{
// Check for valid inputs
if (CheckValidUserInputs()) return(0);
//+------------------------------------------------------------------+
//| Check for Open Position |
//+------------------------------------------------------------------+
HandleOpenPositions();
if (UseTimeLimit)
{
// trading from 7:00 to 13:00 GMT
// trading from Start1 to Start2
YesStop=true;
if (Hour()>=StartHour && Hour()<=StopHour) YesStop=false;
// Comment ("Trading has been stopped as requested - wrong time of day");
if (YesStop) return(0);
}
TradesInThisSymbol=openPositions() + openStops();
//+------------------------------------------------------------------+
//| Check if OK to make new trades |
//+------------------------------------------------------------------+
if(AccountFreeMargin() < Margincutoff)
{
return(0);
}
// Only allow 1 trade per Symbol
if(TradesInThisSymbol > 0)
{
return(0);
}
lotMM=GetLots();
if(CheckEntryCondition("BUY"))
{
OpenBuyStopOrder();
}
if(CheckEntryCondition("SELL"))
{
OpenSellStopOrder();
}
//----
return(0);
}
//+------------------------------------------------------------------+
//| Functions beyond this point should not need to be modified |
//| Eventually will be placed in include file |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Open BuyStop |
//| Open a new trade using Buy Stop |
//| If Stop Loss or TakeProfit are used the values are calculated |
//| for each trade |
//+------------------------------------------------------------------+
void OpenBuyStopOrder()
{
int err,ticket;
double myStopLoss=0, myTakeProfit=0;
double LongTradeRate=Ask + BreakOutLevel*Point;
myStopLoss=0;
if(StopLoss > 0)myStopLoss=LongTradeRate-Point*StopLoss ;
myTakeProfit=0;
if (TakeProfit>0) myTakeProfit=LongTradeRate+Point*TakeProfit;
ticket=OrderSend(Symbol(),OP_BUYSTOP,lotMM,LongTradeRate,0,myStopLoss,myTakeProfit,setup,MagicNumber,0,Green);
if(ticket<=0)
{
err=GetLastError();
Print("Error opening BUY STOP order [" + setup + "]: (" + err + ") " + ErrorDescription(err));
}
}
//+------------------------------------------------------------------+
//| Open SellStop |
//| Open a new trade using Sell Stop |
//| If Stop Loss or TakeProfit are used the values are calculated |
//| for each trade |
//+------------------------------------------------------------------+
void OpenSellStopOrder()
{
int err, ticket;
double myStopLoss=0, myTakeProfit=0;
double ShortTradeRate=Bid - BreakOutLevel * Point;
myStopLoss=0;
if(StopLoss > 0)myStopLoss=ShortTradeRate+Point*StopLoss ;
myTakeProfit=0;
if (TakeProfit > 0) myTakeProfit=ShortTradeRate-Point*TakeProfit;
ticket=OrderSend(Symbol(),OP_SELLSTOP,lotMM,ShortTradeRate,0,myStopLoss,myTakeProfit,setup,MagicNumber,0,Red);
if(ticket<=0)
{
err=GetLastError();
Print("Error opening Sell order [" + setup + "]: (" + err + ") " + ErrorDescription(err));
}
}
//+------------------------------------------------------------------------+
//| counts the number of open positions |
//+------------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int openPositions( )
{
int op =0;
for(int i=OrdersTotal()-1;i>=0;i--) // scan all orders and positions...
{
OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
if (OrderMagicNumber()!=MagicNumber) continue;
if(OrderSymbol()==Symbol() )
{
if(OrderType()==OP_BUY)op++;
if(OrderType()==OP_SELL)op++;
}
}
return(op);
}
//+------------------------------------------------------------------------+
//| counts the number of STOP positions |
//+------------------------------------------------------------------------+
int openStops()
{ int op =0;
for(int i=OrdersTotal()-1;i>=0;i--) // scan all orders and positions...
{
OrderSelect(i, SELECT_BY_POS,MODE_TRADES);
if (OrderMagicNumber()!=MagicNumber) continue;
if(OrderSymbol()==Symbol() )
{
if(OrderType()==OP_BUYSTOP)op++;
if(OrderType()==OP_SELLSTOP)op++;
}
}
return(op);
}
//+------------------------------------------------------------------+
//| Handle Open Positions |
//| Check if any open positions need to be closed or modified |
//+------------------------------------------------------------------+
int HandleOpenPositions()
{
int cnt;
bool YesClose;
double pt;
for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
{
OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol()!=Symbol()) continue;
if(OrderMagicNumber()!=MagicNumber) continue;
if(OrderType()==OP_BUY)
{
if (CheckExitCondition("BUY"))
{
CloseOrder(OrderTicket(),OrderLots(),Bid);
}
else
{
if (UseTrailingStop)
{
HandleTrailingStop("BUY",OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
}
}
}
if(OrderType()==OP_SELL)
{
if (CheckExitCondition("SELL"))
{
CloseOrder(OrderTicket(),OrderLots(),Ask);
}
else
{
if(UseTrailingStop)
{
HandleTrailingStop("SELL",OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
}
}
}
//Close pending orders
if (OrderType()==OP_BUYSTOP && CheckExitCondition("BUY")) DeleteOrder( OrderTicket() );
if (OrderType()==OP_SELLSTOP && CheckExitCondition("SELL")) DeleteOrder( OrderTicket() );
}
}
//+------------------------------------------------------------------+
//| Delete Open Position Controls |
//| Try to close position 3 times |
//+------------------------------------------------------------------+
void DeleteOrder(int ticket)
{
int CloseCnt, err;
// try to close 3 Times
CloseCnt=0;
while(CloseCnt < 3)
{
if (OrderDelete(ticket))
{
CloseCnt=3;
}
else
{
err=GetLastError();
Print(CloseCnt," Error deleting order : (", err , ") " + ErrorDescription(err));
if (err > 0) CloseCnt++;
}
}
}
//+------------------------------------------------------------------+
//| Close Open Position Controls |
//| Try to close position 3 times |
//+------------------------------------------------------------------+
void CloseOrder(int ticket,double numLots,double close_price)
{
int CloseCnt, err;
// try to close 3 Times
CloseCnt=0;
while(CloseCnt < 3)
{
if (OrderClose(ticket,numLots,close_price,Slippage,Violet))
{
CloseCnt=3;
}
else
{
err=GetLastError();
Print(CloseCnt," Error closing order : (", err , ") " + ErrorDescription(err));
if (err > 0) CloseCnt++;
}
}
}
//+------------------------------------------------------------------+
//| Modify Open Position Controls |
//| Try to modify position 3 times |
//+------------------------------------------------------------------+
void ModifyOrder(int ord_ticket,double op, double price,double tp)
{
int CloseCnt, err;
CloseCnt=0;
while(CloseCnt < 3)
{
if (OrderModify(ord_ticket,op,price,tp,0,Aqua))
{
CloseCnt=3;
}
else
{
err=GetLastError();
Print(CloseCnt," Error modifying order : (", err , ") " + ErrorDescription(err));
if (err>0) CloseCnt++;
}
}
}
//+------------------------------------------------------------------+
//| HandleTrailingStop |
//| Type 1 moves the stoploss without delay. |
//| Type 2 waits for price to move the amount of the trailStop |
//| before moving stop loss then moves like type 1 |
//| Type 3 uses up to 3 levels for trailing stop |
//| Level 1 Move stop to 1st level |
//| Level 2 Move stop to 2nd level |
//| Level 3 Trail like type 1 by fixed amount other than 1 |
//| Possible future types |
//| Type 4 uses 2 for 1, every 2 pip move moves stop 1 pip |
//| Type 5 uses 3 for 1, every 3 pip move moves stop 1 pip |
//+------------------------------------------------------------------+
int HandleTrailingStop(string type, int ticket, double op, double os, double tp)
{
double pt, TS=0;
double bos,bop,opa,osa;
if (type=="BUY")
{
switch(TrailingStopType)
{
case 1: pt=Point*StopLoss;
if(Bid-os > pt) ModifyOrder(ticket,op,Bid-pt,tp);
break;
case 2: pt=Point*TrailingStop;
if(Bid-op > pt && os < Bid - pt) ModifyOrder(ticket,op,Bid - pt,tp);
break;
case 3: if (Bid - op > TRStopLevel_1 * Point)
{
TS=op + TRStopLevel_1*Point - TrailingStop1 * Point;
if (os < TS)
{
ModifyOrder(ticket,op,TS,tp);
}
}
if (Bid - op > TRStopLevel_2 * Point)
{
TS=op + TRStopLevel_2*Point - TrailingStop2 * Point;
if (os < TS)
{
ModifyOrder(ticket,op,TS,tp);
}
}
if (Bid - op > TRStopLevel_3 * Point)
{
// TS = op + TRStopLevel_3 * Point - TrailingStop3*Point;
TS=Bid - TrailingStop3*Point;
if (os < TS)
{
ModifyOrder(ticket,op,TS,tp);
}
}
break;
}
return(0);
}
if (type== "SELL")
{
switch(TrailingStopType)
{
case 1: pt=Point*StopLoss;
if(os - Ask > pt) ModifyOrder(ticket,op,Ask+pt,tp);
break;
case 2: pt=Point*TrailingStop;
if(op - Ask > pt && os > Ask+pt) ModifyOrder(ticket,op,Ask+pt,tp);
break;
case 3: if (op - Ask > TRStopLevel_1 * Point)
{
TS=op - TRStopLevel_1 * Point + TrailingStop1 * Point;
if (os > TS)
{
ModifyOrder(ticket,op,TS,tp);
}
}
if (op - Ask > TRStopLevel_2 * Point)
{
TS=op - TRStopLevel_2 * Point + TrailingStop2 * Point;
if (os > TS)
{
ModifyOrder(ticket,op,TS,tp);
}
}
if (op - Ask > TRStopLevel_3 * Point)
{
// TS = op - TRStopLevel_3 * Point + TrailingStop3 * Point;
TS=Ask + TrailingStop3 * Point;
if (os > TS)
{
ModifyOrder(ticket,op,TS,tp);
}
}
break;
}
}
return(0);
}
//+------------------------------------------------------------------+
//| Get number of lots for this trade |
//+------------------------------------------------------------------+
double GetLots()
{
double lot;
if(MoneyManagement)
{
lot=LotsOptimized();
}
else
{
lot=Lots;
if(AccountIsMini)
{
if (lot > 1.0) lot=lot/10;
if (lot < 0.1) lot=0.1;
}
}
return(lot);
}
//+------------------------------------------------------------------+
//| Calculate optimal lot size |
//+------------------------------------------------------------------+
double LotsOptimized()
{
double lot=Lots;
//---- select lot size
lot=NormalizeDouble(MathFloor(AccountFreeMargin()*TradeSizePercent/10000)/10,1);
// lot at this point is number of standard lots
// if (Debug) Print ("Lots in LotsOptimized : ",lot);
// Check if mini or standard Account
if(AccountIsMini)
{
lot=MathFloor(lot*10)/10;
// Use at least 1 mini lot
if(lot<0.1) lot=0.1;
if (lot > MaxLots) lot=MaxLots;
}
else
{
if (lot < 1.0) lot=1.0;
if (lot > MaxLots) lot=MaxLots;
}
return(lot);
}
//+------------------------------------------------------------------+
//| Time frame interval appropriation function |
//+------------------------------------------------------------------+
int func_TimeFrame_Const2Val(int Constant)
{
switch(Constant)
{
case 1: // M1
return(1);
case 5: // M5
return(2);
case 15:
return(3);
case 30:
return(4);
case 60:
return(5);
case 240:
return(6);
case 1440:
return(7);
case 10080:
return(8);
case 43200:
return(9);
}
}
//+------------------------------------------------------------------+
//| Time frame string appropriation function |
//+------------------------------------------------------------------+
string func_TimeFrame_Val2String(int Value)
{
switch(Value)
{
case 1: // M1
return("PERIOD_M1");
case 2: // M1
return("PERIOD_M5");
case 3:
return("PERIOD_M15");
case 4:
return("PERIOD_M30");
case 5:
return("PERIOD_H1");
case 6:
return("PERIOD_H4");
case 7:
return("PERIOD_D1");
case 8:
return("PERIOD_W1");
case 9:
return("PERIOD_MN1");
default:
return("undefined " + Value);
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int func_Symbol2Val(string symbol)
{
if(symbol=="AUDCAD")
{
return(1);
}
else if(symbol=="AUDJPY")
{
return(2);
}
else if(symbol=="AUDNZD")
{
return(3);
}
else if(symbol=="AUDUSD")
{
return(4);
}
else if(symbol=="CHFJPY")
{
return(5);
}
else if(symbol=="EURAUD")
{
return(6);
}
else if(symbol=="EURCAD")
{
return(7);
}
else if(symbol=="EURCHF")
{
return(8);
}
else if(symbol=="EURGBP")
{
return(9);
}
else if(symbol=="EURJPY")
{
return(10);
}
else if(symbol=="EURUSD")
{
return(11);
}
else if(symbol=="GBPCHF")
{
return(12);
}
else if(symbol=="GBPJPY")
{
return(13);
}
else if(symbol=="GBPUSD")
{
return(14);
}
else if(symbol=="NZDUSD")
{
return(15);
}
else if(symbol=="USDCAD")
{
return(16);
}
else if(symbol=="USDCHF")
{
return(17);
}
else if(symbol=="USDJPY")
{
return(18);
}
else
{
Comment("unexpected Symbol");
return(0);
}
}
//+------------------------------------------------------------------+
//| CheckValidUserInputs |
//| Check if User Inputs are valid for ranges allowed |
//| return true if invalid input, false otherwise |
//| Also display an alert for invalid input |
//+------------------------------------------------------------------+
bool CheckValidUserInputs()
{
if (CheckMAMethod(FastMA_Mode))
{
Alert("FastMA_Mode(0 to 4) You entered ",FastMA_Mode);
return(true);
}
if (CheckMAMethod(SlowMA_Mode))
{
Alert("SlowMA_Mode(0 to 4) You entered ",SlowMA_Mode);
return(true);
}
if (CheckAppliedPrice(FastMA_AppliedPrice))
{
Alert("FastMA_AppliedPrice( 0 to 6) You entered ",FastMA_AppliedPrice);
return(true);
}
if (CheckAppliedPrice(SlowMA_AppliedPrice))
{
Alert("SlowMA_AppliedPrice(0 to 6) You entered ",SlowMA_AppliedPrice);
return(true);
}
if (CheckTrailingStopType(TrailingStopType))
{
Alert("TrailingStopType( 1 to 3) You entered ",TrailingStopType);
return(true);
}
}
//+------------------------------------------------+
//| Check for valid Moving Average methods |
//| 0=sma, 1=ema, 2=smma, 3=lwma , 3=lsma |
//| return true if invalid, false if OK |
//+------------------------------------------------+
bool CheckMAMethod(int method)
{
if (method < 0) return(true);
if (method > 4) return(true);
return(false);
}
//+-----------------------------------------------------+
//| Check for valid Applied Price enumerations |
//| 0=close, 1=open, 2=high, 3=low, 4=median((h+l/2)) |
//| 5=typical((h+l+c)/3), 6=weighted((h+l+c+c)/4) |
//| return true if invalid, false if OK |
//+-----------------------------------------------------+
bool CheckAppliedPrice(int applied_price)
{
if (applied_price < 0) return(true);
if (applied_price > 6) return(true);
return(false);
}
//+------------------------------------------------+
//| Check for valid TrailingStopType |
//| |
//| return true if invalid, false if OK |
//+------------------------------------------------+
bool CheckTrailingStopType(int stop_type)
{
if (stop_type < 0)return(true);
if (stop_type > 3) return(true);
return(false);
}
//+------------------------------------------------------------------+Profitability Reports
EUR/USD
Jul 2025 - Sep 2025
147.50
Total Trades
151
Won Trades
48
Lost trades
103
Win Rate
31.79 %
Expected payoff
41770.13
Gross Profit
6350343.00
Gross Loss
-43053.00
Total Net Profit
6307290.00
-100%
-50%
0%
50%
100%
USD/JPY
Jul 2025 - Sep 2025
1.21
Total Trades
169
Won Trades
61
Lost trades
108
Win Rate
36.09 %
Expected payoff
39.34
Gross Profit
38343.19
Gross Loss
-31695.04
Total Net Profit
6648.15
-100%
-50%
0%
50%
100%
GBP/AUD
Oct 2025 - Feb 2026
0.85
Total Trades
241
Won Trades
66
Lost trades
175
Win Rate
27.39 %
Expected payoff
-36.83
Gross Profit
49558.45
Gross Loss
-58433.99
Total Net Profit
-8875.54
-100%
-50%
0%
50%
100%
EUR/USD
Oct 2025 - Feb 2026
0.75
Total Trades
166
Won Trades
61
Lost trades
105
Win Rate
36.75 %
Expected payoff
-47.60
Gross Profit
23403.00
Gross Loss
-31305.00
Total Net Profit
-7902.00
-100%
-50%
0%
50%
100%
GBP/USD
Oct 2024 - Jan 2025
0.67
Total Trades
80
Won Trades
26
Lost trades
54
Win Rate
32.50 %
Expected payoff
-110.96
Gross Profit
17847.00
Gross Loss
-26724.00
Total Net Profit
-8877.00
-100%
-50%
0%
50%
100%
AUD/USD
Jul 2025 - Sep 2025
0.65
Total Trades
106
Won Trades
31
Lost trades
75
Win Rate
29.25 %
Expected payoff
-62.63
Gross Profit
12492.00
Gross Loss
-19131.00
Total Net Profit
-6639.00
-100%
-50%
0%
50%
100%
GBP/AUD
Jul 2025 - Sep 2025
0.64
Total Trades
91
Won Trades
26
Lost trades
65
Win Rate
28.57 %
Expected payoff
-83.53
Gross Profit
13337.81
Gross Loss
-20938.62
Total Net Profit
-7600.81
-100%
-50%
0%
50%
100%
USD/CAD
Jul 2025 - Sep 2025
0.64
Total Trades
117
Won Trades
38
Lost trades
79
Win Rate
32.48 %
Expected payoff
-51.19
Gross Profit
10740.74
Gross Loss
-16729.57
Total Net Profit
-5988.83
-100%
-50%
0%
50%
100%
AUD/USD
Oct 2024 - Jan 2025
0.55
Total Trades
83
Won Trades
0
Lost trades
0
Win Rate
0.00 %
Expected payoff
-114.18
Gross Profit
11598.00
Gross Loss
-21075.00
Total Net Profit
-9477.00
-100%
-50%
0%
50%
100%
AUD/USD
Oct 2025 - Feb 2026
0.50
Total Trades
76
Won Trades
18
Lost trades
58
Win Rate
23.68 %
Expected payoff
-113.84
Gross Profit
8757.00
Gross Loss
-17409.00
Total Net Profit
-8652.00
-100%
-50%
0%
50%
100%
USD/CAD
Oct 2024 - Jan 2025
0.45
Total Trades
66
Won Trades
16
Lost trades
50
Win Rate
24.24 %
Expected payoff
-141.30
Gross Profit
7604.09
Gross Loss
-16930.12
Total Net Profit
-9326.03
-100%
-50%
0%
50%
100%
NZD/USD
Jul 2025 - Sep 2025
0.38
Total Trades
75
Won Trades
19
Lost trades
56
Win Rate
25.33 %
Expected payoff
-117.36
Gross Profit
5331.00
Gross Loss
-14133.00
Total Net Profit
-8802.00
-100%
-50%
0%
50%
100%
GBP/CAD
Oct 2025 - Feb 2026
0.19
Total Trades
29
Won Trades
3
Lost trades
26
Win Rate
10.34 %
Expected payoff
-262.08
Gross Profit
1743.02
Gross Loss
-9343.35
Total Net Profit
-7600.33
-100%
-50%
0%
50%
100%
NZD/USD
Oct 2024 - Jan 2025
0.11
Total Trades
36
Won Trades
8
Lost trades
28
Win Rate
22.22 %
Expected payoff
-263.25
Gross Profit
1203.00
Gross Loss
-10680.00
Total Net Profit
-9477.00
-100%
-50%
0%
50%
100%
Comments