Máquina de estados finitos

Ago 20, 2022 | EasyLanguage

Máquina de estados finitos: Premisa

Un componente importante del algoritmo Turtle fue omitir la siguiente ruptura de 20 días si la anterior resultó ganadora. Supongo que Dennis creía que el éxito / fracaso de una operación tenía un impacto en el resultado de la operación posterior. He escrito sobre cómo puede implementar esto en EasyLanguage en publicaciones anteriores, pero he recibido algunas preguntas sobre la implementación de la máquina de estados finitos en el comercio y pensé que esta publicación podría matar dos pájaros de un tiro: 1) proporcionar una plantilla que se pueda adaptar a cualquier El mecanismo LTL y 2) proporcionan el código / estructura para configurar un FSM utilizando la estructura Switch / Case de EasyLanguage.

 

Lógica LTL específica para tortugas

La lógica de Turtle LTL establece que un intercambio es un perdedor si se produce una pérdida de 2N después de la entrada. N es básicamente una media móvil exponencial de TrueRange. Entonces, si el mercado se mueve 2N contra una posición larga o corta y lo detiene, tiene una operación perdedora. Lo que hace que el algoritmo Turtle sea un poco más difícil es que también puede salir en un nuevo mínimo / máximo de 10 días dependiendo de su posición. La salida final de 10 días no significa una pérdida. Bueno, al menos en esta publicación no es así. Tengo un código que dice que cualquier pérdida es una pérdida, pero para esta explicación, limítese a una pérdida de 2N para determinar la falla de una operación.

Cómo supervisar operaciones cuando se saltan algunas de ellas

Esta es otra capa adicional de complejidad. Tienes que hacer tu propia contabilidad comercial entre bastidores para determinar si se produce una operación perdedora. Porque si tiene una operación ganadora, omite la siguiente operación y si la omite, ¿cómo sabe si habría sido un ganador o un perdedor? Tiene que ejecutar un sistema teórico en paralelo con el código del sistema real.

Bien, comencemos asumiendo que la última operación fue ganadora. Así que desactivamos el comercio real. A medida que pasan las barras, buscamos una penetración alta o baja en 20 días . Suponga que se coloca un nuevo máximo de 20 días y se establece una posición larga en el máximo de 20 días anterior. En este punto, calcula una cantidad de 2N y resta si del precio de entrada teórico para obtener el precio de salida teórico. Entonces tiene un theoMP (marketPosition) y un theoEX (precio de salida). Esta tarea parece bastante simple, así que sigue adelante y comienza a buscar un día que ponga un nuevo mínimo de 10 días o cruce por debajo de su precio theoEX . Si un nuevoSe coloca el mínimo de 10 días y luego continúa buscando una nueva entrada y una pérdida posterior de 2N. Si se produce una pérdida de 2N, vuelve a activar las operaciones y continúa monitorizando las operaciones, desactivando y volviendo a activar las operaciones cuando sea necesario. En el siguiente código utilizo estas variables:

  • estado – 0: buscando una entrada o 1: buscando una salida
  • lep – precio de entrada larga
  • sep – precio de entrada corta
  • seekLong – Estoy buscando una posición larga
  • seekShort: estoy buscando una posición corta
  • theoMP – posición teórica en el mercado
  • theoEX – precio de salida teórico
  • lxp – precio de salida largo
  • sxp – precio de salida corto

Saltemos a la estructura Switch / Case cuando state = 0:

	Switch(state)
	Begin
		Case 0:
			lep = highest(h[1],20) + minMove/priceScale;
			sep = lowest(l[1],20) - minMove/priceScale;
			If seekLong and h >= lep then 
			begin
				theoMP = 1;
				theoEX = maxList(lep,o) - 2 * atr; 
//				print(d," entered long >> exit at ",theoEX," ",atr);
			end;
			If seekShort and l <= sep then 
			begin
				theoMP = -1;
				theoEX = minList(sep,o) + 2 * atr;
			end;
			If theoMP <> 0 then 
			begin
				state = 1;
				cantExitToday = True;
			end;

Estado 0 (Finite State Set Up)

El Switch / Case es una estructura imprescindible en cualquier lenguaje de programación. Lo que realmente me sorprende es que Python no lo tiene. Afirman que es redundante para una estructura if-then y lo es, pero es mucho más fácil de leer e implementar. Básicamente, usa la instrucción Switch y un nombre de variable y, según el valor de la variable, fluirá a cualquier caso al que la variable sea igual. Aquí estamos viendo el estado 0. En la estructura CASE: 0 , la computadora calcula los valores lep y sep – niveles de entrada largos y cortos. Si está plano, entonces está buscando una posición larga o corta. Si el máximo o mínimo de la barra penetra en sus respectivos niveles de activación, entonces el oMP se establece en 1 durante mucho tiempo o -1para abreviar. Luego, TheoEX se calcula en función del valor atr el día de la entrada. Si theoMP se establece en 1 o -1, entonces sabemos que se acaba de activar una operación. La máquina de estados finitos luego cambia de marcha a estado 1 . Dado que State = 1, la siguiente declaración Case se evalúa inmediatamente. No quiero salir en la misma barra en la que entré (las barras anchas pueden entrar y salir durante tiempos volátiles). Utilizo una variable cantExitToday. Esta variable retrasa la evaluación del Caso 1: una barra.

Estado = 1 código:

	Case 1:
		If not(cantExitToday) then
		begin
			lxp = maxList(theoEX,lowest(l[1],10)-minMove/priceScale);
			sxp = minList(theoEX,highest(h[1],10)+minMove/priceScale);	
			If theoMP = 1 and l <= lxp then
			begin
				theoMP = 0;
				seekLong = False;
				if lxp <= theoEX then 
					ltl = True
				Else 
					ltl = False;
			end;
			If theoMP =-1 and h >= sxp then
			begin
				theoMP = 0;
				seekShort = False;
				if sxp >= theoEX then 
					ltl = True
				else 
					ltl = False;
			end;
			If theoMP = 0 then state = 0;
		end;
		cantExitToday = False;	
end;

Estado = 1 (Cambio de marchas)

Una vez que tenemos una posición teórica, solo examinamos el código en el módulo Caso 1: En la barra siguiente después de la entrada, se calculan lxp y sxp (precios de salida larga y salida corta). Tenga en cuenta que estos valores usan maxList o minList para determinar cuál está más cerca de la acción actual del mercado: el stop 2N o el mínimo / máximo mínimo / máximo de los últimos 10 días. Lxp y sxp se asignan lo que esté más cerca. El máximo o mínimo de cada barra se compara con estos valores. Si theoMP = 1 entonces el bajo se compara con lxp. Si la baja cruza por debajo de lxp, entonces las cosas se ponen en movimiento. El theoMP se establece inmediatamente a 0 y seekLong se volvió a Falso. Si lxp <= una pérdida 2N, entonces ltl (perdedor de la última operación) se establece en verdadero. De lo contrario, ltl se establece en False. Si theoMP = 0, entonces asumimos una posición plana y cambiamos el FSM de nuevo al estado 0 y comenzamos a buscar una nueva operación. El ltl Luego, la variable se usa en el código para permitir que ocurra un intercambio real.

La estrategia incorpora nuestra máquina de estados finitos

 

vars:N(0),mp(0),NLossAmt(0);
If barNumber = 1 then n = avgTrueRange(20);
if barNumber > 1 then n = (n*19 + trueRange)/20;

If useLTLFilter then
Begin
	if ltl then buy next bar at highest(h,20) + minMove/priceScale stop;
	if ltl then sellShort next bar at lowest(l,20) -minMove/priceScale stop;
end
Else
Begin
	buy next bar at highest(h,20) + minMove/priceScale stop;
	sellShort next bar at lowest(l,20) -minMove/priceScale stop;
end;

mp = marketPosition;

If mp <> 0 and mp[1] <> mp then NLossAmt = 2 * n;

If mp = 1 then
Begin
	Sell("LL10-LX") next bar at lowest(l,10) - minMove/priceScale stop;
	Sell("2NLS-LX") next bar at entryPrice - NLossAmt stop;
end;
If mp =-1 then
Begin
	buyToCover("HH10-SX") next bar at highest(h,10) + minMove/priceScale stop;
	buyToCover("2NLS-SX") next bar at entryPrice + NLossAmt stop;
end;

Código de estrategia con filtro LTL

Este código básicamente replica lo que hicimos en la máquina de estados finitos, pero coloca órdenes reales basadas en el hecho de que la última operación fue un perdedor (LTL).

¿Funciona la máquina de estados finitos? Sólo opere después de una pérdida de 2N

LTLExample 1
NOLTLCrude

Sin filtro en los últimos 10 años en crudo

LTLCrude

Máquina de estados finitos con filtro en los últimos 10 años en crudo

He programado esto en mi software TradingSimula-18.

Tuve que hacer un poco de juego con algunos códigos debido al hecho de que se puede salir y volver a entrar en la misma barra. En el próximo post de este blog os contaré esas maquinaciones. Con esta plantilla, debería poder recrear cualquier última operación que fue un mecanismo perdedor y ver si puede ayudarlo con sus propios algoritmos de negociación.

Esperamos este artículo le haya servido para programar sus estrategias con la máquina de estados finitos de George Pruitt.

Este artículo fue cedido por George Pruitt

Canal de YouTube de Quantified Models

En nuestro canal de YouTube tenemos varios videos disponibles que pueden resultarle muy útiles para desarrollar sistemas de trading.

Esperamos que esta información te haya sido de utilidad.

Subscribe to our Newsletter

Join our mailing list to receive the latest news and updates from Quantified Models team.

Subscribe to our Newsletter

You have Successfully Subscribed!

Ir al contenido