This script is designed to automate trading in the financial markets using the MetaTrader platform. Imagine it as a robot that tries to make smart decisions about buying and selling currencies. Here's a breakdown of how it works, without getting into technical jargon:
1. Setting the Stage:
- Configuration: The script starts with a set of adjustable settings. Think of these as the robot's preferences and risk parameters. These settings control things like:
- Whether the robot is allowed to buy or sell.
- How much risk to take.
- Whether to use certain analysis methods.
- If to show the account info, decision output etc.
- Market Awareness: The script constantly gathers information about the currency pair it's trading (e.g., EUR/USD). This includes the current price, high and low prices, spread (the difference between buying and selling price), and other market details. It is like scanning and reading all news available.
2. Making Trading Decisions:
- Analyzing Market Trends (Cyberia Logic): A core part of the script involves analyzing past price movements to predict future trends. It is like looking at a history chart to find patterns.
- It calculates probabilities of the market going up (buying) or going down (selling) based on how the price has changed over a recent period.
- It compares these probabilities to averages to identify potential trading opportunities.
- Technical Indicators (MACD, MA): In addition to its own analysis, the script can also use standard technical indicators like MACD and Moving Averages. These are like pre-built tools that provide additional insights into market trends.
- Trend Reversal Detection: The script can identify situations where a trend might be about to change direction. If it finds that current buying or selling probability is way above the average it will try to use it.
- Money Train: This attempts to profit from sudden, strong price movements.
3. Taking Action (Buying and Selling):
- Opening Orders: If the script determines that a buying or selling opportunity exists (based on its analysis, indicators, and settings), it can automatically open a trade. It's like placing a bet that the price will move in a certain direction.
- Managing Risk (Stop Loss): To limit potential losses, the script can set a "stop loss" level. If the price moves against the trade and reaches this level, the trade is automatically closed to prevent further losses. It acts as an emergency brake.
- Pipsator: if the trend is right it will try to buy or sell on smaller minute trends.
4. Managing Open Trades:
- Monitoring Open Orders: The script keeps track of any trades it has opened.
- Exiting Trades: The script has logic to determine when to close a trade, either to take a profit or to cut losses. This can be based on:
- The price reaching a certain level (stop loss or take profit).
- A change in market conditions.
- Its own internal analysis.
5. Continuous Adaptation:
- Period Selection: The script can automatically adjust the period of time it uses for analysis to try and find the most suitable setting for the current market conditions.
- Saving Statistics: It saves previous values so the robot can get more robust as time pass.
In essence, this script is a complex system that attempts to analyze market data, make trading decisions, and manage trades automatically, all according to a pre-defined set of rules and settings.
Price Data Components
Orders Execution
Indicators Used
7
Views
1
Downloads
0
Favorites
CyberiaTrader_v2
/*-----------------------------+
| |
| Shared by www.Aptrafx.com |
| |
+------------------------------*/
#property copyright "Copyright c 2006, Cyberia Decisions"
#property link "http://cyberia.org.ru"
#define DECISION_BUY 1
#define DECISION_SELL 0
#define DECISION_UNKNOWN -1
// ---- Global variables
extern bool ExitMarket = false;
extern bool ShowSuitablePeriod = false;
extern bool ShowMarketInfo = false;
extern bool ShowAccountStatus = false;
extern bool ShowStat = false;
extern bool ShowDecision = false;
extern bool ShowDirection = false;
extern bool BlockSell = false;
extern bool BlockBuy = false;
extern bool ShowLots = false;
extern bool BlockStopLoss = false;
extern bool DisableShadowStopLoss = true;
extern bool DisableExitSell = false;
extern bool DisableExitBuy = false;
extern bool EnableMACD = false;
extern bool EnableMA = false;
extern bool EnableCyberiaLogic = true;
extern bool EnableLogicTrading = false;
extern bool EnableMoneyTrain = false;
extern bool EnableReverceDetector = false;
extern double ReverceIndex = 3;
extern double MoneyTrainLevel = 4;
extern int MACDLevel = 10;
extern bool AutoLots = False;
extern bool AutoDirection = True;
extern double ValuesPeriodCount = 23;
extern double ValuesPeriodCountMax = 23;
extern double SlipPage = 1; // Slippage of the rate
extern double Lots = 0.1; // Quantity of the lots
extern double StopLoss = 0;
extern double TakeProfit = 0;
extern double SymbolsCount = 1;
extern double Risk = 0.5;
extern double StopLossIndex = 1.1;
extern bool AutoStopLossIndex = true;
extern double StopLevel;
bool DisableSell = false;
bool DisableBuy = false;
bool ExitSell = false;
bool ExitBuy = false;
double Disperce = 0;
double DisperceMax = 0;
bool DisableSellPipsator = false;
bool DisableBuyPipsator = false;
//----
double ValuePeriod = 1; // Step of period in minutes
double ValuePeriodPrev = 1;
int FoundOpenedOrder = false;
bool DisablePipsator = false;
double BidPrev = 0;
double AskPrev = 0;
// Variables for evaluating the quality of the simulation
double BuyPossibilityQuality;
double SellPossibilityQuality;
double UndefinedPossibilityQuality;
//double BuyPossibilityQualityMid;
double PossibilityQuality;
double QualityMax = 0;
//----
double BuySucPossibilityQuality;
double SellSucPossibilityQuality;
double UndefinedSucPossibilityQuality;
double PossibilitySucQuality;
//----
double ModelingPeriod; // Period of simulation in the minutes
double ModelingBars; // Quantity of steps in the period
//----
double Spread; // Spread
double Decision;
double DecisionValue;
double PrevDecisionValue;
//----
int ticket, total, cnt;
//----
double BuyPossibility;
double SellPossibility;
double UndefinedPossibility;
double BuyPossibilityPrev;
double SellPossibilityPrev;
double UndefinedPossibilityPrev;
//----
double BuySucPossibilityMid; // Average probability of the successful purchase
double SellSucPossibilityMid; // Average probability of successful sale
double UndefinedSucPossibilityMid; // Average successful probability of the indeterminate state
//----
double SellSucPossibilityCount; // Count of probabilities of successful sale
double BuySucPossibilityCount; // Count of probabilities of the successful purchase
double UndefinedSucPossibilityCount; // Count of probabilities of the indeterminate state
//----
double BuyPossibilityMid; // Average probability of the purchase
double SellPossibilityMid; // Average probability of sale
double UndefinedPossibilityMid; // Average probability of the indeterminate state
//----
double BuyPossibilityCount; // Count of probabilities of purchase
double SellPossibilityCount; // Count of probabilities of sale
double UndefinedPossibilityCount; // Count of probabilities of the indeterminate state
//----
// Variables for the storage information (data) about the market
double ModeLow;
double ModeHigh;
double ModeTime;
double ModeBid;
double ModeAsk;
double ModePoint;
double ModeDigits;
double ModeSpread;
double ModeStopLevel;
double ModeLotSize;
double ModeTickValue;
double ModeTickSize;
double ModeSwapLong;
double ModeSwapShort;
double ModeStarting;
double ModeExpiration;
double ModeTradeAllowed;
double ModeMinLot;
double ModeLotStep;
//
/* System specific */
//
string SystemName = "CyberiaTrader";
double version = 1.50;
//+------------------------------------------------------------------+
//| We read information about the market |
//+------------------------------------------------------------------+
int GetMarketInfo()
{
ModeLow = MarketInfo(Symbol(), MODE_LOW);
ModeHigh = MarketInfo(Symbol(), MODE_HIGH);
ModeTime = MarketInfo(Symbol(), MODE_TIME);
ModeBid = MarketInfo(Symbol(), MODE_BID);
ModeAsk = MarketInfo(Symbol(), MODE_ASK);
ModePoint = MarketInfo(Symbol(), MODE_POINT);
ModeDigits = MarketInfo(Symbol(), MODE_DIGITS);
ModeSpread = MarketInfo(Symbol(), MODE_SPREAD);
ModeStopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL);
ModeLotSize = MarketInfo(Symbol(), MODE_LOTSIZE);
ModeTickValue = MarketInfo(Symbol(), MODE_TICKVALUE);
ModeTickSize = MarketInfo(Symbol(), MODE_TICKSIZE);
ModeSwapLong = MarketInfo(Symbol(), MODE_SWAPLONG);
ModeSwapShort = MarketInfo(Symbol(), MODE_SWAPSHORT);
ModeStarting = MarketInfo(Symbol(), MODE_STARTING);
ModeExpiration = MarketInfo(Symbol(), MODE_EXPIRATION);
ModeTradeAllowed = MarketInfo(Symbol(), MODE_TRADEALLOWED);
ModeMinLot = MarketInfo(Symbol(), MODE_MINLOT);
ModeLotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
// It is concluded information about the market
if ( ShowMarketInfo == True )
{
Print("ModeLow:",ModeLow);
Print("ModeHigh:",ModeHigh);
Print("ModeTime:",ModeTime);
Print("ModeBid:",ModeBid);
Print("ModeAsk:",ModeAsk);
Print("ModePoint:",ModePoint);
Print("ModeDigits:",ModeDigits);
Print("ModeSpread:",ModeSpread);
Print("ModeStopLevel:",ModeStopLevel);
Print("ModeLotSize:",ModeLotSize);
Print("ModeTickValue:",ModeTickValue);
Print("ModeTickSize:",ModeTickSize);
Print("ModeSwapLong:",ModeSwapLong);
Print("ModeSwapShort:",ModeSwapShort);
Print("ModeStarting:",ModeStarting);
Print("ModeExpiration:",ModeExpiration);
Print("ModeTradeAllowed:",ModeTradeAllowed);
Print("ModeMinLot:",ModeMinLot);
Print("ModeLotStep:",ModeLotStep);
}
return (0);
}
//+------------------------------------------------------------------+
//| Calculation of lot quantity |
//+------------------------------------------------------------------+
int CyberiaLots()
{
GetMarketInfo();
// Sum of the calculation
double S;
// Cost of the lot
double L;
// Lot quantity
double k;
// Cost of one pip
if( AutoLots == true )
{
if(SymbolsCount != OrdersTotal())
{
S = (AccountBalance()* Risk - AccountMargin()) * AccountLeverage() /
(SymbolsCount - OrdersTotal());
}
else
{
S = 0;
}
// We check, does currency appear to be EURUSD?
if(StringFind( Symbol(), "USD") == -1)
{
if(StringFind( Symbol(), "EUR") == -1)
{
S = 0;
}
else
{
S = S / iClose ("EURUSD", PERIOD_M1, 0);
if(StringFind( Symbol(), "EUR") != 0)
{
S /= Bid;
}
}
}
else
{
if(StringFind(Symbol(), "USD") != 0)
{
S /= Bid;
}
}
S /= ModeLotSize;
S -= ModeMinLot;
S /= ModeLotStep;
S = NormalizeDouble(S, 0);
S *= ModeLotStep;
S += ModeMinLot;
Lots = S;
if(ShowLots == True)
Print ("Lots:", Lots);
}
return (0);
}
//+------------------------------------------------------------------+
//| We initialize the adviser |
//+------------------------------------------------------------------+
int init()
{
AccountStatus();
GetMarketInfo();
ModelingPeriod = ValuePeriod * ValuesPeriodCount; // Period of simulation in minutes
if (ValuePeriod != 0 )
ModelingBars = ModelingPeriod / ValuePeriod; // Quantity of steps in the period
CalculateSpread();
return(0);
}
//+------------------------------------------------------------------+
//| We calculate the actual value of spread (returned functions on |
//| the market can give the incorrect actual value of spread if the |
//| broker varies the value of spread |
//+------------------------------------------------------------------+
int CalculateSpread()
{
Spread = Ask - Bid;
return (0);
}
//+------------------------------------------------------------------+
//| We make the decision |
//+------------------------------------------------------------------+
int CalculatePossibility (int shift)
{
DecisionValue = iClose( Symbol(), PERIOD_M1, ValuePeriod * shift) - iOpen( Symbol(), PERIOD_M1, ValuePeriod * shift);
PrevDecisionValue = iClose( Symbol(), PERIOD_M1, ValuePeriod * (shift+1)) - iOpen( Symbol(), PERIOD_M1, ValuePeriod * (shift+1));
SellPossibility = 0;
BuyPossibility = 0;
UndefinedPossibility = 0;
if(DecisionValue != 0) // If the solution not definite
{
if(DecisionValue > 0) // If the solution in favor of sale
{
// Suspicion to the probability of sale
if(PrevDecisionValue < 0) // Confirmation of the solution in favor of sale
{
Decision = DECISION_SELL;
BuyPossibility = 0;
SellPossibility = DecisionValue;
UndefinedPossibility = 0;
}
else // Otherwise the solution is not determined
{
Decision = DECISION_UNKNOWN;
UndefinedPossibility = DecisionValue;
BuyPossibility = 0;
SellPossibility = 0;
}
}
else // If the solution in favor of the purchase
{
if(PrevDecisionValue > 0) // Confirmation of the solution in favor of buy
{
Decision = DECISION_BUY;
SellPossibility = 0;
UndefinedPossibility = 0;
BuyPossibility = -1 * DecisionValue;
}
else // The solution is not determined
{
Decision = DECISION_UNKNOWN;
UndefinedPossibility = -1 * DecisionValue;
SellPossibility = 0;
BuyPossibility = 0;
}
}
}
else
{
Decision = DECISION_UNKNOWN;
UndefinedPossibility = 0;
SellPossibility = 0;
BuyPossibility = 0;
}
return (Decision);
}
//+------------------------------------------------------------------+
//| We calculate the statistics of the probabilities |
//+------------------------------------------------------------------+
int CalculatePossibilityStat()
{
int i;
BuySucPossibilityCount = 0;
SellSucPossibilityCount = 0;
UndefinedSucPossibilityCount = 0;
//----
BuyPossibilityCount = 0;
SellPossibilityCount = 0;
UndefinedPossibilityCount = 0;
// We calculate the average values of the probability
BuySucPossibilityMid = 0;
SellSucPossibilityMid = 0;
UndefinedSucPossibilityMid = 0;
BuyPossibilityQuality = 0;
SellPossibilityQuality = 0;
UndefinedPossibilityQuality = 0;
PossibilityQuality = 0;
//----
BuySucPossibilityQuality = 0;
SellSucPossibilityQuality = 0;
UndefinedSucPossibilityQuality = 0;
PossibilitySucQuality = 0;
for( i = 0 ; i < ModelingBars ; i ++ )
{
// We calculate the solution for this interval
CalculatePossibility (i);
// If the solution for value of i - was sold
if(Decision == DECISION_SELL )
SellPossibilityQuality ++;
// If the solution for value of i - was bought
if(Decision == DECISION_BUY )
BuyPossibilityQuality ++;
// If the solution for value of i - is not determined
if(Decision == DECISION_UNKNOWN )
UndefinedPossibilityQuality ++;
// The same estimations for the successful situations
//
if((BuyPossibility > Spread) || (SellPossibility > Spread) ||
(UndefinedPossibility > Spread))
{
if(Decision == DECISION_SELL)
SellSucPossibilityQuality ++;
if(Decision == DECISION_BUY)
BuySucPossibilityQuality ++;
if(Decision == DECISION_UNKNOWN )
UndefinedSucPossibilityQuality ++;
}
// Âû÷èñëÿåì ñðåäíèå âåðîÿòíîñòè ñîáûòèé
// Âåðîÿòíîñòè ïîêóïêè
BuyPossibilityMid *= BuyPossibilityCount;
BuyPossibilityCount ++;
BuyPossibilityMid += BuyPossibility;
if(BuyPossibilityCount != 0 )
BuyPossibilityMid /= BuyPossibilityCount;
else
BuyPossibilityMid = 0;
// Probabilities of sale
SellPossibilityMid *= SellPossibilityCount;
SellPossibilityCount ++;
SellPossibilityMid += SellPossibility;
if(SellPossibilityCount != 0 )
SellPossibilityMid /= SellPossibilityCount;
else
SellPossibilityMid = 0;
// Probabilities of the indeterminate state
UndefinedPossibilityMid *= UndefinedPossibilityCount;
UndefinedPossibilityCount ++;
UndefinedPossibilityMid += UndefinedPossibility;
if(UndefinedPossibilityCount != 0)
UndefinedPossibilityMid /= UndefinedPossibilityCount;
else
UndefinedPossibilityMid = 0;
// We calculate the average probabilities of the successful events
if(BuyPossibility > Spread)
{
BuySucPossibilityMid *= BuySucPossibilityCount;
BuySucPossibilityCount ++;
BuySucPossibilityMid += BuyPossibility;
if(BuySucPossibilityCount != 0)
BuySucPossibilityMid /= BuySucPossibilityCount;
else
BuySucPossibilityMid = 0;
}
if(SellPossibility > Spread)
{
SellSucPossibilityMid *= SellSucPossibilityCount;
SellSucPossibilityCount ++;
SellSucPossibilityMid += SellPossibility;
if (SellSucPossibilityCount != 0)
SellSucPossibilityMid /= SellSucPossibilityCount;
else
SellSucPossibilityMid = 0;
}
if(UndefinedPossibility > Spread)
{
UndefinedSucPossibilityMid *= UndefinedSucPossibilityCount;
UndefinedSucPossibilityCount ++;
UndefinedSucPossibilityMid += UndefinedPossibility;
if(UndefinedSucPossibilityCount != 0)
UndefinedSucPossibilityMid /= UndefinedSucPossibilityCount;
else
UndefinedSucPossibilityMid = 0;
}
}
if((UndefinedPossibilityQuality + SellPossibilityQuality + BuyPossibilityQuality)!= 0)
PossibilityQuality = (SellPossibilityQuality + BuyPossibilityQuality) /
(UndefinedPossibilityQuality + SellPossibilityQuality + BuyPossibilityQuality);
else
PossibilityQuality = 0;
// Quality for the successful situations
if((UndefinedSucPossibilityQuality + SellSucPossibilityQuality +
BuySucPossibilityQuality)!= 0)
PossibilitySucQuality = (SellSucPossibilityQuality + BuySucPossibilityQuality) /
(UndefinedSucPossibilityQuality + SellSucPossibilityQuality +
BuySucPossibilityQuality);
else
PossibilitySucQuality = 0;
return (0);
}
//+------------------------------------------------------------------+
//| We show the statistics |
//+------------------------------------------------------------------+
int DisplayStat()
{
if(ShowStat == true)
{
Print ("SellPossibilityMid*SellPossibilityQuality:", SellPossibilityMid*SellPossibilityQuality);
Print ("BuyPossibilityMid*BuyPossibilityQuality:", BuyPossibilityMid*BuyPossibilityQuality);
Print ("UndefinedPossibilityMid*UndefinedPossibilityQuality:", UndefinedPossibilityMid*UndefinedPossibilityQuality);
Print ("UndefinedSucPossibilityQuality:", UndefinedSucPossibilityQuality);
Print ("SellSucPossibilityQuality:", SellSucPossibilityQuality);
Print ("BuySucPossibilityQuality:", BuySucPossibilityQuality);
Print ("UndefinedPossibilityQuality:", UndefinedPossibilityQuality);
Print ("SellPossibilityQuality:", SellPossibilityQuality);
Print ("BuyPossibilityQuality:", BuyPossibilityQuality);
Print ("UndefinedSucPossibilityMid:", UndefinedSucPossibilityMid);
Print ("SellSucPossibilityMid:", SellSucPossibilityMid);
Print ("BuySucPossibilityMid:", BuySucPossibilityMid);
Print ("UndefinedPossibilityMid:", UndefinedPossibilityMid);
Print ("SellPossibilityMid:", SellPossibilityMid);
Print ("BuyPossibilityMid:", BuyPossibilityMid);
}
return (0);
}
//+------------------------------------------------------------------+
//| We analyze state for decision making |
//+------------------------------------------------------------------+
int CyberiaDecision()
{
// We calculate the statistics of the period
CalculatePossibilityStat();
// We calculate the probabilities of the accomplishment of the transactions
CalculatePossibility(0);
DisplayStat();
return(Decision);
}
//+------------------------------------------------------------------+
//| We calculate the direction of the motion of the market |
//+------------------------------------------------------------------+
int CalculateDirection()
{
DisableSellPipsator = false;
DisableBuyPipsator = false;
DisablePipsator = false;
DisableSell = false;
DisableBuy = false;
//----
if(EnableCyberiaLogic == true)
{
AskCyberiaLogic();
}
if(EnableMACD == true)
AskMACD();
if(EnableMA == true)
AskMA();
if(EnableReverceDetector == true)
ReverceDetector();
return (0);
}
//+---------------------------------------------------------------------------------+
//| If probabilities exceed the thresholds of the inversion of the solution |
//+---------------------------------------------------------------------------------+
int ReverceDetector ()
{
if((BuyPossibility > BuyPossibilityMid * ReverceIndex && BuyPossibility != 0 &&
BuyPossibilityMid != 0) ||(SellPossibility > SellPossibilityMid * ReverceIndex &&
SellPossibility != 0 && SellPossibilityMid != 0))
{
if(DisableSell == true)
DisableSell = false;
else
DisableSell = true;
if(DisableBuy == true)
DisableBuy = false;
else
DisableBuy = true;
//----
if(DisableSellPipsator == true)
DisableSellPipsator = false;
else
DisableSellPipsator = true;
if(DisableBuyPipsator == true)
DisableBuyPipsator = false;
else
DisableBuyPipsator = true;
}
return (0);
}
//+------------------------------------------------------------------+
//| We interrogate the logic of the trade CyberiaLogic(C) |
//+------------------------------------------------------------------+
int AskCyberiaLogic()
{
// We establish blockings with drops in the market
/*DisableBuy = true;
DisableSell = true;
DisablePipsator = false;*/
// If market evenly moves in the assigned direction
if(ValuePeriod > ValuePeriodPrev)
{
if(SellPossibilityMid*SellPossibilityQuality > BuyPossibilityMid*BuyPossibilityQuality)
{
DisableSell = false;
DisableBuy = true;
DisableBuyPipsator = true;
if(SellSucPossibilityMid*SellSucPossibilityQuality >
BuySucPossibilityMid*BuySucPossibilityQuality)
{
DisableSell = true;
}
}
if(SellPossibilityMid*SellPossibilityQuality < BuyPossibilityMid*BuyPossibilityQuality)
{
DisableSell = true;
DisableBuy = false;
DisableSellPipsator = true;
if(SellSucPossibilityMid*SellSucPossibilityQuality <
BuySucPossibilityMid*BuySucPossibilityQuality)
{
DisableBuy = true;
}
}
}
// If market changes direction - never deal against the trend!!!
if(ValuePeriod < ValuePeriodPrev)
{
if(SellPossibilityMid*SellPossibilityQuality > BuyPossibilityMid*BuyPossibilityQuality)
{
DisableSell = true;
DisableBuy = true;
}
if(SellPossibilityMid*SellPossibilityQuality < BuyPossibilityMid*BuyPossibilityQuality)
{
DisableSell = true;
DisableBuy = true;
}
}
// If market is horizontal
if(SellPossibilityMid*SellPossibilityQuality == BuyPossibilityMid*BuyPossibilityQuality)
{
DisableSell = true;
DisableBuy = true;
DisablePipsator=false;
}
// We block the probability of output from the market
if(SellPossibility > SellSucPossibilityMid * 2 && SellSucPossibilityMid > 0)
{
DisableSell = true;
DisableSellPipsator = true;
}
// We block the probability of output from the market
if(BuyPossibility > BuySucPossibilityMid * 2 && BuySucPossibilityMid > 0 )
{
DisableBuy = true;
DisableBuyPipsator = true;
}
if(ShowDirection == true)
{
if(DisableSell == true )
{
Print("Sale is blocked:", SellPossibilityMid*SellPossibilityQuality);
}
else
{
Print ("Sale is permitted:", SellPossibilityMid*SellPossibilityQuality);
}
//----
if(DisableBuy == true )
{
Print ("Purchase is blocked:", BuyPossibilityMid*BuyPossibilityQuality);
}
else
{
Print ("Purchase is permitted:", BuyPossibilityMid*BuyPossibilityQuality);
}
}
if(ShowDecision == true)
{
if(Decision == DECISION_SELL)
Print("Solution - to sell: ", DecisionValue);
if(Decision == DECISION_BUY)
Print("Solution - to buy: ", DecisionValue);
if(Decision == DECISION_UNKNOWN)
Print("Solution - uncertainty: ", DecisionValue);
}
return (0);
}
//+------------------------------------------------------------------+
//| We interrogate indicator MA |
//+------------------------------------------------------------------+
int AskMA()
{
if(iMA(Symbol(), PERIOD_M1, ValuePeriod, 0 , MODE_EMA, PRICE_CLOSE, 0) >
iMA(Symbol(), PERIOD_M1, ValuePeriod, 0 , MODE_EMA, PRICE_CLOSE, 1))
{
DisableSell = true;
DisableSellPipsator = true;
}
if(iMA(Symbol(), PERIOD_M1, ValuePeriod, 0 , MODE_EMA, PRICE_CLOSE, 0) <
iMA(Symbol(), PERIOD_M1, ValuePeriod, 0 , MODE_EMA, PRICE_CLOSE, 1))
{
DisableBuy = true;
DisableBuyPipsator = true;
}
return (0);
}
//+------------------------------------------------------------------+
//| We interrogate indicator MACD |
//+------------------------------------------------------------------+
int AskMACD()
{
double DecisionIndex = 0;
double SellIndex = 0;
double BuyIndex = 0;
double BuyVector = 0;
double SellVector = 0;
double BuyResult = 0;
double SellResult = 0;
DisablePipsator = false;
DisableSellPipsator = false;
DisableBuyPipsator = false;
DisableBuy = false;
DisableSell = false;
DisableExitSell = false;
DisableExitBuy = false;
// We block the errors
for(int i = 0 ; i < MACDLevel ; i ++)
{
if(iMACD(Symbol(), MathPow( 2, i) , 2, 4, 1, PRICE_CLOSE, MODE_MAIN, 0) <
iMACD(Symbol(), MathPow( 2, i), 2, 4, 1, PRICE_CLOSE, MODE_MAIN, 1) )
{
SellIndex += iMACD(Symbol(), MathPow( 2, i), 2, 4, 1, PRICE_CLOSE, MODE_MAIN, 0);
}
if(iMACD(Symbol(), MathPow( 2, i), 2, 4, 1, PRICE_CLOSE, MODE_MAIN, 0) >
iMACD(Symbol(), MathPow( 2, i), 2, 4, 1, PRICE_CLOSE, MODE_MAIN, 1) )
{
BuyIndex += iMACD(Symbol(), MathPow( 2, i), 2, 4, 1, PRICE_CLOSE, MODE_MAIN, 0);
}
}
if(SellIndex> BuyIndex)
{
DisableBuy = true;
DisableBuyPipsator = true;
}
if(SellIndex < BuyIndex)
{
DisableSell = true;
DisableSellPipsator = true;
}
return (0);
}
//+-------------------------------------------------------------------------------+
//| We catch market GEP - it is included directly before the output of the news |
//+-------------------------------------------------------------------------------+
int MoneyTrain()
{
if(FoundOpenedOrder == False)
{
// We count the dispersion
Disperce = (iHigh ( Symbol(), PERIOD_M1, 0) - iLow ( Symbol(), PERIOD_M1, 0));
if(Decision == DECISION_SELL)
{
// We jump into the locomotive in the direction of the motion of chaos of the market
if((iClose( Symbol(), PERIOD_M1, 0) - iClose( Symbol(), PERIOD_M1, ValuePeriod)) /
MoneyTrainLevel >= SellSucPossibilityMid && SellSucPossibilityMid != 0 && EnableMoneyTrain == true)
{
ModeSpread = ModeSpread + 1;
// Calculation of the stoploss
if((Bid - SellSucPossibilityMid*StopLossIndex- ModeSpread * Point) >
(Bid - ModeStopLevel* ModePoint- ModeSpread * Point))
{
StopLoss = Bid - ModeStopLevel* ModePoint- ModeSpread * Point - Disperce;
}
else
{
if(SellSucPossibilityMid != 0)
StopLoss = Bid - SellSucPossibilityMid*StopLossIndex - ModeSpread * Point - Disperce;
else
StopLoss = Bid - ModeStopLevel* ModePoint- ModeSpread * Point - Disperce;
}
// If the manual blocking of purchase is included
if(BlockBuy == true)
{
return(0);
}
StopLevel = StopLoss;
Print ("StopLevel:", StopLevel);
// Blocking stoploss
if(BlockStopLoss == true)
StopLoss = 0;
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, SlipPage, StopLoss, TakeProfit,"CyberiaTrader-AI-HB1",0,0,Blue);
if(ticket > 0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
Print("Long order is opened: ",OrderOpenPrice());
}
else
{
Print("Error on the Long Entry: ",GetLastError());
PrintErrorValues();
}
return (0);
}
}
if(Decision == DECISION_BUY)
{
// We jump into the locomotive in the direction of the motion of chaos of the market
if((iClose( Symbol(), PERIOD_M1, ValuePeriod) - iClose( Symbol(), PERIOD_M1, 0)) /
MoneyTrainLevel >= BuySucPossibilityMid && BuySucPossibilityMid != 0 &&
EnableMoneyTrain == true)
{
ModeSpread = ModeSpread + 1;
// Calculation of the stoploss
if((Ask + BuySucPossibilityMid*StopLossIndex+ ModeSpread* Point) <
(Ask + ModeStopLevel* ModePoint+ ModeSpread * Point))
{
StopLoss = Ask + ModeStopLevel* ModePoint+ ModeSpread * Point+ Disperce;
}
else
{
if(BuySucPossibilityMid != 0)
StopLoss = Ask + BuySucPossibilityMid*StopLossIndex+ ModeSpread*Point +
Disperce;
else
StopLoss = Ask + ModeStopLevel* ModePoint+ ModeSpread * Point+ Disperce;
}
// If the manual blocking of sales is included
if(BlockSell == true)
{
return(0);
}
StopLevel = StopLoss;
Print ("StopLevel:", StopLevel);
// Blocking stoploss
if(BlockStopLoss == true)
StopLoss = 0;
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, SlipPage, StopLoss,
TakeProfit, "CyberiaTrader-AI-HS1", 0, 0, Green);
if(ticket > 0)
{
if(OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
Print("Short order is opened: ", OrderOpenPrice());
}
else
{
Print("Error on the Short Entry: ",GetLastError());
PrintErrorValues();
}
return (0);
}
}
}
return (0);
}
//+------------------------------------------------------------------+
//| Entrance into the market |
//+------------------------------------------------------------------+
int EnterMarket()
{
// If there are no lots, we leave
if(Lots == 0)
{
return (0);
}
// We enter into market if there is no command of exit from the market
if(ExitMarket == False)
{
// If there are no open orders - we enter into the market
if(FoundOpenedOrder == False)
{
// We count the dispersion
Disperce = (iHigh(Symbol(), PERIOD_M1, 0) - iLow(Symbol(), PERIOD_M1, 0));
if(Decision == DECISION_SELL)
{
// If the price of purchase is more than the average value of purchase in the interval being simulated
if(SellPossibility >= SellSucPossibilityMid)
{
// Calculation of the stoploss
if((Ask + BuySucPossibilityMid*StopLossIndex + ModeSpread * Point) <
(Ask + ModeStopLevel* ModePoint+ ModeSpread * Point))
{
StopLoss = Ask + ModeStopLevel* ModePoint+ ModeSpread * Point + Disperce;
}
else
{
if(BuySucPossibilityMid != 0)
StopLoss = Ask + BuySucPossibilityMid*StopLossIndex +
ModeSpread * Point+ Disperce;
else
StopLoss = Ask + ModeStopLevel* ModePoint+ ModeSpread * Point +
Disperce;
}
// If the manual blocking of sales is chosen
if(DisableSell == true)
{
return(0);
}
if(BlockSell == true)
{
return(0);
}
StopLevel = StopLoss;
Print ("StopLevel:", StopLevel);
// Blocking stoploss
if(BlockStopLoss == true)
StopLoss = 0;
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, SlipPage, StopLoss,
TakeProfit, "CyberiaTrader-AI-LS1", 0, 0, Green);
if(ticket > 0)
{
if(OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
Print("Short order is opened: ",OrderOpenPrice());
}
else
{
Print("Error on the Short Entry: ",GetLastError());
PrintErrorValues();
}
// We preserve the previous value of the period
return (0);
}
}
if(Decision == DECISION_BUY)
{
// If the price of purchase is more than the average value of purchase in the interval being simulated
if(BuyPossibility >= BuySucPossibilityMid)
{
// Calculation of the stoploss
if((Bid - SellSucPossibilityMid*StopLossIndex- ModeSpread* Point) >
(Bid - ModeStopLevel* ModePoint- ModeSpread* Point))
{
StopLoss = Bid - ModeStopLevel* ModePoint- ModeSpread* Point - Disperce;
}
else
{
if(SellSucPossibilityMid != 0)
StopLoss = Bid - SellSucPossibilityMid*StopLossIndex-
ModeSpread* Point- Disperce;
else
StopLoss = Bid - ModeStopLevel* ModePoint- ModeSpread* Point-
Disperce;
}
// If the manual blocking of the purchases is chosen
if(DisableBuy == true)
{
return(0);
}
if(BlockBuy == true)
{
return(0);
}
StopLevel = StopLoss;
Print("StopLevel:", StopLevel);
// Blocking stoploss
if(BlockStopLoss == true)
StopLoss = 0;
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, SlipPage, StopLoss,
TakeProfit, "CyberiaTrader-AI-LB1", 0, 0, Blue);
if(ticket > 0)
{
if(OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
Print("Long order is opened: ",OrderOpenPrice());
}
else
{
Print("Error on the Long Entry: ",GetLastError());
PrintErrorValues();
}
return (0);
}
}
}
// ---------------- End of the entrance into the market ----------------------
}
return (0);
}
//+------------------------------------------------------------------+
//| Search for the open orders |
//+------------------------------------------------------------------+
int FindSymbolOrder()
{
FoundOpenedOrder = false;
total = OrdersTotal();
for(cnt = 0; cnt < total; cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
// We search for order on our currency
if(OrderSymbol() == Symbol())
{
FoundOpenedOrder = True;
break;
}
else
{
StopLevel = 0;
StopLoss = 0;
}
}
return (0);
}
//+------------------------------------------------------------------+
//| Pipsator in the minute intervals |
//+------------------------------------------------------------------+
int RunPipsator()
{
int i = 0;
FindSymbolOrder();
// We enter into market if there is no command of output from the market
// We count the dispersion
if(Lots == 0)
return (0);
Disperce = 0;
if(ExitMarket == False)
{
// ---------- If there are no open orders - we enter into the market ----------
if(FoundOpenedOrder == False)
{
Disperce = 0;
DisperceMax = 0;
// We count the maximum dispersion
for(i = 0 ; i < ValuePeriod ; i ++)
{
Disperce = (iHigh( Symbol(), PERIOD_M1, i + 1) -
iLow( Symbol(), PERIOD_M1, i + 1));
if(Disperce > DisperceMax)
DisperceMax = Disperce;
}
Disperce = DisperceMax * StopLossIndex;
if( Disperce == 0 )
{
Disperce = ModeStopLevel * Point;
}
for(i = 0 ; i < ValuePeriod ; i ++)
{
// Pipsator of minute interval on sale
if((Bid - iClose( Symbol(), PERIOD_M1, i + 1)) > SellSucPossibilityMid * (i + 1) && SellSucPossibilityMid != 0 && DisablePipsator == false &&
DisableSellPipsator == false)
{
// Pipsator of minute interval stoploss
if((Ask + ModeSpread * Point + Disperce) <
(Ask + ModeStopLevel* ModePoint + ModeSpread * Point))
{
StopLoss = Ask + ModeStopLevel* ModePoint+ ModeSpread * Point + Point;
}
else
{
if(BuySucPossibilityMid != 0)
StopLoss = Ask + ModeSpread * Point+ Disperce + Point;
else
StopLoss = Ask + ModeStopLevel* ModePoint+ ModeSpread * Point + Point;
}
// If the manual blocking of sales is chosen
if(BlockSell == true)
{
return(0);
}
// If the manual blocking of sales is chosen
if(DisableSell == true)
{
return(0);
}
StopLevel = StopLoss;
Print("StopLevel:", StopLevel);
// Blocking Stoploss
if(BlockStopLoss == true)
StopLoss = 0;
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, SlipPage, StopLoss,
TakeProfit, "CyberiaTrader-AI-PS1", 0, 0, Green);
if(ticket > 0)
{
if(OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
Print("Short order is opened: ",OrderOpenPrice());
}
else
{
Print("Error on the Short Entry: ",GetLastError());
PrintErrorValues();
}
return (0);
}
// Pipsator of minute interval on the purchase
if((iClose(Symbol(), PERIOD_M1, i + 1) - Bid) > BuySucPossibilityMid *(i + 1) &&
BuySucPossibilityMid != 0 && DisablePipsator == False &&
DisableBuyPipsator == false)
{
// Calculation of the stoploss
if((Bid - ModeSpread * Point - Disperce) >
(Bid - ModeStopLevel* ModePoint- ModeSpread * Point))
{
StopLoss = Bid - ModeStopLevel* ModePoint- ModeSpread * Point - Point;
}
else
{
if(SellSucPossibilityMid != 0)
StopLoss = Bid - ModeSpread * Point- Disperce- Point;
else
StopLoss = Bid - ModeStopLevel* ModePoint- ModeSpread * Point - Point;
}
// If the manual blocking is chosen
if(DisableBuy == true)
{
return(0);
}
if(BlockBuy == true)
{
return(0);
}
StopLevel = StopLoss;
Print("StopLevel:", StopLevel);
// Blocking Stoploss
if(BlockStopLoss == true)
StopLoss = 0;
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, SlipPage, StopLoss,
TakeProfit, "CyberiaTrader-AI-PB1", 0, 0, Blue);
if(ticket > 0)
{
if(OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
Print("Long order is opened: ",OrderOpenPrice());
}
else
{
Print("Error on the Long Entry: ",GetLastError());
PrintErrorValues();
}
return (0);
}
} // End of the pipsator cycle
}
}
return (0);
}
//+------------------------------------------------------------------+
//| Exit from the market |
//+------------------------------------------------------------------+
int ExitMarket ()
{
//FindSymbolOrder();
// -------------------- Working the open orders -------------------
if(FoundOpenedOrder == True) // If there is the open order on this currency
{
if(OrderType()==OP_BUY) // If the obtained order to the acquisition of the currency
{
// Closing order, if it reached the level of the stoploss
if(Bid <= StopLevel && DisableShadowStopLoss == false && StopLevel != 0)
{
OrderClose(OrderTicket(),OrderLots(),Bid ,SlipPage,Violet); // Çàêðûâàåì îðäåð
return(0);
}
if(DisableExitBuy == true)
return (0);
// Closing pipsator
if((OrderOpenPrice() < Bid))
{
OrderClose(OrderTicket(), OrderLots(), Bid , SlipPage, Violet); // we close the order
return(0);
}
// We do not leave from the market, if we have chaos, which works on the profit
if((iClose( Symbol(), PERIOD_M1, 0) - iClose( Symbol(), PERIOD_M1, 1)) >= SellSucPossibilityMid * 4 && SellSucPossibilityMid > 0)
return(0);
// Closing order on exceeding of the probability of successful sale
if((OrderOpenPrice() < Bid) && (Bid - OrderOpenPrice() >= SellSucPossibilityMid) && (SellSucPossibilityMid > 0) )
{
OrderClose(OrderTicket(), OrderLots(), Bid , SlipPage, Violet); // Close the order
return(0);
}
// Closing order on exceeding of the probability of the successful purchase
if((OrderOpenPrice() < Bid) && (Bid - OrderOpenPrice() >= BuySucPossibilityMid) && (BuySucPossibilityMid > 0) )
{
OrderClose(OrderTicket(), OrderLots(), Bid , SlipPage, Violet); // Close the order
return(0);
}
if(Decision == DECISION_SELL)
{
// If the price of sale is more than the price of purchase - it means we have a profit (taking into account the slippage)
//if ( OrderOpenPrice() < Bid - SlipPage * Point )
if( OrderOpenPrice() < Bid)
{
// If the price of purchase is more than the average value of purchase in the interval being simulated
if(SellPossibility >= SellPossibilityMid - Point)
{
OrderClose(OrderTicket(), OrderLots(), Bid , SlipPage, Violet); // Close the order
return(0);
}
}
}
// Closing order on the indicator of indeterminate possibility
if((OrderOpenPrice() < Bid) && (Bid - OrderOpenPrice() >= UndefinedPossibilityMid) )
{
OrderClose(OrderTicket(), OrderLots(), Bid , SlipPage, Violet); // Close the order
return(0);
}
// We do check is it possible to sell it at the present moment
if(Decision == DECISION_BUY)
{
return(0);
}
}
if(OrderType() == OP_SELL) // If the obtained order to the acquisition of the currency
{
// Closing order, if it reached the level of the stoploss
if(Ask >= StopLevel && DisableShadowStopLoss == false && StopLevel != 0)
{
OrderClose(OrderTicket(), OrderLots(), Ask , SlipPage, Violet); // Close the order
return(0);
}
if(DisableExitSell == true)
return (0);
// Closing pipsator
if((OrderOpenPrice() > Ask))
{
OrderClose(OrderTicket(), OrderLots(), Ask, SlipPage, Violet); // Close the order
return(0);
}
// We do not leave from the market, if we have chaos, which works on the profit
if((iClose( Symbol(), PERIOD_M1, 1) - iClose( Symbol(), PERIOD_M1, 0)) >= BuySucPossibilityMid * 4 && BuySucPossibilityMid > 0)
return (0);
// Closing order on the fact of probability of the successful purchase
if((OrderOpenPrice() > Ask) && (OrderOpenPrice() - Ask) >=
BuySucPossibilityMid && BuySucPossibilityMid > 0)
{
OrderClose(OrderTicket(), OrderLots(), Ask, SlipPage, Violet); // Close the order
return(0);
}
// Closing warrant on the fact of the probability of successful sale
if((OrderOpenPrice() > Ask) && (OrderOpenPrice() - Ask) >= SellSucPossibilityMid && SellSucPossibilityMid > 0)
{
OrderClose(OrderTicket(), OrderLots(), Ask, SlipPage, Violet); // Close the order
return(0);
}
if (Decision == DECISION_BUY )
{
// If the price of purchase is more than the price of sale - it means we have a profit (taking into account the slippage)
if(OrderOpenPrice() > Ask)
{
// f the price of purchase is more than the average value of purchase in the interval being simulated
if(BuyPossibility >= BuyPossibilityMid - Point)
{
OrderClose(OrderTicket(), OrderLots(), Ask, SlipPage, Violet); // Close the order
return(0);
}
}
}
// Closing warrant on the indicator of indeterminate possibility
if((OrderOpenPrice() > Ask) && (OrderOpenPrice() - Ask) >= UndefinedPossibilityMid)
{
OrderClose(OrderTicket(), OrderLots(), Ask, SlipPage, Violet); // Close the order
return(0);
}
// We do check is it possible to sell it at the present moment
if(Decision == DECISION_SELL)
{
return (0);
}
}
}
// --------------------- End of working the open orders ---------------------
// ValuePeriodPrev = ValuePeriod;
return (0);
}
//+------------------------------------------------------------------------------------+
//| We preserve the values of rates and period of simulation for following statistics |
//+------------------------------------------------------------------------------------+
int SaveStat()
{
BidPrev = Bid;
AskPrev = Ask;
ValuePeriodPrev = ValuePeriod;
return (0);
}
//+------------------------------------------------------------------+
//| Trading Logic |
//+------------------------------------------------------------------+
int Trade ()
{
// We begin to deal
// We search for the open orders
FindSymbolOrder();
CalculateDirection();
AutoStopLossIndex();
//---- If there are no open orders is possible the entrance into the market
//---- Attention - is important precisely this order of the examination of the technologies of the entrance into the market (MoneyTrain, LogicTrading, Pipsator)
if(FoundOpenedOrder == false)
{
if(EnableMoneyTrain == true)
MoneyTrain();
if(EnableLogicTrading == true)
EnterMarket();
if(DisablePipsator == false)
RunPipsator();
}
else
{
ExitMarket();
}
//---- End of working orders logic from the market
return(0);
}
//+------------------------------------------------------------------+
//| To derive the status of the account |
//+------------------------------------------------------------------+
int AccountStatus()
{
if(ShowAccountStatus == True )
{
Print ("AccountBalance:", AccountBalance());
Print ("AccountCompany:", AccountCompany());
Print ("AccountCredit:", AccountCredit());
Print ("AccountCurrency:", AccountCurrency());
Print ("AccountEquity:", AccountEquity());
Print ("AccountFreeMargin:", AccountFreeMargin());
Print ("AccountLeverage:", AccountLeverage());
Print ("AccountMargin:", AccountMargin());
Print ("AccountName:", AccountName());
Print ("AccountNumber:", AccountNumber());
Print ("AccountProfit:", AccountProfit());
}
return ( 0 );
}
//+-----------------------------------------------------------------------+
//| Most important function - selection of the period of the simulation |
//+-----------------------------------------------------------------------+
int FindSuitablePeriod()
{
double SuitablePeriodQuality = -1 *ValuesPeriodCountMax*ValuesPeriodCountMax;
double SuitablePeriod = 0;
int i; // Variable for the analysis of the periods
// Quantity of analyzed periods. i - size of the period
for(i = 0 ; i < ValuesPeriodCountMax ; i ++ )
{
ValuePeriod = i + 1;
// Value selected experimentally and however strangely it coincided with the number in Elliott's theory
ValuesPeriodCount = ValuePeriod * 5;
init();
CalculatePossibilityStat ();
if(PossibilitySucQuality > SuitablePeriodQuality)
{
SuitablePeriodQuality = PossibilitySucQuality;
//Print ("PossibilitySucQuality:", PossibilitySucQuality:);
SuitablePeriod = i + 1;
}
}
ValuePeriod = SuitablePeriod;
init();
// To derive the period of the simulation
if(ShowSuitablePeriod == True)
{
Print("Period of the simulation:", SuitablePeriod, " minutes with the probability:",
SuitablePeriodQuality );
}
return(SuitablePeriod);
}
//+------------------------------------------------------------------+
//| Automatic installation of the level of the stoploss |
//+------------------------------------------------------------------+
int AutoStopLossIndex()
{
if(AutoStopLossIndex == true)
{
StopLossIndex = ModeSpread;
}
return(0);
}
//+------------------------------------------------------------------+
//| Conclusion of errors with the entrance into the market |
//+------------------------------------------------------------------+
int PrintErrorValues()
{
Print("ErrorValues:Symbol=", Symbol(),",Lots=",Lots, ",Bid=", Bid, ",Ask=", Ask,
",SlipPage=", SlipPage, "StopLoss=",StopLoss,",TakeProfit=", TakeProfit);
return (0);
}
//+------------------------------------------------------------------+
//| expert start function (trading) |
//+------------------------------------------------------------------+
int start()
{
string comment_line="";
GetMarketInfo();
CyberiaLots();
CalculateSpread();
FindSuitablePeriod();
CyberiaDecision();
Trade();
SaveStat();
//
/**************************************/
/* REPORTING */
//
comment_line=StringConcatenate("\n",SystemName," v. ",version,"\n");
StringConcatenate(comment_line,"\n");
return(0);
}
Profitability Reports
GBP/USD
Oct 2024 - Jan 2025
0.21
Total Trades
55
Won Trades
0
Lost trades
0
Win Rate
0.00 %
Expected payoff
-0.87
Gross Profit
12.50
Gross Loss
-60.60
Total Net Profit
-48.10
-100%
-50%
0%
50%
100%
NZD/USD
Oct 2024 - Jan 2025
0.01
Total Trades
15
Won Trades
5
Lost trades
10
Win Rate
33.33 %
Expected payoff
-4.71
Gross Profit
0.40
Gross Loss
-71.00
Total Net Profit
-70.60
-100%
-50%
0%
50%
100%
Comments