--- title: "Máquina de estados finitos" description: "George Pruitt ha programado esta máquina de estados finitos en EasyLanguage, con su software TradingSimula-18, usando el algoritmo Turtle." url: https://www.quantifiedmodels.com/es/maquina-de-estados-finitos/ date: 2022-08-20 modified: 2023-05-05 author: "Quantified Models" image: https://www.quantifiedmodels.com/wp-content/uploads/2022/08/BLOG-WEB-Quantified-Models.png categories: ["EasyLanguage"] tags: ["algoritmo", "código", "estrategia", "filtro", "FSM", "George Pruitt", "LTL", "mecanismo", "mercado", "monitor", "operación", "plantilla", "portfolio", "programación", "Tortuga", "trading"] type: post lang: es --- # Máquina de estados finitos ## 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: ```cpp 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 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](https://www.quantifiedmodels.com/wp-content/uploads/2022/08/LTLExample-1.webp)](https://www.quantifiedmodels.com/wp-content/uploads/2022/08/LTLExample-1.webp) [![NOLTLCrude](https://www.quantifiedmodels.com/wp-content/uploads/2022/08/NOLTLCrude.webp)](https://www.quantifiedmodels.com/wp-content/uploads/2022/08/NOLTLCrude.webp) Sin filtro en los últimos 10 años en crudo [![LTLCrude](https://www.quantifiedmodels.com/wp-content/uploads/2022/08/LTLCrude.webp)](https://www.quantifiedmodels.com/wp-content/uploads/2022/08/LTLCrude.webp) 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. [Mira nuestros videos](https://www.youtube.com/channel/UC1aM_BnnBAWRSjiApHVGD5w)