1664 Zeilen
55 KiB
MQL5
1664 Zeilen
55 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| Grid_2.mq5 |
|
|
//| AK47 |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "AK47"
|
|
#property link "https://www.mql5.com"
|
|
#property version "1.00"
|
|
|
|
///////INCLUDE//////////
|
|
|
|
#include <Trade\Trade.mqh>
|
|
#include <Trade\OrderInfo.mqh>
|
|
#include <Trade\SymbolInfo.mqh>
|
|
#include <Trade\AccountInfo.mqh>
|
|
#include <Trade\DealInfo.mqh>
|
|
#include <Trade\PositionInfo.mqh>
|
|
#include <Arrays\ArrayDouble.mqh>
|
|
//#include <News.mqh>
|
|
//#include <Time.mqh>
|
|
////////GLOBALS//////////////
|
|
|
|
enum Side
|
|
{
|
|
Buy=0, // Buy
|
|
Sell=1, // Sell
|
|
Both=2, // Both
|
|
};
|
|
|
|
input double FixedLot=0.01; // Fixed Lot
|
|
input Side EntrySide = 2;
|
|
input double TakeProfitFactor=2;
|
|
double StopLossFactor=3;
|
|
input ushort Grid=250; // Grid Distance
|
|
//input double CloseTreshold=1.05;
|
|
//input double FreeMarginThreshold=0.3;
|
|
//input double EquityStopLossPercent=0.9;
|
|
input int PositionsThreshold=2;
|
|
input double stDev = 1; // deviation
|
|
int MALength = 12;
|
|
input int bandsLength = 18;
|
|
int ATR1Length = 12;
|
|
int ATR2Length = 12;
|
|
input double Grid_mul = 1.2, Vol_Mul=1.8;
|
|
input string GMTstartTime = "11:30";
|
|
input string GMTendTime = "17:30";
|
|
input ENUM_TIMEFRAMES TimeFrame = PERIOD_M5;
|
|
|
|
////////////CLASSES////////////////////
|
|
|
|
CTrade trade;
|
|
CDealInfo deal;
|
|
CPositionInfo PosInfo;
|
|
CArrayDouble List;
|
|
CAccountInfo Account;
|
|
COrderInfo OrdInfo;
|
|
//CNews News;
|
|
//CTime Time;
|
|
|
|
//////////VARIABLES/////////////
|
|
double MAHigh[], MAHighData, MAHighHandle,
|
|
MALow[], MALowData, MALowHandle,
|
|
MA[], MAData, MAHandle, Momentum[], MomentumData, MomentumHandle,
|
|
bands[],bandsupper[],bandslower[], bandsHandle, bandsData,
|
|
MFI[], MFIData, MFIHandle,
|
|
ATR1[], ATR2[], ATR1Data, ATR2Data, ATR1Handle, ATR2Handle;
|
|
|
|
//--- OPTIMIZATION: Position State Cache
|
|
struct PositionState {
|
|
int buyCount;
|
|
int sellCount;
|
|
double buyVolume;
|
|
double sellVolume;
|
|
double meanEntryBuy;
|
|
double meanEntrySell;
|
|
double highestBuy;
|
|
double lowestBuy;
|
|
double highestSell;
|
|
double lowestSell;
|
|
|
|
void Reset() {
|
|
buyCount = 0; sellCount = 0;
|
|
buyVolume = 0; sellVolume = 0;
|
|
meanEntryBuy = 0; meanEntrySell = 0;
|
|
highestBuy = 0; lowestBuy = 0;
|
|
highestSell = 0; lowestSell = 0;
|
|
}
|
|
};
|
|
PositionState State;
|
|
datetime ExpireDate;
|
|
//--- END OPTIMIZATION
|
|
|
|
double ask, bid,
|
|
StopLossBuy=0, StopLossSell=0,
|
|
TakeProfitBuy=0, TakeProfitSell=0,
|
|
StartingBalance,
|
|
spread,
|
|
buyFactor, sellFactor,
|
|
Grid_step_buy,
|
|
Grid_step_sell,
|
|
currentGrid,
|
|
nextUpBuy, nextDownBuy,
|
|
nextUpSell, nextDownSell,
|
|
currentUpBuy, currentDownBuy,
|
|
currentUpSell, currentDownSell,
|
|
meanEntry;
|
|
|
|
int upCount=0, downCount=0;
|
|
|
|
|
|
double maxEquity, equityVolume = 1;
|
|
|
|
string newGrid, previousGrid;
|
|
|
|
double buyVolumeFactor = 1, sellVolumeFactor = 1,
|
|
buyVolume, sellVolume;
|
|
|
|
bool activateSL = false, buyStopSwitch = false, sellStopSwitch = false, buyLimitSwitch = false, sellLimitSwitch = false;
|
|
|
|
|
|
MqlRates Bar1[]; // Removed redundant Bar2
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
//---
|
|
// News.LoadHistory();
|
|
StartingBalance = Account.Balance();
|
|
|
|
ChartSetSymbolPeriod(0,_Symbol,TimeFrame);
|
|
|
|
|
|
MAHighHandle = iMA(_Symbol,TimeFrame,MALength,0,MODE_EMA,PRICE_HIGH);
|
|
MAHandle = iMA(_Symbol,TimeFrame,MALength,0,MODE_EMA,PRICE_CLOSE);
|
|
MALowHandle = iMA(_Symbol,TimeFrame,MALength,0,MODE_EMA,PRICE_LOW);
|
|
bandsHandle = iBands(_Symbol,TimeFrame,bandsLength,0,stDev,PRICE_TYPICAL);
|
|
ATR1Handle = iATR(_Symbol,TimeFrame,ATR1Length);
|
|
ATR2Handle = iATR(_Symbol,PERIOD_H1,ATR2Length);
|
|
MomentumHandle = iMomentum(_Symbol,TimeFrame,21,PRICE_MEDIAN);
|
|
|
|
ArraySetAsSeries(MFI,true);
|
|
|
|
ArraySetAsSeries(ATR1,true);
|
|
ArraySetAsSeries(ATR2,true);
|
|
|
|
ArraySetAsSeries(MAHigh,true);
|
|
ArraySetAsSeries(MA,true);
|
|
ArraySetAsSeries(MALow,true);
|
|
|
|
ArraySetAsSeries(bands,true);
|
|
ArraySetAsSeries(bandsupper,true);
|
|
ArraySetAsSeries(bandslower,true);
|
|
|
|
ArraySetAsSeries(Bar1, true);
|
|
// Removed Bar2 initialization
|
|
ArraySetAsSeries(Momentum, true);
|
|
|
|
ExpireDate = StringToTime("2026.02.14"); // Optimization: Parse once
|
|
|
|
bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);
|
|
ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
|
|
|
|
// double Prices[];
|
|
// double Volumes[];
|
|
// double levelstep = 5;
|
|
// CalculateVolumeDistribution(3,levelstep,Volumes,Prices);
|
|
//
|
|
// int peaks[];
|
|
// int peak_count = ArrayPeaks(Prices,peaks,100);
|
|
//
|
|
//
|
|
// FindIndices((ask+bid)/2,Prices,nextDown,nextUp);
|
|
|
|
nextUpBuy = ask + Grid*_Point;
|
|
nextDownBuy = bid - Grid*_Point;
|
|
nextUpSell = ask + Grid*_Point;
|
|
nextDownSell = bid - Grid*_Point;
|
|
|
|
|
|
|
|
Print("Buy NextLevelUp: " + nextUpBuy);
|
|
Print("Buy NextLevelDown: " + nextDownBuy);
|
|
Print("Sell NextLevelUp: " + nextUpSell);
|
|
Print("Sell NextLevelDown: " + nextDownSell);
|
|
//Print("PeaksCount: " + peak_count);
|
|
|
|
//---
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
//---
|
|
State.Reset();
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick()
|
|
{
|
|
UpdatePositionState(); // Optimization: Calculate all position stats once per tick
|
|
|
|
// CloseByWin();
|
|
//Trailing();
|
|
//breakEven();
|
|
//TPmodify();
|
|
|
|
MqlDateTime dt;
|
|
datetime gmtTime = TimeGMT(dt);
|
|
|
|
bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);
|
|
ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
|
|
spread = ask - bid;
|
|
//////////////TP&SL//////////////////////////////////////////
|
|
|
|
MAHighData = CopyBuffer(MAHighHandle,0,0,4,MAHigh);
|
|
MAData = CopyBuffer(MAHandle,0,0,4,MA);
|
|
MALowData = CopyBuffer(MALowHandle,0,0,4,MALow);
|
|
|
|
ATR1Data = CopyBuffer(ATR1Handle,0,0,15,ATR1);
|
|
ATR2Data = CopyBuffer(ATR2Handle,0,0,15,ATR2);
|
|
|
|
bandsData = CopyBuffer(bandsHandle,0,0,4,bands);
|
|
bandsData = CopyBuffer(bandsHandle,1,0,4,bandsupper);
|
|
bandsData = CopyBuffer(bandsHandle,2,0,4,bandslower);
|
|
MomentumData = CopyBuffer(MomentumHandle,2,0,4,Momentum);
|
|
|
|
CopyRates(_Symbol,TimeFrame,0,10,Bar1);
|
|
// Removed redundant CopyRates for Bar2
|
|
|
|
// TakeProfitBuy = bid+Grid_step*TakeProfitFactor*_Point;
|
|
// TakeProfitSell = ask-Grid_step*TakeProfitFactor*_Point;
|
|
|
|
StopLossBuy = bands[1];
|
|
StopLossSell = bands[1];
|
|
|
|
|
|
|
|
//////////////////// Factors //////////////////////////////////
|
|
|
|
if(State.buyCount != 0)
|
|
buyVolumeFactor = NormalizeDouble(MathPow(Vol_Mul,State.buyCount),0);
|
|
else
|
|
{
|
|
buyVolumeFactor = 1;
|
|
// Grid_step = Grid;
|
|
}
|
|
if(State.sellCount != 0)
|
|
sellVolumeFactor = NormalizeDouble(MathPow(Vol_Mul,State.sellCount),0);
|
|
else
|
|
{
|
|
sellVolumeFactor = 1;
|
|
}
|
|
|
|
if(PositionsTotal() < 1)
|
|
{
|
|
Grid_step_buy = Grid;
|
|
Grid_step_sell = Grid;
|
|
}
|
|
|
|
///////////////////BALANCEGRID//////////////////////////////////
|
|
|
|
// string expire_date = "2026.02.14"; //<-- hard coded datetime
|
|
// datetime e_d = StringToTime(expire_date);
|
|
|
|
//bool tradetime = true;// (dt.hour == 8 || dt.hour == 14 || dt.hour == 0 || dt.hour == 1);
|
|
bool tradetime = ((StringToTime(GMTstartTime) < StringToTime(GMTendTime) && gmtTime >= StringToTime(GMTstartTime) && gmtTime <= StringToTime(GMTendTime)) || (StringToTime(GMTstartTime) > StringToTime(GMTendTime) && gmtTime <= StringToTime(GMTstartTime) && gmtTime >= StringToTime(GMTendTime)));
|
|
//bool tradays = !((dt.day >= 1 && dt.day <= 7 && dt.day_of_week == 5) || (dt.day >= 10 && dt.day <=13) || (dt.day == 16 && dt.mon == 10));
|
|
|
|
|
|
if(TimeCurrent() <= ExpireDate) //spread<1500*_Point){
|
|
{
|
|
|
|
Grid_step_buy = Grid * MathPow(Grid_mul, State.buyCount);
|
|
Grid_step_sell = Grid * MathPow(Grid_mul, State.sellCount);
|
|
|
|
buyVolumeFactor = MathPow(Vol_Mul,State.buyCount);
|
|
sellVolumeFactor = MathPow(Vol_Mul,State.sellCount);
|
|
|
|
buyVolume = NormalizeDouble(equityVolume*buyVolumeFactor*FixedLot,2);
|
|
sellVolume = NormalizeDouble(equityVolume*sellVolumeFactor*FixedLot,2);
|
|
|
|
|
|
//double meanATR1 = ArrayCountAverage(ATR1,3);
|
|
//double meanATR2 = ArrayCountAverage(ATR2,3);
|
|
|
|
//Print("bands: " + bands[1]);
|
|
//Comment("\MATR~1: " + meanATR1 + "MATR~2 " + meanATR2);
|
|
//--- BuyLimit
|
|
if(ask < nextDownBuy)
|
|
{
|
|
buyLimitSwitch = true;
|
|
currentDownBuy = nextDownBuy;
|
|
nextUpBuy = ask + Grid_step_buy*_Point;
|
|
nextDownBuy = bid - Grid_step_buy*_Point;
|
|
}
|
|
|
|
//if(tradetime && (EntrySide == 2 || EntrySide == 0) && buyLimitSwitch && currentDownBuy + 10*_Point && !OtherBuyPosition(NULL) && ask < bandslower[1])
|
|
//{
|
|
// trade.Buy(buyVolume,_Symbol,0,StopLossBuy,TakeProfitBuy,"BuyLimit");
|
|
// buyLimitSwitch = false;
|
|
//}
|
|
|
|
//--- BuyStop
|
|
|
|
if(ask > nextUpBuy)
|
|
{
|
|
buyStopSwitch = true;
|
|
currentUpBuy = nextUpBuy;
|
|
nextUpBuy = ask + Grid_step_buy*_Point;
|
|
nextDownBuy = ask - Grid_step_buy*_Point;
|
|
}
|
|
if(tradetime && (EntrySide == 2 || EntrySide == 0) && buyStopSwitch && currentUpBuy - 1*_Point && !OtherBuyPosition(NULL) && ask > bandsupper[1] && Bar1[0].high > Bar1[1].high)
|
|
{
|
|
trade.Buy(buyVolume,_Symbol,0,StopLossBuy,TakeProfitBuy,"BuyStop");
|
|
buyStopSwitch = false;
|
|
}
|
|
|
|
//--- SellLimit
|
|
|
|
if(bid > nextUpSell)
|
|
{
|
|
sellLimitSwitch = true;
|
|
currentUpSell = nextUpSell;
|
|
nextUpSell = bid + Grid_step_sell*_Point;
|
|
nextDownSell = bid - Grid_step_sell*_Point;
|
|
}
|
|
|
|
//if(tradetime && (EntrySide == 2 || EntrySide == 1) && sellLimitSwitch && currentUpSell - 10*_Point && !OtherSellPosition(NULL) && bid > bandsupper[1])
|
|
//{
|
|
// trade.Sell(sellVolume,_Symbol,0,StopLossSell,TakeProfitSell,"SellLimit");
|
|
// sellLimitSwitch = false;
|
|
//}
|
|
|
|
//--- SellStop
|
|
|
|
if(bid < nextDownSell)// && bid > currentDownSell + 10*_Point && ask < currentUpBuyStop - 10*_Point
|
|
{
|
|
sellStopSwitch = true;
|
|
currentDownSell = nextDownSell;
|
|
nextUpSell = bid + Grid_step_sell*_Point;
|
|
nextDownSell = bid - Grid_step_sell*_Point;
|
|
}
|
|
|
|
if(tradetime && (EntrySide == 2 || EntrySide == 1) && sellStopSwitch && currentDownSell + 1*_Point && !OtherSellPosition(NULL) && bid < bandslower[1] && Bar1[0].low < Bar1[1].low)
|
|
{
|
|
trade.Sell(sellVolume,_Symbol,0,StopLossSell,TakeProfitSell,"SellStop");
|
|
sellStopSwitch = false;
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
{
|
|
Comment("Your license is expired!");
|
|
}
|
|
|
|
//////////////////////CLOSERS//////////////////////////////////////////////
|
|
|
|
StoplossUpdate("buy");
|
|
StoplossUpdate("sell");
|
|
|
|
|
|
if(Account.Equity() > maxEquity && PositionsTotal() < 2)
|
|
{
|
|
maxEquity = Account.Equity();
|
|
//equityVolume = MathCeil(maxEquity/10000);
|
|
//if(VolumeTotal("Total") > StartingBalance/1000)
|
|
//{
|
|
// CloseAllPositions();
|
|
//}
|
|
}
|
|
|
|
if(Account.Equity() >= 1.01*maxEquity)
|
|
{
|
|
activateSL = true;
|
|
maxEquity = Account.Equity();
|
|
}
|
|
|
|
if(activateSL && Account.Equity() <= 1/(1.01)*maxEquity)
|
|
{
|
|
activateSL = false;
|
|
//CloseAllPositions();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Optimization: Unified Position Updater |
|
|
//+------------------------------------------------------------------+
|
|
void UpdatePositionState()
|
|
{
|
|
State.Reset();
|
|
|
|
double buyPriceSum = 0;
|
|
double sellPriceSum = 0;
|
|
|
|
State.lowestBuy = 999999; // Init high
|
|
State.highestBuy = 0; // Init low
|
|
State.lowestSell = 999999; // Init high
|
|
State.highestSell = 0; // Init low
|
|
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(ticket <= 0) continue;
|
|
|
|
if(PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
long type = PositionGetInteger(POSITION_TYPE);
|
|
double vol = PositionGetDouble(POSITION_VOLUME);
|
|
double price = PositionGetDouble(POSITION_PRICE_OPEN);
|
|
|
|
if(type == POSITION_TYPE_BUY)
|
|
{
|
|
State.buyCount++;
|
|
State.buyVolume += vol;
|
|
buyPriceSum += (vol * price);
|
|
|
|
if(price < State.lowestBuy) State.lowestBuy = price;
|
|
if(price > State.highestBuy) State.highestBuy = price;
|
|
}
|
|
else if(type == POSITION_TYPE_SELL)
|
|
{
|
|
State.sellCount++;
|
|
State.sellVolume += vol;
|
|
sellPriceSum += (vol * price);
|
|
|
|
if(price < State.lowestSell) State.lowestSell = price;
|
|
if(price > State.highestSell) State.highestSell = price;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Calculate Means
|
|
if(State.buyVolume > 0) State.meanEntryBuy = buyPriceSum / State.buyVolume;
|
|
else { State.lowestBuy = 0; State.highestBuy = 0; } // Reset extremes if no positions
|
|
|
|
if(State.sellVolume > 0) State.meanEntrySell = sellPriceSum / State.sellVolume;
|
|
else { State.lowestSell = 0; State.highestSell = 0; } // Reset extremes if no positions
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Trade function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTrade()
|
|
{
|
|
//---
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double ArrayCountAverage(double &array[], int count)
|
|
{
|
|
double sum;
|
|
double mean;
|
|
//if (ArraySize(array) < count - 1);
|
|
//{
|
|
// Print("Array has less elements than required for mean" + ArraySize(array) + " count: " + (count-1));
|
|
//}
|
|
for(int i=0;i<count-1;i++)
|
|
{
|
|
sum += array[i] - array[i+1];
|
|
}
|
|
mean = sum/(count-1);
|
|
Print("Derivative is: " + mean);
|
|
return mean;
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double meanEntryPrice(string type)
|
|
{
|
|
|
|
double quantity = 0;
|
|
double volume = 0;
|
|
double entry = 0;
|
|
|
|
|
|
for(int i = PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
PositionGetTicket(i);
|
|
|
|
//////////////////////////////////
|
|
|
|
if(type == "Buy" && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
|
|
volume = volume + PosInfo.Volume();
|
|
}
|
|
if(type == "Sell" && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
|
|
volume = volume + PosInfo.Volume();
|
|
}
|
|
if(type == "Total" && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
|
|
volume = volume + PosInfo.Volume();
|
|
|
|
}
|
|
|
|
|
|
if(type == "BuysAbove" && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PosInfo.PriceOpen() > PosInfo.PriceCurrent() && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
|
|
volume = volume + PosInfo.Volume();
|
|
}
|
|
|
|
if(type == "BuysBelow" && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PosInfo.PriceOpen() < PosInfo.PriceCurrent() && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
|
|
volume = volume + PosInfo.Volume();
|
|
}
|
|
|
|
|
|
/////////////////////////////
|
|
|
|
|
|
|
|
if(type == "SellsAbove" && PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.PriceOpen() > PosInfo.PriceCurrent() && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
|
|
{
|
|
quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
|
|
volume = volume + PosInfo.Volume();
|
|
}
|
|
if(type == "SellsBelow" && PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.PriceOpen() < PosInfo.PriceCurrent() && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
|
|
{
|
|
quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
|
|
volume = volume + PosInfo.Volume();
|
|
}
|
|
}
|
|
|
|
entry = quantity / volume;
|
|
return entry;
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double VolumeTotal(string positionType)
|
|
{
|
|
double totalVolume = 0;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i) && positionType == "Buy" && PosInfo.PositionType() == POSITION_TYPE_BUY)
|
|
{
|
|
totalVolume += PosInfo.Volume();
|
|
}
|
|
}
|
|
//Print("BV: " + positionType + ": "+ totalVolume);
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
{
|
|
if(PosInfo.SelectByIndex(i) && positionType == "Sell" && PosInfo.PositionType() == POSITION_TYPE_SELL)
|
|
{
|
|
totalVolume += PosInfo.Volume();
|
|
}
|
|
}
|
|
//Print("SV: " + positionType + ": " + totalVolume);
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
{
|
|
if(PosInfo.SelectByIndex(i) && positionType == "Total")
|
|
{
|
|
totalVolume += PosInfo.Volume();
|
|
}
|
|
}
|
|
//Print("TV: " + positionType + ": " + totalVolume);
|
|
return totalVolume;
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
int FindIndices(double value, double &arr[], int &indexlow, int &indexhigh)
|
|
{
|
|
int size = ArraySize(arr);
|
|
|
|
// Check if the array has at least two elements
|
|
if(size < 2)
|
|
{
|
|
Print("Array must have at least two elements.");
|
|
// return -1; // Return -1 to indicate an error
|
|
}
|
|
|
|
// Iterate through the array to find the indices
|
|
for(int i = 0; i < size - 1; i++)
|
|
{
|
|
if((value > arr[i] && value < arr[i+1]) || (value < arr[i] && value > arr[i+1]))
|
|
{
|
|
indexlow = i;
|
|
indexhigh = i + 1;
|
|
return 0; // Return 0 to indicate success
|
|
}
|
|
}
|
|
|
|
// If no such indices are found
|
|
Print("No indices found where the value is between two consecutive elements.");
|
|
return -1; // Return -1 to indicate failure
|
|
}
|
|
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
void CalculateVolumeDistribution(int Days, double levelStep, double &volumeArray[], double &priceLevelArray[])
|
|
{
|
|
// Determine the number of bars in two full days
|
|
int barsInFullDay = 1440; // 1440 minutes in a day
|
|
int barsInDays = Days * barsInFullDay;
|
|
|
|
// Calculate the number of bars that have elapsed today
|
|
datetime currentTime = TimeCurrent();
|
|
datetime startOfDay = currentTime - (currentTime % 86400); // Start of the current day
|
|
int barsElapsedToday = (int)((currentTime - startOfDay) / 60) ; // Convert seconds to minutes
|
|
|
|
// Total lookback bars
|
|
int lookbackBars = barsInDays + barsElapsedToday;
|
|
|
|
// Initialize variables to store the lowest low and highest high
|
|
double lowestLow = 0;
|
|
double highestHigh = 0;
|
|
|
|
// Arrays to store the data
|
|
double lowArray[];
|
|
double highArray[];
|
|
long volumeArrayRaw[];
|
|
|
|
// Copy the data for the specified number of bars
|
|
if(CopyLow(_Symbol, PERIOD_M1, 0, lookbackBars, lowArray) <= 0 ||
|
|
CopyHigh(_Symbol, PERIOD_M1, 0, lookbackBars, highArray) <= 0 ||
|
|
CopyTickVolume(_Symbol, PERIOD_M1, 0, lookbackBars, volumeArrayRaw) <= 0)
|
|
{
|
|
Print("Error copying data");
|
|
return;
|
|
}
|
|
|
|
// Loop through the lookback period to find the lowest low and highest high
|
|
for(int i = 0; i < lookbackBars; i++)
|
|
{
|
|
double low = lowArray[i];
|
|
double high = highArray[i];
|
|
|
|
if((low != 0 && low < lowestLow) || lowestLow == 0)
|
|
lowestLow = low;
|
|
if(high > highestHigh)
|
|
highestHigh = high;
|
|
}
|
|
Print("Lowest Level: ", lowestLow);
|
|
Print("Highest Level: ", highestHigh);
|
|
|
|
// Calculate the number of levels
|
|
int numberOfLevels = int((highestHigh - lowestLow) / levelStep) + 1;
|
|
|
|
// Resize the arrays to hold the data
|
|
ArrayResize(volumeArray, numberOfLevels);
|
|
ArrayResize(priceLevelArray, numberOfLevels);
|
|
|
|
// Initialize arrays
|
|
for(int i = 0; i < numberOfLevels; i++)
|
|
{
|
|
volumeArray[i] = 0;
|
|
priceLevelArray[i] = lowestLow + i * levelStep;
|
|
}
|
|
|
|
// Aggregate volume for each level
|
|
for(int i = 0; i < lookbackBars; i++)
|
|
{
|
|
double low = lowArray[i];
|
|
double high = highArray[i];
|
|
double volume = (double)volumeArrayRaw[i];
|
|
|
|
// Determine which levels the current bar's range covers
|
|
int startLevel = int((low - lowestLow) / levelStep);
|
|
int endLevel = int((high - lowestLow) / levelStep);
|
|
|
|
// Distribute volume across the levels covered by the bar
|
|
for(int level = startLevel; level <= endLevel; level++)
|
|
{
|
|
if(level >= 0 && level < numberOfLevels)
|
|
{
|
|
volumeArray[level] += volume;
|
|
//Print("Level: ", level, " Volume: ", volumeArray[level]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
int ArrayPeaks(const double &array[], int &peaks[], double min_distance)
|
|
{
|
|
|
|
int LevelsToCheck = Grid;
|
|
|
|
int array_size = ArraySize(array);
|
|
if(array_size < LevelsToCheck)
|
|
return 0; // Return 0 if the array is too small to have peaks
|
|
|
|
int peak_count = 0;
|
|
ArrayResize(peaks, array_size); // Resize peaks array to the maximum possible size initially
|
|
|
|
// Iterate through the array to find peaks
|
|
for(int i = (int)(LevelsToCheck/2); i < array_size - (int)(LevelsToCheck/2); i++) // Start from level index and end at array_size - level index
|
|
{
|
|
bool is_peak = true;
|
|
// Check if the current element is greater than the elements in the range of indices around it
|
|
for(int j = i - (int)(LevelsToCheck/2); j <= i + (int)(LevelsToCheck/2); j++)
|
|
{
|
|
if(j != i && array[i] <= array[j])
|
|
{
|
|
is_peak = false;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
if(is_peak)
|
|
{
|
|
bool is_far_enough = true;
|
|
for(int j = 0; j < peak_count; j++)
|
|
{
|
|
if(MathAbs(i - peaks[j]) < min_distance)
|
|
{
|
|
is_far_enough = false;
|
|
break;
|
|
}
|
|
}
|
|
if(is_far_enough)
|
|
{
|
|
peaks[peak_count] = i;
|
|
peak_count++;
|
|
}
|
|
}
|
|
}
|
|
|
|
ArrayResize(peaks, peak_count); // Resize peaks array to the actual number of peaks found
|
|
return peak_count; // Return the number of peaks found
|
|
}
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CalculateValueArea(const double &priceLevels[], const double &volumes[], double &valAreaHigh, double &valAreaLow, double percentage = 70.0)
|
|
{
|
|
int size = ArraySize(volumes);
|
|
if(size <= 0 || size != ArraySize(priceLevels))
|
|
{
|
|
//Print("Array Issue: Price Levels and Volumes don't match or are empty.");
|
|
return;
|
|
}
|
|
|
|
// Calculate total volume
|
|
double totalVolume = 0.0;
|
|
for(int i = 0; i < size; i++)
|
|
{
|
|
totalVolume += volumes[i];
|
|
}
|
|
|
|
// Target volume for the value area
|
|
double targetVolume = totalVolume * (percentage / 100.0);
|
|
|
|
// Find the POC
|
|
int pocIndex = 0;
|
|
double maxVolume = volumes[0];
|
|
for(int i = 1; i < size; i++)
|
|
{
|
|
if(volumes[i] > maxVolume)
|
|
{
|
|
maxVolume = volumes[i];
|
|
pocIndex = i;
|
|
}
|
|
}
|
|
|
|
// Initialize the value area with the POC
|
|
valAreaLow = priceLevels[pocIndex];
|
|
valAreaHigh = priceLevels[pocIndex];
|
|
double cumulativeVolume = maxVolume;
|
|
|
|
// Expand the value area around the POC
|
|
int leftIndex = pocIndex - 1;
|
|
int rightIndex = pocIndex + 1;
|
|
|
|
while(cumulativeVolume < targetVolume)
|
|
{
|
|
// Consider both directions and choose the one with larger volume
|
|
if(leftIndex >= 0 && (rightIndex >= size || volumes[leftIndex] >= volumes[rightIndex]))
|
|
{
|
|
cumulativeVolume += volumes[leftIndex];
|
|
valAreaLow = priceLevels[leftIndex];
|
|
leftIndex--;
|
|
}
|
|
else if(rightIndex < size)
|
|
{
|
|
cumulativeVolume += volumes[rightIndex];
|
|
valAreaHigh = priceLevels[rightIndex];
|
|
rightIndex++;
|
|
}
|
|
else
|
|
{
|
|
// No more price levels to consider
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
////////////////CLOSING FUNCTIONS////////////////////////////////////
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseAllPositions()
|
|
{
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
if(PosInfo.SelectByIndex(i)) // select a position
|
|
{
|
|
trade.PositionClose(PosInfo.Ticket());
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CancelLimits(string comment)
|
|
{
|
|
|
|
for(int i = OrdersTotal()-1; i>= 0; i--)
|
|
if(OrdInfo.SelectByIndex(i) && PosInfo.Comment() == comment)
|
|
{
|
|
trade.OrderDelete(OrdInfo.Ticket());
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseByWinning()
|
|
{
|
|
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_BUY)
|
|
{
|
|
double thebuy = PosInfo.PriceOpen();
|
|
int theBuyTicket = PosInfo.Ticket();
|
|
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_SELL)
|
|
{
|
|
double thesell = PosInfo.PriceOpen();
|
|
int theSellTicket = PosInfo.Ticket();
|
|
|
|
if(thesell - thebuy > 0)
|
|
{
|
|
trade.PositionCloseBy(theBuyTicket,theSellTicket);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseByLosing()
|
|
{
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_BUY)
|
|
{
|
|
double thebuy = PosInfo.PriceOpen();
|
|
int theBuyTicket = PosInfo.Ticket();
|
|
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
if(PosInfo.SelectByIndex(i) &&PosInfo.PositionType() == POSITION_TYPE_SELL)
|
|
{
|
|
double thesell = PosInfo.PriceOpen();
|
|
int theSellTicket = PosInfo.Ticket();
|
|
|
|
if(thesell - thebuy < -Grid*_Point)
|
|
{
|
|
trade.PositionCloseBy(theBuyTicket,theSellTicket);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseByWin()
|
|
{
|
|
int profitTicket;
|
|
double profit;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_BUY)
|
|
{
|
|
if(PosInfo.Profit() > profit)
|
|
{
|
|
profit = PosInfo.Profit();
|
|
}
|
|
double thebuy = PosInfo.PriceOpen();
|
|
int theBuyTicket = PosInfo.Ticket();
|
|
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_SELL)
|
|
{
|
|
double thesell = PosInfo.PriceOpen();
|
|
int theSellTicket = PosInfo.Ticket();
|
|
|
|
if(thesell - thebuy > 0)
|
|
{
|
|
trade.PositionCloseBy(theBuyTicket,theSellTicket);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseByLoss()
|
|
{
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_BUY)
|
|
{
|
|
double thebuy = PosInfo.PriceOpen();
|
|
int theBuyTicket = PosInfo.Ticket();
|
|
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
if(PosInfo.SelectByIndex(i) &&PosInfo.PositionType() == POSITION_TYPE_SELL)
|
|
{
|
|
double thesell = PosInfo.PriceOpen();
|
|
int theSellTicket = PosInfo.Ticket();
|
|
|
|
if(thesell - thebuy < -Grid*_Point)
|
|
{
|
|
trade.PositionCloseBy(theBuyTicket,theSellTicket);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseWinners()
|
|
{
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.Profit() > 0)
|
|
{
|
|
int Ticket = PosInfo.Ticket();
|
|
|
|
trade.PositionClose(Ticket);
|
|
}
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseLosers()
|
|
{
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.Profit() < 0)
|
|
{
|
|
int Ticket = PosInfo.Ticket();
|
|
|
|
trade.PositionClose(Ticket);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseBuyWin()
|
|
{
|
|
double Profit;
|
|
int ProfitTicket;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_BUY && PosInfo.Profit() > Profit && PosInfo.Profit() > 0)
|
|
{
|
|
Profit = PosInfo.Profit();
|
|
ProfitTicket = PosInfo.Ticket();
|
|
}
|
|
}
|
|
}
|
|
trade.PositionClose(ProfitTicket);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseSellWin()
|
|
{
|
|
double Profit;
|
|
int ProfitTicket;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.Profit() > Profit && PosInfo.Profit() > 0)
|
|
{
|
|
Profit = PosInfo.Profit();
|
|
ProfitTicket = PosInfo.Ticket();
|
|
}
|
|
}
|
|
}
|
|
trade.PositionClose(ProfitTicket);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseBuyLoss()
|
|
{
|
|
double Profit;
|
|
int ProfitTicket;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_BUY && PosInfo.Profit() < Profit && PosInfo.Profit() < 0)
|
|
{
|
|
Profit = PosInfo.Profit();
|
|
ProfitTicket = PosInfo.Ticket();
|
|
}
|
|
}
|
|
}
|
|
trade.PositionClose(ProfitTicket);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double HighestBuy()
|
|
{
|
|
double Price = 0;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_BUY && PosInfo.PriceOpen() > Price)
|
|
{
|
|
Price = PosInfo.PriceOpen();
|
|
}
|
|
}
|
|
}
|
|
return Price;
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double HighestSell()
|
|
{
|
|
double Price = 0;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.PriceOpen() > Price)
|
|
{
|
|
Price = PosInfo.PriceOpen();
|
|
}
|
|
}
|
|
}
|
|
return Price;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double LowestBuy()
|
|
{
|
|
double Price = 2;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_BUY && PosInfo.PriceOpen() < Price)
|
|
{
|
|
Price = PosInfo.PriceOpen();
|
|
}
|
|
}
|
|
}
|
|
|
|
return Price;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double LowestSell()
|
|
{
|
|
double Price = 2;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.PriceOpen() < Price)
|
|
{
|
|
Price = PosInfo.PriceOpen();
|
|
}
|
|
}
|
|
}
|
|
return Price;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseSellLoss()
|
|
{
|
|
double Profit;
|
|
int ProfitTicket;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.Profit() < Profit && PosInfo.Profit() < 0)
|
|
{
|
|
Profit = PosInfo.Profit();
|
|
ProfitTicket = PosInfo.Ticket();
|
|
}
|
|
}
|
|
}
|
|
trade.PositionClose(ProfitTicket);
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void MAStopLoss()
|
|
{
|
|
int ProfitTicket;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i))
|
|
{
|
|
if(PosInfo.PositionType() == POSITION_TYPE_BUY && PosInfo.PriceOpen() > MAHigh[0] && PosInfo.PriceCurrent() < MALow[0])
|
|
{
|
|
ProfitTicket = PosInfo.Ticket();
|
|
trade.PositionClose(ProfitTicket);
|
|
}
|
|
|
|
if(PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.PriceOpen() < MALow[0]&& PosInfo.PriceCurrent() > MAHigh[0])
|
|
{
|
|
ProfitTicket = PosInfo.Ticket();
|
|
trade.PositionClose(ProfitTicket);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
///////////////////POSITIONS CHECK/////////////////////////
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool OtherBuyPosition(string comment)
|
|
{
|
|
bool other = false;
|
|
|
|
for(int i = PositionsTotal(); i >=0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
|
|
if(PosInfo.SelectByTicket(ticket))
|
|
{
|
|
double currentPrice = PosInfo.PriceCurrent();
|
|
double openPrice = PosInfo.PriceOpen();
|
|
|
|
if(MathAbs(currentPrice-openPrice) < Grid_step_buy*_Point && PosInfo.PositionType() == POSITION_TYPE_BUY && (comment == PosInfo.Comment() || comment == NULL))
|
|
{
|
|
other = true;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
other = false;
|
|
}
|
|
}
|
|
}
|
|
//Print("otherbuyposition: " + other);
|
|
return other;
|
|
}
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool OtherSellPosition(string comment)
|
|
{
|
|
|
|
bool other = false;
|
|
|
|
for(int i = PositionsTotal(); i >=0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
|
|
if(PosInfo.SelectByTicket(ticket))
|
|
{
|
|
double currentPrice = PosInfo.PriceCurrent();
|
|
double openPrice = PosInfo.PriceOpen();
|
|
|
|
if(MathAbs(currentPrice-openPrice) < Grid_step_sell*_Point && PosInfo.PositionType() == POSITION_TYPE_SELL && (comment == PosInfo.Comment() || comment == NULL))
|
|
{
|
|
other = true;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
other = false;
|
|
}
|
|
}
|
|
}
|
|
//Print("othersellposition: " + other);
|
|
return other;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseBuys()
|
|
{
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_BUY)
|
|
{
|
|
double thebuy = PosInfo.PriceOpen();
|
|
int theBuyTicket = PosInfo.Ticket();
|
|
|
|
|
|
trade.PositionClose(theBuyTicket);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseSells()
|
|
{
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
if(PosInfo.SelectByIndex(i) &&PosInfo.PositionType() == POSITION_TYPE_SELL)
|
|
{
|
|
double thesell = PosInfo.PriceOpen();
|
|
int theSellTicket = PosInfo.Ticket();
|
|
|
|
|
|
trade.PositionClose(theSellTicket);
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseBuy()
|
|
{
|
|
double Profit;
|
|
int theBuyTicket = PosInfo.Ticket();
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_BUY)
|
|
{
|
|
if(Profit>PosInfo.Profit())
|
|
{
|
|
Profit = PosInfo.Profit();
|
|
theBuyTicket = PosInfo.Ticket();
|
|
}
|
|
}
|
|
}
|
|
trade.PositionClose(theBuyTicket);
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CloseSell()
|
|
{
|
|
double Profit;
|
|
int theSellTicket = PosInfo.Ticket();
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
|
|
{
|
|
if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_SELL)
|
|
{
|
|
if(Profit>PosInfo.Profit())
|
|
{
|
|
Profit = PosInfo.Profit();
|
|
theSellTicket = PosInfo.Ticket();
|
|
}
|
|
}
|
|
}
|
|
trade.PositionClose(theSellTicket);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void Trailing()
|
|
{
|
|
// if(PositionGetInteger(POSITION_MAGIC) == 444444)//adding magic number, if you want you can delete this if you don't want to use magic number
|
|
// {
|
|
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
// string symbol = PositionGetSymbol(i);
|
|
ulong PositionTicket = PositionGetTicket(i);
|
|
long trade_type = PositionGetInteger(POSITION_TYPE);
|
|
if(trade_type == 0)// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
|
|
{
|
|
|
|
if(bid > PositionGetDouble(POSITION_PRICE_OPEN) + NormalizeDouble(_Point * Grid,_Digits))
|
|
{
|
|
trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN) + Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
|
|
}
|
|
}
|
|
|
|
if(trade_type == 1)// && (PositionGetString(POSITION_COMMENT) == "SellLimit"|| PositionGetString(POSITION_COMMENT) == "SellGrid"))
|
|
{
|
|
|
|
if(ask < PositionGetDouble(POSITION_PRICE_OPEN) - NormalizeDouble(_Point * Grid,_Digits))
|
|
{
|
|
trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN) - Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void TPmodify()
|
|
{
|
|
// if(PositionGetInteger(POSITION_MAGIC) == 444444)//adding magic number, if you want you can delete this if you don't want to use magic number
|
|
// {
|
|
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
ulong PositionTicket = PositionGetTicket(i);
|
|
long trade_type = PositionGetInteger(POSITION_TYPE);
|
|
if(trade_type == 0 && PosInfo.TakeProfit() != State.meanEntryBuy + TakeProfitFactor*Grid*_Point && State.buyCount > PositionsThreshold)
|
|
{
|
|
trade.PositionModify(PositionTicket,PositionGetDouble(POSITION_SL),PositionGetDouble(POSITION_PRICE_OPEN) + TakeProfitFactor*Grid*_Point);
|
|
if(PosInfo.PriceCurrent() > State.meanEntryBuy + Grid*_Point)
|
|
CloseBuys();
|
|
}
|
|
|
|
if(trade_type == 1 && PosInfo.TakeProfit() != State.meanEntrySell - TakeProfitFactor*Grid*_Point && State.sellCount > PositionsThreshold)
|
|
{
|
|
trade.PositionModify(PositionTicket,PositionGetDouble(POSITION_SL),PositionGetDouble(POSITION_PRICE_OPEN) - TakeProfitFactor*Grid*_Point);
|
|
if(PosInfo.PriceCurrent() < State.meanEntrySell - Grid*_Point)
|
|
CloseSells();
|
|
}
|
|
}
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void breakEven()
|
|
{
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
ulong PositionTicket = PositionGetTicket(i);
|
|
long trade_type = PositionGetInteger(POSITION_TYPE);
|
|
if(trade_type == 0)
|
|
if(PosInfo.PriceCurrent() - PosInfo.PriceOpen() > 2*Grid*_Point && (PosInfo.StopLoss() < PosInfo.PriceOpen() || PosInfo.StopLoss() == 0))// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
|
|
{
|
|
trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN) + Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
|
|
}
|
|
if(trade_type == 1)
|
|
if(PosInfo.PriceCurrent() - PosInfo.PriceOpen() < 2*Grid*_Point && (PosInfo.StopLoss() > PosInfo.PriceOpen() || PosInfo.StopLoss() == 0))// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
|
|
{
|
|
trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN) - Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void slStepUp()
|
|
{
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
ulong PositionTicket = PositionGetTicket(i);
|
|
long trade_type = PositionGetInteger(POSITION_TYPE);
|
|
if(trade_type == 0 && PosInfo.StopLoss() > PosInfo.PriceOpen())// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
|
|
{
|
|
trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_SL) + Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void slStepDown()
|
|
{
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
ulong PositionTicket = PositionGetTicket(i);
|
|
long trade_type = PositionGetInteger(POSITION_TYPE);
|
|
if(trade_type == 1 && PosInfo.StopLoss() < PosInfo.PriceOpen())// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
|
|
{
|
|
trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_SL) - Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void StoplossUpdate(string comment)
|
|
{
|
|
|
|
int buyCount = State.buyCount;
|
|
int sellCount = State.sellCount;
|
|
double meanEntryBuy = State.meanEntryBuy;
|
|
double meanEntrySell = State.meanEntrySell;
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
ulong PositionTicket = PositionGetTicket(i);
|
|
long trade_type = PositionGetInteger(POSITION_TYPE);
|
|
double newStopLoss;
|
|
if(trade_type == 0 && comment == "buy")
|
|
{
|
|
if(ask < meanEntryBuy + TakeProfitFactor*Grid*_Point)
|
|
newStopLoss = StopLossBuy;
|
|
if(ask > meanEntryBuy + TakeProfitFactor*Grid*_Point && buyCount > PositionsThreshold)
|
|
newStopLoss = NormalizeDouble((((ask + meanEntryBuy)/2)+ask)/2, _Digits);
|
|
if(PositionGetDouble(POSITION_SL) < newStopLoss - 5*_Point && newStopLoss != PositionGetDouble(POSITION_SL))
|
|
trade.PositionModify(PositionTicket,newStopLoss,PositionGetDouble(POSITION_TP));
|
|
}
|
|
if(trade_type == 1 && comment == "sell")
|
|
{
|
|
if(bid > meanEntrySell - TakeProfitFactor*Grid*_Point)
|
|
newStopLoss = StopLossSell;
|
|
if(bid < meanEntrySell - TakeProfitFactor*Grid*_Point && sellCount > PositionsThreshold)
|
|
newStopLoss = NormalizeDouble((((bid + meanEntrySell)/2)+bid)/2,_Digits);
|
|
if((PositionGetDouble(POSITION_SL) > newStopLoss + 5*_Point || PositionGetDouble(POSITION_SL) == 0) && newStopLoss != PositionGetDouble(POSITION_SL))
|
|
trade.PositionModify(PositionTicket,newStopLoss,PositionGetDouble(POSITION_TP));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
string crossOver(double &Array1[], double &Array2[])
|
|
{
|
|
string crossOver;
|
|
if(Array1[1] > Array2[1] && Array1[2] < Array2[2])
|
|
{
|
|
crossOver = "up";
|
|
}
|
|
if(Array1[1] < Array2[1] && Array1[2] > Array2[2])
|
|
{
|
|
crossOver = "down";
|
|
}
|
|
else
|
|
{
|
|
crossOver = NULL;
|
|
}
|
|
|
|
return (crossOver);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
int BuyPositionsCount()
|
|
{
|
|
int Buys = 0;
|
|
for(int i = PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
PositionGetTicket(i);
|
|
|
|
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
Buys = Buys+1;
|
|
}
|
|
}
|
|
return Buys;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
int SellPositionsCount()
|
|
{
|
|
int Sells = 0;
|
|
for(int i = PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
PositionGetTicket(i);
|
|
|
|
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
Sells = Sells+1;
|
|
}
|
|
}
|
|
return Sells;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void SLmodify()
|
|
{
|
|
// if(PositionGetInteger(POSITION_MAGIC) == 444444)//adding magic number, if you want you can delete this if you don't want to use magic number
|
|
// {
|
|
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
ulong PositionTicket = PositionGetTicket(i);
|
|
long trade_type = PositionGetInteger(POSITION_TYPE);
|
|
|
|
if(trade_type == 0
|
|
&& PosInfo.PriceCurrent() > State.meanEntryBuy + (0.5*Grid*_Point)
|
|
&& (PositionGetDouble(POSITION_SL) < PosInfo.PriceCurrent() - ((State.lowestBuy + 0.5*Grid*_Point)-State.meanEntryBuy) || PositionGetDouble(POSITION_SL) == 0))
|
|
{
|
|
trade.PositionModify(PositionTicket,PosInfo.PriceCurrent() - ((State.lowestBuy + 0.5*Grid*_Point)-State.meanEntryBuy),PositionGetDouble(POSITION_TP));
|
|
Print("Lowest buy: " + State.lowestBuy);
|
|
}
|
|
|
|
if(trade_type == 1
|
|
&& PosInfo.PriceCurrent() < State.meanEntrySell - (0.5*Grid*_Point)
|
|
&& (PositionGetDouble(POSITION_SL) > PosInfo.PriceCurrent() - ((State.highestSell - 0.5*Grid*_Point)-State.meanEntrySell) || PositionGetDouble(POSITION_SL) == 0))
|
|
{
|
|
trade.PositionModify(PositionTicket,PosInfo.PriceCurrent() - ((State.highestSell - 0.5*Grid*_Point)-State.meanEntrySell),PositionGetDouble(POSITION_TP));
|
|
Print("highest sell: " + State.highestSell);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double meanEntryPriceBuy()
|
|
{
|
|
|
|
double price = 0;
|
|
double volume = 0;
|
|
double entry;
|
|
for(int i = PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
PositionGetTicket(i);
|
|
|
|
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
price = price + PosInfo.Volume()*PosInfo.PriceOpen();
|
|
}
|
|
}
|
|
|
|
for(int i = PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
PositionGetTicket(i);
|
|
|
|
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
volume = volume + PosInfo.Volume();
|
|
}
|
|
}
|
|
|
|
entry = price / volume;
|
|
return entry;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double meanEntryPriceSell()
|
|
{
|
|
|
|
double price = 0;
|
|
double volume = 0;
|
|
double entry;
|
|
for(int i = PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
PositionGetTicket(i);
|
|
|
|
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
price = price + PosInfo.Volume()*PosInfo.PriceOpen();
|
|
}
|
|
}
|
|
|
|
for(int i = PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
PositionGetTicket(i);
|
|
|
|
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
volume = volume + PosInfo.Volume();
|
|
}
|
|
}
|
|
|
|
entry = price / volume;
|
|
return entry;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
|
|
//+------------------------------------------------------------------+
|