[ARCHIVO]Cualquier pregunta de novato, para no saturar el foro. Profesionales, no lo dejéis pasar. No puedo ir a ningún sitio sin ti - 5. - página 323

 

Esto es lo que ocurre:

//+-------------------------------------------------------------------------------------+
//| Расчитываем количество идущих один за одним баров одного признака                   |
//+-------------------------------------------------------------------------------------+
int LastCandlesType(int directionMA)
{
   int cntUp,                                                                           // Счётчик идущих друг за другом свечей с..
       cntDn,                                                                           // .. требуемыми признаками
       t;                                                                               // Счётчик всех просчитанных баров
       
   for (int i=i_AnyBarsToHistory; i>=1; i--, t++)
   {
      if (directionMA == CROSS_UP)                                                      // Если машки направлены вверх
      {
         if ((Open[i] - Close[i]) >= i_sizeOfSequentialCorrectionBar * pt)              // Если бар соответствует требуемым признакам..
             cntDn++;                                                                   // .. прибавим 1 к счётчику
         if ((Close[i] - Open[i]) >= i_sizeOfTrandBar * pt)                             // Если бар, не соответствует основному признаку..
             cntDn = 0;                                                                 // .. счётчик обнуляем
                                                                                        
         if (i == 1)
            Print(" directionMA ", directionMA, "; i = ", i, "; Open[i] - Close[i] = ", Open[i] - Close[i], "; cntDn = ", cntDn);

         if (t == i_AnyBarsToHistory)
         {
             if (cntDn == i_sequentBarsСount)                                                // Если cnt баров в подряд медвежьи..
                 return (REQUIRED_SEQUENTIAL_BEARS_GOT);                                     // .. Выходим из функции
         }
      }

      if (directionMA == CROSS_DN)                                                      // Если машки направлены вниз
      {
         if ((Close[i] - Open[i]) >= i_sizeOfSequentialCorrectionBar * pt)              // Если бар соответствует требуемым признакам..
             cntUp++;                                                                   // .. прибавим 1 к счётчику
         if ((Open[i] - Close[i]) >= i_sizeOfTrandBar * pt)                             // Если бар, не соответствует основному признаку..
             cntUp = 0;                                                                 // .. счётчик обнуляем
         if (i == 1)
            Print(" directionMA ", directionMA, "; i = ", i, "; Close[i] - Open[i] = ", Close[i] - Open[i], "; cntUp = ", cntUp);

         if (t == i_AnyBarsToHistory)
         {
             if (cntUp == i_sequentBarsСount)                                                // Если cnt баров в подряд бычьи..
                 return (REQUIRED_SEQUENTIAL_BULLS_GOT);                                     // .. Выходим из функции
         }
      }
      return (REQUIRED_SEQUENTIAL_MISS);
   }
}

De hecho, ni siquiera se imprime una línea:

Print(" directionMA ", directionMA, "; i = ", i, "; Close[i] - Open[i] = ", Close[i] - Open[i], "; cntUp = ", cntUp);

Así que probablemente haya algún tipo de error en lo anterior.

Lo más interesante es que una vez que he añadido un retorno por defecto aquí, de alguna manera funciona todo el tiempo. Me refiero a la cuerda:

return (REQUIRED_SEQUENTIAL_MISS);

Aunque es obvio que el código es elemental, y no puede haber errores ahí.

 

¡Saludos a todos! Estimados gurús, ¿pueden decirme por qué v_s aumenta y disminuye cuando el beneficio aumenta y disminuye en la moneda del depósito?

value_profit() es un cálculo de beneficios en la moneda del depósito.

doble valor_parada,valor_paso;
valor_stop=((SaldoCuenta()/100)*1);
valor_paso=((SaldoCuenta()/100)*4);
doble v_s;
si (valor_ganancia()>=(valor_paso+valor_stop))
for (int v=1;v<=100;v++)
{
si (valor_ganancia()>=(valor_paso+(valor_parada*v))
{
v_s=valor_parada*v;
}
si no
{
si (valor_ganancia()<=v_s)
close_all();
}
}
 
hoz:

De hecho, ni siquiera se imprime una línea:

1. ¿Por qué hacer la modularidad exactamente a la vez? Por supuesto, cada uno tiene su propio estilo, pero yo primero puliría la versión compacta, y luego, cuando funcione como un reloj, la pasaría a la modularidad. La variante compacta (sin las funciones insertadas Trade, LastCandlesType, GetStateOfMA, GetGeneralSignal) fue dada como una variante de start() interno en la última página. ¿Cómo funciona para usted? Si funciona, entonces divídelo en módulos.

2. El código me parece absolutamente idéntico al anterior, ya que el contador t cambia de forma absolutamente paralela al contador i. ¿Por qué entonces comparar con t si se puede comparar con i? Y, siguiendo la lógica, entonces ¿por qué comparar con i si tenemos un código que no funcionó?

3. Siento entrometerme, pero ¿cómo funcionaría esta variante sacando la salida del bucle?

int LastCandlesType(int directionMA){
        int cntUp, cntDn;
        for (int i=i_AnyBarsToHistory; i>=1; i--){
                if (directionMA == CROSS_UP){
                        if ((Open[i] - Close[i]) >= i_sizeOfSequentialCorrectionBar * pt) cntDn++; else cntDn=0;
                        if (i == 1) Print(" directionMA ", directionMA, "; i = ", i, "; Open[i] - Close[i] = ", Open[i] - Close[i], "; cntDn = ", cntDn);
                }
                if (directionMA == CROSS_DN){
                        if ((Close[i] - Open[i]) >= i_sizeOfSequentialCorrectionBar * pt) cntUp++; else cntUp=0;
                        if (i == 1) Print(" directionMA ", directionMA, "; i = ", i, "; Close[i] - Open[i] = ", Close[i] - Open[i], "; cntUp = ", cntUp);
                }
        }
        if ((directionMA==CROSS_UP)&&(cntUp>=i_sequentBarsСount)) return(REQUIRED_SEQUENTIAL_BEARS_GOT);
        if ((directionMA==CROSS_DN)&&(cntDn>=i_sequentBarsСount)) return(REQUIRED_SEQUENTIAL_BULLS_GOT);
        return(REQUIRED_SEQUENTIAL_MISS);
}

Entiendo que puede que tampoco funcione, lo que sea, pero necesito estar seguro de ello para seguir averiguando.

4. Pura adaptación personal: escribir el código no en el meta editor, sino en cualquier otro editor con líneas numeradas, e imprimir en cada cambio de cualquier variable y en cada comprobación de if o switch, en la misma línea (después del último punto y coma). Imprima en el número de línea - valor(es) a comprobar. Imprímalo después de if(tracing) {Print(StringConcatenate("número_de_línea: nombre_de_la_variable=", nombre_de_la_variable));} y declare una variable en la cabecera, como: bool tracing=false;//activar el trazado. En este caso tendrás un rastreo completo y por lo tanto una depuración completa. Pero hay que limpiar los troncos más a menudo, por supuesto. Si va a utilizar el editor meta directamente, puede hacer primero una plantilla vacía como

/*001*/

...

/*999*/

al principio de las líneas (y funciona), y luego en una copia de esta plantilla para escribir el código. Pero esto es sólo lo que pienso, en la práctica lo intenté así, pero lo intenté de forma inconsistente.

 
rajak:

¡Saludos a todos! Estimados gurús, ¿podrían decirme por qué v_s aumenta y disminuye cuando el beneficio aumenta y disminuye en la moneda del depósito?

value_profit() es un cálculo de beneficios en la moneda del depósito.

doble valor_parada,valor_paso;
valor_stop=((SaldoCuenta()/100)*1);
valor_paso=((SaldoCuenta()/100)*4);
doble v_s;
si (valor_ganancia()>=(valor_paso+valor_stop))
for (int v=1;v<=100;v++)
{
si (valor_ganancia()>=(valor_paso+(valor_parada*v))
{
v_s=valor_parada*v;
}
si no
{
si (valor_ganancia()<=v_s)
close_all();
}
}
Tras un rápido vistazo, vi inmediatamente un error con las comillas. Enseñar a utilizar la sentencia if.
 
gyfto:

3. Siento entrometerme, pero ¿cómo te funcionaría sacar la salida del bucle después de todo?

int LastCandlesType(int directionMA){
        int cntUp, cntDn;
        for (int i=i_AnyBarsToHistory; i>=1; i--){
                if (directionMA == CROSS_UP){
                        if ((Open[i] - Close[i]) >= i_sizeOfSequentialCorrectionBar * pt) cntDn++; else cntDn=0;
                        if (i == 1) Print(" directionMA ", directionMA, "; i = ", i, "; Open[i] - Close[i] = ", Open[i] - Close[i], "; cntDn = ", cntDn);
                }
                if (directionMA == CROSS_DN){
                        if ((Close[i] - Open[i]) >= i_sizeOfSequentialCorrectionBar * pt) cntUp++; else cntUp=0;
                        if (i == 1) Print(" directionMA ", directionMA, "; i = ", i, "; Close[i] - Open[i] = ", Close[i] - Open[i], "; cntUp = ", cntUp);
                }
        }
        if ((directionMA==CROSS_UP)&&(cntUp>=i_sequentBarsСount)) return(REQUIRED_SEQUENTIAL_BEARS_GOT);
        if ((directionMA==CROSS_DN)&&(cntDn>=i_sequentBarsСount)) return(REQUIRED_SEQUENTIAL_BULLS_GOT);
        return(REQUIRED_SEQUENTIAL_MISS);
}

Hm. Funcionó. He ejecutado varias "pantallas" en la visual, todo está claro en este intervalo. Todavía tengo que entender por qué no funcionó la última vez. Será útil para evitar tropiezos en el futuro.
 
hoz:

Hmm, está funcionando.


Glad))))

hoz:

Todavía tengo que averiguar por qué no funcionó la última vez. Será útil para evitar tropiezos en el futuro.

Porque en el futuro, no salga para antes de llegar a Close[0] o lo que sea el límite de la ventana en cualquier otro algoritmo. No es mientras.

 
gyfto:

1. ¿Por qué hacer la modularidad de una vez? Por supuesto, cada uno tiene su propio estilo, pero yo primero puliría la versión compacta, y luego, cuando funcione como un reloj, cambiaría a la modularidad. La variante compacta (sin las funciones insertadas Trade, LastCandlesType, GetStateOfMA, GetGeneralSignal) se mostró como una variante de las internas de start() en la página anterior. ¿Cómo funciona para usted? Si funciona, entonces divídelo en módulos.

De hecho, estoy acostumbrado a escribirlo así. Y es más fácil buscar errores. Porque enseguida supe que el error estaba en la funciónLastCandlesType(). Pero aún no he encontrado la razón, aunque tu manera ha funcionado.

gyfto:

2. El código me parece absolutamente idéntico al anterior, ya que el contador t cambia absolutamente en paralelo al contador i. ¿Por qué entonces comparar con t si se puede comparar con i? Y, siguiendo la lógica, entonces ¿por qué comparar con i si tenemos un código que no funcionó?

Demasiado tarde para escribir, ... sobrecarga moral, supongo.

gyfto:

Entiendo que puede que tampoco funcione, lo que sea, pero necesito asegurarme de que lo hace para seguir averiguando.

¡Funciona! Lo que queda por entender es por qué ese código no funcionó. Lo primero que me llamó la atención fue la salida de la función cuando el contador alcanza el valor i_seqqtBarstCounter. Pero, de nuevo, imprimí y el valor del contador sólo mostró 1 todo el tiempo, cuando puse la salida por defecto de la funciónreturn(REQUIRED_SEQUENTIAL_MISS);

Antes de colocarlo, todo estaba calculado correctamente, pero el búho no operaba correctamente. No pasaba nada en absoluto. Aunque, en teoría, si ninguna de las condiciones por encima de la salida por defecto funcionó, significa que ninguna de las condiciones se ha disparado y aunque coloquemos la salida por defecto en la condición no debería funcionar. A la inversa, si la condición se mantiene, debería mantenerse.


gyfto:

4. Pura adaptación personal: escribir el código no en meta-editor, sino en cualquier otro editor con numeración de líneas, e imprimir en cada cambio de cualquier variable y en cada comprobación de if o switch, en la misma línea (después del último punto y coma). Imprima en el número de línea - valor(es) a comprobar. Imprímalo después de if(tracing) {Print(StringConcatenate("número_de_línea: nombre_de_la_variable=", nombre_de_la_variable));} y declare una variable en la cabecera, como: bool tracing=false;//activar el trazado. En este caso tendrás un rastreo completo y por lo tanto una depuración completa. Pero hay que limpiar los troncos más a menudo, por supuesto. Si va a utilizar el editor meta directamente, puede hacer primero una plantilla vacía como

/*001*/

...

/*999*/

al principio de las líneas (y funciona), y luego en una copia de esta plantilla para escribir el código. Pero esto es sólo lo que pienso, en la práctica lo intenté así, pero lo intenté de forma inconsistente.


Bueno, imprimimos en base a los datos del Asesor Experto, no en base a los números de fila. ¿Por qué necesita números de línea? Personalmente, lo uso para el análisis de código, ya que hay momentos realmente útiles. Pero escribir y depurar el código basándose en los números de línea me parece un sinsentido.
 
hoz:

Queda por ver por qué ese código no funcionó.


La forma en que lo descubrí yo mismo. Leemos los cruces de los candelabros. Más precisamente, tres velas alcistas o bajistas después de cruzar en cualquier momento. Cuando se cumple la condición, entramos en el mercado. Pero a juzgar por la descripción verbal, estos tres o más candelabros que vienen en fila pertenecen al borde derecho de la ventana. Según su código, pueden referirse al centro de la ventana. Por lo tanto, el Asesor Experto ha entrado en el mercado cuando se ha alcanzado la condición (tres velas), mientras que la última vela puede no ser la última.
 
gyfto:

Como yo mismo lo descubrí. Leemos la intersección de los osos. Para ser más exactos, tres velas alcistas o bajistas después de cruzar en cualquier momento. Cuando se cumple la condición, entramos en el mercado. Pero a juzgar por la descripción verbal, estos tres o más candelabros que vienen en fila pertenecen al borde derecho de la ventana. Según su código, pueden referirse al centro de la ventana. Por lo tanto, el EA entrará en el mercado cuando se alcance la condición (tres velas), pero la última vela puede no ser la última.


La conclusión es la siguiente: conociendo la sintaxis, hay que vigilar también la lógica. Esto es muy importante. Ahí tuve un error lógico.

Parece sencillo, pero me quedé colgado de algo y no lo entendí de inmediato. Vaya. Sucede que... :(

 

¡Buenas tardes!

Mi pregunta se sale un poco del tema.

¿Podría decirme si es posible encontrar en algún lugar el corte de las formas de AT como archivos CSV? Puedo utilizar txt, xls o cualquier otro formato que se pueda procesar mediante programación.

Hay ejemplos de figuras de AT en varios artículos de AT, libros de texto, pero por supuesto como imágenes ordinarias. ¿Alguien tiene conjuntos más o menos grandes de símbolos de AT guardados como una porción de la historia de algún par de divisas en los períodos H1-H4, digamos?

He buscado en Google y no he encontrado nada. Por supuesto, podemos recorrer manualmente el historial, marcar las formas, exportar este trozo de historial como .csv; repetir el número de veces necesario, y recoger la base de formas al final. Pero si alguien ya lo ha hecho, me gustaría ahorrar tiempo.

Gracias de antemano :)