Perguntas de um "boneco" - página 86

 

Renat, a questão era teórica e não prática.

Para não se perderem no nevoeiro, remeto-vos para um exemplo da ajuda do iFractals. É verdade que existe aí um indicador, mas vamos simplificar a tarefa para um único cálculo da disposição gráfica através de um guião.

Suponha-se que eu pretendia descobrir os tempos de todas as barras fractais do topo sobre toda a história (ou na sua parte substancial em algum período de tempo médio onde haverá muitos fractais). Se entendi correctamente, que é melhor perturbar repetidamenteCopyTime in loop na FrUpBuffer[shift]!=EMPTY_VALUE a uma profundidade de 1 elemento:

handle=iFractals(_Symbol,PERIOD_H4);
// вызов FillArraysFromBuffers(...)
// ...
// прочёс буфера
for(int shift=0; shift<BarsCalculated(handle); shift++)
{
   if(FrUpBuffer[shift]!=EMPTY_VALUE)
   {
     CopyTime(_Symbol,PERIOD_H4, shift, 1, Arr);
     Print(Arr[0]);
   }
}

bool FillArraysFromBuffers(double &up_arrows[],
                           int ind_handle,
                           int amount
                          )
  {
   if(CopyBuffer(ind_handle,0,0,amount,up_arrows)<0) return(false);

   return(true);
  }

e obter um resultado mais rápido do que comer a história de uma só vez com o CopyTime pela profundidade do FrUpBuffer:

handle=iFractals(_Symbol,PERIOD_H4);
// вызов FillArraysFromBuffers(...)
// ...
// прочёс буфера
for(int shift=0; shift<BarsCalculated(handle); shift++)
{
   if(FrUpBuffer[shift]!=EMPTY_VALUE)
     Print(TimeUpBuffer[shift]);
}

bool FillArraysFromBuffers(double &up_arrows[],
                           int ind_handle,
                           int amount
                          )
  {
   if(CopyBuffer(ind_handle,0,0,amount,up_arrows)<0) return(false);
   else CopyTime(_Symbol,PERIOD_H4,0,amount,TimeUpBuffer);

   return(true);
  }
e depois no mesmo laço no mesmo se é só imprimir os valores de tempo da barra fractal?

Ambas as tarefas são idênticas, apenas as implementações são ligeiramente diferentes.

Intuitivamente, compreendo que é mais longo e mais caro copiar uma enorme sequência de tempos de barra (tanto fractal como vazia) para uma matriz; por outro lado, é duvidoso puxar repetidamente o CopyTime para cima até uma profundidade de 1 elemento.

Se a primeira variante é mais rápida, é um ganho absoluto ou tudo depende do número total de fractais encontrados (por exemplo, há muito mais deles em pequenos TF)?

 

Aquihttps://www.mql5.com/ru/forum/3775/page59#comment_94865 fiz uma pergunta sobre a colocação de declaração, ligação, inicialização e outras acções em múltiplos buffers do mesmo tipo num loop, a fim de reduzir o código e melhorar a legibilidade e a capacidade de gestão. Recebi uma resposta com um exemplo (classe, estrutura) e compreendi-a.

Agora, de acordo com o mesmo princípio, tentei acalmar múltiplas atribuições do tipo #propriedade:

#property indicator_label1  "FractalUp1"
#property indicator_type1   DRAW_ARROW
#property indicator_color1  clrGreen

#property indicator_label2  "FractalDown1"
#property indicator_type2   DRAW_ARROW
#property indicator_color2  clrGreen
// ---
#property indicator_label3  "FractalUp2"
#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrBlue

#property indicator_label4  "FractalDown2"
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrBlue
[...]

e encontrou pelo menos dois problemas:

Porque a nível global é proibido, ou seja, a sua utilização mais precoce não é anterior à do OnInit(), mas sabe-se que a propriedade é declarada a nível global antes de todas as outras funções;

2. ao tentar atribuir propriedades a indicadores no laço no OnInit():

// понимаю, что сочинил бред
for (int i=0; i<NUMBER; i++)
{
  #property Property_Array[i].indicator_label (string)("Fractal"+i)
  #property Property_Array[i].indicator_type  DRAW_ARROW
  #property Property_Array[i].indicator_color clrArr[i]
}
Compilador jura em '#' (como esperado): '#propriedade' - ficha inesperada.
Poderia dizer-me se e como a ideia é viável em princípio?
 

Pode dizer-me como declarar uma matriz bidimensional de arrays?

Algo parecido com isto:

double Buffers[6][3]={ [],[],[] },{ [],[],[] },{ [],[],[] },{ [],[],[] },{ [],[],[] },{ [],[],[] };
 
tol64:

Pode dizer-me se é possível declarar uma matriz bidimensional de matrizes?

Um conjunto de estruturas com campos como matrizes pode ser declarado, o compilador salta mesmo matrizes dinâmicas na estrutura:

struct arr{double arr_str[];};
arr buffers[6][3];
Документация по MQL5: Основы языка / Типы данных / Объект динамического массива
Документация по MQL5: Основы языка / Типы данных / Объект динамического массива
  • www.mql5.com
Основы языка / Типы данных / Объект динамического массива - Документация по MQL5
 
tol64:

Pode dizer-me como declarar uma matriz bidimensional de arrays?

Algo parecido com isto:

#define DIM1_NUMBER 6
#define DIM2_NUMBER 3

struct TBuffer
{
  string Buffer[3]; // для нагляднсти поменяем double на string
};

TBuffer Buffer_Array[DIM1_NUMBER];

string prefixArr[6]={"a","b","c","d","e","f"};

int OnInit()
  {
   for (int j=0; j<DIM1_NUMBER; j++)
   {
      for (int i=0; i<DIM2_NUMBER; i++)
      {
        string t;
   
        StringConcatenate(t,prefixArr[j],i);
        Buffer_Array[j].Buffer[i]=t;
      }
   }

   Print(Buffer_Array[0].Buffer[0],", ",
         Buffer_Array[0].Buffer[1],", ",
         Buffer_Array[0].Buffer[2],"; ",

         Buffer_Array[1].Buffer[0],", ",
         Buffer_Array[1].Buffer[1],", ",
         Buffer_Array[1].Buffer[2],"; ",

         Buffer_Array[2].Buffer[0],", ",
         Buffer_Array[2].Buffer[1],", ",
         Buffer_Array[2].Buffer[2],"; ",

         Buffer_Array[3].Buffer[0],", ",
         Buffer_Array[3].Buffer[1],", ",
         Buffer_Array[3].Buffer[2],"; ",

         Buffer_Array[4].Buffer[0],", ",
         Buffer_Array[4].Buffer[1],", ",
         Buffer_Array[4].Buffer[2],"; ",

         Buffer_Array[5].Buffer[0],", ",
         Buffer_Array[5].Buffer[1],", ",
         Buffer_Array[5].Buffer[2]
   );

   return(0);
  }
[Fixo].
 

IgorM, x100intraday

Obrigado pelas opções. Acho que isto deve fazer o truque, vou tentar.

 
tol64:

IgorM, x100intraday

Obrigado pelas opções. Penso que isto deve funcionar, vou tentar.

A propósito, o nome "Buffer" pode ser alterado para "_" ou alguns outros enigmas, então a chamada será completamente clara:

Buffer_Array[0]._[0]

Buffer_Array[0].¦[0]

 
Urain:

A propósito, o nome "Tampão" pode ser alterado para "_" ou qualquer outra coisa, para que a chamada seja completamente clara:

ObrigadoUrain. Também uma adição interessante. É mais familiar)).
 

Mas como se faz tudo isto com #propriedade? - Pergunto-me...

Não faz ideia?

 
x100intraday:

Mas como se faz tudo isto com #propriedade? - Pergunto-me...

Não faz ideia?

decifrar