Free MQL5 Programming for Your Trading Strategies!

zero9898 posted:
Hello,

An idea for your next/future EAs.

How about work on 2 pairs with correlation(arround...50-60% negative) for positive swap, e.g. Long for USDJPY and short for EURGBP...with hedge/basket TP closed strategy.

Order Start Distance multiply count=value(order count)
Position Distance multiplication %=1.0~1.1,1.2,1.3.....
Order Start Lot multiply count=value(order count)
Lot Martingale coefficient %= 1.0~1.1,1.2,1.3.....

Spread filter(in point)

Trading time filter:
Start Time: 00:00
End Tine: 00:00

Pause/stop trading when Equity decreased

A simple EA for your reference.

https://www.mql5.com/en/market/product/108353

Hopefully, the idea makes sense.

MT5 EA Version - not complied or tested:

//+------------------------------------------------------------------+
//| CorrelatedPairsEA.mq5 |
//| Copyright 2024, Your Name Here |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright 'Copyright 2024, Your Name Here'
#property link 'https://www.mql5.com'
#property version '1.00'
#property strict

// Input parameters
input string Pair1 = 'USDJPY';
input string Pair2 = 'EURGBP';
input ENUM_TIMEFRAMES Timeframe = PERIOD_H1;
input double InitialLot = 0.01;
input int MaxOrders = 5;
input double CorrelationThreshold = -0.5;
input int SpreadFilter = 20;
input double EquityStopPercent = 5.0;
input double PositionDistanceMultBase = 1.0;
input double PositionDistanceMultStep = 0.1;
input double LotMartingaleMultBase = 1.0;
input double LotMartingaleMultStep = 0.1;
input string StartTime = '00:00';
input string EndTime = '23:59';

// Global variables
double initialEquity;
int magic = 234000;

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
    initialEquity = AccountInfoDouble(ACCOUNT_EQUITY);
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    // Close all positions when EA is removed
    CloseAllPositions();
}

//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
    if (!CheckTime())
    {
        Print('Outside trading hours. Waiting...');
        return;
    }
    
    if (!CheckEquity())
    {
        Print('Equity decrease threshold reached. Stopping trading.');
        CloseAllPositions();
        return;
    }
    
    double correlation = CalculateCorrelation();
    Print('Current correlation: ', correlation);
    
    if (correlation > CorrelationThreshold)
    {
        Print('Correlation not negative enough. Waiting...');
        return;
    }
    
    if (!CheckSpread())
    {
        Print('Spread too high. Waiting...');
        return;
    }
    
    // Open positions
    for (int i = 0; i < MaxOrders; i++)
    {
        double lot1 = InitialLot * (LotMartingaleMultBase + i * LotMartingaleMultStep);
        double lot2 = InitialLot * (LotMartingaleMultBase + i * LotMartingaleMultStep);
        
        if (!OpenPosition(Pair1, ORDER_TYPE_BUY, lot1) ||
            !OpenPosition(Pair2, ORDER_TYPE_SELL, lot2))
        {
            Print('Failed to open positions. Closing all and waiting...');
            CloseAllPositions();
            return;
        }
        
        Sleep(300000); // Wait for 5 minutes between orders
    }
    
    // Monitor positions
    while (true)
    {
        if (!CheckTime() || !CheckEquity())
        {
            CloseAllPositions();
            return;
        }
        
        double totalProfit = CalculateTotalProfit();
        Print('Current total profit: ', totalProfit);
        
        if (totalProfit > 0)
        {
            Print('Profit target reached. Closing all positions.');
            CloseAllPositions();
            return;
        }
        
        Sleep(60000); // Check every minute
    }
}

//+------------------------------------------------------------------+
//| Calculate correlation between two pairs |
//+------------------------------------------------------------------+
double CalculateCorrelation()
{
    int bars = 100;
    double close1[], close2[];
    
    ArraySetAsSeries(close1, true);
    ArraySetAsSeries(close2, true);
    
    CopyClose(Pair1, Timeframe, 0, bars, close1);
    CopyClose(Pair2, Timeframe, 0, bars, close2);
    
    return MathCorrelation(close1, close2, bars);
}

//+------------------------------------------------------------------+
//| Check if current time is within trading hours |
//+------------------------------------------------------------------+
bool CheckTime()
{
    datetime currentTime = TimeCurrent();
    datetime startTime = StringToTime(StartTime);
    datetime endTime = StringToTime(EndTime);
    
    return (currentTime >= startTime && currentTime <= endTime);
}

//+------------------------------------------------------------------+
//| Check if equity has decreased beyond threshold |
//+------------------------------------------------------------------+
bool CheckEquity()
{
    double currentEquity = AccountInfoDouble(ACCOUNT_EQUITY);
    return ((initialEquity - currentEquity) / initialEquity <= EquityStopPercent / 100);
}

//+------------------------------------------------------------------+
//| Check if spread is within acceptable range |
//+------------------------------------------------------------------+
bool CheckSpread()
{
    return (SymbolInfoInteger(Pair1, SYMBOL_SPREAD) <= SpreadFilter &&
            SymbolInfoInteger(Pair2, SYMBOL_SPREAD) <= SpreadFilter);
}

//+------------------------------------------------------------------+
//| Open a new position |
//+------------------------------------------------------------------+
bool OpenPosition(string symbol, ENUM_ORDER_TYPE orderType, double lot)
{
    MqlTradeRequest request = {};
    MqlTradeResult result = {};
    
    request.action = TRADE_ACTION_DEAL;
    request.symbol = symbol;
    request.volume = lot;
    request.type = orderType;
    request.price = (orderType == ORDER_TYPE_BUY) ? SymbolInfoDouble(symbol, SYMBOL_ASK) : SymbolInfoDouble(symbol, SYMBOL_BID);
    request.deviation = 20;
    request.magic = magic;
    request.comment = 'CorrelatedPairsEA';
    request.type_filling = ORDER_FILLING_IOC;
    
    bool success = OrderSend(request, result);
    
    if (!success)
    {
        Print('OrderSend error: ', GetLastError());
        return false;
    }
    
    return true;
}

//+------------------------------------------------------------------+
//| Close all open positions |
//+------------------------------------------------------------------+
void CloseAllPositions()
{
    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        ulong ticket = PositionGetTicket(i);
        if (ticket > 0)
        {
            if (PositionSelectByTicket(ticket))
            {
                MqlTradeRequest request = {};
                MqlTradeResult result = {};
                
                request.action = TRADE_ACTION_DEAL;
                request.position = ticket;
                request.symbol = PositionGetString(POSITION_SYMBOL);
                request.volume = PositionGetDouble(POSITION_VOLUME);
                request.type = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;
                request.price = (request.type == ORDER_TYPE_SELL) ? SymbolInfoDouble(request.symbol, SYMBOL_BID) : SymbolInfoDouble(request.symbol, SYMBOL_ASK);
                request.deviation = 20;
                request.magic = magic;
                
                OrderSend(request, result);
            }
        }
    }
}

//+------------------------------------------------------------------+
//| Calculate total profit of all open positions |
//+------------------------------------------------------------------+
double CalculateTotalProfit()
{
    double totalProfit = 0;
    
    for (int i = 0; i < PositionsTotal(); i++)
    {
        ulong ticket = PositionGetTicket(i);
        if (ticket > 0)
        {
            if (PositionSelectByTicket(ticket))
            {
                totalProfit += PositionGetDouble(POSITION_PROFIT);
            }
        }
    }
    
    return totalProfit;
}

//+------------------------------------------------------------------+
//| Custom function to calculate correlation |
//+------------------------------------------------------------------+
double MathCorrelation(const double &x[], const double &y[], int size)
{
    if (size <= 1)
        return 0;
    
    double sum_x = 0, sum_y = 0, sum_xy = 0;
    double sum_x2 = 0, sum_y2 = 0;
    
    for (int i = 0; i < size; i++)
    {
        sum_x += x[i];
        sum_y += y[i];
        sum_xy += x[i] * y[i];
        sum_x2 += x[i] * x[i];
        sum_y2 += y[i] * y[i];
    }
    
    double numerator = size * sum_xy - sum_x * sum_y;
    double denominator = MathSqrt((size * sum_x2 - sum_x * sum_x) * (size * sum_y2 - sum_y * sum_y));
    
    if (denominator == 0)
        return 0;
    
    return numerator / denominator;
}