Como es el proceso de abrir una posición paso a paso

En Forex hay 2 maneras de programar órdenes. Una es programarlas en el PC del usuario. Por ejemplo yo programo un EA para que abra una orden cuando llegue a cierto precio. Pero todo dentro de mi PC. La otra manera es programar las órdenes desde el servidor del bróker. Por ejemplo yo creo una orden pendiente para que abra una orden cuando llegue a cierto precio. Los dos ejemplos hacen lo mismo pero se ejecutan en diferentes lados.
La programación local tiene muchísimas más opciones como por ejemplo crear órdenes según un indicador, pero es más complicado programarlas.  Programar órdenes en el servidor es muy muy sencillo, pero tiene muchísimas menos opciones.  Básicamente lo único que uno puede hacer en el servidor es crear ordenes pendientes. No es que una sea mejor que otra, cada opción se debe utilizar según las circunstancias.
Para entender cómo se programan las operaciones lo primero es tener los conceptos bien claros.

• Orden de mercado:  Es cuando se abre una posición de venta o compra. Esta se muestra en la grafica hasta que se cierra. Las órdenes de mercado se pueden abrir y cerrar manual y automáticamente.
• Orden pendiente:  Es cuando se programa una orden de mercado cuando el precio llega a un nivel que nosotros indicamos.
• Solicitud de orden:  Es un comando hecho por una persona o un programa para hacer alguna operación.
• Trade. Es cuando se modifica, abre o cierra una orden.

Las siguientes son las funciones que se utilizan para manejar operaciones comerciales.

• OrderSend () Para abrir ordenes de mercado y ordenes pendientes.
• OrderClose () y OrderCloseBy () Para cerrar órdenes de mercado;
• OrderDelete () Para eliminar ordenes pendientes.
• OrderModify () Para modificar ordenes hechas (stop lost  y take profit) y ordenes pendientes.

El proceso de un trade.

Cuando un EA hace una petición, este se la pasa a MetaTrader para que la procese. MetaTrader analiza la petición y toma dos decisiones según su análisis. Envía la petición al servidor si todo está bien, o la rechaza si algo está mal. Si el EA hace una petición para abrir una posición en un precio que no existe, MetaTrader no envía la petición al servidor.
Si hay varios EA operando en diferentes graficas y un EA hace una operación, los otros EA no podrán realizar sus operaciones hasta que este EA termina la suya.

Con esta gráfica queda mas claro como es el proceso para hacer un trade.

Evento 0. El EA inicio.

Evento 1. El EA hace una petición comercial. Esta solicitud de ha pasado a MetaTrader. En este momento la pelota la tiene MetaTrader  y el EA pausa su operación esperando recibir  una respuesta.

Evento 2. Metatrader ha recibido el control, y tiene la información de la petición. Ahora la va analizar entre t2 y t3 para tomar una decisión.

Evento 3. Para ver los dos casos posibles, vamos a ver dos alternativas. Una petición aceptada y una petición rechazada. En t3 MetaTrader a tomado la decisión.
Alternativa 1. Si la petición ha sido rechazada, MetaTrader le devuelve el control al EA y le manda la información del error.

Evento 4. El EA ha recibido el control y reanuda su funcionamiento. Al mismo tiempo recibe el error de su solicitud. En este caso MetaTrader no se comunica nunca con el servidor.

Alternativa 2.  Aca la solicitud es correcta y MetaTrader la envía al servidor. El transcurso del tiempo entre t3 y t5 depende de la velocidad en que se comuniquen MetaTrader y el Servidor. Entre mejor la conexión, menos tiempo entre este intervalo.

Evento 5. El servidor recibe la petición. MetaTrader y el EA se quedan a la espera de que el servidor envié una respuesta. La decisión que tome el servidor seria en t6. El intervalo de t5 y t6 depende del servidor. Si hay mucha actividad el en servidor esto se puede demorar un poco más de tiempo.

Evento 6. Si no han pasado grandes cambios en el mercado entre t1 y t6 la petición será ejecutada.  Si el precio ha cambiado o la orden supera el margen de la cuanta, o pasa algún problema, el servidor rechaza la petición.
El rechazo por parte del servidor aunque MetaTrader haya permitido la operación es común. La mayoría de las peticiones son aceptadas. Sin embargo, en algunos casos la petición puede ser rechazada. Por esta razón es vital tener esto en cuenta cuando se programe el EA. Para que este pueda gestionar este tipo de errores y no cause un error grave a MetaTrader.
Sea cualquiera la decisión que tome el servidor, este enviara la información sobre la decisión a MetaTrader.

Evento 7. MetaTrader ha recibido la respuesta del servidor. Según la operación que se haya efectuado en el servidor, MetaTrader reflejara esos cambios. Si el servidor ha rechazado la operación, no se verá ningún cambio en MetaTrader.

Evento 8. MetaTrader ha terminado de reflejar los cambios y procede a pasarle el control al EA.

Evento 9. El EA reanuda su funcionamiento y sigue operando.

Hay que tener en cuenta que todo esto pasa en milésimas de segundo y casi parece inmediato, pero en el fondo están pasando todas estas cosas.

Mas info en ingles http://book.mql4.com/trading/common

Arrays en MQL4

Los Arrays son un conjunto organizado de valores de un tipo de dato que tienen un nombre en común. Las matrices pueden ser una solo dimensión o multidimensionales.  La cantidad máxima de dimensiones de una matriz es de cuatro. Las matrices pueden ser de cualquier tipo de dato, pero solo pueden ser de un tipo de dato. Si el Array es de números, esta matriz no puede tener variables que no sean números.
La forma en que MQL4 maneja las Arrays es muy parecida a los demás lenguajes de programación, sin embargo MQL4 tiene unas particularidades.
Antes de poder utilizar un Array esta tiene que ser declarada. Las GlobalsVariables no pueden ser Arrays.
Una declaracion tipica de un array puede ser:

int miArray[10];

Con el int estamos indicando que todos los valores que contendrá esta array serán de tipo int o enteros. Ahora viene lo diferente que tiene MQL4.  En otros lenguajes cuando decimos [10]; estamos haciendo referencia al indice 10 en el array. Pero en MQL4 lo que decimos es que nuestra array va tener un espacio para 10 elementos.  Esto es cuando se inicializa el array. Ejemplos:

bool Mas_b [ 5 ] = { false , true , false , true , true };
string Mas_s[4] = {“a”,”b”, ,”d”};
int Mas_i[6] = { 0,1,2, ,4,5 };

Para explicar mas ampliamente los array voy a copiar la explicación que hace X-Trader de x-trader.net

/////////////////////////////////////////////////

Vectores (Arrays)
Pasamos a ver cómo se declaran vectores en MQL. El esquema para ello es el siguiente:

(Tipo de array) (Nombre del array) [Nº de elementos];

Por ejemplo, la sentencia:

double price[5];

nos creará un vector de 5 elementos de tipo Double.

¿Cómo podemos hacer referencia a cada uno de los componentes del array y darles un valor? Muy fácil: una vez hemos declarado el array “price” del ejemplo anterior, podemos dar un valor a su primer elemento de la siguiente forma:

price[0] = 1.2341;

Obsérvese que los índices de los arrays empiezan en 0, de tal forma que dicho valor se corresponde con el primer elemento del array. Del mismo price[1] = 1.2321; nos asignaría un valor al segundo elemento del array y así sucesivamente.

Por supuesto, podemos declarar un array asignándole valores iniciales:

double price[2] = {1.2234, 1.2421};

Aunque también es posible no especificar el número de elementos y dejar que Metatrader lo determine:

double price[] = {1.2234, 1.2421};

Asimismo, con los arrays también podemos realizar las mismas operaciones que hacíamos con las variables como se muestra en los siguientes ejemplos:

double price[2];
price[0] = 1.2234;  
price[1] = 1.2421;    
MessageBox(“El precio medios es ” + (price[0] + price[1]) / 2.0,”Precio medio”);

/////////////////////////////////////////////////

También voy a copiar algo muy interesante que encontré en init.tler.com.ar.

/////////////////////////////////////////////////

#define
La directiva de precompilador #define sirve para “definir” (valga la redundancia) constantes.

“Ohhh! And so?” Es cierto, si esa fuera la definición final seria aburrido inclusive el uso de esta directiva y ni me gasto en aprenderla… total, tengo variables que no modifico y listo…

Esto es particularmente util en el siguiente caso:

int length = 10;
string array[length]; // ESTO ES TOTALMENTE INVALIDO!
string array2[10]; //Valido pero poco practico.

Nosotros queremos definir un array. Es muy común esto. Luego lo recorreremos y tendremos que buscar de 0 a length -1. Si nosotros usamos el valor 10 en todo nuestro codigo para designar la longitud de nuestro array y luego necesitamos redimensionarlo (por un motivo que ahora no viene al caso), tendriamos que modificar todo nuestro codigo.

En cambio, si definimos una constante para crear el array y usamos su valor para recorrerlo solo bastará modificar la definición de la constante en caso de ser necesario.

Por otro lado, podemos insistir con la idea de que podemos usar una variable a la cual le asignamos el tamaño y listo. Pues no.

Cuando el compilador lee algo como lo siguiente:

#define LENGTH 10
int vector[LENGTH];
…

for (int i = 0; i < LENGTH; i++) {…}

…

Lo que hace es reemplazar el valor de LENGTH en cada aparicion de LENGTH. Por lo que el codigo quedaria de la siguiente manera:

/*#define LENGTH 10 */

int vector[10];

…
for (int i = 0; i < 10; i++) {…}
…

Por supuesto esto nunca lo veremos, pero nos da un codigo fuente mucho mas legible, prolijo y además nuestro programa será mas optimo ya que tendremos menos acceso a variables, menor consumo de memoria y un script mucho mas rapido.

Cuando definimos constantes, podemos definir cualquier valor constante que querramos incluyendo strings, boleanos, etc.

Estructura del switch en MQL4

La estructura del switch es la siguiente.

switch(numeroCualquiera)
{
     case 1:
          Alert(”El numero es 1″);
          break;
     case 2:
          Alert(“El numero es 2″);
          break;
     case 3:
          Alert(“El numero es 3″);
          break;
     default:
          Alert(“No hay numero”);
}

break y continue MQL4

Al igual que los otros lenguajes de programación, MQL4 también cuenta con las sentencias break y continue. break corta el bucle, y continue hace que se salte la iteracion actual del bucle.
   break;
   continue;


Esctructura bucle for en MQL4

bucle for. Es lo mismo que en los demás lenguajes. 
for(i=Nom_1; i<=Nom_2; i++)   
{                                 
      Sum=Sum + i;                      
      Alert("i=",i,"  Sum=",Sum);     
} 


Condicionales en MQL4

Acá no voy a explicar en detalle como funcionan los condicionales. Solo voy a colocar las cosas que me llamado la atención en MQL4.
Uno puede utilizar condicionales con llavez { } cuando hay varias operaciones y sin llaves { } cuando solo es una operació. Ejem.
If (condición)
{
     Operacion1;
     Operacion2;
}
O también
If (condición)
     Operacion1;


Estructura de una funcion

Funciones especiales, estándar y definidas por el usuario

En MQL4 hay 3 tipos de funciones.

Especiales

Son las
3 funciones principales de MQL4, que ya hemos explicado. init(); start(); y deinit

Estándar

Son
funciones incorporadas en MQL4 como Alert(); para mostrar un alerta,
MathSqrt(); para calcular la hipotenusa y así muchas mas.

Definidas por el usuario

Son las
funciones normales que programamos nosotros.

Operadores en MQL4

Operaciones de la asignación

Los símbolos siguientes pertenecen a los símbolos de las operaciones de asignación:

Símbolo	Operación	Ejemplo	Análogo
=	Asignación del valor x a la y variable	у = x
+=	Aumento de la y variable por x	у += x	y = y + x
- =	Reducción de la y variable por x	y – = x	y = y – x
*=	Multiplicación de la y variable por x	*= x de y	y = y * x
/=	División de la y variable por x	y/= x	y = y/x
%=	Residuo de división de la y variable por x	y %= x	y = % de y x

Operaciones de comparación

Los siguientes símbolos sirven para hacer condicionales en los if

Símbolo	Operación	Ejemplo
==	Verdad, si x es igual a y	x == y
¡! =	Verdad, si x no es igual a y	¡x! = y
<	Verdad, si x es menos que y	x < y
>	Verdad, si x es más que y	x > y
<=	Verdad, si x es igual o menos que a y	x <= y
>=	Verdad, si x es igual o más que a y	x >= y

Operaciones (lógicas) boleanas

Los símbolos siguientes pertenecen a los símbolos de las operaciones boleanas:

Símbolo	Operación	Ejemplo	Explicaciones
¡!	NO (negación lógica)	¡! х	VERDAD (1), si el valor del operando es FALSO (0); FALSO (0), si el valor del operando no es FALSO (0).
||	O (separación lógica)	x < 5 || x > 7	VERDAD (1), si algún valor de los valores es verdad
&&	Y (conjunción lógica)	x && del == 3 y < 5	VERDAD (1), si todos los valores son verdades

Orden de las operaciones matematicas en MQL4

Las operaciones se realizan de izquierda a derecha. Ejemplos
Y = 2.0*( 3*X/Z - N) + D;
La expresión anterior tiene dos partes
2.0* (3*X/Z - N) y D
A su vez
2.0* (3*X/Z - N)
tiene dos partes,
2 y (3*X/Z - N)
La expresión entre paréntesis,
3*X / Z - N
consiste en dos operaciones,
3*X/Z
que consiste en tres factores, a saber:
3, X y Z.
Para calcular la expresión, primero calculamos el valor de la expresión
3*X/Z
Esta expresión contiene dos operaciones (multiplicación y división),  así que calcularemos esta expresión de izquierda a derecha. Primero, calcularemos el valor de la expresión
3*X
Entonces calcularemos el valor de la expresión
3*X/Z
Después de eso, el programa calculará el valor de la expresión
3*X/Z - N
y luego de la expresión
2.0* (3*X/Z - N)
y por último la expresión entera
2.0* (3*X/Z - N) + D.

Veamos otro ejemplo para aclarar mejor la cómo funciona el orden de las operaciones.  

Ejemplo:
Calculemos la expresión
А/В*С y А*С/В
para los números enteros А, В, y С.

El resultado del cálculo se espera que intuitivamente sea el mismo en ambos casos. Sin embargo, esta afirmación es cierta sólo para números reales. Pero si hacemos estas mismas operaciones con números enteros o int, debemos considerar un resultado intermedio. En tal caso, el orden de las operaciones es de vital importancia.
int A = 3; // Tipo de dato entero o int
int B = 5; // Tipo de dato entero o int
int C = 6; // Tipo de dato entero o int
int Res_1 = A/B*C; // Resultado 0
int Res_2 = A*C/B; // Resultado
Primero  vamos a calcular A/B*C.
1.  Primero se calcula (de izquierda a derecha) la expresión A/B.  Si A = 3 y B = 5 entonses A/B quedaría 3/5 = 0.
2. Luego calculamos la expresión 0*С (cero multiplicado por С). El resultado es el número entero 0 (cero).
Ahora sigamos y calculemos la expresión A*C/B.
1. Primero calculamos A*C. El valor de esta expresión es el número entero 18 (3*6=18).
2. Luego calculamos la expresión 18/B. La respuesta es obvia: después de que se haya desechado la parte fraccionaria, (18/5) = 3 (tres).