Perguntas de Iniciantes MQL5 MT5 MetaTrader 5 - página 573

Novo comentário
 
Andrey Koldorkin:

Vou ver o que consigo descobrir. Obrigado. (risos)

De nada. Apenas guarda todas as altas num array e depois imprime todos os dados guardados no array num loop.

Este guião não faz necessariamente exactamente o que é preciso fazer. Mostra simplesmente como os dados são armazenados na matriz.

 
Artyom Trishkin:

De modo algum. Simplesmente guarda todos os altos numa matriz, e depois imprime todos os dados guardados na matriz num laço no livro de registo.

Este guião não faz necessariamente aquilo de que precisa. Mostra apenas o princípio de guardar dados numa matriz.

Era exactamente isso que eu procurava. Precisava dele para, de alguma forma, guardar os dados numa matriz para o período que eu escolher. Essa é a parte que compreendi de si.

Agora a minha pergunta é: COMO posso aceder e comparar os dados registados na matriz?

Aqui, ao que parece, itera, escreve a matriz passo a passo. Isto é bom. Mas agora precisamos de comparar os elementos uns com os outros.

É necessário declarar uma nova contagem de iteração e depois recuperar os dados e compará-los de alguma forma? Mas isto mais uma vez tem de escrever os resultados algures e ... tudo se repete no final.

Grosso modo, se o período de comparação for de 5-7 castiçais, então o 1º deve ser comparado com outros 6, depois o 2º e assim por diante.... E se dois ou mais deles tiverem o mesmo Alto, então, em primeiro lugar, deve calcular este Alto, e em segundo lugar, deve encontrar o castiçal com o mais baixo Baixo. Ou seja, a função de chamar castiçais de betão no final para ir buscar todos os seus parâmetros.

É possível fazer isto em geral?

 
Andrey Koldorkin:

era exactamente isso que eu procurava. O que eu precisava era de alguma forma guardar os dados numa matriz para o período que eu estava a seleccionar. Eu compreendi essa parte.

Agora a minha pergunta é: COMO posso aceder e comparar os dados registados na matriz?

Aqui, ao que parece, itera, escreve a matriz passo a passo. Isto é bom. Mas agora precisamos de comparar os elementos uns com os outros.

É necessário declarar uma nova contagem de iteração e depois recuperar os dados e compará-los de alguma forma? Mas isto mais uma vez tem de escrever os resultados algures e ... tudo se repete no final.

Grosso modo, se o período de comparação for de 5-7 castiçais, então o 1º deve ser comparado com outros 6, depois o 2º e assim por diante.... E se dois ou mais deles tiverem o mesmo Alto, então, em primeiro lugar, deve calcular este Alto, e em segundo lugar, deve encontrar o castiçal com o mais baixo Baixo. Ou seja, a função de chamar castiçais de betão no final para ir buscar todos os seus parâmetros.

Mas será possível fazê-lo?

Aqui estamos apenas a interrogar a matriz guardada e a exibir todos os dados guardados no registo:

for(int i=0; i<ArrayRange(mass_high,0); i++) {
   printf("Время: %s, High: %.5f",TimeToString((int)mass_high[i][1],TIME_DATE|TIME_MINUTES),mass_high[i][0]);
   }

Sejamos mais específicos sobre a tarefa:

Precisamos de encontrar ... o quê exactamente na matriz guardada?

 
Artyom Trishkin:

É aqui que a matriz gravada é interrogada, e todos os dados gravados são registados:

Sejamos específicos sobre a tarefa:

Precisamos de encontrar na matriz guardada ... o quê exactamente?

Preciso, para registar um conjunto de dados para todas as velas fechadas (ou seja, a actual não é contada) - Velas altas, baixas, abertas, fechadas (4 parâmetros) para o período especificado nas definições. - é.

A seguir, preciso de comparar os parâmetros. Suponhamos que o período de pesquisa é igual a 10 castiçais. Aqui precisamos de verificar todos os Altos durante o período de 10 castiçais. Se houver dois ou mais jogos, devemos regressar:

1. Bandeira - "Há um fósforo".

1. O Alto valor onde os castiçais têm o mesmo valor.

2. Números destes castiçais, para que possamos referir-nos a eles e descobrir os parâmetros Baixo, Fechado, Aberto para eles.

Em geral, compreendo muito disto como o fazer.

O que não é claro é como referir-se aos castiçais que formam o nível. Idealmente, ao recalcular, poderíamos memorizar o número de iterações (i) mas primeiro temos um recálculo segundo o qual o registo é escrito e não pode ser aplicado.

E nessa variante, como o registo de saída regista - isto também não é o que é necessário.

Compreendo que primeiro tenho de pegar num castiçal 1 e compará-lo com outros 9, se houver um fósforo, depois extrair os números destas velas e os seus parâmetros, ligar a caixa de verificação. Depois verificar a vela 2 com as outras e assim sucessivamente até ao meio da amostra, porque depois só se farão duplicações de comparações a partir do outro lado.

Se o número de castiçais fosse fixo, tê-lo-ia escrito assim - cerca de 5 ciclos de comparação. Mas essa é a questão - como tornar possível tal recálculo para qualquer tamanho de amostra.

 
Andrey Koldorkin:

Preciso de escrever um conjunto de dados para todas as velas fechadas (ou seja, a actual não é contada) - Velas altas, baixas, abertas, fechadas (4 parâmetros) para o período especificado nas definições. - é.

A seguir, preciso de comparar os parâmetros. Suponhamos que o período de pesquisa é igual a 10 castiçais. Aqui precisamos de verificar todos os Altos durante o período de 10 castiçais. Se houver dois ou mais jogos, devemos regressar:

1. Bandeira - "Há um fósforo".

1. O Alto valor onde os castiçais têm o mesmo valor.

2. Números destes castiçais, para que possamos referir-nos a eles e descobrir os parâmetros Baixo, Fechado, Aberto para eles.

Em geral, compreendo muito disto como o fazer.

O que não é claro é como referir-se aos castiçais que formam o nível. Idealmente, ao recalcular, poderíamos memorizar o número da iteração (i) mas primeiro há um recálculo segundo o qual o registo é escrito e não pode ser aplicado.

E nessa variante, como o registo de saída regista - isto também não é o que é necessário.

Compreendo que primeiro tenho de pegar num castiçal 1 e compará-lo com outros 9, se houver um fósforo, depois extrair os números destas velas e os seus parâmetros, ligar a caixa de verificação. Depois verificar a vela 2 com as outras e assim por diante até ao meio da amostra, pois então só se farão duplicações de comparações do outro lado.

Se o número de castiçais fosse fixo, tê-lo-ia escrito assim - cerca de 5 ciclos de comparação. Mas essa é a questão - como tornar possível um tal recálculo para qualquer tamanho de amostra.

E a propósito, é pouco provável que a coincidência exacta dos valores dos preços seja frequente. Precisamos de estabelecer algum delta, e consideramos uma coincidência se os preços não diferirem mais do que este valor.

Assim, se precisarmos de uma lista separada de castiçais correspondentes para cada castiçal da gama, eu tentaria utilizar uma série de estruturas. Vou pensar no assunto e avisar-vos-ei.
 
Andrey Koldorkin:

Preciso de escrever um conjunto de dados para todas as velas fechadas (ou seja, a actual não é contada) - Velas altas, baixas, abertas, fechadas (4 parâmetros) para o período especificado nas definições. - é.

A seguir, preciso de comparar os parâmetros. Suponha que o período de pesquisa é igual a 10 castiçais. Aqui precisamos de verificar todos os Altos durante o período de 10 castiçais. Se houver dois ou mais jogos, devemos regressar:

1. Bandeira - "Há um fósforo".

1. O Alto valor onde os castiçais têm o mesmo valor.

2. Números destes castiçais, para que possamos referir-nos a eles e descobrir os parâmetros Baixo, Fechado, Aberto para eles.

Em geral, compreendo muito disto como o fazer.

O que não é claro é como referir-se aos castiçais que formam o nível. Idealmente, ao recalcular, poderíamos memorizar o número da iteração (i) mas primeiro há um recálculo segundo o qual o registo é escrito e não pode ser aplicado.

E nessa variante, como o registo de saída regista - também aqui não é o que é necessário.

Compreendo que primeiro tenho de pegar num castiçal 1 e compará-lo com outros 9, se houver um fósforo, depois extrair os números destas velas e os seus parâmetros, ligar a caixa de verificação. Depois verificar a vela 2 com as outras e assim por diante até ao meio da amostra, pois então só se farão duplicações de comparações a partir do outro lado.

Se o número de castiçais fosse fixo, tê-lo-ia escrito assim - cerca de 5 ciclos de comparação. Mas essa é a questão - como permitir um tal recálculo para qualquer tamanho de amostra.

Em vez de a bandeira "coincidência" colocar o contador, no valor alto onde o contador é maior, há um nível

O elevado valor pode ser arredondado para cima, por exemplo 1,23456 a 1,2346

e 1.23462 arredondado para 1.2346

porque é improvável que, de 10 castiçais, 2 tenham um máximo de 1,23456

por isso dance a partir do nível

e o número de candelabros é fixo, escreve-se uma certa quantidade de dados na estrutura

ou seja, o número de castiçais escritos na estrutura é o mesmo número de iterações

 
Andrey Koldorkin:

Preciso de escrever um conjunto de dados para todas as velas fechadas (ou seja, a actual não é contada) - Velas altas, baixas, abertas, fechadas (4 parâmetros) para o período especificado nas definições. - é.

A seguir, preciso de comparar os parâmetros. Suponhamos que o período de pesquisa é igual a 10 castiçais. Aqui precisamos de verificar todos os Altos durante o período de 10 castiçais. Se houver dois ou mais jogos, devemos regressar:

1. Bandeira - "Há um fósforo".

1. O Alto valor onde os castiçais têm o mesmo valor.

2. Números destes castiçais, para que possamos referir-nos a eles e descobrir os parâmetros Baixo, Fechado, Aberto para eles.

Em geral, compreendo muito disto como o fazer.

O que não é claro é como referir-se aos castiçais que formam o nível. Idealmente, ao recalcular, poderíamos memorizar o número da iteração (i) mas primeiro há um recálculo segundo o qual o registo é escrito e não pode ser aplicado.

E nessa variante, como o registo de saída regista - isto também não é o que é necessário.

Compreendo que primeiro tenho de pegar num castiçal 1 e compará-lo com outros 9, se houver um fósforo, depois extrair os números destas velas e os seus parâmetros, ligar a caixa de verificação. Depois verificar a vela 2 com as outras e assim por diante até ao meio da amostra, pois então só se farão duplicações de comparações a partir do outro lado.

Se o número de castiçais fosse fixo, tê-lo-ia escrito assim - cerca de 5 ciclos de comparação. Mas eis a questão: como tornar possível um tal recálculo para qualquer tamanho de amostra.

É uma tarefa interessante, mas a sua compreensão de como resolver este problema não é correcta, porque até agora não tem muito conhecimento em programação.

Veja: tem um conjunto de citações. A sua tarefa é escolher, deste conjunto, apenas as barras que satisfaçam determinadas condições. Por exemplo, pretende obter uma colecção de bares, cujos altos coincidem uns com os outros. De facto, podem existir muitas condições para a selecção, que podem ser acrescentadas ao longo do tempo. Uma vez que tenha uma colecção de barras, pode facilmente analisar qualquer um dos seus outros parâmetros.

Assim, para a sua tarefa, precisa de escrever uma função que devolva um conjunto de barras que satisfaçam uma determinada condição (pseudo-código):

массив_баров = ПолучитьНужныеБары(Символ(), Таймфрейм(), Период(), УсловиеОтбора);
Isto é, não há realmente qualquer problema em recordar e iterar alguns dados e índices. Não são necessários os índices das barras em si, mas sim uma colecção específica que satisfaça uma determinada condição. Uma vez que o tem, resolve muitos problemas de uma só vez.
 
Artyom Trishkin:
Assim, se precisarmos de uma lista diferente de castiçais correspondentes para cada castiçal da gama, eu tentaria utilizar uma série de estruturas. Vou pensar no assunto e avisar-vos-ei.

Pensamento. Estou a escrever um guião de teste:

//+------------------------------------------------------------------+
//|                                                     TestCopy.mq4 |
//|              Copyright 2016, Artem A. Trishkin, Skype artmedia70 |
//|                       https://login.mql5.com/ru/users/artmedia70 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, Artem A. Trishkin, Skype artmedia70"
#property link      "https://login.mql5.com/ru/users/artmedia70"
#property version   "1.00"
#property strict
#property script_show_inputs
//--- input parameters
input int Search_Period=10;   // Количество копируемых свечей
int searchPeriod=(Search_Period<1)?1:Search_Period;
input int Delta=2;            // Количество пунктов допуска
int delta=(Delta<0)?0:Delta;
MqlRates array[];             // Массив структур для копирования Open, High, Low, Close, Time
  
struct DataCandle             // Структура для хранения всех совпадений
  {
   int number_matched;           // Количество совпадений
   MqlRates reference_candle;    // Данные эталонной свечи
   MqlRates matched_candles[];   // Массив свечей, совпадающих с эталонной по нужному критерию 
  };
  DataCandle dataCandle[];    // Массив структур данных свечей и их совпадений
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int copy_bars=(int)fmin(Search_Period,Bars(Symbol(),Period()));   // количество копируемых свечей
   int copied=CopyRates(Symbol(),PERIOD_CURRENT,1,copy_bars,array);  // копируем данные
   if(copied>0) {                                                    // если скопировали
      ArrayResize(dataCandle,copied);                                // задаём размер структуры равным числу скопированных данных
      ZeroMemory(dataCandle);                                        // Обнуляем данные в структуре
      //--- основной цикл по "эталонным" свечам в массиве array. Их параметры будем искать в доп. цикле
      for(int i=0; i<copy_bars-1; i++) {                             // цикл по скопированным данным от начала до "на один меньше размера массива"
         dataCandle[i].reference_candle.high=array[i].high;          // ищем этот high
         dataCandle[i].reference_candle.low=array[i].low;            // запомнили low для сравнения
         dataCandle[i].reference_candle.time=array[i].time;          // запомнили time для вывода в журнал
         //--- поиск совпадений с эталонной свечой, индексируемой индексом основного цикла i
         int size=0;                                                 // размер массива совпадающих свечей
         ArrayResize(dataCandle[i].matched_candles,size);            // Размер массива совпадений в ноль
         dataCandle[i].number_matched=size;                          // Инициализируем количество совпадений нулём
         //--- теперь ищем совпадения по high свечей в цикле j с high эталонной свечи с индексом i
         for(int j=i+1; j<copy_bars; j++) {                          // в цикле от i+1 до copy_bars
            //--- если совпадают high эталонной свечи (i) и свечи с индексом j (с допуском на величину delta*Point)
            if(NormalizeDouble(delta*Point()-fabs(array[i].high-array[j].high),Digits())>=0) {
               size++;                                               
               ArrayResize(dataCandle[i].matched_candles,size);            // увеличим размер массива совпадающих свечей
               dataCandle[i].number_matched=size;                          // запишем количество совпадений
               dataCandle[i].matched_candles[size-1].high=array[j].high;   // запишем в массив high совпадающей свечи
               dataCandle[i].matched_candles[size-1].low=array[j].low;     // запишем в массив low совпадающей свечи
               dataCandle[i].matched_candles[size-1].time=array[j].time;   // запишем в массив время совпадающей свечи
               //Print("Время свечи ",i," :",TimeToString(dataCandle[i].reference_candle.time=array[i].time),", high=",DoubleToString(dataCandle[i].reference_candle.high=array[i].high,Digits()),". Совпадение со свечой ",TimeToString(dataCandle[i].matched_candles[size-1].time=array[j].time),", её high ",DoubleToString(dataCandle[i].matched_candles[size-1].high=array[j].high,Digits()),". Совпадений: ",(string)dataCandle[i].number_matched);
               }
            }
         }
      }

   //--- Посмотрим чего понаписали в массивы
   for(int i=0; i<ArraySize(dataCandle)-1; i++) {
      string refs_txt="";
      string matched_txt="";
      refs_txt="Свеча "+IntegerToString(i,2,'0')+": время "+TimeToString(dataCandle[i].reference_candle.time)+", high: "+DoubleToString(dataCandle[i].reference_candle.high,Digits())+" имеет совпадений: "+(string)dataCandle[i].number_matched+" шт. ";
      if(dataCandle[i].number_matched>0) {
         for(int j=0; j<ArraySize(dataCandle[i].matched_candles); j++) {
            matched_txt="Совпадение "+IntegerToString(j+1)+": "+TimeToString(dataCandle[i].matched_candles[j].time)+", high: "+DoubleToString(dataCandle[i].matched_candles[j].high,Digits());
            }
         }
      Print(refs_txt,matched_txt);
      }
  }
//+------------------------------------------------------------------+

Tentei descrever todas as etapas.

Depois de preencher todos os fósforos no laço, temos uma matriz que contém todos os castiçais e os seus castiçais correspondentes. Depois disso, pode procurar por baixo. E pode organizá-lo de forma bem organizada. É mais conveniente para si.

 

Bem, aqui está outra forma de o fazer: são escritos fósforos para cada vela da gama. Na versão anterior, os fósforos foram escritos apenas para uma vela - ou seja, não foi escrito nenhum fósforo para aquele que correspondia a esta.

//+------------------------------------------------------------------+
//|                                                     TestCopy.mq4 |
//|              Copyright 2016, Artem A. Trishkin, Skype artmedia70 |
//|                       https://login.mql5.com/ru/users/artmedia70 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, Artem A. Trishkin, Skype artmedia70"
#property link      "https://login.mql5.com/ru/users/artmedia70"
#property version   "1.00"
#property strict
#property script_show_inputs
//--- input parameters
input int Search_Period=10;   // Количество копируемых свечей
int searchPeriod=(Search_Period<1)?1:Search_Period;
input int Delta=2;            // Количество пунктов допуска
int delta=(Delta<0)?0:Delta;
MqlRates array[];             // Массив структур для копирования Open, High, Low, Close, Time
  
struct DataCandle             // Структура для хранения всех совпадений
  {
   int number_matched;           // Количество совпадений
   MqlRates reference_candle;    // Данные эталонной свечи
   MqlRates matched_candles[];   // Массив свечей, совпадающих с эталонной по нужному критерию 
  };
  DataCandle dataCandle[];    // Массив структур данных свечей и их совпадений
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int copy_bars=(int)fmin(Search_Period,Bars(Symbol(),Period()));   // количество копируемых свечей
   int copied=CopyRates(Symbol(),PERIOD_CURRENT,1,copy_bars,array);  // копируем данные
   if(copied>0) {                                                    // если скопировали
      ArrayResize(dataCandle,copied);                                // задаём размер структуры равным числу скопированных данных
      ZeroMemory(dataCandle);                                        // Обнуляем данные в структуре
      //--- основной цикл по "эталонным" свечам в массиве array. Их параметры будем искать в доп. цикле
      for(int i=0; i<copy_bars; i++) {                               // цикл по скопированным данным от начала до конца
         dataCandle[i].reference_candle.high=array[i].high;          // ищем этот high
         dataCandle[i].reference_candle.low=array[i].low;            // запомнили low для сравнения
         dataCandle[i].reference_candle.time=array[i].time;          // запомнили time для вывода в журнал
         //--- поиск совпадений с эталонной свечой, индексируемой индексом основного цикла i
         int size=0;                                                 // размер массива совпадающих свечей
         ArrayResize(dataCandle[i].matched_candles,size);            // Размер массива совпадений в ноль
         dataCandle[i].number_matched=size;                          // Инициализируем количество совпадений нулём
         //--- теперь ищем совпадения по high свечей в цикле j с high эталонной свечи с индексом i
         for(int j=0; j<copy_bars; j++) {                            // в цикле от 0 до copy_bars
            if(j==i) continue;                                       // пропустим свечу "саму себя"
            //--- если совпадают high эталонной свечи (i) и свечи с индексом j (с допуском на величину Point)
            if(NormalizeDouble(delta*Point()-fabs(array[i].high-array[j].high),Digits())>=0) {
               size++;                                               
               ArrayResize(dataCandle[i].matched_candles,size);            // увеличим размер массива совпадающих свечей
               dataCandle[i].number_matched=size;                          // запишем количество совпадений
               dataCandle[i].matched_candles[size-1].high=array[j].high;   // запишем в массив high совпадающей свечи
               dataCandle[i].matched_candles[size-1].low=array[j].low;     // запишем в массив low совпадающей свечи
               dataCandle[i].matched_candles[size-1].time=array[j].time;   // запишем в массив время совпадающей свечи
               //Print("Время свечи ",i," :",TimeToString(dataCandle[i].reference_candle.time=array[i].time),", high=",DoubleToString(dataCandle[i].reference_candle.high=array[i].high,Digits()),". Совпадение со свечой ",TimeToString(dataCandle[i].matched_candles[size-1].time=array[j].time),", её high ",DoubleToString(dataCandle[i].matched_candles[size-1].high=array[j].high,Digits()),". Совпадений: ",(string)dataCandle[i].number_matched);
               }
            }
         }
      }

   //--- Посмотрим чего понаписали в массивы
   for(int i=0; i<ArraySize(dataCandle)-1; i++) {
      string refs_txt="";
      string matched_txt="";
      refs_txt="Свеча "+IntegerToString(i,2,'0')+": время "+TimeToString(dataCandle[i].reference_candle.time)+", high: "+DoubleToString(dataCandle[i].reference_candle.high,Digits())+" имеет совпадений: "+(string)dataCandle[i].number_matched+" шт. ";
      if(dataCandle[i].number_matched>0) {
         for(int j=0; j<ArraySize(dataCandle[i].matched_candles); j++) {
            matched_txt+=" Совпадение "+IntegerToString(j+1)+": "+TimeToString(dataCandle[i].matched_candles[j].time)+", high: "+DoubleToString(dataCandle[i].matched_candles[j].high,Digits());
            }
         }
      Print(refs_txt,matched_txt);
      }
  }
//+------------------------------------------------------------------+
 
A ideia de abrir encomendas num sinal de compra ou de aderência, como fazer para que haja apenas uma transacção de compra/venda e uma transacção de encomenda pendente, eu tenho uma aberta em cada tic da transacção. Ajudar a resolver o problema.
Arquivos anexados:
ritfv.png  46 kb
ohs.txt  5 kb
1...566567568569570571572573574575576577578579580...1503
Novo comentário