Publi

Publi

Resultados 1 al 9 de 9


  1. #1

    antecessor


    Reputación:
    Poder de reputación: 6

    Mensajes: 490
    Créditos: 156

    Cyberia Trader Scalper todos los pares


    Publi
    Cyberia Scalper. Todos los pares y TF.

    Se aceptan opiniones, experiencias y optimizaciones.
    Foro de Forex Trading United
    Archivos adjuntados Archivos adjuntados

     

  2.                         
    Publi
  3. #2

    antecessor


    Reputación:
    Poder de reputación: 6

    Mensajes: 490
    Créditos: 156

    Re: Cyberia Trader Scalper todos los pares

    Ok.
    Aquí el hilo, con su creador.
    Great EA in backtest!
    Adjunto ultimas versiones del ea y set. V185 Pag22.
    Habia polemica con SL largos, y TP ajustados de 1 pips. Algunos brokers eso no les gustaba. El asunto se ha mejorado en esta nueva version y Set.
    Se ha reducido los SL, se ha colocado GTM (Hay que modificarlo según vuestro broker) Se ha colocado un TS.
    Tf 5 m y 1h.
    Los set. hay para mercado europa y Asia.
    Foro de Forex Trading United
    Archivos adjuntados Archivos adjuntados

     

  4. #3
    Avatar de Airbrake
    Erectus


    Reputación:
    Poder de reputación: 6

    Mensajes: 137
    Créditos: 580

    Re: Cyberia Trader Scalper todos los pares

    En ese mismo hilo, en la página 148 y en el post #1476 un tal cooltrader28 dice esto:

    "...i trade cyberia v2.01 with pipstep 26 on fxrussia.com standard and hedging
    will publish mt4i.com next week i have profit faktor 8.01..."


    Digo yo que si alguien encontrara el Cyberia v2.01... pues que no estaría mal si lo compartiera ¿no? porque con un profit faktor de 8.01 yo me jubilaba, no se si me he explicado

    Foro de Forex Trading United




  5. #4

    antecessor


    Reputación:
    Poder de reputación: 6

    Mensajes: 490
    Créditos: 156

    Re: Cyberia Trader Scalper todos los pares

    Por lo que he ido leyendo...
    Este ea, los brokers lo tienen capado.
    Me explico.
    Al broker, no le va nada que el ea trabaje tanto a cada minuto. Y mucho menos que saque tanto beneficio en tan poco tiempo.
    Según he ido leyendo el post, el primer ea, va bien. Según avanza el post, salen otras variantes. (En mis BT, no son mejores que el primero, todo lo contrario)
    Según avanza el post, algunos participantes en la configuración, se van ausentando.
    Segun avanza el post, se va llegando a la conclusión que.
    A- aumentar el TP en 2 o 3 pips, es mucho mas rentable.
    B- Ponerlo a trabajar el Tf1h, si bien hace menos operaciones, tambien las hace mas certeras. Y al broker, no le satura los servidores. (MM)
    C- Según avanzan las versiones, le van añadiendo filtros...control de horarios, fiboss, etc...
    D- El par mas rentable, E/U y E/J Tf1h
    E- Creo que el ea tiene potencial, pero hay que dominarlo un poco...
    Conclusion:
    Un horario de trabajo. 1 o 3h al día.
    Sl ajustado.
    Tp de 2/4 pips. o TS.
    Puede funcionar.
    Quien se atreve a meterle mano?
    El control de todas las variables, van apareciendo a lo largo del post, quien tenga tiempo, y le guste, aconsejo según vaya leyendo, que vaya apuntando en papel para que sirve cada variable y su nombre. A ver si podemos hacerle un "manual" y tenemos todos un final feliz.
    Yo estoy con un ea, de lo mas sencillo, cruce de EMA, con Sl, TP y TS, conjuntamente con un horario de trabajo en todas las divisas. Voy lento por que es a base de "prueba/error/comparativas", pero estoy camino de conseguir un 10% diario con un DD 3-4%. Lo que mas me gusta de esta estrategia tan sencilla, es que ningún broker te la puede sabotear.
    Un saludo!
    Foro de Forex Trading United

     

  6. #5
    Avatar de yuka666
    Erectus


    Reputación:
    Poder de reputación: 4

    Mensajes: 71
    Créditos: 150

    Re: Cyberia Trader Scalper todos los pares

    Hola a todos

    Por todo lo que he podido leer en diferentes foros vale la pena que entre todos podamos analizar en profundidad este EA, he encontrado una configuración que dicen que funciona bien, yo aún no la he probado pero mañana pienso hacerlo

    #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 EnableFractals = false;
    extern bool EnableCCI = false;
    extern bool EnableCyberiaLogic = true;
    extern bool EnableLogicTrading = true;
    extern bool EnableADX = false;
    extern bool EnablePivot = false; // Use Pivot_day as filter
    extern bool BlockPipsator = true;
    extern bool EnableMoneyTrain = false;
    extern bool EnableReverseDetector = true;
    extern double ReverseIndex = 3.82;
    extern double MoneyTrainLevel = 4;
    extern int MACDLevel = 10;
    extern bool AutoLots = True;
    extern double MAXLots = 10; // Max lots size on AutoLots--added by project1972
    extern bool AutoDirection = True;
    extern double ValuesPeriodCount = 7;
    extern double ValuesPeriodCountMax = 7;
    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 = 2;
    extern double Risk = 0.7;
    extern double StopLossIndex = 2.5;
    extern bool AutoStopLossIndex = true;
    extern double StaticStopLoss = 15;
    extern double StopLevel;
    extern bool EnableTrailingStop = false; // Enable Dynamic Trailing Stop
    extern double TrailingStopFactor = 1.0;
    extern string TimeTradeHoursDisabled="00,01,04,06"; // Example "00,01,02,03,04,05" GMT
    extern int GMT=10; // For North Finance GMT = 3, Alpari GMT = 1, IBFX GMT = -1 etc.
    extern int MagicNumber=123000; // Magic Number -- change for every pair traded

    // ----
    int NoTradeHours1=25; // Time not trade
    int NoTradeHours2=25; // Time not trade
    int NoTradeHours3=25; // Time not trade
    int NoTradeHours4=25; // Time not trade
    int NoTradeHours5=25; // Time not trade
    int NoTradeHours6=25; // Time not trade

    bool SavedBlockSell;
    bool SavedBlockBuy;

    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
    //----

    // Dynamic Trailing stop (TS) global variables
    double PrevBuyStop,BuyStop;
    double PrevSellStop,SellStop;

    // 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-OS";
    double version = 1.85;

    //+------------------------------------------------------------------+
    //| 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", 0, 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 (Lots>MAXLots){ Lots=MAXLots; }
    if(ShowLots == True)
    Print ("Lots:", Lots);
    }
    return (0);
    }

    //+------------------------------------------------------------------+
    //| We initialize the adviser |
    //+------------------------------------------------------------------+

    int init()
    {

    SavedBlockSell = BlockSell;
    SavedBlockBuy = BlockBuy;

    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(), 0, ValuePeriod * shift) -
    iOpen( Symbol(), 0, ValuePeriod * shift);
    PrevDecisionValue = iClose( Symbol(), 0, ValuePeriod * (shift+1)) -
    iOpen( Symbol(), 0, 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 ++;
    }
    // We calculate the average probabilities of the events
    // Probabilities of the purchase
    BuyPossibilityMid *= BuyPossibilityCount;
    BuyPossibilityCount ++;
    BuyPossibilityMid += BuyPossibility;
    if(BuyPossibilityCount != 0 )
    BuyPossibilityMid /= BuyPossibilityCount;
    else
    BuyPossibilityMid = 0;
    // Â??î??íî??? ??îä???
    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;
    // ??÷???âî äë? ó????í?? ???ó?ö?é
    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*UndefinedPossibilityQual ity:", UndefinedPossibilityMid*UndefinedPossibilityQualit y);
    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(EnableReverseDetector == true)
    ReverseDetector();
    if (EnableFractals == true)
    AskFractals();
    if (EnableCCI == true)
    AskCCI();
    if (EnableADX ==true)
    AskADX();
    if (EnablePivot ==true)
    AskPivot();
    return (0);
    }

    int AskADX ()
    {

    if ( iADX(NULL,0,14,PRICE_HIGH,MODE_PLUSDI,0)>iADX(NULL ,0,14,PRICE_HIGH,MODE_MINUSDI,0) )
    {
    DisableSell = true;
    }

    if ( iADX(NULL,0,14,PRICE_HIGH,MODE_PLUSDI,0) Pivot )
    {
    DisableSell = true;
    }

    if ( Price < Pivot )
    {
    DisableBuy= true;
    }

    return (0);
    }

    int AskCCI ()
    {
    if (iCCI( NULL, 0, 13, PRICE_TYPICAL, 0) > 50)
    DisableSell = true;

    if (iCCI( NULL, 0, 13, PRICE_TYPICAL, 0) < -50)
    DisableBuy = true;

    return (0);
    }

    //+------------------------------------------------------------------+
    //| Fractal Noise Filtering |
    //+------------------------------------------------------------------+

    int AskFractals ()
    {
    int i = 0;

    double F = 0;
    while (iFractals( NULL, 0, MODE_UPPER, i ) == 0 && iFractals( NULL, 0, MODE_LOWER, i ) == 0)
    {
    i ++;
    }

    if (iFractals( NULL, 0, MODE_UPPER, i ) != 0 )
    {
    BlockBuy = true;
    BlockSell = false;
    }

    if (iFractals( NULL, 0, MODE_LOWER, i ) != 0 )
    {
    BlockSell = true;
    BlockBuy = false;
    }

    return (0);
    }

    //+---------------------------------------------------------------------------------+
    //| If probabilities exceed the thresholds of the inversion of the solution |
    //+---------------------------------------------------------------------------------+

    int ReverseDetector ()
    {
    if((BuyPossibility > BuyPossibilityMid * ReverseIndex && BuyPossibility != 0 &&
    BuyPossibilityMid != 0) ||(SellPossibility > SellPossibilityMid * ReverseIndex &&
    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 flat
    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 exit 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(), 0, ValuePeriod, 0 , MODE_EMA, PRICE_CLOSE, 0) >
    iMA(Symbol(), 0, ValuePeriod, 0 , MODE_EMA, PRICE_CLOSE, 1))
    {
    DisableSell = true;
    DisableSellPipsator = true;
    }
    if(iMA(Symbol(), 0, ValuePeriod, 0 , MODE_EMA, PRICE_CLOSE, 0) <
    iMA(Symbol(), 0, 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;
    // ?ëî???ó?? î??á??
    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(), 0, 0) - iLow ( Symbol(), 0, 0));
    if(Decision == DECISION_SELL)
    {
    // We jump into the locomotive in the direction of the motion of chaos of the market
    if((iClose( Symbol(), 0, 0) - iClose( Symbol(), 0, 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(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, "NeuroCluster-testing-AI-HB1", MagicNumber, 0, Blue);
    if(ticket > 0)
    {
    if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES ))
    {
    Print("Long order is opened: ",OrderOpenPrice());
    PrevBuyStop = OrderStopLoss();
    }
    }
    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(), 0, ValuePeriod) - iClose( Symbol(), 0, 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, "NeuroCluster-testing-AI-HS1", MagicNumber, 0, Green);
    if(ticket > 0)
    {
    if(OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
    {
    Print("Short order is opened: ", OrderOpenPrice());
    PrevSellStop = OrderStopLoss();
    }
    }
    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(), 0, 0) - iLow(Symbol(), 0, 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);
    }
    if ( StaticStopLoss != 0 )
    {
    StopLoss = Ask + StaticStopLoss * Point;
    }
    StopLevel = StopLoss;
    Print ("StopLevel:", StopLevel);
    // Blocking stoploss
    if(BlockStopLoss == true)
    StopLoss = 0;
    ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, SlipPage, StopLoss, TakeProfit, "NeuroCluster-testing-AI-LS1", MagicNumber, 0, Green);
    if(ticket > 0)
    {
    if(OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
    {
    Print("Short order is opened: ",OrderOpenPrice());
    PrevSellStop = OrderStopLoss();
    }
    }
    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);
    }
    if ( StaticStopLoss != 0 )
    {
    StopLoss = Bid - StaticStopLoss * Point;
    }
    StopLevel = StopLoss;
    Print("StopLevel:", StopLevel);
    // Blocking stoploss
    if(BlockStopLoss == true)
    StopLoss = 0;
    ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, SlipPage, StopLoss, TakeProfit, "NeuroCluster-testing-AI-LB1", MagicNumber, 0, Blue);
    if(ticket > 0)
    {
    if(OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
    {
    Print("Long order is opened: ",OrderOpenPrice());
    PrevBuyStop = OrderStopLoss();
    }
    }
    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() && OrderMagicNumber() == MagicNumber)
    {
    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(), 0, i + 1) -
    iLow( Symbol(), 0, 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(), 0, 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);
    }

    if ( StaticStopLoss != 0 )
    {
    StopLoss = Ask + StaticStopLoss * Point;
    }

    StopLevel = StopLoss;
    Print("StopLevel:", StopLevel);
    // Blocking Stoploss
    if(BlockStopLoss == true)
    StopLoss = 0;
    ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, SlipPage, StopLoss, TakeProfit, "NeuroCluster-testing-AI-PS1", MagicNumber, 0, Green);
    if(ticket > 0)
    {
    if(OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
    {
    Print("Short order is opened: ",OrderOpenPrice());
    PrevSellStop = OrderStopLoss();
    }
    }
    else
    {
    Print("Error on the Short Entry: ",GetLastError());
    PrintErrorValues();
    }
    return (0);
    }
    // Pipsator of minute interval on the purchase
    if((iClose(Symbol(), 0, 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);
    }
    if ( StaticStopLoss != 0 )
    {
    StopLoss = Bid - StaticStopLoss * Point;
    }
    StopLevel = StopLoss;
    Print("StopLevel:", StopLevel);
    // Blocking Stoploss
    if(BlockStopLoss == true)
    StopLoss = 0;
    ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, SlipPage, StopLoss, TakeProfit, "NeuroCluster-testing-AI-PB1", MagicNumber, 0, Blue);
    if(ticket > 0)
    {
    if(OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
    {
    Print("Long order is opened: ",OrderOpenPrice());
    PrevBuyStop = OrderStopLoss();
    }
    }
    else
    {
    Print("Error on the Long Entry: ",GetLastError());
    PrintErrorValues();
    }
    return (0);
    }
    } // End of the pipsator cycle
    }
    }
    return (0);
    }

    //+------------------------------------------------------------------+
    //| Dynamic Trailing Stop |
    //+------------------------------------------------------------------+

    int DynamicTrailStop()
    {
    // Check to see if "EnableTrailingStop" is enabled..if not no need to execute
    // Only Modify the "StopLevel" here, since the exits are executed on the next function ExitMarket()
    // please make sure that the distance is >= 5 pips from the market, otherwise the stop order modification will be rejected.
    // Thank you!

    double TrailingStop = TrailingStopFactor * iATR(Symbol(), 0 , 14 , 1);
    for(int cnt = 0; cnt < OrdersTotal(); cnt++)
    {
    OrderSelect(cnt, SELECT_BY_POS);
    if(OrderMagicNumber() == MagicNumber && TrailingStop > 0)
    {
    if(OrderType() == OP_BUY)
    {
    BuyStop = Bid - TrailingStop;
    if(BuyStop < PrevBuyStop) BuyStop = PrevBuyStop;
    if(BuyStop > 0 && (Bid - BuyStop) >= 5 * Point && BuyStop > OrderStopLoss())
    OrderModify(OrderTicket(), OrderOpenPrice(), BuyStop, OrderTakeProfit(), 0);
    }
    else if(OrderType() == OP_SELL)
    {
    SellStop = Ask + TrailingStop;
    if(SellStop > PrevSellStop) SellStop = PrevSellStop;
    if(SellStop > 0 && (SellStop - Ask) >= 5 * Point && SellStop < OrderStopLoss())
    OrderModify(OrderTicket(), OrderOpenPrice(), SellStop, OrderTakeProfit(), 0);
    }
    }
    }
    PrevBuyStop = BuyStop;
    PrevSellStop = SellStop;
    }

    //+------------------------------------------------------------------+
    //| Exit from the market |
    //+------------------------------------------------------------------+

    int ExitMarket()
    {
    //FindSymbolOrder();
    // -------------------- Working the open orders -------------------

    if(FoundOpenedOrder == True) // If there is the open order on this currency
    {
    if(EnableTrailingStop==true)
    DynamicTrailStop(); // Calculate and modify the Dynamic Trailing Stop

    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); // We close the order
    return(0);
    }

    //long ts
    if(EnableTrailingStop==true)
    {
    DynamicTrailStop();
    if(BuyStop>0)
    if((Bid-BuyStop)>=5*Point)
    if(BuyStop>OrderStopLoss())
    {
    OrderModify(OrderTicket(),OrderOpenPrice(),BuyStop ,OrderTakeProfit(),0);
    }
    }

    if(DisableExitBuy == true)
    return (0);

    // We do not leave from the market, if we have chaos, which works on the profit
    if((iClose( Symbol(), 0, 0) - iClose( Symbol(), 0, 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);
    }

    // Closing pipsator
    if((OrderOpenPrice() < Bid) && BuySucPossibilityMid == 0 && SellSucPossibilityMid == 0)
    {
    OrderClose(OrderTicket(), OrderLots(), Bid , SlipPage, Violet); // Close the order
    return(0);
    }

    }
    if(OrderType() == OP_SELL) // If the obtained order to the selling 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);

    // We do not leave from the market, if we have chaos, which works on the profit
    if((iClose( Symbol(), 0, 1) - iClose( Symbol(), 0, 0)) >= BuySucPossibilityMid * 4 && BuySucPossibilityMid > 0)
    return (0);

    // Closing order on the fact of the 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 order 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);
    }

    // Closing pipsator
    if((OrderOpenPrice() > Ask) && BuySucPossibilityMid == 0 && SellSucPossibilityMid == 0)
    {
    OrderClose(OrderTicket(), OrderLots(), Ask, SlipPage, Violet); // Ç????â??? î?ä??
    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 && BlockPipsator == 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()
    {

    GetMarketInfo();
    CyberiaLots();
    CalculateSpread();
    FindSuitablePeriod();
    CyberiaDecision();
    VerbiageAndTimeCheck();
    Trade();
    SaveStat();

    return(0);
    }

    int VerbiageAndTimeCheck() {
    string comment_line="", comment_time="", comment_ver="";
    string sp = "------------------------------\n";
    comment_ver=StringConcatenate(SystemName," v. ",version,"\n");

    if (StringLen(TimeTradeHoursDisabled) > 1) {
    NoTradeHours1 = StrToInteger(StringSubstr(TimeTradeHoursDisabled,0 ,2));
    }
    if (StringLen(TimeTradeHoursDisabled) > 4) {
    NoTradeHours2 = StrToInteger(StringSubstr(TimeTradeHoursDisabled,3 ,2));
    }
    if (StringLen(TimeTradeHoursDisabled) > 7) {
    NoTradeHours3 = StrToInteger(StringSubstr(TimeTradeHoursDisabled,6 ,2));
    }
    if (StringLen(TimeTradeHoursDisabled) > 10) {
    NoTradeHours4 = StrToInteger(StringSubstr(TimeTradeHoursDisabled,9 ,2));
    }
    if (StringLen(TimeTradeHoursDisabled) > 13) {
    NoTradeHours5 = StrToInteger(StringSubstr(TimeTradeHoursDisabled,1 2,2));
    }
    if (StringLen(TimeTradeHoursDisabled) > 16) {
    NoTradeHours6 = StrToInteger(StringSubstr(TimeTradeHoursDisabled,1 5,2));
    }

    int h=TimeHour(CurTime());
    int hadj=TimeHour(CurTime())-GMT;

    if (((hadj) == NoTradeHours1) || ((hadj) == NoTradeHours2) || ((hadj) == NoTradeHours3) || ((hadj) == NoTradeHours4) ||
    ((hadj) == NoTradeHours5) || ((hadj) == NoTradeHours6)) {

    BlockSell = true;
    BlockBuy = true;

    comment_time=StringConcatenate("Bad Trading Hour: ", hadj, " GMT");
    } else {

    BlockSell = false;
    BlockBuy = false;
    comment_time=StringConcatenate("Good Trading Hour: ", hadj, " GMT");

    }
    comment_line = comment_ver + sp + comment_time;
    if (IsTesting()==false)
    Comment(comment_line);

    }
    Foro de Forex Trading United

    El peor enemigo del inversor no es el mercado,
    sino ellos mismos.

    yuka666

  7. #6

    antecessor


    Reputación:
    Poder de reputación: 6

    Mensajes: 490
    Créditos: 156

    Re: Cyberia Trader Scalper todos los pares

    Ok. Estoy probando de pasarla al MetaEditor, una vez guardado y pasado a MT4, no se me carga el expert. Ni con este, ni con ninguno que haya usado el MetaEditor. Algo estoy haciendo mal.
    Foro de Forex Trading United

     

  8. #7
    Avatar de yuka666
    Erectus


    Reputación:
    Poder de reputación: 4

    Mensajes: 71
    Créditos: 150

    Re: Cyberia Trader Scalper todos los pares

    Cita Iniciado por TradexFol Ver mensaje
    Ok. Estoy probando de pasarla al MetaEditor, una vez guardado y pasado a MT4, no se me carga el expert. Ni con este, ni con ninguno que haya usado el MetaEditor. Algo estoy haciendo mal.
    Yo lo que he hecho es modificar sobre el inicial ya que son valores lo único que cambia, le doy a compilar y listo. Y si funciona. Lo que tenemos que trabajar sobre él.
    Foro de Forex Trading United

    El peor enemigo del inversor no es el mercado,
    sino ellos mismos.

    yuka666

  9. #8

    antecessor


    Reputación:
    Poder de reputación: 6

    Mensajes: 490
    Créditos: 156

    Re: Cyberia Trader Scalper todos los pares

    Pues me parece que me salto el punto de "compilar"? A estas alturas....
    En fin, lo puedes subir?
    Foro de Forex Trading United

     

  10. #9
    Avatar de Airbrake
    Erectus


    Reputación:
    Poder de reputación: 6

    Mensajes: 137
    Créditos: 580

    Re: Cyberia Trader Scalper todos los pares


    Publi
    Cita Iniciado por yuka666 Ver mensaje
    Yo lo que he hecho es modificar sobre el inicial ya que son valores lo único que cambia, le doy a compilar y listo. Y si funciona.
    Disculpa yuka666 pero si me das un poco más de detalles acerca de lo que has hecho para que funcione te lo agradecería. A mí me pasa lo mismo que a TradexFol, no hay manera de hacerlo funcionar y en el compilador aparecen varios errores que no sé muy bien manejarme con ellos debido a mis escasos conocimientos de programación.

    Gracias.
    Foro de Forex Trading United




Publi
Publi


Aviso Legal
Ley Orgánica 15/1999, de 13 de diciembre, de Protección de Datos de Carácter Personal