Preguntas de un "tonto" - página 86

[x572intraday]

Renat, la pregunta era más bien teórica que práctica.

Para no perderme en la niebla, te remitiré al ejemplo de la ayuda de iFractals. Es cierto que hay un indicador allí, pero simplifiquemos la tarea a un cálculo único del diseño gráfico mediante un script.

Supongamos que quiero averiguar los tiempos de todas las barras fractales superiores en toda la historia (o en su parte sustancial en algún marco temporal medio en el que habrá muchos fractales). ¿He entendido bien, que es mejor perturbar repetidamenteCopyTime en bucle en FrUpBuffer[shift]!=EMPTY_VALUE a una profundidad 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);
  }

y obtener un resultado más rápido que comer la historia de una vez con CopyTime por la profundidad de 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);
  }

y luego en el mismo bucle en los mismos if's sólo imprimir los valores de tiempo de la barra fractal?

Ambas tareas son idénticas, sólo que las implementaciones son ligeramente diferentes.

Intuitivamente entiendo que es más largo y costoso copiar una enorme cadena de tiempos de barra (tanto fractal como vacía) en un array; por otro lado, es dudoso tirar de CopyTime repetidamente hasta una profundidad de 1 elemento.

Si la primera variante es más rápida, ¿es una ganancia absoluta o todo depende del número total de fractales encontrados (por ejemplo, hay muchos más en TF pequeños)?

[x572intraday]

Aquíhttps://www.mql5.com/ru/forum/3775/page59#comment_94865 hice una pregunta acerca de poner la declaración, el enlace, la inicialización y otras acciones en múltiples buffers del mismo tipo en un bucle con el fin de reducir el código y mejorar la legibilidad y manejabilidad. Obtuve una respuesta con un ejemplo (clase, estructura) y lo entendí.

Ahora, de acuerdo con el mismo principio, traté de apisonar las asignaciones múltiples de tipo #propiedad:

#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
[...]

y se encontró con al menos dos problemas:

1. Se prohíbe el uso de #property en el nivel global, es decir, su uso más temprano no es anterior a OnInit(), pero se sabe que se declara en el nivel global antes que el resto de las funciones;

2. Al intentar asignar propiedades a los indicadores en el bucle de 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]
}

El compilador jura por '#' (como era de esperar): '#property' - token inesperado.
¿Podría decirme si la idea es, en principio, factible?

[Anatoli Kazharski]

¿Puedes decirme cómo declarar un array bidimensional de arrays?

Algo así:

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

[Igor Makanu]

tol64:

¿Pueden decirme si es posible declarar una matriz bidimensional de matrices?

Se puede declarar un conjunto de estructuras con campos como arrays, el compilador incluso omite los arrays dinámicos en la estructura:

struct arr{double arr_str[];};
arr buffers[6][3];

[x572intraday]

tol64:

¿Puedes decirme cómo declarar un array bidimensional de arrays?

Algo así:

#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);
  }

[Arreglado.]

[Anatoli Kazharski]

IgorM, x100intraday

Gracias por las opciones. Creo que esto debería servir, lo probaré.

[Mykola Demko]

tol64:

IgorM, x100intraday

Gracias por las opciones. Creo que esto debería funcionar, lo probaré.

Por cierto, el nombre "Buffer" puede ser cambiado por "_" o algún otro acertijo, entonces la llamada será completamente clara:

Buffer_Array[0]._[0]

Buffer_Array[0].¦[0]

[Anatoli Kazharski]

Urain:

Por cierto, el nombre "Buffer" se puede cambiar por "_" o cualquier otra cosa, para que la llamada sea completamente clara:

GraciasUrain. También es una adición interesante. Es más familiar).

[x572intraday]

Pero, ¿cómo se hace todo esto con la #propiedad? - Me pregunto...

¿Ni idea?

[Mykola Demko]

x100intraday:

Pero, ¿cómo se hace todo esto con la #propiedad? - Me pregunto...

¿Ni idea?

descifrar