Discussione sull’articolo "Creare Expert Advisor multipli sulla base dei modelli di trading" - pagina 3

Nuovo commento
 
Serj_Che:

Penso che l'articolo dovrebbe essere rinominato: perché semplificare quando si può complicare.

Buona osservazione.

Interessante:

Almeno ho capito (o credo di aver capito) l'essenza di ciò che l'autore voleva trasmettere ai lettori.

È di questo che sto parlando. Tutti hanno capito l'essenza di ciò che è scritto. Chi di coloro che leggono prenderà i codici allegati come una pronta implementazione di qualche fase di sviluppo? Praticamente nessuno, tranne l'autore. L'articolo è risultato essere un articolo introduttivo, da cui si può prendere solo l'idea, non il codice. E non c'era bisogno di fare tante lettere per questo.

Se vi definite un caricatore, allora entrate nel corpo. Se decidete di insegnare agli altri o di condividere la vostra esperienza, allora dovreste scrivere pensando a ogni parola e alla struttura delle informazioni che state presentando. Se i pensieri camminano, e si vuole abbracciare la vastità e scrivere di tutto ciò che c'è nel mondo, allora non c'è nulla da prendere in considerazione per scrivere articoli fondamentali. E le parole che questa è la versione 1.0 beta non sono adatte. Come si rovina la reputazione di un coder competente.

Vorrei che la direzione del forum fosse più attenta ai materiali pubblicati e che effettuasse un controllo più severo dei lavori degli autori (non solo degli articoli, ma anche dei codici). E solo per riempire il numero di pubblicazioni non si dovrebbe prendere tutto di fila. In modo da non fare la fine di Codebase in MQL4. Lavori davvero preziosi senza analoghi si perdono dietro centinaia di versioni 1.0 beta.

 

Руководству форума желаю...

1. Non ditemi come scrivere o cosa scrivere.

2. Non dite a MetaQuotes Software Corporation quale politica di marketing seguire e come valutare e selezionare gli autori per il suo prodotto.

Considerate questi punti non come un augurio, ma come un avvertimento. Se continuerà a diffondere negatività nel thread del forum dedicato al mio articolo e a dire a MetaQuotes cosa fare e come farlo, sarà considerato da me come un tentativo di denigrare il lavoro che ho svolto e di mettere in dubbio la professionalità del team di MetaQuotes. In questo caso, presenterò un reclamo corrispondente ai moderatori di questa sezione, e ho seri motivi per credere che il conflitto tra me e voi si risolverà a mio favore.

Non portiamo la questione al chiarimento ufficiale dei rapporti e passiamo all'accordo amichevole: smetterai di scrivere nel thread dedicato al mio articolo informazioni che non hanno alcuna attinenza con l'argomento in esame e smetterai di denigrare il lavoro svolto da me. Sarebbe meglio se smettesse di postare qualsiasi cosa qui. Capisco il suo punto di vista, lo ha espresso nelle pagine precedenti. Io non sono d'accordo e lei non è d'accordo con la mia opinione. Penso che siamo entrambi persone intelligenti e smettiamo questa inutile polemica.

 
udmurt2:

Vorrei che la direzione del forum fosse più attenta ai materiali pubblicati e che effettuasse un controllo più severo delle opere degli autori (non solo articoli ma anche codici). E solo per riempire il numero di pubblicazioni non si dovrebbe prendere tutto in fila. In modo da non fare la fine di Codebase in MQL4. Lavori davvero preziosi senza analoghi si perdono dietro centinaia di versioni 1.0 beta.

+1

Penso che la sezione "Articoli " dovrebbe essere utile per i consumatori!!! Nadelektsya, non spaventarli e confonderli!

E ora - "Chukcha è uno scrittore, Chukcha non è un lettore" .....

 

>>> Immaginate cheil vostro singolo Expert Advisor operi su diverse decine di strategie di trading, su tutti gli strumenti disponibili e su tutti i timeframe possibili! Inoltre, questo Expert Advisor è perfettamente testato nel tester e sono disponibili uno o più sistemi di gestione del denaro per tutte le strategie in esso incluse.

Questo è esattamente il modo in cui è organizzato il mio trading di Expert Advisor al Campionato. Tutto, come mi sembra, è più semplice. L'importante è progettare tutto correttamente e non mischiare tutto in un unico mucchio.

//+------------------------------------------------------------------+
//|Livelli di vigore.mq5 |
//| Copyright 2010, MetaQuotes Software Corp. | |
//|http://www.mql5.com
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"

#include <Vigor\Strategy.mqh>

#include <Vigor\TradeSignal.mqh>
#include <Vigor\ADXMAStrategy.mqh>
#include <Vigor\ADXStrategy.mqh>
#include <Vigor\MAVSimpleStrategy.mqh>
#include <Vigor\Order.mqh>
#include <Vigor\Dispatcher.mqh>
#include <Vigor\AdaptiveStrategy.mqh>
CDispatcher dispatcher;

//+------------------------------------------------------------------+
//| Funzione di inizializzazione dell'esperto|
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   int myTick = 60;
   EventSetTimer(myTick);
   dispatcher.tickSeconds = myTick;

  //-- l'oggetto dispatcher lavora con gli ordini, gli oggetti strategia 
// si occupano solo dei segnali e non lavorano con il mercato

  //-- semplici strategie di trading separatamente. eredi della classe CStrategy
 //--strategie
   CMAVStrategy *s4 = new CMAVStrategy();
   s4.Symbol = "EURGBP";
   s4.onBars = true;
   s4.TimeFrame = PERIOD_M5;
   s4.HourStart = 7;
   s4.HourEnd = 18;
   s4.Risk = 0.1;
   s4.takeProfit = 2000;
   s4.stopLoss = 450;
   s4.trailingStop = 77;
   s4.lots = 0.1;
   s4.maxLots = 5;
  //-custom;
   s4.period1 = 2;
   s4.max = 0.0025;
   s4.sensity = 0.39;
   s4.unsensity = 0.53;
   s4.init();
   dispatcher.strategies.Add(s4);



  //--strategie
   CADXStrategy *s2 = new CADXStrategy();
   s2.Symbol = "GBPUSD";
   s2.onBars = true;
   s2.TimeFrame = PERIOD_M5;
   //s2.mHourStart = 0;
   //s2.mHourEnd = 24;
   s2.Risk = 0.13;
   s2.takeProfit = 2000;
   s2.stopLoss = 360;
   s2.trailingStop = 150;
   s2.lots = 0.1;
   s2.maxLots = 5;
  //-custom
   s2.period = 17;
   s2.level = 0.0042;
   s2.init();
   dispatcher.strategies.Add(s2);

  //-ecc.


  //-- strategia adattiva che contiene al suo interno un 
//scambio virtuale della lista connessa (ancora CStrategy heirs), 
//anche CStrategy heir e per dispetcher'a non c'è differenza.
   CAdaptiveStrategy *sadapt4 = new CAdaptiveStrategy();
   sadapt4.onBars = false;
   sadapt4.mRisk = 0.13;
   sadapt4.lots = 0.1;
   sadapt4.performance_variant = 2;
   sadapt4.maxLots = 5;
   sadapt4.init();
        
        // ***************************************** M30
        CADXStrategy *s_gbpjpy1 = new CADXStrategy();    s_gbpjpy1.Symbol = "GBPJPY";    s_gbpjpy1.onBars = true;    s_gbpjpy1.TimeFrame = PERIOD_M30;  s_gbpjpy1.takeProfit = 2000; s_gbpjpy1.trailingStop = 70; s_gbpjpy1.lots = 0.1; s_gbpjpy1.maxLots = 5; 
        s_gbpjpy1.stopLoss = 300;  s_gbpjpy1.init();
        sadapt4.strategies.Add(s_gbpjpy1); // inserire tutto nella strategia adattiva
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
        //  и т.д.
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
        


  dispatcher.strategies.Add(sadapt4);


 // riempire con quello che si vuole

  return(0);
  }
//+------------------------------------------------------------------+
//| Funzione di deinizializzazione dell'esperto|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   EventKillTimer();
   
  }
//+------------------------------------------------------------------+
//| Funzione tick dell'esperto|
//+------------------------------------------------------------------+
void OnTimer()
  {
//---
   dispatcher.control();
  }
//+------------------------------------------------------------------+
 

L'esempio che hai fatto è in realtà molto simile al mio. Ci sono meno differenze di quanto possa sembrare. Tutto è implementato tramite classi e ogni classe-strategia ha i suoi parametri indipendenti. La differenza più grande è nella loro disposizione: nel tuo caso tutte le strategie sono gestite dal dispatcher, nel mio sono gestite in una lista di tipo CObject. In realtà, il mio approccio non è molto più complicato del vostro, parliamo solo delle stesse cose, ma in un linguaggio diverso.

Inizialmente intendevo il mio approccio per risolvere qualsiasi combinazione di tre "multi": multitimeframe, multistrategy, multitool. Ora lo vedo come molto più di questo. Nella seconda parte, sto pensando di affrontare il problema delle decisioni dell'esperto. L'Expert Advisor deciderà come operare, cosa operare e quando operare. Tutto ciò consente il mio approccio. Probabilmente anche il tuo approccio, ed è un bene, perché diverse soluzioni della stessa cosa sono uno sviluppo.

A proposito, potete dare un'occhiata all'implementazione del dispatcher stesso?

  
class CDispatcher {
   public:
      CTrade trade;
      CList strategies; 
      CList newOrders; 
      CList currentOrders;
      CList* strategiesResults;
      int repeats;
      int tickSeconds;
   private:
      ulong Magic;            
   public:
      void CDispatcher() {
          strategiesResults = new CList();
          repeats = 5;
          tickSeconds = 1;
      }
      void ~CDispatcher() {
        delete(strategiesResults);
      }
      
      void control();

      bool controlLimits();
      void controlOrders();
      bool controlOpen();
      bool controlClose();
      bool controlModify();      
      ulong ticketOpen(string smb, ENUM_ORDER_TYPE type,double lot,int SL,int TP);
      double countLotByRisk(CSymbolInfo *symbinfo, CStrategy *s, int dist, double risk, double lot, double maxlot);
       double NormalPrice(CSymbolInfo *symbinfo, double d);
      double NormalLot(CSymbolInfo *symbinfo, double lot);
      double BasePrice(CSymbolInfo *symbinfo, int dir);
      double ReversePrice(CSymbolInfo *symbinfo, int dir);
      double ReversType(ENUM_ORDER_TYPE type);
      double NormalTP(CSymbolInfo *symbinfo, int dir,double op,double pr,int TP,double stop);
      double NormalSL(CSymbolInfo *symbinfo, int dir,double op,double pr,int SL,double stop);
      void   checkDeals(CStrategy *s);
       ENUM_ORDER_TYPE getTypeByDirection(int dir);
       int getDirectionByType(ENUM_ORDER_TYPE type);
};
Non pubblicherò l'implementazione. Qui è tutto chiaro. Le strategie sono tutte discendenti di CObject. Ma vengono elaborate dal dispatcher. Dobbiamo passare dal semplice al complesso. Una semplice interfaccia di oggetti, per un osservatore esterno, dovrebbe nascondere tutti i dettagli dell'implementazione. Voglio solo dire che non c'è nulla di straordinario in multis. Avendo l'OOP e il polimorfismo, è tutto semplice.
 
Vigor:
Non pubblicherò l'implementazione. Qui è tutto chiaro. Le strategie sono tutte discendenti di CObject. Ma vengono elaborate dal dispatcher. Dobbiamo passare dal semplice al complesso. Una semplice interfaccia di oggetti, per un osservatore esterno, dovrebbe nascondere tutti i dettagli dell'implementazione. Voglio solo dire che non c'è nulla di straordinario in multis. Con l'OOP e il polimorfismo è tutto semplice.
+1. Sono completamente d'accordo. E in generale voglio dire che il mio approccio è come due gocce d'acqua simili al tuo. Le strategie sono tutte discendenti della strategia di base CModel, che a sua volta è un discendente di CObject. Proprio come voi, tutto è inizializzato dinamicamente e inserito in una lista. Come voi, ho implementato una semplice interfaccia di oggetto che nasconde tutti i dettagli dell'implementazione. Un'altra cosa è che ho dovuto descrivere l'intera implementazione nell'articolo, e per questo molti hanno pensato che fosse complicata. Ma per usare gli oggetti del mio tipo non c'è nemmeno bisogno di sapere come funziona all'interno.
 

Vasily, grazie mille per l'articolo! L'ho letto in un baleno! Mi è venuto molto facile, credo di essere maturo per questo tipo di materiale. Come molti trader, ho riflettuto su alcune delle questioni trattate nell'articolo. Alcuni li ho risolti, altri no. Altri ancora erano solo una vaga idea. È stato molto piacevole e inaspettato vedere tutto in una presentazione così sistematica.

La scala dei problemi risolti e, inoltre, delle prospettive è enorme. Non tutte le "menti" sono abbastanza mature per sollevarle e tanto meno per risolverle. Questo è il motivo dei commenti sullo stile della favola di Krylov "La volpe e l'uva", perché "anche se l'occhio vede l'occhio, il dente non conosce il dente". E il desiderio di autoaffermazione è indomabile, quindi commentano e sperano che gli altri pensino: "Ah, il muschio! So che è abbastanza forte da abbaiare all'elefante!". :) Non vale nemmeno la pena di farci caso.

Continua a creare, aspettiamo con ansia il seguito!

P.S. Anche se non potete ancora lavorare su MetaTrader 5 nella vita reale, potete utilizzare l'articolo "Copiare il trading da MetaTrader 5 a MetaTrader 4". Si tratta di una cosa molto sensata e comprovata! Quindi tutto è molto rilevante e può essere utilizzato nel trading di oggi!

 

......
Per quale motivo, senza timore di peccare,
il Cuculo loda il Gallo?

 

è meglio essere lodati meritatamente che etichettati ingiustificatamente.

1234567
Nuovo commento