Discussão do artigo "Criação de Consultores Multiespecializados com base em Modelos de Comércio" - página 3

Novo comentário
 
Serj_Che:

Acho que o artigo deveria ser renomeado - por que simplificar quando você pode complicar?

Boa observação.

Interessante:

Pelo menos eu entendi (ou acho que entendi) a essência do que o autor queria transmitir aos leitores.

É disso que estou falando. Todo mundo entendeu a essência do que está escrito. Quem, dentre os que leram, tomará os códigos anexados como uma implementação pronta de algum estágio de desenvolvimento? Praticamente ninguém, exceto o autor. O artigo acabou sendo introdutório, do qual você pode tirar apenas a ideia, não o código. E você não precisava escrever tantas letras para isso.

Se você se considera um carregador, então entre no corpo. Se decidir ensinar outras pessoas ou compartilhar sua própria experiência, então deve escrever pensando em cada palavra e na estrutura da informação que está apresentando. Se os pensamentos estiverem caminhando e você quiser abraçar a vastidão e escrever sobre tudo o que existe no mundo, então não há nada que o leve a escrever artigos do plano fundamental. E as palavras de que esta é a versão 1.0 beta não são adequadas. Isso prejudica a reputação de um programador competente.

Gostaria que a administração do fórum estivesse mais atenta aos materiais publicados e realizasse um controle mais rigoroso dos trabalhos do autor (não apenas artigos, mas também códigos). E, apenas para preencher o número de publicações, não se deve fazer tudo de uma vez. Para que não aconteça como o Codebase em MQL4. Trabalhos realmente valiosos sem análogos são perdidos atrás de centenas de versões beta 1.0.

 

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

1. Não me diga como escrever ou o que escrever.

2. Não diga à MetaQuotes Software Corporation qual política de marketing deve seguir e como avaliar e selecionar autores para seu produto.

Considere esses pontos não como um desejo, mas como um aviso. Se você continuar a espalhar negatividade no tópico do fórum dedicado ao meu artigo e também disser à MetaQuotes o que fazer e como fazer, isso será considerado por mim como uma tentativa de denegrir o trabalho que fiz e questionar o profissionalismo da equipe da MetaQuotes. Nesse caso, apresentarei uma reclamação correspondente aos moderadores desta seção, e tenho sérios motivos para acreditar que o conflito entre mim e você será resolvido a meu favor.

Não vamos levar o assunto para o esclarecimento oficial das relações e vamos apenas chegar a um acordo amigável: você vai parar de escrever no tópico dedicado ao meu artigo informações que não se relacionam de forma alguma com o tópico em consideração aqui e vai parar de denegrir o trabalho feito por mim. Seria melhor se você parasse de postar qualquer coisa aqui. Entendo seu ponto de vista, você o expressou nas páginas anteriores. Eu discordo dele e você discorda de minha opinião. Acho que nós dois somos pessoas inteligentes e vamos parar com essa polêmica inútil.

 
udmurt2:

Gostaria que a administração do fórum estivesse mais atenta aos materiais publicados e realizasse um controle mais rigoroso dos trabalhos dos autores (não apenas artigos, mas também códigos). E, apenas para preencher o número de publicações, não se deve fazer tudo em uma fileira. Para que não aconteça como o Codebase em MQL4. Trabalhos realmente valiosos sem análogos são perdidos atrás de centenas de versões beta 1.0.

+1

Acho que a seção "Artigos " deve ser útil para os consumidores!!! Nadelektsya, não os assuste e confunda!

E agora - "Chukcha é um escritor, Chukcha não é um leitor" .....

 

>>> Imagine só,seu único Expert Advisor negocia várias dezenas de estratégias de negociação, em todos os instrumentos disponíveis e em todos os períodos de tempo possíveis ao mesmo tempo! Além disso, esse Expert Advisor é perfeitamente testado no testador, e um ou vários sistemas de gerenciamento de dinheiro estão disponíveis para todas as estratégias incluídas nele.

É exatamente assim que minha negociação com o Expert Advisor no campeonato é organizada. Tudo, ao que me parece, é mais simples. O principal é projetar tudo corretamente e não misturar tudo em uma única pilha.

//+------------------------------------------------------------------+
//|Níveis de Vigor.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;

//+------------------------------------------------------------------+
//| Função de inicialização de especialista|
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   int myTick = 60;
   EventSetTimer(myTick);
   dispatcher.tickSeconds = myTick;

  //-- O objeto despachante trabalha com ordens, os objetos de estratégia 
// lidam apenas com sinais e não trabalham com o mercado

  //-- estratégias simples de negociação separadamente. herdeiros da classe CStrategy
 //--estratégias
   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);



  //--estratégias
   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);

  //--etc.


  //-- Estratégia adaptativa contendo em si uma 
//troca virtual da lista conectada (CStrategy heirs novamente), 
//também CStrategy heir e para dispetcher'a não há diferença.
   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); // colocar tudo na estratégia adaptativa
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
        //  и т.д.
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
        


  dispatcher.strategies.Add(sadapt4);


 // preencha-o com o que você quiser

  return(0);
  }
//+------------------------------------------------------------------+
//| Função de desinicialização de especialista|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   EventKillTimer();
   
  }
//+------------------------------------------------------------------+
//| Função de tique de especialista|
//+------------------------------------------------------------------+
void OnTimer()
  {
//---
   dispatcher.control();
  }
//+------------------------------------------------------------------+
 

O exemplo que você deu é, na verdade, muito semelhante ao meu. Há menos diferenças do que parece. Tudo também é implementado por meio de classes e cada estratégia de classe tem seus próprios parâmetros independentes. A maior diferença está no layout: no seu caso, todas as estratégias são tratadas pelo expedidor; no meu, elas são tratadas em uma lista do tipo CObject. Na verdade, minha abordagem não é muito mais complicada do que a sua, apenas falamos sobre as mesmas coisas, mas em linguagem diferente.

Inicialmente, eu pretendia que minha abordagem resolvesse qualquer combinação de três "multis": multitimeframe, multiestratégia, multiferramenta. Agora vejo que é muito mais do que isso. Na segunda parte, estou pensando em abordar o problema das decisões do especialista. O Expert Advisor decidirá como negociar, o que negociar e quando negociar. Tudo isso permite minha abordagem. Provavelmente, sua abordagem também, e isso é bom, porque várias soluções para a mesma coisa são desenvolvimento.

A propósito, você pode dar uma olhada na implementação do próprio despachante?

  
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);
};
Não publicarei a implementação. Tudo está claro aqui. As estratégias são todas descendentes do CObject. Mas elas são processadas pelo despachante. Precisamos ir do simples ao complexo. Uma interface simples de objetos, para um observador externo, deve ocultar todos os detalhes da implementação. Só quero dizer que não há nada de extraordinário em multis. Com OOP e polimorfismo, tudo é feito de forma simples.
 
Vigor:
Não publicarei a implementação. Tudo está claro aqui. As estratégias são todas descendentes do CObject. Mas elas são processadas pelo despachante. Precisamos ir do simples ao complexo. Uma interface simples de objetos, para um observador externo, deve ocultar todos os detalhes da implementação. Só quero dizer que não há nada de extraordinário em multis. Com OOP e polimorfismo, tudo é feito de forma simples.
+1. Concordo plenamente. E, em geral, quero dizer que minha abordagem é como duas gotas de água semelhantes à sua. As estratégias são todas descendentes da estratégia básica CModel, que, por sua vez, é uma descendente do CObject. Assim como você, tudo é inicializado dinamicamente e colocado em uma lista. Assim como você, implementei uma interface de objeto simples que oculta todos os detalhes da implementação. Outra coisa é que eu tive que descrever toda a implementação no artigo, e é por isso que muitas pessoas acharam que era complicado. Mas para usar objetos do meu tipo, você nem precisa saber como tudo funciona por dentro.
 

Vasily, muito obrigado pelo artigo! Eu o li em um turbilhão! Foi muito fácil, acho que estou preparado para esse tipo de material. Eu, como muitos operadores, refleti sobre algumas das questões abordadas no artigo. Resolvi algumas delas, outras não. E outras estavam apenas na forma de uma vaga ideia. E foi muito agradável e inesperado ver tudo em uma apresentação tão sistemática.

A escala de questões resolvidas e, além disso, de perspectivas é enorme. Nem todas as "mentes" têm maturidade suficiente para levantá-las, muito menos para resolvê-las. Esse é o motivo dos comentários no estilo da fábula de Krylov "A raposa e as uvas", pois "embora o olho veja o olho, o dente não conhece o dente". E o desejo de autoafirmação é indomável, por isso eles comentam e esperam que os outros pensem: "Ah, o musgo! Eu sei que ele é forte o suficiente para latir para o elefante!" :) Nem vale a pena prestar atenção nisso.

Continue criando, estamos ansiosos pela continuação!

P.S. Embora você ainda não possa trabalhar no MetaTrader 5 na vida real, você pode usar o artigo "Copying Trading from MetaTrader 5 to MetaTrader 4". É algo muito sensato e comprovado! Portanto, tudo é muito relevante e pode ser usado nas negociações de hoje!

 

......
Por que, sem medo de pecar,
o Cuco elogia o Galo?

 

é melhor ser merecidamente elogiado do que injustificadamente rotulado.

1234567
Novo comentário