Errores, fallos, preguntas - página 616

[Serj]

Pregunta para los desarrolladores:

Por qué en el probador no es posible obtener el campo de la estructura

MqlTradeResultprice;// ¿Precio en una operación, confirmado por el broker? Da 0.

Funciona bien en la demo.

[Victor Kirillin]

x100intraday:

¿Existe alguna relación entre la estructura de la lista de plazos y los indicadores de visibilidad de los objetos (porque incluso la longitud de las listas es diferente: 22 frente a 23)? En general, lo pregunto para asignar de forma eficiente y compacta la visibilidad de los objetos en los plazos de un ciclo con límites dados, en lugar de enumerar y resumir manualmente las banderas. ¿Qué lógica utilizar si se toma un marco temporal arbitrario, se construye un objeto gráfico sobre él y se necesita permitir que sea visible en todos los marcos temporales que no sean más antiguos que el actual (es decir, el que se construyó)? El algoritmo debe ser universal, no para un caso particular. La correlación del índice ya está jodida, ni siquiera hay una coincidencia de índice. El análisis de cadenas de nombres y la comparación es de nuevo un fracaso debido a la imposibilidad de manejar la cadena en caso de constantes de visibilidad. Hasta ahora, se me ocurre una aplicación complicada, vaga y muy torcida.

Por supuesto que hay una correlación, pero es tan implícita que la única forma de escribir <bandera_de_visibilidad> = F(<fotograma>):

int PeriodToTimeframeFlag(ENUM_TIMEFRAMES period)
  {
   flags=0;
   static ENUM_TIMEFRAMES _p_int[]={PERIOD_M1, PERIOD_M2, PERIOD_M3, PERIOD_M4, PERIOD_M5, PERIOD_M6,
                                    PERIOD_M10,PERIOD_M12,PERIOD_M15,PERIOD_M20,PERIOD_M30,
                                    PERIOD_H1, PERIOD_H2, PERIOD_H3, PERIOD_H4, PERIOD_H6, PERIOD_H8,PERIOD_H12,
                                    PERIOD_D1, PERIOD_W1, PERIOD_MN1};
//--- cycle for all timeframes
   for(int i=0;i<ArraySize(_p_int);i++)
      if(period==_p_int[i])
        {
         //--- at the same time generate the flag of the working timeframe
         flags=((int)1)<<i;
         break;
        }
   return(flags);
  }

[Aleksey Lebedev]

x100intraday:

¿Qué lógica utilizar si tomamos al azar un marco temporal arbitrario, construimos un objeto gráfico sobre él y necesitamos permitir su visibilidad en todos los marcos temporales que no sean más antiguos que el actual (es decir, el que fue construido)?

si no es un verificador)

ENUM_TIMEFRAMES TF[21]={PERIOD_M1,PERIOD_M2,PERIOD_M3,PERIOD_M4,PERIOD_M5,PERIOD_M6,PERIOD_M10,
                     PERIOD_M12,PERIOD_M15,PERIOD_M20,PERIOD_M30,PERIOD_H1,PERIOD_H2,PERIOD_H3,
                     PERIOD_H4,PERIOD_H6,PERIOD_H8,PERIOD_H12,PERIOD_D1,PERIOD_W1,PERIOD_MN1};

int Visibility[21]={1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,
            16383,32767,65535,131071,262143,524287,1048575,2097151};

Considerar TF[i], establecer Visibilidad[i]...

o visibilidad=(int)(MathPow(2,i+1)-1);

[x572intraday]

Swan:

Si lo necesita, entonces no es un damero)

Considerar TF[i], establecer Visibilidad[i]...

o visibilidad=(int)(MathPow(2,i+1)-1);

Gracias por la fórmula de la visibilidad, quizá la adapte. Era obvio por los valores en los plazos, que es un grado de algo, pero no he tratado de reconstruir la fórmula yo mismo.

¿Es necesario el -1? En general, Visibility[] parece estar lleno de valores incorrectos, de hecho debería estar en todas partes sin -1, es decir: 1, 2, 4, 8, 16...

[x572intraday]

uncleVic:

Por supuesto que hay una relación, pero es tan implícita que la única manera de escribir <bandera_de_visibilidad>=F(<fecha>) es hacerlo así:

Gracias, elegante. Eso es exactamente lo que estaba tratando de hacer, excepto el turno en sí, que es exactamente lo que me faltaba.

Y finalmente hice la pregunta sobre el cálculo de los valores de las banderas en cada vuelta del bucle de regresión en la matriz de tiempo _p_int (al final se debe añadir algo por las banderas), no sólo en la actual. Bueno, cambiando el valor de la bandera de visibilidad en el marco temporal actual, y luego con cada rotación de i... algo debería cambiar en algún lugar... En este caso, hay que aplicar la fórmula de exponenciación o utilizar el mismo principio de desplazamiento. Todavía no he descubierto cómo...

... Aunque, sí, es una función con TF-argumento - Voy a tratar de bucle...

Sin embargo, se equivoca de nuevo. Déjeme explicarle. En el ejemplo, hay un ENUM_TIMEFRAMES estático _p_int[] para 21 elementos, pero esto es lo que quiero: ya tengo un array de este tipo, pero puede ser de cualquier longitud. Es un array que contiene los timeframes, sobre los que se construirá algo. Pero también deben ser visibles en todos los timeframes inferiores y ninguno de los arrays se llena con ellos por separado o adicionalmente de los existentes. Así que aquí estoy mencionando la necesidad de calcular las banderas de los marcos de tiempo actuales y todos los inferiores y sumarlos en el bucle de regresión sobre la marcha, bailando desde el marco de tiempo actual. El truco no consiste en crear una matriz completa de valores preestablecidos de cualquier cosa (incluso de plazos o banderas de visibilidad) y juguetear con ellos, sino calcular en mi mente para cada turno sólo la matriz incompleta de plazos preestablecidos.

Iré un rato y si me atasco, preguntaré.

[x572intraday]

Por qué no tengo prisa en utilizar (int)(MathPow(2,i+1)-1) o ((int)1)<<i... Si la i está ahí, puedes sustituirla fácilmente en un bucle y ejecutar... Pero, al igual que en el caso de la multiplicación y el desplazamiento, ¿es siempre seguro? Supongamos que los desarrolladores añaden algún día nuevos plazos, ¿no se perderá toda la lógica? De entrada, en el ejemplo con desplazamiento esperamos que el periodo actual coincida con el preestablecido:

if(period==_p_int[i])

por lo que aunque en el caso real se omitan algunos plazos de la secuencia teóricamente completa o esta secuencia sea ampliada por los desarrolladores, la lógica no debería arrastrarse. Pero si nos basamos en la matemática pura y nos limitamos a recorrer el ciclo por fórmula de frontera a frontera, sin mirar la posible ausencia o presencia de nuevos plazos, entonces tarde o temprano, en la siguiente construcción, nos quedaríamos sesgados...

[Victor Kirillin]

x100intraday:

Por qué no tengo prisa en utilizar (int)(MathPow(2,i+1)-1) o ((int)1)<<i... Si la i está ahí, puedes sustituirla fácilmente en un bucle y ejecutar... Pero, al igual que en el caso de la multiplicación y el desplazamiento, ¿es siempre seguro? Supongamos que los desarrolladores añaden algún día nuevos plazos, ¿no se perderá toda la lógica? En el ejemplo con desplazamiento, esperamos que el período actual sea el mismo que el preestablecido:

por lo que aunque en el caso real se omitan algunos plazos de la secuencia teóricamente completa o esta secuencia sea ampliada por los desarrolladores, la lógica no debería colarse. Pero si nos basamos en la matemática pura y nos limitamos a recorrer el ciclo por la fórmula de frontera a frontera, sin prestar atención a la posible ausencia o presencia de nuevos plazos, entonces tarde o temprano, en la siguiente construcción, obtendríamos un sesgo...

Nuestras preocupaciones son muy razonables. El código anterior justifica el hecho de que la bandera de visibilidad establecida es en realidad una macro.

Sería más correcto trabajar a través de él:

int result=0;
//---
switch(period)
  {
   case PERIOD_M1: result=OBJ_PERIOD_M1; break;
   case PERIOD_M2: result=OBJ_PERIOD_M2; break;
   case PERIOD_M3: result=OBJ_PERIOD_M3; break;
   case PERIOD_M4: result=OBJ_PERIOD_M4; break;
   case PERIOD_M5: result=OBJ_PERIOD_M5; break;

//--- и так далее

   default: print("Что-то новенькое");
  }

[Aleksey Lebedev]

x100intraday:

Gracias por la fórmula de la visibilidad, quizá la adapte. Por los valores de los plazos pude ver que era un grado de algo, pero no he intentado reconstruir la fórmula yo mismo.

¿Es realmente necesario el -1? En realidad, Visibility[] parece estar rellenado incorrectamente, de hecho, debería estar en todas partes sin -1, es decir, 1, 2, 4, 8, 16...

1,2,4 etc. - visibilidad del objeto en un marco temporal. =MathPow(2,i);

en el actual y más pequeño 1, 1+2, 1+2+4, 1+2+4+8 etc., taki =MathPow(2,i+1)-1;

Está más claro en el código binario.

tíoVic:

Los recelos son muy razonables. El código anterior sólo justifica el hecho de que el conjunto de banderas de visibilidad es en realidad una macro.

La forma correcta es trabajar a través de ella:

En principio es lo mismo. Si cambias en la lista de af, tendrás que editar el código.

No puedo imaginar ninguna solución universal, y sospecho que es teóricamente imposible prever posibles cambios.

x100intraday:

Sin embargo, se equivoca de nuevo. Déjeme explicarle. En el ejemplo, se crea el ENUM_TIMEFRAMES estático _p_int[] para 21 elementos, pero esto es lo que quiero: ya tengo un array de este tipo, pero puede ser de cualquier longitud. Es un array que contiene los timeframes, sobre los que se construirá algo. Pero también deben ser visibles en todos los timeframes inferiores y ninguno de los arrays se llena con ellos por separado o adicionalmente de los existentes. Así que aquí estoy mencionando la necesidad de calcular las banderas de los marcos de tiempo actuales y todos los inferiores y sumarlos en el bucle de regresión sobre la marcha, bailando desde el marco de tiempo actual. El truco consiste en no crear una matriz completa de valores preestablecidos de cualquier cosa (incluso de plazos o banderas de visibilidad) y hacer un bucle a través de ellos, sino calcular en mente en cada turno sólo la matriz incompleta de plazos preestablecidos.

No, no lo harás. Hay que definir la correspondencia entre calendario y visibilidad. O dos matrices correspondientes, o un interruptor.

+array con los TFs que necesites, +init calcula la visibilidad del objeto para cada TF que uses. Algo así...)

[Serj]

No puedo entender qué es lo que está mal.

double VirtualSL;
MqlTick tick;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   VirtualSL=0.0;
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   trail();
  }
//+------------------------------------------------------------------+
void trail()
  {
   double stopcal;

   SymbolInfoTick(_Symbol,tick);
   stopcal=tick.bid;

//   if((VirtualSL!=0.0 && stopcal>VirtualSL) || VirtualSL==0.0) // так все работает

   if(VirtualSL==0.0 || (VirtualSL!=0.0 && stopcal>VirtualSL)) // так не хочет работать
     {
      VirtualSL=stopcal;
      Print("use Ok!");
     }
   if(VirtualSL<stopcal) Print("o_O ((((( stopcal = ",stopcal,"   VirtualSL = ",VirtualSL);
  }
//+------------------------------------------------------------------+

2011.12.29 01:16:07 Core 1 2011.09.26 02:54:13 o_O ((((( stopcal = 1.54508 VirtualSL = 1.53378

2011.12.29 01:16:07 Core 1 2011.09.26 02:54:12 o_O ((((( stopcal = 1.54507 VirtualSL = 1.53378

2011.12.29 01:16:07 Core 1 2011.09.26 02:54:12 o_O ((((( stopcal = 1.54508 VirtualSL = 1.53378

[Ilyas]

her.human:

Me he devanado los sesos, no entiendo qué pasa.

Es un error del optimizador del compilador. Gracias por su mensaje, lo arreglaremos.

El error se produce con la siguiente construcción

if(VirtualSL==0.0 || (VirtualSL!=0.0 && stopcal>VirtualSL))
if(VirtualSL<stopcal)

VirtualSL!=0.0 puede eliminarse de la segunda parte de la primera condición if,ya que esta expresión es siempre verdadera después de comprobar la primera parte. El error del optimizador desaparecerá.


Corregido, el arreglo se incluirá en la próxima compilación.