ATcl - Intérprete Tcl para MT4 - página 6

 
Maxim Kuznetsov:

En términos de tecnología de software, potencialmente sí. Las bibliotecas pueden ser llamadas desde el optimizador siempre que no esté en la nube.

en el lado de la NS - ¿cómo lo imaginas?

En el optimizador se hace una pasada y se escriben los datos en el fichero, luego se pasa al entrenamiento de la red, después del entrenamiento se devuelven los resultados de la evaluación del entrenamiento a MT4/5 y se escribe la red (reglas) en el fichero. Y la otra vista es cuando usamos los archivos grabados de la lógica de NS para optimizar (las variantes de NS) y arreglar los indicadores estándar de TS.

 

He ampliado la demo del gráfico Tk - ahora también muestra la tabla de órdenes.

Tabla de pedidos en una ventana aparte

El código MQL que hace referencia a la tabla de pedidos
- selecciona todos sus pedidos y los envía a tcl en el método OnOrderList
- en la salida obtenemos 3 listas de tickets - los que son nuevos, los que cambiaron y los que fueron borrados

void
SendOrderList() 
{
   int total=OrdersTotal();
   Tcl_Obj list=tcl.Ref(tcl.Obj()); // пустой список
   for(int pos=0;pos<total;pos++) {
      if (!OrderSelect(pos,SELECT_BY_POS,MODE_TRADES) ||
         OrderMagicNumber()!=MAGIC ||
         OrderSymbol()!=_Symbol ||
         OrderCloseTime()!=0) continue;
      Tcl_Obj ord=tcl.Ref(tcl.List(
         tcl.Obj(OrderTicket()),
         tcl.Obj(OrderType()),
         tcl.Obj(OrderOpenTime()),
         tcl.Obj(OrderSymbol()),
         tcl.Obj(OrderLots()),
         tcl.Obj(OrderOpenPrice()),
         tcl.Obj(OrderStopLoss()),
         tcl.Obj(OrderTakeProfit()),
         tcl.Obj(OrderComment()),
         tcl.Obj(OrderSwap()),
         tcl.Obj(OrderCommission())
      ));
      tcl.AppendObj(list,ord);
      tcl.Unref(ord);
   }
   if (tcl.Call(panel,methodOnOrderList,list)!=TCL_OK) {
      PrintFormat("OrderSendList failed : %s",tcl.StringResult());
   } else {
      Tcl_Obj triplet=tcl.Ref(tcl.Result()); // 0-новые 1-изменённые 2-удалённые
      Tcl_Obj created=tcl.Ref(tcl.Index(triplet,0));  // список новых ордеров
      Tcl_Obj changed=tcl.Ref(tcl.Index(triplet,1));  // список изменённых ордеров
      Tcl_Obj removed=tcl.Ref(tcl.Index(triplet,2));  // список удалённых ордеров
      PrintOrderList("New orders",created);
      PrintOrderList("Modified orders",changed);
      PrintOrderList("Deleted orders",removed);
      // объекты больше ненужны
      tcl.Unref(removed);
      tcl.Unref(changed);
      tcl.Unref(created);
      tcl.Unref(triplet);
   }
}

y el método Tcl que hace el trabajo principal :
- obtiene una nueva lista de pedidos
- comparar con las convocatorias anteriores
- construye 3 listas (nuevas, modificadas, eliminadas).
- crea una tabla ...que en realidad es un árbol y puede hacerse en varios niveles.


# надо обновить внутренние структуры
# и вернуть триплет (список из трёх списков)
#   1 - список новых ордеров
#   2 - ордера которые поменялись
#    3 - ордера которые удалены
method OnOrderList { orderList } {
    set created {}
    set changed {}
    set removed {}
    foreach order $orderList {
        set ticket [ lindex $order 0 ]
        set known($ticket) $order
        if { ! [ info exists Orders($ticket) ] } {
            # новый тикет
            # добавить в список свежесозданных
            lappend created $ticket
            set Orders($ticket) $order
            continue
        }
        if { $Orders($ticket) != $order } {
            # что-то поменялось
            # добавить в список изменённых
            set Orders($ticket) $order
            lappend changed $ticket
        }
    }
    foreach ticket [ array names Orders ] {
        if { ! [ info exists known($ticket) ] } {
            # прежнего ордера нет в новом списке - значит удалён
            lappend removed $ticket
            unset Orders($ticket)
        }
    }
    # обновить грфику :-)
    foreach ticket $removed {
        my OnRemoveOrder $ticket
    }
    foreach ticket $changed {
        my OnChangeOrder $ticket
    }
    foreach ticket $created {
        my OnCreateOrder $ticket
    }
    return [ list $created $changed $removed ]
}

todo es muy compacto.
Puede utilizar los puntos fuertes de ambos lenguajes: MQL se acerca al entorno comercial y cuenta rápidamente en arrays,
Tcl puede manejar fácilmente listas y hashes.
MQL implementa un duro algoritmo de negociación mientras que los scripts se encargan de la interacción con el mundo y el usuario.

Se adjunta el archivo.

Archivos adjuntos:
atcl.zip  6662 kb
 

Un script para exportar presupuestos a Excel

Hice un pequeño script para exportar las cotizaciones directamente a Excel.
Sin ninguna entrada en el CSV ni ningún parámetro - simplemente lánzalo sobre el gráfico, la hoja de Excel se abrirá y todas las cotizaciones se copiarán en ella.

He comentado el texto todo lo posible y lo he adjuntado. He proporcionado los detalles del script en mi sitio web http://nektomk.ru/atcl:ratestoexcel.
La cantidad está fuera del alcance de este foro, así que está ahí. Quizá cuando tenga ganas lo duplique en el blog local para que la información no se pierda seguro.

El guión adjunto

PS/ ¿Alguien tiene un archivo make para la compilación por lotes de mql ? que cambie un mqh, empuje make y reconstruya un montón de mq4 que están listados en las dependencias...

actualizar/ duplicar el artículo en el blog local https://www.mql5.com/ru/blogs/post/718304 - ahora probablemente no desaparecerá
RatesToExcel
  • nektomk.ru
Часто возникающий (и довольно практичный) вопрос у пользователей MetaTrader - «Как скопировать котировки в Excel?» . При помощи библиотеки ATcl это программируется довольно легко. В состав библиотеки входит «большая» программа работающая с Excel, но для частых потребностей сделал короткий скрипт, который делает самую простую вещь - экспорт...
Archivos adjuntos:
 

El correo funciona, pero todavía necesita más trabajo...

Mientras tanto, una pregunta para la gente: ¿tendrá demanda el GUI-Builder?
para Tk, están ahí, pero debido al hecho de que los scripts en texto escriben más rápido que en draw, son poco demandados.

algo así:

PS/ el resultado de tal GUI-builder puede ser iniciado desde MT4...

 
Maxim Kuznetsov:

el mailer funciona, pero todavía necesita más trabajo...

pero mientras tanto una pregunta para la gente - ¿habrá demanda de GUI-Builder?
para Tk lo son, pero debido al hecho de que los scripts son más rápidos de escribir en texto que en dibujo no tienen mucha demanda.

algo así:

PD/ El resultado de tal GUI-construcción y ahora con la ayuda de "tal y tal madre" se puede ejecutar desde MT4...

Qué cosas tan interesantes... ¿sólo cómo aplicarlos?

Ah, tengo una idea para las interfaces gráficas: ¡crear una lógica de negociación como un árbol de decisiones! Es decir, crear un árbol en el editor gráfico (es decir, el shell) y utilizar un botón para convertirlo en reglas simples, ¡o incluso directamente en código! Sin embargo, las reglas también pueden leerse en código de forma muy compacta.

¿Por qué lo necesitamos? Este enfoque permite detallar la estrategia de negociación, por ejemplo, podemos dividirla fácilmente en series temporales, no sólo para decidir si se negocia o no, sino también si se negocia en este momento y en este otro de manera diferente. Los signos de un cambio de táctica son muchos y variados, pero no es muy conveniente escribirlo en el código y, en segundo lugar, es difícil de leer visualmente: se pueden cometer muchos errores.

¿Te interesa esta idea para aplicar tus talentos?

 
Aleksey Vyazmikin:

Qué cosas tan interesantes... ¿pero cómo aplicarlos?

Ah, tengo una idea para las interfaces gráficas: ¡crear una lógica de negociación como un árbol de decisiones! Es decir, creamos un árbol en el editor gráfico (es decir, el shell) y utilizamos un botón para convertirlo en algunas reglas sencillas o incluso directamente en código. Sin embargo, las reglas también pueden leerse en código de forma muy compacta.

¿Por qué lo necesitamos? Este enfoque permite detallar la estrategia de negociación, por ejemplo, podemos dividirla fácilmente en series temporales, no sólo para decidir si se negocia o no, sino también si se negocia en este momento y en este otro de manera diferente. Los signos de un cambio de táctica son muchos y variados, pero no es muy conveniente escribirlo en el código y, en segundo lugar, es difícil de leer visualmente: se pueden cometer muchos errores.

¿Le interesa esa idea para aplicar sus talentos?

No entiendo la idea de un "árbol de decisión gráfico". :-) quizás tu talento no es suficiente :-)

 
Maxim Kuznetsov:

No entiendo en absoluto la idea del "árbol de decisión gráfico" :-) tal vez no tengas suficiente talento :-)

Imagine una tabla de datos con un conjunto de reglas



Estas normas están organizadas de la siguiente manera

      for(int i=1;i<StrokTotal_Buy; i++)
        {
         UslovieSumm_Buy=
                          Sravnenief(arr_Vektor_Week,arrRead_Buy_01[i])+
                          Sravnenief(arr_Vektor_Day,arrRead_Buy_02[i])+
                          Sravnenief(arr_Vektor_Don,arrRead_Buy_03[i])+
                          Sravnenief(arr_DonProc,arrRead_Buy_04[i])+
                          Sravnenief(arr_iDelta_H1,arrRead_Buy_05[i])+
                          Sravnenief(arr_iDelta_H3,arrRead_Buy_06[i])+
                          Sravnenief(arr_iDelta_H4,arrRead_Buy_07[i])+
                          Sravnenief(arr_iDelta_H6,arrRead_Buy_08[i])+
                          Sravnenief(arr_iDelta_H12,arrRead_Buy_09[i])+
                          Sravnenief(arr_iDelta_D1,arrRead_Buy_10[i])+
                          Sravnenief(arr_iDelta_W1,arrRead_Buy_11[i])+
                          Sravnenief(arr_iDelta_MN1,arrRead_Buy_12[i])+
                          Sravnenief(arr_RSI_Open_M1,arrRead_Buy_13[i])+
                          Sravnenief(arr_RSI_Open_H1,arrRead_Buy_14[i])+
                          Sravnenief(arr_BB_Center_Open,arrRead_Buy_15[i])+
                          Sravnenief(arr_BB_Up_Open,arrRead_Buy_16[i])+
                          Sravnenief(arr_BB_Down_Open,arrRead_Buy_17[i])+
                          Sravnenief(arr_TimeH,arrRead_Buy_18[i])+
                          Sravnenief(arr_Den_Nedeli,arrRead_Buy_19[i])+
                          Sravnenief(arr_iDelta_Max_H1,arrRead_Buy_20[i])+
                          Sravnenief(arr_iDelta_Min_H1,arrRead_Buy_21[i])+
                          Sravnenief(arr_iDelta_Max_D1,arrRead_Buy_22[i])+
                          Sravnenief(arr_iDelta_Min_D1,arrRead_Buy_23[i]);                                                                              
;




         if(UslovieSumm_Buy==23)
           {
            Pattern_Buy=1;
            Pravilo_Buy=i;
            break;
           }
        }

Si tenemos un valor de la regla y un valor calculado (valor del indicador/tiempo/otro patrón) coinciden, entonces se realiza una acción de comercio, por ejemplo.

Este método de decisiones comerciales es muy compacto y versátil - podemos codificar de manera tan simple, por ejemplo, muchas estrategias - dándoles diferentes símbolos mágicos.

Pero la pega es que necesitamos justo el entorno para ese estilo de programación. Este entorno debería parecerse a un árbol de decisión (un diagrama de bloques primitivo) donde podemos crear bloques (resultado de cálculo por ejemploarr_iDelta_Max_D1 con valores predefinidos (1,2,3,4 ...n) y/o con posibilidad de limitar los valores desde y hasta, creando así muchos grupos diferentes), desde este bloque se bifurcará para cada valor de variable o rango de valores de variable, y así hasta el siguiente bloque y así sucesivamente. Así, tendremos un conjunto de reglas, cada una de las cuales, por cierto, no tiene por qué utilizar todos los bloques.

¿Esto te hace entender? Si necesita explicaciones, pídalas.

 
Aleksey Vyazmikin:

Presentar una tabla de datos con un conjunto de reglas



Estas normas están codificadas de la siguiente manera

Si tenemos una coincidencia de los valores de la regla y los valores calculados (valor del indicador/tiempo/otro patrón), entonces, por ejemplo, se realiza una acción comercial.

Este método de decisiones comerciales es muy compacto y versátil - podemos codificar de manera tan simple, por ejemplo, muchas estrategias - dándoles diferentes símbolos mágicos.

Pero la pega es que necesitamos justo el entorno para ese estilo de programación. Este entorno debería parecerse a un árbol de decisión (un diagrama de bloques primitivo) donde podemos crear bloques (resultado de cálculo por ejemploarr_iDelta_Max_D1 con valores predefinidos (1,2,3,4 ...n) y/o con posibilidad de limitar los valores desde y hasta, creando así muchos grupos diferentes), desde este bloque se bifurcará para cada valor de variable o rango de valores de variable, y así hasta el siguiente bloque y así sucesivamente. Así, tendremos un conjunto de reglas, cada una de las cuales, por cierto, no tiene por qué utilizar todos los bloques.

¿Esto te hace entender? Si necesita explicaciones, pídalas.

¿Como Xcos (http://www.scilab.org/en/scilab/features/xcos) y otros similares en simulaciones?
Lo he visto en tcl - un entorno en el que se conectan bloques con flechas... así es como programaban el procesamiento de sonido/vídeo/gráficos. http://wiki.tcl.tk/8565 parece ser un montón de cosas, incluso metieron Maxima en algún bloque
Si lo es, prestará mucha atención
Xcos / Features / Scilab / Home - Scilab
Xcos / Features / Scilab / Home - Scilab
  • Scilab Enterprises
  • www.scilab.org
Xcos is a graphical editor to design hybrid dynamical systems models. Models can be designed, loaded, saved, compiled and simulated.
 
Maxim Kuznetsov:
Como Xcos (http://www.scilab.org/en/scilab/features/xcos) y similares de moda en las simulaciones ?
Lo he visto en tcl - entorno en el que conectan los bloques con flechas... así es como programaban el procesamiento de sonido/vídeo/gráficos. http://wiki.tcl.tk/8565 parece ser un montón de cosas, incluso metieron a Maxima en algún bloque
Si lo es, prestará mucha atención

Sí, este es el enfoque. Lo principal es no complicar las cosas, y hacer un intérprete correcto, para que todos los bloques se recojan en una línea (una rama), con lo que el programa en MQL ya funcionará.

 
Aleksey Vyazmikin:

Sí, este es el enfoque. Lo principal es no complicarse, y hacer un intérprete correcto, para que todos los bloques se recojan en una línea (una rama), con lo que el programa ya funcionará en MQL.

No creo que quiera complicarme demasiado, por ejemplo, no quiero meterme con el código bwise.

A lo sumo, lo adaptaré para usarlo junto con ATcl (es decir, transferir datos de Mql a sus entradas) y tomar las salidas.
Por supuesto, tendré que escribir algún HowTo de "cómo dibujar cuadrados y unirlos a EA". Y practica el inglés cuando te comuniques con el autor o los autores :-)

Razón de la queja: